packages feed

HList 0.2.2 → 0.2.3

raw patch · 3 files changed

+12/−8 lines, 3 filesnew-uploaderPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- 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] (HNat2Integral n) => HNat2Integral (HSucc n)
- Data.HList.FakePrelude: instance [overlap ok] (Show x) => Show (HJust x)
- 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.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] (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] (Typeable x) => Typeable (Proxy x)
- Data.HList.GhcRecord: instance [overlap ok] (Typeable x) => Typeable (Record x)
- Data.HList.HArray: instance [overlap ok] (HLength l (HSucc HZero)) => HSingleton l
- Data.HList.HArray: instance [overlap ok] (HSplit l l' l'') => HSplitByHNats' HNil l HNil 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] (Eq e) => HStagedEq' HTrue e e
- 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] (HFind e l n) => HFind' HFalse e l (HSucc n)
- 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] (HList2List l e) => HList2List (HCons e l) e
- 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] (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] (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.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) => HOccursFst 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.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] (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.HZip: instance [overlap ok] (HZip tx ty l) => HZip (HCons hx tx) (HCons hy ty) (HCons (hx, hy) l)
- 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.Label2: instance [overlap ok] (HEq x x' b) => HEq (Label x ns desc1) (Label x' ns desc2) b
- 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: instance [overlap ok] (Eq r) => Eq (Record r)
- Data.HList.Record: instance [overlap ok] (Eq v) => Eq (LVPair l v)
- Data.HList.Record: instance [overlap ok] (Fail (DuplicatedLabel l1)) => HRLabelSet' l1 v1 l2 v2 HTrue r
- Data.HList.Record: instance [overlap ok] (Fail (DuplicatedLabel x)) => HLabelSet' x ls HTrue
- Data.HList.Record: instance [overlap ok] (Fail (ExtraField l)) => HRearrange HNil (HCons (LVPair l v) a) (ExtraField l)
- Data.HList.Record: instance [overlap ok] (Fail (FieldNotFound l)) => HRearrange' l ls HNil rout (FieldNotFound l)
- 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] (HLabelSet ls) => HLabelSet' x ls HFalse
- 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] (HRearrange ls rout r') => HRearrange' l ls (HCons (LVPair l v) HNil) rout (HCons (LVPair l v) 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) => RecordLabels (HCons (LVPair l v) r') (HCons l ls)
- Data.HList.Record: instance [overlap ok] (RecordValues r' vs) => RecordValues (HCons (LVPair l v) r') (HCons v vs)
- Data.HList.Record: instance [overlap ok] (ShowComponents r) => Show (Record r)
- 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] (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.TIC: instance [overlap ok] (HTypeProxied l) => HTypeProxied (HCons (Proxy e) 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] (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] (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.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.TypeEqBoolGeneric: instance [overlap ok] (Fail ()) => TypeEqFalse x x
- 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.Variant: instance [overlap ok] (HMaybied r r') => HMaybied (HCons (LVPair l (Proxy v)) r) (HCons (LVPair l (Maybe v)) r')
+ 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] HNat2Integral n => HNat2Integral (HSucc n)
+ Data.HList.FakePrelude: instance [overlap ok] Show x => Show (HJust x)
+ 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.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] 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] Typeable x => Typeable (Proxy x)
+ Data.HList.GhcRecord: instance [overlap ok] Typeable x => Typeable (Record x)
+ Data.HList.HArray: instance [overlap ok] HLength l (HSucc HZero) => HSingleton l
+ Data.HList.HArray: instance [overlap ok] HSplit l l' l'' => HSplitByHNats' HNil l HNil 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] Eq e => HStagedEq' HTrue e e
+ 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] HFind e l n => HFind' HFalse e l (HSucc n)
+ 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] HList2List l e => HList2List (HCons e l) e
+ 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] 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] 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.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 => HOccursFst 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.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] 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.HZip: instance [overlap ok] HZip tx ty l => HZip (HCons hx tx) (HCons hy ty) (HCons (hx, hy) l)
+ 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.Label2: instance [overlap ok] HEq x x' b => HEq (Label x ns desc1) (Label x' ns desc2) b
+ 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: instance [overlap ok] Eq r => Eq (Record r)
+ Data.HList.Record: instance [overlap ok] Eq v => Eq (LVPair l v)
+ Data.HList.Record: instance [overlap ok] Fail (DuplicatedLabel l1) => HRLabelSet' l1 v1 l2 v2 HTrue r
+ Data.HList.Record: instance [overlap ok] Fail (DuplicatedLabel x) => HLabelSet' x ls HTrue
+ Data.HList.Record: instance [overlap ok] Fail (ExtraField l) => HRearrange HNil (HCons (LVPair l v) a) (ExtraField l)
+ Data.HList.Record: instance [overlap ok] Fail (FieldNotFound l) => HRearrange' l ls HNil rout (FieldNotFound l)
+ 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] HLabelSet ls => HLabelSet' x ls HFalse
+ 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] HRearrange ls rout r' => HRearrange' l ls (HCons (LVPair l v) HNil) rout (HCons (LVPair l v) 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 => RecordLabels (HCons (LVPair l v) r') (HCons l ls)
+ Data.HList.Record: instance [overlap ok] RecordValues r' vs => RecordValues (HCons (LVPair l v) r') (HCons v vs)
+ Data.HList.Record: instance [overlap ok] ShowComponents r => Show (Record r)
+ 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] 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.TIC: instance [overlap ok] HTypeProxied l => HTypeProxied (HCons (Proxy e) 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] 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] 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.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.TypeEqBoolGeneric: instance [overlap ok] Fail () => TypeEqFalse x x
+ 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.Variant: instance [overlap ok] HMaybied r r' => HMaybied (HCons (LVPair l (Proxy v)) r) (HCons (LVPair l (Maybe v)) r')
- Data.HList: (#) :: (HasField l r v) => r -> l -> v
+ Data.HList: (#) :: HasField l r v => r -> l -> v
- Data.HList: concrete :: (MonadFix m) => (a -> m a) -> a -> m a
+ Data.HList: concrete :: MonadFix m => (a -> m a) -> a -> m a
- Data.HList.FakePrelude: class (HBool t) => HCond t x y z | t x y -> z
+ 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 => HEq x y b | x y -> b
- Data.HList.FakePrelude: class (HBool b) => HLt 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) => HNat2Integral n
+ Data.HList.FakePrelude: class HNat n => HNat2Integral n
- Data.HList.FakePrelude: class (HBool b) => TypeEq x y b | x y -> b
+ Data.HList.FakePrelude: class HBool b => TypeEq x y b | x y -> b
- Data.HList.FakePrelude: hAnd :: (HAnd t t' t'') => t -> t' -> t''
+ 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: hCond :: HCond t x y z => t -> x -> y -> z
- Data.HList.FakePrelude: hEq :: (HEq x y b) => x -> y -> b
+ Data.HList.FakePrelude: hEq :: HEq x y b => x -> y -> b
- Data.HList.FakePrelude: hLt :: (HLt x y b) => x -> y -> b
+ Data.HList.FakePrelude: hLt :: HLt x y b => x -> y -> b
- Data.HList.FakePrelude: hOr :: (HOr t t' t'') => t -> t' -> t''
+ Data.HList.FakePrelude: hOr :: HOr t t' t'' => t -> t' -> t''
- Data.HList.FakePrelude: hPred :: (HNat n) => HSucc n -> n
+ Data.HList.FakePrelude: hPred :: HNat n => HSucc n -> n
- Data.HList.FakePrelude: hStagedEq :: (HStagedEq x y) => x -> y -> Bool
+ Data.HList.FakePrelude: hStagedEq :: HStagedEq x y => x -> y -> Bool
- Data.HList.FakePrelude: hSucc :: (HNat n) => n -> HSucc n
+ Data.HList.FakePrelude: hSucc :: HNat n => n -> HSucc n
- Data.HList.FakePrelude: proxyEq :: (TypeEq t t' b) => Proxy t -> Proxy t' -> b
+ 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: subType :: SubType l l' => l -> l' -> ()
- Data.HList.FakePrelude: typeCast :: (TypeCast x y) => x -> y
+ Data.HList.FakePrelude: typeCast :: TypeCast x y => x -> y
- Data.HList.FakePrelude: typeEq :: (TypeEq t t' b) => t -> t' -> b
+ Data.HList.FakePrelude: typeEq :: TypeEq t t' b => t -> t' -> b
- Data.HList.FakePrelude: typeEqFalse :: (TypeEqFalse x y) => x -> y -> ()
+ Data.HList.FakePrelude: typeEqFalse :: TypeEqFalse x y => x -> y -> ()
- Data.HList.FakePrelude: typeEqTrue :: (TypeEqTrue x y) => x -> y -> ()
+ Data.HList.FakePrelude: typeEqTrue :: TypeEqTrue x y => x -> y -> ()
- Data.HList.GhcExperiments: funType :: (IsTC2 t (->) b) => t -> 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: hDeleteMany :: HDeleteMany e l l' => Proxy e -> l -> l'
- Data.HList.GhcRecord: consLub :: (ConsLub h t l) => h -> t -> l
+ Data.HList.GhcRecord: consLub :: ConsLub h t l => h -> t -> l
- Data.HList.GhcRecord: equivR :: (RecordEquiv r1 r2 res) => Record r1 -> Record r2 -> res
+ 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: equivR' :: RecordEquiv' pj1 pj2 res => pj1 -> pj2 -> res
- Data.HList.GhcRecord: hLub :: (HLub l e) => l -> [e]
+ Data.HList.GhcRecord: hLub :: HLub l e => l -> [e]
- Data.HList.GhcRecord: hasNoProxies :: (HasNoProxies r) => Record r -> ()
+ Data.HList.GhcRecord: hasNoProxies :: HasNoProxies r => Record r -> ()
- Data.HList.GhcRecord: lubNarrow :: (LubNarrow a b c) => a -> b -> (c, c)
+ 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: 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 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' rin rout b res => rin -> rout -> b -> res
- Data.HList.GhcRecord: narrowM'' :: (NarrowM'' f r r') => f -> r -> r'
+ Data.HList.GhcRecord: narrowM'' :: NarrowM'' f r r' => f -> r -> r'
- Data.HList.GhcSyntax: (.!.) :: (HasField l r v) => r -> l -> v
+ Data.HList.GhcSyntax: (.!.) :: HasField l r v => r -> l -> v
- Data.HList.GhcSyntax: (.*.) :: (HExtend e l l') => e -> l -> l'
+ Data.HList.GhcSyntax: (.*.) :: HExtend e l l' => e -> l -> l'
- Data.HList.GhcSyntax: (.+.) :: (HExtend (Proxy e) l l') => e -> l -> l'
+ Data.HList.GhcSyntax: (.+.) :: HExtend (Proxy e) l l' => e -> l -> l'
- Data.HList.GhcSyntax: (.-.) :: (H2ProjectByLabels (HCons e HNil) r _r' r') => Record r -> e -> Record r'
+ Data.HList.GhcSyntax: (.-.) :: H2ProjectByLabels (HCons e HNil) r _r' r' => Record r -> e -> Record r'
- Data.HList.GhcSyntax: (.<++.) :: (HLeftUnion r r' r'') => r -> r' -> r''
+ Data.HList.GhcSyntax: (.<++.) :: HLeftUnion r r' r'' => r -> r' -> r''
- Data.HList.HArray: class (HNat n) => HDeleteAtHNat n l l' | n l -> l'
+ Data.HList.HArray: class HNat n => HDeleteAtHNat n l l' | n l -> l'
- Data.HList.HArray: class (HNat n) => HLookupByHNat n l e | n l -> e
+ Data.HList.HArray: class HNat n => HLookupByHNat n l e | n l -> e
- Data.HList.HArray: class (HNats ns) => HProjectByHNats ns l l' | ns l -> l'
+ Data.HList.HArray: class HNats ns => HProjectByHNats ns l l' | ns l -> l'
- Data.HList.HArray: class (HNats ns) => HSplitByHNats' ns l l' l'' | ns l -> l' 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: 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: hBetween :: HBetween x y => x -> y
- Data.HList.HArray: hDeleteAtHNat :: (HDeleteAtHNat n l l') => n -> l -> l'
+ 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: hDiff :: HDiff x y z => x -> y -> z
- Data.HList.HArray: hLength :: (HLength l n) => l -> n
+ Data.HList.HArray: hLength :: HLength l n => l -> n
- Data.HList.HArray: hLookupByHNat :: (HLookupByHNat n l e) => n -> l -> e
+ 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: hOrdMember :: HOrdMember e l b => e -> l -> b
- Data.HList.HArray: hProjectAwayByHNats :: (HProjectAwayByHNats ns l l') => ns -> l -> l'
+ 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: hProjectByHNats :: HProjectByHNats ns l l' => ns -> l -> l'
- Data.HList.HArray: hSplitByHNats' :: (HSplitByHNats' ns l l' l'') => ns -> l -> (l', l'')
+ 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: hUpdateAtHNat :: HUpdateAtHNat n e l l' => n -> e -> l -> l'
- Data.HList.HListPrelude: apply :: (Apply f a r) => f -> a -> r
+ Data.HList.HListPrelude: apply :: Apply f a r => f -> a -> r
- Data.HList.HListPrelude: class (HNat n) => HFind e l n | e l -> n
+ 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 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 HList l => HFoldr f v l r | f v l -> r
- Data.HList.HListPrelude: class (HBool b) => HMember e l b | e l -> b
+ Data.HList.HListPrelude: class HBool b => HMember e l b | e l -> b
- Data.HList.HListPrelude: class (HList l) => HNats l
+ Data.HList.HListPrelude: class HList l => HNats l
- Data.HList.HListPrelude: class (HBool b) => HTIntersectBool b h t l1 l2 | b h t l1 -> l2
+ 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 HBool b => HTMember e l b | e l -> b
- Data.HList.HListPrelude: fromHJust :: (FromHJust l l') => l -> l'
+ Data.HList.HListPrelude: fromHJust :: FromHJust l l' => l -> l'
- Data.HList.HListPrelude: hAddTag :: (HMap (HAddTag t) l l') => t -> 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 :: HAppend l l' l'' => l -> l' -> l''
- Data.HList.HListPrelude: hAppend' :: (HFoldr ApplyHCons v l r) => l -> v -> r
+ 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' HNil a r => a -> r
- Data.HList.HListPrelude: hBuild' :: (HBuild' l a r) => l -> 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: hCons :: HList l => e -> l -> HCons e l
- Data.HList.HListPrelude: hExtend :: (HExtend e l l') => e -> l -> l'
+ 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 e l n => e -> l -> n
- Data.HList.HListPrelude: hFind' :: (HFind' b e l n) => b -> 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: hFlag :: HMap (HAddTag HTrue) l l' => l -> l'
- Data.HList.HListPrelude: hFoldr :: (HFoldr f v l r) => f -> v -> l -> r
+ 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: hHead :: HHead l h => l -> h
- Data.HList.HListPrelude: hList2List :: (HList2List l e) => l -> [e]
+ Data.HList.HListPrelude: hList2List :: HList2List l e => l -> [e]
- Data.HList.HListPrelude: hMap :: (HMap f l l') => f -> l -> l'
+ 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: hMap' :: HFoldr (HMap' f) HNil l r => f -> l -> r
- Data.HList.HListPrelude: hMapOut :: (HMapOut f r e) => f -> r -> [e]
+ 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: hMember :: HMember e l b => e -> l -> b
- Data.HList.HListPrelude: hReverse :: (HReverse l1 l2) => l1 -> l2
+ Data.HList.HListPrelude: hReverse :: HReverse l1 l2 => l1 -> l2
- Data.HList.HListPrelude: hReverse' :: (HReverse' l1 l2 l3) => l1 -> l2 -> l3
+ Data.HList.HListPrelude: hReverse' :: HReverse' l1 l2 l3 => l1 -> l2 -> l3
- Data.HList.HListPrelude: hRmTag :: (HMap HRmTag l l') => l -> l'
+ Data.HList.HListPrelude: hRmTag :: HMap HRmTag l l' => l -> l'
- Data.HList.HListPrelude: hSplit :: (HSplit l l' 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: hStagedEq' :: HStagedEq' b e e' => b -> e -> e' -> Bool
- Data.HList.HListPrelude: hTIntersect :: (HTIntersect l1 l2 l3) => l1 -> l2 -> l3
+ 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: 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: hTMember :: HTMember e l b => e -> l -> b
- Data.HList.HListPrelude: hTail :: (HTail l l') => l -> l'
+ Data.HList.HListPrelude: hTail :: HTail l l' => l -> l'
- Data.HList.HListPrelude: naiveHReverse :: (NaiveHReverse l l') => l -> l'
+ Data.HList.HListPrelude: naiveHReverse :: NaiveHReverse l l' => l -> l'
- Data.HList.HListPrelude: toHJust :: (ToHJust l l') => l -> l'
+ Data.HList.HListPrelude: toHJust :: ToHJust l l' => l -> l'
- Data.HList.HOccurs: hOccurs :: (HOccurs e l) => l -> e
+ Data.HList.HOccurs: hOccurs :: HOccurs e l => l -> 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: hOccursBool :: HOccursBool b e l => b -> l -> e
- Data.HList.HOccurs: hOccursFst :: (HOccursFst e l) => l -> e
+ Data.HList.HOccurs: hOccursFst :: HOccursFst e l => l -> e
- Data.HList.HOccurs: hOccursMany :: (HOccursMany 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: hOccursMany1 :: HOccursMany1 e l => l -> (e, [e])
- Data.HList.HOccurs: hOccursOpt :: (HOccursOpt e l) => l -> Maybe e
+ Data.HList.HOccurs: hOccursOpt :: HOccursOpt e l => l -> Maybe e
- Data.HList.HOccurs: hProject :: (HProject l l') => l -> l'
+ Data.HList.HOccurs: hProject :: HProject l l' => l -> l'
- Data.HList.HTypeIndexed: class (HNat n) => HType2HNat e l n | e l -> n
+ Data.HList.HTypeIndexed: class HNat n => HType2HNat e l n | e l -> n
- Data.HList.HTypeIndexed: hDeleteMany :: (HDeleteMany e l l') => 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: hDeleteManyCase :: HDeleteManyCase b e e' l l' => b -> Proxy e -> e' -> l -> l'
- Data.HList.HTypeIndexed: hType2HNat :: (HType2HNat e l n) => Proxy e -> l -> n
+ 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: hTypes2HNats :: HTypes2HNats ps l ns => ps -> l -> ns
- Data.HList.HZip: hUnzip :: (HZip x y l) => l -> (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: hZip :: HZip x y l => x -> y -> l
- Data.HList.Label1: label :: (HNat n) => n -> Label n
+ Data.HList.Label1: label :: HNat n => n -> Label n
- Data.HList.Label1: nextLabel :: (HNat t) => Label t -> Label (HSucc t)
+ Data.HList.Label1: nextLabel :: HNat t => Label t -> Label (HSucc t)
- Data.HList.Record: h2projectByLabels :: (H2ProjectByLabels ls r rin rout) => ls -> r -> (rin, rout)
+ 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: h2projectByLabels' :: H2ProjectByLabels' b ls r rin rout => b -> ls -> r -> (rin, rout)
- Data.HList.Record: hDeleteAtLabel :: (H2ProjectByLabels (HCons e HNil) t t1 t2) => e -> Record t -> Record t2
+ Data.HList.Record: hDeleteAtLabel :: H2ProjectByLabels (HCons e HNil) t t1 t2 => e -> Record t -> Record t2
- Data.HList.Record: hLeftUnion :: (HLeftUnion r r' r'') => r -> r' -> r''
+ 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: 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 l r v => l -> r -> v
- Data.HList.Record: hLookupByLabel' :: (HasField' b l r v) => b -> l -> r -> v
+ Data.HList.Record: hLookupByLabel' :: HasField' b l r v => b -> l -> r -> v
- Data.HList.Record: hRearrange2 :: (HRearrange ls r r') => ls -> r -> r'
+ Data.HList.Record: hRearrange2 :: HRearrange ls r r' => ls -> r -> r'
- Data.HList.Record: hRearrange2' :: (HRearrange' l ls rin rout r') => l -> ls -> rin -> rout -> r'
+ Data.HList.Record: hRearrange2' :: HRearrange' l ls rin rout r' => l -> ls -> rin -> rout -> r'
- Data.HList.Record: mkRecord :: (HRLabelSet r) => r -> Record r
+ Data.HList.Record: mkRecord :: HRLabelSet r => r -> Record r
- Data.HList.Record: recordLabels :: (RecordLabels r ls) => Record r -> ls
+ Data.HList.Record: recordLabels :: RecordLabels r ls => Record r -> ls
- Data.HList.Record: recordLabels' :: (RecordLabels r ls) => r -> ls
+ Data.HList.Record: recordLabels' :: RecordLabels r ls => r -> ls
- Data.HList.Record: recordValues :: (RecordValues r vs) => Record r -> vs
+ Data.HList.Record: recordValues :: RecordValues r vs => Record r -> vs
- Data.HList.Record: recordValues' :: (RecordValues r ls) => r -> ls
+ Data.HList.Record: recordValues' :: RecordValues r ls => r -> ls
- Data.HList.Record: showComponents :: (ShowComponents l) => String -> l -> String
+ Data.HList.Record: showComponents :: ShowComponents l => String -> l -> String
- Data.HList.Record: showLabel :: (ShowLabel l) => 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 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: unionSR' :: UnionSymRec' b r1 f2 r2' ru => b -> r1 -> f2 -> r2' -> (ru, ru)
- Data.HList.RecordP: class (HRLabelSet r) => RecordR2P r ls vs | r -> ls vs, ls vs -> r
+ Data.HList.RecordP: class HRLabelSet r => RecordR2P r ls vs | r -> ls vs, ls vs -> r
- Data.HList.RecordP: h2ProjectByLabelP :: (HProjectByLabelP l ls vs lso v vso) => l -> RecordP ls vs -> (v, RecordP lso vso)
+ 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: 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: 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: hLookupByLabelP' :: HasFieldP' b l r v => b -> l -> r -> v
- Data.HList.RecordP: record_p2r :: (RecordR2P r ls vs) => RecordP ls vs -> Record r
+ 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.RecordP: record_r2p :: RecordR2P r ls vs => Record r -> RecordP ls vs
- Data.HList.TIP: class (HList l) => HTypeIndexed l
+ Data.HList.TIP: class HList l => HTypeIndexed l
- Data.HList.TIP: mkTIP :: (HTypeIndexed l) => l -> TIP l
+ Data.HList.TIP: mkTIP :: HTypeIndexed l => l -> TIP l
- Data.HList.TypeCastGeneric2: typeCast :: (TypeCast a b) => a -> b
+ 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.TypeCastGeneric2: typeCast'' :: (TypeCast'' t a b) => t -> a -> b
+ Data.HList.TypeCastGeneric2: typeCast'' :: TypeCast'' t a b => t -> a -> b
- Data.HList.TypeEqGeneric1: class (HBool b) => TupleType t b | t -> b
+ Data.HList.TypeEqGeneric1: class HBool b => TupleType t b | t -> b
- Data.HList.TypeEqGeneric2: class (TypeEq' () x y b) => TypeEq x y b | x y -> b
+ Data.HList.TypeEqGeneric2: class TypeEq' () x y b => TypeEq x y b | x y -> b
- Data.HList.TypeEqGeneric2: typeEq :: (TypeEq t t' b) => t -> t' -> b
+ Data.HList.TypeEqGeneric2: typeEq :: TypeEq t t' b => t -> t' -> b
- Data.HList.Variant: hMaybied :: (HMaybied r r') => r -> r'
+ Data.HList.Variant: hMaybied :: HMaybied r r' => r -> r'

Files

Data/HList/HZip.hs view
@@ -1,9 +1,5 @@ {-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, UndecidableInstances #-} -module Data.HList.HZip where--import Data.HList.HListPrelude- {- |    The HList library @@ -11,6 +7,11 @@     Zipping and unzipping for (conceptually) lists of pairs.  -}++module Data.HList.HZip where++import Data.HList.HListPrelude+  {-----------------------------------------------------------------------------}
Data/HList/MakeLabels.hs view
@@ -1,7 +1,8 @@+{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell, FlexibleInstances, EmptyDataDecls #-}  -{- | Making labels+{- | Making labels in the style of "Data.HList.Label4"   The following TH splice @@ -25,6 +26,8 @@ import Data.Char (toUpper, toLower) import Control.Monad (liftM) +import Data.Typeable (Typeable)+ capitalize, uncapitalize :: String -> String capitalize   (c:rest) = toUpper c : rest uncapitalize (c:rest) = toLower c : rest@@ -40,7 +43,7 @@  -- The template of our declaration. We will then replace all occurences -- of Foo with the desired name-dcl_template = [d| data Foo; foo = proxy::Proxy Foo |]+dcl_template = [d| data Foo deriving Typeable; foo = proxy::Proxy Foo |]  -- A very dirty traversal/replacement...
HList.cabal view
@@ -1,5 +1,5 @@ Name:                HList-Version:             0.2.2+Version:             0.2.3 Category:            Data Synopsis:            Heterogeneous lists Description:         HList is a record system providing strongly typed heterogenous lists, records,@@ -12,7 +12,7 @@  Data-files:          README Cabal-version:       >= 1.4-Tested-With:         GHC==6.8.2+Tested-With:         GHC==6.12.1 Build-Depends:       base >= 3 && < 5, template-haskell Build-Type:          Simple Exposed-modules:     Data.HList, Data.HList.CommonMain, Data.HList.Variant, Data.HList.GhcSyntax,