Data.Comp.Fixplate

A replacement for the basic machinery in Compdata.

Differences and limitations

Deriving of type classes for base functors

Compdata's macros for deriving are replaced by similar macros from deriving-compat. See the documentation for defaultEqualF and similar functions in the same section.

Co-products and injections

Compdata and Fixplate use different names for equivalent things. For this reason, we export type and pattern synonyms to make the interface as similar to Compdata's as possible.

Unfortunately, :+: is defined as left-associative in Fixplate, which means that injections will look differently. For example, consider a compound base functor F :+: G :+: H. Elements from G are injected differently in the two libraries:

Inr (Inl ...) -- Compdata
InL (InR ...) -- Fixplate

(Note also the difference in capitalization.)

Smart constructors

There are no TemplateHaskell macros for making smart constructors, but the operators from Data.Composition (re-exported by this module) take us a long way towards the same goal. Consider the following base functors:

data Add a        = Add a a          deriving (Functor)
data IfThenElse a = IfThenElse a a a deriving (Functor)

Smart versions of these constructors can now be defined as follows:

(|+|) :: Add :<: f => Term f -> Term f -> Term f
(|+|) = inject .: Add

ite :: IfThenElse :<: f => Term f -> Term f -> Term f -> Term f
ite = inject .:. IfThenElse

Basic classes and operations on functors

class Eq1 (f :: * -> *)

Lifting of the Eq class to unary type constructors.

Since: base-4.9.0.0

Minimal complete definition

liftEq

Instances

Eq1 []

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> [a] -> [b] -> Bool

Eq1 Maybe

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> Maybe a -> Maybe b -> Bool

Eq1 Identity

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> Identity a -> Identity b -> Bool

Eq1 NonEmpty

Since: base-4.10.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> NonEmpty a -> NonEmpty b -> Bool

Eq1 Tree

Since: containers-0.5.9

Defined in Data.Tree

Methods

liftEq :: (a -> b -> Bool) -> Tree a -> Tree b -> Bool

Eq1 Seq

Since: containers-0.5.9

Defined in Data.Sequence.Internal

Methods

liftEq :: (a -> b -> Bool) -> Seq a -> Seq b -> Bool

Eq1 Set

Since: containers-0.5.9

Defined in Data.Set.Internal

Methods

liftEq :: (a -> b -> Bool) -> Set a -> Set b -> Bool

Eq a => Eq1 (Either a)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a0 -> b -> Bool) -> Either a a0 -> Either a b -> Bool

Eq a => Eq1 ((,) a)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a0 -> b -> Bool) -> (a, a0) -> (a, b) -> Bool

Eq1 (Proxy :: * -> *)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> Proxy a -> Proxy b -> Bool

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

Eq a => Eq1 (Const a :: * -> *)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a0 -> b -> Bool) -> Const a a0 -> Const a b -> Bool

(Eq e, Eq1 m) => Eq1 (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

liftEq :: (a -> b -> Bool) -> ErrorT e m a -> ErrorT e m b -> Bool

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

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

Defined in Data.Generics.Fixplate.Functor

Methods

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

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

Defined in Data.Generics.Fixplate.Functor

Methods

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

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

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

Defined in Data.Generics.Fixplate.Base

Methods

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

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

Defined in Data.Generics.Fixplate.Base

Methods

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

class Show1 (f :: * -> *)

Lifting of the Show class to unary type constructors.

Since: base-4.9.0.0

Minimal complete definition

liftShowsPrec

Instances

Show1 []

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

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

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

Show1 Maybe

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Maybe a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Maybe a] -> ShowS

Show1 Identity

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Identity a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Identity a] -> ShowS

Show1 NonEmpty

Since: base-4.10.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> NonEmpty a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [NonEmpty a] -> ShowS

Show1 Tree

Since: containers-0.5.9

Defined in Data.Tree

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Tree a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Tree a] -> ShowS

Show1 Seq

Since: containers-0.5.9

Defined in Data.Sequence.Internal

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Seq a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Seq a] -> ShowS

Show1 Set

Since: containers-0.5.9

Defined in Data.Set.Internal

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Set a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Set a] -> ShowS

Show a => Show1 (Either a)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Either a a0 -> ShowS

liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Either a a0] -> ShowS

Show a => Show1 ((,) a)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> (a, a0) -> ShowS

liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [(a, a0)] -> ShowS

Show1 (Proxy :: * -> *)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy a] -> ShowS

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

Show a => Show1 (Const a :: * -> *)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Const a a0 -> ShowS

liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Const a a0] -> ShowS

(Show e, Show1 m) => Show1 (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ErrorT e m a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ErrorT e m a] -> ShowS

class ShowF (f :: * -> *) where

Minimal complete definition

showsPrecF

Methods

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

Instances

ShowF f => ShowF (HideInj f)

Defined in Data.Comp.Fixplate

Methods

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

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

Defined in Data.Comp.Fixplate

Methods

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

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

Defined in Data.Generics.Fixplate.Functor

Methods

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

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

Defined in Data.Generics.Fixplate.Functor

Methods

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

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

Defined in Data.Generics.Fixplate.Base

Methods

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

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

Defined in Data.Generics.Fixplate.Base

Methods

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

deriveEq1 :: Name -> Q [Dec]

Generates an Eq1 instance declaration for the given data type or data family instance.

deriveShow1 :: Name -> Q [Dec]

Generates a Show1 instance declaration for the given data type or data family instance.

defaultEqualF :: (Eq1 f, Eq a) => f a -> f a -> Bool

Default implementation of equalF

Use as follows:

data F = ...

deriveEq1 ''F -- Requires TemplateHaskell
instance EqF F where equalF = defaultEqualF

defaultShowsPrecF :: (Show1 f, Show a) => Int -> f a -> ShowS

Default implementation of showsPrecF

Use as follows:

data F = ...

deriveShow1 ''F -- Requires TemplateHaskell
instance ShowF F where showsPrecF = defaultShowsPrecF

eqMod :: (EqF f, Functor f, Foldable f) => f a -> f b -> Maybe [(a, b)]

Compositional data types

type Term = Mu

pattern Term :: f (Term f) -> Term f

unTerm :: Term f -> f (Term f)

type (:&:) f a = Ann f a

pattern (:&:) :: f b -> a -> (f :&: a) b

data ((f :: * -> *) :+: (g :: * -> *)) a infixl 6

Sum of two functors

Constructors

InL (f a)

InR (g a)

Instances

f :<: h => f :<: (h :+: g)

Unlike standard Data Types à la Carte, this instance recurses into the left term. This is due to the left-associativity of :+: in Fixplate.

Defined in Data.Comp.Fixplate

Methods

inj :: f a -> (h :+: g) a

prj :: (h :+: g) a -> Maybe (f a)

f :<: f => f :<: (g :+: f)

Defined in Data.Comp.Fixplate

Methods

inj :: f a -> (g :+: f) a

prj :: (g :+: f) a -> Maybe (f a)

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

Defined in Data.Comp.Fixplate

Methods

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

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

Defined in Data.Generics.Fixplate.Functor

Methods

fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b

(<$) :: a -> (f :+: g) b -> (f :+: g) a

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

Defined in Data.Generics.Fixplate.Functor

Methods

fold :: Monoid m => (f :+: g) m -> m

foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m

foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b

foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b

foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b

foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b

foldr1 :: (a -> a -> a) -> (f :+: g) a -> a

foldl1 :: (a -> a -> a) -> (f :+: g) a -> a

toList :: (f :+: g) a -> [a]

null :: (f :+: g) a -> Bool

length :: (f :+: g) a -> Int

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

maximum :: Ord a => (f :+: g) a -> a

minimum :: Ord a => (f :+: g) a -> a

sum :: Num a => (f :+: g) a -> a

product :: Num a => (f :+: g) a -> a

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

Defined in Data.Generics.Fixplate.Functor

Methods

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

sequenceA :: Applicative f0 => (f :+: g) (f0 a) -> f0 ((f :+: g) a)

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

sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a)

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

Defined in Data.Generics.Fixplate.Functor

Methods

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

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

Defined in Data.Generics.Fixplate.Functor

Methods

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

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

Defined in Data.Generics.Fixplate.Functor

Methods

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

(Eq (f a), Eq (g a)) => Eq ((f :+: g) a)

Defined in Data.Generics.Fixplate.Functor

Methods

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

(/=) :: (f :+: g) a -> (f :+: g) a -> Bool

(Ord (f a), Ord (g a)) => Ord ((f :+: g) a)

Defined in Data.Generics.Fixplate.Functor

Methods

compare :: (f :+: g) a -> (f :+: g) a -> Ordering

(<) :: (f :+: g) a -> (f :+: g) a -> Bool

(<=) :: (f :+: g) a -> (f :+: g) a -> Bool

(>) :: (f :+: g) a -> (f :+: g) a -> Bool

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

max :: (f :+: g) a -> (f :+: g) a -> (f :+: g) a

min :: (f :+: g) a -> (f :+: g) a -> (f :+: g) a

(Show (f a), Show (g a)) => Show ((f :+: g) a)

Defined in Data.Generics.Fixplate.Functor

Methods

showsPrec :: Int -> (f :+: g) a -> ShowS

show :: (f :+: g) a -> String

showList :: [(f :+: g) a] -> ShowS

class f :<: g where infix 7

Minimal complete definition

inj, prj

Methods

inj :: f a -> g a

prj :: g a -> Maybe (f a)

Instances

f :<: f

Defined in Data.Comp.Fixplate

Methods

inj :: f a -> f a

prj :: f a -> Maybe (f a)

f :<: h => f :<: (h :+: g)

Unlike standard Data Types à la Carte, this instance recurses into the left term. This is due to the left-associativity of :+: in Fixplate.

Defined in Data.Comp.Fixplate

Methods

inj :: f a -> (h :+: g) a

prj :: (h :+: g) a -> Maybe (f a)

f :<: f => f :<: (g :+: f)

Defined in Data.Comp.Fixplate

Methods

inj :: f a -> (g :+: f) a

prj :: (g :+: f) a -> Maybe (f a)

inject :: f :<: g => f (Term g) -> Term g

project :: f :<: g => Term g -> Maybe (f (Term g))

Rendering

data HideInj f a

Wrapper type with a ShowF instance that does not show injections (InL, InR)

Instances

Functor f => Functor (HideInj f)

Defined in Data.Comp.Fixplate

Methods

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

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

Foldable f => Foldable (HideInj f)

Defined in Data.Comp.Fixplate

Methods

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

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

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

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

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

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

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

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

toList :: HideInj f a -> [a]

null :: HideInj f a -> Bool

length :: HideInj f a -> Int

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

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

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

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

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

Traversable f => Traversable (HideInj f)

Defined in Data.Comp.Fixplate

Methods

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

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

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

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

ShowF f => ShowF (HideInj f)

Defined in Data.Comp.Fixplate

Methods

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

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

Defined in Data.Comp.Fixplate

Methods

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

showTerm :: (Functor f, Foldable f, ShowF (HideInj f)) => Term f -> String

Represent a Term as an ASCII drawing

showTermU :: (Functor f, Foldable f, ShowF (HideInj f)) => Term f -> String

Represent a Term as a Unicode drawing

drawTerm :: (Functor f, Foldable f, ShowF (HideInj f)) => Term f -> IO ()

Display a Term as an ASCII drawing

drawTermU :: (Functor f, Foldable f, ShowF (HideInj f)) => Term f -> IO ()

Display a Term as a Unicode drawing

Making smart constructors

(.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d infixr 8

Compose two functions. f .: g is similar to f . g except that g will be fed two arguments instead of one before handing its result to f.

This function is defined as

(f .: g) x y = f (g x y)

Example usage:

concatMap :: (a -> b) -> [a] -> [b]
concatMap = concat .: map

Notice how two arguments (the function and the list) will be given to map before the result is passed to concat. This is equivalent to:

concatMap f xs = concat (map f xs)

(.:.) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e infixr 8

One compact pattern for composition operators is to "count the dots after the first one", which begins with the common .:, and proceeds by first appending another . and then replacing it with :

(.::) :: (d -> e) -> (a1 -> a2 -> b -> c -> d) -> a1 -> a2 -> b -> c -> e infixr 8

(.::.) :: (d -> e) -> (a1 -> a2 -> a3 -> b -> c -> d) -> a1 -> a2 -> a3 -> b -> c -> e infixr 8

(.:::) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> b -> c -> e infixr 8