HList 0.1 → 0.1.1
raw patch · 16 files changed
+1022/−58 lines, 16 filesdep ~basePVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependency ranges changed: base
API changes (from Hackage documentation)
- Data.HList: (.!.) :: (HasField l r v) => r -> l -> v
- Data.HList: (.*.) :: (HExtend e l l') => e -> l -> l'
- Data.HList: (.+.) :: (HTypeIndexed l, HTypeProxied l, HOccursNot (Proxy e) l) => e -> TIP l -> TIP (HCons (Proxy e) l)
- Data.HList: (.-.) :: (H2ProjectByLabels (HCons e HNil) t t1 t2) => Record t -> e -> Record t2
- Data.HList: (.<++.) :: (HLeftUnion r r' r'') => r -> r' -> r''
- Data.HList: (.<.) :: (HasField t t2 t1, RecordLabels t2 ls, HFind t ls n, HUpdateAtHNat n (LVPair t t1) t2 l') => LVPair t t1 -> Record t2 -> Record l'
- Data.HList: (.=.) :: l -> v -> LVPair l v
- Data.HList: (.@.) :: (HUpdateAtHNat n (LVPair t t1) t2 l', HFind t ls n, RecordLabels t2 ls) => Record t2 -> LVPair t t1 -> Record l'
- Data.HList: (.^.) :: (HasField t t2 (Proxy t1), RecordLabels t2 ls, HFind t ls n, HUpdateAtHNat n (LVPair t t1) t2 l') => LVPair t t1 -> Record t2 -> Record l'
- Data.HList: ApplyHCons :: ApplyHCons
- Data.HList: HAddTag :: t -> HAddTag t
- Data.HList: HCons :: e -> l -> HCons e l
- Data.HList: HJust :: x -> HJust x
- Data.HList: HMap' :: f -> HMap' f
- Data.HList: HNil :: HNil
- Data.HList: HNothing :: HNothing
- Data.HList: HRmTag :: HRmTag
- Data.HList: HSeq :: x -> HSeq x
- Data.HList: HShow :: HShow
- Data.HList: Id :: Id
- Data.HList: LVPair :: v -> LVPair l v
- Data.HList: Record :: r -> Record r
- Data.HList: TIC :: Dynamic -> TIC l
- Data.HList: TIP :: l -> TIP l
- Data.HList: Variant :: mr -> Variant mr
- Data.HList: append :: [a] -> [a] -> [a]
- Data.HList: append' :: [a] -> [a] -> [a]
- Data.HList: apply :: (Apply f a r) => f -> a -> r
- Data.HList: class Apply f a r | f a -> r
- Data.HList: class ConsLub h t l | h t -> l
- Data.HList: class Fail x
- Data.HList: class FromHJust l l' | l -> l'
- Data.HList: class H2ProjectByLabels ls r rin rout | ls r -> rin rout
- Data.HList: class H2ProjectByLabels' b ls r rin rout | b ls r -> rin rout
- Data.HList: class (HBool t, HBool t', HBool t'') => HAnd t t' t'' | t t' -> t''
- Data.HList: class HAppend l l' l'' | l l' -> l''
- Data.HList: class HBetween x y | x -> y
- Data.HList: class HBool x
- Data.HList: class HBuild' l a r | r -> a l
- Data.HList: class (HBool t) => HCond t x y z | t x y -> z
- Data.HList: class (HNat n) => HDeleteAtHNat n l l' | n l -> l'
- Data.HList: class HDeleteMany e l l' | e l -> l'
- Data.HList: class HDeleteManyCase b e e' l l' | b e e' l -> l'
- Data.HList: class HDiff x y z | x y -> z
- Data.HList: class (HBool b) => HEq x y b | x y -> b
- Data.HList: class HExtend e l l' | e l -> l', l' -> e l
- Data.HList: class (HNat n) => HFind e l n | e l -> n
- Data.HList: class (HNat n) => HFind' b e l n | b e l -> n
- Data.HList: class (HList l) => HFoldr f v l r | f v l -> r
- Data.HList: class HHead l h | l -> h
- Data.HList: class HLabelSet ls
- Data.HList: class HLeftUnion r r' r'' | r r' -> r''
- Data.HList: class HLeftUnionBool b r f r' | b r f -> r'
- Data.HList: class (HList l, HNat n) => HLength l n | l -> n
- Data.HList: class HList l
- Data.HList: class HList2List l e
- Data.HList: class (HNat n) => HLookupByHNat n l e | n l -> e
- Data.HList: class (HBool b) => HLt x y b | x y -> b
- Data.HList: class HLub l e | l -> e
- Data.HList: class HMap f l l' | f l -> l'
- Data.HList: class HMapOut f r e
- Data.HList: class HMaxLength l s
- Data.HList: class HMaybied r r' | r -> r'
- Data.HList: class (HBool b) => HMember e l b | e l -> b
- Data.HList: class HMemberM e l r | e l -> r
- Data.HList: class HMemberM' b e l r | b e l -> r
- Data.HList: class HMinLength l s
- Data.HList: class HNat n
- Data.HList: class (HNat n) => HNat2Integral n
- Data.HList: class (HList l) => HNats l
- Data.HList: class HOccurs e l
- Data.HList: class HOccurs' e l
- Data.HList: class HOccursBool b e l
- Data.HList: class HOccursFst e l
- Data.HList: class HOccursMany e l
- Data.HList: class HOccursMany1 e l
- Data.HList: class HOccursNot e l
- Data.HList: class HOccursOpt e l
- Data.HList: class (HBool t, HBool t', HBool t'') => HOr t t' t'' | t t' -> t''
- Data.HList: class HOrdMember e l b | e l -> b
- Data.HList: class HProject l l'
- Data.HList: class HProjectAwayByHNats ns l l' | ns l -> l'
- Data.HList: class (HNats ns) => HProjectByHNats ns l l' | ns l -> l'
- Data.HList: class HRLabelSet ps
- Data.HList: class HReverse l1 l2 | l1 -> l2, l2 -> l1
- Data.HList: class HReverse' l1 l2 l3 | l1 l2 -> l3
- Data.HList: class HSet l
- Data.HList: class HSingleton l
- Data.HList: class HSplit l l' l'' | l -> l' l''
- Data.HList: class (HNats ns) => HSplitByHNats' ns l l' l'' | ns l -> l' l''
- Data.HList: class HStagedEq x y
- Data.HList: class HStagedEq' b e e'
- Data.HList: class HTIntersect l1 l2 l3 | l1 l2 -> l3
- Data.HList: class (HBool b) => HTIntersectBool b h t l1 l2 | b h t l1 -> l2
- Data.HList: class (HBool b) => HTMember e l b | e l -> b
- Data.HList: class HTail l l' | l -> l'
- Data.HList: class (HNat n) => HType2HNat e l n | e l -> n
- Data.HList: class (HBool b, HNat n) => HType2HNatCase b e l n | b e l -> n
- Data.HList: class (HList l) => HTypeIndexed l
- Data.HList: class HTypeProxied l
- Data.HList: class HTypes2HNats ps l ns | ps l -> ns
- Data.HList: class (HNat n) => HUpdateAtHNat n e l l' | n e l -> l', l' n -> e
- Data.HList: class HZip x y l | x y -> l, l -> x y
- Data.HList: class HZippable x y
- Data.HList: class HasField l r v | l r -> v
- Data.HList: class HasField' b l r v | b l r -> v
- Data.HList: class HasNoProxies l
- Data.HList: class IsTC1 x f :: (* -> *) b | x f -> b
- Data.HList: class IsTC2 x f :: (* -> * -> *) b | x f -> b
- Data.HList: class LubNarrow a b c | a b -> c
- Data.HList: class NaiveHReverse l l' | l -> l'
- Data.HList: class Narrow a b
- Data.HList: class NarrowM a b res | a b -> res
- Data.HList: class NarrowM' rin rout b res | rin rout b -> res
- Data.HList: class NarrowM'' f r r' | f r -> r'
- Data.HList: class RecordEquiv r1 r2 res | r1 r2 -> res
- Data.HList: class RecordEquiv' pj1 pj2 res | pj1 pj2 -> res
- Data.HList: class RecordLabels r ls | r -> ls
- Data.HList: class ShowComponents l
- Data.HList: class ShowLabel l
- Data.HList: class SubType l l'
- Data.HList: class ToHJust l l' | l -> l'
- Data.HList: class TypeCast x y | x -> y, y -> x
- Data.HList: class (HBool b) => TypeEq x y b | x y -> b
- Data.HList: class TypeEqFalse x y
- Data.HList: class TypeEqTrue x y
- Data.HList: class UnionSymRec r1 r2 ru | r1 r2 -> ru
- Data.HList: class UnionSymRec' b r1 f2 r2' ru | b r1 f2 r2' -> ru
- Data.HList: consLub :: (ConsLub h t l) => h -> t -> l
- Data.HList: data ApplyHCons
- Data.HList: data HAddTag t
- Data.HList: data HCons e l
- Data.HList: data HFalse
- Data.HList: data HJust x
- Data.HList: data HMap' f
- Data.HList: data HNil
- Data.HList: data HNothing
- Data.HList: data HRmTag
- Data.HList: data HSeq x
- Data.HList: data HShow
- Data.HList: data HSucc n
- Data.HList: data HTrue
- Data.HList: data HZero
- Data.HList: data Id
- Data.HList: data NilLub
- Data.HList: data Proxy e
- Data.HList: data ProxyFound x
- Data.HList: data TIC l
- Data.HList: data TypeFound e
- Data.HList: data TypeNotFound e
- Data.HList: emptyRecord :: Record HNil
- Data.HList: emptyTIP :: TIP HNil
- Data.HList: equivR :: (RecordEquiv r1 r2 res) => Record r1 -> Record r2 -> res
- Data.HList: equivR' :: (RecordEquiv' pj1 pj2 res) => pj1 -> pj2 -> res
- Data.HList: fromHJust :: (FromHJust l l') => l -> l'
- Data.HList: funType :: (IsTC2 t (->) b) => t -> b
- Data.HList: h2projectByLabels :: (H2ProjectByLabels ls r rin rout) => ls -> r -> (rin, rout)
- Data.HList: h2projectByLabels' :: (H2ProjectByLabels' b ls r rin rout) => b -> ls -> r -> (rin, rout)
- Data.HList: hAddTag :: (HMap (HAddTag t) l l') => t -> l -> l'
- Data.HList: hAnd :: (HAnd t t' t'') => t -> t' -> t''
- Data.HList: hAppend :: (HAppend l l' l'') => l -> l' -> l''
- Data.HList: hAppend' :: (HFoldr ApplyHCons v l r) => l -> v -> r
- Data.HList: hBetween :: (HBetween x y) => x -> y
- Data.HList: hBuild :: (HBuild' HNil a r) => a -> r
- Data.HList: hBuild' :: (HBuild' l a r) => l -> a -> r
- Data.HList: hCond :: (HCond t x y z) => t -> x -> y -> z
- Data.HList: hCons :: (HList l) => e -> l -> HCons e l
- Data.HList: hConsTcName :: TyCon
- Data.HList: hDeleteAtHNat :: (HDeleteAtHNat n l l') => n -> l -> l'
- Data.HList: hDeleteAtLabel :: (H2ProjectByLabels (HCons e HNil) t t1 t2) => e -> Record t -> Record t2
- Data.HList: hDeleteAtProxy :: (HDeleteAtHNat n l l', HType2HNat e l n) => Proxy e -> l -> l'
- Data.HList: hDeleteMany :: (HDeleteMany e l l') => Proxy e -> l -> l'
- Data.HList: hDeleteManyCase :: (HDeleteManyCase b e e' l l') => b -> Proxy e -> e' -> l -> l'
- Data.HList: hDiff :: (HDiff x y z) => x -> y -> z
- Data.HList: hEnd :: HCons t t1 -> HCons t t1
- Data.HList: hEq :: (HEq x y b) => x -> y -> b
- Data.HList: hExtend :: (HExtend e l l') => e -> l -> l'
- Data.HList: hExtend' :: (HTypeIndexed t, HOccursNot e t) => e -> TIP t -> TIP (HCons e t)
- Data.HList: hFalse :: HFalse
- Data.HList: hFieldTcName :: TyCon
- Data.HList: hFind :: (HFind e l n) => e -> l -> n
- Data.HList: hFind' :: (HFind' b e l n) => b -> e -> l -> n
- Data.HList: hFlag :: (HMap (HAddTag HTrue) l l') => l -> l'
- Data.HList: hFoldr :: (HFoldr f v l r) => f -> v -> l -> r
- Data.HList: hHead :: (HHead l h) => l -> h
- Data.HList: hLeftUnion :: (HLeftUnion r r' r'') => r -> r' -> r''
- Data.HList: hLeftUnionBool :: (HLeftUnionBool b r f r') => b -> r -> f -> r'
- Data.HList: hLength :: (HLength l n) => l -> n
- Data.HList: hList2List :: (HList2List l e) => l -> [e]
- Data.HList: hLookupByHNat :: (HLookupByHNat n l e) => n -> l -> e
- Data.HList: hLookupByLabel :: (HasField l r v) => l -> r -> v
- Data.HList: hLookupByLabel' :: (HasField' b l r v) => b -> l -> r -> v
- Data.HList: hLt :: (HLt x y b) => x -> y -> b
- Data.HList: hLub :: (HLub l e) => l -> [e]
- Data.HList: hMap :: (HMap f l l') => f -> l -> l'
- Data.HList: hMap' :: (HFoldr (HMap' f) HNil l r) => f -> l -> r
- Data.HList: hMapM :: (Monad m, HMapOut f l (m e)) => f -> l -> [m e]
- Data.HList: hMapM_ :: (Monad m, HMapOut f l (m ())) => f -> l -> m ()
- Data.HList: hMapOut :: (HMapOut f r e) => f -> r -> [e]
- Data.HList: hMaybied :: (HMaybied r r') => r -> r'
- Data.HList: hMember :: (HMember e l b) => e -> l -> b
- Data.HList: hNat2Integral :: (HNat2Integral n, Integral i) => n -> i
- Data.HList: hNil :: HNil
- Data.HList: hNilTcName :: TyCon
- Data.HList: hOccurs :: (HOccurs e l) => l -> e
- Data.HList: hOccurs' :: (HOccurs' e l) => l -> e
- Data.HList: hOccursBool :: (HOccursBool b e l) => b -> l -> e
- Data.HList: hOccursFst :: (HOccursFst e l) => l -> e
- Data.HList: hOccursMany :: (HOccursMany e l) => l -> [e]
- Data.HList: hOccursMany1 :: (HOccursMany1 e l) => l -> (e, [e])
- Data.HList: hOccursOpt :: (HOccursOpt e l) => l -> Maybe e
- Data.HList: hOr :: (HOr t t' t'') => t -> t' -> t''
- Data.HList: hOrdMember :: (HOrdMember e l b) => e -> l -> b
- Data.HList: hPred :: (HNat n) => HSucc n -> n
- Data.HList: hProject :: (HProject l l') => l -> l'
- Data.HList: hProjectAwayByHNats :: (HProjectAwayByHNats ns l l') => ns -> l -> l'
- Data.HList: hProjectByHNats :: (HProjectByHNats ns l l') => ns -> l -> l'
- Data.HList: hProjectByLabels :: (HRLabelSet a, H2ProjectByLabels ls t a b) => ls -> Record t -> Record a
- Data.HList: hProjectByLabels2 :: (HRLabelSet t2, HRLabelSet t1, H2ProjectByLabels ls t t1 t2) => ls -> Record t -> (Record t1, Record t2)
- Data.HList: hProjectByProxies :: (HProjectByHNats ns l l', HTypes2HNats ps l ns) => ps -> l -> l'
- Data.HList: hRenameLabel :: (H2ProjectByLabels (HCons e HNil) t t1 t2, HasField e t v, HRLabelSet (HCons (LVPair l v) t2)) => e -> l -> Record t -> Record (HCons (LVPair l v) t2)
- Data.HList: hReverse :: (HReverse l1 l2) => l1 -> l2
- Data.HList: hReverse' :: (HReverse' l1 l2 l3) => l1 -> l2 -> l3
- Data.HList: hRmTag :: (HMap HRmTag l l') => l -> l'
- Data.HList: hSingle :: (HSingleton l, HHead l e) => l -> e
- Data.HList: hSplit :: (HSplit l l' l'') => l -> (l', l'')
- Data.HList: hSplitByHNats :: (HSplitByHNats' ns l' l'1 l'', HMap (HAddTag HTrue) l l') => ns -> l -> (l'1, l'')
- Data.HList: hSplitByHNats' :: (HSplitByHNats' ns l l' l'') => ns -> l -> (l', l'')
- Data.HList: hSplitByProxies :: (HMap (HAddTag HTrue) l l', HSplitByHNats' ns l' l'1 l'', HTypes2HNats ps l ns) => ps -> l -> (l'1, l'')
- Data.HList: hStagedEq :: (HStagedEq x y) => x -> y -> Bool
- Data.HList: hStagedEq' :: (HStagedEq' b e e') => b -> e -> e' -> Bool
- Data.HList: hSucc :: (HNat n) => n -> HSucc n
- Data.HList: hTIntersect :: (HTIntersect l1 l2 l3) => l1 -> l2 -> l3
- Data.HList: hTIntersectBool :: (HTIntersectBool b h t l1 l2) => b -> h -> t -> l1 -> l2
- Data.HList: hTMember :: (HTMember e l b) => e -> l -> b
- Data.HList: hTPupdateAtLabel :: (HUpdateAtHNat n (LVPair l a) t l', HFind l ls n, RecordLabels t ls, HasField l t a) => l -> a -> Record t -> Record l'
- Data.HList: hTail :: (HTail l l') => l -> l'
- Data.HList: hTrue :: HTrue
- Data.HList: hType2HNat :: (HType2HNat e l n) => Proxy e -> l -> n
- Data.HList: hTypes2HNats :: (HTypes2HNats ps l ns) => ps -> l -> ns
- Data.HList: hUnproxyLabel :: (HUpdateAtHNat n (LVPair l a) t l', HFind l ls n, RecordLabels t ls, HasField l t (Proxy a)) => l -> a -> Record t -> Record l'
- Data.HList: hUnzip :: (HZip x y l) => l -> (x, y)
- Data.HList: hUpdateAtHNat :: (HUpdateAtHNat n e l l') => n -> e -> l -> l'
- Data.HList: hUpdateAtLabel :: (RecordLabels t ls, HFind e ls n, HUpdateAtHNat n (LVPair e v) t l') => e -> v -> Record t -> Record l'
- Data.HList: hUpdateAtType :: (HUpdateAtHNat n e l l', HType2HNat e l n) => e -> l -> l'
- Data.HList: hZero :: HZero
- Data.HList: hZip :: (HZip x y l) => x -> y -> l
- Data.HList: hasNoProxies :: (HasNoProxies r) => Record r -> ()
- Data.HList: labelLVPair :: LVPair l v -> l
- Data.HList: lubNarrow :: (LubNarrow a b c) => a -> b -> (c, c)
- Data.HList: mkRecord :: (HRLabelSet r) => r -> Record r
- Data.HList: mkTIC :: (HTypeIndexed l, HTypeProxied l, HOccurs (Proxy i) l, Typeable i) => i -> TIC l
- Data.HList: mkTIP :: (HTypeIndexed l) => l -> TIP l
- Data.HList: mkVariant :: (RecordLabels v ls, HFind x ls n, HMaybied v v', HUpdateAtHNat n (LVPair x (Maybe y)) v' v') => x -> y -> (Record v) -> Variant v'
- Data.HList: naiveHReverse :: (NaiveHReverse l l') => l -> l'
- Data.HList: narrow :: (Narrow a b) => Record a -> Record b
- Data.HList: narrowM :: (NarrowM a b res) => Record a -> Record b -> res
- Data.HList: narrowM' :: (NarrowM' rin rout b res) => rin -> rout -> b -> res
- Data.HList: narrowM'' :: (NarrowM'' f r r') => f -> r -> r'
- Data.HList: newLVPair :: l -> v -> LVPair l v
- Data.HList: newtype LVPair l v
- Data.HList: newtype Record r
- Data.HList: newtype TIP l
- Data.HList: newtype Variant mr
- Data.HList: nilLub :: NilLub
- Data.HList: onTIP :: (HTypeIndexed a) => (b -> a) -> TIP b -> TIP a
- Data.HList: oneTrue :: TIP (HCons Int (HCons Bool HNil))
- Data.HList: proxy :: Proxy e
- Data.HList: proxyEq :: (TypeEq t t' b) => Proxy t -> Proxy t' -> b
- Data.HList: proxyTcName :: TyCon
- Data.HList: recordLabels :: (RecordLabels r ls) => r -> ls
- Data.HList: recordTcName :: TyCon
- Data.HList: showComponents :: (ShowComponents l) => String -> l -> String
- Data.HList: showLabel :: (ShowLabel l) => l -> String
- Data.HList: subType :: (SubType l l') => l -> l' -> ()
- Data.HList: tipyDelete :: (HTypeIndexed l', HType2HNat e b n, HDeleteAtHNat n b l') => Proxy e -> TIP b -> TIP l'
- Data.HList: tipyProject :: (HTypeIndexed l', HTypes2HNats ps b ns, HProjectByHNats ns b l') => ps -> TIP b -> TIP l'
- Data.HList: tipySplit :: (HTypeIndexed t2, HTypeIndexed t1, HTypes2HNats ps t ns, HSplitByHNats' ns l' t1 t2, HMap (HAddTag HTrue) t l') => ps -> TIP t -> (TIP t1, TIP t2)
- Data.HList: tipyUpdate :: (HTypeIndexed l', HType2HNat e b n, HUpdateAtHNat n e b l') => e -> TIP b -> TIP l'
- Data.HList: toHJust :: (ToHJust l l') => l -> l'
- Data.HList: toProxy :: e -> Proxy e
- Data.HList: tuple :: (HOccurs e1 (TIP l), HType2HNat e1 l n, HDeleteAtHNat n l l', HOccurs e2 (TIP l'), HOccurs e2 (TIP l), HType2HNat e2 l n', HDeleteAtHNat n' l l'', HOccurs e1 (TIP l'')) => TIP l -> (e1, e2)
- Data.HList: type :*: e l = HCons e l
- Data.HList: type :+: e l = HCons (Proxy e) l
- Data.HList: type :=: l v = LVPair l v
- Data.HList: typeCast :: (TypeCast x y) => x -> y
- Data.HList: typeEq :: (TypeEq t t' b) => t -> t' -> b
- Data.HList: typeEqFalse :: (TypeEqFalse x y) => x -> y -> ()
- Data.HList: typeEqTrue :: (TypeEqTrue x y) => x -> y -> ()
- Data.HList: unProxy :: Proxy e -> e
- Data.HList: unTIC :: (HTypeIndexed l, HTypeProxied l, HOccurs (Proxy o) l, Typeable o) => TIC l -> Maybe o
- Data.HList: unTIP :: TIP l -> l
- Data.HList: unVariant :: (RecordLabels v ls, HFind x ls n, HLookupByHNat n v (LVPair x (Maybe y))) => x -> Variant v -> Maybe y
- Data.HList: unionSR :: (UnionSymRec r1 r2 ru) => r1 -> r2 -> (ru, ru)
- Data.HList: unionSR' :: (UnionSymRec' b r1 f2 r2' ru) => b -> r1 -> f2 -> r2' -> (ru, ru)
- Data.HList: valueLVPair :: LVPair l v -> v
+ Data.HList.FakePrelude: HJust :: x -> HJust x
+ Data.HList.FakePrelude: HNothing :: HNothing
+ Data.HList.FakePrelude: class Fail x
+ Data.HList.FakePrelude: class (HBool t, HBool t', HBool t'') => HAnd t t' t'' | t t' -> t''
+ Data.HList.FakePrelude: class HBool x
+ Data.HList.FakePrelude: class (HBool t) => HCond t x y z | t x y -> z
+ Data.HList.FakePrelude: class (HBool b) => HEq x y b | x y -> b
+ Data.HList.FakePrelude: class (HBool b) => HLt x y b | x y -> b
+ Data.HList.FakePrelude: class HNat n
+ Data.HList.FakePrelude: class (HNat n) => HNat2Integral n
+ Data.HList.FakePrelude: class (HBool t, HBool t', HBool t'') => HOr t t' t'' | t t' -> t''
+ Data.HList.FakePrelude: class HStagedEq x y
+ Data.HList.FakePrelude: class SubType l l'
+ Data.HList.FakePrelude: class TypeCast x y | x -> y, y -> x
+ Data.HList.FakePrelude: class (HBool b) => TypeEq x y b | x y -> b
+ Data.HList.FakePrelude: class TypeEqFalse x y
+ Data.HList.FakePrelude: class TypeEqTrue x y
+ Data.HList.FakePrelude: data HFalse
+ Data.HList.FakePrelude: data HJust x
+ Data.HList.FakePrelude: data HNothing
+ Data.HList.FakePrelude: data HSucc n
+ Data.HList.FakePrelude: data HTrue
+ Data.HList.FakePrelude: data HZero
+ Data.HList.FakePrelude: data Proxy e
+ Data.HList.FakePrelude: hAnd :: (HAnd t t' t'') => t -> t' -> t''
+ Data.HList.FakePrelude: hCond :: (HCond t x y z) => t -> x -> y -> z
+ Data.HList.FakePrelude: hEq :: (HEq x y b) => x -> y -> b
+ Data.HList.FakePrelude: hFalse :: HFalse
+ Data.HList.FakePrelude: hLt :: (HLt x y b) => x -> y -> b
+ Data.HList.FakePrelude: hNat2Integral :: (HNat2Integral n, Integral i) => n -> i
+ Data.HList.FakePrelude: hOr :: (HOr t t' t'') => t -> t' -> t''
+ Data.HList.FakePrelude: hPred :: (HNat n) => HSucc n -> n
+ Data.HList.FakePrelude: hStagedEq :: (HStagedEq x y) => x -> y -> Bool
+ Data.HList.FakePrelude: hSucc :: (HNat n) => n -> HSucc n
+ Data.HList.FakePrelude: hTrue :: HTrue
+ Data.HList.FakePrelude: hZero :: HZero
+ Data.HList.FakePrelude: instance [overlap ok] (HNat n) => HEq (HSucc n) HZero HFalse
+ Data.HList.FakePrelude: instance [overlap ok] (HNat n) => HEq HZero (HSucc n) HFalse
+ Data.HList.FakePrelude: instance [overlap ok] (HNat n) => HLt (HSucc n) HZero HFalse
+ Data.HList.FakePrelude: instance [overlap ok] (HNat n) => HLt HZero (HSucc n) HTrue
+ Data.HList.FakePrelude: instance [overlap ok] (HNat n) => HNat (HSucc n)
+ Data.HList.FakePrelude: instance [overlap ok] (HNat n, HNat n', HEq n n' b) => HEq (HSucc n) (HSucc n') b
+ Data.HList.FakePrelude: instance [overlap ok] (HNat n, HNat n', HLt n n' b) => HLt (HSucc n) (HSucc n') b
+ Data.HList.FakePrelude: instance [overlap ok] (HNat n, Show (HSucc n)) => Show (HSucc (HSucc n))
+ Data.HList.FakePrelude: instance [overlap ok] (HNat2Integral n) => HNat2Integral (HSucc n)
+ Data.HList.FakePrelude: instance [overlap ok] (Show x) => Show (HJust x)
+ Data.HList.FakePrelude: instance [overlap ok] HAnd HFalse HFalse HFalse
+ Data.HList.FakePrelude: instance [overlap ok] HAnd HFalse HTrue HFalse
+ Data.HList.FakePrelude: instance [overlap ok] HAnd HTrue HFalse HFalse
+ Data.HList.FakePrelude: instance [overlap ok] HAnd HTrue HTrue HTrue
+ Data.HList.FakePrelude: instance [overlap ok] HBool HFalse
+ Data.HList.FakePrelude: instance [overlap ok] HBool HTrue
+ Data.HList.FakePrelude: instance [overlap ok] HCond HFalse x y y
+ Data.HList.FakePrelude: instance [overlap ok] HCond HTrue x y x
+ Data.HList.FakePrelude: instance [overlap ok] HEq HZero HZero HTrue
+ Data.HList.FakePrelude: instance [overlap ok] HLt HZero HZero HFalse
+ Data.HList.FakePrelude: instance [overlap ok] HNat HZero
+ Data.HList.FakePrelude: instance [overlap ok] HNat2Integral HZero
+ Data.HList.FakePrelude: instance [overlap ok] HOr HFalse HFalse HFalse
+ Data.HList.FakePrelude: instance [overlap ok] HOr HFalse HTrue HTrue
+ Data.HList.FakePrelude: instance [overlap ok] HOr HTrue HFalse HTrue
+ Data.HList.FakePrelude: instance [overlap ok] HOr HTrue HTrue HTrue
+ Data.HList.FakePrelude: instance [overlap ok] Show (HSucc HZero)
+ Data.HList.FakePrelude: instance [overlap ok] Show (Proxy e)
+ Data.HList.FakePrelude: instance [overlap ok] Show HFalse
+ Data.HList.FakePrelude: instance [overlap ok] Show HNothing
+ Data.HList.FakePrelude: instance [overlap ok] Show HTrue
+ Data.HList.FakePrelude: instance [overlap ok] Show HZero
+ Data.HList.FakePrelude: proxy :: Proxy e
+ Data.HList.FakePrelude: proxyEq :: (TypeEq t t' b) => Proxy t -> Proxy t' -> b
+ Data.HList.FakePrelude: subType :: (SubType l l') => l -> l' -> ()
+ Data.HList.FakePrelude: toProxy :: e -> Proxy e
+ Data.HList.FakePrelude: typeCast :: (TypeCast x y) => x -> y
+ Data.HList.FakePrelude: typeEq :: (TypeEq t t' b) => t -> t' -> b
+ Data.HList.FakePrelude: typeEqFalse :: (TypeEqFalse x y) => x -> y -> ()
+ Data.HList.FakePrelude: typeEqTrue :: (TypeEqTrue x y) => x -> y -> ()
+ Data.HList.FakePrelude: unProxy :: Proxy e -> e
+ Data.HList.GhcExperiments: class HDeleteMany e l l' | e l -> l'
+ Data.HList.GhcExperiments: class IsTC1 x f :: (* -> *) b | x f -> b
+ Data.HList.GhcExperiments: class IsTC2 x f :: (* -> * -> *) b | x f -> b
+ Data.HList.GhcExperiments: funType :: (IsTC2 t (->) b) => t -> b
+ Data.HList.GhcExperiments: hDeleteMany :: (HDeleteMany e l l') => Proxy e -> l -> l'
+ Data.HList.GhcExperiments: instance [overlap ok] (HList l, HDeleteMany e l l') => HDeleteMany e (HCons e l) l'
+ Data.HList.GhcExperiments: instance [overlap ok] (HList l, HDeleteMany e l l', TypeCast (HCons e' l') l'') => HDeleteMany e (HCons e' l) l''
+ Data.HList.GhcExperiments: instance [overlap ok] (TypeCast HFalse b) => IsTC1 f x b
+ Data.HList.GhcExperiments: instance [overlap ok] (TypeCast HFalse b) => IsTC2 f x b
+ Data.HList.GhcExperiments: instance [overlap ok] (TypeCast HTrue b) => IsTC1 (f a) f b
+ Data.HList.GhcExperiments: instance [overlap ok] (TypeCast HTrue b) => IsTC2 (f a b) f b
+ Data.HList.GhcExperiments: instance [overlap ok] HDeleteMany e HNil HNil
+ Data.HList.GhcRecord: class ConsLub h t l | h t -> l
+ Data.HList.GhcRecord: class HLub l e | l -> e
+ Data.HList.GhcRecord: class HasNoProxies l
+ Data.HList.GhcRecord: class LubNarrow a b c | a b -> c
+ Data.HList.GhcRecord: class Narrow a b
+ Data.HList.GhcRecord: class NarrowM a b res | a b -> res
+ Data.HList.GhcRecord: class NarrowM' rin rout b res | rin rout b -> res
+ Data.HList.GhcRecord: class NarrowM'' f r r' | f r -> r'
+ Data.HList.GhcRecord: class RecordEquiv r1 r2 res | r1 r2 -> res
+ Data.HList.GhcRecord: class RecordEquiv' pj1 pj2 res | pj1 pj2 -> res
+ Data.HList.GhcRecord: consLub :: (ConsLub h t l) => h -> t -> l
+ Data.HList.GhcRecord: data NilLub
+ Data.HList.GhcRecord: data ProxyFound x
+ Data.HList.GhcRecord: equivR :: (RecordEquiv r1 r2 res) => Record r1 -> Record r2 -> res
+ Data.HList.GhcRecord: equivR' :: (RecordEquiv' pj1 pj2 res) => pj1 -> pj2 -> res
+ Data.HList.GhcRecord: hConsTcName :: TyCon
+ Data.HList.GhcRecord: hFieldTcName :: TyCon
+ Data.HList.GhcRecord: hLub :: (HLub l e) => l -> [e]
+ Data.HList.GhcRecord: hNilTcName :: TyCon
+ Data.HList.GhcRecord: hUnproxyLabel :: (HUpdateAtHNat n (LVPair l a) t l', HFind l ls n, RecordLabels t ls, HasField l t (Proxy a)) => l -> a -> Record t -> Record l'
+ Data.HList.GhcRecord: hasNoProxies :: (HasNoProxies r) => Record r -> ()
+ Data.HList.GhcRecord: instance [overlap ok] (Fail (ProxyFound x)) => HasNoProxies (HCons (LVPair lab (Proxy x)) l)
+ Data.HList.GhcRecord: instance [overlap ok] (Fail (ProxyFound x)) => HasNoProxies (HCons (Proxy x) l)
+ Data.HList.GhcRecord: instance [overlap ok] (H2ProjectByLabels (HCons l HNil) a rin rout, NarrowM' rin rout b res) => NarrowM a (HCons (LVPair l v) b) res
+ Data.HList.GhcRecord: instance [overlap ok] (HLub (HCons h (HCons h'' t)) e', HLub (HCons h' (HCons h'' t)) e'', LubNarrow e' e'' e, HLub (HCons e (HCons h'' t)) e) => HLub (HCons h (HCons h' (HCons h'' t))) e
+ Data.HList.GhcRecord: instance [overlap ok] (HasNoProxies l) => HasNoProxies (HCons e l)
+ Data.HList.GhcRecord: instance [overlap ok] (LubNarrow e0 e1 e2) => ConsLub e0 [e1] [e2]
+ Data.HList.GhcRecord: instance [overlap ok] (LubNarrow h h' e) => HLub (HCons h (HCons h' HNil)) e
+ Data.HList.GhcRecord: instance [overlap ok] (Narrow rout r', H2ProjectByLabels (HCons l HNil) r (HCons (LVPair l v) HNil) rout) => Narrow r (HCons (LVPair l v) r')
+ Data.HList.GhcRecord: instance [overlap ok] (NarrowM r1 r2 r12, NarrowM r2 r1 r21, RecordEquiv' (Record r1 -> r12) (Record r2 -> r21) res) => RecordEquiv r1 r2 res
+ Data.HList.GhcRecord: instance [overlap ok] (NarrowM rout b res', NarrowM'' f res' res) => NarrowM' (HCons f HNil) rout b res
+ Data.HList.GhcRecord: instance [overlap ok] (RecordLabels a la, RecordLabels b lb, HTIntersect la lb lc, H2ProjectByLabels lc a c aout, H2ProjectByLabels lc b c bout, HRLabelSet c) => LubNarrow (Record a) (Record b) (Record c)
+ Data.HList.GhcRecord: instance [overlap ok] (Typeable x) => Typeable (Proxy x)
+ Data.HList.GhcRecord: instance [overlap ok] (Typeable x) => Typeable (Record x)
+ Data.HList.GhcRecord: instance [overlap ok] (Typeable x, Typeable y) => Typeable (HCons x y)
+ Data.HList.GhcRecord: instance [overlap ok] (Typeable x, Typeable y) => Typeable (LVPair x y)
+ Data.HList.GhcRecord: instance [overlap ok] ConsLub e NilLub [e]
+ Data.HList.GhcRecord: instance [overlap ok] HasNoProxies HNil
+ Data.HList.GhcRecord: instance [overlap ok] Narrow a HNil
+ Data.HList.GhcRecord: instance [overlap ok] NarrowM a HNil (HJust (Record HNil))
+ Data.HList.GhcRecord: instance [overlap ok] NarrowM' HNil rout b HNothing
+ Data.HList.GhcRecord: instance [overlap ok] NarrowM'' f (HJust (Record r)) (HJust (Record (HCons f r)))
+ Data.HList.GhcRecord: instance [overlap ok] NarrowM'' f HNothing HNothing
+ Data.HList.GhcRecord: instance [overlap ok] RecordEquiv' (r1 -> HJust r2) (r2 -> HJust r1) (HJust (r1 -> r2, r2 -> r1))
+ Data.HList.GhcRecord: instance [overlap ok] RecordEquiv' (r1 -> HJust r2) (r2 -> HNothing) HNothing
+ Data.HList.GhcRecord: instance [overlap ok] RecordEquiv' (r1 -> HNothing) pj2 HNothing
+ Data.HList.GhcRecord: instance [overlap ok] Typeable HNil
+ Data.HList.GhcRecord: lubNarrow :: (LubNarrow a b c) => a -> b -> (c, c)
+ Data.HList.GhcRecord: narrow :: (Narrow a b) => Record a -> Record b
+ Data.HList.GhcRecord: narrowM :: (NarrowM a b res) => Record a -> Record b -> res
+ Data.HList.GhcRecord: narrowM' :: (NarrowM' rin rout b res) => rin -> rout -> b -> res
+ Data.HList.GhcRecord: narrowM'' :: (NarrowM'' f r r') => f -> r -> r'
+ Data.HList.GhcRecord: nilLub :: NilLub
+ Data.HList.GhcRecord: proxyTcName :: TyCon
+ Data.HList.GhcRecord: recordTcName :: TyCon
+ Data.HList.GhcSyntax: (.!.) :: (HasField l r v) => r -> l -> v
+ Data.HList.GhcSyntax: (.*.) :: (HExtend e l l') => e -> l -> l'
+ Data.HList.GhcSyntax: (.=.) :: l -> v -> LVPair l v
+ Data.HList.GhcSyntax: type :*: e l = HCons e l
+ Data.HList.GhcSyntax: type :+: e l = HCons (Proxy e) l
+ Data.HList.GhcSyntax: type :=: l v = LVPair l v
+ Data.HList.HArray: class HBetween x y | x -> y
+ Data.HList.HArray: class (HNat n) => HDeleteAtHNat n l l' | n l -> l'
+ Data.HList.HArray: class HDiff x y z | x y -> z
+ Data.HList.HArray: class (HList l, HNat n) => HLength l n | l -> n
+ Data.HList.HArray: class (HNat n) => HLookupByHNat n l e | n l -> e
+ Data.HList.HArray: class HMaxLength l s
+ Data.HList.HArray: class HMinLength l s
+ Data.HList.HArray: class HOrdMember e l b | e l -> b
+ Data.HList.HArray: class HProjectAwayByHNats ns l l' | ns l -> l'
+ Data.HList.HArray: class (HNats ns) => HProjectByHNats ns l l' | ns l -> l'
+ Data.HList.HArray: class HSingleton l
+ Data.HList.HArray: class (HNats ns) => HSplitByHNats' ns l l' l'' | ns l -> l' l''
+ Data.HList.HArray: class (HNat n) => HUpdateAtHNat n e l l' | n e l -> l', l' n -> e
+ Data.HList.HArray: hBetween :: (HBetween x y) => x -> y
+ Data.HList.HArray: hDeleteAtHNat :: (HDeleteAtHNat n l l') => n -> l -> l'
+ Data.HList.HArray: hDiff :: (HDiff x y z) => x -> y -> z
+ Data.HList.HArray: hLength :: (HLength l n) => l -> n
+ Data.HList.HArray: hLookupByHNat :: (HLookupByHNat n l e) => n -> l -> e
+ Data.HList.HArray: hOrdMember :: (HOrdMember e l b) => e -> l -> b
+ Data.HList.HArray: hProjectAwayByHNats :: (HProjectAwayByHNats ns l l') => ns -> l -> l'
+ Data.HList.HArray: hProjectByHNats :: (HProjectByHNats ns l l') => ns -> l -> l'
+ Data.HList.HArray: hSingle :: (HSingleton l, HHead l e) => l -> e
+ Data.HList.HArray: hSplitByHNats' :: (HSplitByHNats' ns l l' l'') => ns -> l -> (l', l'')
+ Data.HList.HArray: hUpdateAtHNat :: (HUpdateAtHNat n e l l') => n -> e -> l -> l'
+ Data.HList.HArray: instance [overlap ok] (HDeleteAtHNat n l l', HNat n) => HDeleteAtHNat (HSucc n) (HCons e l) (HCons e l')
+ Data.HList.HArray: instance [overlap ok] (HEq e e' b1, HOrdMember e l b2, HOr b1 b2 b) => HOrdMember e (HCons e' l) b
+ Data.HList.HArray: instance [overlap ok] (HLength l (HSucc HZero)) => HSingleton l
+ Data.HList.HArray: instance [overlap ok] (HLength l len, HBetween len nats, HDiff nats ns ns', HProjectByHNats ns' l l') => HProjectAwayByHNats ns l l'
+ Data.HList.HArray: instance [overlap ok] (HLength l n, HNat n, HList l) => HLength (HCons a l) (HSucc n)
+ Data.HList.HArray: instance [overlap ok] (HLength l s', HLt s (HSucc s') HTrue) => HMinLength l s
+ Data.HList.HArray: instance [overlap ok] (HLength l s', HLt s' (HSucc s) HTrue) => HMaxLength l s
+ Data.HList.HArray: instance [overlap ok] (HLookupByHNat n (HCons e l) e', HProjectByHNats ns (HCons e l) l') => HProjectByHNats (HCons n ns) (HCons e l) (HCons e' l')
+ Data.HList.HArray: instance [overlap ok] (HLookupByHNat n l (e, b), HUpdateAtHNat n (e, HFalse) l l''', HSplitByHNats' ns l''' l' l'') => HSplitByHNats' (HCons n ns) l (HCons e l') l''
+ Data.HList.HArray: instance [overlap ok] (HLookupByHNat n l e', HNat n) => HLookupByHNat (HSucc n) (HCons e l) e'
+ Data.HList.HArray: instance [overlap ok] (HNat x, HBetween (HSucc x) y, HAppend y (HCons (HSucc x) HNil) z, HList y) => HBetween (HSucc (HSucc x)) z
+ Data.HList.HArray: instance [overlap ok] (HOrdMember e y b, HDiff x y z, HCond b z (HCons e z) z') => HDiff (HCons e x) y z'
+ Data.HList.HArray: instance [overlap ok] (HSplit l l' l'') => HSplitByHNats' HNil l HNil l'
+ Data.HList.HArray: instance [overlap ok] (HUpdateAtHNat n e' l l', HNat n) => HUpdateAtHNat (HSucc n) e' (HCons e l) (HCons e l')
+ Data.HList.HArray: instance [overlap ok] HBetween (HSucc HZero) (HCons HZero HNil)
+ Data.HList.HArray: instance [overlap ok] HDeleteAtHNat HZero (HCons e l) l
+ Data.HList.HArray: instance [overlap ok] HDiff HNil x HNil
+ Data.HList.HArray: instance [overlap ok] HLength HNil HZero
+ Data.HList.HArray: instance [overlap ok] HLookupByHNat HZero (HCons e l) e
+ Data.HList.HArray: instance [overlap ok] HOrdMember e HNil HFalse
+ Data.HList.HArray: instance [overlap ok] HProjectByHNats HNil (HCons e l) HNil
+ Data.HList.HArray: instance [overlap ok] HProjectByHNats HNil HNil HNil
+ Data.HList.HArray: instance [overlap ok] HUpdateAtHNat HZero e' (HCons e l) (HCons e' l)
+ Data.HList.HListPrelude: ApplyHCons :: ApplyHCons
+ Data.HList.HListPrelude: HAddTag :: t -> HAddTag t
+ Data.HList.HListPrelude: HCons :: e -> l -> HCons e l
+ Data.HList.HListPrelude: HMap' :: f -> HMap' f
+ Data.HList.HListPrelude: HNil :: HNil
+ Data.HList.HListPrelude: HRmTag :: HRmTag
+ Data.HList.HListPrelude: HSeq :: x -> HSeq x
+ Data.HList.HListPrelude: HShow :: HShow
+ Data.HList.HListPrelude: Id :: Id
+ Data.HList.HListPrelude: append :: [a] -> [a] -> [a]
+ Data.HList.HListPrelude: append' :: [a] -> [a] -> [a]
+ Data.HList.HListPrelude: apply :: (Apply f a r) => f -> a -> r
+ Data.HList.HListPrelude: class Apply f a r | f a -> r
+ Data.HList.HListPrelude: class FromHJust l l' | l -> l'
+ Data.HList.HListPrelude: class HAppend l l' l'' | l l' -> l''
+ Data.HList.HListPrelude: class HBuild' l a r | r -> a l
+ Data.HList.HListPrelude: class HExtend e l l' | e l -> l', l' -> e l
+ Data.HList.HListPrelude: class (HNat n) => HFind e l n | e l -> n
+ Data.HList.HListPrelude: class (HNat n) => HFind' b e l n | b e l -> n
+ Data.HList.HListPrelude: class (HList l) => HFoldr f v l r | f v l -> r
+ Data.HList.HListPrelude: class HHead l h | l -> h
+ Data.HList.HListPrelude: class HList l
+ Data.HList.HListPrelude: class HList2List l e
+ Data.HList.HListPrelude: class HMap f l l' | f l -> l'
+ Data.HList.HListPrelude: class HMapOut f r e
+ Data.HList.HListPrelude: class (HBool b) => HMember e l b | e l -> b
+ Data.HList.HListPrelude: class HMemberM e l r | e l -> r
+ Data.HList.HListPrelude: class HMemberM' b e l r | b e l -> r
+ Data.HList.HListPrelude: class (HList l) => HNats l
+ Data.HList.HListPrelude: class HReverse l1 l2 | l1 -> l2, l2 -> l1
+ Data.HList.HListPrelude: class HReverse' l1 l2 l3 | l1 l2 -> l3
+ Data.HList.HListPrelude: class HSet l
+ Data.HList.HListPrelude: class HSplit l l' l'' | l -> l' l''
+ Data.HList.HListPrelude: class HStagedEq' b e e'
+ Data.HList.HListPrelude: class HTIntersect l1 l2 l3 | l1 l2 -> l3
+ Data.HList.HListPrelude: class (HBool b) => HTIntersectBool b h t l1 l2 | b h t l1 -> l2
+ Data.HList.HListPrelude: class (HBool b) => HTMember e l b | e l -> b
+ Data.HList.HListPrelude: class HTail l l' | l -> l'
+ Data.HList.HListPrelude: class NaiveHReverse l l' | l -> l'
+ Data.HList.HListPrelude: class ToHJust l l' | l -> l'
+ Data.HList.HListPrelude: data ApplyHCons
+ Data.HList.HListPrelude: data HAddTag t
+ Data.HList.HListPrelude: data HCons e l
+ Data.HList.HListPrelude: data HMap' f
+ Data.HList.HListPrelude: data HNil
+ Data.HList.HListPrelude: data HRmTag
+ Data.HList.HListPrelude: data HSeq x
+ Data.HList.HListPrelude: data HShow
+ Data.HList.HListPrelude: data Id
+ Data.HList.HListPrelude: fromHJust :: (FromHJust l l') => l -> l'
+ Data.HList.HListPrelude: hAddTag :: (HMap (HAddTag t) l l') => t -> l -> l'
+ Data.HList.HListPrelude: hAppend :: (HAppend l l' l'') => l -> l' -> l''
+ Data.HList.HListPrelude: hAppend' :: (HFoldr ApplyHCons v l r) => l -> v -> r
+ Data.HList.HListPrelude: hBuild :: (HBuild' HNil a r) => a -> r
+ Data.HList.HListPrelude: hBuild' :: (HBuild' l a r) => l -> a -> r
+ Data.HList.HListPrelude: hCons :: (HList l) => e -> l -> HCons e l
+ Data.HList.HListPrelude: hEnd :: HCons t t1 -> HCons t t1
+ Data.HList.HListPrelude: hExtend :: (HExtend e l l') => e -> l -> l'
+ Data.HList.HListPrelude: hFind :: (HFind e l n) => e -> l -> n
+ Data.HList.HListPrelude: hFind' :: (HFind' b e l n) => b -> e -> l -> n
+ Data.HList.HListPrelude: hFlag :: (HMap (HAddTag HTrue) l l') => l -> l'
+ Data.HList.HListPrelude: hFoldr :: (HFoldr f v l r) => f -> v -> l -> r
+ Data.HList.HListPrelude: hHead :: (HHead l h) => l -> h
+ Data.HList.HListPrelude: hList2List :: (HList2List l e) => l -> [e]
+ Data.HList.HListPrelude: hMap :: (HMap f l l') => f -> l -> l'
+ Data.HList.HListPrelude: hMap' :: (HFoldr (HMap' f) HNil l r) => f -> l -> r
+ Data.HList.HListPrelude: hMapM :: (Monad m, HMapOut f l (m e)) => f -> l -> [m e]
+ Data.HList.HListPrelude: hMapM_ :: (Monad m, HMapOut f l (m ())) => f -> l -> m ()
+ Data.HList.HListPrelude: hMapOut :: (HMapOut f r e) => f -> r -> [e]
+ Data.HList.HListPrelude: hMember :: (HMember e l b) => e -> l -> b
+ Data.HList.HListPrelude: hNil :: HNil
+ Data.HList.HListPrelude: hReverse :: (HReverse l1 l2) => l1 -> l2
+ Data.HList.HListPrelude: hReverse' :: (HReverse' l1 l2 l3) => l1 -> l2 -> l3
+ Data.HList.HListPrelude: hRmTag :: (HMap HRmTag l l') => l -> l'
+ Data.HList.HListPrelude: hSplit :: (HSplit l l' l'') => l -> (l', l'')
+ Data.HList.HListPrelude: hStagedEq' :: (HStagedEq' b e e') => b -> e -> e' -> Bool
+ Data.HList.HListPrelude: hTIntersect :: (HTIntersect l1 l2 l3) => l1 -> l2 -> l3
+ Data.HList.HListPrelude: hTIntersectBool :: (HTIntersectBool b h t l1 l2) => b -> h -> t -> l1 -> l2
+ Data.HList.HListPrelude: hTMember :: (HTMember e l b) => e -> l -> b
+ Data.HList.HListPrelude: hTail :: (HTail l l') => l -> l'
+ Data.HList.HListPrelude: instance [overlap ok] (Apply f e e') => Apply (HMap' f) (e, l) (HCons e' l)
+ Data.HList.HListPrelude: instance [overlap ok] (Apply f x y, HMap f xs ys) => HMap f (HCons x xs) (HCons y ys)
+ Data.HList.HListPrelude: instance [overlap ok] (Eq e) => HStagedEq' HTrue e e
+ Data.HList.HListPrelude: instance [overlap ok] (Eq e, Eq l) => Eq (HCons e l)
+ Data.HList.HListPrelude: instance [overlap ok] (FromHJust l l') => FromHJust (HCons (HJust e) l) (HCons e l')
+ Data.HList.HListPrelude: instance [overlap ok] (FromHJust l l') => FromHJust (HCons HNothing l) l'
+ Data.HList.HListPrelude: instance [overlap ok] (HBuild' (HCons a l) b r) => HBuild' l a (b -> r)
+ Data.HList.HListPrelude: instance [overlap ok] (HEq e e' b, HFind' b e l n) => HFind e (HCons e' l) n
+ Data.HList.HListPrelude: instance [overlap ok] (HEq e e' b, HMember e l b', HOr b b' b'') => HMember e (HCons e' l) b''
+ Data.HList.HListPrelude: instance [overlap ok] (HEq e e' b, HMemberM' b e (HCons e' l) res) => HMemberM e (HCons e' l) res
+ Data.HList.HListPrelude: instance [overlap ok] (HFind e l n) => HFind' HFalse e l (HSucc n)
+ Data.HList.HListPrelude: instance [overlap ok] (HFoldr f v l r, Apply f (e, r) r') => HFoldr f v (HCons e l) r'
+ Data.HList.HListPrelude: instance [overlap ok] (HList l) => Apply ApplyHCons (e, l) (HCons e l)
+ Data.HList.HListPrelude: instance [overlap ok] (HList l) => HAppend HNil l l
+ Data.HList.HListPrelude: instance [overlap ok] (HList l) => HEq (HCons e l) HNil HFalse
+ Data.HList.HListPrelude: instance [overlap ok] (HList l) => HEq HNil (HCons e l) HFalse
+ Data.HList.HListPrelude: instance [overlap ok] (HList l) => HExtend e (HCons e' l) (HCons e (HCons e' l))
+ Data.HList.HListPrelude: instance [overlap ok] (HList l) => HList (HCons e l)
+ Data.HList.HListPrelude: instance [overlap ok] (HList l, HAppend l l' l'') => HAppend (HCons x l) l' (HCons x l'')
+ Data.HList.HListPrelude: instance [overlap ok] (HList l, HList l', HEq e e' b, HEq l l' b', HAnd b b' b'') => HEq (HCons e l) (HCons e' l') b''
+ Data.HList.HListPrelude: instance [overlap ok] (HList2List l e) => HList2List (HCons e l) e
+ Data.HList.HListPrelude: instance [overlap ok] (HMapOut f l e', Apply f e e') => HMapOut f (HCons e l) e'
+ Data.HList.HListPrelude: instance [overlap ok] (HMember e l HFalse, HSet l) => HSet (HCons e l)
+ Data.HList.HListPrelude: instance [overlap ok] (HMemberM e l r, HMemberM' r e (HCons e' l) res) => HMemberM' HFalse e (HCons e' l) res
+ Data.HList.HListPrelude: instance [overlap ok] (HNat n, HNats ns) => HNats (HCons n ns)
+ Data.HList.HListPrelude: instance [overlap ok] (HReverse (HCons a l) (HCons a' l')) => HBuild' l a (HCons a' l')
+ Data.HList.HListPrelude: instance [overlap ok] (HReverse' (HCons a l1) l2' l3) => HReverse' l1 (HCons a l2') l3
+ Data.HList.HListPrelude: instance [overlap ok] (HReverse' HNil l2 l3, HReverse' HNil l3 l2) => HReverse l2 l3
+ Data.HList.HListPrelude: instance [overlap ok] (HSplit l l' l'') => HSplit (HCons (e, HFalse) l) l' (HCons e l'')
+ Data.HList.HListPrelude: instance [overlap ok] (HSplit l l' l'') => HSplit (HCons (e, HTrue) l) (HCons e l') l''
+ Data.HList.HListPrelude: instance [overlap ok] (HTIntersect t l1 l2) => HTIntersectBool HFalse h t l1 l2
+ Data.HList.HListPrelude: instance [overlap ok] (HTIntersect t l1 l2) => HTIntersectBool HTrue h t l1 (HCons h l2)
+ Data.HList.HListPrelude: instance [overlap ok] (HTMember h l1 b, HTIntersectBool b h t l1 l2) => HTIntersect (HCons h t) l1 l2
+ Data.HList.HListPrelude: instance [overlap ok] (Monad m, Apply f x (m ())) => Apply (HSeq f) (x, m ()) (m ())
+ Data.HList.HListPrelude: instance [overlap ok] (NaiveHReverse l l', HAppend l' (HCons e HNil) l'') => NaiveHReverse (HCons e l) l''
+ Data.HList.HListPrelude: instance [overlap ok] (Read e, Read l) => Read (HCons e l)
+ Data.HList.HListPrelude: instance [overlap ok] (Show e, Show l) => Show (HCons e l)
+ Data.HList.HListPrelude: instance [overlap ok] (Show x) => Apply HShow x (IO ())
+ Data.HList.HListPrelude: instance [overlap ok] (ToHJust l l') => ToHJust (HCons e l) (HCons (HJust e) l')
+ Data.HList.HListPrelude: instance [overlap ok] (TypeEq e e' b, HStagedEq l l', HStagedEq' b e e') => HStagedEq (HCons e l) (HCons e' l')
+ Data.HList.HListPrelude: instance [overlap ok] (TypeEq e e' b, HTMember e l b', HOr b b' b'') => HTMember e (HCons e' l) b''
+ Data.HList.HListPrelude: instance [overlap ok] Apply (HAddTag t) e (e, t)
+ Data.HList.HListPrelude: instance [overlap ok] Apply (x -> y) x y
+ Data.HList.HListPrelude: instance [overlap ok] Apply HRmTag (e, t) e
+ Data.HList.HListPrelude: instance [overlap ok] Apply Id x x
+ Data.HList.HListPrelude: instance [overlap ok] Eq HNil
+ Data.HList.HListPrelude: instance [overlap ok] FromHJust HNil HNil
+ Data.HList.HListPrelude: instance [overlap ok] HEq HNil HNil HTrue
+ Data.HList.HListPrelude: instance [overlap ok] HExtend e HNil (HCons e HNil)
+ Data.HList.HListPrelude: instance [overlap ok] HFind' HTrue e l HZero
+ Data.HList.HListPrelude: instance [overlap ok] HFoldr f v HNil v
+ Data.HList.HListPrelude: instance [overlap ok] HHead (HCons e l) e
+ Data.HList.HListPrelude: instance [overlap ok] HList HNil
+ Data.HList.HListPrelude: instance [overlap ok] HList2List HNil e
+ Data.HList.HListPrelude: instance [overlap ok] HMap f HNil HNil
+ Data.HList.HListPrelude: instance [overlap ok] HMapOut f HNil e
+ Data.HList.HListPrelude: instance [overlap ok] HMember e HNil HFalse
+ Data.HList.HListPrelude: instance [overlap ok] HMemberM e HNil HNothing
+ Data.HList.HListPrelude: instance [overlap ok] HMemberM' (HJust l') e (HCons e' l) (HJust (HCons e' l'))
+ Data.HList.HListPrelude: instance [overlap ok] HMemberM' HNothing e l HNothing
+ Data.HList.HListPrelude: instance [overlap ok] HMemberM' HTrue e (HCons e l) (HJust l)
+ Data.HList.HListPrelude: instance [overlap ok] HNats HNil
+ Data.HList.HListPrelude: instance [overlap ok] HReverse' l1 HNil l1
+ Data.HList.HListPrelude: instance [overlap ok] HSet HNil
+ Data.HList.HListPrelude: instance [overlap ok] HSplit HNil HNil HNil
+ Data.HList.HListPrelude: instance [overlap ok] HStagedEq (HCons e l) HNil
+ Data.HList.HListPrelude: instance [overlap ok] HStagedEq HNil (HCons e l)
+ Data.HList.HListPrelude: instance [overlap ok] HStagedEq HNil HNil
+ Data.HList.HListPrelude: instance [overlap ok] HStagedEq' HFalse e e'
+ Data.HList.HListPrelude: instance [overlap ok] HTIntersect HNil l HNil
+ Data.HList.HListPrelude: instance [overlap ok] HTMember e HNil HFalse
+ Data.HList.HListPrelude: instance [overlap ok] HTail (HCons e l) l
+ Data.HList.HListPrelude: instance [overlap ok] NaiveHReverse HNil HNil
+ Data.HList.HListPrelude: instance [overlap ok] Read HNil
+ Data.HList.HListPrelude: instance [overlap ok] Show HNil
+ Data.HList.HListPrelude: instance [overlap ok] ToHJust HNil HNil
+ Data.HList.HListPrelude: naiveHReverse :: (NaiveHReverse l l') => l -> l'
+ Data.HList.HListPrelude: toHJust :: (ToHJust l l') => l -> l'
+ Data.HList.HOccurs: class HOccurs e l
+ Data.HList.HOccurs: class HOccurs' e l
+ Data.HList.HOccurs: class HOccursBool b e l
+ Data.HList.HOccurs: class HOccursFst e l
+ Data.HList.HOccurs: class HOccursMany e l
+ Data.HList.HOccurs: class HOccursMany1 e l
+ Data.HList.HOccurs: class HOccursNot e l
+ Data.HList.HOccurs: class HOccursOpt e l
+ Data.HList.HOccurs: class HProject l l'
+ Data.HList.HOccurs: data TypeFound e
+ Data.HList.HOccurs: data TypeNotFound e
+ Data.HList.HOccurs: hOccurs :: (HOccurs e l) => l -> e
+ Data.HList.HOccurs: hOccurs' :: (HOccurs' e l) => l -> e
+ Data.HList.HOccurs: hOccursBool :: (HOccursBool b e l) => b -> l -> e
+ Data.HList.HOccurs: hOccursFst :: (HOccursFst e l) => l -> e
+ Data.HList.HOccurs: hOccursMany :: (HOccursMany e l) => l -> [e]
+ Data.HList.HOccurs: hOccursMany1 :: (HOccursMany1 e l) => l -> (e, [e])
+ Data.HList.HOccurs: hOccursOpt :: (HOccursOpt e l) => l -> Maybe e
+ Data.HList.HOccurs: hProject :: (HProject l l') => l -> l'
+ Data.HList.HOccurs: instance [overlap ok] (Fail (TypeFound e)) => HOccursNot e (HCons e l)
+ Data.HList.HOccurs: instance [overlap ok] (Fail (TypeNotFound e)) => HOccurs e HNil
+ Data.HList.HOccurs: instance [overlap ok] (HList l', HOccurs e l, HProject l l') => HProject l (HCons e l')
+ Data.HList.HOccurs: instance [overlap ok] (HList l) => HOccursFst e (HCons e l)
+ Data.HList.HOccurs: instance [overlap ok] (HList l, HOccursNot e l) => HOccurs e (HCons e l)
+ Data.HList.HOccurs: instance [overlap ok] (HList l, HOccursNot e l) => HOccursBool HTrue e (HCons e l)
+ Data.HList.HOccurs: instance [overlap ok] (HOccurs e l, HList l) => HOccurs e (HCons e' l)
+ Data.HList.HOccurs: instance [overlap ok] (HOccurs' e l, HList l) => HOccursBool HFalse e (HCons e' l)
+ Data.HList.HOccurs: instance [overlap ok] (HOccursFst e l, HList l) => HOccursFst e (HCons e' l)
+ Data.HList.HOccurs: instance [overlap ok] (HOccursMany e l, HList l) => HOccursMany e (HCons e l)
+ Data.HList.HOccurs: instance [overlap ok] (HOccursMany e l, HList l) => HOccursMany e (HCons e' l)
+ Data.HList.HOccurs: instance [overlap ok] (HOccursMany e l, HList l) => HOccursMany1 e (HCons e l)
+ Data.HList.HOccurs: instance [overlap ok] (HOccursMany1 e l, HList l) => HOccursMany1 e (HCons e' l)
+ Data.HList.HOccurs: instance [overlap ok] (HOccursNot e l) => HOccursNot e (HCons e' l)
+ Data.HList.HOccurs: instance [overlap ok] (HOccursOpt e l) => HOccursOpt e (HCons e' l)
+ Data.HList.HOccurs: instance [overlap ok] (TypeEq e e' b, HOccursBool b e (HCons e' l)) => HOccurs' e (HCons e' l)
+ Data.HList.HOccurs: instance [overlap ok] HOccursMany e HNil
+ Data.HList.HOccurs: instance [overlap ok] HOccursNot e HNil
+ Data.HList.HOccurs: instance [overlap ok] HOccursOpt e (HCons e l)
+ Data.HList.HOccurs: instance [overlap ok] HOccursOpt e HNil
+ Data.HList.HOccurs: instance [overlap ok] HProject l HNil
+ Data.HList.HTypeIndexed: class HDeleteMany e l l' | e l -> l'
+ Data.HList.HTypeIndexed: class HDeleteManyCase b e e' l l' | b e e' l -> l'
+ Data.HList.HTypeIndexed: class (HNat n) => HType2HNat e l n | e l -> n
+ Data.HList.HTypeIndexed: class (HBool b, HNat n) => HType2HNatCase b e l n | b e l -> n
+ Data.HList.HTypeIndexed: class HTypes2HNats ps l ns | ps l -> ns
+ Data.HList.HTypeIndexed: hDeleteAtProxy :: (HDeleteAtHNat n l l', HType2HNat e l n) => Proxy e -> l -> l'
+ Data.HList.HTypeIndexed: hDeleteMany :: (HDeleteMany e l l') => Proxy e -> l -> l'
+ Data.HList.HTypeIndexed: hDeleteManyCase :: (HDeleteManyCase b e e' l l') => b -> Proxy e -> e' -> l -> l'
+ Data.HList.HTypeIndexed: hProjectByProxies :: (HProjectByHNats ns l l', HTypes2HNats ps l ns) => ps -> l -> l'
+ Data.HList.HTypeIndexed: hSplitByProxies :: (HMap (HAddTag HTrue) l l', HSplitByHNats' ns l' l'1 l'', HTypes2HNats ps l ns) => ps -> l -> (l'1, l'')
+ Data.HList.HTypeIndexed: hType2HNat :: (HType2HNat e l n) => Proxy e -> l -> n
+ Data.HList.HTypeIndexed: hTypes2HNats :: (HTypes2HNats ps l ns) => ps -> l -> ns
+ Data.HList.HTypeIndexed: hUpdateAtType :: (HUpdateAtHNat n e l l', HType2HNat e l n) => e -> l -> l'
+ Data.HList.HTypeIndexed: instance [overlap ok] (HDeleteMany e l l') => HDeleteManyCase HFalse e e' l (HCons e' l')
+ Data.HList.HTypeIndexed: instance [overlap ok] (HDeleteMany e l l') => HDeleteManyCase HTrue e e l l'
+ Data.HList.HTypeIndexed: instance [overlap ok] (HList l, TypeEq e e' b, HDeleteManyCase b e e' l l') => HDeleteMany e (HCons e' l) l'
+ Data.HList.HTypeIndexed: instance [overlap ok] (HOccursNot e l) => HType2HNatCase HTrue e l HZero
+ Data.HList.HTypeIndexed: instance [overlap ok] (HType2HNat e l n) => HType2HNatCase HFalse e l (HSucc n)
+ Data.HList.HTypeIndexed: instance [overlap ok] (HType2HNat e l n, HTypes2HNats ps l ns) => HTypes2HNats (HCons (Proxy e) ps) l (HCons n ns)
+ Data.HList.HTypeIndexed: instance [overlap ok] (TypeEq e' e b, HType2HNatCase b e l n) => HType2HNat e (HCons e' l) n
+ Data.HList.HTypeIndexed: instance [overlap ok] HDeleteMany e HNil HNil
+ Data.HList.HTypeIndexed: instance [overlap ok] HTypes2HNats HNil l HNil
+ Data.HList.HZip: class HZip x y l | x y -> l, l -> x y
+ Data.HList.HZip: class HZippable x y
+ Data.HList.HZip: hUnzip :: (HZip x y l) => l -> (x, y)
+ Data.HList.HZip: hZip :: (HZip x y l) => x -> y -> l
+ Data.HList.HZip: instance [overlap ok] (HZip tx ty l) => HZip (HCons hx tx) (HCons hy ty) (HCons (hx, hy) l)
+ Data.HList.HZip: instance [overlap ok] (HZippable l l') => HZippable (HCons e l) (HCons e' l')
+ Data.HList.HZip: instance [overlap ok] HZip HNil HNil HNil
+ Data.HList.HZip: instance [overlap ok] HZippable HNil HNil
+ Data.HList.Label1: Label :: x -> Label x
+ Data.HList.Label1: firstLabel :: Label HZero
+ Data.HList.Label1: instance [overlap ok] (HEq n n' b) => HEq (Label n) (Label n') b
+ Data.HList.Label1: instance [overlap ok] (Show n) => ShowLabel (Label n)
+ Data.HList.Label1: instance [overlap ok] (Show x) => Show (Label x)
+ Data.HList.Label1: label :: (HNat n) => n -> Label n
+ Data.HList.Label1: newtype Label x
+ Data.HList.Label1: nextLabel :: (HNat t) => Label t -> Label (HSucc t)
+ Data.HList.Label2: data (HNat x) => Label x ns desc
+ Data.HList.Label2: firstLabel :: ns -> desc -> Label HZero ns desc
+ Data.HList.Label2: instance [overlap ok] (HEq x x' b) => HEq (Label x ns desc1) (Label x' ns desc2) b
+ Data.HList.Label2: instance [overlap ok] (HNat x, HNat2Integral x, Show ns) => Show (Label x ns desc)
+ Data.HList.Label2: instance [overlap ok] (HNat x, Show desc) => ShowLabel (Label x ns desc)
+ Data.HList.Label2: nextLabel :: Label x ns desc -> desc' -> Label (HSucc x) ns desc'
+ Data.HList.Label3: data (HNat x) => Label x ns desc
+ Data.HList.Label3: firstLabel :: ns -> desc -> Label HZero ns desc
+ Data.HList.Label3: instance [overlap ok] (HEq x x' b, TypeEq ns ns' b', HAnd b b' b'') => HEq (Label x ns desc) (Label x' ns' desc') b''
+ Data.HList.Label3: instance [overlap ok] (HNat x, Show desc) => Show (Label x ns desc)
+ Data.HList.Label3: instance [overlap ok] (HNat x, Show desc) => ShowLabel (Label x ns desc)
+ Data.HList.Label3: nextLabel :: Label x ns desc -> desc' -> Label (HSucc x) ns desc'
+ Data.HList.Label4: instance [overlap ok] (TypeEq x y b) => HEq (Proxy x) (Proxy y) b
+ Data.HList.Label4: instance [overlap ok] (Typeable x) => ShowLabel (Proxy x)
+ Data.HList.Label5: instance [overlap ok] (TypeEq x y b) => HEq x y b
+ Data.HList.Label5: instance [overlap ok] (Typeable x) => ShowLabel x
+ Data.HList.Record: LVPair :: v -> LVPair l v
+ Data.HList.Record: Record :: r -> Record r
+ Data.HList.Record: class H2ProjectByLabels ls r rin rout | ls r -> rin rout
+ Data.HList.Record: class H2ProjectByLabels' b ls r rin rout | b ls r -> rin rout
+ Data.HList.Record: class HLabelSet ls
+ Data.HList.Record: class HLeftUnion r r' r'' | r r' -> r''
+ Data.HList.Record: class HLeftUnionBool b r f r' | b r f -> r'
+ Data.HList.Record: class HRLabelSet ps
+ Data.HList.Record: class HasField l r v | l r -> v
+ Data.HList.Record: class HasField' b l r v | b l r -> v
+ Data.HList.Record: class RecordLabels r ls | r -> ls
+ Data.HList.Record: class ShowComponents l
+ Data.HList.Record: class ShowLabel l
+ Data.HList.Record: class UnionSymRec r1 r2 ru | r1 r2 -> ru
+ Data.HList.Record: class UnionSymRec' b r1 f2 r2' ru | b r1 f2 r2' -> ru
+ Data.HList.Record: emptyRecord :: Record HNil
+ Data.HList.Record: h2projectByLabels :: (H2ProjectByLabels ls r rin rout) => ls -> r -> (rin, rout)
+ Data.HList.Record: h2projectByLabels' :: (H2ProjectByLabels' b ls r rin rout) => b -> ls -> r -> (rin, rout)
+ Data.HList.Record: hLeftUnion :: (HLeftUnion r r' r'') => r -> r' -> r''
+ Data.HList.Record: hLeftUnionBool :: (HLeftUnionBool b r f r') => b -> r -> f -> r'
+ Data.HList.Record: hLookupByLabel :: (HasField l r v) => l -> r -> v
+ Data.HList.Record: hLookupByLabel' :: (HasField' b l r v) => b -> l -> r -> v
+ Data.HList.Record: hProjectByLabels :: (HRLabelSet a, H2ProjectByLabels ls t a b) => ls -> Record t -> Record a
+ Data.HList.Record: instance [overlap ok] (H2ProjectByLabels ls r' rin rout) => H2ProjectByLabels' HNothing ls (HCons f' r') rin (HCons f' rout)
+ Data.HList.Record: instance [overlap ok] (H2ProjectByLabels ls' r' rin rout) => H2ProjectByLabels' (HJust ls') ls (HCons f' r') (HCons f' rin) rout
+ Data.HList.Record: instance [overlap ok] (HEq l l' b, HasField' b l (HCons (LVPair l' v') r) v) => HasField l (HCons (LVPair l' v') r) v
+ Data.HList.Record: instance [overlap ok] (HEq l1 l2 HFalse, HRLabelSet (HCons (LVPair l2 v2) r), HRLabelSet (HCons (LVPair l1 v1) r)) => HRLabelSet (HCons (LVPair l1 v1) (HCons (LVPair l2 v2) r))
+ Data.HList.Record: instance [overlap ok] (HMember x ls HFalse, HLabelSet ls) => HLabelSet (HCons x ls)
+ Data.HList.Record: instance [overlap ok] (HMemberM l' (HCons l ls) b, H2ProjectByLabels' b (HCons l ls) (HCons (LVPair l' v') r') rin rout) => H2ProjectByLabels (HCons l ls) (HCons (LVPair l' v') r') rin rout
+ Data.HList.Record: instance [overlap ok] (HRLabelSet (HCons (LVPair l v) r)) => HExtend (LVPair l v) (Record r) (Record (HCons (LVPair l v) r))
+ Data.HList.Record: instance [overlap ok] (HRLabelSet r'', HAppend r r' r'') => HAppend (Record r) (Record r') (Record r'')
+ Data.HList.Record: instance [overlap ok] (HasField l r v) => HasField l (Record r) v
+ Data.HList.Record: instance [overlap ok] (HasField l r v) => HasField' HFalse l (HCons fld r) v
+ Data.HList.Record: instance [overlap ok] (RecordLabels r ls, HMember l ls b, HLeftUnionBool b r (LVPair l v) r''', HLeftUnion (Record r''') (Record r') r'') => HLeftUnion (Record r) (Record (HCons (LVPair l v) r')) r''
+ Data.HList.Record: instance [overlap ok] (RecordLabels r' ls) => RecordLabels (HCons (LVPair l v) r') (HCons l ls)
+ Data.HList.Record: instance [overlap ok] (RecordLabels r' ls, H2ProjectByLabels ls r r' rout) => SubType (Record r) (Record r')
+ Data.HList.Record: instance [overlap ok] (RecordLabels r1 ls, HMember l ls b, UnionSymRec' b (Record r1) (LVPair l v) (Record r2') ru) => UnionSymRec (Record r1) (Record (HCons (LVPair l v) r2')) ru
+ Data.HList.Record: instance [overlap ok] (ShowComponents r) => Show (Record r)
+ Data.HList.Record: instance [overlap ok] (ShowLabel l, Show v, ShowComponents r) => ShowComponents (HCons (LVPair l v) r)
+ Data.HList.Record: instance [overlap ok] (UnionSymRec r1 r2' (Record ru), HExtend f2 (Record ru) (Record (HCons f2 ru))) => UnionSymRec' HFalse r1 f2 r2' (Record (HCons f2 ru))
+ Data.HList.Record: instance [overlap ok] (UnionSymRec r1 r2' (Record ru), HasField l2 ru v2, HUpdateAtHNat n (LVPair l2 v2) ru ru, RecordLabels ru ls, HFind l2 ls n) => UnionSymRec' HTrue r1 (LVPair l2 v2) r2' (Record ru)
+ Data.HList.Record: instance [overlap ok] H2ProjectByLabels (HCons l ls) HNil HNil HNil
+ Data.HList.Record: instance [overlap ok] H2ProjectByLabels HNil r HNil r
+ Data.HList.Record: instance [overlap ok] HLabelSet HNil
+ Data.HList.Record: instance [overlap ok] HLeftUnion r (Record HNil) r
+ Data.HList.Record: instance [overlap ok] HLeftUnionBool HFalse r f (HCons f r)
+ Data.HList.Record: instance [overlap ok] HLeftUnionBool HTrue r f r
+ Data.HList.Record: instance [overlap ok] HRLabelSet (HCons x HNil)
+ Data.HList.Record: instance [overlap ok] HRLabelSet HNil
+ Data.HList.Record: instance [overlap ok] HasField' HTrue l (HCons (LVPair l v) r) v
+ Data.HList.Record: instance [overlap ok] RecordLabels HNil HNil
+ Data.HList.Record: instance [overlap ok] ShowComponents HNil
+ Data.HList.Record: instance [overlap ok] UnionSymRec r1 (Record HNil) r1
+ Data.HList.Record: labelLVPair :: LVPair l v -> l
+ Data.HList.Record: mkRecord :: (HRLabelSet r) => r -> Record r
+ Data.HList.Record: newLVPair :: l -> v -> LVPair l v
+ Data.HList.Record: newtype LVPair l v
+ Data.HList.Record: newtype Record r
+ Data.HList.Record: recordLabels :: (RecordLabels r ls) => r -> ls
+ Data.HList.Record: showComponents :: (ShowComponents l) => String -> l -> String
+ Data.HList.Record: showLabel :: (ShowLabel l) => l -> String
+ Data.HList.Record: unionSR :: (UnionSymRec r1 r2 ru) => r1 -> r2 -> (ru, ru)
+ Data.HList.Record: unionSR' :: (UnionSymRec' b r1 f2 r2' ru) => b -> r1 -> f2 -> r2' -> (ru, ru)
+ Data.HList.Record: valueLVPair :: LVPair l v -> v
+ Data.HList.RecordP: RecordP :: vs -> RecordP ls vs
+ Data.HList.RecordP: class HProjectByLabelP l ls vs lso v vso | l ls vs -> lso v vso
+ Data.HList.RecordP: class HProjectByLabelP' b l ls vs lso v vso | b l ls vs -> lso v vso
+ Data.HList.RecordP: class HSameLength l1 l2
+ Data.HList.RecordP: class HasFieldP' b l r v | b l r -> v
+ Data.HList.RecordP: class (HRLabelSet r) => RecordR2P r ls vs | r -> ls vs, ls vs -> r
+ Data.HList.RecordP: emptyRecordP :: RecordP HNil HNil
+ Data.HList.RecordP: h2ProjectByLabelP :: (HProjectByLabelP l ls vs lso v vso) => l -> RecordP ls vs -> (v, RecordP lso vso)
+ Data.HList.RecordP: h2ProjectByLabelP' :: (HProjectByLabelP' b l ls vs lso v vso) => b -> l -> RecordP ls vs -> (v, RecordP lso vso)
+ Data.HList.RecordP: hDeleteAtLabelP :: (HProjectByLabelP l ls vs lso v vso) => l -> RecordP ls vs -> RecordP lso vso
+ Data.HList.RecordP: hLookupByLabelP' :: (HasFieldP' b l r v) => b -> l -> r -> v
+ Data.HList.RecordP: hUpdateAtLabelP :: (HUpdateAtHNat n e1 t1 l', HFind e t n) => e -> e1 -> RecordP t t1 -> RecordP ls l'
+ Data.HList.RecordP: instance [overlap ok] (H2ProjectByLabels ls (RecordP ls' vs') (RecordP lin vin) rout) => H2ProjectByLabels' HTrue ls (RecordP (HCons l' ls') (HCons v' vs')) (RecordP (HCons l' lin) (HCons v' vin)) rout
+ Data.HList.RecordP: instance [overlap ok] (H2ProjectByLabels ls (RecordP ls' vs') rin (RecordP lo vo)) => H2ProjectByLabels' HFalse ls (RecordP (HCons l' ls') (HCons v' vs')) rin (RecordP (HCons l' lo) (HCons v' vo))
+ Data.HList.RecordP: instance [overlap ok] (H2ProjectByLabels ls' (RecordP ls vs) (RecordP ls' vs') rout) => SubType (RecordP ls vs) (RecordP ls' vs')
+ Data.HList.RecordP: instance [overlap ok] (HEq l l' b, HProjectByLabelP' b l (HCons l' ls) vs lso v vso) => HProjectByLabelP l (HCons l' ls) vs lso v vso
+ Data.HList.RecordP: instance [overlap ok] (HEq l l' b, HasFieldP' b l (RecordP (HCons l' ls) vs) v) => HasField l (RecordP (HCons l' ls) vs) v
+ Data.HList.RecordP: instance [overlap ok] (HLabelSet (HCons l ls), HSameLength ls vs) => HExtend (LVPair l v) (RecordP ls vs) (RecordP (HCons l ls) (HCons v vs))
+ Data.HList.RecordP: instance [overlap ok] (HLabelSet ls'', HAppend ls ls' ls'', HAppend vs vs' vs'', HSameLength ls'' vs'') => HAppend (RecordP ls vs) (RecordP ls' vs') (RecordP ls'' vs'')
+ Data.HList.RecordP: instance [overlap ok] (HMember l' ls b, H2ProjectByLabels' b ls (RecordP (HCons l' ls') vs') rin rout) => H2ProjectByLabels ls (RecordP (HCons l' ls') vs') rin rout
+ Data.HList.RecordP: instance [overlap ok] (HProjectByLabelP l ls vs lso' v vso') => HProjectByLabelP' HFalse l (HCons l' ls) (HCons v' vs) (HCons l' lso') v (HCons v' vso')
+ Data.HList.RecordP: instance [overlap ok] (HSameLength l1 l2) => HSameLength (HCons e1 l1) (HCons e2 l2)
+ Data.HList.RecordP: instance [overlap ok] (HasField l (RecordP ls vs) v) => HasFieldP' HFalse l (RecordP (HCons l' ls) (HCons v' vs)) v
+ Data.HList.RecordP: instance [overlap ok] (RecordR2P r ls vs, HRLabelSet (HCons (LVPair l v) r), HLabelSet (HCons l ls), HSameLength ls vs) => RecordR2P (HCons (LVPair l v) r) (HCons l ls) (HCons v vs)
+ Data.HList.RecordP: instance [overlap ok] (RecordR2P r ls vs, ShowComponents r, HRLabelSet r) => Show (RecordP ls vs)
+ Data.HList.RecordP: instance [overlap ok] H2ProjectByLabels (HCons l ls) (RecordP HNil HNil) (RecordP HNil HNil) (RecordP HNil HNil)
+ Data.HList.RecordP: instance [overlap ok] HProjectByLabelP' HTrue l (HCons l ls) (HCons v vs) ls v vs
+ Data.HList.RecordP: instance [overlap ok] HSameLength HNil HNil
+ Data.HList.RecordP: instance [overlap ok] HasFieldP' HTrue l (RecordP (HCons l ls) (HCons v vs)) v
+ Data.HList.RecordP: instance [overlap ok] RecordR2P HNil HNil HNil
+ Data.HList.RecordP: labels_of_recordp :: RecordP ls vs -> ls
+ Data.HList.RecordP: mkRecordP :: (HSameLength ls vs, HLabelSet ls) => ls -> vs -> RecordP ls vs
+ Data.HList.RecordP: newtype RecordP ls vs
+ Data.HList.RecordP: record_p2r :: (RecordR2P r ls vs) => RecordP ls vs -> Record r
+ Data.HList.RecordP: record_r2p :: (RecordR2P r ls vs) => Record r -> RecordP ls vs
+ Data.HList.TIC: TIC :: Dynamic -> TIC l
+ Data.HList.TIC: class HTypeProxied l
+ Data.HList.TIC: data TIC l
+ Data.HList.TIC: instance [overlap ok] (HTypeProxied l) => HTypeProxied (HCons (Proxy e) l)
+ Data.HList.TIC: instance [overlap ok] HTypeProxied HNil
+ Data.HList.TIC: instance [overlap ok] Show (TIC l)
+ Data.HList.TIC: mkTIC :: (HTypeIndexed l, HTypeProxied l, HOccurs (Proxy i) l, Typeable i) => i -> TIC l
+ Data.HList.TIC: unTIC :: (HTypeIndexed l, HTypeProxied l, HOccurs (Proxy o) l, Typeable o) => TIC l -> Maybe o
+ Data.HList.TIP: TIP :: l -> TIP l
+ Data.HList.TIP: class (HList l) => HTypeIndexed l
+ Data.HList.TIP: emptyTIP :: TIP HNil
+ Data.HList.TIP: instance [overlap ok] (HAppend l l' l'', HTypeIndexed l'') => HAppend (TIP l) (TIP l') (TIP l'')
+ Data.HList.TIP: instance [overlap ok] (HOccurs e (HCons x (HCons y l))) => HOccurs e (TIP (HCons x (HCons y l)))
+ Data.HList.TIP: instance [overlap ok] (HOccurs e l, SubType (TIP l) (TIP l')) => SubType (TIP l) (TIP (HCons e l'))
+ Data.HList.TIP: instance [overlap ok] (HOccursFst e l) => HOccursFst e (TIP l)
+ Data.HList.TIP: instance [overlap ok] (HOccursMany e l) => HOccursMany e (TIP l)
+ Data.HList.TIP: instance [overlap ok] (HOccursMany1 e l) => HOccursMany1 e (TIP l)
+ Data.HList.TIP: instance [overlap ok] (HOccursNot e l) => HOccursNot e (TIP l)
+ Data.HList.TIP: instance [overlap ok] (HOccursNot e l, HTypeIndexed l) => HExtend e (TIP l) (TIP (HCons e l))
+ Data.HList.TIP: instance [overlap ok] (HOccursNot e l, HTypeIndexed l) => HTypeIndexed (HCons e l)
+ Data.HList.TIP: instance [overlap ok] (HOccursOpt e l) => HOccursOpt e (TIP l)
+ Data.HList.TIP: instance [overlap ok] (Read l) => Read (TIP l)
+ Data.HList.TIP: instance [overlap ok] (Show l) => Show (TIP l)
+ Data.HList.TIP: instance [overlap ok] (TypeCast e' e) => HOccurs e (TIP (HCons e' HNil))
+ Data.HList.TIP: instance [overlap ok] HTypeIndexed HNil
+ Data.HList.TIP: instance [overlap ok] SubType (TIP l) (TIP HNil)
+ Data.HList.TIP: mkTIP :: (HTypeIndexed l) => l -> TIP l
+ Data.HList.TIP: newtype TIP l
+ Data.HList.TIP: oneTrue :: TIP (HCons Int (HCons Bool HNil))
+ Data.HList.TIP: tuple :: (HOccurs e1 (TIP l), HType2HNat e1 l n, HDeleteAtHNat n l l', HOccurs e2 (TIP l'), HOccurs e2 (TIP l), HType2HNat e2 l n', HDeleteAtHNat n' l l'', HOccurs e1 (TIP l'')) => TIP l -> (e1, e2)
+ Data.HList.TIP: unTIP :: TIP l -> l
+ Data.HList.TypeCastGeneric1: instance [overlap ok] TypeCast x x
+ Data.HList.TypeCastGeneric2: class TypeCast a b | a -> b, b -> a
+ Data.HList.TypeCastGeneric2: class TypeCast' t a b | t a -> b, t b -> a
+ Data.HList.TypeCastGeneric2: class TypeCast'' t a b | t a -> b, t b -> a
+ Data.HList.TypeCastGeneric2: instance [overlap ok] (TypeCast' () a b) => TypeCast a b
+ Data.HList.TypeCastGeneric2: instance [overlap ok] (TypeCast'' t a b) => TypeCast' t a b
+ Data.HList.TypeCastGeneric2: instance [overlap ok] TypeCast'' () a a
+ Data.HList.TypeCastGeneric2: typeCast :: (TypeCast a b) => a -> b
+ Data.HList.TypeCastGeneric2: typeCast' :: (TypeCast' t a b) => t -> a -> b
+ Data.HList.TypeCastGeneric2: typeCast'' :: (TypeCast'' t a b) => t -> a -> b
+ Data.HList.TypeEqBoolGeneric: instance [overlap ok] (Fail ()) => TypeEqFalse x x
+ Data.HList.TypeEqBoolGeneric: instance [overlap ok] TypeEqFalse x y
+ Data.HList.TypeEqBoolGeneric: instance [overlap ok] TypeEqTrue x x
+ Data.HList.TypeEqGeneric1: class (HBool b) => TupleType t b | t -> b
+ Data.HList.TypeEqGeneric1: instance [overlap ok] (HBool b, TypeCast HFalse b) => TupleType x b
+ Data.HList.TypeEqGeneric1: instance [overlap ok] (HBool b, TypeCast HFalse b) => TypeEq x y b
+ Data.HList.TypeEqGeneric1: instance [overlap ok] TupleType () HTrue
+ Data.HList.TypeEqGeneric1: instance [overlap ok] TupleType (x, y) HTrue
+ Data.HList.TypeEqGeneric1: instance [overlap ok] TupleType (x, y, z) HTrue
+ Data.HList.TypeEqGeneric1: instance [overlap ok] TypeEq x x HTrue
+ Data.HList.TypeEqGeneric2: class (TypeEq' () x y b) => TypeEq x y b | x y -> b
+ Data.HList.TypeEqGeneric2: class TypeEq' q x y b | q x y -> b
+ Data.HList.TypeEqGeneric2: class TypeEq'' q x y b | q x y -> b
+ Data.HList.TypeEqGeneric2: instance [overlap ok] (TypeCast b HTrue) => TypeEq' () x x b
+ Data.HList.TypeEqGeneric2: instance [overlap ok] (TypeEq' () x y b) => TypeEq x y b
+ Data.HList.TypeEqGeneric2: instance [overlap ok] (TypeEq'' q x y b) => TypeEq' q x y b
+ Data.HList.TypeEqGeneric2: instance [overlap ok] TypeEq'' () x y HFalse
+ Data.HList.TypeEqGeneric2: typeEq :: (TypeEq t t' b) => t -> t' -> b
+ Data.HList.Variant: Variant :: mr -> Variant mr
+ Data.HList.Variant: class HMaybied r r' | r -> r'
+ Data.HList.Variant: hMaybied :: (HMaybied r r') => r -> r'
+ Data.HList.Variant: instance [overlap ok] (HMaybied r r') => HMaybied (HCons (LVPair l (Proxy v)) r) (HCons (LVPair l (Maybe v)) r')
+ Data.HList.Variant: instance [overlap ok] HMaybied HNil HNil
+ Data.HList.Variant: instance [overlap ok] Show (Variant v)
+ Data.HList.Variant: mkVariant :: (RecordLabels v ls, HFind x ls n, HMaybied v v', HUpdateAtHNat n (LVPair x (Maybe y)) v' v') => x -> y -> (Record v) -> Variant v'
+ Data.HList.Variant: newtype Variant mr
+ Data.HList.Variant: unVariant :: (RecordLabels v ls, HFind x ls n, HLookupByHNat n v (LVPair x (Maybe y))) => x -> Variant v -> Maybe y
Files
- Data/HList/GhcRecord.hs +6/−4
- Data/HList/GhcSyntax.hs +3/−21
- Data/HList/HArray.hs +4/−2
- Data/HList/Label1.hs +51/−0
- Data/HList/Label2.hs +67/−0
- Data/HList/Label3.hs +73/−0
- Data/HList/Label5.hs +40/−0
- Data/HList/Record.hs +2/−13
- Data/HList/RecordP.hs +212/−0
- Data/HList/TIP.hs +7/−9
- Data/HList/TypeCastGeneric2.hs +33/−0
- Data/HList/TypeEqGeneric1.hs +1/−1
- Data/HList/TypeEqGeneric2.hs +50/−0
- HList.cabal +11/−8
- README +22/−0
- keyword-arguments.lhs +440/−0
Data/HList/GhcRecord.hs view
@@ -1,6 +1,7 @@-{-# LANGUAGE PatternSignatures, ScopedTypeVariables, EmptyDataDecls,- FunctionalDependencies, FlexibleInstances, FlexibleContexts,- MultiParamTypeClasses, UndecidableInstances #-}+{-# OPTIONS_GHC -fno-warn-missing-signatures #-}+{-# LANGUAGE ScopedTypeVariables, EmptyDataDecls, FunctionalDependencies, + MultiParamTypeClasses, UndecidableInstances, PatternSignatures,+ FlexibleInstances, FlexibleContexts #-} {- The HList library@@ -25,6 +26,7 @@ -- A variation on update. -- Replace a proxy by a value of the proxied type.+-- The signature is inferred hUnproxyLabel :: (HUpdateAtHNat n (LVPair l a) t l', HFind l ls n, RecordLabels t ls, HasField l t (Proxy a)) =>@@ -140,7 +142,7 @@ data NilLub nilLub :: NilLub-nilLub = undefined :: NilLub+nilLub = undefined class ConsLub h t l | h t -> l where
Data/HList/GhcSyntax.hs view
@@ -1,3 +1,4 @@+{-# OPTIONS_GHC -fno-warn-missing-signatures #-} {-# LANGUAGE FlexibleContexts #-} {- (C) 2004, Oleg Kiselyov, Ralf Laemmel, Keean Schupke@@ -33,6 +34,8 @@ {-----------------------------------------------------------------------------} -- Convenience notation for records+-- Many signatures are deliberately omitted. They should be inferred.+-- There is no point of writing the same thing in terms and in types. infixr 4 :=: type l :=: v = LVPair l v@@ -46,34 +49,18 @@ r .!. l = hLookupByLabel l r infixl 1 .-.-(.-.) :: (H2ProjectByLabels (HCons e HNil) t t1 t2) => Record t -> e -> Record t2 r .-. l = hDeleteAtLabel l r infixl 1 .@.-(.@.) :: (HUpdateAtHNat n (LVPair t t1) t2 l',- HFind t ls n,- RecordLabels t2 ls) =>- Record t2 -> LVPair t t1 -> Record l' r .@. f@(LVPair v) = hUpdateAtLabel (labelLVPair f) v r infixr 1 .^.-(.^.) :: (HasField t t2 (Proxy t1),- RecordLabels t2 ls,- HFind t ls n,- Data.HList.HArray.HUpdateAtHNat n (LVPair t t1) t2 l') =>- LVPair t t1 -> Record t2 -> Record l' f@(LVPair v) .^. r = hUnproxyLabel (labelLVPair f) v r infixr 1 .<.-(.<.) :: (HasField t t2 t1,- RecordLabels t2 ls,- HFind t ls n,- HUpdateAtHNat n (LVPair t t1) t2 l') =>- LVPair t t1 -> Record t2 -> Record l' f@(LVPair v) .<. r = hTPupdateAtLabel (labelLVPair f) v r infixl 1 .<++.-(.<++.) :: (HLeftUnion r r' r'') => r -> r' -> r'' r .<++. r' = hLeftUnion r r' @@ -86,11 +73,6 @@ type e :+: l = HCons (Proxy e) l -(.+.) :: ( HTypeIndexed l- , HTypeProxied l- , HOccursNot (Proxy e) l- )- => e -> TIP l -> TIP (HCons (Proxy e) l) e .+. r = hExtend (toProxy e) r
Data/HList/HArray.hs view
@@ -1,3 +1,4 @@+{-# OPTIONS_GHC -fno-warn-missing-signatures #-} {-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, FlexibleContexts, UndecidableInstances #-} {-@@ -72,8 +73,9 @@ {-----------------------------------------------------------------------------} -- Splitting an array according to indices-hSplitByHNats :: (HSplitByHNats' ns l' l'1 l'', HMap (HAddTag HTrue) l l') =>- ns -> l -> (l'1, l'')+-- Signature is inferred:+-- hSplitByHNats :: (HSplitByHNats' ns l' l'1 l'', HMap (HAddTag HTrue) l l') =>+-- ns -> l -> (l'1, l'') hSplitByHNats ns l = hSplitByHNats' ns (hFlag l) class HNats ns => HSplitByHNats' ns l l' l'' | ns l -> l' l''
+ Data/HList/Label1.hs view
@@ -0,0 +1,51 @@+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}++{-+ The HList library++ (C) 2004-2006, Oleg Kiselyov, Ralf Laemmel, Keean Schupke++ A model of label as needed for extensible records.++ Record labels are simply type-level naturals.+ This models is as simple and as portable as it could be.+-}++module Data.HList.Label1 where++import Data.HList.FakePrelude+import Data.HList.Record (ShowLabel(..))+++-- Labels are type-level naturals++newtype Label x = Label x deriving Show+++-- Public constructors for labels++label :: HNat n => n -> Label n+label = Label+++-- Construct the first label+firstLabel :: Label HZero+firstLabel = label hZero+++-- Construct the next label+nextLabel ::( HNat t) => Label t -> Label (HSucc t)+nextLabel (Label n) = label (hSucc n)+++-- Equality on labels++instance HEq n n' b+ => HEq (Label n) (Label n') b+++-- Show label++instance Show n => ShowLabel (Label n)+ where+ showLabel (Label n) = show n
+ Data/HList/Label2.hs view
@@ -0,0 +1,67 @@+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, UndecidableInstances, EmptyDataDecls #-}++{-+ The HList library++ (C) 2004-2006, Oleg Kiselyov, Ralf Laemmel, Keean Schupke++ A model of labels as needed for extensible records. As before,+ all the information about labels is recorded in their type, so+ the labels of records may be purely phantom. In general,+ Labels are exclusively type-level entities and have no run-time+ representation.++ Record labels are triplets of type-level naturals, namespace,+ and description. The namespace part helps avoid confusions between+ labels from different Haskell modules. The description is+ an arbitrary nullary type constructor.+ For the sake of printing, the namespace part and the description+ are required to be the instance of Show. One must make sure that+ the show functions does not examine the value, as descr is purely phantom.+ Here's an example of the good Label description:+ data MyLabelDescr; instance Show MyLabelDescr where show _ = "descr"+ which obviously can be automated with Template Haskell.++ This model requires all labels in a record to inhabit the same namespace.+-}++module Data.HList.Label2 where++import Data.HList.FakePrelude+import Data.HList.Record (ShowLabel(..))+++-- Labels are type-level naturals++data HNat x => Label x ns desc -- labels are exclusively type-level entities+++-- Construct the first label++firstLabel :: ns -> desc -> Label HZero ns desc+firstLabel = undefined+++-- Construct the next label+nextLabel :: Label x ns desc -> desc' -> Label (HSucc x) ns desc'+nextLabel = undefined+++-- Equality on labels (descriptions are ignored)++instance HEq x x' b+ => HEq (Label x ns desc1) (Label x' ns desc2) b+++-- Show label++instance (HNat x, Show desc) => ShowLabel (Label x ns desc) where+ showLabel = show . getd+ where getd :: Label x ns desc -> desc+ getd = undefined++instance (HNat x, HNat2Integral x,Show ns) => Show (Label x ns desc) where+ show l = unwords ["L",show ((hNat2Integral x)::Integer), show ns]+ where geti :: Label x ns desc -> (x,ns) -- for the sake of Hugs+ geti = undefined+ (x,ns) = geti l
+ Data/HList/Label3.hs view
@@ -0,0 +1,73 @@+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, UndecidableInstances, EmptyDataDecls #-}++{-+ The HList library++ (C) 2004-2006, Oleg Kiselyov, Ralf Laemmel, Keean Schupke++ A model of labels as needed for extensible records. As before,+ all the information about labels is recorded in their type, so+ the labels of records may be purely phantom. In general,+ Labels are exclusively type-level entities and have no run-time+ representation.++ Record labels are triplets of type-level naturals, namespace,+ and description. The namespace part helps avoid confusions between+ labels from different Haskell modules. The description is+ an arbitrary nullary type constructor.+ For the sake of printing, the description is required to be the+ instance of Show. One must make sure that the show functions does+ not examine the value, as descr is purely phantom. Here's an+ example of the good Label description:+ data MyLabelDescr; instance Show MyLabelDescr where show _ = "descr"+ which obviously can be automated with Template Haskell.++ This model even allows the labels in a record to belong to different+ namespaces. To this end, the model employs the predicate for type+ equality.+-}++module Data.HList.Label3 where++import Data.HList.FakePrelude+import Data.HList.Record (ShowLabel(..))+++-- Labels are type-level naturals+data HNat x => Label x ns desc -- labels are exclusively type-level entities+++-- Public constructors for labels++-- Construct the first label+firstLabel :: ns -> desc -> Label HZero ns desc+firstLabel = undefined+++-- Construct the next label+nextLabel :: Label x ns desc -> desc' -> Label (HSucc x) ns desc'+nextLabel = undefined+++-- Equality on labels (descriptions are ignored)++instance ( HEq x x' b+ , TypeEq ns ns' b'+ , HAnd b b' b''+ )+ => HEq (Label x ns desc) (Label x' ns' desc') b''+++-- Show label++instance (HNat x, Show desc) => ShowLabel (Label x ns desc) where+ showLabel = show . getd+ where getd :: Label x ns desc -> desc -- for the sake of Hugs+ getd = undefined++instance (HNat x, Show desc) => Show (Label x ns desc)+ where+ show = show . getd+ where getd :: Label x ns desc -> desc -- for the sake of Hugs+ getd = undefined+
+ Data/HList/Label5.hs view
@@ -0,0 +1,40 @@+{-# LANGUAGE FlexibleInstances, UndecidableInstances, MultiParamTypeClasses #-}++{-+ The HList library++ (C) 2004, Oleg Kiselyov, Ralf Laemmel, Keean Schupke++ Yet another model of labels.+ This model allow us to use any type as label type.+ As a result, we need some generic instances.+ Also, type errors may be more confusing now.+-}++module Data.HList.Label5 where++import Data.Typeable+import Data.Char+import Data.HList.FakePrelude+import Data.HList.Record+++-- Equality on labels++instance TypeEq x y b => HEq x y b+++-- Show label++instance Typeable x => ShowLabel x+ where+ showLabel = (\(x:xs) -> toLower x:xs)+ . reverse+ . takeWhile (not . (==) '.')+ . reverse+ . show+{-+ . tyConString+ . typeRepTyCon+-}+ . typeOf
Data/HList/Record.hs view
@@ -1,6 +1,6 @@ {-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,- FlexibleContexts, UndecidableInstances #-}-{-# OPTIONS -fglasgow-exts #-}+ FlexibleContexts, UndecidableInstances, ScopedTypeVariables #-}+{-# OPTIONS_GHC -fno-warn-missing-signatures #-} {- The HList library@@ -191,7 +191,6 @@ {-----------------------------------------------------------------------------} -- Delete operation-hDeleteAtLabel :: (H2ProjectByLabels (HCons e HNil) t t1 t2) => e -> Record t -> Record t2 hDeleteAtLabel l (Record r) = Record r' where (_,r') = h2projectByLabels (HCons l HNil) r@@ -200,8 +199,6 @@ {-----------------------------------------------------------------------------} -- Update operation-hUpdateAtLabel ::( RecordLabels t ls, HFind e ls n, HUpdateAtHNat n (LVPair e v) t l') =>- e -> v -> Record t -> Record l' hUpdateAtLabel l v (Record r) = Record r' where n = hFind l (recordLabels r)@@ -215,8 +212,6 @@ hProjectByLabels :: (HRLabelSet a, H2ProjectByLabels ls t a b) => ls -> Record t -> Record a hProjectByLabels ls (Record r) = mkRecord (fst $ h2projectByLabels ls r) -hProjectByLabels2 :: (HRLabelSet t2, HRLabelSet t1, H2ProjectByLabels ls t t1 t2) =>- ls -> Record t -> (Record t1, Record t2) hProjectByLabels2 ls (Record r) = (mkRecord rin, mkRecord rout) where (rin,rout) = h2projectByLabels ls r @@ -256,9 +251,6 @@ {-----------------------------------------------------------------------------} -- Rename the label of record-hRenameLabel :: (H2ProjectByLabels (HCons e HNil) t t1 t2, HasField e t v,- HRLabelSet (HCons (LVPair l v) t2)) =>- e -> l -> Record t -> Record (HCons (LVPair l v) t2) hRenameLabel l l' r = r'' where v = hLookupByLabel l r@@ -269,9 +261,6 @@ {-----------------------------------------------------------------------------} -- A variation on update: type-preserving update.-hTPupdateAtLabel :: (HUpdateAtHNat n (LVPair l a) t l', HFind l ls n, RecordLabels t ls,- HasField l t a) =>- l -> a -> Record t -> Record l' hTPupdateAtLabel l v r = hUpdateAtLabel l v r where te :: a -> a -> ()
+ Data/HList/RecordP.hs view
@@ -0,0 +1,212 @@+{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleContexts,+ UndecidableInstances, FlexibleInstances #-}+{-# OPTIONS -fglasgow-exts #-}++{-+ The HList library++ (C) 2004-2006, Oleg Kiselyov, Ralf Laemmel, Keean Schupke++ Extensible records: labels are phantom, so at run-time, the record+ is just a heterogenous list of field values.+ This sort of record is generalizable to `tables' (which are, at+ run-time, a list or a map containing the heterogenous lists+ of field values).++ The are different models of labels that go with this module;+ see the files Label?.hs.+-}++module Data.HList.RecordP where++import Data.HList.FakePrelude+import Data.HList.HListPrelude+import Data.HList.Record+import Data.HList.HArray++{-----------------------------------------------------------------------------}++-- Record types as Phantom labels with values++newtype RecordP ls vs = RecordP vs+++-- Build a record. I wonder if the 'ls' argument of mkRecordP can be+-- removed. So far, we had no need for it...++mkRecordP :: (HSameLength ls vs, HLabelSet ls) => ls -> vs -> RecordP ls vs+mkRecordP _ vs = RecordP vs++-- The contraint that two HLists have the same length+class HSameLength l1 l2+instance HSameLength HNil HNil+instance HSameLength l1 l2 => HSameLength (HCons e1 l1) (HCons e2 l2)++-- Build an empty record+emptyRecordP :: RecordP HNil HNil+emptyRecordP = mkRecordP HNil HNil++-- Converting between RecordP and Record (label/value pairs)++-- The following class declares a bijection between Record and recordP+class HRLabelSet r => RecordR2P r ls vs | r -> ls vs, ls vs -> r where+ record_r2p :: Record r -> RecordP ls vs+ record_p2r :: RecordP ls vs -> Record r++instance RecordR2P HNil HNil HNil where+ record_r2p _ = emptyRecordP+ record_p2r _ = emptyRecord++instance (RecordR2P r ls vs, HRLabelSet (HCons (LVPair l v) r),+ HLabelSet (HCons l ls), HSameLength ls vs)+ => RecordR2P (HCons (LVPair l v) r) (HCons l ls) (HCons v vs) where+ record_r2p (Record (HCons f r)) = hExtend f (record_r2p (Record r))+ record_p2r (RecordP (HCons v r)) = hExtend (LVPair v) (record_p2r (RecordP r))++labels_of_recordp :: RecordP ls vs -> ls+labels_of_recordp = undefined+++{-----------------------------------------------------------------------------}++-- A Show instance to appeal to normal records+-- to save the coding time (rather than run-time), we just+-- convert RecordP to regular Record, which we know how to show++instance (RecordR2P r ls vs, ShowComponents r, HRLabelSet r) =>+ Show (RecordP ls vs) where show rp = show $ record_p2r rp+++{-----------------------------------------------------------------------------}++-- Extension for records++instance (HLabelSet (HCons l ls), HSameLength ls vs)+ => HExtend (LVPair l v) (RecordP ls vs) (RecordP (HCons l ls) (HCons v vs))+ where+ hExtend (LVPair v) (RecordP vs) = mkRecordP undefined (HCons v vs)+++{-----------------------------------------------------------------------------}++-- Record concatenation++instance ( HLabelSet ls''+ , HAppend ls ls' ls''+ , HAppend vs vs' vs''+ , HSameLength ls'' vs''+ )+ => HAppend (RecordP ls vs) (RecordP ls' vs') (RecordP ls'' vs'')+ where+ hAppend (RecordP vs) (RecordP vs') = mkRecordP undefined (hAppend vs vs')++{-----------------------------------------------------------------------------}++-- Lookup operation++-- Because hLookupByLabel is so frequent and important, we+-- implement it separately. The algorithm is familiar assq,+-- only the comparison operation is done at compile-time++instance (HEq l l' b, HasFieldP' b l (RecordP (HCons l' ls) vs) v)+ => HasField l (RecordP (HCons l' ls) vs) v where+ hLookupByLabel = hLookupByLabelP' (undefined::b)++class HasFieldP' b l r v | b l r -> v where+ hLookupByLabelP' :: b -> l -> r -> v++instance HasFieldP' HTrue l (RecordP (HCons l ls) (HCons v vs)) v where+ hLookupByLabelP' _ _ (RecordP (HCons v _)) = v++instance HasField l (RecordP ls vs) v+ => HasFieldP' HFalse l (RecordP (HCons l' ls) (HCons v' vs)) v where+ hLookupByLabelP' _ l (RecordP (HCons _ vs)) =+ hLookupByLabel l ((RecordP vs)::RecordP ls vs)+++{-----------------------------------------------------------------------------}++-- Delete operation+hDeleteAtLabelP :: HProjectByLabelP l ls vs lso v vso =>+ l -> RecordP ls vs -> RecordP lso vso+hDeleteAtLabelP l r = snd $ h2ProjectByLabelP l r+++{-----------------------------------------------------------------------------}++-- Update operation+hUpdateAtLabelP :: (HUpdateAtHNat n e1 t1 l', HFind e t n) => e -> e1 -> RecordP t t1 -> RecordP ls l'+hUpdateAtLabelP l v rp@(RecordP vs) = RecordP (hUpdateAtHNat n v vs)+ where+ n = hFind l (labels_of_recordp rp)++{-----------------------------------------------------------------------------}+-- Projection for records+-- It is also an important operation: the basis of many+-- deconstructors -- so we try to implement it efficiently.++-- Project by a single label+class HProjectByLabelP l ls vs lso v vso | l ls vs -> lso v vso where+ h2ProjectByLabelP :: l -> RecordP ls vs -> (v,RecordP lso vso)++instance (HEq l l' b, HProjectByLabelP' b l (HCons l' ls) vs lso v vso)+ => HProjectByLabelP l (HCons l' ls) vs lso v vso where+ h2ProjectByLabelP = h2ProjectByLabelP' (undefined::b)++class HProjectByLabelP' b l ls vs lso v vso | b l ls vs -> lso v vso where+ h2ProjectByLabelP' :: b -> l -> RecordP ls vs -> (v,RecordP lso vso)++instance HProjectByLabelP' HTrue l (HCons l ls) (HCons v vs) ls v vs where+ h2ProjectByLabelP' _ _ (RecordP (HCons v vs)) = (v,RecordP vs)++instance (HProjectByLabelP l ls vs lso' v vso')+ => HProjectByLabelP' HFalse l (HCons l' ls) (HCons v' vs)+ (HCons l' lso') v (HCons v' vso') where+ h2ProjectByLabelP' _ l (RecordP (HCons v' vs)) =+ let (v,RecordP vso) = h2ProjectByLabelP l ((RecordP vs)::RecordP ls vs)+ in (v, RecordP (HCons v' vso))+++-- Invariant: r = rin `disjoint-union` rout+-- labels(rin) = ls+-- classes H2ProjectByLabels and H2ProjectByLabels' are declared in+-- Record.hs++instance H2ProjectByLabels (HCons l ls)+ (RecordP HNil HNil) (RecordP HNil HNil)+ (RecordP HNil HNil)+ where+ h2projectByLabels _ _ = (emptyRecordP,emptyRecordP)++instance (HMember l' ls b,+ H2ProjectByLabels' b ls (RecordP (HCons l' ls') vs') rin rout)+ => H2ProjectByLabels ls (RecordP (HCons l' ls') vs') rin rout where+ h2projectByLabels = h2projectByLabels' (undefined::b)++instance H2ProjectByLabels ls (RecordP ls' vs') (RecordP lin vin) rout =>+ H2ProjectByLabels' HTrue ls (RecordP (HCons l' ls') (HCons v' vs'))+ (RecordP (HCons l' lin) (HCons v' vin)) rout where+ h2projectByLabels' _ ls (RecordP (HCons v' vs')) =+ (RecordP (HCons v' vin), rout)+ where (RecordP vin,rout) =+ h2projectByLabels ls ((RecordP vs')::RecordP ls' vs')++instance H2ProjectByLabels ls (RecordP ls' vs') rin (RecordP lo vo) =>+ H2ProjectByLabels' HFalse ls (RecordP (HCons l' ls') (HCons v' vs'))+ rin (RecordP (HCons l' lo) (HCons v' vo)) where+ h2projectByLabels' _ ls (RecordP (HCons v' vs')) =+ (rin, RecordP (HCons v' vo))+ where (rin,RecordP vo) =+ h2projectByLabels ls ((RecordP vs')::RecordP ls' vs')+++{-----------------------------------------------------------------------------}++-- Subtyping for records++-- Hmm, a bit too conservative. It works for all our examples,+-- where the record extension is by simple extension. In the future,+-- we should account for possible field permutation.++instance H2ProjectByLabels ls' (RecordP ls vs) (RecordP ls' vs') rout+ => SubType (RecordP ls vs) (RecordP ls' vs')
Data/HList/TIP.hs view
@@ -1,4 +1,7 @@-{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, FlexibleContexts, UndecidableInstances #-}+{-# OPTIONS_GHC -fno-warn-missing-signatures #-}+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, UndecidableInstances,+ FlexibleContexts #-}+ module Data.HList.TIP where {-@@ -73,7 +76,8 @@ {-----------------------------------------------------------------------------} -- Type-indexed extension-hExtend' :: (HTypeIndexed t, HOccursNot e t) => e -> TIP t -> TIP (HCons e t)+-- signature is inferred+-- hExtend' :: (HTypeIndexed t, HOccursNot e t) => e -> TIP t -> TIP (HCons e t) hExtend' e (TIP l) = mkTIP (HCons e l) {-@@ -145,22 +149,16 @@ {-----------------------------------------------------------------------------} -- Shielding type-indexed operations+-- The absence of signatures is deliberate! They all must be inferred. -onTIP :: HTypeIndexed a => (b -> a) -> TIP b -> TIP a onTIP f (TIP l) = mkTIP (f l) -tipyDelete :: (HTypeIndexed l',HType2HNat e b n,HDeleteAtHNat n b l') => Proxy e -> TIP b -> TIP l' tipyDelete p t = onTIP (hDeleteAtProxy p) t-tipyUpdate :: (HTypeIndexed l',HType2HNat e b n,HUpdateAtHNat n e b l') => e -> TIP b -> TIP l' tipyUpdate e t = onTIP (hUpdateAtType e) t-tipyProject :: (HTypeIndexed l',HTypes2HNats ps b ns,HProjectByHNats ns b l') => ps -> TIP b -> TIP l' tipyProject ps t = onTIP (hProjectByProxies ps) t -- Split produces two TIPs-tipySplit :: (HTypeIndexed t2,HTypeIndexed t1,HTypes2HNats ps t ns,HSplitByHNats' ns l' t1 t2,- HMap (HAddTag HTrue) t l') =>- ps -> TIP t -> (TIP t1, TIP t2) tipySplit ps (TIP l) = (mkTIP l',mkTIP l'') where (l',l'') = hSplitByProxies ps l
+ Data/HList/TypeCastGeneric2.hs view
@@ -0,0 +1,33 @@+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, FunctionalDependencies, UndecidableInstances #-}+{-+ The HList library++ (C) 2004, Oleg Kiselyov, Ralf Laemmel, Keean Schupke++ A generic implementation of a type-safe cast. The specific coding+ here is only shown for completeness' sake and it is explained in the+ TR version of the paper. The shown coding does not rely on separate+ compilation (while TypeCastGeneric1.hs does), but on some other tricks.+-}++module Data.HList.TypeCastGeneric2 where++-- We make everything self-contained to show that separate compilation+-- is not needed.++import Data.HList.FakePrelude () -- hiding (TypeCast,typeCast)+++{-----------------------------------------------------------------------------}++-- The actual encoding++class TypeCast a b | a -> b, b->a where typeCast :: a -> b+class TypeCast' t a b | t a -> b, t b -> a where typeCast' :: t->a->b+class TypeCast'' t a b | t a -> b, t b -> a where typeCast'' :: t->a->b+instance TypeCast' () a b => TypeCast a b where typeCast x = typeCast' () x+instance TypeCast'' t a b => TypeCast' t a b where typeCast' = typeCast''+instance TypeCast'' () a a where typeCast'' _ x = x+++{-----------------------------------------------------------------------------}
Data/HList/TypeEqGeneric1.hs view
@@ -1,5 +1,5 @@ {-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,- FlexibleContexts, UndecidableInstances #-}+ FlexibleContexts, OverlappingInstances, UndecidableInstances #-} {- The HList library
+ Data/HList/TypeEqGeneric2.hs view
@@ -0,0 +1,50 @@+{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleContexts, FlexibleInstances, UndecidableInstances #-}++{-+ The HList library++ (C) 2004, Oleg Kiselyov, Ralf Laemmel, Keean Schupke++ A generic implementation of a type equality predicate. The given+ implementation only works for GHC. The specific coding here is only+ shown for completeness' sake. We actually favour the encoding from+ TypeEqGeneric1.hs for its conciseness. The specific coding here+ does not rely on separate compilation (while TypeEqGeneric1.hs+ does), but on some other tricks.+-}++module Data.HList.TypeEqGeneric2 where++-- We make everything self-contained to show that separate compilation+-- is not needed. Also, we need a new class constraint for TypeEqBool,+-- (unless we again employ separate compilation in some ways) so+-- that instance selection of its generic instance within client code+-- of TypeEqBool does not issue problems with the instance+-- constraints.++import Data.HList.FakePrelude hiding (TypeEq,typeEq,proxyEq,TypeCast,typeCast)+import Data.HList.TypeCastGeneric2++-- Re-enabled for testing++typeEq :: TypeEq t t' b => t -> t' -> b+typeEq = undefined+++{-----------------------------------------------------------------------------}++-- The actual encoding++class TypeEq' () x y b => TypeEq x y b | x y -> b+class TypeEq' q x y b | q x y -> b+class TypeEq'' q x y b | q x y -> b+instance TypeEq' () x y b => TypeEq x y b+-- This instance used to work <= GHC 6.2+-- instance TypeEq' () x x HTrue+-- There were some problems however with GHC CVS 6.3.+-- So we favour the following, more stable (?) instance instead.+instance TypeCast b HTrue => TypeEq' () x x b+instance TypeEq'' q x y b => TypeEq' q x y b+instance TypeEq'' () x y HFalse++{-----------------------------------------------------------------------------}
HList.cabal view
@@ -1,26 +1,29 @@ Name: HList-Version: 0.1+Version: 0.1.1 Category: Data Synopsis: Heterogeneous lists Description: HList is a record system providing strongly typed heterogenous lists, records, type-indexed products (TIP) and co-products; licensed under the MIT X License.-License: OtherLicense+License: MIT License-File: LICENSE Author: 2004 Oleg Kiselyov (FNMOC, Monterey), Ralf Laemmel (CWI/VU, Amsterdam), Keean Schupke (Imperial College, London) Maintainer: oleg@pobox.com +Data-files: README, keyword-arguments.lhs+Cabal-version: >= 1.4 Tested-With: GHC==6.8.2-Build-Depends: base+Build-Depends: base >= 3 && < 5 Build-Type: Simple-Exposed-modules: Data.HList-Other-modules: Data.HList.Label4, Data.HList.CommonMain, Data.HList.Variant, Data.HList.GhcSyntax,+Exposed-modules: Data.HList, Data.HList.CommonMain, Data.HList.Variant, Data.HList.GhcSyntax, Data.HList.GhcRecord, Data.HList.Record, Data.HList.HZip, Data.HList.TIC, Data.HList.TIP, Data.HList.HTypeIndexed, Data.HList.HOccurs, Data.HList.HArray, Data.HList.GhcExperiments, Data.HList.HListPrelude, Data.HList.TypeEqBoolGeneric, Data.HList.TypeEqGeneric1,- Data.HList.TypeCastGeneric1, Data.HList.FakePrelude+ Data.HList.TypeCastGeneric1, Data.HList.TypeCastGeneric2, Data.HList.FakePrelude, + Data.HList.RecordP, Data.HList.TypeEqGeneric2,+ Data.HList.Label1, Data.HList.Label2, Data.HList.Label3, Data.HList.Label4, Data.HList.Label5 extensions: EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies,- MultiParamTypeClasses, OverlappingInstances, PatternSignatures, RankNTypes,+ MultiParamTypeClasses, OverlappingInstances, ScopedTypeVariables, RankNTypes, ScopedTypeVariables, TypeSynonymInstances, UndecidableInstances-ghc-options: -O2 -Wall+ghc-options: -Wall
+ README view
@@ -0,0 +1,22 @@+(C) 2004--2005, Oleg Kiselyov, Ralf Laemmel, Keean Schupke++The HList library and samples++This distribution covers all essential issues discussed in the HList paper.+Additional examples and HList operations are provided.+The code from the database section of the HList paper is not included+since doing so would have implied inclusion of substantial packages,+namely the underlying infrastructure for database access library.++You can get HList from Hackage or from Darcs:++$ darcs get --partial http://darcs.haskell.org/HList/++The code works --- within the limits exercised in the source files ---+for both GHC (6.4) and Hugs (Nov 2003). See the Makefile for ways of+running test cases.++One may run "make test" to check the distribution.++Last updated; February 08, 2006+
+ keyword-arguments.lhs view
@@ -0,0 +1,440 @@+From oleg-at-okmij.org Fri Aug 13 14:58:35 2004+To: haskell@haskell.org+Subject: Keyword arguments+From: oleg-at-pobox.com+Message-ID: <20040813215834.F1FF3AB7E@Adric.metnet.navy.mil>+Date: Fri, 13 Aug 2004 14:58:34 -0700 (PDT)+Status: OR+++We show the Haskell implementation of keyword arguments, which goes+well beyond records (e.g., in permitting the re-use of+labels). Keyword arguments indeed look just like regular, positional+arguments. However, keyword arguments may appear in any+order. Furthermore, one may associate defaults with some keywords; the+corresponding arguments may then be omitted. It is a type error to+omit a required keyword argument. The latter property is in stark+contrast with the conventional way of emulating keyword arguments via+records. Also in marked contrast with records, keyword labels may be+reused throughout the code with no restriction; the same label may be+associated with arguments of different types in different+functions. Labels of Haskell records may not be re-used. Our solution+is essentially equivalent to keyword arguments of DSSSL Scheme or+labels of OCaml.++Keyword argument functions are naturally polyvariadic: Haskell does+support varargs! Keyword argument functions may be polymorphic. As+usual, functions with keyword arguments may be partially applied. On+the downside, sometimes one has to specify the type of the return+value of the function (if the keyword argument function has no+signature -- the latter is the norm, see below) -- provided that the+compiler cannot figure the return type out on its own. This is usually+only the case when we use keyword functions at the top level (GHCi+prompt).++Our solution requires no special extensions to Haskell and works with+the existing Haskell compilers; it is tested on GHC 6.0.1. The+overlapping instances extension is not necessary (albeit it is+convenient).++The gist of our implementation is the realization that the type of a+function is a polymorphic collection of its argument types -- a+collection that we can traverse. This message thus illustrates a+limited form of the reflection on a function.+++Our implementation is a trivial extension of the strongly-typed+polymorphic open records described in+ http://homepages.cwi.nl/~ralf/HList/++In fact, the implementation relies on the HList library. To run the+code (which this message is), one needs to download the HList library+from the above site.++The HList paper discusses the issue of labels in some detail. The+paper gives three different representations. One of them needs no+overlapping instances and is very portable. In this message, we chose+a representation that relies on generic type equality and therefore+needs overlapping instances as implemented in GHC. Again, this is+merely an outcome of our non-deterministic choice. It should be+emphasized that other choices are possible, which do not depend on +overlapping instances at all. Please see the HList paper for details.++> {-# OPTIONS -fglasgow-exts -fallow-undecidable-instances #-}+> {-# OPTIONS -fallow-overlapping-instances #-}+> +> module KW where+> +> import FakePrelude hiding (TypeEq,typeEq,proxyEq,TypeCast,typeCast)+> import TypeEqGeneric2+> import TypeCastGeneric2+> import HListPrelude+++We will be using an example inspired by a graphics toolkit -- the area+which really benefits from keyword arguments. We first define our+labels and useful datatypes++> data Color = Color+> data Size = Size+> data Origin = Origin+> data RaisedBorder = RaisedBorder+>+> data CommonColor = Red | Green | Blue deriving Show+> data RGBColor = RGBColor Int Int Int deriving Show++and two functions:++> make_square Size n Origin (x0,y0) Color (color::CommonColor) =+> unwords ["Square:", show n, "at", show (x0,y0), show color] ++ "\n"+> +> make_rect Size (nx,ny) Origin (x0,y0) Color (color::RGBColor)+> RaisedBorder border =+> unwords ["Rectangle:", show (nx,ny), "at", show (x0,y0),+> show color, if border then "raised border" else ""] ++ "\n"+++We are not interested in really drawing squares and rectangles+here. Therefore, make_square and make_rect return a String, which we+can regard as a ``command'' to be passed to a low-level graphics+library. The functions make_square and make_rect are genuine functions+and can be used as such. They are not keyword argument functions, yet,+but they set the stage. These functions can be considered an+`interface' for the keyword argument functions. We should note that+the functions are polymorphic: for example, `Size' can be any+showable. We must also emphasize the re-use of the labels: The Color+of a square is the value of the enumerated type CommonColor. OTH, the+color of the rectangle is given as an RGB triple. The sizes of the+square and of the rectangle are specified differently too, the same+label notwithstanding.++Once the user wrote the functions such as make_square and make_rect,+he can _automatically_ convert them to their keyword+alternatives. This transformation is done by a function 'kw'. The user+should pass the positional-argument function (`labeled' as above),+and an HList of default values for some of the labels. The latter may+be HNil if all keyword arguments are required.++The first example (no defaults)++> tests1 :: String = +> kw make_square HNil Size (1::Int) Origin (0::Int,10::Int) Color Red + +we can permute the arguments at wish++> tests2 :: String = +> kw make_square HNil Color Red Size (1::Int) Origin (0::Int,10::Int) + +we can also assign a name to a keyword function, or partially apply it:++> tests3 = let f x = kw make_square HNil Color Red x+> in "here: " ++ f Origin (0::Int,10::Int) Size (1::Int) + +The dummy argument 'x' is merely to avoid the monomorphic+restriction. The following is a more interesting example, with the+defaults:++> tests4 = let defaults = Origin .*. (0::Int,10::Int) .*.+> RaisedBorder .*. True .*.+> HNil+> in kw make_square defaults Size (1::Int) Color Red +++> kw make_rect defaults Color (RGBColor 0 10 255)+> Size (1.0::Float, 2.0::Float)++The argument RaisedBorder is not given, and so the default value is+used. Of course, we can override the default:++> tests5 = let defaults = Origin .*. (0::Int,10::Int) .*.+> RaisedBorder .*. True .*.+> HNil+> sq x = kw make_square defaults Color x+> re x = kw make_rect defaults x+> in sq Red Size (1::Int) +++> re Color (RGBColor 0 10 255)+> RaisedBorder False+> Size (1.0::Float, 2.0::Float)++We have reshuffled a few arguments, just for fun. As you can see, the+function `kw make_rect defaults' is polyvariadic indeed. We chose to+partially apply 'Color' to the function `kw make_square defaults' --+so that the function `sq' is positional in its first argument, and+keyword in the rest.++If we omit a required argument, we get a type error:++] testse1 = let f x = kw make_square HNil Color Red x+] in "here: " ++ f Origin (0::Int,10::Int) ++ Couldn't match `ErrReqdArgNotFound Size' against `[Char]'+ Expected type: ErrReqdArgNotFound Size+ Inferred type: [Char] ...++The error message seems reasonably clear. Likewise we get an error+message if we pass to a keyword function an argument it does not expect:++] testse2 = let f x = kw make_square HNil Color Red x+] in "here: " ++ f Origin (0::Int,10::Int) Size (1::Int) +] RaisedBorder False++ No instances for (Fail (ErrUnexpectedKW RaisedBorder),+ KWApply [Char] (HCons RaisedBorder (:*: Bool HNil)) [Char])+ arising from use of `f' at ...+ In the second argument of `(++)', namely+ `f Origin (0 :: Int, 10 :: Int) Size (1 :: Int) RaisedBorder False'+++The function 'kw' receives the appropriately labeled function (such+as make_square) and the HList with default values. The function 'kw'+is polymorphic; the overloading is resolved based on the type of the+user function *and* on the type of its continuation. The continuation+indicates if a keyword argument is forthcoming, or not. In the latter+case, 'kw' checks to see if the supplied defaults can provide the+values of the still missing arguments. We see therefore that a+function type is more than it may appear -- the type of a function is+truly a heterogeneous, type level collection! The function 'kw'+traverses that collection, thus performing a limited form of+reflection on Haskell functions.+ ++Implementation Outline++One of the key tools of the implementation is 'kwapply', which applies+a function to a polymorphic collection of that function's arguments.+The order of the arguments in the collection is irrelevant. The+contraption kwapply can handle polymorphic functions with arbitrary+number of labeled arguments.++For example, if we define++> f1 Size n = show n+> f2 Size n Color m = unwords ["size:", show n, "color:", show m]+> f3 Origin x Color m Size n = +> unwords ["origin:", show x, "size:", show n, "color:",show m]++then we can run++> katest1 = kwapply f1 (Size .*. () .*. HNil)+> katest11 = kwapply f1 (Size .*. "Large" .*. HNil)+> +> katest2 = kwapply f2 (Size .*. (1::Int) .*. Color .*. Red .*. HNil)+> katest21 = kwapply f2 (Color .*. Red .*. Size .*. (1::Int) .*. HNil)+> +> katest3 = kwapply f3 (Size .*. (1::Int) .*. Origin .*. (2.0::Float) .*. +> Color .*. Red .*. HNil)++Another key contraption is ++> reflect_fk:: (ReflectFK fn kws) => fn -> Arg kws HNil+> reflect_fk _ = Arg HNil++that reflects on a user-supplied function. It converts the *type* of a+user function to a collection of keywords required by that+function. This and the previous contraptions may be used to define an+`extended' version of some user function that takes more arguments --+without the need to enumerate all arguments of the original+function. We thus infringe on the area of object and module systems.++The rest of the implementation is just to convert `kw fn defaults' +into the application of kwapply. ++++The rest of the implementation++We should note that all implementation is written in the+continuation-passing style (CPS) -- at the term level and especially+at the _typeclass level_. One of the reasons is to avoid relying on+overlapping instances: we compare types with a predicate `TypeEq x y+hbool', obtain the type-level boolean, and dispatch to two+non-overlapping instances of an auxiliary, continuation class. One+instance handles HTrue, and the other the HFalse alternative. Please+see the HList paper for more discussion of this technique.++The other, equally important reason for the thorough CPS of the+typeclasses is to control the order of evaluation of constraints and+their functional dependencies. The sole reason is to produce+informative error messages. The order of constraints is irrelevant+when all the constraints are satisfied. However, if the user omitted a+required keyword, many of the constraints below will fail. If a+'wrong' constraint fails first, we get a totally off-the-wall error+message that gives us no clue whatsoever about the problem. By tightly+constraining the order via CPS, we are able to force the typechecker+to give informative error messages.+++Preliminaries++> -- A bit of syntax sugar for HLists+> infixr 1 :*:+> infixr 1 .*.+> type e :*: l = HCons e l+> (.*.) = HCons+++Errors++> data ErrReqdArgNotFound x+> data ErrUnexpectedKW x+> data Trace x++All our keywords must be registered++> class IsKeyFN t flag | t-> flag+> instance IsKeyFN (Color->a->b) HTrue+> instance IsKeyFN (Size->a->b) HTrue+> instance IsKeyFN (Origin->a->b) HTrue+> instance IsKeyFN (RaisedBorder->a->b) HTrue+> instance TypeCast HFalse flag => IsKeyFN t flag++The implementation of KWApply++> class KWApply f arg_values r | f arg_values -> r where+> kwapply:: f -> arg_values -> r+> +> instance KWApply r HNil r where+> kwapply f _ = f+> +> instance (TypeEq kw kw' flag,+> KWApply' flag (kw->a->f') (kw' :*: a' :*: tail) r)+> => KWApply (kw->a->f') (kw' :*: a' :*: tail) r where+> kwapply = kwapply' (undefined::flag)+> +> class KWApply' flag f arg_values r | flag f arg_values -> r where+> kwapply':: flag -> f -> arg_values -> r+> +> instance (TypeCast v' v, KWApply f' tail r)+> => KWApply' HTrue (kw->v->f') (kw :*: v' :*: tail) r where+> kwapply' _ f (HCons kw (HCons v' tail)) = +> kwapply (f kw (typeCast v')) tail+> +> -- Rotate the arg list ...+> instance (HAppend tail (kw :*: v :*: HNil) l',+> KWApply f l' r)+> => KWApply' HFalse f (kw :*: v :*: tail) r where+> kwapply' _ f (HCons kw (HCons v tail)) = +> kwapply f (hAppend tail (kw .*. v .*. HNil))++The datatype Arg below is to maintain the state of keyword+accumulation: which keywords we need, and which keyword and values we+have already got.+arg_types is the phantom HList of keywords that are yet to be satisfied.+arg_values is the HList (kw .*. kw_value .*. etc)+of already found keywords and their values.++> newtype Arg arg_types arg_values = Arg arg_values deriving Show++Reflection on a function:+Given a function, return the type list of its keywords++> class ReflectFK f kws | f -> kws+> instance (IsKeyFN f flag, ReflectFK' flag f kws) => ReflectFK f kws+> class ReflectFK' flag f kws | flag f -> kws+> instance ReflectFK rest kws => ReflectFK' HTrue (kw->a->rest) (HCons kw kws)+> instance ReflectFK' HFalse f HNil++-- :t reflect_fk (undefined::Size->Int->Color->CommonColor->String)+-- :t reflect_fk (undefined::Size->Int->()->Int)++The main class: collect and apply the keyword arguments++> class KW f arg_desc arg_def r where+> kwdo :: f -> arg_desc -> arg_def -> r+> +> instance (IsKeyFN r rflag, -- Fail (Trace (arg_desc,r)),+> KW' rflag f arg_desc arg_def r)+> => KW f arg_desc arg_def r where+> kwdo = kw' (undefined::rflag)+> +> class KW' rflag f arg_desc arg_def r where+> kw' :: rflag -> f -> arg_desc -> arg_def -> r++If the continuation r does not promise any more keyword+arguments, apply the defaults++> instance KWMerge arg_needed arg_values arg_def f r+> => KW' HFalse f (Arg arg_needed arg_values) arg_def r where+> kw' _ f args_given arg_def = kwmerge args_given arg_def f++Otherwise, collect the supplied keyword and its value, and recurse for+more:++> instance KWAcc arg_desc kw a f arg_def r+> => KW' HTrue f arg_desc arg_def (kw->a->r) where+> kw' _ f arg_desc arg_def kw a = kwaccum arg_desc kw a f arg_def+++Add the needed arguments from arg_def to arg_values and continue+with kwapply.+That is, we try to satisfy the missing arguments from the defaults.+It will be a type error if some required arguments are missing++> class KWMerge arg_needed arg_values arg_def f r |+> arg_needed arg_values arg_def f -> r where+> kwmerge:: Arg arg_needed arg_values -> arg_def -> f -> r+> +> instance KWApply f arg_values r +> => KWMerge HNil arg_values arg_def f r where+> kwmerge (Arg arg_values) _ f = kwapply f arg_values+> +> instance KWMerge' kw arg_def atail arg_values arg_def f r+> => KWMerge (HCons kw atail) arg_values arg_def f r where+> kwmerge (Arg arg_values) arg_def = +> kwmerge' (undefined::kw) arg_def+> ((Arg arg_values)::Arg atail arg_values) arg_def+> +> class KWMerge' kw list atail arg_values arg_def f r | +> kw list atail arg_values arg_def f -> r where+> kwmerge':: kw -> list -> (Arg atail arg_values) -> arg_def -> f -> r+> +> instance Fail (ErrReqdArgNotFound kw)+> => KWMerge' kw HNil atail arg_values arg_def f+> (ErrReqdArgNotFound kw) where+> kwmerge' = undefined+> instance (TypeEq kw kw' flag,+> KWMerge'' flag kw (kw' :*: etc) atail arg_values arg_def f r)+> => KWMerge' kw (kw' :*: etc) atail arg_values arg_def f r where+> kwmerge' = kwmerge'' (undefined::flag)+> +> class KWMerge'' flag kw list atail arg_values arg_def f r |+> flag kw list atail arg_values arg_def f -> r where+> kwmerge'':: flag -> kw -> list -> (Arg atail arg_values) -> arg_def+> -> f -> r+> instance KWMerge atail (kw :*: v :*: arg_values) arg_def f r+> => KWMerge'' HTrue kw (kw :*: v :*: tail)+> atail arg_values arg_def f r where+> kwmerge'' _ _ (HCons kw (HCons v _)) (Arg arg_values) =+> kwmerge ((Arg (kw .*. v .*. arg_values))::+> (Arg atail (kw :*: v :*: arg_values)))+> instance KWMerge' kw tail atail arg_values arg_def f r+> => KWMerge'' HFalse kw (kw' :*: v' :*: tail)+> atail arg_values arg_def f r where+> kwmerge'' _ kw (HCons _ (HCons _ tail)) = kwmerge' kw tail++Add the real argument to the Arg structure, and continue++> class KWAcc arg_desc kw a f arg_def r where+> kwaccum:: arg_desc -> kw -> a -> f -> arg_def -> r+> +> instance (HDelete kw arg_types arg_types',+> KW f (Arg arg_types' (kw :*: a :*: arg_values)) arg_def r)+> => KWAcc (Arg arg_types arg_values) kw a f arg_def r where+> kwaccum (Arg arg_values) kw a f = +> kwdo f (Arg (kw .*. a .*. arg_values)::+> Arg arg_types' (kw :*: a :*: arg_values))++Delete e from l to yield l' The element e must occur in l++> class HDelete e l l' | e l -> l'+> instance Fail (ErrUnexpectedKW e) => HDelete e HNil HNil+> instance (TypeEq e e' flag, HDelete' flag e (HCons e' tail) l')+> => HDelete e (HCons e' tail) l'+> class HDelete' flag e l l' | flag e l -> l'+> instance HDelete' HTrue e (HCons e tail) tail+> instance HDelete e tail tail'+> => HDelete' HFalse e (HCons e' tail) (HCons e' tail')++Finally,++> kw f = kwdo f (reflect_fk f)++