| License | BSD-style (see the file LICENSE) |
|---|---|
| Maintainer | sjoerd@w3future.com |
| Stability | experimental |
| Portability | non-portable |
| Safe Haskell | None |
| Language | Haskell2010 |
Data.Functor.Free
Contents
Description
A free functor is left adjoint to a forgetful functor. In this package the forgetful functor forgets class constraints.
- newtype Free c a = Free {
- runFree :: forall b. c b => (a -> b) -> b
- deriveInstances :: Name -> Q [Dec]
- unit :: a -> Free c a
- rightAdjunct :: c b => (a -> b) -> Free c a -> b
- rightAdjunctF :: ForallF c f => (a -> f b) -> Free c a -> f b
- counit :: c a => Free c a -> a
- leftAdjunct :: (Free c a -> b) -> a -> b
- transform :: (forall r. c r => (b -> r) -> a -> r) -> Free c a -> Free c b
- unfold :: (b -> Coproduct c b a) -> b -> Free c a
- convert :: (c (f a), Applicative f) => Free c a -> f a
- convertClosed :: c r => Free c Void -> r
- newtype Extract a = Extract {
- getExtract :: a
- newtype Duplicate f a = Duplicate {
- getDuplicate :: f (f a)
- type Coproduct c m n = Free c (Either m n)
- coproduct :: c r => (m -> r) -> (n -> r) -> Coproduct c m n -> r
- inL :: m -> Coproduct c m n
- inR :: n -> Coproduct c m n
- type InitialObject c = Free c Void
- initial :: c r => InitialObject c -> r
- data ShowHelper f a
- = ShowUnit a
- | ShowRec (f (ShowHelper f a))
Documentation
The free functor for class c.
Free c a is basically an expression tree with operations from class c
and variables/placeholders of type a, created with unit.
Monadic bind allows you to replace each of these variables with another sub-expression.
Instances
| SuperClass1 * (Class f) c => Algebra f (Free c a) Source # | |
| Monad (Free c) Source # | |
| Functor (Free c) Source # | |
| Applicative (Free c) Source # | |
| ForallLifted c => Foldable (Free c) Source # | |
| ForallLifted c => Traversable (Free c) Source # | |
| (ForallF * * c Extract, ForallF * * c (Duplicate (Free c))) => Comonad (Free c) Source # | |
| SuperClass1 * Floating c => Floating (Free c a) Source # | |
| SuperClass1 * Fractional c => Fractional (Free c a) Source # | |
| SuperClass1 * Num c => Num (Free c a) Source # | |
| (Show a, Show (Signature c (ShowHelper (Signature c) a)), c (ShowHelper (Signature c) a)) => Show (Free c a) Source # | |
| SuperClass1 * Semigroup c => Semigroup (Free c a) Source # | |
| SuperClass1 * Monoid c => Monoid (Free c a) Source # | |
deriveInstances :: Name -> Q [Dec] Source #
Derive the instances of Free c ac, Show, Foldable and Traversable.
For example:
deriveInstances ''Num
rightAdjunct :: c b => (a -> b) -> Free c a -> b Source #
rightAdjunct is the destructor of Free c
rightAdjunctF :: ForallF c f => (a -> f b) -> Free c a -> f b Source #
leftAdjunct :: (Free c a -> b) -> a -> b Source #
leftAdjunct f = f . unit
transform :: (forall r. c r => (b -> r) -> a -> r) -> Free c a -> Free c b Source #
transform f as = as >>= f unit
transform f . transform g = transform (g . f)
convert :: (c (f a), Applicative f) => Free c a -> f a Source #
convert = rightAdjunct pure
convertClosed :: c r => Free c Void -> r Source #
convertClosed = rightAdjunct absurd
Constructors
| Extract | |
Fields
| |
newtype Duplicate f a Source #
Constructors
| Duplicate | |
Fields
| |
Coproducts
type Coproduct c m n = Free c (Either m n) Source #
Products of Monoids are Monoids themselves. But coproducts of Monoids are not.
However, the free Monoid applied to the coproduct is a Monoid, and it is the coproduct in the category of Monoids.
This is also called the free product, and generalizes to any algebraic class.
type InitialObject c = Free c Void Source #
initial :: c r => InitialObject c -> r Source #
Internal
data ShowHelper f a Source #
Constructors
| ShowUnit a | |
| ShowRec (f (ShowHelper f a)) |
Instances
| Algebra f (ShowHelper f a) Source # | |
| (Show a, Show (f (ShowHelper f a))) => Show (ShowHelper f a) Source # | |