KList

abstract def apply[N[x] >: M[x], Z](f: (Transform[Types.Id]) ⇒ Z)(implicit ap: Applicative[N]): N[Z]

Applies f to the elements of this list in the applicative functor defined by ap.

abstract def toList: List[M[_]]

Discards the heterogeneous type information and constructs a plain List from this KList's elements.

abstract def transform[N[_]](f: ~>[M, N]): Transform[N]

Apply the natural transformation f to each element.

abstract def traverse[N[_], P[_]](f: ~>[M, [T]N[P[T]]])(implicit np: Applicative[N]): N[Transform[P]]

Equivalent to transform(f) . apply(x => x), this is the essence of the iterator at the level of natural transformations.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def foldr[T](f: (M[_], T) ⇒ T, init: T): T

Folds this list using a function that operates on the homogeneous type of the elements of this list.

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit