Haskus.Utils.Variant

Open sum type

Documentation

data Variant (l :: [*])

A variant contains a value whose type is at the given position in the type list

Instances

(Eq (Variant xs), Eq x) => Eq (Variant (x ': xs))

Defined in Haskus.Utils.Variant

Methods

(==) :: Variant (x ': xs) -> Variant (x ': xs) -> Bool

(/=) :: Variant (x ': xs) -> Variant (x ': xs) -> Bool

Eq (Variant ([] :: [*]))

Defined in Haskus.Utils.Variant

Methods

(==) :: Variant [] -> Variant [] -> Bool

(/=) :: Variant [] -> Variant [] -> Bool

(Ord (Variant xs), Ord x) => Ord (Variant (x ': xs))

Defined in Haskus.Utils.Variant

Methods

compare :: Variant (x ': xs) -> Variant (x ': xs) -> Ordering

(<) :: Variant (x ': xs) -> Variant (x ': xs) -> Bool

(<=) :: Variant (x ': xs) -> Variant (x ': xs) -> Bool

(>) :: Variant (x ': xs) -> Variant (x ': xs) -> Bool

(>=) :: Variant (x ': xs) -> Variant (x ': xs) -> Bool

max :: Variant (x ': xs) -> Variant (x ': xs) -> Variant (x ': xs)

min :: Variant (x ': xs) -> Variant (x ': xs) -> Variant (x ': xs)

Ord (Variant ([] :: [*]))

Defined in Haskus.Utils.Variant

Methods

compare :: Variant [] -> Variant [] -> Ordering

(<) :: Variant [] -> Variant [] -> Bool

(<=) :: Variant [] -> Variant [] -> Bool

(>) :: Variant [] -> Variant [] -> Bool

(>=) :: Variant [] -> Variant [] -> Bool

max :: Variant [] -> Variant [] -> Variant []

min :: Variant [] -> Variant [] -> Variant []

(Show (Variant xs), Show x) => Show (Variant (x ': xs))

Defined in Haskus.Utils.Variant

Methods

showsPrec :: Int -> Variant (x ': xs) -> ShowS

show :: Variant (x ': xs) -> String

showList :: [Variant (x ': xs)] -> ShowS

Show (Variant ([] :: [*]))

Defined in Haskus.Utils.Variant

Methods

showsPrec :: Int -> Variant [] -> ShowS

show :: Variant [] -> String

showList :: [Variant []] -> ShowS

Flattenable (Variant ([] :: [*])) rs

Defined in Haskus.Utils.Variant

Methods

toFlattenVariant :: Word -> Variant [] -> rs

(Flattenable (Variant ys) (Variant rs), KnownNat (Length xs)) => Flattenable (Variant (Variant xs ': ys)) (Variant rs)

Defined in Haskus.Utils.Variant

Methods

toFlattenVariant :: Word -> Variant (Variant xs ': ys) -> Variant rs

type V = Variant

variantIndex :: Variant a -> Word

Get Variant index

Patterns

pattern V :: forall c cs. Popable c cs => c -> Variant cs

Pattern synonym for Variant

Usage: case v of V (x :: Int) -> ... V (x :: String) -> ...

pattern VMaybe :: forall c cs. MaybePopable c cs => c -> Variant cs

Statically unchecked matching on a Variant

type (:<) a xs = Popable a xs

type (:<?) a xs = MaybePopable a xs

Operations by index

toVariantAt :: forall (n :: Nat) (l :: [*]). KnownNat n => Index n l -> Variant l

Set the value with the given indexed type

toVariantHead :: forall x xs. x -> Variant (x ': xs)

Set the first value

toVariantTail :: forall x xs. Variant xs -> Variant (x ': xs)

Set the tail

fromVariantAt :: forall (n :: Nat) (l :: [*]). KnownNat n => Variant l -> Maybe (Index n l)

Get the value if it has the indexed type

popVariantAt :: forall (n :: Nat) l. KnownNat n => Variant l -> Either (Variant (RemoveAt n l)) (Index n l)

Pop a variant value by index, return either the value or the remaining variant

popVariantHead :: forall x xs. Variant (x ': xs) -> Either (Variant xs) x

Pop the head of a variant value

updateVariantAt :: forall (n :: Nat) a b l. (KnownNat n, a ~ Index n l) => (a -> b) -> Variant l -> Variant (ReplaceN n b l)

Update a variant value

foldMapVariantAt :: forall (n :: Nat) l l2. (KnownNat n, KnownNat (Length l2)) => (Index n l -> Variant l2) -> Variant l -> Variant (ReplaceAt n l l2)

Update a variant value with a variant and fold the result

foldMapVariantAtM :: forall (n :: Nat) m l l2. (KnownNat n, KnownNat (Length l2), Monad m) => (Index n l -> m (Variant l2)) -> Variant l -> m (Variant (ReplaceAt n l l2))

Update a variant value with a variant and fold the result

Operations by type

toVariant :: forall a l. Member a l => a -> Variant l

Put a value into a Variant

Use the first matching type index.

type Member (x :: k) (xs :: [k]) = (IsMember x xs ~ True, x ~ Index (IndexOf x xs) xs, KnownNat (IndexOf x xs))

Constraint: x member of xs

type family Filter (a :: k) (l :: [k]) :: [k] where ...

Remove a in l

Equations

Filter (a :: k) ([] :: [k]) = ([] :: [k])

Filter (a :: k) (a ': as :: [k]) = Filter a as

Filter (a :: k) (b ': as :: [k]) = b ': Filter a as

type Popable a xs = (Member a xs, PopVariant a xs)

a is popable in xs

type MaybePopable a xs = PopVariant a xs

a may be popable in xs

popVariant :: forall a xs. Popable a xs => Variant xs -> Either (Variant (Filter a xs)) a

Extract a type from a variant. Return either the value of this type or the remaining variant

popVariantMaybe :: forall a xs. MaybePopable a xs => Variant xs -> Either (Variant (Filter a xs)) a

Extract a type from a variant. Return either the value of this type or the remaining variant

fromVariant :: forall a xs. Popable a xs => Variant xs -> Maybe a

Try to a get a value of a given type from a Variant

fromVariantMaybe :: forall a xs. MaybePopable a xs => Variant xs -> Maybe a

Try to a get a value of a given type from a Variant that may not even support the given type.

fromVariantFirst :: forall a l. Member a l => Variant l -> Maybe a

Pick the first matching type of a Variant

fromVariantFirst @A (Variant 2 undefined :: Variant '[A,B,A]) == Nothing

updateVariantFirst :: forall a b n l. (Member a l, n ~ IndexOf a l) => (a -> b) -> Variant l -> Variant (ReplaceN n b l)

Update a variant value

updateVariantFirstM :: forall (n :: Nat) l l2 m. (KnownNat n, Monad m) => (Index n l -> m (Index n l2)) -> Variant l -> m (Variant l2)

Monadic update of the first matching variant value

type MappableVariant a b cs = MapVariant a b cs (IndexesOf a cs)

mapVariant :: forall a b cs. MappableVariant a b cs => (a -> b) -> Variant cs -> Variant (ReplaceNS (IndexesOf a cs) b cs)

Map the matching types of a variant

foldMapVariantFirst :: forall a (n :: Nat) 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)

Update a variant value with a variant and fold the result

foldMapVariantFirstM :: forall a (n :: Nat) l l2 m. (KnownNat n, KnownNat (Length l2), n ~ IndexOf a l, a ~ Index n l, Monad m) => (a -> m (V l2)) -> V l -> m (V (ReplaceAt n l l2))

Update a variant value with a variant and fold the result

foldMapVariant :: forall a cs ds i. (i ~ IndexOf a cs, Popable a cs) => (a -> V ds) -> V cs -> V (InsertAt i (Filter a cs) ds)

Update a variant value with a variant and fold the result

Generic operations with type classes

class AlterVariant c (b :: [*])

Minimal complete definition

alterVariant'

Instances

AlterVariant c ([] :: [*])

Defined in Haskus.Utils.Variant

Methods

alterVariant' :: Alter c -> Word -> Any -> Any

(AlterVariant c xs, c x) => AlterVariant c (x ': xs)

Defined in Haskus.Utils.Variant

Methods

alterVariant' :: Alter c -> Word -> Any -> Any

class TraverseVariant c (b :: [*]) m

Minimal complete definition

traverseVariant'

Instances

TraverseVariant c ([] :: [*]) m

Defined in Haskus.Utils.Variant

Methods

traverseVariant' :: AlterM c m -> Word -> Any -> m Any

(TraverseVariant c xs m, c x, Monad m) => TraverseVariant c (x ': xs) m

Defined in Haskus.Utils.Variant

Methods

traverseVariant' :: AlterM c m -> Word -> Any -> m Any

class NoConstraint a

Useful to specify a "* -> Constraint" function returning no constraint

Instances

NoConstraint a

Defined in Haskus.Utils.Variant

alterVariant :: forall c (a :: [*]). AlterVariant c a => (forall x. c x => x -> x) -> Variant a -> Variant a

Alter a variant. You need to specify the constraints required by the modifying function.

Usage: alterVariant NoConstraint id v alterVariant Resizable (resize 4) v

class (Ord a, Num a) => OrdNum a instance (Ord a, Num a) => OrdNum a

traverseVariant :: forall c (a :: [*]) m. (TraverseVariant c a m, Monad m) => (forall x. c x => x -> m x) -> Variant a -> m (Variant a)

Traverse a variant. You need to specify the constraints required by the modifying function.

traverseVariant_ :: forall c (a :: [*]) m. (TraverseVariant c a m, Monad m) => (forall x. c x => x -> m ()) -> Variant a -> m ()

Traverse a variant. You need to specify the constraints required by the modifying function.

Conversions between variants

appendVariant :: forall (ys :: [*]) (xs :: [*]). Variant xs -> Variant (Concat xs ys)

Extend a variant by appending other possible values

prependVariant :: forall (ys :: [*]) (xs :: [*]). KnownNat (Length ys) => Variant xs -> Variant (Concat ys xs)

Extend a variant by prepending other possible values

type Liftable xs ys = (IsSubset xs ys ~ True, LiftVariant xs ys)

xs is liftable in ys

liftVariant :: forall xs ys. Liftable xs ys => Variant xs -> Variant ys

Lift a variant into another

Set values to the first matching type

nubVariant :: Liftable xs (Nub xs) => V xs -> V (Nub xs)

Nub the type list

productVariant :: forall xs ys. KnownNat (Length ys) => Variant xs -> Variant ys -> Variant (Product xs ys)

Product of two variants

class Flattenable a rs

Minimal complete definition

toFlattenVariant

Instances

Flattenable (Variant ([] :: [*])) rs

Defined in Haskus.Utils.Variant

Methods

toFlattenVariant :: Word -> Variant [] -> rs

(Flattenable (Variant ys) (Variant rs), KnownNat (Length xs)) => Flattenable (Variant (Variant xs ': ys)) (Variant rs)

Defined in Haskus.Utils.Variant

Methods

toFlattenVariant :: Word -> Variant (Variant xs ': ys) -> Variant rs

type family FlattenVariant (xs :: [*]) :: [*] where ...

Equations

FlattenVariant '[] = '[]

FlattenVariant (Variant xs ': ys) = Concat xs (FlattenVariant ys)

FlattenVariant (y ': ys) = y ': FlattenVariant ys

flattenVariant :: forall xs. Flattenable (Variant xs) (Variant (FlattenVariant xs)) => Variant xs -> Variant (FlattenVariant xs)

Flatten variants in a variant

type family ExtractMonad m f where ...

Equations

ExtractMonad m '[m x] = '[x]

ExtractMonad m (m x ': xs) = x ': ExtractMonad m xs

joinVariant :: forall m xs ys. (Applicative m, ys ~ ExtractMonad m xs) => Variant xs -> m (Variant ys)

Join on a variant

Transform a variant of applicatives as follow: V'[m a, m b, m c] ===> m (V'[a,b,c])

Conversions to/from other data types

variantToValue :: Variant '[a] -> a

Retrieve a single value

variantFromValue :: a -> Variant '[a]

Create a variant from a single value

variantToEither :: forall a b. Variant '[a, b] -> Either b a

Convert a variant of two values in a Either

variantFromEither :: Either a b -> Variant '[b, a]

Lift an Either into a Variant (reversed order by convention)

variantToHList :: VariantToHList xs => Variant xs -> HList (Map Maybe xs)

Convert a variant into a HList of Maybes

variantToTuple :: forall l t. (VariantToHList l, HTuple' (Map Maybe l) t) => Variant l -> t

Get variant possible values in a tuple of Maybe types

Continuations

class ContVariant xs where

Minimal complete definition

variantToCont, variantToContM, contToVariant, contToVariantM

Methods

variantToCont :: Variant xs -> ContFlow xs r

Convert a variant into a multi-continuation

variantToContM :: Monad m => m (Variant xs) -> ContFlow xs (m r)

Convert a variant into a multi-continuation

contToVariant :: ContFlow xs (Variant xs) -> Variant xs

Convert a multi-continuation into a Variant

contToVariantM :: Monad m => ContFlow xs (m (Variant xs)) -> m (Variant xs)

Convert a multi-continuation into a Variant

Instances

ContVariant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': ([] :: [*])))))))))))))

Defined in Haskus.Utils.Variant

Methods

variantToCont :: Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': [])))))))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': [])))))))))))) r

variantToContM :: Monad m => m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': []))))))))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': [])))))))))))) (m r)

contToVariant :: ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': [])))))))))))) (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': []))))))))))))) -> Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': []))))))))))))

contToVariantM :: Monad m => ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': [])))))))))))) (m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': [])))))))))))))) -> m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': [])))))))))))))

ContVariant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': ([] :: [*]))))))))))))

Defined in Haskus.Utils.Variant

Methods

variantToCont :: Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': []))))))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': []))))))))))) r

variantToContM :: Monad m => m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': [])))))))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': []))))))))))) (m r)

contToVariant :: ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': []))))))))))) (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': [])))))))))))) -> Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': [])))))))))))

contToVariantM :: Monad m => ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': []))))))))))) (m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': []))))))))))))) -> m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': []))))))))))))

ContVariant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': ([] :: [*])))))))))))

Defined in Haskus.Utils.Variant

Methods

variantToCont :: Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': [])))))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': [])))))))))) r

variantToContM :: Monad m => m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': []))))))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': [])))))))))) (m r)

contToVariant :: ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': [])))))))))) (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': []))))))))))) -> Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': []))))))))))

contToVariantM :: Monad m => ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': [])))))))))) (m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': [])))))))))))) -> m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': [])))))))))))

ContVariant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': ([] :: [*]))))))))))

Defined in Haskus.Utils.Variant

Methods

variantToCont :: Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': []))))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': []))))))))) r

variantToContM :: Monad m => m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': [])))))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': []))))))))) (m r)

contToVariant :: ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': []))))))))) (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': [])))))))))) -> Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': [])))))))))

contToVariantM :: Monad m => ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': []))))))))) (m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': []))))))))))) -> m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': []))))))))))

ContVariant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': ([] :: [*])))))))))

Defined in Haskus.Utils.Variant

Methods

variantToCont :: Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': [])))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': [])))))))) r

variantToContM :: Monad m => m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': []))))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': [])))))))) (m r)

contToVariant :: ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': [])))))))) (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': []))))))))) -> Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': []))))))))

contToVariantM :: Monad m => ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': [])))))))) (m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': [])))))))))) -> m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': [])))))))))

ContVariant (a ': (b ': (c ': (d ': (e ': (f ': (g ': ([] :: [*]))))))))

Defined in Haskus.Utils.Variant

Methods

variantToCont :: Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': []))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': []))))))) r

variantToContM :: Monad m => m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': [])))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': []))))))) (m r)

contToVariant :: ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': []))))))) (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': [])))))))) -> Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': [])))))))

contToVariantM :: Monad m => ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': []))))))) (m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': []))))))))) -> m (Variant (a ': (b ': (c ': (d ': (e ': (f ': (g ': []))))))))

ContVariant (a ': (b ': (c ': (d ': (e ': (f ': ([] :: [*])))))))

Defined in Haskus.Utils.Variant

Methods

variantToCont :: Variant (a ': (b ': (c ': (d ': (e ': (f ': [])))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': [])))))) r

variantToContM :: Monad m => m (Variant (a ': (b ': (c ': (d ': (e ': (f ': []))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': [])))))) (m r)

contToVariant :: ContFlow (a ': (b ': (c ': (d ': (e ': (f ': [])))))) (Variant (a ': (b ': (c ': (d ': (e ': (f ': []))))))) -> Variant (a ': (b ': (c ': (d ': (e ': (f ': []))))))

contToVariantM :: Monad m => ContFlow (a ': (b ': (c ': (d ': (e ': (f ': [])))))) (m (Variant (a ': (b ': (c ': (d ': (e ': (f ': [])))))))) -> m (Variant (a ': (b ': (c ': (d ': (e ': (f ': [])))))))

ContVariant (a ': (b ': (c ': (d ': (e ': ([] :: [*]))))))

Defined in Haskus.Utils.Variant

Methods

variantToCont :: Variant (a ': (b ': (c ': (d ': (e ': []))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': []))))) r

variantToContM :: Monad m => m (Variant (a ': (b ': (c ': (d ': (e ': [])))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': []))))) (m r)

contToVariant :: ContFlow (a ': (b ': (c ': (d ': (e ': []))))) (Variant (a ': (b ': (c ': (d ': (e ': [])))))) -> Variant (a ': (b ': (c ': (d ': (e ': [])))))

contToVariantM :: Monad m => ContFlow (a ': (b ': (c ': (d ': (e ': []))))) (m (Variant (a ': (b ': (c ': (d ': (e ': []))))))) -> m (Variant (a ': (b ': (c ': (d ': (e ': []))))))

ContVariant (a ': (b ': (c ': (d ': ([] :: [*])))))

Defined in Haskus.Utils.Variant

Methods

variantToCont :: Variant (a ': (b ': (c ': (d ': [])))) -> ContFlow (a ': (b ': (c ': (d ': [])))) r

variantToContM :: Monad m => m (Variant (a ': (b ': (c ': (d ': []))))) -> ContFlow (a ': (b ': (c ': (d ': [])))) (m r)

contToVariant :: ContFlow (a ': (b ': (c ': (d ': [])))) (Variant (a ': (b ': (c ': (d ': []))))) -> Variant (a ': (b ': (c ': (d ': []))))

contToVariantM :: Monad m => ContFlow (a ': (b ': (c ': (d ': [])))) (m (Variant (a ': (b ': (c ': (d ': [])))))) -> m (Variant (a ': (b ': (c ': (d ': [])))))

ContVariant (a ': (b ': (c ': ([] :: [*]))))

Defined in Haskus.Utils.Variant

Methods

variantToCont :: Variant (a ': (b ': (c ': []))) -> ContFlow (a ': (b ': (c ': []))) r

variantToContM :: Monad m => m (Variant (a ': (b ': (c ': [])))) -> ContFlow (a ': (b ': (c ': []))) (m r)

contToVariant :: ContFlow (a ': (b ': (c ': []))) (Variant (a ': (b ': (c ': [])))) -> Variant (a ': (b ': (c ': [])))

contToVariantM :: Monad m => ContFlow (a ': (b ': (c ': []))) (m (Variant (a ': (b ': (c ': []))))) -> m (Variant (a ': (b ': (c ': []))))

ContVariant (a ': (b ': ([] :: [*])))

Defined in Haskus.Utils.Variant

Methods

variantToCont :: Variant (a ': (b ': [])) -> ContFlow (a ': (b ': [])) r

variantToContM :: Monad m => m (Variant (a ': (b ': []))) -> ContFlow (a ': (b ': [])) (m r)

contToVariant :: ContFlow (a ': (b ': [])) (Variant (a ': (b ': []))) -> Variant (a ': (b ': []))

contToVariantM :: Monad m => ContFlow (a ': (b ': [])) (m (Variant (a ': (b ': [])))) -> m (Variant (a ': (b ': [])))

ContVariant (a ': ([] :: [*]))

Defined in Haskus.Utils.Variant

Methods

variantToCont :: Variant (a ': []) -> ContFlow (a ': []) r

variantToContM :: Monad m => m (Variant (a ': [])) -> ContFlow (a ': []) (m r)

contToVariant :: ContFlow (a ': []) (Variant (a ': [])) -> Variant (a ': [])

contToVariantM :: Monad m => ContFlow (a ': []) (m (Variant (a ': []))) -> m (Variant (a ': []))

Internals

pattern V' :: forall c cs. (Member' c cs, PopVariant c cs) => c -> Variant cs

Silent pattern synonym for Variant

Usage: case v of V (x :: Int) -> ... V (x :: String) -> ...

liftVariant' :: LiftVariant xs ys => Variant xs -> Variant ys

fromVariant' :: forall a xs. PopVariant a xs => Variant xs -> Maybe a

Try to a get a value of a given type from a Variant (silent)

popVariant' :: PopVariant a xs => Variant xs -> Either (Variant (Filter a xs)) a

Remove a type from a variant

toVariant' :: forall a l. Member' a l => a -> Variant l

Put a value into a Variant (silent)

Use the first matching type index.

class LiftVariant xs ys

Minimal complete definition

liftVariant'

Instances

LiftVariant ([] :: [*]) ys

Defined in Haskus.Utils.Variant

Methods

liftVariant' :: Variant [] -> Variant ys

(LiftVariant xs ys, KnownNat (IndexOf x ys)) => LiftVariant (x ': xs) ys

Defined in Haskus.Utils.Variant

Methods

liftVariant' :: Variant (x ': xs) -> Variant ys

class PopVariant a xs

Minimal complete definition

popVariant'

Instances

PopVariant a ([] :: [*])

Defined in Haskus.Utils.Variant

Methods

popVariant' :: Variant [] -> Either (Variant (Filter a [])) a

(PopVariant a xs', n ~ MaybeIndexOf a xs, xs' ~ RemoveAt1 n xs, Filter a xs' ~ Filter a xs, KnownNat n, xs ~ (y ': ys)) => PopVariant a (y ': ys)

Defined in Haskus.Utils.Variant

Methods

popVariant' :: Variant (y ': ys) -> Either (Variant (Filter a (y ': ys))) a