Data.HList.HListPrelude

The HList library

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

Declarations for various classes and functions that apply for the whole range of heterogeneous collections (HList, TIP, records, etc).

Documentation

class HExtend e l where

Associated Types

type HExtendR e l

Methods

(.*.) :: e -> l -> HExtendR e l infixr 2

Instances

HExtend e (HList l)

Defined in Data.HList.HList

Associated Types

type HExtendR e (HList l)

Methods

(.*.) :: e -> HList l -> HExtendR e (HList l)

HRLabelSet (t ': r) => HExtend t (Record r)

Defined in Data.HList.Record

Associated Types

type HExtendR t (Record r)

Methods

(.*.) :: t -> Record r -> HExtendR t (Record r)

(le ~ Tagged l (Maybe e), HOccursNot (Label l) (LabelsOf v)) => HExtend le (Variant v)

Extension for Variants prefers the first value

(l .=. Nothing) .*. v = v
(l .=. Just e)  .*. _ = mkVariant l e Proxy

Defined in Data.HList.Variant

Associated Types

type HExtendR le (Variant v)

Methods

(.*.) :: le -> Variant v -> HExtendR le (Variant v)

(HRLabelSet (Tagged e e ': l), HTypeIndexed l) => HExtend e (TIP l)

Defined in Data.HList.TIP

Associated Types

type HExtendR e (TIP l)

Methods

(.*.) :: e -> TIP l -> HExtendR e (TIP l)

(me ~ Maybe e, HOccursNot (Tagged e e) l) => HExtend me (TIC l)

Nothing .*. x = x
Just a .*. y = mkTIC a

Defined in Data.HList.TIC

Associated Types

type HExtendR me (TIC l)

Methods

(.*.) :: me -> TIC l -> HExtendR me (TIC l)

(to ~ LabeledTo 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.

Defined in Data.HList.Labelable

Associated Types

type HExtendR (to p q) (Proxy (Lbl n ns desc ': xs))

Methods

(.*.) :: to p q -> Proxy (Lbl n ns desc ': xs) -> HExtendR (to p q) (Proxy (Lbl n ns desc ': xs))

(to ~ LabeledTo x, ToSym (to p q) x) => HExtend (to p q) (Proxy (x ': xs))

Defined in Data.HList.Labelable

Associated Types

type HExtendR (to p q) (Proxy (x ': xs))

Methods

(.*.) :: to p q -> Proxy (x ': xs) -> HExtendR (to p q) (Proxy (x ': xs))

(to ~ LabeledTo x, ToSym (to p q) x) => HExtend (to p q) (Proxy ('[] :: [Type]))

Together with the instance below, this allows writing

makeLabelable "x y z"
p = x .*. y .*. z .*. emptyProxy

Or with HListPP

p = `x .*. `y .*. `z .*. emptyProxy

instead of

p = Proxy :: Proxy ["x","y","z"]

Defined in Data.HList.Labelable

Associated Types

type HExtendR (to p q) (Proxy '[])

Methods

(.*.) :: to p q -> Proxy '[] -> HExtendR (to p q) (Proxy '[])

HExtend (Label (Lbl n ns desc)) (Proxy (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"]

Defined in Data.HList.Label3

Associated Types

type HExtendR (Label (Lbl n ns desc)) (Proxy (x ': xs))

Methods

(.*.) :: Label (Lbl n ns desc) -> Proxy (x ': xs) -> HExtendR (Label (Lbl n ns desc)) (Proxy (x ': xs))

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 () ()]

Defined in Data.HList.Label3

Associated Types

type HExtendR (Label (Lbl n ns desc)) (Proxy (Lbl n' ns' desc' ': xs))

Methods

(.*.) :: Label (Lbl n ns desc) -> Proxy (Lbl n' ns' desc' ': xs) -> HExtendR (Label (Lbl n ns desc)) (Proxy (Lbl n' ns' desc' ': xs))

HExtend (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label3

Associated Types

type HExtendR (Label y) (Proxy (x ': xs))

Methods

(.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs))

HExtend (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label3

Associated Types

type HExtendR (Label y) (Proxy (x ': xs))

Methods

(.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs))

HExtend (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label6

Associated Types

type HExtendR (Label y) (Proxy (x ': xs))

Methods

(.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs))

HExtend (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label3

Associated Types

type HExtendR (Label y) (Proxy (x ': xs))

Methods

(.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs))

HExtend (Label y) (Proxy (x ': xs))

Mixing two label kinds means we have to include Label:

>>> let s = label6 .*. label3 .*. emptyProxy
>>> :t s
s :: Proxy '[Label "6", Label (Lbl 'HZero () ())]

Defined in Data.HList.Label3

Associated Types

type HExtendR (Label y) (Proxy (x ': xs))

Methods

(.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs))

HExtend (Label y) (Proxy (x ': xs))

>>> let labelX = Label :: Label "x"
>>> let labelY = Label :: Label "y"
>>> let p = labelX .*. labelY .*. emptyProxy
>>> :t p
p :: Proxy '["x", "y"]

Defined in Data.HList.Label6

Associated Types

type HExtendR (Label y) (Proxy (x ': xs))

Methods

(.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs))

HExtend (Label x) (Proxy ('[] :: [Type]))

to keep types shorter, .*. used with Proxy avoids producing a Proxy :: Proxy '[Label x,Label y,Label z] if Proxy :: Proxy '[x,y,z] is not a kind error (as it is when mixing Label6 and Label3 labels).

ghc-7.6 does not accept Proxy ('[] :: [k]) so for now require k ~ *

Defined in Data.HList.HListPrelude

Associated Types

type HExtendR (Label x) (Proxy '[])

Methods

(.*.) :: Label x -> Proxy '[] -> HExtendR (Label x) (Proxy '[])

emptyProxy :: Proxy ('[] :: [Type])

similar to emptyRecord, emptyTIP, emptyHList (actually called HNil), except emptyProxy is the rightmost argument to .*.

class SubType l l'

Instances

H2ProjectByLabels (LabelsOf r2) r1 r2 rout => SubType (Record r1 :: Type) (Record r2 :: Type)

Subtyping for records

Defined in Data.HList.Record

(HOccurs e (TIP l1), SubType (TIP l1) (TIP l2)) => SubType (TIP l1 :: Type) (TIP (e ': l2) :: Type)

Defined in Data.HList.TIP

SubType (TIP l :: Type) (TIP ('[] :: [Type]))

Subtyping for TIPs

Defined in Data.HList.TIP

class HAppend l1 l2 where

Methods

hAppend :: l1 -> l2 -> HAppendR l1 l2

Instances

HAppendList l1 l2 => HAppend (HList l1) (HList l2)

Defined in Data.HList.HList

Methods

hAppend :: HList l1 -> HList l2 -> HAppendR (HList l1) (HList l2)

(HRLabelSet (HAppendListR r1 r2), HAppend (HList r1) (HList r2)) => HAppend (Record r1) (Record r2)

(.*.)

Add a field to a record. Analagous to (++) for lists.

record .*. field1
       .*. field2

Defined in Data.HList.Record

Methods

hAppend :: Record r1 -> Record r2 -> HAppendR (Record r1) (Record r2)

(HAppend (HList l) (HList l'), HTypeIndexed (HAppendListR l l')) => HAppend (TIP l) (TIP l')

Defined in Data.HList.TIP

Methods

hAppend :: TIP l -> TIP l' -> HAppendR (TIP l) (TIP l')

type family HAppendR (l1 :: k) (l2 :: k) :: k

poly-kinded, but hAppend only works in cases where the kind variable k is *

Instances

type HAppendR (HList l1 :: Type) (HList l2 :: Type)

Defined in Data.HList.HList

type HAppendR (HList l1 :: Type) (HList l2 :: Type) = HList (HAppendListR l1 l2)

type HAppendR (Record r1 :: Type) (Record r2 :: Type)

Defined in Data.HList.Record

type HAppendR (Record r1 :: Type) (Record r2 :: Type) = Record (HAppendListR r1 r2)

type HAppendR (TIP l :: Type) (TIP l' :: Type)

Defined in Data.HList.TIP

type HAppendR (TIP l :: Type) (TIP l' :: Type) = TIP (HAppendListR l l')

class HOccurs e l where

Methods

hOccurs :: l -> e

Instances

(HOccurrence e (x ': y) l', HOccurs' e l' (x ': y)) => HOccurs e (HList (x ': y))

Defined in Data.HList.HOccurs

Methods

hOccurs :: HList (x ': y) -> e

HasField e (Record (x ': (y ': l))) e => HOccurs e (TIP (x ': (y ': l)))

Defined in Data.HList.TIP

Methods

hOccurs :: TIP (x ': (y ': l)) -> e

tee ~ Tagged e e => HOccurs e (TIP '[tee])

One occurrence and nothing is left

This variation provides an extra feature for singleton lists. That is, the result type is unified with the element in the list. Hence the explicit provision of a result type can be omitted.

Defined in Data.HList.TIP

Methods

hOccurs :: TIP '[tee] -> e

(HasField o (TIC l) mo, mo ~ Maybe o) => HOccurs mo (TIC l)

Defined in Data.HList.TIC

Methods

hOccurs :: TIC l -> mo

class HOccursNot (e :: k) (l :: [k])

Instances

HOccursNot1 e xs xs => HOccursNot (e :: k) (xs :: [k])

Defined in Data.HList.HOccurs

class HProject l l' where

Methods

hProject :: l -> l'

Instances

(HOccurs e l, HProject l (HList l')) => HProject l (HList (e ': l'))

Defined in Data.HList.HOccurs

Methods

hProject :: l -> HList (e ': l')

HProject (HList l) (HList ('[] :: [Type]))

Defined in Data.HList.HOccurs

Methods

hProject :: HList l -> HList '[]

class HType2HNat (e :: k) (l :: [k]) (n :: HNat) | e l -> n

Map a type (key) to a natural (index) within the collection This is a purely type-level computation

Instances

(HEq e1 e b, HType2HNatCase b e1 l n) => HType2HNat (e1 :: Type) (e ': l :: [Type]) n

Map a type to a natural (index within the collection) This is a purely type-level computation

Defined in Data.HList.HTypeIndexed

class HTypes2HNats es l (ns :: [HNat]) | es l -> ns

Instances

HTypes2HNats ('[] :: [Type]) (l :: [Type]) ('[] :: [HNat])

And lift to the list of types

Defined in Data.HList.HTypeIndexed

(HType2HNat e l n, HTypes2HNats es l ns) => HTypes2HNats (e ': es :: [Type]) (l :: [Type]) (n ': ns)

Defined in Data.HList.HTypeIndexed

class HDeleteMany e l l' | e l -> l' where

Delete all elements with the type-level key e from the collection l. Since the key is type-level, it is represented by a Proxy. (polykinded)

Methods

hDeleteMany :: Proxy e -> l -> l'

Instances

HDeleteMany (e :: k) (HList ('[] :: [Type])) (HList ('[] :: [Type]))

Defined in Data.HList.HTypeIndexed

Methods

hDeleteMany :: Proxy e -> HList '[] -> HList '[]

(HEq e1 e b, HDeleteManyCase b e1 e l l1) => HDeleteMany (e1 :: Type) (HList (e ': l)) (HList l1)

Defined in Data.HList.HTypeIndexed

Methods

hDeleteMany :: Proxy e1 -> HList (e ': l) -> HList l1

class HDeleteAtLabel (r :: [*] -> *) (l :: k) v v' | l v -> v' where

Methods

hDeleteAtLabel :: Label l -> r v -> r v'

Instances

H2ProjectByLabels '[Label l] v t1 v' => HDeleteAtLabel Record (l :: k) v v'

Defined in Data.HList.Record

Methods

hDeleteAtLabel :: Label l -> Record v -> Record v'

(HDeleteAtLabel Record e v v', HTypeIndexed v') => HDeleteAtLabel TIP (e :: k) v v'

Defined in Data.HList.TIP

Methods

hDeleteAtLabel :: Label e -> TIP v -> TIP v'

(HDeleteAtHNat n l, HType2HNat e l n, l' ~ HDeleteAtHNatR n l) => HDeleteAtLabel HList (e :: Type) l l'

should this instead delete the first element of that type?

Defined in Data.HList.HTypeIndexed

Methods

hDeleteAtLabel :: Label e -> HList l -> HList l'

class SameLengths [x, y, xy] => HUnzip (r :: [*] -> *) x y xy | x y -> xy, xy -> x y where

unzip

Methods

hUnzip :: r xy -> (r x, r y)

Instances

(SameLengths '[x, y, xy], HZipList x y xy) => HUnzip HList x y xy

Defined in Data.HList.HList

Methods

hUnzip :: HList xy -> (HList x, HList y)

(HZipRecord x y xy, SameLengths '[x, y, xy]) => HUnzip Record x y xy

Defined in Data.HList.Record

Methods

hUnzip :: Record xy -> (Record x, Record y)

(HZipList xL yL xyL, lty ~ (HList xyL -> (HList xL, HList yL)), Coercible lty (TIP xy -> (TIP x, TIP y)), UntagR x ~ xL, TagR xL ~ x, UntagR y ~ yL, TagR yL ~ y, UntagR xy ~ xyL, TagR xyL ~ xy, SameLengths '[x, y, xy], UntagTag x, UntagTag y, UntagTag xy) => HUnzip TIP x y xy

Defined in Data.HList.TIP

Methods

hUnzip :: TIP xy -> (TIP x, TIP y)

(Unvariant '[txy] txy, tx ~ Tagged t x, ty ~ Tagged t y, txy ~ Tagged t (x, y)) => HUnzip Variant '[tx] '[ty] '[txy]

Defined in Data.HList.Variant

Methods

hUnzip :: Variant '[txy] -> (Variant '[tx], Variant '[ty])

(HUnzip Variant (x2 ': xs) (y2 ': ys) (xy2 ': xys), SameLength xs ys, SameLength ys xys, tx ~ Tagged t x, ty ~ Tagged t y, txy ~ Tagged t (x, y)) => HUnzip Variant (tx ': (x2 ': xs)) (ty ': (y2 ': ys)) (txy ': (xy2 ': xys))

Defined in Data.HList.Variant

Methods

hUnzip :: Variant (txy ': (xy2 ': xys)) -> (Variant (tx ': (x2 ': xs)), Variant (ty ': (y2 ': ys)))

HUnzip (Proxy :: [Type] -> Type) ('[] :: [Type]) ('[] :: [Type]) ('[] :: [Type])

Defined in Data.HList.HListPrelude

Methods

hUnzip :: Proxy '[] -> (Proxy '[], Proxy '[])

(lv ~ Tagged l v, HUnzip (Proxy :: [Type] -> Type) ls vs lvs) => HUnzip (Proxy :: [Type] -> Type) (Label l ': ls) (v ': vs) (lv ': lvs)

Defined in Data.HList.HListPrelude

Methods

hUnzip :: Proxy (lv ': lvs) -> (Proxy (Label l ': ls), Proxy (v ': vs))

class HUnzip r x y xy => HZip (r :: [*] -> *) x y xy where

zip. Variant supports hUnzip, but not hZip (hZipVariant returns a Maybe)

Methods

hZip :: r x -> r y -> r xy

Instances

(SameLengths '[x, y, xy], HZipList x y xy) => HZip HList x y xy

Defined in Data.HList.HList

Methods

hZip :: HList x -> HList y -> HList xy

(HZipRecord x y xy, SameLengths '[x, y, xy]) => HZip Record x y xy

>>> let x :: Record '[Tagged "x" Int]; x = undefined
>>> let y :: Record '[Tagged "x" Char]; y = undefined
>>> :t hZip x y
hZip x y :: Record '[Tagged "x" (Int, Char)]

Defined in Data.HList.Record

Methods

hZip :: Record x -> Record y -> Record xy

(HUnzip TIP x y xy, HZipList xL yL xyL, lty ~ (HList xL -> HList yL -> HList xyL), Coercible lty (TIP x -> TIP y -> TIP xy), UntagR x ~ xL, UntagR y ~ yL, UntagR xy ~ xyL, UntagTag x, UntagTag y, UntagTag xy) => HZip TIP x y xy

Defined in Data.HList.TIP

Methods

hZip :: TIP x -> TIP y -> TIP xy

HUnzip (Proxy :: [Type] -> Type) ls vs lvs => HZip (Proxy :: [Type] -> Type) ls vs lvs

Missing from GHC-7.6.3 due to a bug:

let r = hEnd $ hBuild 1 2 3
*Data.HList> hZipList r r
H[(1,1),(2,2),(3,3)]
*Data.HList> hZip r r

<interactive>:30:1:
    Couldn't match type `Label k l' with `Integer'
    When using functional dependencies to combine
      HUnzip
        (Proxy [*]) ((':) * (Label k l) ls) ((':) * v vs) ((':) * lv lvs),
        arising from the dependency `xy -> x y'
        in the instance declaration at Data/HList/HListPrelude.hs:96:10
      HUnzip
        HList
        ((':) * Integer ((':) * Integer ((':) * Integer ('[] *))))
        ((':) * Integer ((':) * Integer ((':) * Integer ('[] *))))
        ((':)
           *
           (Integer, Integer)
           ((':) * (Integer, Integer) ((':) * (Integer, Integer) ('[] *)))),
        arising from a use of `hZip' at <interactive>:30:1-4
    In the expression: hZip r r
    In an equation for `it': it = hZip r r

Defined in Data.HList.HListPrelude

Methods

hZip :: Proxy ls -> Proxy vs -> Proxy lvs