Data.HList.Record

The HList library

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

Extensible records

The three-ish models of labels that go with this module;

• Data.HList.Label3
• Data.HList.Label5
• Data.HList.Label6
• Data.HList.Labelable

These used to work:

• Data.HList.Label1
• Data.HList.Label2
• Data.HList.Label4

labels used for doctests

>>> let x = Label :: Label "x"
>>> let y = Label :: Label "y"
>>> let z = Label :: Label "z"

Records

Labels

Record types as label-value pairs, where label is purely phantom. Thus the run-time representation of a field is the same as that of its value, and the record, at run-time, is indistinguishable from the HList of field values. At run-time, all information about the labels is erased.

The type from Data.Tagged is used.

module Data.Tagged

(.=.) :: Label l -> v -> Tagged l v infixr 4

Create a value with the given label. Analagous to a data constructor such as Just, Left, or Right. Higher fixity than record-modification operations like (.*.), (.-.), etc. to support expression like the below w/o parentheses:

>>> x .=. "v1" .*. y .=. '2' .*. emptyRecord
Record{x="v1",y='2'}

Record

newtype Record r

Constructors

Record (HList r)

Instances

Relabeled Record

TypeIndexed Record TIP

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

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

HMapAux HList (HFmap f) x y => HMapAux Record f x y

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

(H2ProjectByLabels (LabelsOf a) s a_ _s_minus_a, HRLabelSet a_, HRLabelSet a, HRearrange (LabelsOf a) a_ a, HLeftUnion b s bs, HRLabelSet bs, HRearrange (LabelsOf t) bs t, HRLabelSet t) => Projected Record s t a b

Lens rs rt ra rb

where rs ~ Record s, rt ~ Record t, ra ~ Record a, rb ~ Record b

(HUpdateAtLabel2 k l v r r', HasField k l (Record r') v) => HUpdateAtLabel k Record l v r r'

HLens k x Record s t a b => Labelable k x Record s t a b

make a Lens (Record s) (Record t) a b

(HEqK k k1 l l1 b, HasField' k b l ((:) * (Tagged k1 l1 v1) r) v) => HasField k l (Record ((:) * (Tagged k l1 v1) r)) v

H2ProjectByLabels (LabelsOf r2) r1 r2 rout => SubType * * (Record r1) (Record r2)

Subtyping for records

Fail * (FieldNotFound k l) => HasField k l (Record ([] *)) (FieldNotFound k l)

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

(HReverse l lRev, HMapTaggedFn lRev l') => HBuild' l (Record l')

This instance allows creating Record with

hBuild 3 a :: Record '[Tagged "x" Int, Tagged "y" Char]

(HLeftUnion lv x lvx, HRLabelSet x, HLabelSet [*] (LabelsOf x), HRearrange (LabelsOf x) lvx x) => HUpdateMany lv (Record x)

implementation in terms of .<++.

Bounded (HList r) => Bounded (Record r)

Eq (HList r) => Eq (Record r)

DataRecordCxt a => Data (Record a)

Ord (HList r) => Ord (Record r)

(HMapCxt HList ReadComponent (AddProxy [*] rs) bs, ApplyAB ReadComponent (Proxy * r) readP_r, HProxies rs, HSequence ReadP ((:) * readP_r bs) ((:) * r rs)) => Read (Record ((:) * r rs))

ShowComponents r => Show (Record r)

Ix (HList r) => Ix (Record r)

Monoid (HList r) => Monoid (Record r)

TypeRepsList (HList xs) => TypeRepsList (Record xs)

((~) [*] la (LabelsOf a), (~) [*] lt (LabelsOf t), HRearrange la s a, HRearrange lt b t, HLabelSet [*] la, HLabelSet [*] lt) => Rearranged [*] Record s t a b

Iso (Record s) (Record t) (Record a) (Record b)

where s is a permutation of a, b is a permutation of t. In practice sameLabels and sameLength are likely needed on both sides of rearranged, to avoid ambiguous types.

An alternative implementation:

rearranged x = iso hRearrange' hRearrange' x

(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

Typeable ([*] -> *) Record

type LabelableTy Record = LabelableLens

type HExtendR t (Record r) = Record ((:) * t r)

type HAppendR * (Record r1) (Record r2) = Record (HAppendListR * r1 r2)

mkRecord :: HRLabelSet r => HList r -> Record r

Build a record

emptyRecord :: Record []

Build an empty record

hEndR :: Record a -> Record a

serves the same purpose as hEnd

hEndP :: Proxy (xs :: [k]) -> Proxy xs

hEndP $ hBuild label1 label2

is one way to make a Proxy of labels (for use with asLabelsOf for example). Another way is

label1 .*. label2 .*. emptyProxy

hListRecord :: (HLabelSet [*] (LabelsOf r), HAllTaggedLV r, Profunctor p, Functor f) => p (Record r) (f (Record t)) -> p (HList r) (f (HList t))

HRLabelSet t => Iso (HList s) (HList t) (Record s) (Record t)

hListRecord' :: (Profunctor p, Functor f) => p (Record r) (f (Record r)) -> p (HList r) (f (HList r))

Iso' (HList s) (Record s)

Getting Labels

type family LabelsOf ls :: [*]

Construct the (phantom) list of labels of a record, or list of Label.

Instances

type LabelsOf ([] *) = [] *

type LabelsOf ((:) * (Tagged k l v) r) = (:) * (Label k l) (LabelsOf r)

type LabelsOf ((:) * (Label k l) r) = (:) * (Label k l) (LabelsOf r)

labelsOf :: hlistOrRecord l -> Proxy (LabelsOf l)

asLabelsOf :: (HAllTaggedLV x, SameLabels x y, SameLength x y) => r x -> s y -> r x

similar to asTypeOf:

>>> let s0 = Proxy :: Proxy '["x", "y"]
>>> let s1 = Proxy :: Proxy '[Label "x", Label "y"]
>>> let s2 = Proxy :: Proxy '[Tagged "x" Int, Tagged "y" Char]

>>> let f0 r = () where _ = r `asLabelsOf` s0
>>> let f1 r = () where _ = r `asLabelsOf` s1
>>> let f2 r = () where _ = r `asLabelsOf` s2

>>> :t f0
f0 :: r '[Tagged "x" v, Tagged "y" v1] -> ()

>>> :t f1
f1 :: r '[Tagged "x" v, Tagged "y" v1] -> ()

>>> :t f2
f2 :: r '[Tagged "x" v, Tagged "y" v1] -> ()

Getting Values

class SameLength r (RecordValuesR r) => RecordValues r where

Construct the HList of values of the record.

Associated Types

type RecordValuesR r :: [*]

Methods

recordValues' :: HList r -> HList (RecordValuesR r)

Instances

RecordValues ([] *)

RecordValues r => RecordValues ((:) * (Tagged k l v) r)

recordValues :: RecordValues r => Record r -> HList (RecordValuesR r)

hMapTaggedFn :: HMapTaggedFn a b => HList a -> Record b

"inverse" to recordValues

unlabeled0 :: (RecordValues y, RecordValues x, HMapAux HList TaggedFn (RecordValuesR y) y, SameLabels [*] [*] x y, Profunctor p, Functor f) => p (HList (RecordValuesR x)) (f (HList (RecordValuesR y))) -> p (Record x) (f (Record y))

Iso (Record s) (Record t) (HList a) (HList b)

view unlabeled == recordValues

type Unlabeled x y = (HMapCxt HList TaggedFn (RecordValuesR y) y, RecordValues x, RecordValues y, SameLength (RecordValuesR x) (RecordValuesR y), SameLength x y, SameLabels x y, HAllTaggedLV x, HAllTaggedLV y)

unlabeled :: (Unlabeled x y, Profunctor p, Functor f) => (HList (RecordValuesR x) `p` f (HList (RecordValuesR y))) -> Record x `p` f (Record y)

type Unlabeled' x = Unlabeled x x

unlabeled' :: (Unlabeled' x, Profunctor p, Functor f) => (HList (RecordValuesR x) `p` f (HList (RecordValuesR x))) -> Record x `p` f (Record x)

Unlabeled' x => Iso' (Record x) (HList (RecordValuesR x))

Operations

Show

A corresponding Show instance exists as

show x = "Record {" ++ showComponents "" x ++ "}"

class ShowComponents l where

Methods

showComponents :: String -> HList l -> String

Instances

ShowComponents ([] *)

(ShowLabel k l, Show v, ShowComponents r) => ShowComponents ((:) * (Tagged k l v) r)

class ShowLabel l where

Methods

showLabel :: Label l -> String

Instances

Typeable * x => ShowLabel * x

Equality on labels

Show label

KnownNat x => ShowLabel Nat x

KnownSymbol x => ShowLabel Symbol x

Show desc => ShowLabel * (Lbl x ns desc)

Equality on labels (descriptions are ignored) Use generic instance

Show label

Extension

hExtend, hAppend

(.*.) :: HExtend e l => e -> l -> HExtendR e l

Delete

hDeleteAtLabel label record

(.-.) :: HDeleteAtLabel r l xs xs' => r xs -> Label l -> r xs' infixl 2

Remove a field from a record. At the same level as other record modification options (.*.). Analagous to (\\) in lists.

record1 .-. label1

label1 .=. value1 .*.
label2 .=. value2 .-.
label2 .*.
emptyRecord

label1 .=. value1 .-.
label1 .*.
label2 .=. value2 .*.
emptyRecord

record1 .*. label1 .=. record2 .!. label1
        .*. label2 .=. record2 .!. label2
        .-. label1

class HDeleteLabels ks r r' | ks r -> r' where

Methods

hDeleteLabels

Arguments

:: proxy (ks :: [*])

as provided by labelsOf

-> Record r

-> Record r'

Instances

HDeleteLabels ks ([] *) ([] *)

(HMember * (Label k l) ks b, HCond b (Record r2) (Record ((:) * (Tagged k l v) r2)) (Record r3), HDeleteLabels ks r1 r2) => HDeleteLabels ks ((:) * (Tagged k l v) r1) r3

Lookup/update

Lens-based setters/getters are popular. hLens packages up hUpdateAtLabel and hLookupByLabel.

Refer to examples/lens.hs and examples/labelable.hs for examples.

class HLensCxt x r s t a b => HLens x r s t a b | x s b -> t, x t a -> s, x s -> a, x t -> b where

Methods

hLens :: Label x -> forall f. Functor f => (a -> f b) -> r s -> f (r t)

hLens :: Label x -> Lens (r s) (r t) a b

Instances

HLensCxt k r x s t a b => HLens k r x s t a b

Lookup

class HasField l r v | l r -> v where

This is a baseline implementation. We use a helper class, HasField, to abstract from the implementation.

Because hLookupByLabel is so frequent and important, we implement it separately, more efficiently. The algorithm is familiar assq, only the comparison operation is done at compile-time

Methods

hLookupByLabel :: Label l -> r -> v

Instances

((~) * e e', HasField * e (Record l) e') => HasField * e (TIP l) e'

(HEqK k k1 l l1 b, HasField' k b l ((:) * (Tagged k1 l1 v1) r) v) => HasField k l (Record ((:) * (Tagged k l1 v1) r)) v

(IArray UArray v, (~) * v (GetElemTy ls), HFindLabel k l ls n, HNat2Integral n) => HasField k l (RecordU ls) v

(HFindLabel k l r n, HLookupByHNatUS n u (Tagged k l v), HasField k l (Record r) v, RecordUSCxt r u) => HasField k l (RecordUS r) v

works expected. See examples attached to bad.

HasField * o (Variant l) (Maybe o) => HasField * o (TIC l) (Maybe o)

Public destructor (or, open union's projection function)

(HasField k x (Record vs) a, HFindLabel k x vs n, HNat2Integral n) => HasField k x (Variant vs) (Maybe a)

Fail * (FieldNotFound k l) => HasField k l (Record ([] *)) (FieldNotFound k l)

class HasFieldM l r v | l r -> v where

a version of HasField hLookupByLabel .!. that returns a default value when the label is not in the record:

>>> let r = x .=. "the x value" .*. emptyRecord

>>> hLookupByLabelM y r ()
()

>>> hLookupByLabelM x r ()
"the x value"

Methods

hLookupByLabelM

Arguments

:: Label l

-> r

Record (or Variant,TIP,TIC)

-> t

default value

-> DemoteMaybe t v

Instances

(HMemberM * (Label k l) (LabelsOf xs) b, HasFieldM1 k b l (r xs) v) => HasFieldM k l (r xs) v

(.!.) :: HasField l r v => r -> Label l -> v infixr 9

Lookup a value in a record by its label. Analagous to (!!), the list indexing operation. Highest fixity, like (!!).

>>> :{
let record1 = x .=. 3 .*.
              y .=. 'y' .*.
              emptyRecord
:}

>>> record1 .!. x
3

>>> record1 .!. y
'y'

>>> :{
let r2 = y .=. record1 .!. x .*.
         z .=. record1 .!. y .*.
         emptyRecord
:}

>>> r2
Record{y=3,z='y'}

Note that labels made following Data.HList.Labelable allow using "Control.Lens.^." instead.

Update

(.@.) :: (HUpdateAtLabel k record l v r r', SameLength' * * r' r, SameLength' * * r r') => Tagged k l v -> record r -> record r' infixr 2

Update a field with a particular value. Same fixity as (.*.) so that extensions and updates can be chained. There is no real list analogue, since there is no Prelude defined update.

label1 .=. value1 .@. record1

class HUpdateAtLabel record l v r r' | l v r -> r', l r' -> v where

hUpdateAtLabel label value record

Methods

hUpdateAtLabel :: SameLength r r' => Label l -> v -> record r -> record r'

Instances

(HUpdateAtLabel * Record e' e r r', HTypeIndexed r', (~) * e e') => HUpdateAtLabel * TIP e' e r r'

(HUpdateAtLabel2 k l v r r', HasField k l (Record r') v) => HUpdateAtLabel k Record l v r r'

HUpdateVariantAtLabelCxt k l e v v' n _e => HUpdateAtLabel k Variant l e v v'

hUpdateAtLabel x e' (mkVariant x e proxy) == mkVariant x e' proxy
hUpdateAtLabel y e' (mkVariant x e proxy) == mkVariant x e  proxy

((~) [*] r r', (~) * v (GetElemTy r), HFindLabel k l r n, HNat2Integral n, IArray UArray v, HasField k l (Record r') v) => HUpdateAtLabel k RecordU l v r r'

type-preserving versions

Note: these restrict the resulting record type to be the same as in input record type, which can help reduce the number of type annotations needed

(.<.) :: (HUpdateAtLabel k record l v r r, SameLength' * * r r) => Tagged k l v -> record r -> record r infixr 2

The same as .@., except type preserving. It has the same fixity as (.@.).

type HTPupdateAtLabel record l v r = (HUpdateAtLabel record l v r r, SameLength' r r)

hTPupdateAtLabel :: HTPupdateAtLabel record l v r => Label l -> v -> record r -> record r

We could also say:

hTPupdateAtLabel l v r = hUpdateAtLabel l v r `asTypeOf` r

Then we were taking a dependency on Haskell's type equivalence. This would also constrain the actual implementation of hUpdateAtLabel.

A variation on hUpdateAtLabel: type-preserving update.

Rename Label

hRenameLabel :: (HasField k l (r v) v1, HExtend (Tagged k1 l1 v1) (r v'), HDeleteAtLabel k r l v v') => Label k l -> Label k1 l1 -> r v -> HExtendR (Tagged k1 l1 v1) (r v')

Rename the label of record

>>> hRenameLabel x y (x .=. () .*. emptyRecord)
Record{y=()}

Projection

type family Labels xs :: *

A helper to make the Proxy needed by hProjectByLabels, and similar functions which accept a list of kind [*].

For example:

(rin,rout) = hProjectByLabels2 (Proxy :: Labels ["x","y"]) r

behaves like

rin = r .!. (Label :: Label "x") .*.
      r .!. (Label :: Label "y") .*.
      emptyRecord

rout = r .-. (Label :: Label "x") .-. (Label :: Label "y")

Instances

type Labels k xs

It is also an important operation: the basis of many deconstructors -- so we try to implement it efficiently.

hProjectByLabels :: (HRLabelSet a, H2ProjectByLabels ls t a b) => proxy ls -> Record t -> Record a

hProjectByLabels ls r returns r with only the labels in ls remaining

hProjectByLabels' :: (HLabelSet [*] (LabelsOf l), HLabelSet [*] (LabelsOf r), H2ProjectByLabels (LabelsOf l) t r b, HRearrange3 (LabelsOf l) r l, SameLength' * * (LabelsOf l) r, SameLength' * * l r, SameLength' * * r (LabelsOf l), SameLength' * * r l, HAllTaggedLV r) => Record t -> Record l

hProjectByLabels2 :: (H2ProjectByLabels ls t t1 t2, HRLabelSet t1, HRLabelSet t2) => Proxy ls -> Record t -> (Record t1, Record t2)

See H2ProjectByLabels

a lens for projection

see Data.HList.Labelable.Projected

Unions

Left

class HLeftUnion r r' r'' | r r' -> r'' where

Methods

hLeftUnion :: Record r -> Record r' -> Record r''

Instances

(HDeleteLabels (LabelsOf l) r r', HAppend (Record l) (Record r'), (~) * (HAppendR * (Record l) (Record r')) (Record lr)) => HLeftUnion l r lr

(.<++.) :: HLeftUnion r r' r'' => Record r -> Record r' -> Record r'' infixl 1

Similar to list append, so give this slightly lower fixity than (.*.), so we can write:

field1 .=. value .*. record1 .<++. record2

Symmetric

Compute the symmetric union of two records r1 and r2 and return the pair of records injected into the union (ru1, ru2).

To be more precise, we compute the symmetric union type ru of two record types r1 and r2. The emphasis on types is important.

The two records (ru1,ru2) in the result of unionSR have the same type ru, but they are generally different values. Here the simple example: suppose

 r1 = (Label .=. True)  .*. emptyRecord
 r2 = (Label .=. False) .*. emptyRecord

Then unionSR r1 r2 will return (r1,r2). Both components of the result are different records of the same type.

To project from the union ru, use hProjectByLabels. It is possible to project from the union obtaining a record that was not used at all when creating the union.

We do assure however that if unionSR r1 r2 gave (r1u,r2u), then projecting r1u onto the type of r1 gives the value identical to r1. Ditto for r2.

class UnionSymRec r1 r2 ru | r1 r2 -> ru where

Methods

unionSR :: Record r1 -> Record r2 -> (Record ru, Record ru)

Instances

(~) [*] r1 r1' => UnionSymRec r1 ([] *) r1'

(HMemberLabel k l r1 b, UnionSymRec' b r1 (Tagged k l v) r2' ru) => UnionSymRec r1 ((:) * (Tagged k l v) r2') ru

Reorder Labels

hRearrange :: (HLabelSet ls, HRearrange ls r r') => Proxy ls -> Record r -> Record r'

Rearranges a record by labels. Returns the record r, rearranged such that the labels are in the order given by ls. (LabelsOf r) must be a permutation of ls.

hRearrange' :: (HLabelSet [*] (LabelsOf l), HRearrange3 (LabelsOf l) r l, SameLength' * * (LabelsOf l) r, SameLength' * * l r, SameLength' * * r (LabelsOf l), SameLength' * * r l) => Record r -> Record l

hRearrange' is hRearrange where ordering specified by the Proxy argument is determined by the result type.

With built-in haskell records, these e1 and e2 have the same type:

data R = R { x, y :: Int }
e1 = R{ x = 1, y = 2}
e2 = R{ y = 2, x = 1}

hRearrange' can be used to allow either ordering to be accepted:

h1, h2 :: Record [ Tagged "x" Int, Tagged "y" Int ]
h1 = hRearrange' $
    x .=. 1 .*.
    y .=. 2 .*.
    emptyRecord

h2 = hRearrange' $
    y .=. 2 .*.
    x .=. 1 .*.
    emptyRecord

isos using hRearrange

class Rearranged r s t a b where

Methods

rearranged :: (Profunctor p, Functor f) => (r a `p` f (r b)) -> r s `p` f (r t)

Instances

((~) [*] la (LabelsOf a), (~) [*] lt (LabelsOf t), HRearrange la s a, HRearrange lt b t, HLabelSet [*] la, HLabelSet [*] lt) => Rearranged [*] Record s t a b

Iso (Record s) (Record t) (Record a) (Record b)

where s is a permutation of a, b is a permutation of t. In practice sameLabels and sameLength are likely needed on both sides of rearranged, to avoid ambiguous types.

An alternative implementation:

rearranged x = iso hRearrange' hRearrange' x

(SameLength * * s a, ExtendsVariant s a, SameLength * * b t, ExtendsVariant b t) => Rearranged [*] Variant s t a b

rearranged' :: (Rearranged k r s s b b, Profunctor p, Functor f) => p (r b) (f (r b)) -> p (r s) (f (r s))

Iso' (r s) (r a)

where s is a permutation of a

Apply a function to all values

hMapR :: (HMapAux HList (HFmap f) x y, SameLength' * * y x, SameLength' * * x y) => f -> Record x -> Record y

map over the values of a record. This is a shortcut for

\ f (Record a) -> Record (hMap (HFmap f) a)

Example

suppose we have a function that should be applied to every element of a record:

>>> let circSucc_ x | x == maxBound = minBound | otherwise = succ x

>>> :t circSucc_
circSucc_ :: (Eq a, Enum a, Bounded a) => a -> a

Use a shortcut (Fun) to create a value that has an appropriate ApplyAB instance:

>>> let circSucc = Fun circSucc_ :: Fun '[Eq,Enum,Bounded] '()

Confirm that we got Fun right:

>>> :t applyAB circSucc
applyAB circSucc :: (Bounded b, Enum b, Eq b) => b -> b

>>> applyAB circSucc True
False

define the actual record:

>>> let r = x .=. 'a' .*. y .=. False .*. emptyRecord
>>> r
Record{x='a',y=False}

>>> hMapR circSucc r
Record{x='b',y=True}

newtype HMapR f

Constructors

HMapR f

Instances

(HMapCxt Record f x y, (~) * rx (Record x), (~) * ry (Record y)) => ApplyAB (HMapR f) rx ry

cast labels

class Relabeled r where

Iso (Record s) (Record t) (Record a) (Record b), such that relabeled = unlabeled . from unlabeled

in other words, pretend a record has different labels, but the same values.

Methods

relabeled :: forall p f s t a b. (HMapTaggedFn (RecordValuesR s) a, HMapTaggedFn (RecordValuesR b) t, SameLengths `[s, a, t, b]`, RecordValuesR t ~ RecordValuesR b, RecordValuesR s ~ RecordValuesR a, RecordValues b, RecordValues s, Profunctor p, Functor f) => (r a `p` f (r b)) -> r s `p` f (r t)

Instances

Relabeled Record

Relabeled Variant

relabeled' :: (Relabeled r, RecordValues b, RecordValues a, RecordValues s, HMapAux HList TaggedFn (RecordValuesR s) a, HMapAux HList TaggedFn (RecordValuesR s) s, SameLength' * * (RecordValuesR s) a, SameLength' * * b s, SameLength' * * a (RecordValuesR s), SameLength' * * a s, SameLength' * * s b, SameLength' * * s a, Profunctor p, Functor f, (~) [*] (RecordValuesR b) (RecordValuesR s), (~) [*] (RecordValuesR a) (RecordValuesR s)) => p (r a) (f (r b)) -> p (r s) (f (r s))

Iso' (Record s) (Record a)

such that RecordValuesR s ~ RecordValuesR a

Hints for type errors

data DuplicatedLabel l

Property of a proper label set for a record: no duplication of labels, and every element of the list is Tagged label value

data ExtraField l

data FieldNotFound l

Instances

Fail * (FieldNotFound k l) => HasField k l (Record ([] *)) (FieldNotFound k l)

Unclassified

Probably internals, that may not be useful

zipTagged :: (MapLabel ts ~ lts, HZip Proxy lts vs tvs) => Proxy ts -> proxy vs -> Proxy tvs

a variation on hZip for Proxy, where the list of labels does not have to include Label (as in ts')

>>> let ts = Proxy :: Proxy ["x","y"]
>>> let ts' = Proxy :: Proxy [Label "x",Label "y"]
>>> let vs = Proxy :: Proxy [Int,Char]

>>> :t zipTagged ts Proxy
zipTagged ts Proxy :: Proxy '[Tagged "x" y, Tagged "y" y1]

>>> :t zipTagged ts vs
zipTagged ts vs :: Proxy '[Tagged "x" Int, Tagged "y" Char]

And and the case when hZip does the same thing:

>>> :t zipTagged ts' vs
zipTagged ts' vs :: Proxy '[Tagged "x" Int, Tagged "y" Char]

>>> :t hZip ts' vs
hZip ts' vs :: Proxy '[Tagged "x" Int, Tagged "y" Char]

class HasField' b l r v | b l r -> v where

Methods

hLookupByLabel' :: Proxy b -> Label l -> HList r -> v

Instances

HasField k l (Record r) v => HasField' k False l ((:) * fld r) v

HasField' k True l ((:) * (Tagged k l v) r) v

type family DemoteMaybe d v :: *

Instances

type DemoteMaybe d (Nothing *) = d

type DemoteMaybe d (Just * a) = a

class HasFieldM1 b l r v | b l r -> v where

Methods

hLookupByLabelM1 :: Proxy b -> Label l -> r -> t -> DemoteMaybe t v

Instances

HasFieldM1 k (Nothing [*]) l r (Nothing *)

HasField k l r v => HasFieldM1 k (Just [*] b) l r (Just * v)

class H2ProjectByLabels ls r rin rout | ls r -> rin rout where

Invariant:

r === rin `disjoint-union` rout
labels rin === ls
    where (rin,rout) = hProjectByLabels ls r

Methods

h2projectByLabels :: proxy ls -> HList r -> (HList rin, HList rout)

Instances

H2ProjectByLabels ([] *) r ([] *) r

H2ProjectByLabels ((:) * l ls) ([] *) ([] *) ([] *)

(HMemberM * (Label k l1) ((:) * l ls) b, H2ProjectByLabels' b ((:) * l ls) ((:) * (Tagged k l1 v1) r1) rin rout) => H2ProjectByLabels ((:) * l ls) ((:) * (Tagged k l1 v1) r1) rin rout

class H2ProjectByLabels' b ls r rin rout | b ls r -> rin rout where

Methods

h2projectByLabels' :: Proxy b -> proxy ls -> HList r -> (HList rin, HList rout)

Instances

H2ProjectByLabels ls r rin rout => H2ProjectByLabels' (Nothing [*]) ls ((:) * f r) rin ((:) * f rout)

H2ProjectByLabels ls1 r rin rout => H2ProjectByLabels' (Just [*] ls1) ls ((:) * f r) ((:) * f rin) rout

class HLabelSet ls

Relation between HLabelSet and HRLabelSet

instance HLabelSet (LabelsOf ps) => HRLabelSet ps

see also HSet

Instances

HLabelSet [k] ([] k)

(HEqK k k l1 l2 leq, HLabelSet' k k [k] l1 l2 leq r) => HLabelSet [k] ((:) k l1 ((:) k l2 r))

HLabelSet [k] ((:) k x ([] k))

class HLabelSet' l1 l2 leq r

Instances

Fail * (DuplicatedLabel k l1) => HLabelSet' k k k l1 l2 True r

(HLabelSet [k] ((:) k l2 r), HLabelSet [k] ((:) k l1 r)) => HLabelSet' k k [k] l1 l2 False r

class (HLabelSet (LabelsOf ps), HAllTaggedLV ps) => HRLabelSet ps

Instances

(HLabelSet [*] (LabelsOf ps), HAllTaggedLV ps) => HRLabelSet ps

class HAllTaggedLV ps

The Record, Variant, TIP, TIC type constructors only make sense when they are applied to an instance of this class

Instances

HAllTaggedLV ([] *)

(HAllTaggedLV xs, (~) * x (Tagged k t v)) => HAllTaggedLV ((:) * x xs)

class (HRearrange3 ls r r', LabelsOf r' ~ ls, SameLength ls r, SameLength r r') => HRearrange ls r r' | ls r -> r', r' -> ls where

Helper class for hRearrange

Methods

hRearrange2 :: proxy ls -> HList r -> HList r'

Instances

(HRearrange3 ls r r', (~) [*] (LabelsOf r') ls, SameLength * * ls r, SameLength * * r r') => HRearrange ls r r'

class HRearrange3 ls r r' | ls r -> r' where

same as HRearrange, except no backwards FD

Methods

hRearrange3 :: proxy ls -> HList r -> HList r'

Instances

HRearrange3 ([] *) ([] *) ([] *)

Fail * (ExtraField k l) => HRearrange3 ([] *) ((:) * (Tagged k l v) a) ([] *)

For improved error messages

(H2ProjectByLabels ((:) * l ([] *)) r rin rout, HRearrange4 l ls rin rout r', (~) * l (Label k ll)) => HRearrange3 ((:) * l ls) r r'

class HRearrange4 l ls rin rout r' | l ls rin rout -> r' where

Helper class 2 for hRearrange

Methods

hRearrange4 :: proxy l -> Proxy ls -> HList rin -> HList rout -> HList r'

Instances

Fail * (FieldNotFound * l) => HRearrange4 l ls ([] *) rout ([] *)

For improved error messages

(HRearrange3 ls rout r', (~) [*] r'' ((:) * (Tagged k l v) r'), (~) * ll (Label k l)) => HRearrange4 ll ls ((:) * (Tagged k l v) ([] *)) rout r''

class UnionSymRec' b r1 f2 r2' ru | b r1 f2 r2' -> ru where

Methods

unionSR' :: Proxy b -> Record r1 -> f2 -> Record r2' -> (Record ru, Record ru)

Instances

(UnionSymRec r1 r2' ru, HExtend f2 (Record ru), (~) * (Record f2ru) (HExtendR f2 (Record ru))) => UnionSymRec' False r1 f2 r2' f2ru

(UnionSymRec r1 r2' ru, HTPupdateAtLabel k Record l2 v2 ru, (~) * f2 (Tagged k l2 v2)) => UnionSymRec' True r1 f2 r2' ru

Field f2 is already in r1, so it will be in the union of r1 with the rest of r2.

To inject (HCons f2 r2) in that union, we should replace the field f2

type HFindLabel l ls n = HFind l (UnLabel l (LabelsOf ls)) n

A version of HFind where the ls type variable is a list of Tagged or Label. This is a bit indirect, and ideally LabelsOf could have kind [*] -> [k].

labelLVPair :: Tagged l v -> Label l

Label accessor

newLVPair :: Label l -> v -> Tagged l v

type family UnLabel proxy ls :: [k]

remove the Label type constructor. The proxy argument is supplied to make it easier to fix the kind variable k.

Instances

type UnLabel k proxy ([] *) = [] k

type UnLabel k proxy ((:) * (Label k x) xs) = (:) k x (UnLabel k proxy xs)

type HMemberLabel l r b = HMember l (UnLabel l (LabelsOf r)) b

data TaggedFn

Constructors

TaggedFn

Instances

(~) * tx (Tagged k t x) => ApplyAB TaggedFn x tx

data ReadComponent

Instances

(Read v, ShowLabel k l, (~) * x (Tagged k l v), (~) * (ReadP x) y) => ApplyAB ReadComponent (Proxy * x) y

type HMapTaggedFn l r = (HMapCxt HList TaggedFn l r, RecordValuesR r ~ l, RecordValues r)

type HLensCxt x r s t a b = (HasField x (r s) a, HUpdateAtLabel r x b s t, HasField x (r t) b, HUpdateAtLabel r x a t s, SameLength s t, SameLabels s t)

constraints needed to implement HLens

zip

use the more general HZip class instead

class HZipRecord x y xy | x y -> xy, xy -> x y where

Methods

hZipRecord :: Record x -> Record y -> Record xy

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

Instances

HZipRecord ([] *) ([] *) ([] *)

HZipRecord as bs abss => HZipRecord ((:) * (Tagged k x a) as) ((:) * (Tagged k x b) bs) ((:) * (Tagged k x (a, b)) abss)

alternative implementation

hZipRecord2 :: (RecordValues y1, RecordValues y, RecordValues x, HMapAux HList TaggedFn (RecordValuesR x) x, HZipList (RecordValuesR y1) (RecordValuesR y) (RecordValuesR x), SameLength' * * y1 x, SameLength' * * y x, SameLength' * * x y1, SameLength' * * x y, SameLabels [*] [*] x y1, SameLabels [*] [*] x y, HAllTaggedLV x) => Record y1 -> Record y -> Record x

instead of explicit recursion above, we could define HZipRecord in terms of HZipList. While all types are inferred, this implementation is probably slower, so explicit recursion is used in the HZip Record instance.

hUnzipRecord2 :: (RecordValues y, RecordValues x1, RecordValues x, HMapAux HList TaggedFn (RecordValuesR x) x, HMapAux HList TaggedFn (RecordValuesR x1) x1, HZipList (RecordValuesR x) (RecordValuesR x1) (RecordValuesR y), SameLength' * * y x1, SameLength' * * y x, SameLength' * * x1 y, SameLength' * * x y, SameLabels [*] [*] x1 y, SameLabels [*] [*] x y, HAllTaggedLV x1, HAllTaggedLV x) => Record y -> (Record x, Record x1)