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 Source #
Methods typeIndexed :: (TypeIndexedCxt s t a b, Profunctor p, Functor f) => p (TIC (TagR a)) (f (TIC (TagR b))) -> p (Variant s) (f (Variant t)) Source #
HMapAux Variant f xs ys => HMapAux TIC f xs ys Source #
Methods hMapAux :: f -> TIC xs -> TIC ys Source #
(TICPrism s t a b, (~) * (Label k x) (Label * a), (~) * a b, (~) [] s t, SameLength * s t) => Labelable k x TIC s t a b Source #	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 Note: `x :: k` according to the instance head, but the instance body forces the kind variable to be * later on. IE. (k ~ *)
Associated Types type LabelableTy (s :: [] -> ) :: LabeledOpticType Source # Methods hLens' :: Label x TIC -> LabeledOptic x TIC s t a b b Source #
(HasField * o (TIC l) mo, (~) * mo (Maybe o)) => HOccurs mo (TIC l) Source #
Methods hOccurs :: TIC l -> mo Source #
((~) * me (Maybe e), HOccursNot * (Tagged * e e) l) => HExtend me (TIC l) Source #	Nothing .. x = x Just a .. y = mkTIC a
Associated Types type HExtendR me (TIC l) :: * Source # Methods (.*.) :: me -> TIC l -> HExtendR me (TIC l) Source #
Bounded (Variant l) => Bounded (TIC l) Source #
Methods minBound :: TIC l # maxBound :: TIC l #
Enum (Variant l) => Enum (TIC l) Source #
Methods succ :: TIC l -> TIC l # pred :: TIC l -> TIC l # toEnum :: Int -> TIC l # fromEnum :: TIC l -> Int # enumFrom :: TIC l -> [TIC l] # enumFromThen :: TIC l -> TIC l -> [TIC l] # enumFromTo :: TIC l -> TIC l -> [TIC l] # enumFromThenTo :: TIC l -> TIC l -> TIC l -> [TIC l] #
Eq (Variant l) => Eq (TIC l) Source #
Methods (==) :: TIC l -> TIC l -> Bool # (/=) :: TIC l -> TIC l -> Bool #
Ord (Variant l) => Ord (TIC l) Source #
Methods compare :: TIC l -> TIC l -> Ordering # (<) :: TIC l -> TIC l -> Bool # (<=) :: TIC l -> TIC l -> Bool # (>) :: TIC l -> TIC l -> Bool # (>=) :: TIC l -> TIC l -> Bool # max :: TIC l -> TIC l -> TIC l # min :: TIC l -> TIC l -> TIC l #
(ReadVariant l, HAllTaggedEq l, HRLabelSet l) => Read (TIC l) Source #
Methods readsPrec :: Int -> ReadS (TIC l) # readList :: ReadS [TIC l] # readPrec :: ReadPrec (TIC l) # readListPrec :: ReadPrec [TIC l] #
ShowVariant l => Show (TIC l) Source #	TICs are not opaque
Methods showsPrec :: Int -> TIC l -> ShowS # show :: TIC l -> String # showList :: [TIC l] -> ShowS #
Ix (Variant l) => Ix (TIC l) Source #
Methods range :: (TIC l, TIC l) -> [TIC l] # index :: (TIC l, TIC l) -> TIC l -> Int # unsafeIndex :: (TIC l, TIC l) -> TIC l -> Int inRange :: (TIC l, TIC l) -> TIC l -> Bool # rangeSize :: (TIC l, TIC l) -> Int # unsafeRangeSize :: (TIC l, TIC l) -> Int
Semigroup (Variant l) => Semigroup (TIC l) Source #
Methods (<>) :: TIC l -> TIC l -> TIC l # sconcat :: NonEmpty (TIC l) -> TIC l # stimes :: Integral b => b -> TIC l -> TIC l #
Monoid (Variant l) => Monoid (TIC l) Source #
Methods mempty :: TIC l # mappend :: TIC l -> TIC l -> TIC l # mconcat :: [TIC l] -> TIC l #
HasField * o (Variant l) (Maybe o) => HasField * o (TIC l) (Maybe o) Source #	Public destructor (or, open union's projection function)
Methods hLookupByLabel :: Label o (TIC l) -> Maybe o -> v Source #
type LabelableTy TIC Source #
type LabelableTy TIC = LabelablePrism
type HExtendR me (TIC l) Source #
type HExtendR me (TIC l) = TIC ((:) * (Tagged * (UnMaybe me) (UnMaybe me)) l)

ticVariant :: (Functor f, Profunctor p) => p (Variant l1) (f (Variant l2)) -> p (TIC l1) (f (TIC l2)) Source #

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

typeIndexed may be more appropriate

ticVariant' :: (Profunctor p, Functor f) => p (Variant l) (f (Variant l)) -> p (TIC l) (f (TIC l)) 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'

Minimal complete definition

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 Source #
Methods typeIndexed :: (TypeIndexedCxt s t a b, Profunctor p, Functor f) => p (TIP (TagR a)) (f (TIP (TagR b))) -> p (Record s) (f (Record t)) Source #
TypeIndexed Variant TIC Source #
Methods typeIndexed :: (TypeIndexedCxt s t a b, Profunctor p, Functor f) => p (TIC (TagR a)) (f (TIC (TagR b))) -> p (Variant s) (f (Variant t)) Source #

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' :: ((~#) [*] [*] (RecordValuesR (TagR b)) b, Functor f, Profunctor p, TagUntagFD b (TagR b), HLabelSet [*] (LabelsOf (TagR b)), HAllTaggedLV (TagR b), SameLength' * * b b, SameLength' * * (TagR b) (TagR b), SameLabels [*] [*] (TagR b) (TagR b), RecordValues (TagR b), HMapAux HList TaggedFn b (TagR b), TypeIndexed r tr) => p (tr (TagR b)) (f (tr (TagR b))) -> p (r (TagR b)) (f (r (TagR b))) 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), HAllTaggedLV l, KnownNat (HNat2Nat n), HasField * i (Record l) i, HFind1 * i (UnLabel * i (LabelsOf l)) (UnLabel * i (LabelsOf l)) 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

Minimal complete definition

ticPrism

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 Source #
Methods ticPrism :: (SameLength * * s t, Choice p, Applicative f) => p a (f b) -> p (TIC s) (f (TIC t)) Source #

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