KeyTree

This module contains types for our internal tree representation of types and configurations. It also contains some helper functions for working with these trees. This should make it easier to implement different source providers.

Since: 0.0.2.0

Types

type KeyTree key value = Free (Map key) value

Type alias for our internal tree structure. If this was written directly as a sum type it would look like this:

Pure value | Free (Map key (KeyTree key value))

Since: 0.0.2.0

type KeyForest key value = Map key (Free (Map key) value)

Type alias for a subtree

Since: 0.0.2.0

Helper Functions

foldKeyTree

Arguments

:: (Eq k, Eq v)

=> (v -> a)

Function to run on Pure values

-> (k -> Free (Map k) v -> a -> a)

Step function for fold

-> a

Initial accumulator

-> KeyTree k v

KeyTree to fold

-> a

Right fold on a KeyTree. Uses foldrWithKey under the hood.

Since: 0.0.2.0

appendFold

Arguments

:: (Eq k, Eq v)

=> (a -> v -> v')

Function to run on existing Pure leaves a is the accumulator v is the value in Pure.

-> (a -> v')

Function from accumulator a to a value v. This happens when an empty subtree is found.

-> (k -> a -> Map k (Free (Map k) v) -> a)

Step function for fold with key k as an argument.

-> a

Accumulator.

-> KeyTree k v

KeyTree to append values to.

-> KeyTree k v'

A fold that appends a value at the leaf of the KeyTree, identifies what to insert at the leaf by running a function on an accumulated value.

Since: 0.0.2.0

mayAppendFold

Arguments

:: (Eq k, Eq v)

=> (a -> v -> Maybe v')

Function to run on existing Pure leaves.

-> (a -> Maybe v')

Function to run when an empty node is found.

-> (k -> a -> Map k (Free (Map k) v) -> a)

Step function for fold with key k as an argument.

-> a

Accumulator.

-> KeyTree k v

Tree to be folded.

-> KeyTree k v'

A fold that appends a value at the leaf of the KeyTree (like appendFold), but the function on the accumulator can return a Maybe. In the Nothing case we just append a Free full of an empty Map.

Since: 0.0.2.0

appendTraverse

Arguments

:: (Applicative f, Eq k, Eq v)

=> (a -> v -> f v')

Function to run on existing Pure leaves.

-> (a -> f v')

Function to run when an empty node is found.

-> (k -> a -> Map k (Free (Map k) v) -> a)

Step function for fold with key k as an argument.

-> a

Accumulator.

-> KeyTree k v

Tree to be folded.

-> f (KeyTree k v')

Like appendFold but with functions that return a value wrapped in an Applicative effect f. The function is suffixed with "Traverse" because we use the sequenceA to wrap the entire tree in a single Applicative effect.

Since: 0.0.2.0

mayAppendTraverse :: (Applicative f, Eq k, Eq v) => (a -> v -> f v') -> (a -> f (Maybe v')) -> (k -> a -> Map k (Free (Map k) v) -> a) -> a -> KeyTree k v -> f (KeyTree k v')

Similar to appendTraverse except the Applicative effect can optionally return a result. The function is manually implemented rather than using Traversable methods so that we don't have to require Traversable on f. This allows consumers to use effects like IO that don't have a Traversable instance.

Since: 0.0.2.0

Type Re-exports

data Map k a

A Map from keys k to values a.

The Semigroup operation for Map is union, which prefers values from the left operand. If m1 maps a key k to a value a1, and m2 maps the same key to a different value a2, then their union m1 <> m2 maps k to a1.

Instances

Bifoldable Map

Since: containers-0.6.3.1

Defined in Data.Map.Internal

Methods

bifold :: Monoid m => Map m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Map a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Map a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Map a b -> c

Eq2 Map

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Map a c -> Map b d -> Bool

Ord2 Map

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Map a c -> Map b d -> Ordering

Show2 Map

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Map a b -> ShowS

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Map a b] -> ShowS

Hashable2 Map

Since: hashable-1.3.4.0

Defined in Data.Hashable.Class

Methods

liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> Map a b -> Int

(Lift k, Lift a) => Lift (Map k a :: Type)

Since: containers-0.6.6

Defined in Data.Map.Internal

Methods

lift :: Quote m => Map k a -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Map k a -> Code m (Map k a)

Foldable (Map k)

Folds in order of increasing key.

Defined in Data.Map.Internal

Methods

fold :: Monoid m => Map k m -> m

foldMap :: Monoid m => (a -> m) -> Map k a -> m

foldMap' :: Monoid m => (a -> m) -> Map k a -> m

foldr :: (a -> b -> b) -> b -> Map k a -> b

foldr' :: (a -> b -> b) -> b -> Map k a -> b

foldl :: (b -> a -> b) -> b -> Map k a -> b

foldl' :: (b -> a -> b) -> b -> Map k a -> b

foldr1 :: (a -> a -> a) -> Map k a -> a

foldl1 :: (a -> a -> a) -> Map k a -> a

toList :: Map k a -> [a]

null :: Map k a -> Bool

length :: Map k a -> Int

elem :: Eq a => a -> Map k a -> Bool

maximum :: Ord a => Map k a -> a

minimum :: Ord a => Map k a -> a

sum :: Num a => Map k a -> a

product :: Num a => Map k a -> a

Eq k => Eq1 (Map k)

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

liftEq :: (a -> b -> Bool) -> Map k a -> Map k b -> Bool

Ord k => Ord1 (Map k)

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

liftCompare :: (a -> b -> Ordering) -> Map k a -> Map k b -> Ordering

(Ord k, Read k) => Read1 (Map k)

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Map k a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Map k a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Map k a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Map k a]

Show k => Show1 (Map k)

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Map k a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Map k a] -> ShowS

Traversable (Map k)

Traverses in order of increasing key.

Defined in Data.Map.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b)

sequenceA :: Applicative f => Map k (f a) -> f (Map k a)

mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b)

sequence :: Monad m => Map k (m a) -> m (Map k a)

Functor (Map k)

Defined in Data.Map.Internal

Methods

fmap :: (a -> b) -> Map k a -> Map k b

(<$) :: a -> Map k b -> Map k a

Hashable k => Hashable1 (Map k)

Since: hashable-1.3.4.0

Defined in Data.Hashable.Class

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Map k a -> Int

(Data k, Data a, Ord k) => Data (Map k a)

Defined in Data.Map.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Map k a -> c (Map k a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Map k a)

toConstr :: Map k a -> Constr

dataTypeOf :: Map k a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Map k a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Map k a))

gmapT :: (forall b. Data b => b -> b) -> Map k a -> Map k a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r

gmapQ :: (forall d. Data d => d -> u) -> Map k a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Map k a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a)

Ord k => Monoid (Map k v)

Defined in Data.Map.Internal

Methods

mempty :: Map k v

mappend :: Map k v -> Map k v -> Map k v

mconcat :: [Map k v] -> Map k v

Ord k => Semigroup (Map k v)

Defined in Data.Map.Internal

Methods

(<>) :: Map k v -> Map k v -> Map k v

sconcat :: NonEmpty (Map k v) -> Map k v

stimes :: Integral b => b -> Map k v -> Map k v

Ord k => IsList (Map k v)

Since: containers-0.5.6.2

Defined in Data.Map.Internal

Associated Types

type Item (Map k v)

Defined in Data.Map.Internal

type Item (Map k v) = (k, v)

Methods

fromList :: [Item (Map k v)] -> Map k v

fromListN :: Int -> [Item (Map k v)] -> Map k v

toList :: Map k v -> [Item (Map k v)]

(Ord k, Read k, Read e) => Read (Map k e)

Defined in Data.Map.Internal

Methods

readsPrec :: Int -> ReadS (Map k e)

readList :: ReadS [Map k e]

readPrec :: ReadPrec (Map k e)

readListPrec :: ReadPrec [Map k e]

(Show k, Show a) => Show (Map k a)

Defined in Data.Map.Internal

Methods

showsPrec :: Int -> Map k a -> ShowS

show :: Map k a -> String

showList :: [Map k a] -> ShowS

(NFData k, NFData a) => NFData (Map k a)

Defined in Data.Map.Internal

Methods

rnf :: Map k a -> ()

(Eq k, Eq a) => Eq (Map k a)

Defined in Data.Map.Internal

Methods

(==) :: Map k a -> Map k a -> Bool

(/=) :: Map k a -> Map k a -> Bool

(Ord k, Ord v) => Ord (Map k v)

Defined in Data.Map.Internal

Methods

compare :: Map k v -> Map k v -> Ordering

(<) :: Map k v -> Map k v -> Bool

(<=) :: Map k v -> Map k v -> Bool

(>) :: Map k v -> Map k v -> Bool

(>=) :: Map k v -> Map k v -> Bool

max :: Map k v -> Map k v -> Map k v

min :: Map k v -> Map k v -> Map k v

(Hashable k, Hashable v) => Hashable (Map k v)

Since: hashable-1.3.4.0

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Map k v -> Int

hash :: Map k v -> Int

type Item (Map k v)

Defined in Data.Map.Internal

type Item (Map k v) = (k, v)

data Free (f :: Type -> Type) a

The Free Monad for a Functor f.

Formally

A Monad n is a free Monad for f if every monad homomorphism from n to another monad m is equivalent to a natural transformation from f to m.

Why Free?

Every "free" functor is left adjoint to some "forgetful" functor.

If we define a forgetful functor U from the category of monads to the category of functors that just forgets the Monad, leaving only the Functor. i.e.

U (M,return,join) = M

then Free is the left adjoint to U.

Free being left adjoint to U means that there is an isomorphism between

Free f -> m in the category of monads and f -> U m in the category of functors.

Morphisms in the category of monads are Monad homomorphisms (natural transformations that respect return and join).

Morphisms in the category of functors are Functor homomorphisms (natural transformations).

Given this isomorphism, every monad homomorphism from Free f to m is equivalent to a natural transformation from f to m

Showing that this isomorphism holds is left as an exercise.

In practice, you can just view a Free f a as many layers of f wrapped around values of type a, where (>>=) performs substitution and grafts new layers of f in for each of the free variables.

This can be very useful for modeling domain specific languages, trees, or other constructs.

This instance of MonadFree is fairly naive about the encoding. For more efficient free monad implementation see Control.Monad.Free.Church, in particular note the improve combinator. You may also want to take a look at the kan-extensions package (http://hackage.haskell.org/package/kan-extensions).

A number of common monads arise as free monads,

• Given data Empty a, Free Empty is isomorphic to the Identity monad.
• Free Maybe can be used to model a partiality monad where each layer represents running the computation for a while longer.

Constructors

Pure a

Free (f (Free f a))

Instances

MonadTrans Free

This is not a true monad transformer. It is only a monad transformer "up to retract".

Defined in Control.Monad.Free

Methods

lift :: Monad m => m a -> Free m a

Functor f => Generic1 (Free f :: Type -> Type)

Defined in Control.Monad.Free

Associated Types

type Rep1 (Free f :: Type -> Type)

Defined in Control.Monad.Free

type Rep1 (Free f :: Type -> Type) = D1 ('MetaData "Free" "Control.Monad.Free" "free-5.2-HYM0gD1Fq69B83fsZa2Ny8" 'False) (C1 ('MetaCons "Pure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1) :+: C1 ('MetaCons "Free" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (f :.: Rec1 (Free f))))

Methods

from1 :: Free f a -> Rep1 (Free f) a

to1 :: Rep1 (Free f) a -> Free f a

Functor f => MonadFree f (Free f)

Defined in Control.Monad.Free

Methods

wrap :: f (Free f a) -> Free f a

MonadError e m => MonadError e (Free m)

Defined in Control.Monad.Free

Methods

throwError :: e -> Free m a

catchError :: Free m a -> (e -> Free m a) -> Free m a

MonadReader e m => MonadReader e (Free m)

Defined in Control.Monad.Free

Methods

ask :: Free m e

local :: (e -> e) -> Free m a -> Free m a

reader :: (e -> a) -> Free m a

MonadState s m => MonadState s (Free m)

Defined in Control.Monad.Free

Methods

get :: Free m s

put :: s -> Free m ()

state :: (s -> (a, s)) -> Free m a

MonadWriter e m => MonadWriter e (Free m)

Defined in Control.Monad.Free

Methods

writer :: (a, e) -> Free m a

tell :: e -> Free m ()

listen :: Free m a -> Free m (a, e)

pass :: Free m (a, e -> e) -> Free m a

Functor f => MonadFix (Free f)

Defined in Control.Monad.Free

Methods

mfix :: (a -> Free f a) -> Free f a

Foldable f => Foldable (Free f)

Defined in Control.Monad.Free

Methods

fold :: Monoid m => Free f m -> m

foldMap :: Monoid m => (a -> m) -> Free f a -> m

foldMap' :: Monoid m => (a -> m) -> Free f a -> m

foldr :: (a -> b -> b) -> b -> Free f a -> b

foldr' :: (a -> b -> b) -> b -> Free f a -> b

foldl :: (b -> a -> b) -> b -> Free f a -> b

foldl' :: (b -> a -> b) -> b -> Free f a -> b

foldr1 :: (a -> a -> a) -> Free f a -> a

foldl1 :: (a -> a -> a) -> Free f a -> a

toList :: Free f a -> [a]

null :: Free f a -> Bool

length :: Free f a -> Int

elem :: Eq a => a -> Free f a -> Bool

maximum :: Ord a => Free f a -> a

minimum :: Ord a => Free f a -> a

sum :: Num a => Free f a -> a

product :: Num a => Free f a -> a

Foldable1 f => Foldable1 (Free f)

Defined in Control.Monad.Free

Methods

fold1 :: Semigroup m => Free f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Free f a -> m

foldMap1' :: Semigroup m => (a -> m) -> Free f a -> m

toNonEmpty :: Free f a -> NonEmpty a

maximum :: Ord a => Free f a -> a

minimum :: Ord a => Free f a -> a

head :: Free f a -> a

last :: Free f a -> a

foldrMap1 :: (a -> b) -> (a -> b -> b) -> Free f a -> b

foldlMap1' :: (a -> b) -> (b -> a -> b) -> Free f a -> b

foldlMap1 :: (a -> b) -> (b -> a -> b) -> Free f a -> b

foldrMap1' :: (a -> b) -> (a -> b -> b) -> Free f a -> b

Eq1 f => Eq1 (Free f)

Defined in Control.Monad.Free

Methods

liftEq :: (a -> b -> Bool) -> Free f a -> Free f b -> Bool

Ord1 f => Ord1 (Free f)

Defined in Control.Monad.Free

Methods

liftCompare :: (a -> b -> Ordering) -> Free f a -> Free f b -> Ordering

Read1 f => Read1 (Free f)

Defined in Control.Monad.Free

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Free f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Free f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Free f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Free f a]

Show1 f => Show1 (Free f)

Defined in Control.Monad.Free

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Free f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Free f a] -> ShowS

Traversable f => Traversable (Free f)

Defined in Control.Monad.Free

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Free f a -> f0 (Free f b)

sequenceA :: Applicative f0 => Free f (f0 a) -> f0 (Free f a)

mapM :: Monad m => (a -> m b) -> Free f a -> m (Free f b)

sequence :: Monad m => Free f (m a) -> m (Free f a)

Alternative v => Alternative (Free v)

This violates the Alternative laws, handle with care.

Defined in Control.Monad.Free

Methods

empty :: Free v a

(<|>) :: Free v a -> Free v a -> Free v a

some :: Free v a -> Free v [a]

many :: Free v a -> Free v [a]

Functor f => Applicative (Free f)

Defined in Control.Monad.Free

Methods

pure :: a -> Free f a

(<*>) :: Free f (a -> b) -> Free f a -> Free f b

liftA2 :: (a -> b -> c) -> Free f a -> Free f b -> Free f c

(*>) :: Free f a -> Free f b -> Free f b

(<*) :: Free f a -> Free f b -> Free f a

Functor f => Functor (Free f)

Defined in Control.Monad.Free

Methods

fmap :: (a -> b) -> Free f a -> Free f b

(<$) :: a -> Free f b -> Free f a

Functor f => Monad (Free f)

Defined in Control.Monad.Free

Methods

(>>=) :: Free f a -> (a -> Free f b) -> Free f b

(>>) :: Free f a -> Free f b -> Free f b

return :: a -> Free f a

MonadPlus v => MonadPlus (Free v)

This violates the MonadPlus laws, handle with care.

Defined in Control.Monad.Free

Methods

mzero :: Free v a

mplus :: Free v a -> Free v a -> Free v a

MonadCont m => MonadCont (Free m)

Defined in Control.Monad.Free

Methods

callCC :: ((a -> Free m b) -> Free m a) -> Free m a

Functor f => Apply (Free f)

Defined in Control.Monad.Free

Methods

(<.>) :: Free f (a -> b) -> Free f a -> Free f b

(.>) :: Free f a -> Free f b -> Free f b

(<.) :: Free f a -> Free f b -> Free f a

liftF2 :: (a -> b -> c) -> Free f a -> Free f b -> Free f c

Functor f => Bind (Free f)

Defined in Control.Monad.Free

Methods

(>>-) :: Free f a -> (a -> Free f b) -> Free f b

join :: Free f (Free f a) -> Free f a

Traversable1 f => Traversable1 (Free f)

Defined in Control.Monad.Free

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> Free f a -> f0 (Free f b)

sequence1 :: Apply f0 => Free f (f0 b) -> f0 (Free f b)

FoldableWithIndex i f => FoldableWithIndex [i] (Free f)

Defined in Control.Monad.Free

Methods

ifoldMap :: Monoid m => ([i] -> a -> m) -> Free f a -> m

ifoldMap' :: Monoid m => ([i] -> a -> m) -> Free f a -> m

ifoldr :: ([i] -> a -> b -> b) -> b -> Free f a -> b

ifoldl :: ([i] -> b -> a -> b) -> b -> Free f a -> b

ifoldr' :: ([i] -> a -> b -> b) -> b -> Free f a -> b

ifoldl' :: ([i] -> b -> a -> b) -> b -> Free f a -> b

FunctorWithIndex i f => FunctorWithIndex [i] (Free f)

Defined in Control.Monad.Free

Methods

imap :: ([i] -> a -> b) -> Free f a -> Free f b

TraversableWithIndex i f => TraversableWithIndex [i] (Free f)

Defined in Control.Monad.Free

Methods

itraverse :: Applicative f0 => ([i] -> a -> f0 b) -> Free f a -> f0 (Free f b)

(Typeable f, Data (f (Free f a)), Data a) => Data (Free f a)

Defined in Control.Monad.Free

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Free f a -> c (Free f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Free f a)

toConstr :: Free f a -> Constr

dataTypeOf :: Free f a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Free f a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Free f a))

gmapT :: (forall b. Data b => b -> b) -> Free f a -> Free f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Free f a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Free f a -> r

gmapQ :: (forall d. Data d => d -> u) -> Free f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Free f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Free f a -> m (Free f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Free f a -> m (Free f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Free f a -> m (Free f a)

Generic (Free f a)

Defined in Control.Monad.Free

Associated Types

type Rep (Free f a)

Defined in Control.Monad.Free

type Rep (Free f a) = D1 ('MetaData "Free" "Control.Monad.Free" "free-5.2-HYM0gD1Fq69B83fsZa2Ny8" 'False) (C1 ('MetaCons "Pure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Free" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f (Free f a)))))

Methods

from :: Free f a -> Rep (Free f a) x

to :: Rep (Free f a) x -> Free f a

(Read1 f, Read a) => Read (Free f a)

Defined in Control.Monad.Free

Methods

readsPrec :: Int -> ReadS (Free f a)

readList :: ReadS [Free f a]

readPrec :: ReadPrec (Free f a)

readListPrec :: ReadPrec [Free f a]

(Show1 f, Show a) => Show (Free f a)

Defined in Control.Monad.Free

Methods

showsPrec :: Int -> Free f a -> ShowS

show :: Free f a -> String

showList :: [Free f a] -> ShowS

(Eq1 f, Eq a) => Eq (Free f a)

Defined in Control.Monad.Free

Methods

(==) :: Free f a -> Free f a -> Bool

(/=) :: Free f a -> Free f a -> Bool

(Ord1 f, Ord a) => Ord (Free f a)

Defined in Control.Monad.Free

Methods

compare :: Free f a -> Free f a -> Ordering

(<) :: Free f a -> Free f a -> Bool

(<=) :: Free f a -> Free f a -> Bool

(>) :: Free f a -> Free f a -> Bool

(>=) :: Free f a -> Free f a -> Bool

max :: Free f a -> Free f a -> Free f a

min :: Free f a -> Free f a -> Free f a

type Rep1 (Free f :: Type -> Type)

Defined in Control.Monad.Free

type Rep1 (Free f :: Type -> Type) = D1 ('MetaData "Free" "Control.Monad.Free" "free-5.2-HYM0gD1Fq69B83fsZa2Ny8" 'False) (C1 ('MetaCons "Pure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1) :+: C1 ('MetaCons "Free" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (f :.: Rec1 (Free f))))

type Rep (Free f a)

Defined in Control.Monad.Free

type Rep (Free f a) = D1 ('MetaData "Free" "Control.Monad.Free" "free-5.2-HYM0gD1Fq69B83fsZa2Ny8" 'False) (C1 ('MetaCons "Pure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Free" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f (Free f a)))))