Maintainer | diagrams-discuss@googlegroups.com |
---|---|

Safe Haskell | None |

Heterogeneous lists of monoids.

# Heterogeneous monoidal lists

The idea of *heterogeneous lists* has been around for a long time.
Here, we adopt heterogeneous lists where the element types are all
monoids: this allows us to leave out identity values, so that a
heterogeneous list containing only a single non-identity value can
be created without incurring constraints due to all the other
types, by leaving all the other values out.

The empty heterogeneous list.

Cons for heterogeneous lists.

Missing l | The |

a ::: l | An |

(Action a a', Action (SM a) l) => Action (SM a) (::: a' l) | |

(Eq a, Eq l) => Eq (::: a l) | |

(Ord a, Ord l) => Ord (::: a l) | |

(Show a, Show l) => Show (::: a l) | |

(Semigroup a, Semigroup tl, Monoid tl) => Monoid (::: a tl) | Heterogeneous monoidal lists are themselves instances of |

(Semigroup a, Semigroup tl) => Semigroup (::: a tl) | |

(Monoid a, ToTuple l) => ToTuple (::: a l) | |

MList l => MList (::: a l) | |

(Monoid a, Action (SM a) l2, Action l1 l2) => Action (::: a l1) l2 | |

:>: t a => (::: b t) :>: a | |

(MList t, Monoid a) => (::: a t) :>: a | |

Newtype (QDiagram b v m) (UDTree (UpAnnots v m) (DownAnnots v) (Prim b v)) |

Type class for heterogeneous monoidal lists, with a single method allowing construction of an empty list.

# Converting to tuples

type family Tuple l :: *Source

A type function to compute the tuple-based representation for
instances of `MList`

.

`toTuple`

can be used to convert a heterogeneous list to its
tuple-based representation.

# Accessing embedded values

The relation `l :>: a`

holds when `a`

is the type of an element
in `l`

. For example, `(Char ::: Int ::: Bool ::: Nil) :>: Int`

.

# Monoid actions of heterogeneous lists

Monoidal heterogeneous lists may act on one another as you would expect, with each element in the first list acting on each in the second. Unfortunately, coding this up in type class instances is a bit fiddly.

`SM`

, an abbreviation for "single monoid" (as opposed to a
heterogeneous list of monoids), is only used internally to help
guide instance selection when defining the action of
heterogeneous monoidal lists on each other.

SM m |