HList- Heterogeneous lists

Safe HaskellNone




The HList library

(C) 2004-2006, Oleg Kiselyov, Ralf Laemmel, Keean Schupke

A model of labels as needed for extensible records. As before, all the information about labels is recorded in their type, so the labels of records may be purely phantom. In general, Labels are exclusively type-level entities and have no run-time representation.

Record labels are triplets of type-level naturals, namespace, and description. The namespace part helps avoid confusions between labels from different Haskell modules. The description is an arbitrary nullary type constructor.

For the sake of printing, the description is required to be the instance of Show. One must make sure that the show functions does not examine the value, as descr is purely phantom. Here's an example of the good Label description:

    data MyLabelDescr; instance Show MyLabelDescr where show _ = "descr"

which are automated by makeLabels3 from Data.HList.MakeLabel.

This model even allows the labels in a record to belong to different namespaces. To this end, the model employs the predicate for type equality.



>>> let label3 = Label :: Label (Lbl HZero () ())
>>> let label6 = Label :: Label "6"

data Lbl x ns desc Source


(HEqBy * HNat HLeFn n m b, (~) * ns ns') => HEqBy * * HLeFn (Lbl n ns desc) (Lbl m ns' desc') b

Data.HList.Label3 labels can only be compared if they belong to the same namespace.

(~) * (Label k t) (Label * (Lbl ix ns n)) => SameLabels * * (Label k t) (Lbl ix ns n) 
Show desc => ShowLabel * (Lbl x ns desc)

Equality on labels (descriptions are ignored) Use generic instance

Show label

Show desc => Show (Label * (Lbl x ns desc)) 
Typeable (HNat -> * -> * -> *) Lbl 
((~) (* -> * -> *) to (LabeledTo Symbol x), ToSym (to p q) x) => HExtend (to p q) (Proxy [*] ((:) * (Lbl n ns desc) xs))

if the proxy has Data.HList.Label3.Lbl, then everything has to be wrapped in Label to make the kinds match up.

HExtend (Label * (Lbl n ns desc)) (Proxy [Symbol] ((:) Symbol x xs))

Mixing two label kinds means we have to include Label:

>>> let r = label3 .*. label6 .*. emptyProxy
>>> :t r
r :: Proxy '[Label (Lbl 'HZero () ()), Label "6"]
HExtend (Label * (Lbl n ns desc)) (Proxy [*] ((:) * (Lbl n' ns' desc') xs))

If possible, Label is left off:

>>> let q = label3 .*. label3 .*. emptyProxy
>>> :t q
q :: Proxy '[Lbl 'HZero () (), Lbl 'HZero () ()]
type ZipTagged * ((:) * (Lbl ix ns n) ts) ((:) * v vs) = (:) * (Tagged * (Lbl ix ns n) v) (ZipTagged * ts vs) 
type HExtendR (to p q) (Proxy [*] ((:) * (Lbl n ns desc) xs)) 
type HExtendR (Label * (Lbl n ns desc)) (Proxy [Symbol] ((:) Symbol x xs)) = Proxy [*] ((:) * (Label * (Lbl n ns desc)) (MapLabel Symbol ((:) Symbol x xs))) 
type HExtendR (Label * (Lbl n ns desc)) (Proxy [*] ((:) * (Lbl n' ns' desc') xs)) = Proxy [*] ((:) * (Lbl n ns desc) ((:) * (Lbl n' ns' desc') xs)) 

Public constructors for labels

firstLabel :: ns -> desc -> Label (Lbl HZero ns desc) Source

Construct the first label

nextLabel :: Label (Lbl x ns desc) -> desc' -> Label (Lbl (HSucc x) ns desc') Source

Construct the next label

type family MapLabel xs :: [*] Source

similar to Data.HList.Record.Labels1, but avoids producing Label (Label x)


type MapLabel k ([] k) = [] * 
type MapLabel k ((:) k x xs) = (:) * (AddLabel k x) (MapLabel k xs) 

type family AddLabel x :: * Source


AddLabel (Label x) = Label x 
AddLabel x = Label x