Struct Cofree 

pub struct Cofree<F, A>
where
    F: HKT,
{
    pub head: A,
    pub tail: Box<<F as HKT>::Of<Cofree<F, A>>>,
}

Cofree Comonad — the dual of the Free Monad.

Cofree<F, A> pairs a value A at each node with a branching structure determined by F. The choice of F determines the shape:

• OptionF → a non-empty list (finite stream)
• VecF → a rose tree
• IdentityF → an infinite stream

Each node carries a value (head) and subtrees (tail).

Fields

head: A

The value at this node.

tail: Box<<F as HKT>::Of<Cofree<F, A>>>

The subtrees, with branching structure determined by F.

Implementations

impl<F, A> Cofree<F, A>

where F: HKT,

pub fn new(head: A, tail: <F as HKT>::Of<Cofree<F, A>>) -> Cofree<F, A>

Create a Cofree node with the given head and tail.

pub fn extract(&self) -> A

where A: Clone,

Extract the head value.

impl<F, A> Cofree<F, A>

where F: HKT + Functor,

pub fn fmap<B>(self, f: impl Fn(A) -> B) -> Cofree<F, B>

Map a function over all head values in the tree.

pub fn extend<B>(self, f: impl Fn(&Cofree<F, A>) -> B) -> Cofree<F, B>

where A: Clone,

Apply a context-aware function to every position in the tree.

At each node, f receives the entire sub-cofree rooted at that node and produces the new head value.

pub fn unfold<Seed>( seed: Seed, f: impl Fn(&Seed) -> (A, <F as HKT>::Of<Seed>), ) -> Cofree<F, A>

Build a Cofree from a seed value and an unfolding function.

The function takes a seed and returns (head, F<Seed>) — the value at this node and seeds for the subtrees.