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
   type Constraints (T a) c = (c Int, c a, c (T a))
   buildsRecA For sub rec = 
     [ (ctor "A", A <$> sub (FieldInfo (\(A i _) -> i)) <*> sub (FieldInfo (\(A _ a) -> a)))
     , (ctor "B", 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

The kind of constraints

The ADT type class

class ADT t where

Type class for algebraic data types of kind *. Minimal implementation: ctorIndex and either buildsA if the type t is not recursive, or buildsRecA if the type t is recursive.

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.

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.

-> [(CtorInfo, f t)]

A list of pairs, one for each constructor of type t. Each pair consists of information about the constructor and 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.

-> [(CtorInfo, f t)]

A list of pairs, one for each constructor of type t. Each pair consists of information about the constructor and the result of applicatively applying the constructor to the results of the given functions for each field of the constructor.

Instances

ADT Bool

ADT ()

ADT [a]

ADT (Maybe a)

ADT (Either a b)

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

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

at :: ADT t => [(a, b)] -> t -> b

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) -> [(CtorInfo, t)]

buildsA specialized to the Identity applicative functor.

mbuilds :: forall t c m. (ADT t, Constraints t c, Monoid m) => For c -> (forall s. c s => FieldInfo (t -> s) -> m) -> [(CtorInfo, 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.