Cofree

abstract def applyCofree[B](f: (A) ⇒ B, g: (Cofree[S, A]) ⇒ Cofree[S, B])(implicit S: Functor[S]): Cofree[S, B]

Applies f to the head and g through the tail.

abstract def head: A

abstract def t: Free[Function0, S[Cofree[S, A]]]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def =>>[B](f: (Cofree[S, A]) ⇒ B)(implicit S: Functor[S]): Cofree[S, B]

Alias for extend

final def applyTail[B](b: B, g: (Cofree[S, A]) ⇒ Cofree[S, B])(implicit S: Functor[S]): Cofree[S, B]

Replaces the head with b and applies g through the tail.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def copure: A

Alias for head, for compatibility with Scalaz 6

final def duplicate(implicit S: Functor[S]): Cofree[S, Cofree[S, A]]

Redecorates the structure with values representing entire substructures.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def extend[B](f: (Cofree[S, A]) ⇒ B)(implicit S: Functor[S]): Cofree[S, B]

Redecorates this structure with a computation whose context is the entire structure under that value.

final def extract: A

Alias for head, for compatibility with Scalaz 6

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def inject[B](b: B)(implicit S: Functor[S]): Cofree[S, B]

Injects a constant value into this structure.

final def isInstanceOf[T0]: Boolean

final def map[B](f: (A) ⇒ B)(implicit S: Functor[S]): Cofree[S, B]

final def mapBranching[T[_]](f: ~>[S, T])(implicit S: Functor[S], T: Functor[T]): Cofree[T, A]

Changes the branching functor by the given natural transformation.

final def mapFirstBranching(f: ~>[S, S]): Cofree[S, A]

Modifies the first branching with the given natural transformation.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def out: S[Cofree[S, A]]

Alias for tail, for compatibility with Scalaz 6

def scanr[B](g: (A, S[Cofree[S, B]]) ⇒ B)(implicit S: Functor[S]): Cofree[S, B]

Folds over this cofree structure, returning all the intermediate values in a new structure.

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

def tail: S[Cofree[S, A]]

final def toPair: (A, S[Cofree[S, A]])

Returns the components of this structure in a tuple.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def zap[G[_], B](fs: Free[G, (A) ⇒ B])(implicit S: Functor[S], G: Functor[G], d: Zap[S, G]): B

Applies a function in a monad to the corresponding value in this comonad, annihilating both.

final def zapWith[G[_], B, C](bs: Free[G, B])(f: (A, B) ⇒ C)(implicit S: Functor[S], G: Functor[G], d: Zap[S, G]): C

Applies a function f to a value in this comonad and a corresponding value in the dual monad, annihilating both.