Data.HList.RecordU

The public interface is exported from RecordU

Type definitions

RecordUS

newtype RecordUS (x :: [*])

RecordUS is stored as a HList of RecordU to allow the RecordUS to contain elements of different types, so long all of the types can be put into an unboxed array (UArray).

It is advantageous (at least space-wise) to sort the record to keep elements with the same types elements adjacent. See SortForRecordUS for more details.

Constructors

RecordUS Any

Any here is the HList u given RecordUSCxt x u

Instances

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

works expected. See examples attached to bad.

Defined in Data.HList.RecordU

Methods

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

(RecordUSCxt x u, Show (HList u)) => Show (RecordUS x)

Defined in Data.HList.RecordU

Methods

showsPrec :: Int -> RecordUS x -> ShowS

show :: RecordUS x -> String

showList :: [RecordUS x] -> ShowS

class RecordUSCxt (x :: [*]) (u :: [*]) | x -> u, u -> x where

connect the unpacked x representation with the corresponding list of RecordU u representation.

Minimal complete definition

Nothing

Methods

recordUSToHList :: RecordUS x -> HList u

O(1) should be possible to implement this without unsafeCoerce, but we want to hide the u parameter _and_ keep the RecordUSCxt as a class (instead of a type family) because of HEq. In some cases it is possible to have instances that do not actually respect the functional dependency, but this should be safe if the check is not disabled (by using -XDysfunctionalDependencies https://phabricator.haskell.org/D69, or ghc-7.6)

hListToRecordUS :: HList u -> RecordUS x

O(1) should be possible to implement this without unsafeCoerce

Instances

(HGroupBy EqTagValue x g, HMapUnboxF g u) => RecordUSCxt x u

the only instance

Defined in Data.HList.RecordU

Methods

recordUSToHList :: RecordUS x -> HList u

hListToRecordUS :: HList u -> RecordUS x

data EqTagValue

Instances

HEqByFn EqTagValue

Defined in Data.HList.RecordU

(txv ~ Tagged x v, tyw ~ Tagged y w, HEq v w b) => HEqBy EqTagValue (txv :: Type) (tyw :: Type) b

Defined in Data.HList.RecordU

class HMapUnboxF (xs :: [*]) (us :: [*]) | xs -> us, us -> xs

proof that hMap UnboxF :: r xs -> r us can determine xs from us and us from xs

Instances

HMapUnboxF ('[] :: [Type]) ('[] :: [Type])

Defined in Data.HList.RecordU

HMapUnboxF xs us => HMapUnboxF (HList x ': xs) (RecordU x ': us)

Defined in Data.HList.RecordU

RecordU

newtype RecordU l

A type which behaves similarly to Record, except all elements must fit in the same UArray. A consequence of this is that RecordU has the following properties:

• it is strict in the element types
• it cannot do type-changing updates of RecordU, except if the function applies to all elements
• it probably is slower to update the very first elements of the RecordU

The benefit is that lookups should be faster and records should take up less space. However benchmarks done with a slow HNat2Integral do not suggest that RecordU is faster than Record.

Constructors

RecordU (UArray Int (GetElemTy l))

Instances

(ApplyAB f (GetElemTy x) (GetElemTy y), IArray UArray (GetElemTy y), IArray UArray (GetElemTy x)) => HMapAux RecordU f x y

Defined in Data.HList.RecordU

Methods

hMapAux :: f -> RecordU x -> RecordU y

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

Defined in Data.HList.RecordU

Methods

hUpdateAtLabel :: Label l -> v -> RecordU r -> RecordU r'

(s ~ t, a ~ b, IArray UArray a, a ~ GetElemTy s, HLensCxt x RecordU s t a b) => Labelable (x :: k) RecordU s t a b

make a Lens' (RecordU s) a

Defined in Data.HList.RecordU

Associated Types

type LabelableTy RecordU :: LabeledOpticType

Methods

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

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

Defined in Data.HList.RecordU

Methods

hLookupByLabel :: Label l -> RecordU ls -> v

(RecordValues lv, HList2List (RecordValuesR lv) v, HFindMany (LabelsOf lv) (LabelsOf r) ixs, IArray UArray v, v ~ GetElemTy r, HNats2Integrals ixs) => HUpdateMany lv (RecordU r)

Defined in Data.HList.RecordU

Methods

hUpdateMany :: Record lv -> RecordU r -> RecordU r

Eq (UArray Int (GetElemTy l)) => Eq (RecordU l)

Defined in Data.HList.RecordU

Methods

(==) :: RecordU l -> RecordU l -> Bool

(/=) :: RecordU l -> RecordU l -> Bool

Ord (UArray Int (GetElemTy l)) => Ord (RecordU l)

Defined in Data.HList.RecordU

Methods

compare :: RecordU l -> RecordU l -> Ordering

(<) :: RecordU l -> RecordU l -> Bool

(<=) :: RecordU l -> RecordU l -> Bool

(>) :: RecordU l -> RecordU l -> Bool

(>=) :: RecordU l -> RecordU l -> Bool

max :: RecordU l -> RecordU l -> RecordU l

min :: RecordU l -> RecordU l -> RecordU l

Read (UArray Int (GetElemTy l)) => Read (RecordU l)

Defined in Data.HList.RecordU

Methods

readsPrec :: Int -> ReadS (RecordU l)

readList :: ReadS [RecordU l]

readPrec :: ReadPrec (RecordU l)

readListPrec :: ReadPrec [RecordU l]

Show (UArray Int (GetElemTy l)) => Show (RecordU l)

Defined in Data.HList.RecordU

Methods

showsPrec :: Int -> RecordU l -> ShowS

show :: RecordU l -> String

showList :: [RecordU l] -> ShowS

HMapUnboxF xs us => HMapUnboxF (HList x ': xs) (RecordU x ': us)

Defined in Data.HList.RecordU

type LabelableTy RecordU

Defined in Data.HList.RecordU

type LabelableTy RecordU = 'LabelableLens

type family GetElemTy (x :: [*]) :: *

Instances

type GetElemTy (Tagged label v ': rest)

Defined in Data.HList.RecordU

type GetElemTy (Tagged label v ': rest) = v

class SortForRecordUS x x' | x -> x' where

Reorders a Record such that the RecordUS made from it takes up less space

Bad has alternating Double and Int fields

>>> bad
Record{x=1.0,i=2,y=3.0,j=4}

4 arrays containing one element each are needed when this Record is stored as a RecordUS

>>> recordToRecordUS bad
RecordUS H[RecordU (array (0,0) [(0,1.0)]),RecordU (array (0,0) [(0,2)]),RecordU (array (0,0) [(0,3.0)]),RecordU (array (0,0) [(0,4)])]

It is possible to sort the record

>>> sortForRecordUS bad
Record{x=1.0,y=3.0,i=2,j=4}

This allows the same content to be stored in two unboxed arrays

>>> recordToRecordUS (sortForRecordUS bad)
RecordUS H[RecordU (array (0,1) [(0,1.0),(1,3.0)]),RecordU (array (0,1) [(0,2),(1,4)])]

Methods

sortForRecordUS :: Record x -> Record x'

Instances

SortForRecordUS ('[] :: [Type]) ('[] :: [Type])

Defined in Data.HList.RecordU

Methods

sortForRecordUS :: Record '[] -> Record '[]

(HPartitionEq EqTagValue x (x ': xs) xi xo, SortForRecordUS xo xo', sorted ~ HAppendListR xi xo', HAppendList xi xo') => SortForRecordUS (x ': xs) sorted

Defined in Data.HList.RecordU

Methods

sortForRecordUS :: Record (x ': xs) -> Record sorted

Lookup

class HLookupByHNatUS (n :: HNat) (us :: [*]) (e :: *) | n us -> e where

Methods

hLookupByHNatUS :: Proxy n -> HList us -> e

Instances

(r ~ HSubtract (HLength u) n, RecordU u ~ ru, HLookupByHNatUS1 r n u us e) => HLookupByHNatUS n (ru ': us) e

Defined in Data.HList.RecordU

Methods

hLookupByHNatUS :: Proxy n -> HList (ru ': us) -> e

class HLookupByHNatUS1 (r :: Either HNat HNat) (n :: HNat) (u :: [*]) (us :: [*]) (e :: *) | r n u us -> e where

Methods

hLookupByHNatUS1 :: Proxy r -> Proxy n -> RecordU u -> HList us -> e

Instances

(HNat2Integral n, HLookupByHNatR n u ~ le, le ~ Tagged l e, IArray UArray e, e ~ GetElemTy u) => HLookupByHNatUS1 ('Left t :: Either HNat HNat) n u us le

Defined in Data.HList.RecordU

Methods

hLookupByHNatUS1 :: Proxy ('Left t) -> Proxy n -> RecordU u -> HList us -> le

HLookupByHNatUS t us e => HLookupByHNatUS1 ('Right t :: Either HNat HNat) n u us e

Defined in Data.HList.RecordU

Methods

hLookupByHNatUS1 :: Proxy ('Right t) -> Proxy n -> RecordU u -> HList us -> e

type family HSubtract (n1 :: HNat) (n2 :: HNat) :: Either HNat HNat

HSubtract a b is Left (a-b), Right (b-a) or Right HZero

Instances

type HSubtract 'HZero 'HZero

Defined in Data.HList.RecordU

type HSubtract 'HZero 'HZero = 'Right 'HZero :: Either HNat HNat

type HSubtract 'HZero ('HSucc y)

Defined in Data.HList.RecordU

type HSubtract 'HZero ('HSucc y) = 'Right ('HSucc y) :: Either HNat HNat

type HSubtract ('HSucc y) 'HZero

Defined in Data.HList.RecordU

type HSubtract ('HSucc y) 'HZero = 'Left ('HSucc y) :: Either HNat HNat

type HSubtract ('HSucc x) ('HSucc y)

Defined in Data.HList.RecordU

type HSubtract ('HSucc x) ('HSucc y) = HSubtract x y

Conversion of RecordUS

with the actual representation

recordUS :: forall p f (x1 :: [Type]) (g1 :: [Type]) (x2 :: [Type]) (g2 :: [Type]) (u1 :: [Type]) (u2 :: [Type]). (Profunctor p, Functor f, HGroupBy EqTagValue x1 g1, HGroupBy EqTagValue x2 g2, HMapUnboxF g1 u1, HMapUnboxF g2 u2) => p (RecordUS x1) (f (RecordUS x2)) -> p (HList u1) (f (HList u2))

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

recordUS' :: forall (x :: [Type]) (g :: [Type]) f p (u :: [Type]). (HGroupBy EqTagValue x g, Functor f, Profunctor p, HMapUnboxF g u) => p (RecordUS x) (f (RecordUS x)) -> p (HList u) (f (HList u))

Iso (HList s) (RecordUS a)

s is a HList of RecordU while a :: [*] is list of Tagged label value

with Record

recordToRecordUS :: forall x g u. (HMapCxt HList UnboxF g u, HMapUnboxF g u, HGroupBy EqTagValue x g, RecordUSCxt x u) => Record x -> RecordUS x

view unboxedS or ^. unboxedS are preferred

recordUSToRecord :: forall u g x. (HConcatFD g x, HMapCxt HList BoxF u g, HMapUnboxF g u, RecordUSCxt x u) => RecordUS x -> Record x

^. from unboxedS is preferred

unboxedS :: forall (g1 :: [Type]) (u1 :: [Type]) (g2 :: [Type]) (u2 :: [Type]) (x1 :: [Type]) (x2 :: [Type]) p f. (HMapUnboxF g1 u1, HMapUnboxF g2 u2, HGroupBy EqTagValue x1 g1, HGroupBy EqTagValue x2 g2, Profunctor p, Functor f, HConcatFD g1 x1, SameLength' u2 g2, SameLength' g2 u2, SameLength' u1 g1, SameLength' g1 u1, HMapAux HList UnboxF g2 u2, HMapAux HList BoxF u1 g1) => p (RecordUS x2) (f (RecordUS x1)) -> p (Record x2) (f (Record x1))

Iso (Record x) (Record y) (RecordUS x) (RecordUS y)

unboxedS' :: forall (g :: [Type]) (u :: [Type]) (x :: [Type]) p f. (HMapUnboxF g u, HGroupBy EqTagValue x g, Profunctor p, Functor f, HConcatFD g x, SameLength' u g, SameLength' g u, HMapAux HList UnboxF g u, HMapAux HList BoxF u g) => p (RecordUS x) (f (RecordUS x)) -> p (Record x) (f (Record x))

Iso' (Record x) (RecordUS x)

class ElemTyEq (xs :: [*])

all elements of the list have the same type

Instances

ElemTyEq ('[] :: [Type])

Defined in Data.HList.RecordU

t1v ~ Tagged t v => ElemTyEq (t1v ': rest)

Defined in Data.HList.RecordU

(t1v ~ Tagged t1 v, t2v ~ Tagged t2 v, ElemTyEq (tv2 ': rest)) => ElemTyEq (tv1 ': (tv2 ': rest))

Defined in Data.HList.RecordU

class HUpdateMany lv rx where

analogous flip //. Similar to .<++., except it is restricted to cases where the left argument holds a subset of elements.

Methods

hUpdateMany :: Record lv -> rx -> rx

Instances

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

implementation in terms of .<++.

Defined in Data.HList.RecordU

Methods

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

(RecordValues lv, HList2List (RecordValuesR lv) v, HFindMany (LabelsOf lv) (LabelsOf r) ixs, IArray UArray v, v ~ GetElemTy r, HNats2Integrals ixs) => HUpdateMany lv (RecordU r)

Defined in Data.HList.RecordU

Methods

hUpdateMany :: Record lv -> RecordU r -> RecordU r

class HFindMany (ls :: [k]) (r :: [k]) (ns :: [HNat]) | ls r -> ns

behaves like map HFind

Instances

HFindMany ('[] :: [k]) (r :: [k]) ('[] :: [HNat])

Defined in Data.HList.RecordU

(HFind l r n, HFindMany ls r ns) => HFindMany (l ': ls :: [k]) (r :: [k]) (n ': ns)

Defined in Data.HList.RecordU

hMapRU :: HMapCxt RecordU f x y => f -> RecordU x -> RecordU y

hMap specialized to RecordU

unboxed :: forall x y f p. (Profunctor p, Functor f, RecordToRecordU x, RecordUToRecord y) => (RecordU x `p` f (RecordU y)) -> Record x `p` f (Record y)

Iso (Record x) (Record y) (RecordU x) (RecordU y)

unboxed' :: forall p f (y :: [Type]) (n :: HNat). (Profunctor p, Functor f, RecordValues y, HList2List (RecordValuesR y) (GetElemTy y), KnownNat (HNat2Nat n), HLengthEq1 y n, HLengthEq2 y n, IArray UArray (GetElemTy y), SameLength' (HReplicateR n ()) y, HMapAux HList TaggedFn (RecordValuesR y) y) => p (RecordU y) (f (RecordU y)) -> p (Record y) (f (Record y))

Iso' (Record x) (RecordU x)

class RecordToRecordU x where

Methods

recordToRecordU :: Record x -> RecordU x

Instances

(RecordValues x, HList2List (RecordValuesR x) (GetElemTy x), HNat2Integral n, HLengthEq x n, IArray UArray (GetElemTy x)) => RecordToRecordU x

Defined in Data.HList.RecordU

Methods

recordToRecordU :: Record x -> RecordU x

class RecordUToRecord x where

Methods

recordUToRecord :: RecordU x -> Record x

Instances

(HMapCxt HList TaggedFn (RecordValuesR x) x, IArray UArray (GetElemTy x), HList2List (RecordValuesR x) (GetElemTy x)) => RecordUToRecord x

Defined in Data.HList.RecordU

Methods

recordUToRecord :: RecordU x -> Record x

definitions for doctest examples

type Bad = [Tagged "x" Double, Tagged "i" Int, Tagged "y" Double, Tagged "j" Int]

bad :: Record Bad

HasField instances

RecordUS

>>> let r = recordToRecordUS (sortForRecordUS bad)
>>> let s = recordToRecordUS bad

>>> let x = Label :: Label "x"
>>> let y = Label :: Label "y"
>>> let i = Label :: Label "i"
>>> let j = Label :: Label "j"

>>> (r .!. x, r .!. i, r .!. y, r .!. j)
(1.0,2,3.0,4)

>>> (s .!. x, s .!. i, s .!. y, s .!. j)
(1.0,2,3.0,4)

RecordU

>>> let t = recordToRecordU bad1
>>> (t .!. x, t .!. y)
(1.0,2.0)

>>> hUpdateAtLabel x 3 t .!. x
3.0

bad1 :: Record [Tagged "x" Double, Tagged "y" Double]

Implementation Details

data UnboxF

Constructors

UnboxF

Instances

(hx ~ HList x, ux ~ RecordU x, RecordToRecordU x) => ApplyAB UnboxF hx ux

Defined in Data.HList.RecordU

Methods

applyAB :: UnboxF -> hx -> ux

data BoxF

Constructors

BoxF

Instances

(ux ~ RecordU x, hx ~ HList x, RecordUToRecord x) => ApplyAB BoxF ux hx

Defined in Data.HList.RecordU

Methods

applyAB :: BoxF -> ux -> hx