Haskus.Utils.Variant

Open sum type

Documentation

data V (l :: [*])

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

Constructors

Variant !Word Any

Instances

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

Defined in Haskus.Utils.Variant

Methods

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

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

Eq (V ([] :: [*]))

Defined in Haskus.Utils.Variant

Methods

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

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

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

Defined in Haskus.Utils.Variant

Methods

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

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

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

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

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

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

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

Ord (V ([] :: [*]))

Defined in Haskus.Utils.Variant

Methods

compare :: V [] -> V [] -> Ordering

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

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

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

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

max :: V [] -> V [] -> V []

min :: V [] -> V [] -> V []

(Show (V xs), Show x, Typeable x) => Show (V (x ': xs))

Defined in Haskus.Utils.Variant

Methods

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

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

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

Show (V ([] :: [*]))

Defined in Haskus.Utils.Variant

Methods

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

show :: V [] -> String

showList :: [V []] -> ShowS

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

Defined in Haskus.Utils.Variant

Methods

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

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

Defined in Haskus.Utils.Variant

Methods

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

variantIndex :: V a -> Word

Get Variant index

Patterns

pattern V :: forall c cs. c :< cs => c -> V cs

Pattern synonym for Variant

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

pattern VMaybe :: forall c cs. c :<? cs => c -> V cs

Statically unchecked matching on a Variant

type (:<) x xs = (Member x xs, x :<? xs)

A value of type "x" can be extracted from (V xs)

type (:<?) x xs = PopVariant x xs

A value of type "x" **might** be extracted from (V xs). We don't check that "x" is in "xs".

Operations by index

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

Set the value with the given indexed type

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

Set the first value

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

Set the tail

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

Get the value if it has the indexed type

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

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

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

Pop the head of a variant value

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

Update a single variant value by index

mapVariantAtM :: forall (n :: Nat) a b l m. (KnownNat n, Applicative m, a ~ Index n l) => (a -> m b) -> V l -> m (V (ReplaceN n b l))

Applicative update of a single variant value by index

foldMapVariantAt :: forall (n :: Nat) l l2. (KnownNat n, KnownNat (Length l2)) => (Index n l -> V l2) -> V l -> V (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 (V l2)) -> V l -> m (V (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 -> V 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

popVariant :: forall a xs. a :< xs => V xs -> Either (V (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. a :<? xs => V xs -> Either (V (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. a :< xs => V xs -> Maybe a

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

fromVariantMaybe :: forall a xs. a :<? xs => V 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 => V l -> Maybe a

Pick the first matching type of a Variant

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

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

Update of the first matching variant value

mapVariantFirstM :: forall a b n l m. (Member a l, n ~ IndexOf a l, Applicative m) => (a -> m b) -> V l -> m (V (ReplaceN n b l))

Applicative update of the first matching variant value

type ReplaceAll a b cs = ReplaceNS (IndexesOf a cs) b cs

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

mapVariant :: forall a b cs. MapVariant a b cs => (a -> b) -> V cs -> V (ReplaceAll a b cs)

Map the matching types of a variant

mapNubVariant :: forall a b cs ds rs. (MapVariant a b cs, ds ~ ReplaceNS (IndexesOf a cs) b cs, rs ~ Nub ds, Liftable ds rs) => (a -> b) -> V cs -> V rs

Map the matching types of a variant and nub the result

foldMapVariantFirst :: forall a (n :: Nat) l l2. (KnownNat n, KnownNat (Length l2), n ~ IndexOf a l, a ~ Index n l) => (a -> V l2) -> V l -> V (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, 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 NoConstraint a

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

Instances

NoConstraint a

Defined in Haskus.Utils.Variant

class AlterVariant c (b :: [*])

Minimal complete definition

alterVariant'

Instances

AlterVariant c ([] :: [*])

Defined in Haskus.Utils.Variant

Methods

alterVariant' :: (forall a. c a => a -> a) -> Word -> Any -> Any

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

Defined in Haskus.Utils.Variant

Methods

alterVariant' :: (forall a. c a => a -> a) -> Word -> Any -> Any

alterVariant :: forall c (a :: [*]). AlterVariant c a => (forall x. c x => x -> x) -> V a -> V 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

• - Multiple constraints: class (Ord a, Num a) => OrdNum a instance (Ord a, Num a) => OrdNum a alterVariant @OrdNum foo v

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

Minimal complete definition

traverseVariant'

Instances

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

Defined in Haskus.Utils.Variant

Methods

traverseVariant' :: (forall a. (Monad m, c a) => a -> m a) -> Word -> Any -> m Any

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

Defined in Haskus.Utils.Variant

Methods

traverseVariant' :: (forall a. (Monad m, c a) => a -> m a) -> Word -> Any -> m Any

traverseVariant :: forall c (a :: [*]) m. (TraverseVariant c a m, Monad m) => (forall x. c x => x -> m x) -> V a -> m (V 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 ()) -> V a -> m ()

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

class ReduceVariant c r (b :: [*])

Minimal complete definition

reduceVariant'

Instances

ReduceVariant c r ([] :: [*])

Defined in Haskus.Utils.Variant

Methods

reduceVariant' :: (forall a. c a => a -> r) -> Word -> Any -> r

(ReduceVariant c r xs, c x) => ReduceVariant c r (x ': xs)

Defined in Haskus.Utils.Variant

Methods

reduceVariant' :: (forall a. c a => a -> r) -> Word -> Any -> r

reduceVariant :: forall c r (a :: [*]). ReduceVariant c r a => (forall x. c x => x -> r) -> V a -> r

Reduce a variant to a single value by using a class function. You need to specify the constraints required by the modifying function.

Usage: reduceVariant @Show show v

Conversions between variants

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

Extend a variant by appending other possible values

prependVariant :: forall (ys :: [*]) (xs :: [*]). KnownNat (Length ys) => V xs -> V (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 ys xs. Liftable xs ys => V xs -> V 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) => V xs -> V ys -> V (Product xs ys)

Product of two variants

class Flattenable a rs

Minimal complete definition

toFlattenVariant

Instances

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

Defined in Haskus.Utils.Variant

Methods

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

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

Defined in Haskus.Utils.Variant

Methods

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

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

Equations

FlattenVariant '[] = '[]

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

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

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

Flatten variants in a variant

type family ExtractM m f where ...

Equations

ExtractM m '[] = '[]

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

joinVariant :: JoinVariant m xs => V xs -> m (V (ExtractM m xs))

Join on a variant

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

joinVariantUnsafe :: forall m xs ys. (Functor m, ys ~ ExtractM m xs) => V xs -> m (V ys)

Join on a variant in an unsafe way.

Works with IO for example but not with Maybe.

class JoinVariant m xs

Minimal complete definition

joinVariant

Instances

JoinVariant m ([] :: [*])

Defined in Haskus.Utils.Variant

Methods

joinVariant :: V [] -> m (V (ExtractM m []))

(Functor m, ExtractM m (m a ': xs) ~ (a ': ExtractM m xs), JoinVariant m xs) => JoinVariant m (m a ': xs)

Defined in Haskus.Utils.Variant

Methods

joinVariant :: V (m a ': xs) -> m (V (ExtractM m (m a ': xs)))

splitVariant :: forall as xs. SplitVariant as xs xs => V xs -> Either (V as) (V (Complement xs as))

Split a variant in two

class SplitVariant as rs xs

Minimal complete definition

splitVariant'

Instances

SplitVariant as rs ([] :: [*])

Defined in Haskus.Utils.Variant

Methods

splitVariant' :: V [] -> Either (V as) (V (Complement rs as))

(n ~ MaybeIndexOf x as, m ~ IndexOf x rs, SplitVariant as rs xs, KnownNat m, KnownNat n) => SplitVariant as rs (x ': xs)

Defined in Haskus.Utils.Variant

Methods

splitVariant' :: V (x ': xs) -> Either (V as) (V (Complement rs as))

Conversions to/from other data types

variantToValue :: V '[a] -> a

Retrieve a single value

variantFromValue :: a -> V '[a]

Create a variant from a single value

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

Convert a variant of two values in a Either

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

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

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

Convert a variant into a HList of Maybes

variantToTuple :: forall l t. (VariantToHList l, HTuple' (Map Maybe l) t) => V 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 :: V xs -> ContFlow xs r

Convert a variant into a multi-continuation

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

Convert a variant into a multi-continuation

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

Convert a multi-continuation into a Variant

contToVariantM :: Monad m => ContFlow xs (m (V xs)) -> m (V 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 :: V (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 (V (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 ': [])))))))))))) (V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': []))))))))))))) -> V (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 (V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': (l ': [])))))))))))))) -> m (V (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 :: V (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 (V (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 ': []))))))))))) (V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': [])))))))))))) -> V (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 (V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': (k ': []))))))))))))) -> m (V (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 :: V (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 (V (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 ': [])))))))))) (V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': []))))))))))) -> V (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 (V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': (j ': [])))))))))))) -> m (V (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 :: V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': []))))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': []))))))))) r

variantToContM :: Monad m => m (V (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 ': []))))))))) (V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': [])))))))))) -> V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': [])))))))))

contToVariantM :: Monad m => ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': []))))))))) (m (V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': (i ': []))))))))))) -> m (V (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 :: V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': [])))))))) -> ContFlow (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': [])))))))) r

variantToContM :: Monad m => m (V (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 ': [])))))))) (V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': []))))))))) -> V (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': []))))))))

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

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

Defined in Haskus.Utils.Variant

Methods

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

variantToContM :: Monad m => m (V (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 ': []))))))) (V (a ': (b ': (c ': (d ': (e ': (f ': (g ': [])))))))) -> V (a ': (b ': (c ': (d ': (e ': (f ': (g ': [])))))))

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

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

Defined in Haskus.Utils.Variant

Methods

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

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

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

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

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

Defined in Haskus.Utils.Variant

Methods

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

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

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

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

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

Defined in Haskus.Utils.Variant

Methods

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

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

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

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

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

Defined in Haskus.Utils.Variant

Methods

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

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

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

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

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

Defined in Haskus.Utils.Variant

Methods

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

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

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

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

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

Defined in Haskus.Utils.Variant

Methods

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

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

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

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

Internals

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

Silent pattern synonym for Variant

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

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

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

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

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

Remove a type from a variant

toVariant' :: forall a l. Member' a l => a -> V 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' :: V [] -> V ys

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

Defined in Haskus.Utils.Variant

Methods

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

class PopVariant a xs

Minimal complete definition

popVariant'

Instances

PopVariant a ([] :: [*])

Defined in Haskus.Utils.Variant

Methods

popVariant' :: V [] -> Either (V (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' :: V (y ': ys) -> Either (V (Filter a (y ': ys))) a