Safe Haskell | Safe |
---|---|
Language | Haskell2010 |
Synopsis
- type Void = Mu Identity
- absurd :: Recursive (->) t Identity => t -> a
- append :: (Recursive (->) t (XNor a), Steppable (->) u (XNor a)) => t -> u -> u
- at :: (Recursive (->) n Maybe, Projectable (->) s ((,) a)) => n -> s -> a
- atMay :: (Recursive (->) n Maybe, Projectable (->) s (XNor a)) => n -> s -> Maybe a
- constantly :: Corecursive (->) t (Pair a) => a -> t
- drop' :: Projectable (->) t (XNor a) => Maybe (t -> t) -> t -> t
- drop :: (Recursive (->) n Maybe, Projectable (->) t (XNor a)) => n -> t -> t
- fibonacci :: Corecursive (->) t ((,) Int) => t
- fibonacciPolynomials :: (Integral i, Corecursive (->) t ((,) i)) => i -> t
- fromList :: Corecursive (->) t (XNor a) => [a] -> t
- fromListN :: Steppable (->) t (XNor a) => Int -> [a] -> t
- fromMaybe :: (Steppable (->) t (Either a), Corecursive (->) t (Either a)) => Maybe a -> t
- height :: (Foldable f, Steppable (->) n Maybe, Ord n) => f n -> n
- jacobsthal :: (Integral i, Corecursive (->) t ((,) i)) => t
- length :: (Recursive (->) t (XNor a), Steppable (->) n Maybe, Ord n) => t -> n
- lucas :: Integral i => Corecursive (->) t ((,) i) => t
- lucasSequenceU :: (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t
- lucasSequenceV :: (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t
- maybeReify :: (Projectable (->) s f, Steppable (->) l (FreeF f s), Functor f) => Algebra (->) Maybe (s -> l)
- mersenne :: (Integral i, Corecursive (->) t ((,) i)) => t
- naturals :: (Steppable (->) n Maybe, Corecursive (->) t ((,) n)) => t
- now :: Steppable (->) t (Either a) => a -> t
- pell :: (Integral i, Corecursive (->) t ((,) i)) => t
- reifyUpTo :: (Recursive (->) n Maybe, Projectable (->) s f, Steppable (->) l (FreeF f s), Functor f) => n -> s -> l
- reverse' :: Steppable (->) t (XNor a) => XNor a (XNor a t -> XNor a t) -> XNor a t -> XNor a t
- reverse :: (Recursive (->) t (XNor a), Steppable (->) u (XNor a)) => t -> u
- runToEnd :: Recursive (->) t (Either a) => t -> a
- succN :: Steppable (->) t Maybe => t -> t
- tail :: Projectable (->) t (XNor a) => t -> t
- take :: (Recursive (->) n Maybe, Projectable (->) s ((,) a), Steppable (->) l (XNor a)) => n -> s -> l
- takeUpTo :: (Recursive (->) n Maybe, Projectable (->) s (XNor a), Steppable (->) l (XNor a)) => n -> s -> l
- toList :: Projectable (->) t (XNor a) => t -> [a]
- truncate :: (Recursive (->) n Maybe, Projectable (->) t f, Steppable (->) u (FreeF f ()), Functor f) => n -> t -> u
- vacuous :: (Functor f, Recursive (->) t Identity) => f t -> f a
- zeroN :: Steppable (->) t Maybe => t
Documentation
at :: (Recursive (->) n Maybe, Projectable (->) s ((,) a)) => n -> s -> a Source #
Extracts the element at a finite index of an infinite sequence (a
!!
that can't fail).
constantly :: Corecursive (->) t (Pair a) => a -> t Source #
Creates an infinite stream of the provided value.
fibonacciPolynomials :: (Integral i, Corecursive (->) t ((,) i)) => i -> t Source #
fromList :: Corecursive (->) t (XNor a) => [a] -> t Source #
An implementation of toList
for Corecursive
fixed-points of
XNor
.
fromListN :: Steppable (->) t (XNor a) => Int -> [a] -> t Source #
An implementation of fromListN
for Steppable
fixed-points of
XNor
.
This should return an empty structure if the Int
is negative.
If the target structure isn’t Steppable
or the target structure is
Corecursive
(i.e., unsafeFromList
isn’t used),
then the default definition for fromListN
should suffice.
fromMaybe :: (Steppable (->) t (Either a), Corecursive (->) t (Either a)) => Maybe a -> t Source #
Converts exceptional divergence to non-termination.
jacobsthal :: (Integral i, Corecursive (->) t ((,) i)) => t Source #
lucasSequenceU :: (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t Source #
lucasSequenceV :: (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t Source #
maybeReify :: (Projectable (->) s f, Steppable (->) l (FreeF f s), Functor f) => Algebra (->) Maybe (s -> l) Source #
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 Source #
reverse' :: Steppable (->) t (XNor a) => XNor a (XNor a t -> XNor a t) -> XNor a t -> XNor a t Source #
runToEnd :: Recursive (->) t (Either a) => t -> a Source #
This will collapse all the intermediate steps to get to the value that must exist at the end.
tail :: Projectable (->) t (XNor a) => t -> t Source #
take :: (Recursive (->) n Maybe, Projectable (->) s ((,) a), Steppable (->) l (XNor a)) => n -> s -> l Source #
Extracts _exactly_ n
elements from the infinite stream s
.
takeUpTo :: (Recursive (->) n Maybe, Projectable (->) s (XNor a), Steppable (->) l (XNor a)) => n -> s -> l Source #
Extracts _no more than_ n
elements from the possibly-infinite sequence
s
.
toList :: Projectable (->) t (XNor a) => t -> [a] Source #
An implementation of toList
for Projectable
fixed-points of
XNor
.
truncate :: (Recursive (->) n Maybe, Projectable (->) t f, Steppable (->) u (FreeF f ()), Functor f) => n -> t -> u Source #
Lops off the branches of the tree below a certain depth, turning a
potentially-infinite structure into a finite one. Like a generalized
take
.