Generics.Instant.Base

This module defines the basic representation types and the conversion functions to and from. A typical instance for a user-defined datatype would be:

 -- Example datatype
 data Exp = Const Int | Plus Exp Exp

 -- Auxiliary datatypes for constructor representations
 data Const
 data Plus
 
 instance Constructor Const where conName _ = "Const"
 instance Constructor Plus  where conName _ = "Plus"
 
 -- Representable instance
 instance Representable Exp where
   type Rep Exp = C Const (Var Int) :+: C Plus (Rec Exp :*: Rec Exp)
 
   from (Const n)   = L (C (Var n))
   from (Plus e e') = R (C (Rec e :*: Rec e'))
 
   to (L (C (Var n)))            = Const n
   to (R (C (Rec e :*: Rec e'))) = Plus e e'

Documentation

data Z

data U

Constructors

U

Instances

Read U

Show U

Representable U

HasRec U

Empty U

GEnum U

type Rep U = U

data a :+: b infixr 5

Constructors

L a

R b

Instances

(Read a, Read b) => Read ((:+:) a b)

(Show a, Show b) => Show ((:+:) a b)

(Representable a, Representable b) => Representable ((:+:) a b)

(HasRec a, HasRec b) => HasRec ((:+:) a b)

(HasRec a, Empty a, Empty b) => Empty ((:+:) a b)

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

type Rep ((:+:) a b) = (:+:) a b

data a :*: b infixr 6

Constructors

a :*: b infixr 6

Instances

(Read a, Read b) => Read ((:*:) a b)

(Show a, Show b) => Show ((:*:) a b)

(Representable a, Representable b) => Representable ((:*:) a b)

(HasRec a, HasRec b) => HasRec ((:*:) a b)

(Empty a, Empty b) => Empty ((:*:) a b)

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

type Rep ((:*:) a b) = (:*:) a b

data CEq c p q a where

Constructors

C :: a -> CEq c p p a

Instances

Read a => Read (CEq k k c p p a)

Show a => Show (CEq k k c p q a)

Representable a => Representable (CEq * * c p q a)

HasRec a => HasRec (CEq k k c p q a)

Empty a => Empty (CEq k k c p p a)

GEnum (CEq k k c p q a)

GEnum a => GEnum (CEq k k c p p a)

type Rep (CEq * * c p q a) = CEq * * c p q a

type C c a = CEq c () () a

data Var a

Constructors

Var a

Instances

Read a => Read (Var a)

Show a => Show (Var a)

Representable a => Representable (Var a)

HasRec (Var a)

Empty a => Empty (Var a)

GEnum a => GEnum (Var a)

type Rep (Var a) = Var a

data Rec a

Constructors

Rec a

Instances

Read a => Read (Rec a)

Show a => Show (Rec a)

Representable a => Representable (Rec a)

HasRec (Rec a)

Empty a => Empty (Rec a)

GEnum a => GEnum (Rec a)

type Rep (Rec a) = Rec a

class Constructor c where

Class for datatypes that represent data constructors. For non-symbolic constructors, only conName has to be defined.

Minimal complete definition

conName

Methods

conName :: t c p q a -> String

conFixity :: t c p q a -> Fixity

conIsRecord :: t c p q a -> 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

Datatype to represent the associativy of a constructor.

Constructors

LeftAssociative

RightAssociative

NotAssociative

Instances

Eq Associativity

Ord Associativity

Read Associativity

Show Associativity

Lift Associativity

class Representable a where

Associated Types

type Rep a

Methods

to :: Rep a -> a

from :: a -> Rep a

Instances

Representable Bool

Representable Char

Representable Float

Representable Int

Representable U

Representable [a]

Representable (Maybe a)

Representable a => Representable (Rec a)

Representable a => Representable (Var a)

Representable (a, b)

(Representable a, Representable b) => Representable ((:*:) a b)

(Representable a, Representable b) => Representable ((:+:) a b)

Representable a => Representable (CEq * * c p q a)

type family X c n a :: k2

data Nat

Constructors

Ze

Su Nat