HListOps

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[S <: HList](suffix: S)(implicit prepend: Prepend[L, S]): Out

Append the argument HList to this HList.

def ++:[P <: HList](prefix: P)(implicit prepend: Prepend[P, L]): Out

Prepend the argument HList to this HList.

def +:[H](h: H): ::[H, L]

Prepend the argument element to this HList.

def :+[T](t: T)(implicit prepend: Prepend[L, ::[T, HNil]]): Out

Append the argument element to this HList.

def ::[H](h: H): ::[H, L]

Prepend the argument element to this HList.

def :::[P <: HList](prefix: P)(implicit prepend: Prepend[P, L]): Out

Prepend the argument HList to this HList.

final def ==(arg0: Any): Boolean

def adjoined(implicit adjoin: Adjoin[L]): ops.adjoin.Adjoin.Out

Adjoins the elements of this HList by flattening any HList elements.

def align[M <: HList](m: M)(implicit align: Align[L, M]): M

Permutes this HList into the same order as the supplied HList with the same element types.

def align[M <: HList](implicit align: Align[L, M]): M

Permutes this HList into the same order as another HList.

def apply(n: Nat)(implicit at: At[L, N]): ops.hlist.At.Out

Returns the nth element of this HList.

def apply[N <: Nat](implicit at: At[L, N]): ops.hlist.At.Out

Returns the nth element of this HList.

final def asInstanceOf[T0]: T0

def at(n: Nat)(implicit at: At[L, N]): ops.hlist.At.Out

Returns the nth element of this HList.

def at[N <: Nat](implicit at: At[L, N]): ops.hlist.At.Out

Returns the nth element of this HList.

def clone(): AnyRef

def collect(p: Poly)(implicit collect: Collect[L, p.type]): Out

Collect a higher rank function across this HList.

def collectFirst[P <: Poly](p: P)(implicit collect: CollectFirst[L, p.type]): ops.hlist.CollectFirst.Out

Finds the first element of the HList for which the given Poly is defined, and applies the Poly to it.

def diff[M <: HList](implicit diff: Diff[L, M]): Out

Returns the difference between this HList and another HList.

def drop(n: Nat)(implicit drop: Drop[L, N]): Out

Returns all but the first n elements of this HList.

def drop[N <: Nat](implicit drop: Drop[L, N]): Out

Returns all but the first n elements of this HList.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter[U](implicit partition: Partition[L, U]): Prefix

Returns all elements of type U of this HList.

def filterNot[U](implicit partition: Partition[L, U]): Suffix

Returns all elements of type different than U of this HList.

def finalize(): Unit

def flatMap(f: Poly)(implicit mapper: FlatMapper[f.type, L]): Out

Flatmaps a higher rank function across this HList.

def foldLeft[R](z: R)(op: Poly)(implicit folder: LeftFolder[L, R, op.type]): ops.hlist.LeftFolder.Out

Computes a left fold over this HList using the polymorphic binary combining operator op.

def foldMap[R](z: R)(f: Poly)(op: (R, R) ⇒ R)(implicit folder: MapFolder[L, R, f.type]): R

Maps a higher rank function f across this HList and folds the result using monomorphic combining operator op.

def foldRight[R](z: R)(op: Poly)(implicit folder: RightFolder[L, R, op.type]): ops.hlist.RightFolder.Out

Computes a right fold over this HList using the polymorphic binary combining operator op.

final def getClass(): Class[_]

def group[Pad <: HList](n: Nat, step: Nat, pad: Pad)(implicit grouper: PaddedGrouper[L, N, N, Pad]): Out

Groups the elements of this HList into tuples of n elements, offset by step Use elements in pad as necessary to complete last group up to n items.

def group(n: Nat, step: Nat)(implicit grouper: Grouper[L, N, N]): Out

Groups the elements of this HList into tuples of n elements, offset by step

def hashCode(): Int

def head(implicit c: IsHCons[L]): H

Returns the head of this HList.

def init(implicit init: Init[L]): Out

Returns an HList consisting of all the elements of this HList except the last.

def intersect[M <: HList](implicit intersection: Intersection[L, M]): Out

Returns the intersection between this HList and another HList.

final def isInstanceOf[T0]: Boolean

def last(implicit last: Last[L]): ops.hlist.Last.Out

Returns the last element of this HList.

def length(implicit length: Length[L]): Out

Compute the length of this HList.

def map(f: Poly)(implicit mapper: Mapper[f.type, L]): Out

Maps a higher rank function across this HList.

def mapCons[A](a: A)(implicit mapCons: MapCons[A, L]): Out

Conses an element onto each row of this HMatrix (HList of HLists).

def mapConst[C](c: C)(implicit mapper: ConstMapper[C, L]): Out

Replaces each element of this HList with a constant value.

def mkString(start: String, sep: String, end: String)(implicit toTraversable: Aux[L, List, Any]): String

Displays all elements of this hlist in a string using start, end, and separator strings.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def padTo[A](n: Nat, elem: A)(implicit padTo: PadTo[N, A, L]): Out

Appends elem until a given length N is reached.

def partition[U](implicit partition: Partition[L, U]): (Prefix, Suffix)

def partitionP[U](implicit partition: Partition[L, U]): ::[Prefix, ::[Suffix, HNil]]

def patch[N <: Nat, M <: Nat]: PatchAux[N, M]

Produces a new HList where a slice of this HList is replaced by another.

def patch[In <: HList](n: Nat, in: In, m: Nat)(implicit patcher: Patcher[N, N, L, In]): Out

Produces a new HList where a slice of this HList is replaced by another.

def permutations(implicit permutations: Permutations[L]): Out

Returns all permutations of this 'HList'

def reduceLeft(op: Poly)(implicit reducer: LeftReducer[L, op.type]): ops.hlist.LeftReducer.Out

Computes a left reduce over this HList using the polymorphic binary combining operator op.

def reduceRight(op: Poly)(implicit reducer: RightReducer[L, op.type]): ops.hlist.RightReducer.Out

Computes a right reduce over this HList using the polymorphic binary combining operator op.

def reinsert[O <: HList]: ReinsertAux[O]

Reinserts an element U into this HList to return another HList O.

def reinsertAll[O <: HList]: ReinsertAllAux[O]

Reinserts the elements of SL into this HList to return another HList O.

def removeAll[SL <: HList](implicit removeAll: RemoveAll[L, SL]): ops.hlist.RemoveAll.Out

Returns the first elements of this HList that have types in SL plus the remainder of the HList.

def removeElem[U](implicit remove: Remove[L, U]): ops.hlist.Remove.Out

Returns the first element of type U of this HList plus the remainder of the HList.

def replace[U](u: U)(implicit replacer: Replacer[L, U, U]): ops.hlist.Replacer.Out

Replaces the first element of type U of this HList with the supplied value, also of type U returning both the replaced element and the updated HList.

def replaceType[U]: ReplaceTypeAux[U]

Replaces the first element of type U of this HList with the supplied value of type V, returning both the replaced element and the updated HList.

def reverse(implicit reverse: Reverse[L]): Out

Reverses this HList.

def reverse_:::[P <: HList](prefix: P)(implicit prepend: ReversePrepend[P, L]): Out

Prepend the reverse of the argument HList to this HList.

def reverse_split(n: Nat)(implicit split: ReverseSplit[L, N]): (Prefix, Suffix)

Splits this HList at the nth element, returning the reverse of the prefix and suffix as a pair.

def reverse_split[N <: Nat](implicit split: ReverseSplit[L, N]): (Prefix, Suffix)

Splits this HList at the nth element, returning the reverse of the prefix and suffix as a pair.

def reverse_splitLeft[U](implicit split: ReverseSplitLeft[L, U]): (Prefix, Suffix)

Splits this HList at the first occurrence of an element of type U, returning reverse of the prefix and suffix as a pair.

def reverse_splitLeftP[U](implicit split: ReverseSplitLeft[L, U]): ::[Prefix, ::[Suffix, HNil]]

def reverse_splitP(n: Nat)(implicit split: ReverseSplit[L, N]): ::[Prefix, ::[Suffix, HNil]]

def reverse_splitP[N <: Nat](implicit split: ReverseSplit[L, N]): ::[Prefix, ::[Suffix, HNil]]

def reverse_splitRight[U](implicit split: ReverseSplitRight[L, U]): (Prefix, Suffix)

Splits this HList at the last occurrence of an element of type U, returning reverse of the prefix and suffix as a pair.

def reverse_splitRightP[U](implicit split: ReverseSplitRight[L, U]): ::[Prefix, ::[Suffix, HNil]]

def rotateLeft(n: Nat)(implicit rotateLeft: RotateLeft[L, N]): Out

Rotate this 'HList' left by N

def rotateLeft[N <: Nat](implicit rotateLeft: RotateLeft[L, N]): Out

Rotate this 'HList' left by N.

def rotateRight(n: Nat)(implicit rotateRight: RotateRight[L, N]): Out

Rotate this 'HList' right by N

def rotateRight[N <: Nat](implicit rotateRight: RotateRight[L, N]): Out

Rotate this 'HList' right by N.

def runtimeLength: Int

Compute the length of this HList as a runtime Int value.

def runtimeList: List[Any]

Convert this HList to a List[Any].

def scanLeft[A, P <: Poly](z: A)(op: Poly)(implicit scanL: LeftScanner[L, A, op.type]): Out

Computes a left scan over this HList using the polymorphic binary combining operator op.

def scanRight[A, P <: Poly](z: A)(op: Poly)(implicit scanR: RightScanner[L, A, op.type]): Out

Computes a right scan over this HList using the polymorphic binary combining operator op.

def select[U](implicit selector: Selector[L, U]): U

Returns the first element of type U of this HList.

def selectMany: SelectManyAux[L]

def selectManyType[Ids <: HList](implicit sel: SelectMany[L, Ids]): Out

def selectRange(a: Nat, b: Nat)(implicit sel: SelectRange[L, N, N]): Out

def selectRange[A <: Nat, B <: Nat](implicit sel: SelectRange[L, A, B]): Out

Returns the elements of this HList specified by the range of ids in [A,B[ Available only if there is evidence that this HList contains all elements in that range

def slice(from: Nat, until: Nat)(implicit slice: Slice[N, N, L]): Out

Slices beginning at index from and afterwards, up until index until

def split(n: Nat)(implicit split: Split[L, N]): (Prefix, Suffix)

Splits this HList at the nth element, returning the prefix and suffix as a pair.

def split[N <: Nat](implicit split: Split[L, N]): (Prefix, Suffix)

Splits this HList at the nth element, returning the prefix and suffix as a pair.

def splitLeft[U](implicit split: SplitLeft[L, U]): (Prefix, Suffix)

Splits this HList at the first occurrence of an element of type U, returning the prefix and suffix as a pair.

def splitLeftP[U](implicit split: SplitLeft[L, U]): ::[Prefix, ::[Suffix, HNil]]

def splitP(n: Nat)(implicit split: Split[L, N]): ::[Prefix, ::[Suffix, HNil]]

def splitP[N <: Nat](implicit split: Split[L, N]): ::[Prefix, ::[Suffix, HNil]]

def splitRight[U](implicit split: SplitRight[L, U]): (Prefix, Suffix)

Splits this HList at the last occurrence of an element of type U, returning the prefix and suffix as a pair.

def splitRightP[U](implicit split: SplitRight[L, U]): ::[Prefix, ::[Suffix, HNil]]

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

def tail(implicit c: IsHCons[L]): T

Returns the tail of this HList.

def take(n: Nat)(implicit take: Take[L, N]): Out

Returns the first n elements of this HList.

def take[N <: Nat](implicit take: Take[L, N]): Out

Returns the first n elements of this HList.

def to[M[_]](implicit ts: ToTraversable[L, M]): Out

Converts this HList to a M of elements typed as the least upper bound of the types of the elements of this HList.

def toArray[Lub](implicit toTraversableAux: Aux[L, Array, Lub]): (toTraversableAux)#Out

Converts this HList to an Array of elements typed as the least upper bound of the types of the elements of this HList.

def toCoproduct[M[_] <: Traversable[_]](implicit toCoproductTraversable: ToCoproductTraversable[L, M]): Out

Converts this HList to a M of elements embedded in a minimal Coproduct encompassing the types of every elements of this HList.

def toList[Lub](implicit toTraversableAux: Aux[L, List, Lub]): (toTraversableAux)#Out

Converts this HList to an ordinary List of elements typed as the least upper bound of the types of the elements of this HList.

def toSized[M[_]](implicit ts: ToSized[L, M]): Out

Converts this HList to a - sized - M of elements typed as the least upper bound of the types of the elements of this HList.

def toString(): String

def transpose(implicit transpose: Transposer[L]): Out

Transposes this HList.

def tupled(implicit tupler: Tupler[L]): ops.hlist.Tupler.Out

Converts this HList to a correspondingly typed tuple.

def unify(implicit unifier: Unifier[L]): Out

Returns an HList typed as a repetition of the least upper bound of the types of the elements of this HList.

def unifySubtypes[B](implicit subtypeUnifier: SubtypeUnifier[L, B]): Out

Returns an HList with all elements that are subtypes of B typed as B.

def union[M <: HList](s: M)(implicit union: Union[L, M]): Out

Returns the union between this HList and another HList.

def unzip(implicit unzipper: Unzip[L]): ops.hlist.Unzip.Out

Unzips this HList of tuples returning a tuple of HLists.

def updateAtWith[V](n: NatWith[[n]At[L, n]])(f: (ops.hlist.At.Out) ⇒ V)(implicit upd: ModifierAt[L, N, ops.hlist.At.Out, V]): ops.hlist.ModifierAt.Out

Replaces the Nth element of this HList with the result of calling the supplied function on it.

def updateWith[U, V, Out <: HList](f: (U) ⇒ V)(implicit replacer: Aux[L, U, V, (U, Out)]): Out

Replaces the first element of type U of this HList with the result of its transformation to a V via the supplied function.

def updatedAt[U, V, Out <: HList](n: Nat, u: U)(implicit replacer: Aux[L, N, U, (V, Out)]): Out

Replaces the nth' element of this HList with the supplied value of type U. Available only if there is evidence that this HList has at least n elements.

def updatedAt[N <: Nat]: UpdatedAtAux[N]

Replaces the nth' element of this HList with the supplied value of type U. An explicit type argument must be provided for N. Available only if there is evidence that this HList has at least n elements.

def updatedElem[U, Out <: HList](u: U)(implicit replacer: Aux[L, U, U, (U, Out)]): Out

Replaces the first element of type U of this HList with the supplied value, also of type U.

def updatedType[U]: UpdatedTypeAux[U]

Replaces the first element of type U of this HList with the supplied value of type V.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip(implicit zipper: Zip[L]): Out

Zips this HList of HLists returning an HList of tuples.

def zip[R <: HList](r: R)(implicit zipper: Zip[::[L, ::[R, HNil]]]): Out

Zips this HList with its argument HList returning an HList of pairs.

def zipApply[A <: HList](a: A)(implicit zipper: ZipApply[L, A]): Out

Zips this HList of monomorphic function values with its argument HList of correspondingly typed function arguments returning the result of each application as an HList.

def zipConst[C](c: C)(implicit zipConst: ZipConst[C, L]): Out

Zips this HList with a constant, resulting in an HList of tuples of the form ({element from this HList}, {supplied constant})

def zipOne[T <: HList](t: T)(implicit zipOne: ZipOne[L, T]): Out

Zips this HList with its argument HList of HLists, returning an HList of HLists with each element of this HList prepended to the corresponding HList element of the argument HList.

def zipWith[R <: HList, P <: Poly2](r: R)(p: P)(implicit zipWith: ZipWith[L, R, P]): Out

Zips this 'HList' with its argument 'HList' using argument 'Poly2', returning an 'HList'.

def zipWithIndex(implicit zipWithIndex: ZipWithIndex[L]): Out

Zips this HList with its element indices, resulting in a 'HList' of tuples of the form ({element from input tuple}, {element index})

def zipWithKeys[K <: HList](implicit withKeys: ZipWithKeys[K, L]): Out

Converts this HList of values into a record with given keys.

def zipWithKeys[K <: HList](keys: K)(implicit withKeys: ZipWithKeys[K, L]): Out

Converts this HList of values into a record with the provided keys.

def unzipped(implicit unzipper: Unzip[L]): ops.hlist.Unzip.Out

Unzips this HList of tuples returning a tuple of HLists.

def zipped(implicit zipper: Zip[L]): Out

Zips this HList of HLists returning an HList of tuples.