| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Haskus.Utils.Variant
Description
Typed Variant type (union)
- data Variant l
- variantIndex :: Variant a -> Word
- getVariantN :: forall n l. KnownNat n => Variant l -> Maybe (Index n l)
- setVariantN :: forall n l. KnownNat n => Index n l -> Variant l
- updateVariantN :: forall n a b l. (KnownNat n, a ~ Index n l) => (a -> b) -> Variant l -> Variant (ReplaceN n b l)
- setVariant :: forall a l. Member a l => a -> Variant l
- getVariant :: forall a l. Member a l => Variant l -> Maybe a
- updateVariant :: forall a b n l. (Member a l, n ~ IndexOf a l) => (a -> b) -> Variant l -> Variant (ReplaceN n b l)
- updateVariantM :: forall n l l2 m. (KnownNat n, Monad m) => (Index n l -> m (Index n l2)) -> Variant l -> m (Variant l2)
- updateVariantFold :: forall a n l l2. (KnownNat n, KnownNat (Length l2), n ~ IndexOf a l, a ~ Index n l) => (a -> Variant l2) -> Variant l -> Variant (ReplaceAt n l l2)
- updateVariantFoldN :: forall n l l2. (KnownNat n, KnownNat (Length l2)) => (Index n l -> Variant l2) -> Variant l -> Variant (ReplaceAt n l l2)
- updateVariantFoldM :: forall n m l l2. (KnownNat n, KnownNat (Length l2), Monad m) => (Index n l -> m (Variant l2)) -> Variant l -> m (Variant (ReplaceAt n l l2))
- variantToHList :: VariantToHList xs => Variant xs -> HList (MapMaybe xs)
- variantToTuple :: forall l t. (VariantToHList l, HTuple' (MapMaybe l) t) => Variant l -> t
- liftEither :: Either a b -> Variant '[b, a]
- liftEitherM :: Monad m => m (Either a b) -> m (Variant '[b, a])
- variantRemoveType :: VariantRemoveType a xs => Variant xs -> Either (Variant (Filter a xs)) a
- type Member x xs = (IsMember x xs ~ True, x ~ Index (IndexOf x xs) xs, KnownNat (IndexOf x xs))
- type Catchable a xs = (IsMember a xs ~ True, VariantRemoveType a xs)
- type MaybeCatchable a xs = VariantRemoveType a xs
- type Liftable xs ys = (IsSubset xs ys ~ True, VariantLift xs ys)
- catchVariant :: forall a xs. Catchable a xs => Variant xs -> Either (Variant (Filter a xs)) a
- catchVariantMaybe :: forall a xs. MaybeCatchable a xs => Variant xs -> Either (Variant (Filter a xs)) a
- pickVariant :: forall n l. KnownNat n => Variant l -> Either (Variant (RemoveAt n l)) (Index n l)
- headVariant :: forall x xs. Variant (x ': xs) -> Either (Variant xs) x
- singleVariant :: Variant '[a] -> a
- appendVariant :: forall ys xs. Variant xs -> Variant (Concat xs ys)
- prependVariant :: forall ys xs. KnownNat (Length ys) => Variant xs -> Variant (Concat ys xs)
- liftVariant :: forall xs ys. Liftable xs ys => Variant xs -> Variant ys
- liftVariantM :: (Liftable xs ys, Monad m) => Variant xs -> m (Variant ys)
- toEither :: forall a b. Variant '[a, b] -> Either b a
- class ContVariant xs where
Documentation
A variant contains a value whose type is at the given position in the type list
variantIndex :: Variant a -> Word Source #
Make GHC consider l as a representational parameter to make coercions
between Variant values unsafe
Get Variant index
getVariantN :: forall n l. KnownNat n => Variant l -> Maybe (Index n l) Source #
Get the value if it has the indexed type
setVariantN :: forall n l. KnownNat n => Index n l -> Variant l Source #
Set the value with the given indexed type
updateVariantN :: forall n a b l. (KnownNat n, a ~ Index n l) => (a -> b) -> Variant l -> Variant (ReplaceN n b l) Source #
Update a variant value
setVariant :: forall a l. Member a l => a -> Variant l Source #
Set the first matching type of a Variant
getVariant :: forall a l. Member a l => Variant l -> Maybe a Source #
Set the first matching type of a Variant
updateVariant :: forall a b n l. (Member a l, n ~ IndexOf a l) => (a -> b) -> Variant l -> Variant (ReplaceN n b l) Source #
Update a variant value
updateVariantM :: forall n l l2 m. (KnownNat n, Monad m) => (Index n l -> m (Index n l2)) -> Variant l -> m (Variant l2) Source #
Update a variant value in a Monad
updateVariantFold :: forall a n l l2. (KnownNat n, KnownNat (Length l2), n ~ IndexOf a l, a ~ Index n l) => (a -> Variant l2) -> Variant l -> Variant (ReplaceAt n l l2) Source #
Update a variant value with a variant and fold the result
updateVariantFoldN :: forall n l l2. (KnownNat n, KnownNat (Length l2)) => (Index n l -> Variant l2) -> Variant l -> Variant (ReplaceAt n l l2) Source #
Update a variant value with a variant and fold the result
updateVariantFoldM :: forall n m l l2. (KnownNat n, KnownNat (Length l2), Monad m) => (Index n l -> m (Variant l2)) -> Variant l -> m (Variant (ReplaceAt n l l2)) Source #
Update a variant value with a variant and fold the result
variantToHList :: VariantToHList xs => Variant xs -> HList (MapMaybe xs) Source #
Convert a variant into a HList of Maybes
variantToTuple :: forall l t. (VariantToHList l, HTuple' (MapMaybe l) t) => Variant l -> t Source #
Get variant possible values in a tuple of Maybe types
liftEither :: Either a b -> Variant '[b, a] Source #
Lift an Either into a Variant (reversed order by convention)
liftEitherM :: Monad m => m (Either a b) -> m (Variant '[b, a]) Source #
Lift an Either into a Variant (reversed order by convention)
variantRemoveType :: VariantRemoveType a xs => Variant xs -> Either (Variant (Filter a xs)) a Source #
Remove a type from a variant
type Member x xs = (IsMember x xs ~ True, x ~ Index (IndexOf x xs) xs, KnownNat (IndexOf x xs)) Source #
Constraint: x member of xs
type MaybeCatchable a xs = VariantRemoveType a xs Source #
a may be catchable in xs
catchVariant :: forall a xs. Catchable a xs => Variant xs -> Either (Variant (Filter a xs)) a Source #
Extract a type from a variant. Return either the value of this type or the remaining variant
catchVariantMaybe :: forall a xs. MaybeCatchable a xs => Variant xs -> Either (Variant (Filter a xs)) a Source #
Extract a type from a variant. Return either the value of this type or the remaining variant
pickVariant :: forall n l. KnownNat n => Variant l -> Either (Variant (RemoveAt n l)) (Index n l) Source #
Pick a variant value
headVariant :: forall x xs. Variant (x ': xs) -> Either (Variant xs) x Source #
Pick the head of a variant value
singleVariant :: Variant '[a] -> a Source #
Retreive the last v
appendVariant :: forall ys xs. Variant xs -> Variant (Concat xs ys) Source #
Extend a variant by appending other possible values
prependVariant :: forall ys xs. KnownNat (Length ys) => Variant xs -> Variant (Concat ys xs) Source #
Extend a variant by prepending other possible values
liftVariant :: forall xs ys. Liftable xs ys => Variant xs -> Variant ys Source #
Lift a variant into another
Set values to the first matching type
toEither :: forall a b. Variant '[a, b] -> Either b a Source #
Convert a variant of two values in a Either
class ContVariant xs where Source #
Minimal complete definition
variantToCont, variantToContM, contToVariant, contToVariantM
Methods
variantToCont :: Variant xs -> ContFlow xs r Source #
Convert a variant into a multi-continuation
variantToContM :: Monad m => m (Variant xs) -> ContFlow xs (m r) Source #
Convert a variant into a multi-continuation
contToVariant :: ContFlow xs (Variant xs) -> Variant xs Source #
Convert a multi-continuation into a Variant
contToVariantM :: Monad m => ContFlow xs (m (Variant xs)) -> m (Variant xs) Source #
Convert a multi-continuation into a Variant
Instances
| ContVariant ((:) * a ((:) * b ((:) * c ((:) * d ((:) * e ((:) * f ((:) * g ((:) * h ((:) * i ((:) * j ((:) * k ((:) * l ([] *))))))))))))) Source # | |
| ContVariant ((:) * a ((:) * b ((:) * c ((:) * d ((:) * e ((:) * f ((:) * g ((:) * h ((:) * i ((:) * j ((:) * k ([] *)))))))))))) Source # | |
| ContVariant ((:) * a ((:) * b ((:) * c ((:) * d ((:) * e ((:) * f ((:) * g ((:) * h ((:) * i ((:) * j ([] *))))))))))) Source # | |
| ContVariant ((:) * a ((:) * b ((:) * c ((:) * d ((:) * e ((:) * f ((:) * g ((:) * h ((:) * i ([] *)))))))))) Source # | |
| ContVariant ((:) * a ((:) * b ((:) * c ((:) * d ((:) * e ((:) * f ((:) * g ((:) * h ([] *))))))))) Source # | |
| ContVariant ((:) * a ((:) * b ((:) * c ((:) * d ((:) * e ((:) * f ((:) * g ([] *)))))))) Source # | |
| ContVariant ((:) * a ((:) * b ((:) * c ((:) * d ((:) * e ((:) * f ([] *))))))) Source # | |
| ContVariant ((:) * a ((:) * b ((:) * c ((:) * d ((:) * e ([] *)))))) Source # | |
| ContVariant ((:) * a ((:) * b ((:) * c ((:) * d ([] *))))) Source # | |
| ContVariant ((:) * a ((:) * b ((:) * c ([] *)))) Source # | |
| ContVariant ((:) * a ((:) * b ([] *))) Source # | |
| ContVariant ((:) * a ([] *)) Source # | |