Cofree

A free comonad for some branching functor S. Branching is done lazily using Eval. A tree with data at the branches, as opposed to Free which is a tree with data at the leaves. Not an instruction set functor made into a program monad as in Free, but an instruction set's outputs as a functor made into a tree of the possible worlds reachable using the instruction set.

This Scala implementation of Cofree and its usages are derived from Scalaz's Cofree, originally written by Rúnar Bjarnason.

Linear Supertypes

Serializable, Serializable, Product, Equals, AnyRef, Any

Instance Constructors

new Cofree(head: A, tail: Eval[S[Cofree[S, A]]])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def coflatMap[B](f: (Cofree[S, A]) ⇒ B)(implicit S: Functor[S]): Cofree[S, B]

Map f over each subtree of the computation.
def coflatten(implicit S: Functor[S]): Cofree[S, Cofree[S, A]]

Replace each node in the computation with the subtree from that node downwards
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def extract: A

Alias for head.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def forceAll(implicit S: Functor[S]): Cofree[S, A]

Evaluate the entire Cofree tree.
def forceTail: Cofree[S, A]

Evaluate just the tail.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
val head: A
final def isInstanceOf[T0]: Boolean

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

Map over head and inner S[_] branches.
def mapBranchingRoot(nat: ~>[S, S])(implicit S: Functor[S]): Cofree[S, A]

Transform the branching functor at the root of the Cofree tree.
def mapBranchingS[T[_]](nat: ~>[S, T])(implicit S: Functor[S]): Cofree[T, A]

Transform the branching functor, using the S functor to perform the recursion.
def mapBranchingT[T[_]](nat: ~>[S, T])(implicit T: Functor[T]): Cofree[T, A]

Transform the branching functor, using the T functor to perform the recursion.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val tail: Eval[S[Cofree[S, A]]]
def tailForced: S[Cofree[S, A]]

Evaluates and returns the tail of the computation.
def transform[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 to the tail.
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object Cofree | package free

final case class Cofree[S[_], A](head: A, tail: Eval[S[Cofree[S, A]]]) extends Product with Serializable

Instance Constructors

new Cofree(head: A, tail: Eval[S[Cofree[S, A]]])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

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

final def eq(arg0: AnyRef): Boolean

def extract: A

def finalize(): Unit

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

def forceTail: Cofree[S, A]

final def getClass(): Class[_]

val head: A

final def isInstanceOf[T0]: Boolean

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

def mapBranchingRoot(nat: ~>[S, S])(implicit S: Functor[S]): Cofree[S, A]

def mapBranchingS[T[_]](nat: ~>[S, T])(implicit S: Functor[S]): Cofree[T, A]

def mapBranchingT[T[_]](nat: ~>[S, T])(implicit T: Functor[T]): Cofree[T, A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

val tail: Eval[S[Cofree[S, A]]]

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped