Safe Haskell	None
Language	Haskell2010

Data.HList.TIC

Description

The HList library

Type-indexed co-products. The public interface is exposed in CommonMain#TIC

(There are other ways: see ConsUnion.hs, for example)

Synopsis

Documentation

newtype TIC l Source

A datatype for type-indexed co-products. A TIC is just a Variant, where the elements of the type-level list "l" are in the form Tagged x x.

Constructors

TIC (Variant l)

Instances

TypeIndexed Variant TIC
HMapAux Variant f xs ys => HMapAux TIC f xs ys
(TICPrism s t a b, (~) * x a, (~) * a b, (~) [] s t, SameLength * s t) => Labelable * x TIC s t a b	hLens' :: Label a -> Prism' (TIC s) a note that a more general function `ticPrism :: Prism (TIC s) (TIC t) a b`, cannot have an instance of Labelable
HasField * o (Variant l) (Maybe o) => HasField * o (TIC l) (Maybe o)	Public destructor (or, open union's projection function)
(HasField * o (TIC l) mo, (~) * mo (Maybe o)) => HOccurs mo (TIC l)
((~) * me (Maybe e), HOccursNot * (Tagged * e e) l) => HExtend me (TIC l)	Nothing .. x = x Just a .. y = mkTIC a
Bounded (Variant l) => Bounded (TIC l)
Enum (Variant l) => Enum (TIC l)
Eq (Variant l) => Eq (TIC l)
(TypeablePolyK [] xs, Typeable (Variant xs), Data (Variant xs)) => Data (TIC xs)
Ord (Variant l) => Ord (TIC l)
(ReadVariant l, HAllTaggedEq l, HRLabelSet l) => Read (TIC l)
ShowVariant l => Show (TIC l)	TICs are not opaque
Ix (Variant l) => Ix (TIC l)
Monoid (Variant l) => Monoid (TIC l)
Typeable ([] -> ) TIC
type LabelableTy TIC = LabelablePrism
type HExtendR me (TIC l) = TIC ((:) * (Tagged * (UnMaybe me) (UnMaybe me)) l)

ticVariant :: (Profunctor p, Functor f) => p (Variant t) (f (Variant l)) -> p (TIC t) (f (TIC l)) Source

Iso (TIC s) (TIC t) (Variant s) (Variant t)

typeIndexed may be more appropriate

ticVariant' :: (Profunctor p, Functor f) => p (Variant t) (f (Variant t)) -> p (TIC t) (f (TIC t)) Source

Iso' (TIC s) (Variant s)

class TypeIndexed r tr | r -> tr, tr -> r where Source

Conversion between type indexed collections (TIC and TIP) and the corresponding collection that has other label types (Variant and Record respectively)

See typeIndexed'

Methods

typeIndexed :: forall p f s t a b. (TypeIndexedCxt s t a b, Profunctor p, Functor f) => p (tr (TagR a)) (f (tr (TagR b))) -> p (r s) (f (r t)) Source

Iso (r s) (r t) (tr a) (tr b)

Instances

TypeIndexed Record TIP
TypeIndexed Variant TIC

type TypeIndexedCxt s t a b = (HMapCxt HList TaggedFn b t, RecordValues s, RecordValues t, a ~ RecordValuesR s, b ~ RecordValuesR t, SameLabels s t, SameLength s t, SameLength b a, Coercible (TagR b) t, Coercible (TagR a) s, HAllTaggedLV s, HRLabelSet t, TagUntag a, TagUntag b) Source

typeIndexed' :: (TypeIndexed r tr, TagUntagFD (RecordValuesR s) (TagR (RecordValuesR s)), HLabelSet [*] (LabelsOf s), RecordValues s, HMapAux HList TaggedFn (RecordValuesR s) s, SameLength' * * (RecordValuesR s) (RecordValuesR s), SameLength' * * s s, SameLabels [*] [*] s s, HAllTaggedLV s, Profunctor p, Coercible [*] (TagR (RecordValuesR s)) s, Functor f) => p (tr (TagR (RecordValuesR s))) (f (tr (TagR (RecordValuesR s)))) -> p (r s) (f (r s)) Source

Iso' (Variant s) (TIC a)

Iso' (Record s) (TIP a)

where s has a type like '[Tagged "x" Int], and a has a type like '[Tagged Int Int].

mkTIC' Source

Arguments

:: (HTypeIndexed l, MkVariant i i l)
=> i
-> proxy l	the ordering of types in the `l :: [*]` matters. This argument is intended to fix the ordering it can be a Record, Variant, TIP, Proxy
-> TIC l

Public constructor (or, open union's injection function)

mkTIC1 :: forall i. MkVariant i i `[Tagged i i]` => i -> TIC `[Tagged i i]` Source

make a TIC that contains one element

mkTIC :: (HAllTaggedEq l, HLabelSet [*] (LabelsOf l), HasField * i (Record l) i, HFind1 * i (UnLabel * i (LabelsOf l)) n, HAllTaggedLV l, KnownNat (HNat2Nat n)) => i -> TIC l Source

make a TIC for use in contexts where the result type is fixed

class TICPrism s t a b | s a b -> t, t a b -> s where Source

similar to HPrism

Methods

ticPrism :: (SameLength s t, Choice p, Applicative f) => (a `p` f b) -> TIC s `p` f (TIC t) Source

Instances

(MkVariant * b b t, HasField * a (Variant s) (Maybe a), SameLength * * s t, HFindLabel * b t n, HFindLabel * a s n, (~) [*] (HUpdateAtHNatR n (Tagged * b b) s) t, (~) [*] (HUpdateAtHNatR n (Tagged * a a) t) s) => TICPrism s t a b

ticPrism' :: forall s t a b. (HPrism a s t a b, a ~ b, s ~ t) => forall f p. (Applicative f, Choice p) => (a `p` f b) -> TIC s `p` f (TIC t) Source

Prism' (TIC s) a