HList 0.5.2.0 → 0.5.3.0

+ Data.HList: type ApplyR f a :: *;

+ Data.HList: type FromHJustR l :: [*];

+ Data.HList: type HDeleteAtHNatR (n :: HNat) (l :: [*]) :: [*];

+ Data.HList: type HExtendR e l;

+ Data.HList: type HInitR xs :: [*];

+ Data.HList: type HLookupByHNatR (n :: HNat) (l :: [*]) :: *;

+ Data.HList: type HSplitF l :: [*];

+ Data.HList: type HSplitT l :: [*];

+ Data.HList: type HUpdateAtHNatR (n :: HNat) e (l :: [*]) :: [*];

+ Data.HList: type LabelableTy r :: LabeledOpticType;

+ Data.HList: type MapFst z :: [*];

+ Data.HList: type MapSnd z :: [*];

+ Data.HList: type RecordValuesR r :: [*];

+ Data.HList: type ToHJustR l :: [*];

+ Data.HList.CommonMain: type FromHJustR l :: [*];

+ Data.HList.CommonMain: type HInitR xs :: [*];

+ Data.HList.CommonMain: type HSplitF l :: [*];

+ Data.HList.CommonMain: type HSplitT l :: [*];

+ Data.HList.CommonMain: type LabelableTy r :: LabeledOpticType;

+ Data.HList.CommonMain: type ToHJustR l :: [*];

+ Data.HList.FakePrelude: type ApplyR f a :: *;

+ Data.HList.HArray: type HDeleteAtHNatR (n :: HNat) (l :: [*]) :: [*];

+ Data.HList.HArray: type HLookupByHNatR (n :: HNat) (l :: [*]) :: *;

+ Data.HList.HArray: type HUpdateAtHNatR (n :: HNat) e (l :: [*]) :: [*];

+ Data.HList.HList: type FromHJustR l :: [*];

+ Data.HList.HList: type HInitR xs :: [*];

+ Data.HList.HList: type HSplitF l :: [*];

+ Data.HList.HList: type HSplitT l :: [*];

+ Data.HList.HList: type ToHJustR l :: [*];

+ Data.HList.HListPrelude: type HExtendR e l;

+ Data.HList.HSort: instance (Data.HList.FakePrelude.HEq (GHC.TypeLits.Internal.CmpSymbol x y) 'GHC.Types.GT nb, Data.HList.FakePrelude.HNot nb GHC.Types.~ b) => Data.HList.FakePrelude.HEqBy Data.HList.HSort.HLeFn x y b

+ Data.HList.HSort: instance forall k (x :: k) (y :: k) (b :: GHC.Types.Bool). ((x Data.Type.Ord.<=? y) GHC.Types.~ b) => Data.HList.FakePrelude.HEqBy Data.HList.HSort.HLeFn x y b

+ Data.HList.HZip: type MapFst z :: [*];

+ Data.HList.HZip: type MapSnd z :: [*];

+ Data.HList.Labelable: type LabelableTy r :: LabeledOpticType;

+ Data.HList.Record: instance forall k (l :: k) (xs :: [*]) (b :: GHC.Maybe.Maybe [*]) (r :: [*] -> *) (v :: GHC.Maybe.Maybe (*)). (Data.HList.HList.HMemberM (Data.HList.FakePrelude.Label l) (Data.HList.Record.LabelsOf xs) b, Data.HList.Record.HasFieldM1 b l (r xs) v) => Data.HList.Record.HasFieldM l (r xs) v

+ Data.HList.Record: instance forall k (rs :: [*]) (bs :: [*]) r readP_r (l :: k) v. (Data.HList.HList.HMapCxt Data.HList.HList.HList Data.HList.Record.ReadComponent (Data.HList.HList.AddProxy rs) bs, Data.HList.FakePrelude.ApplyAB Data.HList.Record.ReadComponent (Data.Proxy.Proxy r) readP_r, Data.HList.HList.HProxies rs, Data.HList.HList.HSequence Text.ParserCombinators.ReadP.ReadP (readP_r : bs) (r : rs), readP_r GHC.Types.~ Text.ParserCombinators.ReadP.ReadP (Data.Tagged.Tagged l v), r GHC.Types.~ Data.Tagged.Tagged l v, Data.HList.FakePrelude.ShowLabel l, GHC.Read.Read v, Data.HList.HList.HSequence Text.ParserCombinators.ReadP.ReadP bs rs) => GHC.Read.Read (Data.HList.Record.Record (r : rs))

+ Data.HList.Record: type RecordValuesR r :: [*];

+ Data.HList.Variant: instance forall k lv (l :: k) v lv' v' (fs :: [*]) (b :: GHC.Maybe.Maybe [*]) (f :: GHC.Maybe.Maybe (*)) (rs :: [*]) (vs :: [*]). (lv GHC.Types.~ Data.Tagged.Tagged l v, lv' GHC.Types.~ Data.Tagged.Tagged l v', Data.HList.HList.HMemberM (Data.HList.FakePrelude.Label l) (Data.HList.Record.LabelsOf fs) b, Data.HList.Record.HasFieldM l (Data.HList.Record.Record fs) f, Data.HList.Record.DemoteMaybe (v -> v) f GHC.Types.~ (v -> v'), Data.HList.Variant.MkVariant l v' (lv' : rs), Data.HList.Variant.ZipVR fs vs rs) => Data.HList.Variant.ZipVR fs (lv : vs) (lv' : rs)

+ Data.HList: (.<.) :: forall {k} {record} {l :: k} {v} {r :: [Type]}. (HUpdateAtLabel record l v r r, SameLength' r r) => Tagged l v -> record r -> record r

+ Data.HList: (.==.) :: forall {k} {x} {l :: k} {v}. EnsureLabel x (Label l) => x -> v -> Tagged l v

+ Data.HList: (.@.) :: forall {k} {record} {l :: k} {v} {r :: [Type]} {r' :: [Type]}. (HUpdateAtLabel record l v r r', SameLength' r r', SameLength' r' r) => Tagged l v -> record r -> record r'

+ Data.HList: asTaggedTypeOf :: forall {k} s tagged (b :: k). s -> tagged s b -> s

+ Data.HList: class HasFieldM (l :: k) r (v :: Maybe (*)) | l r -> v

+ Data.HList: dredge :: forall {k1} {k2} {r} {ns :: [[Type]]} {xs :: [Type]} {p} {v} {fb :: k1} {rft :: k1} {vs :: [Type]} {ns1 :: [[Type]]} {vs1 :: [Type]} {l :: k2} {ns2 :: [[Type]]} {x}. (MapFieldTree (TryCollectionListTF r) ns, LabelablePath xs (p v fb) (p r rft), SameLength' ns vs, SameLength' ns1 vs1, SameLength' vs ns, SameLength' vs1 ns1, MapFieldTreeVal r (TryCollectionListTF r) vs, FilterLastEq (Label l) ns ns ns1, FilterLastEq (Label l) ns vs vs1, FilterVEq1 v vs1 ns1 ns2, HGuardNonNull (NamesDontMatch r ns l) ns1, HSingleton (NonUnique r v l) (TypesDontMatch r ns1 vs1 v) ns2 xs, EnsureLabel x (Label l)) => x -> p v fb -> p r rft

+ Data.HList: dredge' :: forall {k1} {k2} {s} {ns :: [[Type]]} {xs :: [Type]} {p} {a} {f :: Type -> k1} {vs :: [Type]} {ns1 :: [[Type]]} {vs1 :: [Type]} {l :: k2} {ns2 :: [[Type]]} {x}. (MapFieldTree (TryCollectionListTF s) ns, LabelablePath xs (p a (f a)) (p s (f s)), SameLength' ns vs, SameLength' ns1 vs1, SameLength' vs ns, SameLength' vs1 ns1, MapFieldTreeVal s (TryCollectionListTF s) vs, FilterLastEq (Label l) ns ns ns1, FilterLastEq (Label l) ns vs vs1, FilterVEq1 a vs1 ns1 ns2, HGuardNonNull (NamesDontMatch s ns l) ns1, HSingleton (NonUnique s a l) (TypesDontMatch s ns1 vs1 a) ns2 xs, EnsureLabel x (Label l)) => x -> p a (f a) -> p s (f s)

+ Data.HList: dredgeND :: forall {k1} {k2} {xs :: [Type]} {p} {a} {fb :: k1} {r} {rft :: k1} {ns :: [[Type]]} {l :: k2} {ns' :: [[Type]]} {x}. (LabelablePath xs (p a fb) (p r rft), MapFieldTree (TryCollectionListTF r) ns, FilterLastEq (Label l) ns ns ns', HSingleton (NonUnique' r l) (NamesDontMatch r ns l) ns' xs, EnsureLabel x (Label l)) => x -> p a fb -> p r rft

+ Data.HList: dredgeND' :: forall {k1} {k2} {xs :: [Type]} {p} {a} {f :: Type -> k1} {s} {ns :: [[Type]]} {l :: k2} {ns' :: [[Type]]} {x}. (LabelablePath xs (p a (f a)) (p s (f s)), MapFieldTree (TryCollectionListTF s) ns, FilterLastEq (Label l) ns ns ns', HSingleton (NonUnique' s l) (NamesDontMatch s ns l) ns' xs, EnsureLabel x (Label l)) => x -> p a (f a) -> p s (f s)

+ Data.HList: dredgeTI' :: forall {k} {xs :: [Type]} {p} {a} {f :: Type -> k} {s} {ns :: [[Type]]} {ns' :: [[Type]]} {q}. (LabelablePath xs (p a (f a)) (p s (f s)), MapFieldTree (TryCollectionListTF s) ns, FilterLastEq (Label a) ns ns ns', HSingleton (NonUnique' s a) (NamesDontMatch s ns a) ns' xs) => q a -> p a (f a) -> p s (f s)

+ Data.HList: hAddTag :: forall {a :: [Type]} {b :: [Type]} {r} {t}. (SameLength' a b, SameLength' b a, HMapAux r (HAddTag t) a b) => t -> r a -> r b

+ Data.HList: hCompose :: forall {f1} {n1 :: HNat} {b} {n2 :: HNat} {xs1 :: [Type]} {x} {xs2 :: [Type]} {r} {n3 :: HNat} {f2} {xsys :: [Type]}. (ArityRev f1 n1, ArityRev b n2, ArityFwd f1 n1, ArityFwd b n2, HCurry' n1 f1 xs1 x, HCurry' n2 b xs2 r, HCurry' n3 f2 xsys r, HAppendList1 xs1 xs2 xsys, HSplitAt1 ('[] :: [Type]) n1 xsys xs1 xs2) => (x -> b) -> f1 -> f2

+ Data.HList: hCurry :: forall {n :: HNat} {f} {xs :: [Type]} {r}. (HCurry' n f xs r, ArityFwd f n, ArityRev f n) => (HList xs -> r) -> f

+ Data.HList: hDeleteAt :: forall {n :: HNat} {l :: [Type]} {e} {proxy1}. (HDeleteAtHNat n l, HType2HNat e l n) => proxy1 e -> HList l -> HList (HDeleteAtHNatR n l)

+ Data.HList: hFlag :: forall {a :: [Type]} {b :: [Type]} {r}. (SameLength' a b, SameLength' b a, HMapAux r (HAddTag (Proxy 'True)) a b) => r a -> r b

+ Data.HList: hLast :: forall {l1 :: [Type]} {e} {l :: [Type]}. HRevApp l1 ('[] :: [Type]) (e : l) => HList l1 -> e

+ Data.HList: hListRecord :: forall {p} {f} {r1 :: [Type]} {r2 :: [Type]}. (Profunctor p, Functor f, HLabelSet (LabelsOf r1), HAllTaggedLV r1) => p (Record r1) (f (Record r2)) -> p (HList r1) (f (HList r2))

+ Data.HList: hListRecord' :: forall {p} {f} {r :: [Type]}. (Profunctor p, Functor f, HLabelSet (LabelsOf r), HAllTaggedLV r) => p (Record r) (f (Record r)) -> p (HList r) (f (HList r))

+ Data.HList: hLookupByLabelDredge :: forall {k} {ls :: [Type]} {r1} {r2} {v} {ns :: [[Type]]} {l :: k} {ns' :: [[Type]]}. (HasFieldPath 'False ls (r1 r2) v, MapFieldTree (TryCollectionListTF r2) ns, FilterLastEq (Label l) ns ns ns', HSingleton (NonUnique' r2 l) (NamesDontMatch r2 ns l) ns' ls) => Label l -> r1 r2 -> v

+ Data.HList: hMap :: forall {a :: [Type]} {b :: [Type]} {r} {f}. (SameLength' a b, SameLength' b a, HMapAux r f a b) => f -> r a -> r b

+ Data.HList: hMapL :: forall {a :: [Type]} {b :: [Type]} {f}. (SameLength' a b, SameLength' b a, HMapAux HList f a b) => f -> HList a -> HList b

+ Data.HList: hMapR :: forall {x :: [Type]} {y :: [Type]} {f}. (SameLength' x y, SameLength' y x, HMapAux HList (HFmap f) x y) => f -> Record x -> Record y

+ Data.HList: hMapV :: forall {f} {x :: [Type]} {y :: [Type]}. (HMapAux Variant (HFmap f) x y, SameLength' x y, SameLength' y x) => f -> Variant x -> Variant y

+ Data.HList: hMaybied :: forall {p} {f} {x :: [Type]} {v1 :: [Type]} {v2 :: [Type]} {r :: [Type]}. (Choice p, Applicative f, HFoldr HMaybiedToVariantFs [Variant ('[] :: [Type])] x [Variant v1], VariantToHMaybied v2 r, VariantToHMaybied v1 x, SameLength' x r, SameLength' r x, HMapAux HList (HFmap HCastF) x r) => p (Variant v1) (f (Variant v2)) -> p (Record x) (f (Record r))

+ Data.HList: hMaybied' :: forall {p} {f} {x :: [Type]} {v :: [Type]}. (Choice p, Applicative f, HFoldr HMaybiedToVariantFs [Variant ('[] :: [Type])] x [Variant v], VariantToHMaybied v x, SameLength' x x, HMapAux HList (HFmap HCastF) x x) => p (Variant v) (f (Variant v)) -> p (Record x) (f (Record x))

+ Data.HList: hOccursRest :: forall {l} {r} {v :: [Type]} {v' :: [Type]}. (HOccurs l (r v), HDeleteAtLabel r l v v') => r v -> (l, r v')

+ Data.HList: hProjectAwayByHNats :: forall {ns :: [HNat]} {a} {z :: [Type]}. (HUnfoldFD (FHUProj 'False ns) (ApplyR (FHUProj 'False ns) (a, Proxy 'HZero)) z, Apply (FHUProj 'False ns) (a, Proxy 'HZero)) => Proxy ns -> a -> HList z

+ Data.HList: hProjectBy :: forall {k} {ns :: [HNat]} {hlist} {l :: k} {z :: [Type]} {es :: [Type]}. (HUnfoldFD (FHUProj 'True ns) (ApplyR (FHUProj 'True ns) (hlist l, Proxy 'HZero)) z, Apply (FHUProj 'True ns) (hlist l, Proxy 'HZero), HTypes2HNats es l ns) => Proxy es -> hlist l -> HList z

+ Data.HList: hProjectByHNats :: forall {ns :: [HNat]} {a} {z :: [Type]}. (HUnfoldFD (FHUProj 'True ns) (ApplyR (FHUProj 'True ns) (a, Proxy 'HZero)) z, Apply (FHUProj 'True ns) (a, Proxy 'HZero)) => Proxy ns -> a -> HList z

+ Data.HList: hProjectByHNats' :: forall {a :: [Type]} {b :: [Type]} {r} {l :: [Type]}. (SameLength' a b, SameLength' b a, HMapAux r (FHLookupByHNat l) a b) => r a -> HList l -> r b

+ Data.HList: hProjectByLabels' :: forall {l :: [Type]} {r :: [Type]} {t :: [Type]} {b :: [Type]}. (HRearrange3 (LabelsOf l) r l, SameLength' r l, SameLength' r (LabelsOf l), SameLength' l r, SameLength' (LabelsOf l) r, HLabelSet (LabelsOf l), HLabelSet (LabelsOf r), HAllTaggedLV r, H2ProjectByLabels (LabelsOf l) t r b) => Record t -> Record l

+ Data.HList: hRearrange' :: forall {l :: [Type]} {r :: [Type]}. (HLabelSet (LabelsOf l), HRearrange3 (LabelsOf l) r l, SameLength' r l, SameLength' r (LabelsOf l), SameLength' l r, SameLength' (LabelsOf l) r) => Record r -> Record l

+ Data.HList: hRenameLabel :: forall {k1} {k2} {r} {l1 :: k1} {v1 :: [Type]} {v' :: [Type]} {v2} {l2 :: k2}. (HDeleteAtLabel r l1 v1 v', HasField l1 (r v1) v2, HExtend (Tagged l2 v2) (r v')) => Label l1 -> Label l2 -> r v1 -> HExtendR (Tagged l2 v2) (r v')

+ Data.HList: hReverse_ :: forall {l1 :: [Type]} {l3 :: [Type]}. HRevApp l1 ('[] :: [Type]) l3 => HList l1 -> HList l3

+ Data.HList: hRmTag :: forall {a :: [Type]} {b :: [Type]} {r}. (SameLength' a b, SameLength' b a, HMapAux r HRmTag a b) => r a -> r b

+ Data.HList: hSplitBy :: forall {k} {ns :: [HNat]} {hlist} {l :: k} {z1 :: [Type]} {z2 :: [Type]} {es :: [Type]}. (HUnfoldFD (FHUProj 'True ns) (ApplyR (FHUProj 'True ns) (hlist l, Proxy 'HZero)) z1, HUnfoldFD (FHUProj 'False ns) (ApplyR (FHUProj 'False ns) (hlist l, Proxy 'HZero)) z2, Apply (FHUProj 'True ns) (hlist l, Proxy 'HZero), Apply (FHUProj 'False ns) (hlist l, Proxy 'HZero), HTypes2HNats es l ns) => Proxy es -> hlist l -> (HList z1, HList z2)

+ Data.HList: hSplitByHNats :: forall {ns :: [HNat]} {a} {z1 :: [Type]} {z2 :: [Type]}. (HUnfoldFD (FHUProj 'True ns) (ApplyR (FHUProj 'True ns) (a, Proxy 'HZero)) z1, HUnfoldFD (FHUProj 'False ns) (ApplyR (FHUProj 'False ns) (a, Proxy 'HZero)) z2, Apply (FHUProj 'True ns) (a, Proxy 'HZero), Apply (FHUProj 'False ns) (a, Proxy 'HZero)) => Proxy ns -> a -> (HList z1, HList z2)

+ Data.HList: hTranspose :: forall {a :: [Type]} {b :: [Type]} {c :: [Type]} {es :: [Type]} {l :: [Type]} {n :: HNat}. (HZip3 a b c, HFoldr HZipF (HList es) l (HList b), HReplicateFD n (HList ('[] :: [Type])) es, SameLength' (HReplicateR n ()) a, HLengthEq1 a n, HLengthEq2 a n) => HList (HList a : l) -> HList c

+ Data.HList: hTuple :: forall {p} {f} {v1 :: [Type]} {a} {v2 :: [Type]} {b}. (Profunctor p, Functor f, HTuple v1 a, HTuple v2 b) => p a (f b) -> p (HList v1) (f (HList v2))

+ Data.HList: hTuple' :: forall {p} {f} {v :: [Type]} {a}. (Profunctor p, Functor f, HTuple v a) => p a (f a) -> p (HList v) (f (HList v))

+ Data.HList: hUncurry :: forall {n :: HNat} {f} {xs :: [Type]} {r}. (HCurry' n f xs r, ArityFwd f n, ArityRev f n) => f -> HList xs -> r

+ Data.HList: hUnfold :: forall {f} {a} {z :: [Type]}. (HUnfoldFD f (ApplyR f a) z, Apply f a) => f -> a -> HList z

+ Data.HList: hUnzipRecord2 :: forall {x1 :: [Type]} {y :: [Type]} {x2 :: [Type]}. (SameLabels x1 y, SameLabels x2 y, HAllTaggedLV x1, HAllTaggedLV x2, HZipList (RecordValuesR x2) (RecordValuesR x1) (RecordValuesR y), HMapAux HList TaggedFn (RecordValuesR x2) x2, HMapAux HList TaggedFn (RecordValuesR x1) x1, RecordValues x2, RecordValues y, RecordValues x1, SameLength' x2 y, SameLength' x1 y, SameLength' y x1, SameLength' y x2) => Record y -> (Record x2, Record x1)

+ Data.HList: hUpdateAt :: forall {n :: HNat} {e} {l :: [Type]}. (HUpdateAtHNat' n e l l, HType2HNat e l n) => e -> HList l -> HList (HUpdateAtHNatR n e l)

+ Data.HList: hZipRecord2 :: forall {x :: [Type]} {y1 :: [Type]} {y2 :: [Type]}. (SameLabels x y1, SameLabels x y2, HAllTaggedLV x, HMapAux HList TaggedFn (RecordValuesR x) x, HZipList (RecordValuesR y1) (RecordValuesR y2) (RecordValuesR x), RecordValues x, RecordValues y1, RecordValues y2, SameLength' x y1, SameLength' x y2, SameLength' y2 x, SameLength' y1 x) => Record y1 -> Record y2 -> Record x

+ Data.HList: listAsHList :: forall {p} {f} {l1 :: [Type]} {e1} {l2 :: [Type]} {e2}. (Choice p, Applicative f, HList2List l1 e1, HList2List l2 e2) => p (HList l2) (f (HList l1)) -> p [e2] (f [e1])

+ Data.HList: listAsHList' :: forall {p} {f} {l :: [Type]} {e}. (Choice p, Applicative f, HList2List l e) => p (HList l) (f (HList l)) -> p [e] (f [e])

+ Data.HList: mkTIC :: forall {i} {l :: [Type]} {n :: HNat}. (HFind1 i (UnLabel i (LabelsOf l)) (UnLabel i (LabelsOf l)) n, HasField i (Record l) i, HAllTaggedLV l, HLabelSet (LabelsOf l), HAllTaggedEq l, KnownNat (HNat2Nat n)) => i -> TIC l

+ Data.HList: mkVariant1 :: forall {k} {l :: k} {e}. Label l -> e -> Variant '[Tagged l e]

+ Data.HList: projected' :: forall {r} {p} {f} {t :: [Type]} {b :: [Type]}. (LabeledOpticP (LabelableTy r) p, LabeledOpticF (LabelableTy r) f, Projected r t t b b) => p (r b) (f (r b)) -> p (r t) (f (r t))

+ Data.HList: proxy :: forall {k} (s :: k) a proxy. Tagged s a -> proxy s -> a

+ Data.HList: rearranged' :: forall {k} {r} {t :: k} {b :: k} {p} {f}. (Rearranged r t t b b, Profunctor p, Functor f) => p (r b) (f (r b)) -> p (r t) (f (r t))

+ Data.HList: relabeled' :: forall {t :: [Type]} {b :: [Type]} {r} {p} {f}. (RecordValuesR t ~ RecordValuesR b, Relabeled r, HMapAux HList TaggedFn (RecordValuesR t) b, HMapAux HList TaggedFn (RecordValuesR b) t, RecordValues b, RecordValues t, SameLength' t b, SameLength' t (RecordValuesR b), SameLength' b t, SameLength' b (RecordValuesR t), SameLength' (RecordValuesR t) b, SameLength' (RecordValuesR b) t, Profunctor p, Functor f) => p (r b) (f (r b)) -> p (r t) (f (r t))

+ Data.HList: reproxy :: forall {k1} {k2} proxy (a :: k1) (b :: k2). proxy a -> Proxy b

+ Data.HList: retag :: forall {k1} {k2} (s :: k1) b (t :: k2). Tagged s b -> Tagged t b

+ Data.HList: tagWith :: forall {k} proxy (s :: k) a. proxy s -> a -> Tagged s a

+ Data.HList: ticVariant :: forall {p} {f} {l1 :: [Type]} {l2 :: [Type]}. (Profunctor p, Functor f) => p (Variant l1) (f (Variant l2)) -> p (TIC l1) (f (TIC l2))

+ Data.HList: ticVariant' :: forall {p} {f} {l :: [Type]}. (Profunctor p, Functor f) => p (Variant l) (f (Variant l)) -> p (TIC l) (f (TIC l))

+ Data.HList: tipHList :: forall {p} {f} {a1 :: [Type]} {ta :: [Type]} {a2 :: [Type]} {l :: [Type]}. (Profunctor p, Functor f, TagUntagFD a1 ta, TagUntagFD a2 l) => p (HList a1) (f (HList a2)) -> p (TIP ta) (f (TIP l))

+ Data.HList: tipHList' :: forall {p} {f} {a :: [Type]} {l :: [Type]}. (Profunctor p, Functor f, TagUntagFD a l) => p (HList a) (f (HList a)) -> p (TIP l) (f (TIP l))

+ Data.HList: tipRecord :: forall {p} {f} {r :: [Type]} {l :: [Type]}. (Profunctor p, Functor f) => p (Record r) (f (Record l)) -> p (TIP r) (f (TIP l))

+ Data.HList: tipRecord' :: forall {p} {f} {l :: [Type]}. (Profunctor p, Functor f) => p (Record l) (f (Record l)) -> p (TIP l) (f (TIP l))

+ Data.HList: tipyLens :: forall {n :: HNat} {x} {xs1 :: [Type]} {l1 :: [Type]} {a1} {xs2 :: [Type]} {b :: Bool} {a2} {f}. (HSplitAt1 ('[] :: [Type]) n (Tagged x x : xs1) l1 (Tagged a1 a1 : xs2), HAppendList1 l1 (Tagged a1 a1 : xs2) (Tagged x x : xs1), SameLength' (HReplicateR n ()) l1, HLengthEq1 l1 n, HLengthEq2 l1 n, HEq (Label a1) (Label x) b, HFind2 b (Label a1) (LabelsOf xs1) (Label x : LabelsOf xs1) n, HAllTaggedEq (HAppendListR l1 (Tagged a2 a2 : xs2)), HLabelSet (LabelsOf (HAppendListR l1 (Tagged a2 a2 : xs2))), HAllTaggedLV (HAppendListR l1 (Tagged a2 a2 : xs2)), HAppendList l1 (Tagged a2 a2 : xs2), Functor f) => (a1 -> f a2) -> TIP (Tagged x x : xs1) -> f (TIP (HAppendListR l1 (Tagged a2 a2 : xs2)))

+ Data.HList: tipyLens' :: forall {a} {t :: [Type]} {f}. (HasField a (Record t) a, HUpdateAtLabel2 a a t t, HAllTaggedEq t, HLabelSet (LabelsOf t), HAllTaggedLV t, SameLength' t t, SameLabels t t, Functor f) => (a -> f a) -> TIP t -> f (TIP t)

+ Data.HList: tipyProject :: forall {l :: [Type]} {ls :: [Type]} {r :: [Type]} {b :: [Type]} {proxy}. (HAllTaggedEq l, HLabelSet (LabelsOf l), HAllTaggedLV l, H2ProjectByLabels ls r l b) => proxy ls -> TIP r -> TIP l

+ Data.HList: tipyProject2 :: forall {ls :: [Type]} {r :: [Type]} {l1 :: [Type]} {l2 :: [Type]} {proxy}. (H2ProjectByLabels ls r l1 l2, HAllTaggedEq l1, HAllTaggedEq l2, HLabelSet (LabelsOf l1), HLabelSet (LabelsOf l2), HAllTaggedLV l1, HAllTaggedLV l2) => proxy ls -> TIP r -> (TIP l1, TIP l2)

+ Data.HList: tipyTuple :: forall {t1} {r} {v1 :: [Type]} {v2 :: [Type]} {t2} {v3 :: [Type]} {v'1 :: [Type]} {v'2 :: [Type]}. (HOccurs t1 (r v1), HOccurs t1 (r v2), HOccurs t2 (r v2), HOccurs t2 (r v3), HDeleteAtLabel r t1 v1 v'1, HDeleteAtLabel r t1 v2 v3, HDeleteAtLabel r t2 v2 v1, HDeleteAtLabel r t2 v3 v'2) => r v2 -> (t2, t1)

+ Data.HList: tipyTuple3 :: forall {t1} {r} {v1 :: [Type]} {v2 :: [Type]} {v3 :: [Type]} {t2} {v4 :: [Type]} {v5 :: [Type]} {t3} {v6 :: [Type]} {v7 :: [Type]} {v'1 :: [Type]} {v'2 :: [Type]} {v'3 :: [Type]}. (HOccurs t1 (r v1), HOccurs t1 (r v2), HOccurs t1 (r v3), HOccurs t2 (r v4), HOccurs t2 (r v3), HOccurs t2 (r v5), HOccurs t3 (r v3), HOccurs t3 (r v6), HOccurs t3 (r v7), HDeleteAtLabel r t1 v1 v4, HDeleteAtLabel r t1 v2 v'1, HDeleteAtLabel r t1 v3 v5, HDeleteAtLabel r t2 v4 v'2, HDeleteAtLabel r t2 v3 v6, HDeleteAtLabel r t2 v5 v7, HDeleteAtLabel r t3 v3 v1, HDeleteAtLabel r t3 v6 v2, HDeleteAtLabel r t3 v7 v'3) => r v3 -> (t3, t1, t2)

+ Data.HList: tipyTuple4 :: forall {t1} {r} {v1 :: [Type]} {v2 :: [Type]} {v3 :: [Type]} {v4 :: [Type]} {t2} {v5 :: [Type]} {v6 :: [Type]} {v7 :: [Type]} {t3} {v8 :: [Type]} {v9 :: [Type]} {v10 :: [Type]} {t4} {v11 :: [Type]} {v12 :: [Type]} {v13 :: [Type]} {v'1 :: [Type]} {v'2 :: [Type]} {v'3 :: [Type]} {v'4 :: [Type]}. (HOccurs t1 (r v1), HOccurs t1 (r v2), HOccurs t1 (r v3), HOccurs t1 (r v4), HOccurs t2 (r v5), HOccurs t2 (r v6), HOccurs t2 (r v4), HOccurs t2 (r v7), HOccurs t3 (r v8), HOccurs t3 (r v4), HOccurs t3 (r v9), HOccurs t3 (r v10), HOccurs t4 (r v4), HOccurs t4 (r v11), HOccurs t4 (r v12), HOccurs t4 (r v13), HDeleteAtLabel r t1 v1 v5, HDeleteAtLabel r t1 v2 v6, HDeleteAtLabel r t1 v3 v'1, HDeleteAtLabel r t1 v4 v7, HDeleteAtLabel r t2 v5 v8, HDeleteAtLabel r t2 v6 v'2, HDeleteAtLabel r t2 v4 v9, HDeleteAtLabel r t2 v7 v10, HDeleteAtLabel r t3 v8 v'3, HDeleteAtLabel r t3 v4 v11, HDeleteAtLabel r t3 v9 v12, HDeleteAtLabel r t3 v10 v13, HDeleteAtLabel r t4 v4 v1, HDeleteAtLabel r t4 v11 v2, HDeleteAtLabel r t4 v12 v3, HDeleteAtLabel r t4 v13 v'4) => r v4 -> (t4, t1, t2, t3)

+ Data.HList: tipyTuple5 :: forall {t1} {r} {v1 :: [Type]} {v2 :: [Type]} {v3 :: [Type]} {v4 :: [Type]} {v5 :: [Type]} {t2} {v6 :: [Type]} {v7 :: [Type]} {v8 :: [Type]} {v9 :: [Type]} {t3} {v10 :: [Type]} {v11 :: [Type]} {v12 :: [Type]} {v13 :: [Type]} {t4} {v14 :: [Type]} {v15 :: [Type]} {v16 :: [Type]} {v17 :: [Type]} {t5} {v18 :: [Type]} {v19 :: [Type]} {v20 :: [Type]} {v21 :: [Type]} {v'1 :: [Type]} {v'2 :: [Type]} {v'3 :: [Type]} {v'4 :: [Type]} {v'5 :: [Type]}. (HOccurs t1 (r v1), HOccurs t1 (r v2), HOccurs t1 (r v3), HOccurs t1 (r v4), HOccurs t1 (r v5), HOccurs t2 (r v6), HOccurs t2 (r v7), HOccurs t2 (r v8), HOccurs t2 (r v5), HOccurs t2 (r v9), HOccurs t3 (r v10), HOccurs t3 (r v11), HOccurs t3 (r v5), HOccurs t3 (r v12), HOccurs t3 (r v13), HOccurs t4 (r v14), HOccurs t4 (r v5), HOccurs t4 (r v15), HOccurs t4 (r v16), HOccurs t4 (r v17), HOccurs t5 (r v5), HOccurs t5 (r v18), HOccurs t5 (r v19), HOccurs t5 (r v20), HOccurs t5 (r v21), HDeleteAtLabel r t1 v1 v6, HDeleteAtLabel r t1 v2 v7, HDeleteAtLabel r t1 v3 v8, HDeleteAtLabel r t1 v4 v'1, HDeleteAtLabel r t1 v5 v9, HDeleteAtLabel r t2 v6 v10, HDeleteAtLabel r t2 v7 v11, HDeleteAtLabel r t2 v8 v'2, HDeleteAtLabel r t2 v5 v12, HDeleteAtLabel r t2 v9 v13, HDeleteAtLabel r t3 v10 v14, HDeleteAtLabel r t3 v11 v'3, HDeleteAtLabel r t3 v5 v15, HDeleteAtLabel r t3 v12 v16, HDeleteAtLabel r t3 v13 v17, HDeleteAtLabel r t4 v14 v'4, HDeleteAtLabel r t4 v5 v18, HDeleteAtLabel r t4 v15 v19, HDeleteAtLabel r t4 v16 v20, HDeleteAtLabel r t4 v17 v21, HDeleteAtLabel r t5 v5 v1, HDeleteAtLabel r t5 v18 v2, HDeleteAtLabel r t5 v19 v3, HDeleteAtLabel r t5 v20 v4, HDeleteAtLabel r t5 v21 v'5) => r v5 -> (t5, t1, t2, t3, t4)

+ Data.HList: tipyUpdate :: forall {record} {v} {r :: [Type]}. (HUpdateAtLabel record v v r r, SameLength' r r) => v -> record r -> record r

+ Data.HList: typeIndexed' :: forall {t :: [Type]} {r} {tr} {p} {f}. (Coercible (TagR (RecordValuesR t)) t, TypeIndexed r tr, HMapAux HList TaggedFn (RecordValuesR t) t, RecordValues t, SameLabels t t, HAllTaggedLV t, HLabelSet (LabelsOf t), TagUntagFD (RecordValuesR t) (TagR (RecordValuesR t)), Profunctor p, Functor f, SameLength' t t, SameLength' (RecordValuesR t) (RecordValuesR t)) => p (tr (TagR (RecordValuesR t))) (f (tr (TagR (RecordValuesR t)))) -> p (r t) (f (r t))

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

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

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

+ Data.HList: unlabeled0 :: forall {f} {p} {x :: [Type]} {y :: [Type]}. (Functor f, Profunctor p, SameLabels x y, HMapAux HList TaggedFn (RecordValuesR y) y, RecordValues x, RecordValues y) => p (HList (RecordValuesR x)) (f (HList (RecordValuesR y))) -> p (Record x) (f (Record y))

+ Data.HList: unproxy :: forall {k} (s :: k) a. (Proxy s -> a) -> Tagged s a

+ Data.HList: untag :: forall {k} (s :: k) b. Tagged s b -> b

+ Data.HList: unvarianted' :: forall {b :: Bool} {t :: [Type]} {a} {f}. (Unvariant1 b t a, HAllEqVal' (Tagged () a : t), HAllEqVal t b, HAllEqVal (Tagged () a : t) b, SameLabels t t, SameLength' t t, Functor f) => (a -> f a) -> Variant t -> f (Variant t)

+ Data.HList.CommonMain: (.==.) :: forall {k} {x} {l :: k} {v}. EnsureLabel x (Label l) => x -> v -> Tagged l v

+ Data.HList.CommonMain: dredge :: forall {k1} {k2} {r} {ns :: [[Type]]} {xs :: [Type]} {p} {v} {fb :: k1} {rft :: k1} {vs :: [Type]} {ns1 :: [[Type]]} {vs1 :: [Type]} {l :: k2} {ns2 :: [[Type]]} {x}. (MapFieldTree (TryCollectionListTF r) ns, LabelablePath xs (p v fb) (p r rft), SameLength' ns vs, SameLength' ns1 vs1, SameLength' vs ns, SameLength' vs1 ns1, MapFieldTreeVal r (TryCollectionListTF r) vs, FilterLastEq (Label l) ns ns ns1, FilterLastEq (Label l) ns vs vs1, FilterVEq1 v vs1 ns1 ns2, HGuardNonNull (NamesDontMatch r ns l) ns1, HSingleton (NonUnique r v l) (TypesDontMatch r ns1 vs1 v) ns2 xs, EnsureLabel x (Label l)) => x -> p v fb -> p r rft

+ Data.HList.CommonMain: dredge' :: forall {k1} {k2} {s} {ns :: [[Type]]} {xs :: [Type]} {p} {a} {f :: Type -> k1} {vs :: [Type]} {ns1 :: [[Type]]} {vs1 :: [Type]} {l :: k2} {ns2 :: [[Type]]} {x}. (MapFieldTree (TryCollectionListTF s) ns, LabelablePath xs (p a (f a)) (p s (f s)), SameLength' ns vs, SameLength' ns1 vs1, SameLength' vs ns, SameLength' vs1 ns1, MapFieldTreeVal s (TryCollectionListTF s) vs, FilterLastEq (Label l) ns ns ns1, FilterLastEq (Label l) ns vs vs1, FilterVEq1 a vs1 ns1 ns2, HGuardNonNull (NamesDontMatch s ns l) ns1, HSingleton (NonUnique s a l) (TypesDontMatch s ns1 vs1 a) ns2 xs, EnsureLabel x (Label l)) => x -> p a (f a) -> p s (f s)

+ Data.HList.CommonMain: dredgeND :: forall {k1} {k2} {xs :: [Type]} {p} {a} {fb :: k1} {r} {rft :: k1} {ns :: [[Type]]} {l :: k2} {ns' :: [[Type]]} {x}. (LabelablePath xs (p a fb) (p r rft), MapFieldTree (TryCollectionListTF r) ns, FilterLastEq (Label l) ns ns ns', HSingleton (NonUnique' r l) (NamesDontMatch r ns l) ns' xs, EnsureLabel x (Label l)) => x -> p a fb -> p r rft

+ Data.HList.CommonMain: dredgeND' :: forall {k1} {k2} {xs :: [Type]} {p} {a} {f :: Type -> k1} {s} {ns :: [[Type]]} {l :: k2} {ns' :: [[Type]]} {x}. (LabelablePath xs (p a (f a)) (p s (f s)), MapFieldTree (TryCollectionListTF s) ns, FilterLastEq (Label l) ns ns ns', HSingleton (NonUnique' s l) (NamesDontMatch s ns l) ns' xs, EnsureLabel x (Label l)) => x -> p a (f a) -> p s (f s)

+ Data.HList.CommonMain: dredgeTI' :: forall {k} {xs :: [Type]} {p} {a} {f :: Type -> k} {s} {ns :: [[Type]]} {ns' :: [[Type]]} {q}. (LabelablePath xs (p a (f a)) (p s (f s)), MapFieldTree (TryCollectionListTF s) ns, FilterLastEq (Label a) ns ns ns', HSingleton (NonUnique' s a) (NamesDontMatch s ns a) ns' xs) => q a -> p a (f a) -> p s (f s)

+ Data.HList.CommonMain: hAddTag :: forall {a :: [Type]} {b :: [Type]} {r} {t}. (SameLength' a b, SameLength' b a, HMapAux r (HAddTag t) a b) => t -> r a -> r b

+ Data.HList.CommonMain: hCompose :: forall {f1} {n1 :: HNat} {b} {n2 :: HNat} {xs1 :: [Type]} {x} {xs2 :: [Type]} {r} {n3 :: HNat} {f2} {xsys :: [Type]}. (ArityRev f1 n1, ArityRev b n2, ArityFwd f1 n1, ArityFwd b n2, HCurry' n1 f1 xs1 x, HCurry' n2 b xs2 r, HCurry' n3 f2 xsys r, HAppendList1 xs1 xs2 xsys, HSplitAt1 ('[] :: [Type]) n1 xsys xs1 xs2) => (x -> b) -> f1 -> f2

+ Data.HList.CommonMain: hCurry :: forall {n :: HNat} {f} {xs :: [Type]} {r}. (HCurry' n f xs r, ArityFwd f n, ArityRev f n) => (HList xs -> r) -> f

+ Data.HList.CommonMain: hFlag :: forall {a :: [Type]} {b :: [Type]} {r}. (SameLength' a b, SameLength' b a, HMapAux r (HAddTag (Proxy 'True)) a b) => r a -> r b

+ Data.HList.CommonMain: hLast :: forall {l1 :: [Type]} {e} {l :: [Type]}. HRevApp l1 ('[] :: [Type]) (e : l) => HList l1 -> e

+ Data.HList.CommonMain: hLookupByLabelDredge :: forall {k} {ls :: [Type]} {r1} {r2} {v} {ns :: [[Type]]} {l :: k} {ns' :: [[Type]]}. (HasFieldPath 'False ls (r1 r2) v, MapFieldTree (TryCollectionListTF r2) ns, FilterLastEq (Label l) ns ns ns', HSingleton (NonUnique' r2 l) (NamesDontMatch r2 ns l) ns' ls) => Label l -> r1 r2 -> v

+ Data.HList.CommonMain: hMap :: forall {a :: [Type]} {b :: [Type]} {r} {f}. (SameLength' a b, SameLength' b a, HMapAux r f a b) => f -> r a -> r b

+ Data.HList.CommonMain: hMapL :: forall {a :: [Type]} {b :: [Type]} {f}. (SameLength' a b, SameLength' b a, HMapAux HList f a b) => f -> HList a -> HList b

+ Data.HList.CommonMain: hMapV :: forall {f} {x :: [Type]} {y :: [Type]}. (HMapAux Variant (HFmap f) x y, SameLength' x y, SameLength' y x) => f -> Variant x -> Variant y

+ Data.HList.CommonMain: hMaybied :: forall {p} {f} {x :: [Type]} {v1 :: [Type]} {v2 :: [Type]} {r :: [Type]}. (Choice p, Applicative f, HFoldr HMaybiedToVariantFs [Variant ('[] :: [Type])] x [Variant v1], VariantToHMaybied v2 r, VariantToHMaybied v1 x, SameLength' x r, SameLength' r x, HMapAux HList (HFmap HCastF) x r) => p (Variant v1) (f (Variant v2)) -> p (Record x) (f (Record r))

+ Data.HList.CommonMain: hMaybied' :: forall {p} {f} {x :: [Type]} {v :: [Type]}. (Choice p, Applicative f, HFoldr HMaybiedToVariantFs [Variant ('[] :: [Type])] x [Variant v], VariantToHMaybied v x, SameLength' x x, HMapAux HList (HFmap HCastF) x x) => p (Variant v) (f (Variant v)) -> p (Record x) (f (Record x))

+ Data.HList.CommonMain: hReverse_ :: forall {l1 :: [Type]} {l3 :: [Type]}. HRevApp l1 ('[] :: [Type]) l3 => HList l1 -> HList l3

+ Data.HList.CommonMain: hRmTag :: forall {a :: [Type]} {b :: [Type]} {r}. (SameLength' a b, SameLength' b a, HMapAux r HRmTag a b) => r a -> r b

+ Data.HList.CommonMain: hTuple :: forall {p} {f} {v1 :: [Type]} {a} {v2 :: [Type]} {b}. (Profunctor p, Functor f, HTuple v1 a, HTuple v2 b) => p a (f b) -> p (HList v1) (f (HList v2))

+ Data.HList.CommonMain: hTuple' :: forall {p} {f} {v :: [Type]} {a}. (Profunctor p, Functor f, HTuple v a) => p a (f a) -> p (HList v) (f (HList v))

+ Data.HList.CommonMain: hUncurry :: forall {n :: HNat} {f} {xs :: [Type]} {r}. (HCurry' n f xs r, ArityFwd f n, ArityRev f n) => f -> HList xs -> r

+ Data.HList.CommonMain: hUnfold :: forall {f} {a} {z :: [Type]}. (HUnfoldFD f (ApplyR f a) z, Apply f a) => f -> a -> HList z

+ Data.HList.CommonMain: listAsHList :: forall {p} {f} {l1 :: [Type]} {e1} {l2 :: [Type]} {e2}. (Choice p, Applicative f, HList2List l1 e1, HList2List l2 e2) => p (HList l2) (f (HList l1)) -> p [e2] (f [e1])

+ Data.HList.CommonMain: listAsHList' :: forall {p} {f} {l :: [Type]} {e}. (Choice p, Applicative f, HList2List l e) => p (HList l) (f (HList l)) -> p [e] (f [e])

+ Data.HList.CommonMain: mkTIC :: forall {i} {l :: [Type]} {n :: HNat}. (HFind1 i (UnLabel i (LabelsOf l)) (UnLabel i (LabelsOf l)) n, HasField i (Record l) i, HAllTaggedLV l, HLabelSet (LabelsOf l), HAllTaggedEq l, KnownNat (HNat2Nat n)) => i -> TIC l

+ Data.HList.CommonMain: mkVariant1 :: forall {k} {l :: k} {e}. Label l -> e -> Variant '[Tagged l e]

+ Data.HList.CommonMain: projected' :: forall {r} {p} {f} {t :: [Type]} {b :: [Type]}. (LabeledOpticP (LabelableTy r) p, LabeledOpticF (LabelableTy r) f, Projected r t t b b) => p (r b) (f (r b)) -> p (r t) (f (r t))

+ Data.HList.CommonMain: ticVariant :: forall {p} {f} {l1 :: [Type]} {l2 :: [Type]}. (Profunctor p, Functor f) => p (Variant l1) (f (Variant l2)) -> p (TIC l1) (f (TIC l2))

+ Data.HList.CommonMain: ticVariant' :: forall {p} {f} {l :: [Type]}. (Profunctor p, Functor f) => p (Variant l) (f (Variant l)) -> p (TIC l) (f (TIC l))

+ Data.HList.CommonMain: tipHList :: forall {p} {f} {a1 :: [Type]} {ta :: [Type]} {a2 :: [Type]} {l :: [Type]}. (Profunctor p, Functor f, TagUntagFD a1 ta, TagUntagFD a2 l) => p (HList a1) (f (HList a2)) -> p (TIP ta) (f (TIP l))

+ Data.HList.CommonMain: tipHList' :: forall {p} {f} {a :: [Type]} {l :: [Type]}. (Profunctor p, Functor f, TagUntagFD a l) => p (HList a) (f (HList a)) -> p (TIP l) (f (TIP l))

+ Data.HList.CommonMain: tipRecord :: forall {p} {f} {r :: [Type]} {l :: [Type]}. (Profunctor p, Functor f) => p (Record r) (f (Record l)) -> p (TIP r) (f (TIP l))

+ Data.HList.CommonMain: tipRecord' :: forall {p} {f} {l :: [Type]}. (Profunctor p, Functor f) => p (Record l) (f (Record l)) -> p (TIP l) (f (TIP l))

+ Data.HList.CommonMain: tipyLens :: forall {n :: HNat} {x} {xs1 :: [Type]} {l1 :: [Type]} {a1} {xs2 :: [Type]} {b :: Bool} {a2} {f}. (HSplitAt1 ('[] :: [Type]) n (Tagged x x : xs1) l1 (Tagged a1 a1 : xs2), HAppendList1 l1 (Tagged a1 a1 : xs2) (Tagged x x : xs1), SameLength' (HReplicateR n ()) l1, HLengthEq1 l1 n, HLengthEq2 l1 n, HEq (Label a1) (Label x) b, HFind2 b (Label a1) (LabelsOf xs1) (Label x : LabelsOf xs1) n, HAllTaggedEq (HAppendListR l1 (Tagged a2 a2 : xs2)), HLabelSet (LabelsOf (HAppendListR l1 (Tagged a2 a2 : xs2))), HAllTaggedLV (HAppendListR l1 (Tagged a2 a2 : xs2)), HAppendList l1 (Tagged a2 a2 : xs2), Functor f) => (a1 -> f a2) -> TIP (Tagged x x : xs1) -> f (TIP (HAppendListR l1 (Tagged a2 a2 : xs2)))

+ Data.HList.CommonMain: tipyLens' :: forall {a} {t :: [Type]} {f}. (HasField a (Record t) a, HUpdateAtLabel2 a a t t, HAllTaggedEq t, HLabelSet (LabelsOf t), HAllTaggedLV t, SameLength' t t, SameLabels t t, Functor f) => (a -> f a) -> TIP t -> f (TIP t)

+ Data.HList.CommonMain: tipyProject :: forall {l :: [Type]} {ls :: [Type]} {r :: [Type]} {b :: [Type]} {proxy}. (HAllTaggedEq l, HLabelSet (LabelsOf l), HAllTaggedLV l, H2ProjectByLabels ls r l b) => proxy ls -> TIP r -> TIP l

+ Data.HList.CommonMain: tipyProject2 :: forall {ls :: [Type]} {r :: [Type]} {l1 :: [Type]} {l2 :: [Type]} {proxy}. (H2ProjectByLabels ls r l1 l2, HAllTaggedEq l1, HAllTaggedEq l2, HLabelSet (LabelsOf l1), HLabelSet (LabelsOf l2), HAllTaggedLV l1, HAllTaggedLV l2) => proxy ls -> TIP r -> (TIP l1, TIP l2)

+ Data.HList.CommonMain: tipyTuple :: forall {t1} {r} {v1 :: [Type]} {v2 :: [Type]} {t2} {v3 :: [Type]} {v'1 :: [Type]} {v'2 :: [Type]}. (HOccurs t1 (r v1), HOccurs t1 (r v2), HOccurs t2 (r v2), HOccurs t2 (r v3), HDeleteAtLabel r t1 v1 v'1, HDeleteAtLabel r t1 v2 v3, HDeleteAtLabel r t2 v2 v1, HDeleteAtLabel r t2 v3 v'2) => r v2 -> (t2, t1)

+ Data.HList.CommonMain: tipyTuple3 :: forall {t1} {r} {v1 :: [Type]} {v2 :: [Type]} {v3 :: [Type]} {t2} {v4 :: [Type]} {v5 :: [Type]} {t3} {v6 :: [Type]} {v7 :: [Type]} {v'1 :: [Type]} {v'2 :: [Type]} {v'3 :: [Type]}. (HOccurs t1 (r v1), HOccurs t1 (r v2), HOccurs t1 (r v3), HOccurs t2 (r v4), HOccurs t2 (r v3), HOccurs t2 (r v5), HOccurs t3 (r v3), HOccurs t3 (r v6), HOccurs t3 (r v7), HDeleteAtLabel r t1 v1 v4, HDeleteAtLabel r t1 v2 v'1, HDeleteAtLabel r t1 v3 v5, HDeleteAtLabel r t2 v4 v'2, HDeleteAtLabel r t2 v3 v6, HDeleteAtLabel r t2 v5 v7, HDeleteAtLabel r t3 v3 v1, HDeleteAtLabel r t3 v6 v2, HDeleteAtLabel r t3 v7 v'3) => r v3 -> (t3, t1, t2)

+ Data.HList.CommonMain: tipyTuple4 :: forall {t1} {r} {v1 :: [Type]} {v2 :: [Type]} {v3 :: [Type]} {v4 :: [Type]} {t2} {v5 :: [Type]} {v6 :: [Type]} {v7 :: [Type]} {t3} {v8 :: [Type]} {v9 :: [Type]} {v10 :: [Type]} {t4} {v11 :: [Type]} {v12 :: [Type]} {v13 :: [Type]} {v'1 :: [Type]} {v'2 :: [Type]} {v'3 :: [Type]} {v'4 :: [Type]}. (HOccurs t1 (r v1), HOccurs t1 (r v2), HOccurs t1 (r v3), HOccurs t1 (r v4), HOccurs t2 (r v5), HOccurs t2 (r v6), HOccurs t2 (r v4), HOccurs t2 (r v7), HOccurs t3 (r v8), HOccurs t3 (r v4), HOccurs t3 (r v9), HOccurs t3 (r v10), HOccurs t4 (r v4), HOccurs t4 (r v11), HOccurs t4 (r v12), HOccurs t4 (r v13), HDeleteAtLabel r t1 v1 v5, HDeleteAtLabel r t1 v2 v6, HDeleteAtLabel r t1 v3 v'1, HDeleteAtLabel r t1 v4 v7, HDeleteAtLabel r t2 v5 v8, HDeleteAtLabel r t2 v6 v'2, HDeleteAtLabel r t2 v4 v9, HDeleteAtLabel r t2 v7 v10, HDeleteAtLabel r t3 v8 v'3, HDeleteAtLabel r t3 v4 v11, HDeleteAtLabel r t3 v9 v12, HDeleteAtLabel r t3 v10 v13, HDeleteAtLabel r t4 v4 v1, HDeleteAtLabel r t4 v11 v2, HDeleteAtLabel r t4 v12 v3, HDeleteAtLabel r t4 v13 v'4) => r v4 -> (t4, t1, t2, t3)

+ Data.HList.CommonMain: tipyTuple5 :: forall {t1} {r} {v1 :: [Type]} {v2 :: [Type]} {v3 :: [Type]} {v4 :: [Type]} {v5 :: [Type]} {t2} {v6 :: [Type]} {v7 :: [Type]} {v8 :: [Type]} {v9 :: [Type]} {t3} {v10 :: [Type]} {v11 :: [Type]} {v12 :: [Type]} {v13 :: [Type]} {t4} {v14 :: [Type]} {v15 :: [Type]} {v16 :: [Type]} {v17 :: [Type]} {t5} {v18 :: [Type]} {v19 :: [Type]} {v20 :: [Type]} {v21 :: [Type]} {v'1 :: [Type]} {v'2 :: [Type]} {v'3 :: [Type]} {v'4 :: [Type]} {v'5 :: [Type]}. (HOccurs t1 (r v1), HOccurs t1 (r v2), HOccurs t1 (r v3), HOccurs t1 (r v4), HOccurs t1 (r v5), HOccurs t2 (r v6), HOccurs t2 (r v7), HOccurs t2 (r v8), HOccurs t2 (r v5), HOccurs t2 (r v9), HOccurs t3 (r v10), HOccurs t3 (r v11), HOccurs t3 (r v5), HOccurs t3 (r v12), HOccurs t3 (r v13), HOccurs t4 (r v14), HOccurs t4 (r v5), HOccurs t4 (r v15), HOccurs t4 (r v16), HOccurs t4 (r v17), HOccurs t5 (r v5), HOccurs t5 (r v18), HOccurs t5 (r v19), HOccurs t5 (r v20), HOccurs t5 (r v21), HDeleteAtLabel r t1 v1 v6, HDeleteAtLabel r t1 v2 v7, HDeleteAtLabel r t1 v3 v8, HDeleteAtLabel r t1 v4 v'1, HDeleteAtLabel r t1 v5 v9, HDeleteAtLabel r t2 v6 v10, HDeleteAtLabel r t2 v7 v11, HDeleteAtLabel r t2 v8 v'2, HDeleteAtLabel r t2 v5 v12, HDeleteAtLabel r t2 v9 v13, HDeleteAtLabel r t3 v10 v14, HDeleteAtLabel r t3 v11 v'3, HDeleteAtLabel r t3 v5 v15, HDeleteAtLabel r t3 v12 v16, HDeleteAtLabel r t3 v13 v17, HDeleteAtLabel r t4 v14 v'4, HDeleteAtLabel r t4 v5 v18, HDeleteAtLabel r t4 v15 v19, HDeleteAtLabel r t4 v16 v20, HDeleteAtLabel r t4 v17 v21, HDeleteAtLabel r t5 v5 v1, HDeleteAtLabel r t5 v18 v2, HDeleteAtLabel r t5 v19 v3, HDeleteAtLabel r t5 v20 v4, HDeleteAtLabel r t5 v21 v'5) => r v5 -> (t5, t1, t2, t3, t4)

+ Data.HList.CommonMain: tipyUpdate :: forall {record} {v} {r :: [Type]}. (HUpdateAtLabel record v v r r, SameLength' r r) => v -> record r -> record r

+ Data.HList.CommonMain: typeIndexed' :: forall {t :: [Type]} {r} {tr} {p} {f}. (Coercible (TagR (RecordValuesR t)) t, TypeIndexed r tr, HMapAux HList TaggedFn (RecordValuesR t) t, RecordValues t, SameLabels t t, HAllTaggedLV t, HLabelSet (LabelsOf t), TagUntagFD (RecordValuesR t) (TagR (RecordValuesR t)), Profunctor p, Functor f, SameLength' t t, SameLength' (RecordValuesR t) (RecordValuesR t)) => p (tr (TagR (RecordValuesR t))) (f (tr (TagR (RecordValuesR t)))) -> p (r t) (f (r t))

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

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

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

+ Data.HList.CommonMain: unvarianted' :: forall {b :: Bool} {t :: [Type]} {a} {f}. (Unvariant1 b t a, HAllEqVal' (Tagged () a : t), HAllEqVal t b, HAllEqVal (Tagged () a : t) b, SameLabels t t, SameLength' t t, Functor f) => (a -> f a) -> Variant t -> f (Variant t)

+ Data.HList.Dredge: dredge :: forall {k} {k} {r} {ns :: [[Type]]} {xs :: [Type]} {p} {v} {fb :: k} {rft :: k} {vs :: [Type]} {ns1 :: [[Type]]} {vs1 :: [Type]} {l :: k} {ns2 :: [[Type]]} {x}. (MapFieldTree (TryCollectionListTF r) ns, LabelablePath xs (p v fb) (p r rft), SameLength' ns vs, SameLength' ns1 vs1, SameLength' vs ns, SameLength' vs1 ns1, MapFieldTreeVal r (TryCollectionListTF r) vs, FilterLastEq (Label l) ns ns ns1, FilterLastEq (Label l) ns vs vs1, FilterVEq1 v vs1 ns1 ns2, HGuardNonNull (NamesDontMatch r ns l) ns1, HSingleton (NonUnique r v l) (TypesDontMatch r ns1 vs1 v) ns2 xs, EnsureLabel x (Label l)) => x -> p v fb -> p r rft

+ Data.HList.Dredge: dredge' :: forall {k} {k} {s} {ns :: [[Type]]} {xs :: [Type]} {p} {a} {f :: Type -> k} {vs :: [Type]} {ns1 :: [[Type]]} {vs1 :: [Type]} {l :: k} {ns2 :: [[Type]]} {x}. (MapFieldTree (TryCollectionListTF s) ns, LabelablePath xs (p a (f a)) (p s (f s)), SameLength' ns vs, SameLength' ns1 vs1, SameLength' vs ns, SameLength' vs1 ns1, MapFieldTreeVal s (TryCollectionListTF s) vs, FilterLastEq (Label l) ns ns ns1, FilterLastEq (Label l) ns vs vs1, FilterVEq1 a vs1 ns1 ns2, HGuardNonNull (NamesDontMatch s ns l) ns1, HSingleton (NonUnique s a l) (TypesDontMatch s ns1 vs1 a) ns2 xs, EnsureLabel x (Label l)) => x -> p a (f a) -> p s (f s)

+ Data.HList.Dredge: dredgeND :: forall {k} {k} {xs :: [Type]} {p} {a} {fb :: k} {r} {rft :: k} {ns :: [[Type]]} {l :: k} {ns' :: [[Type]]} {x}. (LabelablePath xs (p a fb) (p r rft), MapFieldTree (TryCollectionListTF r) ns, FilterLastEq (Label l) ns ns ns', HSingleton (NonUnique' r l) (NamesDontMatch r ns l) ns' xs, EnsureLabel x (Label l)) => x -> p a fb -> p r rft

+ Data.HList.Dredge: dredgeND' :: forall {k} {k} {xs :: [Type]} {p} {a} {f :: Type -> k} {s} {ns :: [[Type]]} {l :: k} {ns' :: [[Type]]} {x}. (LabelablePath xs (p a (f a)) (p s (f s)), MapFieldTree (TryCollectionListTF s) ns, FilterLastEq (Label l) ns ns ns', HSingleton (NonUnique' s l) (NamesDontMatch s ns l) ns' xs, EnsureLabel x (Label l)) => x -> p a (f a) -> p s (f s)

+ Data.HList.Dredge: dredgeTI' :: forall {k} {xs :: [Type]} {p} {a} {f :: Type -> k} {s} {ns :: [[Type]]} {ns' :: [[Type]]} {q}. (LabelablePath xs (p a (f a)) (p s (f s)), MapFieldTree (TryCollectionListTF s) ns, FilterLastEq (Label a) ns ns ns', HSingleton (NonUnique' s a) (NamesDontMatch s ns a) ns' xs) => q a -> p a (f a) -> p s (f s)

+ Data.HList.Dredge: hLookupByLabelDredge :: forall {k} {ls :: [Type]} {r} {r} {v} {ns :: [[Type]]} {l :: k} {ns' :: [[Type]]}. (HasFieldPath 'False ls (r r) v, MapFieldTree (TryCollectionListTF r) ns, FilterLastEq (Label l) ns ns ns', HSingleton (NonUnique' r l) (NamesDontMatch r ns l) ns' ls) => Label l -> r r -> v

+ Data.HList.HArray: hProjectAwayByHNats :: forall {ns :: [HNat]} {a} {z :: [Type]}. (HUnfoldFD (FHUProj 'False ns) (ApplyR (FHUProj 'False ns) (a, Proxy 'HZero)) z, Apply (FHUProj 'False ns) (a, Proxy 'HZero)) => Proxy ns -> a -> HList z

+ Data.HList.HArray: hProjectByHNats :: forall {ns :: [HNat]} {a} {z :: [Type]}. (HUnfoldFD (FHUProj 'True ns) (ApplyR (FHUProj 'True ns) (a, Proxy 'HZero)) z, Apply (FHUProj 'True ns) (a, Proxy 'HZero)) => Proxy ns -> a -> HList z

+ Data.HList.HArray: hProjectByHNats' :: forall {a :: [Type]} {b :: [Type]} {r} {l :: [Type]}. (SameLength' a b, SameLength' b a, HMapAux r (FHLookupByHNat l) a b) => r a -> HList l -> r b

+ Data.HList.HArray: hSplitByHNats :: forall {ns :: [HNat]} {a} {z :: [Type]} {z :: [Type]}. (HUnfoldFD (FHUProj 'True ns) (ApplyR (FHUProj 'True ns) (a, Proxy 'HZero)) z, HUnfoldFD (FHUProj 'False ns) (ApplyR (FHUProj 'False ns) (a, Proxy 'HZero)) z, Apply (FHUProj 'True ns) (a, Proxy 'HZero), Apply (FHUProj 'False ns) (a, Proxy 'HZero)) => Proxy ns -> a -> (HList z, HList z)

+ Data.HList.HCurry: hCompose :: forall {f} {n :: HNat} {b} {n :: HNat} {xs :: [Type]} {x} {xs :: [Type]} {r} {n :: HNat} {f} {xsys :: [Type]}. (ArityRev f n, ArityRev b n, ArityFwd f n, ArityFwd b n, HCurry' n f xs x, HCurry' n b xs r, HCurry' n f xsys r, HAppendList1 xs xs xsys, HSplitAt1 ('[] :: [Type]) n xsys xs xs) => (x -> b) -> f -> f

+ Data.HList.HCurry: hCurry :: forall {n :: HNat} {f} {xs :: [Type]} {r}. (HCurry' n f xs r, ArityFwd f n, ArityRev f n) => (HList xs -> r) -> f

+ Data.HList.HCurry: hUncurry :: forall {n :: HNat} {f} {xs :: [Type]} {r}. (HCurry' n f xs r, ArityFwd f n, ArityRev f n) => f -> HList xs -> r

+ Data.HList.HList: hAddTag :: forall {a :: [Type]} {b :: [Type]} {r} {t}. (SameLength' a b, SameLength' b a, HMapAux r (HAddTag t) a b) => t -> r a -> r b

+ Data.HList.HList: hFlag :: forall {a :: [Type]} {b :: [Type]} {r}. (SameLength' a b, SameLength' b a, HMapAux r (HAddTag (Proxy 'True)) a b) => r a -> r b

+ Data.HList.HList: hLast :: forall {l1 :: [Type]} {e} {l :: [Type]}. HRevApp l1 ('[] :: [Type]) (e : l) => HList l1 -> e

+ Data.HList.HList: hMap :: forall {a :: [Type]} {b :: [Type]} {r} {f}. (SameLength' a b, SameLength' b a, HMapAux r f a b) => f -> r a -> r b

+ Data.HList.HList: hMapL :: forall {a :: [Type]} {b :: [Type]} {f}. (SameLength' a b, SameLength' b a, HMapAux HList f a b) => f -> HList a -> HList b

+ Data.HList.HList: hReverse_ :: forall {l1 :: [Type]} {l3 :: [Type]}. HRevApp l1 ('[] :: [Type]) l3 => HList l1 -> HList l3

+ Data.HList.HList: hRmTag :: forall {a :: [Type]} {b :: [Type]} {r}. (SameLength' a b, SameLength' b a, HMapAux r HRmTag a b) => r a -> r b

+ Data.HList.HList: hSequence2 :: forall {f} {l :: [Type]} {a}. (Applicative f, HFoldr (LiftA2 FHCons) (f (HList ('[] :: [Type]))) l (f a)) => HList l -> f a

+ Data.HList.HList: hTuple :: forall {p} {f} {v :: [Type]} {a} {v :: [Type]} {b}. (Profunctor p, Functor f, HTuple v a, HTuple v b) => p a (f b) -> p (HList v) (f (HList v))

+ Data.HList.HList: hTuple' :: forall {p} {f} {v :: [Type]} {a}. (Profunctor p, Functor f, HTuple v a) => p a (f a) -> p (HList v) (f (HList v))

+ Data.HList.HList: hUnfold :: forall {f} {a} {z :: [Type]}. (HUnfoldFD f (ApplyR f a) z, Apply f a) => f -> a -> HList z

+ Data.HList.HList: listAsHList :: forall {p} {f} {l :: [Type]} {e} {l :: [Type]} {e}. (Choice p, Applicative f, HList2List l e, HList2List l e) => p (HList l) (f (HList l)) -> p [e] (f [e])

+ Data.HList.HList: listAsHList' :: forall {p} {f} {l :: [Type]} {e}. (Choice p, Applicative f, HList2List l e) => p (HList l) (f (HList l)) -> p [e] (f [e])

+ Data.HList.HOccurs: hOccursRest :: forall {l} {r} {v :: [Type]} {v' :: [Type]}. (HOccurs l (r v), HDeleteAtLabel r l v v') => r v -> (l, r v')

+ Data.HList.HSort: hMerge1 :: forall {t :: Bool} {y} {x} {a} {b}. (HCond t y x a, HCond t x y b) => Proxy t -> y -> x -> (a, b)

+ Data.HList.HTypeIndexed: hDeleteAt :: forall {n :: HNat} {l :: [Type]} {e} {proxy1}. (HDeleteAtHNat n l, HType2HNat e l n) => proxy1 e -> HList l -> HList (HDeleteAtHNatR n l)

+ Data.HList.HTypeIndexed: hProjectBy :: forall {k} {ns :: [HNat]} {hlist} {l :: k} {z :: [Type]} {es :: [Type]}. (HUnfoldFD (FHUProj 'True ns) (ApplyR (FHUProj 'True ns) (hlist l, Proxy 'HZero)) z, Apply (FHUProj 'True ns) (hlist l, Proxy 'HZero), HTypes2HNats es l ns) => Proxy es -> hlist l -> HList z

+ Data.HList.HTypeIndexed: hSplitBy :: forall {k} {ns :: [HNat]} {hlist} {l :: k} {z1 :: [Type]} {z2 :: [Type]} {es :: [Type]}. (HUnfoldFD (FHUProj 'True ns) (ApplyR (FHUProj 'True ns) (hlist l, Proxy 'HZero)) z1, HUnfoldFD (FHUProj 'False ns) (ApplyR (FHUProj 'False ns) (hlist l, Proxy 'HZero)) z2, Apply (FHUProj 'True ns) (hlist l, Proxy 'HZero), Apply (FHUProj 'False ns) (hlist l, Proxy 'HZero), HTypes2HNats es l ns) => Proxy es -> hlist l -> (HList z1, HList z2)

+ Data.HList.HTypeIndexed: hUpdateAt :: forall {n :: HNat} {e} {l :: [Type]}. (HUpdateAtHNat' n e l l, HType2HNat e l n) => e -> HList l -> HList (HUpdateAtHNatR n e l)

+ Data.HList.HZip: hTranspose :: forall {a :: [Type]} {b :: [Type]} {c :: [Type]} {es :: [Type]} {l :: [Type]} {n :: HNat}. (HZip3 a b c, HFoldr HZipF (HList es) l (HList b), HReplicateFD n (HList ('[] :: [Type])) es, SameLength' (HReplicateR n ()) a, HLengthEq1 a n, HLengthEq2 a n) => HList (HList a : l) -> HList c

+ Data.HList.Labelable: (.==.) :: forall {k} {x} {l :: k} {v}. EnsureLabel x (Label l) => x -> v -> Tagged l v

+ Data.HList.Labelable: projected' :: forall {r} {p} {f} {t :: [Type]} {b :: [Type]}. (LabeledOpticP (LabelableTy r) p, LabeledOpticF (LabelableTy r) f, Projected r t t b b) => p (r b) (f (r b)) -> p (r t) (f (r t))

+ Data.HList.Labelable: toLabelSym :: forall {x} {x :: Symbol}. EnsureLabel x (Label x) => x -> Label x

+ Data.HList.Record: (.<.) :: forall {k} {record} {l :: k} {v} {r :: [Type]}. (HUpdateAtLabel record l v r r, SameLength' r r) => Tagged l v -> record r -> record r

+ Data.HList.Record: (.@.) :: forall {k} {record} {l :: k} {v} {r :: [Type]} {r' :: [Type]}. (HUpdateAtLabel record l v r r', SameLength' r r', SameLength' r' r) => Tagged l v -> record r -> record r'

+ Data.HList.Record: class HasFieldM (l :: k) r (v :: Maybe (*)) | l r -> v

+ Data.HList.Record: hListRecord :: forall {p} {f} {r :: [Type]} {r :: [Type]}. (Profunctor p, Functor f, HLabelSet (LabelsOf r), HAllTaggedLV r) => p (Record r) (f (Record r)) -> p (HList r) (f (HList r))

+ Data.HList.Record: hListRecord' :: forall {p} {f} {r :: [Type]}. (Profunctor p, Functor f, HLabelSet (LabelsOf r), HAllTaggedLV r) => p (Record r) (f (Record r)) -> p (HList r) (f (HList r))

+ Data.HList.Record: hMapR :: forall {x :: [Type]} {y :: [Type]} {f}. (SameLength' x y, SameLength' y x, HMapAux HList (HFmap f) x y) => f -> Record x -> Record y

+ Data.HList.Record: hProjectByLabels' :: forall {l :: [Type]} {r :: [Type]} {t :: [Type]} {b :: [Type]}. (HRearrange3 (LabelsOf l) r l, SameLength' r l, SameLength' r (LabelsOf l), SameLength' l r, SameLength' (LabelsOf l) r, HLabelSet (LabelsOf l), HLabelSet (LabelsOf r), HAllTaggedLV r, H2ProjectByLabels (LabelsOf l) t r b) => Record t -> Record l

+ Data.HList.Record: hRearrange' :: forall {l :: [Type]} {r :: [Type]}. (HLabelSet (LabelsOf l), HRearrange3 (LabelsOf l) r l, SameLength' r l, SameLength' r (LabelsOf l), SameLength' l r, SameLength' (LabelsOf l) r) => Record r -> Record l

+ Data.HList.Record: hRenameLabel :: forall {k} {k} {r} {l :: k} {v :: [Type]} {v' :: [Type]} {v} {l :: k}. (HDeleteAtLabel r l v v', HasField l (r v) v, HExtend (Tagged l v) (r v')) => Label l -> Label l -> r v -> HExtendR (Tagged l v) (r v')

+ Data.HList.Record: hUnzipRecord2 :: forall {x :: [Type]} {y :: [Type]} {x :: [Type]}. (SameLabels x y, SameLabels x y, HAllTaggedLV x, HAllTaggedLV x, HZipList (RecordValuesR x) (RecordValuesR x) (RecordValuesR y), HMapAux HList TaggedFn (RecordValuesR x) x, HMapAux HList TaggedFn (RecordValuesR x) x, RecordValues x, RecordValues y, RecordValues x, SameLength' x y, SameLength' x y, SameLength' y x, SameLength' y x) => Record y -> (Record x, Record x)

+ Data.HList.Record: hZipRecord2 :: forall {x :: [Type]} {y :: [Type]} {y :: [Type]}. (SameLabels x y, SameLabels x y, HAllTaggedLV x, HMapAux HList TaggedFn (RecordValuesR x) x, HZipList (RecordValuesR y) (RecordValuesR y) (RecordValuesR x), RecordValues x, RecordValues y, RecordValues y, SameLength' x y, SameLength' x y, SameLength' y x, SameLength' y x) => Record y -> Record y -> Record x

+ Data.HList.Record: rearranged' :: forall {k} {r} {t :: k} {b :: k} {p} {f}. (Rearranged r t t b b, Profunctor p, Functor f) => p (r b) (f (r b)) -> p (r t) (f (r t))

+ Data.HList.Record: relabeled' :: forall {t :: [Type]} {b :: [Type]} {r} {p} {f}. (RecordValuesR t ~ RecordValuesR b, Relabeled r, HMapAux HList TaggedFn (RecordValuesR t) b, HMapAux HList TaggedFn (RecordValuesR b) t, RecordValues b, RecordValues t, SameLength' t b, SameLength' t (RecordValuesR b), SameLength' b t, SameLength' b (RecordValuesR t), SameLength' (RecordValuesR t) b, SameLength' (RecordValuesR b) t, Profunctor p, Functor f) => p (r b) (f (r b)) -> p (r t) (f (r t))

+ Data.HList.Record: unlabeled0 :: forall {f} {p} {x :: [Type]} {y :: [Type]}. (Functor f, Profunctor p, SameLabels x y, HMapAux HList TaggedFn (RecordValuesR y) y, RecordValues x, RecordValues y) => p (HList (RecordValuesR x)) (f (HList (RecordValuesR y))) -> p (Record x) (f (Record y))

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

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

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

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

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

+ Data.HList.TIC: mkTIC :: forall {i} {l :: [Type]} {n :: HNat}. (HFind1 i (UnLabel i (LabelsOf l)) (UnLabel i (LabelsOf l)) n, HasField i (Record l) i, HAllTaggedLV l, HLabelSet (LabelsOf l), HAllTaggedEq l, KnownNat (HNat2Nat n)) => i -> TIC l

+ Data.HList.TIC: ticVariant :: forall {p} {f} {l :: [Type]} {l :: [Type]}. (Profunctor p, Functor f) => p (Variant l) (f (Variant l)) -> p (TIC l) (f (TIC l))

+ Data.HList.TIC: ticVariant' :: forall {p} {f} {l :: [Type]}. (Profunctor p, Functor f) => p (Variant l) (f (Variant l)) -> p (TIC l) (f (TIC l))

+ Data.HList.TIC: typeIndexed' :: forall {t :: [Type]} {r} {tr} {p} {f}. (Coercible (TagR (RecordValuesR t)) t, TypeIndexed r tr, HMapAux HList TaggedFn (RecordValuesR t) t, RecordValues t, SameLabels t t, HAllTaggedLV t, HLabelSet (LabelsOf t), TagUntagFD (RecordValuesR t) (TagR (RecordValuesR t)), Profunctor p, Functor f, SameLength' t t, SameLength' (RecordValuesR t) (RecordValuesR t)) => p (tr (TagR (RecordValuesR t))) (f (tr (TagR (RecordValuesR t)))) -> p (r t) (f (r t))

+ Data.HList.TIP: hUnzipTIP :: forall {a :: [Type]} {a :: [Type]} {l :: [Type]} {l :: [Type]} {l :: [Type]} {ta :: [Type]}. (HZipList a a l, HAllTaggedEq l, HAllTaggedEq l, HLabelSet (LabelsOf l), HLabelSet (LabelsOf l), HAllTaggedLV l, HAllTaggedLV l, TagUntagFD l ta, TagUntagFD a l, TagUntagFD a l) => TIP ta -> (TIP l, TIP l)

+ Data.HList.TIP: hZipTIP :: forall {x :: [Type]} {y :: [Type]} {a :: [Type]} {l :: [Type]} {ta :: [Type]} {ta :: [Type]}. (HZipList x y a, TagUntagFD a l, TagUntagFD x ta, TagUntagFD y ta) => TIP ta -> TIP ta -> TIP l

+ Data.HList.TIP: onRecord :: forall {l :: [Type]} {r :: [Type]}. (HAllTaggedEq l, HLabelSet (LabelsOf l), HAllTaggedLV l) => (Record r -> Record l) -> TIP r -> TIP l

+ Data.HList.TIP: tipHList :: forall {p} {f} {a :: [Type]} {ta :: [Type]} {a :: [Type]} {l :: [Type]}. (Profunctor p, Functor f, TagUntagFD a ta, TagUntagFD a l) => p (HList a) (f (HList a)) -> p (TIP ta) (f (TIP l))

+ Data.HList.TIP: tipHList' :: forall {p} {f} {a :: [Type]} {l :: [Type]}. (Profunctor p, Functor f, TagUntagFD a l) => p (HList a) (f (HList a)) -> p (TIP l) (f (TIP l))

+ Data.HList.TIP: tipRecord :: forall {p} {f} {r :: [Type]} {l :: [Type]}. (Profunctor p, Functor f) => p (Record r) (f (Record l)) -> p (TIP r) (f (TIP l))

+ Data.HList.TIP: tipRecord' :: forall {p} {f} {l :: [Type]}. (Profunctor p, Functor f) => p (Record l) (f (Record l)) -> p (TIP l) (f (TIP l))

+ Data.HList.TIP: tipyLens :: forall {n :: HNat} {x} {xs :: [Type]} {l1 :: [Type]} {a} {xs :: [Type]} {b :: Bool} {a} {f}. (HSplitAt1 ('[] :: [Type]) n (Tagged x x : xs) l1 (Tagged a a : xs), HAppendList1 l1 (Tagged a a : xs) (Tagged x x : xs), SameLength' (HReplicateR n ()) l1, HLengthEq1 l1 n, HLengthEq2 l1 n, HEq (Label a) (Label x) b, HFind2 b (Label a) (LabelsOf xs) (Label x : LabelsOf xs) n, HAllTaggedEq (HAppendListR l1 (Tagged a a : xs)), HLabelSet (LabelsOf (HAppendListR l1 (Tagged a a : xs))), HAllTaggedLV (HAppendListR l1 (Tagged a a : xs)), HAppendList l1 (Tagged a a : xs), Functor f) => (a -> f a) -> TIP (Tagged x x : xs) -> f (TIP (HAppendListR l1 (Tagged a a : xs)))

+ Data.HList.TIP: tipyLens' :: forall {a} {t :: [Type]} {f}. (HasField a (Record t) a, HUpdateAtLabel2 a a t t, HAllTaggedEq t, HLabelSet (LabelsOf t), HAllTaggedLV t, SameLength' t t, SameLabels t t, Functor f) => (a -> f a) -> TIP t -> f (TIP t)

+ Data.HList.TIP: tipyProject :: forall {l :: [Type]} {ls :: [Type]} {r :: [Type]} {b :: [Type]} {proxy}. (HAllTaggedEq l, HLabelSet (LabelsOf l), HAllTaggedLV l, H2ProjectByLabels ls r l b) => proxy ls -> TIP r -> TIP l

+ Data.HList.TIP: tipyProject2 :: forall {ls :: [Type]} {r :: [Type]} {l :: [Type]} {l :: [Type]} {proxy}. (H2ProjectByLabels ls r l l, HAllTaggedEq l, HAllTaggedEq l, HLabelSet (LabelsOf l), HLabelSet (LabelsOf l), HAllTaggedLV l, HAllTaggedLV l) => proxy ls -> TIP r -> (TIP l, TIP l)

+ Data.HList.TIP: tipyUpdate :: forall {record} {v} {r :: [Type]}. (HUpdateAtLabel record v v r r, SameLength' r r) => v -> record r -> record r

+ Data.HList.TIPtuple: tipyTuple :: forall {t} {r} {v :: [Type]} {v :: [Type]} {t} {v :: [Type]} {v' :: [Type]} {v' :: [Type]}. (HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HDeleteAtLabel r t v v', HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v') => r v -> (t, t)

+ Data.HList.TIPtuple: tipyTuple3 :: forall {t} {r} {v :: [Type]} {v :: [Type]} {v :: [Type]} {t} {v :: [Type]} {v :: [Type]} {t} {v :: [Type]} {v :: [Type]} {v' :: [Type]} {v' :: [Type]} {v' :: [Type]}. (HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HDeleteAtLabel r t v v, HDeleteAtLabel r t v v', HDeleteAtLabel r t v v, HDeleteAtLabel r t v v', HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v') => r v -> (t, t, t)

+ Data.HList.TIPtuple: tipyTuple4 :: forall {t} {r} {v :: [Type]} {v :: [Type]} {v :: [Type]} {v :: [Type]} {t} {v :: [Type]} {v :: [Type]} {v :: [Type]} {t} {v :: [Type]} {v :: [Type]} {v :: [Type]} {t} {v :: [Type]} {v :: [Type]} {v :: [Type]} {v' :: [Type]} {v' :: [Type]} {v' :: [Type]} {v' :: [Type]}. (HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v', HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v', HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v', HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v') => r v -> (t, t, t, t)

+ Data.HList.TIPtuple: tipyTuple5 :: forall {t} {r} {v :: [Type]} {v :: [Type]} {v :: [Type]} {v :: [Type]} {v :: [Type]} {t} {v :: [Type]} {v :: [Type]} {v :: [Type]} {v :: [Type]} {t} {v :: [Type]} {v :: [Type]} {v :: [Type]} {v :: [Type]} {t} {v :: [Type]} {v :: [Type]} {v :: [Type]} {v :: [Type]} {t} {v :: [Type]} {v :: [Type]} {v :: [Type]} {v :: [Type]} {v' :: [Type]} {v' :: [Type]} {v' :: [Type]} {v' :: [Type]} {v' :: [Type]}. (HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HOccurs t (r v), HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v', HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v', HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v', HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v', HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v, HDeleteAtLabel r t v v') => r v -> (t, t, t, t, t)

+ Data.HList.Variant: eqVariant :: forall {x :: [Type]} {b :: Bool} {x :: [Type]} {y :: [Type]}. (SameLength' x (HMapOutV_gety x Bool), SameLength' (HMapOutV_gety x Bool) x, HMapAux Variant (HFmap UncurryEq) x (HMapOutV_gety x Bool), Unvariant1 b (HMapOutV_gety x Bool) Bool, HAllEqVal (Tagged () Bool : HMapOutV_gety x Bool) b, HAllEqVal (HMapOutV_gety x Bool) b, ZipVariant x y x) => Variant x -> Variant y -> Bool

+ Data.HList.Variant: hMapV :: forall {f} {x :: [Type]} {y :: [Type]}. (HMapAux Variant (HFmap f) x y, SameLength' x y, SameLength' y x) => f -> Variant x -> Variant y

+ Data.HList.Variant: hMaybied :: forall {p} {f} {x :: [Type]} {v :: [Type]} {v :: [Type]} {r :: [Type]}. (Choice p, Applicative f, HFoldr HMaybiedToVariantFs [Variant ('[] :: [Type])] x [Variant v], VariantToHMaybied v r, VariantToHMaybied v x, SameLength' x r, SameLength' r x, HMapAux HList (HFmap HCastF) x r) => p (Variant v) (f (Variant v)) -> p (Record x) (f (Record r))

+ Data.HList.Variant: hMaybied' :: forall {p} {f} {x :: [Type]} {v :: [Type]}. (Choice p, Applicative f, HFoldr HMaybiedToVariantFs [Variant ('[] :: [Type])] x [Variant v], VariantToHMaybied v x, SameLength' x x, HMapAux HList (HFmap HCastF) x x) => p (Variant v) (f (Variant v)) -> p (Record x) (f (Record x))

+ Data.HList.Variant: mkVariant1 :: forall {k} {l :: k} {e}. Label l -> e -> Variant '[Tagged l e]

+ Data.HList.Variant: unvarianted' :: forall {b :: Bool} {t :: [Type]} {a} {f}. (Unvariant1 b t a, HAllEqVal' (Tagged () a : t), HAllEqVal t b, HAllEqVal (Tagged () a : t) b, SameLabels t t, SameLength' t t, Functor f) => (a -> f a) -> Variant t -> f (Variant t)