Generics.OneLiner.ADT

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

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

data T a = A Int a | B a (T a)

instance ADT (T a) where
  ctorIndex A{} = 0
  ctorIndex B{} = 1
  ctorInfo _ 0 = ctor "A"
  ctorInfo _ 1 = ctor "B"
  type Constraints (T a) c = (c Int, c a, c (T a))
  buildsRecA _ sub rec =
    [ A <$> sub (FieldInfo (\(A i _) -> i)) <*> sub (FieldInfo (\(A _ a) -> a))
    , B <$> sub (FieldInfo (\(B a _) -> a)) <*> rec (FieldInfo (\(B _ t) -> t))
    ]

And this is how you would write generic equality, using the All monoid:

eqADT :: (ADT t, Constraints t Eq) => t -> t -> Bool
eqADT s t = ctorIndex s == ctorIndex t &&
  getAll (mbuilds (For :: For Eq) (\fld -> All $ s ! fld == t ! fld) `at` s)

Re-exports

module Generics.OneLiner.Info

data Constraint :: BOX

Instances

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

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

Typeable (* -> Constraint) Monoid

The kind of constraints

The ADT type class

class ADT 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 -> Int

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

ctorInfo :: t -> 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).

buildsA

Arguments

:: (Constraints t c, Applicative f)

=> for c

Witness for the constraint c.

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

This function should return a value for each subcomponent of t, wrapped in an applicative functor f. It is given information about the field, which contains a projector function to get the subcomponent from a value of type t. The type of the subcomponent is an instance of class c.

-> [f t]

A list of results, one for each constructor of type t. Each element is the result of applicatively applying the constructor to the results of the given function for each field of the constructor.

buildsRecA

Arguments

:: (Constraints t c, Applicative f)

=> for c

Witness for the constraint c.

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

This function should return a value for each subcomponent of t, wrapped in an applicative functor f. It is given information about the field, which contains a projector function to get the subcomponent from a value of type t. The type of the subcomponent is an instance of class c.

-> (FieldInfo (t -> t) -> f t)

This function should return a value for each subcomponent of t that is itself of type t.

-> [f t]

A list of results, one for each constructor of type t. Each element is the result of applicatively applying the constructor to the results of the given function for each field of the constructor.

Instances

ADT Bool

ADT ()

ADT [a]

ADT (Maybe a)

ADT (Either a b)

ADT (a, b)

ADT (a, b, c)

ADT (a, b, c, d)

class ADT t => ADTRecord t

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

This class has no methods.

Instances

ADTRecord ()

ADTRecord (a, b)

ADTRecord (a, b, c)

ADTRecord (a, b, c, d)

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

Helper functions

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

Get the subcomponent by using the projector from the field information.

at :: ADT t => [a] -> t -> a

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

Derived traversal schemes

builds :: (ADT t, Constraints t c) => for c -> (forall s. c s => FieldInfo (t -> s) -> s) -> [t]

buildsA specialized to the Identity applicative functor.

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

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

gmap :: (ADT t, Constraints t c) => for c -> (forall s. c s => s -> s) -> t -> t

Transform a value by transforming each subcomponent.

gfoldMap :: (ADT t, Constraints t c, Monoid m) => for c -> (forall s. c s => s -> m) -> t -> m

Fold a value, by mapping each subcomponent to a monoid value and collecting those.

gtraverse :: (ADT t, Constraints t c, Applicative f) => for c -> (forall s. c s => s -> f s) -> t -> f t

Applicative traversal given a way to traverse each subcomponent.

...for single constructor data types

build :: (ADTRecord t, Constraints t c) => for c -> (forall s. c s => FieldInfo (t -> s) -> s) -> t

builds for data types with exactly one constructor

op0 :: (ADTRecord t, Constraints t c) => for c -> (forall s. c s => s) -> t

Derive a 0-ary operation by applying the operation to every subcomponent.

op1 :: (ADTRecord t, Constraints t c) => for c -> (forall s. c s => s -> s) -> t -> t

Derive a unary operation by applying the operation to every subcomponent.

op2 :: (ADTRecord t, Constraints t c) => for c -> (forall s. c s => s -> s -> s) -> t -> t -> t

Derive a binary operation by applying the operation to every subcomponent.