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

Methods

relabeled :: (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) => p (Record a) (f (Record b)) -> p (Record s) (f (Record t))

TypeIndexed Record TIP

Methods

typeIndexed :: (TypeIndexedCxt s t a b, Profunctor p, Functor f) => p (TIP (TagR a)) (f (TIP (TagR b))) -> p (Record s) (f (Record t))

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

Methods

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

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

Methods

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

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

Methods

hMapAux :: f -> Record x -> Record y

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

Methods

hDeleteAtLabel :: Label Record v -> l v' -> l 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

Methods

projected :: ((LabeledOpticType ~ ty) (LabelableTy Record), LabeledOpticP ty p, LabeledOpticF ty f) => p (Record a) (f (Record b)) -> p (Record s) (f (Record t))

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

Methods

hUpdateAtLabel :: Label Record v -> r -> l r' -> l 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

Associated Types

type LabelableTy (s :: [*] -> *) :: LabeledOpticType

Methods

hLens' :: Label x Record -> LabeledOptic x Record s t a b b

((~) * t (Any *), Fail ErrorMessage (FieldNotFound k * l ())) => HasField k l (Record ([] *)) t

XXX

Methods

hLookupByLabel :: Label l (Record [*]) -> t -> v

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

Methods

hLookupByLabel :: Label l (Record ((* ': Tagged k1 l1 v1) r)) -> v -> v

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

Associated Types

type HExtendR t (Record r) :: *

Methods

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

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

This instance allows creating a Record with

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

Methods

hBuild' :: HList l -> Record l'

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

implementation in terms of .<++.

Methods

hUpdateMany :: Record lv -> Record x -> Record x

(HasField k l (Record r) u, HasFieldPath needJust ls u v) => HasFieldPath needJust ((:) * (Label k l) ls) (Record r) v

Methods

hLookupByLabelPath1 :: Proxy Bool needJust -> Label [*] ((* ': Label k l) ls) -> Record r -> v

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

Methods

minBound :: Record r

maxBound :: Record r

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

Methods

(==) :: Record r -> Record r -> Bool

(/=) :: Record r -> Record r -> Bool

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

Methods

compare :: Record r -> Record r -> Ordering

(<) :: Record r -> Record r -> Bool

(<=) :: Record r -> Record r -> Bool

(>) :: Record r -> Record r -> Bool

(>=) :: Record r -> Record r -> Bool

max :: Record r -> Record r -> Record r

min :: Record r -> Record r -> Record r

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

Methods

readsPrec :: Int -> ReadS (Record ((* ': r) rs))

readList :: ReadS [Record ((* ': r) rs)]

readPrec :: ReadPrec (Record ((* ': r) rs))

readListPrec :: ReadPrec [Record ((* ': r) rs)]

ShowComponents r => Show (Record r)

Methods

showsPrec :: Int -> Record r -> ShowS

show :: Record r -> String

showList :: [Record r] -> ShowS

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

Methods

range :: (Record r, Record r) -> [Record r]

index :: (Record r, Record r) -> Record r -> Int

unsafeIndex :: (Record r, Record r) -> Record r -> Int

inRange :: (Record r, Record r) -> Record r -> Bool

rangeSize :: (Record r, Record r) -> Int

unsafeRangeSize :: (Record r, Record r) -> Int

Semigroup (HList r) => Semigroup (Record r)

Methods

(<>) :: Record r -> Record r -> Record r

sconcat :: NonEmpty (Record r) -> Record r

stimes :: Integral b => b -> Record r -> Record r

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

Methods

mempty :: Record r

mappend :: Record r -> Record r -> Record r

mconcat :: [Record r] -> Record r

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

Methods

typeRepsList :: Record xs -> [TypeRep]

((~) [*] 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

Methods

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

(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

Methods

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

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

Subtyping for records

type LabelableTy Record

type LabelableTy Record = LabelableLens

type HExtendR t (Record r)

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

type HAppendR * (Record r1) (Record r2)

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 :: (HAllTaggedLV r1, HLabelSet [*] (LabelsOf r1), Functor f, Profunctor p) => p (Record r1) (f (Record r2)) -> p (HList r1) (f (HList r2))

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

hListRecord' :: (Profunctor p, Functor f, HLabelSet [*] (LabelsOf r), HAllTaggedLV r) => 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 ([] *) = [] *

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

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

type LabelsOf ((:) * (Label k l) 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.

Minimal complete definition

recordValues'

Associated Types

type RecordValuesR r :: [*]

Methods

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

Instances

RecordValues ([] *)

Associated Types

type RecordValuesR ([*] :: [*]) :: [*]

Methods

recordValues' :: HList [*] -> HList (RecordValuesR [*])

(SameLength' * * r (RecordValuesR r), SameLength' * * (RecordValuesR r) r, RecordValues r) => RecordValues ((:) * (Tagged k l v) r)

Associated Types

type RecordValuesR ((* ': Tagged k l v) r :: [*]) :: [*]

Methods

recordValues' :: HList ((* ': Tagged k l v) r) -> HList (RecordValuesR ((* ': 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

Minimal complete definition

showComponents

Methods

showComponents :: String -> HList l -> String

Instances

ShowComponents ([] *)

Methods

showComponents :: String -> HList [*] -> String

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

Methods

showComponents :: String -> HList ((* ': Tagged k l v) r) -> String

class ShowLabel l where

Minimal complete definition

showLabel

Methods

showLabel :: Label l -> String

Instances

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

Equality on labels (descriptions are ignored) Use generic instance

Show label

Methods

showLabel :: Label (Lbl x ns desc) l -> String

Extension

hExtend, hAppend

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

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

Minimal complete definition

hDeleteLabels

Methods

hDeleteLabels

Arguments

:: proxy (ks :: [*])

as provided by labelsOf

-> Record r

-> Record r'

Instances

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

Methods

hDeleteLabels :: proxy ks -> Record [*] -> Record [*]

(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

Methods

hDeleteLabels :: proxy ks -> Record ((* ': Tagged k l v) r1) -> Record 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

Minimal complete definition

hLens

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

Methods

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

Lookup

class HasField (l :: k) 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

Minimal complete definition

hLookupByLabel

Methods

hLookupByLabel :: Label l -> r -> v

Instances

((~) * t (Any *), Fail ErrorMessage (FieldNotFound k * l ())) => HasField k l (Record ([] *)) t

XXX

Methods

hLookupByLabel :: Label l (Record [*]) -> t -> v

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

Methods

hLookupByLabel :: Label l (Record ((* ': Tagged k1 l1 v1) r)) -> v -> v

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

Methods

hLookupByLabel :: Label l (RecordU ls) -> v -> 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.

Methods

hLookupByLabel :: Label l (RecordUS r) -> v -> v

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

Methods

hLookupByLabel :: Label x (Variant vs) -> Maybe a -> v

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

Methods

hLookupByLabel :: Label e (TIP l) -> e' -> v

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

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

Methods

hLookupByLabel :: Label o (TIC l) -> Maybe o -> v

class HasFieldM (l :: k) r (v :: Maybe *) | 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"

Minimal complete definition

hLookupByLabelM

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

Methods

hLookupByLabelM :: Label l (r xs) -> v -> t -> DemoteMaybe t 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

(.@.) :: (SameLength' * * r' r, SameLength' * * r r', HUpdateAtLabel k record l v 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 :: k) (v :: *) (r :: [*]) (r' :: [*]) | l v r -> r', l r' -> v where

hUpdateAtLabel label value record

Minimal complete definition

hUpdateAtLabel

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'

Methods

hUpdateAtLabel :: Label TIP e -> r -> e' r' -> e' r'

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

Methods

hUpdateAtLabel :: Label Record v -> r -> l r' -> l 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

Methods

hUpdateAtLabel :: Label Variant e -> v -> l v' -> l r'

((~) [*] 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'

Methods

hUpdateAtLabel :: Label RecordU v -> r -> l r' -> l 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

(.<.) :: (SameLength' * * r r, HUpdateAtLabel k record l v 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 :: (HExtend (Tagged k2 l2 v2) (r v'), HasField k1 l1 (r v1) v2, HDeleteAtLabel k1 r l1 v1 v') => Label k1 l1 -> Label k2 l2 -> r v1 -> HExtendR (Tagged k2 l2 v2) (r v')

Rename the label of record

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

Projection

type family Labels (xs :: [k]) :: *

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

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' :: (H2ProjectByLabels (LabelsOf l) t r b, HAllTaggedLV r, HLabelSet [*] (LabelsOf r), HLabelSet [*] (LabelsOf l), HRearrange3 (LabelsOf l) r l, SameLength' * * (LabelsOf l) r, SameLength' * * r (LabelsOf l), SameLength' * * r l, SameLength' * * l 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

Minimal complete definition

hLeftUnion

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

Methods

hLeftUnion :: Record l -> Record r -> Record 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

Minimal complete definition

unionSR

Methods

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

Instances

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

Methods

unionSR :: Record r1 -> Record [*] -> (Record r1', Record r1')

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

Methods

unionSR :: Record r1 -> Record ((* ': Tagged k l v) r2') -> (Record ru, Record 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' :: (SameLength' * * l r, SameLength' * * r l, SameLength' * * r (LabelsOf l), SameLength' * * (LabelsOf l) r, HRearrange3 (LabelsOf l) r l, HLabelSet [*] (LabelsOf 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

Minimal complete definition

rearranged

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

Methods

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

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

Methods

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

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

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_ :: (Bounded a, Enum a, Eq 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

Methods

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.

Minimal complete definition

relabeled

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

Methods

relabeled :: (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) => p (Record a) (f (Record b)) -> p (Record s) (f (Record t))

Relabeled Variant

Methods

relabeled :: (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) => p (Variant a) (f (Variant b)) -> p (Variant s) (f (Variant t))

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

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

type ExtraField x = ErrText "extra field" :<>: ErrShowType x

type FieldNotFound key collection = (ErrText "key" :<>: ErrShowType key) :$$: (ErrText "could not be found in" :<>: ErrShowType collection)

Unclassified

Probably internals, that may not be useful

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

Missing from ghc-7.6, because HZip Proxy instances interfere with HZip HList instances.

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 :: Bool) (l :: k) (r :: [*]) v | b l r -> v where

Minimal complete definition

hLookupByLabel'

Methods

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

Instances

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

Methods

hLookupByLabel' :: Proxy Bool l -> Label False ((* ': fld) r) -> HList v -> v

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

Methods

hLookupByLabel' :: Proxy Bool l -> Label True ((* ': Tagged k l v) r) -> HList v -> v

type family DemoteMaybe (d :: *) (v :: Maybe *) :: *

Instances

type DemoteMaybe d (Nothing *)

type DemoteMaybe d (Nothing *) = d

type DemoteMaybe d (Just * a)

type DemoteMaybe d (Just * a) = a

class HasFieldM1 (b :: Maybe [*]) (l :: k) r v | b l r -> v where

Minimal complete definition

hLookupByLabelM1

Methods

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

Instances

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

Methods

hLookupByLabelM1 :: Proxy (Maybe [*]) l -> Label (Nothing [*]) r -> Nothing * -> t -> DemoteMaybe t v

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

Methods

hLookupByLabelM1 :: Proxy (Maybe [*]) l -> Label (Just [*] b) r -> Just * v -> t -> DemoteMaybe t 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

Minimal complete definition

h2projectByLabels

Methods

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

Instances

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

Methods

h2projectByLabels :: proxy [*] -> HList r -> (HList [*], HList r)

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

Methods

h2projectByLabels :: proxy ((* ': l) ls) -> HList [*] -> (HList [*], HList [*])

(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

Methods

h2projectByLabels :: proxy ((* ': l) ls) -> HList ((* ': Tagged k l1 v1) r1) -> (HList rin, HList rout)

class H2ProjectByLabels' (b :: Maybe [*]) (ls :: [*]) r rin rout | b ls r -> rin rout where

Minimal complete definition

h2projectByLabels'

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)

if ls above has labels not in the record, we get labels (rin isSubsetOf ls).

Methods

h2projectByLabels' :: Proxy (Maybe [*]) (Nothing [*]) -> proxy ls -> HList ((* ': f) r) -> (HList rin, HList ((* ': f) rout))

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

Methods

h2projectByLabels' :: Proxy (Maybe [*]) (Just [*] ls1) -> proxy ls -> HList ((* ': f) r) -> (HList ((* ': f) rin), HList rout)

class HLabelSet ls

Relation between HLabelSet and HRLabelSet

instance HLabelSet (LabelsOf ps) => HRLabelSet ps

see also HSet

Instances

HLabelSet [k] ([] k)

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

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

class HLabelSet' l1 l2 (leq :: Bool) r

Instances

Fail * (DuplicatedLabel k3 l1) => HLabelSet' k3 k2 k1 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

Minimal complete definition

hRearrange2

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'

Methods

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

class HRearrange3 (ls :: [*]) r r' | ls r -> r' where

same as HRearrange, except no backwards FD

Minimal complete definition

hRearrange3

Methods

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

Instances

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

Methods

hRearrange3 :: proxy [*] -> HList [*] -> HList [*]

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

For improved error messages

Methods

hRearrange3 :: proxy [*] -> HList ((* ': Tagged k l v) a) -> HList [*]

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

Methods

hRearrange3 :: proxy ((* ': l) ls) -> HList r -> HList r'

class HRearrange4 (l :: *) (ls :: [*]) rin rout r' | l ls rin rout -> r' where

Helper class 2 for hRearrange

Minimal complete definition

hRearrange4

Methods

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

Instances

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

For improved error messages. XXX FieldNotFound

Methods

hRearrange4 :: proxy l -> Proxy [*] ls -> HList [*] -> HList rout -> HList [*]

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

Methods

hRearrange4 :: proxy ll -> Proxy [*] ls -> HList ((* ': Tagged k l v) [*]) -> HList rout -> HList r''

class UnionSymRec' (b :: Bool) r1 f2 r2' ru | b r1 f2 r2' -> ru where

Minimal complete definition

unionSR'

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

Methods

unionSR' :: Proxy Bool False -> Record r1 -> f2 -> Record r2' -> (Record f2ru, Record 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

Methods

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

type HFindLabel (l :: k) (ls :: [*]) (n :: HNat) = 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 :: k) (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 ([] *)

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

type UnLabel a proxy ((:) * (Label a x) xs)

type UnLabel a proxy ((:) * (Label a x) xs) = (:) a x (UnLabel a 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

Methods

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

Methods

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

Minimal complete definition

hZipRecord, hUnzipRecord

Methods

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

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

Instances

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

Methods

hZipRecord :: Record [*] -> Record [*] -> Record [*]

hUnzipRecord :: Record [*] -> (Record [*], Record [*])

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

Methods

hZipRecord :: Record ((* ': Tagged k x a) as) -> Record ((* ': Tagged k x b) bs) -> Record ((* ': Tagged k x (a, b)) abss)

hUnzipRecord :: Record ((* ': Tagged k x (a, b)) abss) -> (Record ((* ': Tagged k x a) as), Record ((* ': Tagged k x b) bs))

alternative implementation

hZipRecord2 :: (SameLength' * * y1 x, SameLength' * * y2 x, SameLength' * * x y2, SameLength' * * x y1, RecordValues y2, RecordValues y1, RecordValues x, HZipList (RecordValuesR y1) (RecordValuesR y2) (RecordValuesR x), HMapAux HList TaggedFn (RecordValuesR x) x, HAllTaggedLV x, SameLabels [*] [*] x y2, SameLabels [*] [*] x y1) => Record y1 -> Record y2 -> 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 :: (SameLength' * * y x2, SameLength' * * y x1, SameLength' * * x1 y, SameLength' * * x2 y, RecordValues x1, RecordValues y, RecordValues x2, HMapAux HList TaggedFn (RecordValuesR x1) x1, HMapAux HList TaggedFn (RecordValuesR x2) x2, HZipList (RecordValuesR x2) (RecordValuesR x1) (RecordValuesR y), HAllTaggedLV x2, HAllTaggedLV x1, SameLabels [*] [*] x2 y, SameLabels [*] [*] x1 y) => Record y -> (Record x2, Record x1)

Orphan instances

((~) [*] (HRevAppR * l ([] *)) lRev, (~) * (HExtendRs * lRev (Proxy [*] ([] *))) (Proxy k l1), (~) k l' l1) => HBuild' l (Proxy k l')

see hEndP

Methods

hBuild' :: HList l -> Proxy k l'