Кортеж Tuple.Tuple

объект Tuple

Типы

Исходник

тип Append[X <: Tuple, Y] = X match { case EmptyTuple => Y *: EmptyTuple case x *: xs => x *: Append[xs, Y] }

Тип кортежа с добавленным элементом

Исходник

тип Concat[X <: Tuple, +Y <: Tuple] = X match { case EmptyTuple => Y case x1 *: xs1 => x1 *: Concat[xs1, Y] }

Тип конкатенации двух кортежей

Исходник

тип Drop[T <: Tuple, N <: Int] = N match { case 0 => T case S[n1] => T match { case EmptyTuple => EmptyTuple case x *: xs => Drop[xs, n1] } }

Преобразует кортеж (T1, ..., Tn) в (Ti+1, ..., Tn).

Исходник

тип Elem[X <: Tuple, N <: Int] = X match { case x *: xs => N match { case 0 => x case S[n1] => Elem[xs, n1] } }

Тип элемента в позиции N кортежа X

Исходник

тип Filter[Tup <: Tuple, P <: ([_] =>> Boolean)] = Tup match { case EmptyTuple => EmptyTuple case h *: t => P[h] match { case true => h *: Filter[t, P] case false => Filter[t, P] } }

Фильтрует элементы кортежа, для которых предикат P возвращает значение false. Предикат P[X] — это тип, который может быть либо true, либо false. Например:

type IsString[x] <: Boolean = x match {
  case String => true
  case _ => false
}
summon[Tuple.Filter[(1, "foo", 2, "bar"), IsString] =:= ("foo", "bar")]

Исходник

тип FlatMap[Tup <: Tuple, F <: ([_ <: Union[Tup]] =>> Tuple)] = Tup match { case EmptyTuple => EmptyTuple case h *: t => Concat[F[h], FlatMap[t, F]] }

Преобразует кортеж (T1, ..., Tn) в сплющенный (..F[T1], ..., ..F[Tn])

Исходник

тип Fold[Tup <: Tuple, Z, F[_, _]] = Tup match { case EmptyTuple => Z case h *: t => F[h, Fold[t, Z, F]] }

Сворачивает кортеж (T1, ..., Tn) в F[T1, F[... F[Tn, Z]...]]]

Исходник

тип Head[X <: NonEmptyTuple] = X match { case x *: _$13 => x }

Тип первого элемента кортежа

Исходник

тип Init[X <: Tuple] = X match { case _$14 *: EmptyTuple => EmptyTuple case x *: xs => x *: Init[xs] }

Тип начальной части кортежа без последнего элемента

Исходник

тип InverseMap[X <: Tuple, F[_]] = X match { case F[x] *: t => x *: InverseMap[t, F] case EmptyTuple => EmptyTuple }

Преобразует кортеж (F[T1], ..., F[Tn]) в (T1, ... Tn)

Исходник

тип IsMappedBy[F[_]] = [X <: Tuple] =>> X =:= Map[InverseMap[X, F], F]

Неявное доказательство. IsMappedBy[F][X] присутствует в неявном пространстве имен, если X является кортежем, тип каждого элемента которого построен с помощью F. Например, (F[A1], ..., F[An]), но не (F[A1], B2, ..., F[An]), где B2 не имеет формы F[A]

Исходник

тип Last[X <: Tuple] = X match { case x *: EmptyTuple => x case _$16 *: xs => Last[xs] }

Тип последнего элемента кортежа

Исходник

тип Map[Tup <: Tuple, F[_ <: Union[Tup]]] = Tup match { case EmptyTuple => EmptyTuple case h *: t => F[h] *: Map[t, F] }

Преобразует кортеж (T1, ..., Tn) в (F[T1], ..., F[Tn])

Исходник

тип Size[X <: Tuple] = X match { case EmptyTuple => 0 case x *: xs => S[Size[xs]] }

Литеральная константа типа Int — размер кортежа

Исходник

тип Split[T <: Tuple, N <: Int] = (Take[T, N], Drop[T, N])

Разделяет кортеж (T1, ..., Tn) на пару двух кортежей (T1, ..., Ti) и (Ti+1, ..., Tn).

Исходник

тип Tail[X <: NonEmptyTuple] = X match { case _$15 *: xs => xs }

Тип хвоста кортежа

Исходник

тип Take[T <: Tuple, N <: Int] = N match { case 0 => EmptyTuple case S[n1] => T match { case EmptyTuple => EmptyTuple case x *: xs => x *: Take[xs, n1] } }

Преобразует кортеж (T1, ..., Tn) в (T1, ..., Ti).

Исходник

тип Union[T <: Tuple] = Fold[T, Nothing, [x, y] =>> x | y]

Для данного кортежа (T1, ..., Tn), возвращает объединение его типов членов: T1 | ... | Tn. Возвращает Nothing если кортеж пуст.

Исходник

тип Zip[T1 <: Tuple, T2 <: Tuple] = (T1, T2) match { case (h1 *: t1, h2 *: t2) => (h1, h2) *: Zip[t1, t2] case (EmptyTuple, _$11) => EmptyTuple case (_$12, EmptyTuple) => EmptyTuple case Any => Tuple }

Даны две кортежи, A1 *: ... *: An * At и B1 *: ... *: Bn *: Bt где по крайней мере один из At или Bt является EmptyTuple или Tuple, возвращает тип кортежа (A1, B1) *: ... *: (An, Bn) *: Ct где Ct является EmptyTuple если At или Bt является EmptyTuple, в противном случае Ct является Tuple.

Наследуемые типы

Исходный код

type MirroredElemLabels <: Tuple

Названия элементов продукта

Исходный код

type MirroredLabel <: String

Имя типа

Конкретные методы

Исходный код

def apply(): EmptyTuple

Пустой кортеж

Исходный код

def apply[T](x: T): T *: EmptyTuple

Кортеж с одним элементом

Исходный код

def fromArray[T](xs: Array[T]): Tuple

Преобразование массива в кортеж неизвестной арности и типов

Исходный код

def fromIArray[T](xs: IArray[T]): Tuple

Преобразование неизменяемого массива в кортеж неизвестной арности и типов

Исходный код

def fromProduct(product: Product): Tuple

Преобразование Product в кортеж неизвестной арности и типов

Исходный код

def fromProductTyped[P <: Product](p: P)(using m: ProductOf[P]): <none>

Исходный код

def unapply(x: EmptyTuple): true

Совпадает с пустым кортежем.

Установки

Исходный код

given canEqualEmptyTuple: CanEqual[EmptyTuple, EmptyTuple]

Исходный код

given canEqualTuple[H1, T1 <: Tuple, H2, T2 <: Tuple](using eqHead: CanEqual[H1, H2], eqTail: CanEqual[T1, T2]): CanEqual[H1 *: T1, H2 *: T2]