regular-0.1: Generic programming library for regular datatypes.Source codeContentsIndex
Generics.Regular.Base
Portabilitynon-portable
Stabilityexperimental
Maintainergenerics@haskell.org
Contents
Functorial structural representation types
Fixed-point type
Type class capturing the structural representation of a type and the corresponding embedding-projection pairs
Description
Summary: Types for structural representation.
Synopsis
data K a r = K {
unK :: a
}
data I r = I {
unI :: r
}
data U r = U
data (f :+: g) r
= L (f r)
| R (g r)
data (f :*: g) r = (f r) :*: (g r)
data C c f r = C {
unC :: f r
}
class Constructor c where
conName :: t c (f :: * -> *) r -> String
conFixity :: t c (f :: * -> *) r -> Fixity
data Fixity
= Prefix
| Infix Associativity Int
data Associativity
= LeftAssociative
| RightAssociative
| NotAssociative
newtype Fix f = In (f (Fix f))
class Regular a where
from :: a -> PF a a
to :: PF a a -> a
type family PF a :: * -> *
Functorial structural representation types
data K a r Source
Structure type for constant values.
Constructors
K
unK :: a
show/hide Instances
Functor (K a)
Fold (K a)
LRBase a => LR (K a)
Show a => GShow (K a)
Eq a => Zip (K a)
CrushR (K a)
GMap (K a)
data I r Source
Structure type for recursive values.
Constructors
I
unI :: r
show/hide Instances
data U r Source
Structure type for empty constructors.
Constructors
U
show/hide Instances
data (f :+: g) r Source
Structure type for alternatives in a type.
Constructors
L (f r)
R (g r)
show/hide Instances
(Functor f, Functor g) => Functor (f :+: g)
(Fold f, Fold g) => Fold (f :+: g)
(LR f, LR g) => LR (f :+: g)
(GShow f, GShow g) => GShow (f :+: g)
(Zip f, Zip g) => Zip (f :+: g)
(CrushR f, CrushR g) => CrushR (f :+: g)
(GMap f, GMap g) => GMap (f :+: g)
data (f :*: g) r Source
Structure type for fields of a constructor.
Constructors
(f r) :*: (g r)
show/hide Instances
(Functor f, Functor g) => Functor (f :*: g)
Fold g => Fold (I :*: g)
Fold g => Fold (K a :*: g)
(LR f, LR g) => LR (f :*: g)
(GShow f, GShow g) => GShow (f :*: g)
(Zip f, Zip g) => Zip (f :*: g)
(CrushR f, CrushR g) => CrushR (f :*: g)
(GMap f, GMap g) => GMap (f :*: g)
data C c f r Source
Structure type to store the name of a constructor.
Constructors
C
unC :: f r
show/hide Instances
Functor f => Functor (C c f)
Fold f => Fold (C c f)
LR f => LR (C c f)
(Constructor c, GShow f) => GShow (C c f)
Zip f => Zip (C c f)
CrushR f => CrushR (C c f)
GMap f => GMap (C c f)
class Constructor c whereSource
Class for datatypes that represent data constructors. For non-symbolic constructors, only conName has to be defined. The weird argument is supposed to be instantiated with C from base, hence the complex kind.
Methods
conName :: t c (f :: * -> *) r -> StringSource
conFixity :: t c (f :: * -> *) r -> FixitySource
data Fixity Source
Datatype to represent the fixity of a constructor. An infix declaration directly corresponds to an application of Infix.
Constructors
Prefix
Infix Associativity Int
show/hide Instances
data Associativity Source
Constructors
LeftAssociative
RightAssociative
NotAssociative
show/hide Instances
Fixed-point type
newtype Fix f Source
The well-known fixed-point type.
Constructors
In (f (Fix f))
Type class capturing the structural representation of a type and the corresponding embedding-projection pairs
class Regular a whereSource

The type class Regular captures the structural representation of a type and the corresponding embedding-projection pairs.

To be able to use the generic functions, the user is required to provide an instance of this type class.

Methods
from :: a -> PF a aSource
to :: PF a a -> aSource
type family PF a :: * -> *Source

The type family PF represents the pattern functor of a datatype.

To be able to use the generic functions, the user is required to provide an instance of this type family.

Produced by Haddock version 2.4.2