Data.HList.TIC

The HList library

(C) 2004, Oleg Kiselyov, Ralf Laemmel, Keean Schupke

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

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

Documentation

newtype TIC l

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))

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))

Iso' (TIC s) (Variant s)

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

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))

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)

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))

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'

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]`

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

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

similar to HPrism

Methods

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

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)

Prism' (TIC s) a