HCons

final def !=(arg0: Any): Boolean

final def ##(): Int

def +[V](v: V)(implicit f: Appender[HCons[T, U], HCons[V, HNil], Plus[HCons[V, HNil]]]): HCons[T, U.Plus[HCons[V, HNil]]]

Append an element to this HList

def ++[L2 <: HList](l2: L2)(implicit f: Appender[HCons[T, U], L2, Plus[L2]]): HCons[T, U.Plus[L2]]

Append another HList to this HList

def ->[B](y: B): (HCons[T, U], B)

def ::[V](v: V): HCons[V, HCons[T, U]]

Append element at the beginning of this HList

final def ==(arg0: Any): Boolean

def apply[A](index: Int)(implicit arg0: ClassTag[A]): A

Retrieve element at index

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def ensuring(cond: (HCons[T, U]) ⇒ Boolean, msg: ⇒ Any): HCons[T, U]

def ensuring(cond: (HCons[T, U]) ⇒ Boolean): HCons[T, U]

def ensuring(cond: Boolean, msg: ⇒ Any): HCons[T, U]

def ensuring(cond: Boolean): HCons[T, U]

final def eq(arg0: AnyRef): Boolean

def filter(p: (Any) ⇒ Boolean): HList

Filter this HList with a predicate

def finalize(): Unit

def foldLeft[V](zero: V)(f: (V, Any) ⇒ V): V

Applies a binary operator to a start value and all elements of this HList, going left to right.

def foreach(f: (Any) ⇒ Unit): Unit

Executes f for each element of the HList

def formatted(fmtstr: String): String

def get[A](index: Int)(implicit arg0: ClassTag[A]): Option[A]

Retrieve element at index in an Option

final def getClass(): Class[_]

val head: T

final def isInstanceOf[T0]: Boolean

def map(f: (Any) ⇒ Any): HList

Apply f to all elements of this HList

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

val tail: U

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (HCons[T, U], B)

def +(other: String): String