Data.Generics.Fixplate.Base

The core types of Fixplate.

Documentation

newtype Mu f

The fixed-point type.

Constructors

Fix

Fields

• unFix :: f (Mu f)

Instances

EqF f => Eq (Mu f)

Methods

(==) :: Mu f -> Mu f -> Bool

(/=) :: Mu f -> Mu f -> Bool

OrdF f => Ord (Mu f)

Methods

compare :: Mu f -> Mu f -> Ordering

(<) :: Mu f -> Mu f -> Bool

(<=) :: Mu f -> Mu f -> Bool

(>) :: Mu f -> Mu f -> Bool

(>=) :: Mu f -> Mu f -> Bool

max :: Mu f -> Mu f -> Mu f

min :: Mu f -> Mu f -> Mu f

ReadF f => Read (Mu f)

Methods

readsPrec :: Int -> ReadS (Mu f)

readList :: ReadS [Mu f]

readPrec :: ReadPrec (Mu f)

readListPrec :: ReadPrec [Mu f]

ShowF f => Show (Mu f)

Methods

showsPrec :: Int -> Mu f -> ShowS

show :: Mu f -> String

showList :: [Mu f] -> ShowS

isAtom :: Foldable f => Mu f -> Bool

We call a tree "atomic" if it has no subtrees.

Annotations

data Ann f a b

Type of annotations

Constructors

Ann

Fields

• attr :: a

  the annotation

• unAnn :: f b

  the original functor

Instances

Functor f => Functor (Ann f a)

Methods

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

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

Foldable f => Foldable (Ann f a)

Methods

fold :: Monoid m => Ann f a m -> m

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

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

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

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

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

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

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

toList :: Ann f a a -> [a]

null :: Ann f a a -> Bool

length :: Ann f a a -> Int

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

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

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

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

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

Traversable f => Traversable (Ann f a)

Methods

traverse :: Applicative f => (a -> f b) -> Ann f a a -> f (Ann f a b)

sequenceA :: Applicative f => Ann f a (f a) -> f (Ann f a a)

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

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

(Read a, ReadF f) => ReadF (Ann f a)

Methods

readPrecF :: Read a => ReadPrec (Ann f a a)

(Show a, ShowF f) => ShowF (Ann f a)

Methods

showsPrecF :: Show a => Int -> Ann f a a -> ShowS

(Ord a, OrdF f) => OrdF (Ann f a)

NOTE: The OrdF instance for annotations first compares the annotations, and then the functor part. If this is not the desired behaviour (it's not clear to me at the moment what is the good default here), you can use the standard newtype trick to define a new behaviour.

Methods

compareF :: Ord a => Ann f a a -> Ann f a a -> Ordering

(Eq a, EqF f) => EqF (Ann f a)

NOTE: The EqF instance for annotations compares both the annotations and the original part.

Methods

equalF :: Eq a => Ann f a a -> Ann f a a -> Bool

(Eq a, Eq (f b)) => Eq (Ann f a b)

Methods

(==) :: Ann f a b -> Ann f a b -> Bool

(/=) :: Ann f a b -> Ann f a b -> Bool

(Ord a, Ord (f b)) => Ord (Ann f a b)

Methods

compare :: Ann f a b -> Ann f a b -> Ordering

(<) :: Ann f a b -> Ann f a b -> Bool

(<=) :: Ann f a b -> Ann f a b -> Bool

(>) :: Ann f a b -> Ann f a b -> Bool

(>=) :: Ann f a b -> Ann f a b -> Bool

max :: Ann f a b -> Ann f a b -> Ann f a b

min :: Ann f a b -> Ann f a b -> Ann f a b

(Show a, Show (f b)) => Show (Ann f a b)

Methods

showsPrec :: Int -> Ann f a b -> ShowS

show :: Ann f a b -> String

showList :: [Ann f a b] -> ShowS

type Attr f a = Mu (Ann f a)

Annotated fixed-point type. Equivalent to CoFree f a

liftAnn :: (f e -> g e) -> Ann f a e -> Ann g a e

Lifting natural transformations to annotations.

Co-annotations

data CoAnn f a b

Categorical dual of Ann.

Constructors

Pure a

CoAnn (f b)

Instances

Functor f => Functor (CoAnn f a)

Methods

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

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

Foldable f => Foldable (CoAnn f a)

Methods

fold :: Monoid m => CoAnn f a m -> m

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

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

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

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

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

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

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

toList :: CoAnn f a a -> [a]

null :: CoAnn f a a -> Bool

length :: CoAnn f a a -> Int

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

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

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

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

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

Traversable f => Traversable (CoAnn f a)

Methods

traverse :: Applicative f => (a -> f b) -> CoAnn f a a -> f (CoAnn f a b)

sequenceA :: Applicative f => CoAnn f a (f a) -> f (CoAnn f a a)

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

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

(Show a, ShowF f) => ShowF (CoAnn f a)

Methods

showsPrecF :: Show a => Int -> CoAnn f a a -> ShowS

(Ord a, OrdF f) => OrdF (CoAnn f a)

Methods

compareF :: Ord a => CoAnn f a a -> CoAnn f a a -> Ordering

(Eq a, EqF f) => EqF (CoAnn f a)

Methods

equalF :: Eq a => CoAnn f a a -> CoAnn f a a -> Bool

(Eq a, Eq (f b)) => Eq (CoAnn f a b)

Methods

(==) :: CoAnn f a b -> CoAnn f a b -> Bool

(/=) :: CoAnn f a b -> CoAnn f a b -> Bool

(Ord a, Ord (f b)) => Ord (CoAnn f a b)

Methods

compare :: CoAnn f a b -> CoAnn f a b -> Ordering

(<) :: CoAnn f a b -> CoAnn f a b -> Bool

(<=) :: CoAnn f a b -> CoAnn f a b -> Bool

(>) :: CoAnn f a b -> CoAnn f a b -> Bool

(>=) :: CoAnn f a b -> CoAnn f a b -> Bool

max :: CoAnn f a b -> CoAnn f a b -> CoAnn f a b

min :: CoAnn f a b -> CoAnn f a b -> CoAnn f a b

(Show a, Show (f b)) => Show (CoAnn f a b)

Methods

showsPrec :: Int -> CoAnn f a b -> ShowS

show :: CoAnn f a b -> String

showList :: [CoAnn f a b] -> ShowS

type CoAttr f a = Mu (CoAnn f a)

Categorical dual of Attr. Equivalent to Free f a

liftCoAnn :: (f e -> g e) -> CoAnn f a e -> CoAnn g a e

Lifting natural transformations to annotations.

Annotated trees

attribute :: Attr f a -> a

The attribute of the root node.

forget :: Functor f => Attr f a -> Mu f

A function forgetting all the attributes from an annotated tree.

Holes

data Hole

This a data type defined to be a place-holder for childs. It is used in tree drawing, hashing, and Shape.

It is deliberately not made an instance of Show, so that you can choose your preferred style. For example, an acceptable choice is

instance Show Hole where show _ = "_"

Constructors

Hole

Instances

Eq Hole

Methods

(==) :: Hole -> Hole -> Bool

(/=) :: Hole -> Hole -> Bool

Ord Hole

Methods

compare :: Hole -> Hole -> Ordering

(<) :: Hole -> Hole -> Bool

(<=) :: Hole -> Hole -> Bool

(>) :: Hole -> Hole -> Bool

(>=) :: Hole -> Hole -> Bool

max :: Hole -> Hole -> Hole

min :: Hole -> Hole -> Hole

Higher-order type classes

class EqF f where

"Functorised" versions of standard type classes. If you have your a structure functor, for example

Expr e 
  = Kst Int 
  | Var String 
  | Add e e 
  deriving (Eq,Ord,Read,Show,Functor,Foldable,Traversable)

you should make it an instance of these, so that the fixed-point type Mu Expr can be an instance of Eq, Ord and Show. Doing so is very easy:

instance EqF   Expr where equalF     = (==)
instance OrdF  Expr where compareF   = compare
instance ShowF Expr where showsPrecF = showsPrec

The Read instance depends on whether we are using GHC or not. The Haskell98 version is

instance ReadF Expr where readsPrecF = readsPrec

while the GHC version is

instance ReadF Expr where readPrecF  = readPrec

Minimal complete definition

equalF

Methods

equalF :: Eq a => f a -> f a -> Bool

Instances

(Eq a, EqF f) => EqF (CoAnn f a)

Methods

equalF :: Eq a => CoAnn f a a -> CoAnn f a a -> Bool

(Eq a, EqF f) => EqF (Ann f a)

NOTE: The EqF instance for annotations compares both the annotations and the original part.

Methods

equalF :: Eq a => Ann f a a -> Ann f a a -> Bool

(EqF f, EqF g) => EqF ((:*:) f g)

Methods

equalF :: Eq a => (f :*: g) a -> (f :*: g) a -> Bool

(EqF f, EqF g) => EqF ((:+:) f g)

Methods

equalF :: Eq a => (f :+: g) a -> (f :+: g) a -> Bool

(Eq hash, EqF f) => EqF (HashAnn hash f)

Methods

equalF :: Eq a => HashAnn hash f a -> HashAnn hash f a -> Bool

class EqF f => OrdF f where

Minimal complete definition

compareF

Methods

compareF :: Ord a => f a -> f a -> Ordering

Instances

(Ord a, OrdF f) => OrdF (CoAnn f a)

Methods

compareF :: Ord a => CoAnn f a a -> CoAnn f a a -> Ordering

(Ord a, OrdF f) => OrdF (Ann f a)

NOTE: The OrdF instance for annotations first compares the annotations, and then the functor part. If this is not the desired behaviour (it's not clear to me at the moment what is the good default here), you can use the standard newtype trick to define a new behaviour.

Methods

compareF :: Ord a => Ann f a a -> Ann f a a -> Ordering

(OrdF f, OrdF g) => OrdF ((:*:) f g)

Methods

compareF :: Ord a => (f :*: g) a -> (f :*: g) a -> Ordering

(OrdF f, OrdF g) => OrdF ((:+:) f g)

Methods

compareF :: Ord a => (f :+: g) a -> (f :+: g) a -> Ordering

(Ord hash, OrdF f) => OrdF (HashAnn hash f)

Methods

compareF :: Ord a => HashAnn hash f a -> HashAnn hash f a -> Ordering

class ShowF f where

Minimal complete definition

showsPrecF

Methods

showsPrecF :: Show a => Int -> f a -> ShowS

Instances

(Show a, ShowF f) => ShowF (CoAnn f a)

Methods

showsPrecF :: Show a => Int -> CoAnn f a a -> ShowS

(Show a, ShowF f) => ShowF (Ann f a)

Methods

showsPrecF :: Show a => Int -> Ann f a a -> ShowS

(ShowF f, ShowF g) => ShowF ((:*:) f g)

Methods

showsPrecF :: Show a => Int -> (f :*: g) a -> ShowS

(ShowF f, ShowF g) => ShowF ((:+:) f g)

Methods

showsPrecF :: Show a => Int -> (f :+: g) a -> ShowS

(ShowF f, Show hash) => ShowF (HashAnn hash f)

Methods

showsPrecF :: Show a => Int -> HashAnn hash f a -> ShowS

class ReadF f where

Minimal complete definition

readPrecF

Methods

readPrecF :: Read a => ReadPrec (f a)

Instances

(Read a, ReadF f) => ReadF (Ann f a)

Methods

readPrecF :: Read a => ReadPrec (Ann f a a)

showF :: (ShowF f, Show a) => f a -> String

showsF :: (ShowF f, Show a) => f a -> ShowS

Attrib (cofree comonad)

newtype Attrib f a

A newtype wrapper around Attr f a so that we can make Attr f an instance of Functor, Foldable and Traversable (and Comonad). This is necessary since Haskell does not allow partial application of type synonyms.

Equivalent to the co-free comonad.

Constructors

Attrib

Fields

• unAttrib :: Attr f a

Instances

Functor f => Functor (Attrib f)

Methods

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

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

Foldable f => Foldable (Attrib f)

Methods

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

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

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

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

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

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

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

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

toList :: Attrib f a -> [a]

null :: Attrib f a -> Bool

length :: Attrib f a -> Int

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

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

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

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

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

Traversable f => Traversable (Attrib f)

Methods

traverse :: Applicative f => (a -> f b) -> Attrib f a -> f (Attrib f b)

sequenceA :: Applicative f => Attrib f (f a) -> f (Attrib f a)

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

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

(ShowF f, Show a) => Show (Attrib f a)

Methods

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

show :: Attrib f a -> String

showList :: [Attrib f a] -> ShowS

CoAttrib (free monad)

newtype CoAttrib f a

Categorial dual of Attrib. Equivalent to the free monad.

Constructors

CoAttrib

Fields

• unCoAttrib :: CoAttr f a

Instances

Functor f => Monad (CoAttrib f)

Methods

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

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

return :: a -> CoAttrib f a

fail :: String -> CoAttrib f a

Functor f => Functor (CoAttrib f)

Methods

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

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

Functor f => Applicative (CoAttrib f)

Methods

pure :: a -> CoAttrib f a

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

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

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

Foldable f => Foldable (CoAttrib f)

Methods

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

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

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

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

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

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

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

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

toList :: CoAttrib f a -> [a]

null :: CoAttrib f a -> Bool

length :: CoAttrib f a -> Int

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

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

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

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

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

Traversable f => Traversable (CoAttrib f)

Methods

traverse :: Applicative f => (a -> f b) -> CoAttrib f a -> f (CoAttrib f b)

sequenceA :: Applicative f => CoAttrib f (f a) -> f (CoAttrib f a)

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

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

(ShowF f, Show a) => Show (CoAttrib f a)

Methods

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

show :: CoAttrib f a -> String

showList :: [CoAttrib f a] -> ShowS