Safe Haskell	None
Language	Haskell2010

Data.Comp.Fixplate

Contents

Basic classes and operations on functors
Compositional data types
Rendering
Making smart constructors

Description

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

Synopsis

class Eq1 (f :: * -> *)
class EqF (f :: * -> *) where
class Show1 (f :: * -> *)
class ShowF (f :: * -> *) where
deriveEq1 :: Name -> Q [Dec]
deriveShow1 :: Name -> Q [Dec]
defaultEqualF :: (Eq1 f, Eq a) => f a -> f a -> Bool
defaultShowsPrecF :: (Show1 f, Show a) => Int -> f a -> ShowS
eqMod :: (EqF f, Functor f, Foldable f) => f a -> f b -> Maybe [(a, b)]
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
- = InL (f a)
- | InR (g a)
class f :<: g where
inject :: f :<: g => f (Term g) -> Term g
project :: f :<: g => Term g -> Maybe (f (Term g))
data HideInj f a
showTerm :: (Functor f, Foldable f, ShowF (HideInj f)) => Term f -> String
showTermU :: (Functor f, Foldable f, ShowF (HideInj f)) => Term f -> String
drawTerm :: (Functor f, Foldable f, ShowF (HideInj f)) => Term f -> IO ()
drawTermU :: (Functor f, Foldable f, ShowF (HideInj f)) => Term f -> IO ()
(.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
(.:.) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
(.::) :: (d -> e) -> (a1 -> a2 -> b -> c -> d) -> a1 -> a2 -> b -> c -> e
(.::.) :: (d -> e) -> (a1 -> a2 -> a3 -> b -> c -> d) -> a1 -> a2 -> a3 -> b -> c -> e
(.:::) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> b -> c -> e

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
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> [a] -> [b] -> Bool #
Eq1 Maybe	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> Maybe a -> Maybe b -> Bool #
Eq1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> Identity a -> Identity b -> Bool #
Eq1 NonEmpty	Since: base-4.10.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> NonEmpty a -> NonEmpty b -> Bool #
Eq1 Tree	Since: containers-0.5.9
Instance details Defined in Data.Tree Methods liftEq :: (a -> b -> Bool) -> Tree a -> Tree b -> Bool #
Eq1 Seq	Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftEq :: (a -> b -> Bool) -> Seq a -> Seq b -> Bool #
Eq1 Set	Since: containers-0.5.9
Instance details 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
Instance details 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
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a0 -> b -> Bool) -> (a, a0) -> (a, b) -> Bool #
Eq1 (Proxy :: * -> *)	Since: base-4.9.0.0
Instance details 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
Instance details 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
Instance details 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)
Instance details 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)
Instance details Defined in Data.Generics.Fixplate.Functor Methods equalF :: Eq a => (f :+: g) a -> (f :+: g) a -> Bool #
(EqF f, EqF g) => EqF (f :*: g)
Instance details 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.
Instance details 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)
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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)
Instance details 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) #
Instance details Defined in Data.Comp.Fixplate Methods showsPrecF :: Show a => Int -> HideInj f a -> ShowS #
(ShowF (HideInj f), ShowF (HideInj g)) => ShowF (HideInj (f :+: g)) #
Instance details Defined in Data.Comp.Fixplate Methods showsPrecF :: Show a => Int -> HideInj (f :+: g) a -> ShowS #
(ShowF f, ShowF g) => ShowF (f :+: g)
Instance details Defined in Data.Generics.Fixplate.Functor Methods showsPrecF :: Show a => Int -> (f :+: g) a -> ShowS #
(ShowF f, ShowF g) => ShowF (f :*: g)
Instance details Defined in Data.Generics.Fixplate.Functor Methods showsPrecF :: Show a => Int -> (f :*: g) a -> ShowS #
(Show a, ShowF f) => ShowF (Ann f a)
Instance details Defined in Data.Generics.Fixplate.Base Methods showsPrecF :: Show a0 => Int -> Ann f a a0 -> ShowS #
(Show a, ShowF f) => ShowF (CoAnn f a)
Instance details 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 Source #

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 Source #

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)] Source #

Compositional data types

type Term = Mu Source #

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

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

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

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

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

Sum of two functors

Constructors

InL (f a)
InR (g a)

Instances

f :<: h => f :<: (h :+: g) Source #	Unlike standard Data Types à la Carte, this instance recurses into the left term. This is due to the left-associativity of `:+:` in Fixplate.
Instance details Defined in Data.Comp.Fixplate Methods inj :: f a -> (h :+: g) a Source # prj :: (h :+: g) a -> Maybe (f a) Source #
f :<: f => f :<: (g :+: f) Source #
Instance details Defined in Data.Comp.Fixplate Methods inj :: f a -> (g :+: f) a Source # prj :: (g :+: f) a -> Maybe (f a) Source #
(ShowF (HideInj f), ShowF (HideInj g)) => ShowF (HideInj (f :+: g)) #
Instance details Defined in Data.Comp.Fixplate Methods showsPrecF :: Show a => Int -> HideInj (f :+: g) a -> ShowS #
(Functor f, Functor g) => Functor (f :+: g)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details Defined in Data.Generics.Fixplate.Functor Methods equalF :: Eq a => (f :+: g) a -> (f :+: g) a -> Bool #
(OrdF f, OrdF g) => OrdF (f :+: g)
Instance details Defined in Data.Generics.Fixplate.Functor Methods compareF :: Ord a => (f :+: g) a -> (f :+: g) a -> Ordering #
(ShowF f, ShowF g) => ShowF (f :+: g)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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 Source #

Minimal complete definition

inj, prj

Methods

inj :: f a -> g a Source #

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

Instances

f :<: f Source #
Instance details Defined in Data.Comp.Fixplate Methods inj :: f a -> f a Source # prj :: f a -> Maybe (f a) Source #
f :<: h => f :<: (h :+: g) Source #	Unlike standard Data Types à la Carte, this instance recurses into the left term. This is due to the left-associativity of `:+:` in Fixplate.
Instance details Defined in Data.Comp.Fixplate Methods inj :: f a -> (h :+: g) a Source # prj :: (h :+: g) a -> Maybe (f a) Source #
f :<: f => f :<: (g :+: f) Source #
Instance details Defined in Data.Comp.Fixplate Methods inj :: f a -> (g :+: f) a Source # prj :: (g :+: f) a -> Maybe (f a) Source #

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

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

Rendering

data HideInj f a Source #

Instances

Functor f => Functor (HideInj f) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details Defined in Data.Comp.Fixplate Methods showsPrecF :: Show a => Int -> HideInj f a -> ShowS #
(ShowF (HideInj f), ShowF (HideInj g)) => ShowF (HideInj (f :+: g)) Source #
Instance details 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 Source #

Represent a Term as an ASCII drawing

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

Represent a Term as a Unicode drawing

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

Display a Term as an ASCII drawing

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

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 #