Yaya.Applied

Documentation

now :: Steppable (->) t (Either a) => a -> t

runToEnd :: Recursive (->) t (Either a) => t -> a

This will collapse all the intermediate steps to get to the value that must exist at the end.

fromMaybe :: (Steppable (->) t (Either a), Corecursive (->) t (Either a)) => Maybe a -> t

Converts exceptional divergence to non-termination.

type Void = Mu Identity

absurd :: Recursive (->) t Identity => t -> a

vacuous :: (Functor f, Recursive (->) t Identity) => f t -> f a

zeroN :: Steppable (->) t Maybe => t

succN :: Steppable (->) t Maybe => t -> t

height :: (Foldable f, Steppable (->) n Maybe, Ord n) => f n -> n

naturals :: (Steppable (->) n Maybe, Corecursive (->) t ((,) n)) => t

takeUpTo :: (Recursive (->) n Maybe, Projectable (->) s (XNor a), Steppable (->) l (XNor a)) => n -> s -> l

Extracts _no more than_ n elements from the possibly-infinite sequence s.

take :: (Recursive (->) n Maybe, Projectable (->) s ((,) a), Steppable (->) l (XNor a)) => n -> s -> l

Extracts _exactly_ n elements from the infinite stream s.

at :: (Recursive (->) n Maybe, Projectable (->) s ((,) a)) => n -> s -> a

Extracts the element at a finite index of an infinite sequence (a !! that can't fail).

atMay :: (Recursive (->) n Maybe, Projectable (->) s (XNor a)) => n -> s -> Maybe a

Extracts the element at a finite index of a (co)list (a !! that fails with Nothing).

maybeReify :: (Projectable (->) s f, Steppable (->) l (FreeF f s), Functor f) => Algebra (->) Maybe (s -> l)

Turns part of a structure inductive, so it can be analyzed, without forcing the entire tree.

reifyUpTo :: (Recursive (->) n Maybe, Projectable (->) s f, Steppable (->) l (FreeF f s), Functor f) => n -> s -> l

fibonacciPolynomials :: (Integral i, Corecursive (->) t ((,) i)) => i -> t

fibonacci :: Corecursive (->) t ((,) Int) => t

lucasSequenceU :: (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t

lucasSequenceV :: (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t

lucas :: Integral i => Corecursive (->) t ((,) i) => t

pell :: (Integral i, Corecursive (->) t ((,) i)) => t

jacobsthal :: (Integral i, Corecursive (->) t ((,) i)) => t

mersenne :: (Integral i, Corecursive (->) t ((,) i)) => t

constantly :: Corecursive (->) t ((,) a) => a -> t

Creates an infinite stream of the provided value.

truncate :: (Recursive (->) n Maybe, Projectable (->) t f, Steppable (->) u (FreeF f ()), Functor f) => n -> t -> u

Lops off the branches of the tree below a certain depth, turning a potentially-infinite structure into a finite one. Like a generalized take.