trait TwiddleCompat extends AnyRef
Mix-in trait that provides source compatibility between Scala 2 tuples and Twiddles.
- Source
- TwiddleCompat.scala
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- TwiddleCompat
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
val
*:: ::.type
- Annotations
- @inline()
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
val
EmptyTuple: EmptyTuple
- Annotations
- @inline()
-
val
Tuple: HList.type
- Annotations
- @inline()
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hlistToTuple[L <: Tuple, T](l: L)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[L, T]): T
- implicit def hlistToTuple0[Z <: Tuple](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, Unit]): Unit
- implicit def hlistToTuple1[Z <: Tuple, A](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A)]): (A)
- implicit def hlistToTuple10[Z <: Tuple, A, B, C, D, E, F, G, H, I, J](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J)]): (A, B, C, D, E, F, G, H, I, J)
- implicit def hlistToTuple11[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K)]): (A, B, C, D, E, F, G, H, I, J, K)
- implicit def hlistToTuple12[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L)]): (A, B, C, D, E, F, G, H, I, J, K, L)
- implicit def hlistToTuple13[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M)]): (A, B, C, D, E, F, G, H, I, J, K, L, M)
- implicit def hlistToTuple14[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
- implicit def hlistToTuple15[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
- implicit def hlistToTuple16[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
- implicit def hlistToTuple17[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
- implicit def hlistToTuple18[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
- implicit def hlistToTuple19[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
- implicit def hlistToTuple2[Z <: Tuple, A, B](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B)]): (A, B)
- implicit def hlistToTuple20[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
- implicit def hlistToTuple21[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
- implicit def hlistToTuple22[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
- implicit def hlistToTuple3[Z <: Tuple, A, B, C](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C)]): (A, B, C)
- implicit def hlistToTuple4[Z <: Tuple, A, B, C, D](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D)]): (A, B, C, D)
- implicit def hlistToTuple5[Z <: Tuple, A, B, C, D, E](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E)]): (A, B, C, D, E)
- implicit def hlistToTuple6[Z <: Tuple, A, B, C, D, E, F](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F)]): (A, B, C, D, E, F)
- implicit def hlistToTuple7[Z <: Tuple, A, B, C, D, E, F, G](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G)]): (A, B, C, D, E, F, G)
- implicit def hlistToTuple8[Z <: Tuple, A, B, C, D, E, F, G, H](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H)]): (A, B, C, D, E, F, G, H)
- implicit def hlistToTuple9[Z <: Tuple, A, B, C, D, E, F, G, H, I](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I)]): (A, B, C, D, E, F, G, H, I)
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
- implicit def toTupleOps[T <: Tuple](t: T): TupleOps[T]
- implicit def tuple10ToHList[A, B, C, D, E, F, G, H, I, J](t: (A, B, C, D, E, F, G, H, I, J)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, EmptyTuple]]]]]]]]]]
- implicit def tuple11ToHList[A, B, C, D, E, F, G, H, I, J, K](t: (A, B, C, D, E, F, G, H, I, J, K)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, EmptyTuple]]]]]]]]]]]
- implicit def tuple12ToHList[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)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, EmptyTuple]]]]]]]]]]]]
- implicit def tuple13ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M](t: (A, B, C, D, E, F, G, H, I, J, K, L, M)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, EmptyTuple]]]]]]]]]]]]]
- implicit def tuple14ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, EmptyTuple]]]]]]]]]]]]]]
- implicit def tuple15ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, EmptyTuple]]]]]]]]]]]]]]]
- implicit def tuple16ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, EmptyTuple]]]]]]]]]]]]]]]]
- implicit def tuple17ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, *:[Q, EmptyTuple]]]]]]]]]]]]]]]]]
- implicit def tuple18ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, *:[Q, *:[R, EmptyTuple]]]]]]]]]]]]]]]]]]
- implicit def tuple19ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, *:[Q, *:[R, *:[S, EmptyTuple]]]]]]]]]]]]]]]]]]]
- implicit def tuple20ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, *:[Q, *:[R, *:[S, *:[T, EmptyTuple]]]]]]]]]]]]]]]]]]]]
- implicit def tuple21ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, *:[Q, *:[R, *:[S, *:[T, *:[U, EmptyTuple]]]]]]]]]]]]]]]]]]]]]
- implicit def tuple22ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, *:[J, *:[K, *:[L, *:[M, *:[N, *:[O, *:[P, *:[Q, *:[R, *:[S, *:[T, *:[U, *:[V, EmptyTuple]]]]]]]]]]]]]]]]]]]]]]
- implicit def tuple2ToHList[A, B](t: (A, B)): *:[A, *:[B, EmptyTuple]]
- implicit def tuple3ToHList[A, B, C](t: (A, B, C)): *:[A, *:[B, *:[C, EmptyTuple]]]
- implicit def tuple4ToHList[A, B, C, D](t: (A, B, C, D)): *:[A, *:[B, *:[C, *:[D, EmptyTuple]]]]
- implicit def tuple5ToHList[A, B, C, D, E](t: (A, B, C, D, E)): *:[A, *:[B, *:[C, *:[D, *:[E, EmptyTuple]]]]]
- implicit def tuple6ToHList[A, B, C, D, E, F](t: (A, B, C, D, E, F)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, EmptyTuple]]]]]]
- implicit def tuple7ToHList[A, B, C, D, E, F, G](t: (A, B, C, D, E, F, G)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, EmptyTuple]]]]]]]
- implicit def tuple8ToHList[A, B, C, D, E, F, G, H](t: (A, B, C, D, E, F, G, H)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, EmptyTuple]]]]]]]]
- implicit def tuple9ToHList[A, B, C, D, E, F, G, H, I](t: (A, B, C, D, E, F, G, H, I)): *:[A, *:[B, *:[C, *:[D, *:[E, *:[F, *:[G, *:[H, *:[I, EmptyTuple]]]]]]]]]
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()