Generics.OneLiner.ADT1

This module is for writing generic functions on algebraic data types of kind * -> *. These data types must be an instance of the ADT1 type class.

Here's an example how to write such an instance for this data type:

data T a = A [a] | B a (T a)

instance ADT1 T where
  ctorIndex A{} = 0
  ctorIndex B{} = 1
  ctorInfo _ 0 = ctor "A"
  ctorInfo _ 1 = ctor "B"
  type Constraints T c = (c [], c T)
  buildsRecA _ par sub rec =
    [ A <$> sub (component (\(A l) -> l)
    , B <$> par (param (\(B a _) -> a)) <*> rec (component (\(B _ t) -> t))
    ]

Re-exports

module Generics.OneLiner.Info

data Constraint :: BOX

Instances

Typeable ((* -> *) -> Constraint) Alternative

Typeable ((* -> *) -> Constraint) Applicative

Typeable (* -> Constraint) Monoid

The kind of constraints

The ADT1 type class

class ADT1 t where

Type class for algebraic data types of kind * -> *. Implement either buildsA if the type t is not recursive, or buildsRecA if the type t is recursive.

Minimal complete definition

ctorInfo, (buildsA | buildsRecA)

Associated Types

type Constraints t c :: Constraint

The constraints needed to run buildsA and buildsRecA. It should be a list of all the types of the subcomponents of t, each applied to c.

Methods

ctorIndex :: t a -> Int

Gives the index of the constructor of the given value in the list returned by buildsA and buildsRecA.

ctorInfo :: t a -> Int -> CtorInfo

ctorInfo n gives constructor information, f.e. its name, for the nth constructor. The first argument is a dummy argument and can be (undefined :: t a).

buildsA

Arguments

:: (Constraints t c, Applicative f)

=> for c

Witness for the constraint c.

-> (FieldInfo (Extract t) -> f b)

-> (forall s. c s => FieldInfo (t :~> s) -> f (s b))

-> [f (t b)]

buildsRecA

Arguments

:: (Constraints t c, Applicative f)

=> for c

Witness for the constraint c.

-> (FieldInfo (Extract t) -> f b)

-> (forall s. c s => FieldInfo (t :~> s) -> f (s b))

-> (FieldInfo (t :~> t) -> f (t b))

-> [f (t b)]

Instances

ADT1 []

ADT1 Maybe

class ADT1 t => ADT1Record t

Add an instance for this class if the data type has exactly one constructor.

This class has no methods.

data For c

Tell the compiler which class we want to use in the traversal. Should be used like this:

(For :: For Show)

Where Show can be any class.

Constructors

For

newtype Extract f

Constructors

Extract

Fields

getExtract :: forall x. f x -> x

newtype f :~> g

Constructors

Nat

Fields

getNat :: forall x. f x -> g x

Helper functions

(!) :: t a -> FieldInfo (Extract t) -> a infixl 9

(!~) :: t a -> FieldInfo (t :~> s) -> s a infixl 9

at :: ADT1 t => [a] -> t b -> a

Get the value from the result of one of the builds functions that matches the constructor of t.

param :: (forall a. t a -> a) -> FieldInfo (Extract t)

component :: (forall a. t a -> s a) -> FieldInfo (t :~> s)

Derived traversal schemes

builds :: (ADT1 t, Constraints t c) => for c -> (FieldInfo (Extract t) -> b) -> (forall s. c s => FieldInfo (t :~> s) -> s b) -> [t b]

buildsA specialized to the Identity applicative functor.

mbuilds :: forall t c m for. (ADT1 t, Constraints t c, Monoid m) => for c -> (FieldInfo (Extract t) -> m) -> (forall s. c s => FieldInfo (t :~> s) -> m) -> [m]

buildsA specialized to the Constant applicative functor, which collects monoid values m.

build :: (ADT1Record t, Constraints t c) => for c -> (FieldInfo (Extract t) -> b) -> (forall s. c s => FieldInfo (t :~> s) -> s b) -> t b

builds for data types with exactly one constructor