sbt

Scoped

object Scoped extends AnyRef

Methods and types related to constructing settings, including keys, scopes, and initializations.

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Hide All
  2. Show all
  1. Scoped
  2. AnyRef
  3. Any
Visibility
  1. Public
  2. All

Type Members

  1. type AnyInitTask = sbt.Project.Initialize[sbt.Task[T]] forSome { type T }

  2. final class Apply10[A, B, C, D, E, F, G, H, I, J] extends AnyRef

  3. final class Apply11[A, B, C, D, E, F, G, H, I, J, K] extends AnyRef

  4. final class Apply12[A, B, C, D, E, F, G, H, I, J, K, L] extends AnyRef

  5. final class Apply13[A, B, C, D, E, F, G, H, I, J, K, L, N] extends AnyRef

  6. final class Apply14[A, B, C, D, E, F, G, H, I, J, K, L, N, O] extends AnyRef

  7. final class Apply15[A, B, C, D, E, F, G, H, I, J, K, L, N, O, P] extends AnyRef

  8. final class Apply2[A, B] extends AnyRef

  9. final class Apply3[A, B, C] extends AnyRef

  10. final class Apply4[A, B, C, D] extends AnyRef

  11. final class Apply5[A, B, C, D, E] extends AnyRef

  12. final class Apply6[A, B, C, D, E, F] extends AnyRef

  13. final class Apply7[A, B, C, D, E, F, G] extends AnyRef

  14. final class Apply8[A, B, C, D, E, F, G, H] extends AnyRef

  15. final class Apply9[A, B, C, D, E, F, G, H, I] extends AnyRef

  16. trait Combine[D[_]] extends AnyRef

  17. sealed trait DefinableSetting[S] extends AnyRef

  18. sealed trait DefinableTask[S] extends AnyRef

  19. sealed trait ListSetting[S, M[_]] extends AnyRef

  20. type RedHL[HL <: HList] = sbt.Scoped.Reduced[_, _, HL]

  21. trait Reduced[HLs <: HList, HLt <: HList, HLv <: HList] extends AnyRef

  22. final class RichAnyTaskSeq extends AnyRef

  23. sealed abstract class RichFileBase extends AnyRef

  24. final class RichFileSetting extends RichFileBase

  25. final class RichFilesSetting extends RichFileBase

  26. sealed abstract class RichInitTaskBase[S, R[_]] extends AnyRef

  27. final class RichInitialize[S] extends AnyRef

  28. final class RichInitializeInputTask[S] extends RichInitTaskBase[S, InputTask]

  29. final class RichInitializeTask[S] extends RichInitTaskBase[S, Task]

  30. final class RichTaskSeq[T] extends AnyRef

  31. final class RichTaskable10[A, B, C, D, E, F, G, H, I, J] extends RichTaskables[:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, HNil]]]]]]]]]]]

  32. final class RichTaskable11[A, B, C, D, E, F, G, H, I, J, K] extends RichTaskables[:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, HNil]]]]]]]]]]]]

  33. final class RichTaskable12[A, B, C, D, E, F, G, H, I, J, K, L] extends RichTaskables[:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, :+:[L, HNil]]]]]]]]]]]]]

  34. final class RichTaskable13[A, B, C, D, E, F, G, H, I, J, K, L, N] extends RichTaskables[:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, :+:[L, :+:[N, HNil]]]]]]]]]]]]]]

  35. final class RichTaskable14[A, B, C, D, E, F, G, H, I, J, K, L, N, O] extends RichTaskables[:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, :+:[L, :+:[N, :+:[O, HNil]]]]]]]]]]]]]]]

  36. final class RichTaskable15[A, B, C, D, E, F, G, H, I, J, K, L, N, O, P] extends RichTaskables[:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, :+:[L, :+:[N, :+:[O, :+:[P, HNil]]]]]]]]]]]]]]]]

  37. final class RichTaskable2[A, B] extends RichTaskables[:+:[A, :+:[B, HNil]]]

  38. final class RichTaskable3[A, B, C] extends RichTaskables[:+:[A, :+:[B, :+:[C, HNil]]]]

  39. final class RichTaskable4[A, B, C, D] extends RichTaskables[:+:[A, :+:[B, :+:[C, :+:[D, HNil]]]]]

  40. final class RichTaskable5[A, B, C, D, E] extends RichTaskables[:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, HNil]]]]]]

  41. final class RichTaskable6[A, B, C, D, E, F] extends RichTaskables[:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, HNil]]]]]]]

  42. final class RichTaskable7[A, B, C, D, E, F, G] extends RichTaskables[:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, HNil]]]]]]]]

  43. final class RichTaskable8[A, B, C, D, E, F, G, H] extends RichTaskables[:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, HNil]]]]]]]]]

  44. final class RichTaskable9[A, B, C, D, E, F, G, H, I] extends RichTaskables[:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, HNil]]]]]]]]]]

  45. final class RichTaskableKeys[In <: HList] extends AnyRef

  46. sealed abstract class RichTaskables[In <: HList] extends AnyRef

  47. sealed trait ScopingSetting[Result] extends AnyRef

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any

  3. final def ##(): Int

    Definition Classes
    AnyRef → Any

  4. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  5. final def ==(arg0: Any): Boolean

    Definition Classes
    Any

  6. object Combine extends AnyRef

  7. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  8. def clone(): AnyRef

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()

  9. def emptyReduced: Reduced[HNil, HNil, HNil]

  10. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  11. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  12. def finalize(): Unit

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()

  13. final def getClass(): java.lang.Class[_]

    Definition Classes
    AnyRef → Any

  14. def hashCode(): Int

    Definition Classes
    AnyRef → Any

  15. def hf10[A, B, C, D, E, F, G, H, I, J, T](z: (A, B, C, D, E, F, G, H, I, J) ⇒ T): (:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, HNil]]]]]]]]]]) ⇒ T

  16. def hf11[A, B, C, D, E, F, G, H, I, J, K, T](z: (A, B, C, D, E, F, G, H, I, J, K) ⇒ T): (:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, HNil]]]]]]]]]]]) ⇒ T

  17. def hf12[A, B, C, D, E, F, G, H, I, J, K, L, T](z: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ T): (:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, :+:[L, HNil]]]]]]]]]]]]) ⇒ T

  18. def hf13[A, B, C, D, E, F, G, H, I, J, K, L, N, T](z: (A, B, C, D, E, F, G, H, I, J, K, L, N) ⇒ T): (:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, :+:[L, :+:[N, HNil]]]]]]]]]]]]]) ⇒ T

  19. def hf14[A, B, C, D, E, F, G, H, I, J, K, L, N, O, T](z: (A, B, C, D, E, F, G, H, I, J, K, L, N, O) ⇒ T): (:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, :+:[L, :+:[N, :+:[O, HNil]]]]]]]]]]]]]]) ⇒ T

  20. def hf15[A, B, C, D, E, F, G, H, I, J, K, L, N, O, P, T](z: (A, B, C, D, E, F, G, H, I, J, K, L, N, O, P) ⇒ T): (:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, :+:[L, :+:[N, :+:[O, :+:[P, HNil]]]]]]]]]]]]]]]) ⇒ T

  21. def hf2[A, B, T](z: (A, B) ⇒ T): (:+:[A, :+:[B, HNil]]) ⇒ T

  22. def hf3[A, B, C, T](z: (A, B, C) ⇒ T): (:+:[A, :+:[B, :+:[C, HNil]]]) ⇒ T

  23. def hf4[A, B, C, D, T](z: (A, B, C, D) ⇒ T): (:+:[A, :+:[B, :+:[C, :+:[D, HNil]]]]) ⇒ T

  24. def hf5[A, B, C, D, E, T](z: (A, B, C, D, E) ⇒ T): (:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, HNil]]]]]) ⇒ T

  25. def hf6[A, B, C, D, E, F, T](z: (A, B, C, D, E, F) ⇒ T): (:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, HNil]]]]]]) ⇒ T

  26. def hf7[A, B, C, D, E, F, G, T](z: (A, B, C, D, E, F, G) ⇒ T): (:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, HNil]]]]]]]) ⇒ T

  27. def hf8[A, B, C, D, E, F, G, H, T](z: (A, B, C, D, E, F, G, H) ⇒ T): (:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, HNil]]]]]]]]) ⇒ T

  28. def hf9[A, B, C, D, E, F, G, H, I, T](z: (A, B, C, D, E, F, G, H, I) ⇒ T): (:+:[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, HNil]]]]]]]]]) ⇒ T

  29. implicit def inputScopedToKey[T](s: InputKey[T]): ScopedKey[InputTask[T]]

  30. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  31. def k10[M[_], A, B, C, D, E, F, G, H, I, J](t10: (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J])): KCons[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, HNil]]]]]]]]], [X]M[X]]

  32. def k11[M[_], A, B, C, D, E, F, G, H, I, J, K](t11: (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K])): KCons[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, HNil]]]]]]]]]], [X]M[X]]

  33. def k12[M[_], A, B, C, D, E, F, G, H, I, J, K, L](t12: (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K], M[L])): KCons[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, :+:[L, HNil]]]]]]]]]]], [X]M[X]]

  34. def k13[M[_], A, B, C, D, E, F, G, H, I, J, K, L, N](t13: (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K], M[L], M[N])): KCons[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, :+:[L, :+:[N, HNil]]]]]]]]]]]], [X]M[X]]

  35. def k14[M[_], A, B, C, D, E, F, G, H, I, J, K, L, N, O](t14: (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K], M[L], M[N], M[O])): KCons[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, :+:[L, :+:[N, :+:[O, HNil]]]]]]]]]]]]], [X]M[X]]

  36. def k15[M[_], A, B, C, D, E, F, G, H, I, J, K, L, N, O, P](t15: (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K], M[L], M[N], M[O], M[P])): KCons[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, :+:[J, :+:[K, :+:[L, :+:[N, :+:[O, :+:[P, HNil]]]]]]]]]]]]]], [X]M[X]]

  37. def k2[M[_], A, B](t2: (M[A], M[B])): KCons[A, :+:[B, HNil], [X]M[X]]

  38. def k3[M[_], A, B, C](t3: (M[A], M[B], M[C])): KCons[A, :+:[B, :+:[C, HNil]], [X]M[X]]

  39. def k4[M[_], A, B, C, D](t4: (M[A], M[B], M[C], M[D])): KCons[A, :+:[B, :+:[C, :+:[D, HNil]]], [X]M[X]]

  40. def k5[M[_], A, B, C, D, E](t5: (M[A], M[B], M[C], M[D], M[E])): KCons[A, :+:[B, :+:[C, :+:[D, :+:[E, HNil]]]], [X]M[X]]

  41. def k6[M[_], A, B, C, D, E, F](t6: (M[A], M[B], M[C], M[D], M[E], M[F])): KCons[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, HNil]]]]], [X]M[X]]

  42. def k7[M[_], A, B, C, D, E, F, G](t7: (M[A], M[B], M[C], M[D], M[E], M[F], M[G])): KCons[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, HNil]]]]]], [X]M[X]]

  43. def k8[M[_], A, B, C, D, E, F, G, H](t8: (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H])): KCons[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, HNil]]]]]]], [X]M[X]]

  44. def k9[M[_], A, B, C, D, E, F, G, H, I](t9: (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I])): KCons[A, :+:[B, :+:[C, :+:[D, :+:[E, :+:[F, :+:[G, :+:[H, :+:[I, HNil]]]]]]]], [X]M[X]]

  45. def mkTuple10[A, B, C, D, E, F, G, H, I, J]: (A, B, C, D, E, F, G, H, I, J) ⇒ (A, B, C, D, E, F, G, H, I, J)

  46. def mkTuple11[A, B, C, D, E, F, G, H, I, J, K]: (A, B, C, D, E, F, G, H, I, J, K) ⇒ (A, B, C, D, E, F, G, H, I, J, K)

  47. def mkTuple12[A, B, C, D, E, F, G, H, I, J, K, L]: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L)

  48. def mkTuple13[A, B, C, D, E, F, G, H, I, J, K, L, N]: (A, B, C, D, E, F, G, H, I, J, K, L, N) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, N)

  49. def mkTuple14[A, B, C, D, E, F, G, H, I, J, K, L, N, O]: (A, B, C, D, E, F, G, H, I, J, K, L, N, O) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, N, O)

  50. def mkTuple15[A, B, C, D, E, F, G, H, I, J, K, L, N, O, P]: (A, B, C, D, E, F, G, H, I, J, K, L, N, O, P) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, N, O, P)

  51. def mkTuple2[A, B]: (A, B) ⇒ (A, B)

  52. def mkTuple3[A, B, C]: (A, B, C) ⇒ (A, B, C)

  53. def mkTuple4[A, B, C, D]: (A, B, C, D) ⇒ (A, B, C, D)

  54. def mkTuple5[A, B, C, D, E]: (A, B, C, D, E) ⇒ (A, B, C, D, E)

  55. def mkTuple6[A, B, C, D, E, F]: (A, B, C, D, E, F) ⇒ (A, B, C, D, E, F)

  56. def mkTuple7[A, B, C, D, E, F, G]: (A, B, C, D, E, F, G) ⇒ (A, B, C, D, E, F, G)

  57. def mkTuple8[A, B, C, D, E, F, G, H]: (A, B, C, D, E, F, G, H) ⇒ (A, B, C, D, E, F, G, H)

  58. def mkTuple9[A, B, C, D, E, F, G, H, I]: (A, B, C, D, E, F, G, H, I) ⇒ (A, B, C, D, E, F, G, H, I)

  59. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  60. final def notify(): Unit

    Definition Classes
    AnyRef

  61. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  62. def reduced[HL <: HList](settings: KList[ScopedTaskable, HL]): sbt.Scoped.Reduced[_, _, HL]

  63. implicit def richAnyTaskSeq(in: Seq[AnyInitTask]): RichAnyTaskSeq

  64. implicit def richFileSetting(s: SettingKey[File]): RichFileSetting

  65. implicit def richFilesSetting(s: SettingKey[Seq[File]]): RichFilesSetting

  66. implicit def richTaskSeq[T](in: Seq[Initialize[Task[T]]]): RichTaskSeq[T]

  67. implicit def richTaskableKeys[HL <: HList](in: KList[ScopedTaskable, HL]): RichTaskableKeys[HL]

  68. def scopedInput[T](s: Scope, k: AttributeKey[InputTask[T]]): InputKey[T]

  69. def scopedSetting[T](s: Scope, k: AttributeKey[T]): SettingKey[T]

  70. def scopedTask[T](s: Scope, k: AttributeKey[Task[T]]): TaskKey[T]

  71. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef

  72. implicit def t10ToApp10[A, B, C, D, E, F, G, H, I, J](t10: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J])): Apply10[A, B, C, D, E, F, G, H, I, J]

  73. implicit def t10ToTable10[A, B, C, D, E, F, G, H, I, J](t10: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J])): RichTaskable10[A, B, C, D, E, F, G, H, I, J]

  74. implicit def t11ToApp11[A, B, C, D, E, F, G, H, I, J, K](t11: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K])): Apply11[A, B, C, D, E, F, G, H, I, J, K]

  75. implicit def t11ToTable11[A, B, C, D, E, F, G, H, I, J, K](t11: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K])): RichTaskable11[A, B, C, D, E, F, G, H, I, J, K]

  76. implicit def t12ToApp12[A, B, C, D, E, F, G, H, I, J, K, L](t12: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K], Initialize[L])): Apply12[A, B, C, D, E, F, G, H, I, J, K, L]

  77. implicit def t12ToTable12[A, B, C, D, E, F, G, H, I, J, K, L](t12: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K], ScopedTaskable[L])): RichTaskable12[A, B, C, D, E, F, G, H, I, J, K, L]

  78. implicit def t13ToApp13[A, B, C, D, E, F, G, H, I, J, K, L, N](t13: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K], Initialize[L], Initialize[N])): Apply13[A, B, C, D, E, F, G, H, I, J, K, L, N]

  79. implicit def t13ToTable13[A, B, C, D, E, F, G, H, I, J, K, L, N](t13: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K], ScopedTaskable[L], ScopedTaskable[N])): RichTaskable13[A, B, C, D, E, F, G, H, I, J, K, L, N]

  80. implicit def t14ToApp14[A, B, C, D, E, F, G, H, I, J, K, L, N, O](t14: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K], Initialize[L], Initialize[N], Initialize[O])): Apply14[A, B, C, D, E, F, G, H, I, J, K, L, N, O]

  81. implicit def t14ToTable14[A, B, C, D, E, F, G, H, I, J, K, L, N, O](t14: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K], ScopedTaskable[L], ScopedTaskable[N], ScopedTaskable[O])): RichTaskable14[A, B, C, D, E, F, G, H, I, J, K, L, N, O]

  82. implicit def t15ToApp15[A, B, C, D, E, F, G, H, I, J, K, L, N, O, P](t15: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K], Initialize[L], Initialize[N], Initialize[O], Initialize[P])): Apply15[A, B, C, D, E, F, G, H, I, J, K, L, N, O, P]

  83. implicit def t15ToTable15[A, B, C, D, E, F, G, H, I, J, K, L, N, O, P](t15: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K], ScopedTaskable[L], ScopedTaskable[N], ScopedTaskable[O], ScopedTaskable[P])): RichTaskable15[A, B, C, D, E, F, G, H, I, J, K, L, N, O, P]

  84. implicit def t2ToApp2[A, B](t2: (Initialize[A], Initialize[B])): Apply2[A, B]

  85. implicit def t2ToTable2[A, B](t2: (ScopedTaskable[A], ScopedTaskable[B])): RichTaskable2[A, B]

  86. implicit def t3ToApp3[A, B, C](t3: (Initialize[A], Initialize[B], Initialize[C])): Apply3[A, B, C]

  87. implicit def t3ToTable3[A, B, C](t3: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C])): RichTaskable3[A, B, C]

  88. implicit def t4ToApp4[A, B, C, D](t4: (Initialize[A], Initialize[B], Initialize[C], Initialize[D])): Apply4[A, B, C, D]

  89. implicit def t4ToTable4[A, B, C, D](t4: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D])): RichTaskable4[A, B, C, D]

  90. implicit def t5ToApp5[A, B, C, D, E](t5: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E])): Apply5[A, B, C, D, E]

  91. implicit def t5ToTable5[A, B, C, D, E](t5: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E])): RichTaskable5[A, B, C, D, E]

  92. implicit def t6ToApp6[A, B, C, D, E, F](t6: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F])): Apply6[A, B, C, D, E, F]

  93. implicit def t6ToTable6[A, B, C, D, E, F](t6: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F])): RichTaskable6[A, B, C, D, E, F]

  94. implicit def t7ToApp7[A, B, C, D, E, F, G](t7: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G])): Apply7[A, B, C, D, E, F, G]

  95. implicit def t7ToTable7[A, B, C, D, E, F, G](t7: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G])): RichTaskable7[A, B, C, D, E, F, G]

  96. implicit def t8ToApp8[A, B, C, D, E, F, G, H](t8: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H])): Apply8[A, B, C, D, E, F, G, H]

  97. implicit def t8ToTable8[A, B, C, D, E, F, G, H](t8: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H])): RichTaskable8[A, B, C, D, E, F, G, H]

  98. implicit def t9ToApp9[A, B, C, D, E, F, G, H, I](t9: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I])): Apply9[A, B, C, D, E, F, G, H, I]

  99. implicit def t9ToTable9[A, B, C, D, E, F, G, H, I](t9: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I])): RichTaskable9[A, B, C, D, E, F, G, H, I]

  100. implicit def taskScopedToKey[T](s: TaskKey[T]): ScopedKey[Task[T]]

  101. def toString(): String

    Definition Classes
    AnyRef → Any

  102. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()

  103. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()

  104. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()

Inherited from AnyRef

Inherited from Any