one-liner-0.4.1: Constraint-based generics

Description

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)
```

Synopsis

# Re-exports

data Constraint :: BOX

Instances

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

The kind of constraints

# The `ADT` type class

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

Associated Types

type Constraints t c :: Constraint Source

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 Source

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

ctorInfo :: t -> Int -> CtorInfo Source

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

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.

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

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

This class has no methods.

Instances

data For c Source

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 Source

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

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

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] Source

`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] Source

`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 Source

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 Source

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 Source

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 Source

`builds` for data types with exactly one constructor

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

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 Source

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 Source

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