Generics.Regular.Base

Summary: Types for structural representation.

Functorial structural representation types

newtype K a r

Structure type for constant values.

Constructors

K

Fields

unK :: a

Instances

Functor (K a)

ConNames (K a)

Crush (K a)

Unfold (K a)

Fold (K a)

GMap (K a)

LRBase a => LR (K a)

Eq a => Zip (K a)

Eq a => Eq (K a)

Read a => Read (K a)

CountAtoms (K a)

Show a => Show (K a)

Fold g => Fold (:*: (K a) g)

(Constructor c, Read (K a)) => Read (C c (K a))

newtype I r

Structure type for recursive values.

Constructors

I

Fields

unI :: r

Instances

Functor I

ConNames I

Crush I

Unfold I

Fold I

GMap I

LR I

Zip I

Eq I

Read I

CountAtoms I

Show I

Fold g => Fold (:*: I g)

(Constructor c, Read I) => Read (C c I)

data U r

Structure type for empty constructors.

Constructors

U

Instances

Functor U

ConNames U

Crush U

Unfold U

Fold U

GMap U

LR U

Zip U

Eq U

Read U

Show U

Constructor c => Read (C c U)

data (f :+: g) r

Structure type for alternatives in a type.

Constructors

L (f r)

R (g r)

Instances

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

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

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

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

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

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

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

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

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

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

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

data (f :*: g) r

Structure type for fields of a constructor.

Constructors

(f r) :*: (g r)

Instances

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

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

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

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

Fold g => Fold (:*: I g)

Fold g => Fold (:*: (K a) g)

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

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

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

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

(Constructor c, CountAtoms f, CountAtoms g, Read f, Read g) => Read (C c (:*: f g))

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

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

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

data C c f r

Structure type to store the name of a constructor.

Constructors

C

Fields

unC :: f r

Instances

Functor f => Functor (C c f)

(ConNames f, Constructor c) => ConNames (C c f)

Crush f => Crush (C c f)

Unfold f => Unfold (C c f)

Fold f => Fold (C c f)

GMap f => GMap (C c f)

LR f => LR (C c f)

Zip f => Zip (C c f)

Eq f => Eq (C c f)

(Constructor c, CountAtoms f, CountAtoms g, Read f, Read g) => Read (C c (:*: f g))

(Constructor c, Read (S s f)) => Read (C c (S s f))

(Constructor c, Read (K a)) => Read (C c (K a))

(Constructor c, Read I) => Read (C c I)

Constructor c => Read (C c U)

(Constructor c, Show f) => Show (C c f)

data S l f r

Structure type to store the name of a record selector.

Constructors

S

Fields

unS :: f r

Instances

Functor f => Functor (S c f)

ConNames (S s f)

Crush f => Crush (S s f)

Unfold f => Unfold (S s f)

Fold f => Fold (S s f)

GMap f => GMap (S s f)

LR f => LR (S s f)

Zip f => Zip (S s f)

Eq f => Eq (S s f)

(Selector s, Read f) => Read (S s f)

(Constructor c, Read (S s f)) => Read (C c (S s f))

CountAtoms f => CountAtoms (S s f)

(Selector s, Show f) => Show (S s f)

class Constructor c where

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 -> String

conFixity :: t c (f :: * -> *) r -> Fixity

conIsRecord :: t c (f :: * -> *) r -> Bool

data Fixity

Datatype to represent the fixity of a constructor. An infix declaration directly corresponds to an application of Infix.

Constructors

Prefix

Infix Associativity Int

Instances

Eq Fixity

Ord Fixity

Read Fixity

Show Fixity

Lift Fixity

data Associativity

Constructors

LeftAssociative

RightAssociative

NotAssociative

Instances

Eq Associativity

Ord Associativity

Read Associativity

Show Associativity

Lift Associativity

class Selector s where

Methods

selName :: t s (f :: * -> *) r -> String

Fixed-point type

newtype Fix f

The well-known fixed-point type.

Constructors

In

Fields

out :: f (Fix f)

Type class capturing the structural representation of a type and the corresponding embedding-projection pairs

class Regular a where

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 a

to :: PF a a -> a

type family PF a :: * -> *

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.