Documentation

Heterogeneous list type. Construct like so:

x = (5 :: Int) :- 'a' :- True :- Nil

Append two heterogeneous lists. Of course, as HeteroLists know their type, this produces a new type.

Synonym for '(++)'.

Applies a constraint c to a type of HeteroList a. So you want to write this:

(HeteroListConstraintT c t) => HeteroList t

not

HeteroListConstraintT c (HeteroList t)  => HeteroList t

Constraint which requires the argument to be a HeteroList

Get the type of the first element of a HeteroList

Get the type of the tail of a HeteroList.

Gets the types of the HeteroList. Naturally this is a list of types of type [*].

An analogue to concat

The analogue of map. Not you'll need to pass a Poly as the function. A more complex example is included in the function hap.

The analogue of concatMap, or >>= ("bind") from Monad. It's just hmap followed by hconcat.

This constraints c, which is intended to be the argument of a Poly, to be a constraint which allows one to map between the two HeteroLists of type a and b

Applies every function in the HeteroList of Polys in the first argument to the HeteroList which is the second argument. This is much like hap except the result list is not "flattened" by hconcat

This is the analogue of ap, or 'Control.Applicative.<*>. Arguments are the same as hmapfl, but the result is flattened.

Here's an example usage:

>>> triple = Poly @((IsHomoFunc 1) &&& ((Arg 0) `IxConstrainBy` Num)) (*3)
>>> compareZero = Poly @((IsFunc 1) &&& ((Arg 0) `IxConstrainBy` (Num &&& Ord)) &&& ((Result 1) `IxIs` Ordering)) (`compare` 0)
>>> greaterThanZero = Poly @((IsFunc 1) &&& ((Arg 0) `IxConstrainBy` (Num &&& Ord)) &&& ((Result 1) `IxIs` Bool)) (> 0)

>>> f = triple :- compareZero :- greaterThanZero :- Nil
>>> x = (42 :: Int) :- (-100 :: Float) :- (22 % 7 :: Rational) :- Nil

>>> f `hap` x
[126, -300.0, 66 % 7, GT, LT, GT, True, False, True]

Note that

The type of a concatenated list. Note, like HeteroListConstraintT you need to apply this type function to the parameter to HeteroList.

Naturally, if (and only if) a HeteroList is actually homogeneous, we can turn it into an ordinary list.

IsHomogeneousList a t

constraints a 'HeteroList t' to have elements only of type a.

i.e.

IsHomogeneousList Int t => HeteroList t

means the HeteroList only has elements of type Int.

Length of a HeteroList. I'm not sure if this can be done in constant time as the type defines the length, but currently it just does the usual traverse the list and count.

Type level length the paramter of a HeteroList