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

Methods

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

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

Eq (Variant ([] *))

Methods

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

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

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

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 ([] *))

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

Methods

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

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

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

Show (Variant ([] *))

Methods

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

show :: Variant [*] -> String

showList :: [Variant [*]] -> ShowS

type V = Variant

variantIndex :: Variant a -> Word

Get Variant index

Patterns

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

Make GHC consider l as a representational parameter to make coercions between Variant values unsafe

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

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 xs = (IsMember x xs ~ True, x ~ Index (IndexOf x xs) xs, KnownNat (IndexOf x xs))

Constraint: x member of xs

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

Remove a in l

Equations

Filter a '[] = '[]

Filter a (a ': as) = Filter a as

Filter a (b ': as) = 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 :: [*]) where

Minimal complete definition

alterVariant'

Methods

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

Instances

AlterVariant c ([] *)

Methods

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

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

Methods

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

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

Minimal complete definition

traverseVariant'

Methods

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

Instances

TraverseVariant c ([] *) m

Methods

traverseVariant' :: AlterM c m -> Word -> Any * -> m (Any *)

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

Methods

traverseVariant' :: AlterM c m -> Word -> Any * -> m (Any *)

class NoConstraint a

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

Instances

NoConstraint a

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, VariantLift 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

Conversions to/from other data types

variantToValue :: Variant '[a] -> a

Retreive 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 (MapMaybe xs)

Convert a variant into a HList of Maybes

variantToTuple :: forall l t. (VariantToHList l, HTuple' (MapMaybe 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 ([] *)))))))))))))

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 ([] *))))))))))))

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 ([] *)))))))))))

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 ([] *))))))))))

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 ([] *)))))))))

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 ([] *))))))))

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 ([] *)))))))

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 ([] *))))))

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 ([] *)))))

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 ([] *))))

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 ([] *)))

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 ([] *))

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) [*]))