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

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

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 x, Show (V xs)) => Show (V (x ': xs))

Show instance

>>> show (V @Int 10  :: V '[Int,String,Double])
"10"

Defined in Haskus.Utils.Variant

Methods

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

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

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

Show (V ([] :: [Type]))

Defined in Haskus.Utils.Variant

Methods

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

show :: V [] -> String

showList :: [V []] -> ShowS

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

Defined in Haskus.Utils.Variant

Methods

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

NFData (V ([] :: [Type]))

Defined in Haskus.Utils.Variant

Methods

rnf :: V [] -> ()

ContVariant xs => MultiCont (V xs)

Defined in Haskus.Utils.Variant

Associated Types

type MultiContTypes (V xs) :: [Type]

Methods

toCont :: V xs -> ContFlow (MultiContTypes (V xs)) r

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

Flattenable (V ([] :: [Type])) 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 MultiContTypes (V xs)

Defined in Haskus.Utils.Variant

type MultiContTypes (V xs) = xs

variantIndex :: V a -> Word

Get Variant index

>>> let x = V "Test" :: V '[Int,String,Double]
>>> variantIndex x
1
>>> let y = toVariantAt @0 10 :: V '[Int,String,Double]
>>> variantIndex y
0

variantSize :: forall xs. KnownNat (Length xs) => V xs -> Word

Get variant size

>>> let x = V "Test" :: V '[Int,String,Double]
>>> variantSize x
3
>>> let y = toVariantAt @0 10 :: V '[Int,String,Double,Int]
>>> variantSize y
4

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 = (CheckMember x xs, Member x xs, x :<? xs)

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

type family xs :<< ys :: Constraint where ...

Forall x in xs, `x :< ys`

Equations

'[] :<< ys = ()

(x ': xs) :<< ys = (x :< ys, xs :<< ys)

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

>>> toVariantAt @1 10 :: V '[Word,Int,Double]
10

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

Set the first value

>>> toVariantHead 10 :: V '[Int,Float,Word]
10

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

Set the tail

>>> let x = V @Int 10 :: V '[Int,String,Float]
>>> let y = toVariantTail @Double x
>>> :t y
y :: V '[Double, Int, String, Float]

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

Try to get a value by index into the type list

>>> let x = V "Test" :: V '[Int,String,Float]
>>> fromVariantAt @0 x
Nothing
>>> fromVariantAt @1 x
Just "Test"
>>> fromVariantAt @2 x
Nothing

fromVariantHead :: V (x ': xs) -> Maybe x

Try to get the first variant value

>>> let x = V "Test" :: V '[Int,String,Float]
>>> fromVariantHead x
Nothing
>>> let y = V @Int 10 :: V '[Int,String,Float]
>>> fromVariantHead y
Just 10

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

>>> let x = V @Word 10 :: V '[Int,Word,Float]
>>> popVariantAt @0 x
Left 10
>>> popVariantAt @1 x
Right 10
>>> popVariantAt @2 x
Left 10

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

Pop the head of a variant value

>>> let x = V @Word 10 :: V '[Int,Word,Float]
>>> popVariantHead x
Left 10

>>> let y = V @Int 10 :: V '[Int,Word,Float]
>>> popVariantHead y
Right 10

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

>>> import Data.Char (toUpper)
>>> let x = V @String "Test" :: V '[Int,String,Float]
>>> mapVariantAt @1 (fmap toUpper) x
"TEST"

>>> mapVariantAt @0 (+1) x
"Test"

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

Example with Maybe:

>>> let f s = if s == "Test" then Just (42 :: Word) else Nothing
>>> let x = V @String "Test" :: V '[Int,String,Float]
>>> mapVariantAtM @1 f x
Just 42

>>> let y = V @String "NotTest" :: V '[Int,String,Float]
>>> mapVariantAtM @1 f y
Nothing

Example with IO:

>>> v <- mapVariantAtM @0 print x

>>> :t v
v :: V '[(), String, Float]

>>> v <- mapVariantAtM @1 print x
"Test"

>>> :t v
v :: V '[Int, (), Float]

>>> v <- mapVariantAtM @2 print x

>>> :t v
v :: V '[Int, [Char], ()]

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

>>> newtype Odd  = Odd Int  deriving (Show)
>>> newtype Even = Even Int deriving (Show)
>>> let f x = if even x then V (Even x) else V (Odd x) :: V '[Odd, Even]
>>> foldMapVariantAt @1 f (V @Int 10 :: V '[Float,Int,Double])
Even 10

>>> foldMapVariantAt @1 f (V @Float 0.5 :: V '[Float,Int,Double])
0.5

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

bindVariant :: forall x xs ys. KnownNat (Length ys) => V (x ': xs) -> (x -> V ys) -> V (Concat ys xs)

Bind (>>=) for a Variant

constBindVariant :: forall xs ys. V xs -> V ys -> V (Concat ys xs)

Const bind (>>) for a Variant

variantHeadTail :: (x -> u) -> (V xs -> u) -> V (x ': xs) -> u

List-like catamorphism

>>> let f = variantHeadTail (\i -> "Found Int: " ++ show i) (const "Something else")
>>> f (V @String "Test" :: V '[Int,String,Float])
"Something else"

>>> f (V @Int 10 :: V '[Int,String,Float])
"Found Int: 10"

mapVariantHeadTail :: (x -> y) -> (V xs -> V ys) -> V (x ': xs) -> V (y ': ys)

Bimap Variant head and tail

>>> let f = mapVariantHeadTail (+5) (appendVariant @'[Double,Char])
>>> f (V @Int 10 :: V '[Int,Word,Float])
15

>>> f (V @Word 20 :: V '[Int,Word,Float])
20

Operations by type

toVariant :: forall a l. a :< l => a -> V l

Put a value into a Variant

Use the first matching type index.

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

Equivalent to pattern V.

>>> let x = toVariantAt @2 10 :: V '[Int,String,Int]
>>> fromVariant @Int x
Just 10
>>> fromVariant @Double x

... error:
... `Double' is not a member of '[Int, String, Int]
...

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.

>>> let x = V @Int 10 :: V '[Int,String,Float]
>>> fromVariantMaybe @Int x
Just 10
>>> fromVariantMaybe @Double x
Nothing

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

Pick the first matching type of a Variant

>>> let x = toVariantAt @2 10 :: V '[Int,String,Int]
>>> fromVariantFirst @Int x
Nothing

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

Update the first matching variant value

>>> let x = toVariantAt @0 10 :: V '[Int,String,Int]
>>> mapVariantFirst @Int (+32) x
42

>>> let y = toVariantAt @2 10 :: V '[Int,String,Int]
>>> mapVariantFirst @Int (+32) y
10

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

Example with Maybe:

>>> let f s = if s == (42 :: Int) then Just "Yeah!" else Nothing
>>> mapVariantFirstM f (toVariantAt @0 42 :: V '[Int,Float,Int])
Just "Yeah!"

>>> mapVariantFirstM f (toVariantAt @2 42 :: V '[Int,Float,Int])
Just 42

>>> mapVariantFirstM f (toVariantAt @0 10 :: V '[Int,Float,Int])
Nothing

>>> mapVariantFirstM f (toVariantAt @2 10 :: V '[Int,Float,Int])
Just 10

Example with IO:

>>> mapVariantFirstM @Int print (toVariantAt @0 42 :: V '[Int,Float,Int])
42
()

>>> mapVariantFirstM @Int print (toVariantAt @2 42 :: V '[Int,Float,Int])
42

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

>>> let add1 = mapVariant @Int (+1)
>>> add1 (toVariantAt @0 10 :: V '[Int,Float,Int,Double])
11

>>> add1 (toVariantAt @2 10 :: V '[Int,Float,Int, Double])
11

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

Map the matching types of a variant and nub the result

>>> let add1 = mapNubVariant @Int (+1)
>>> add1 (toVariantAt @0 10 :: V '[Int,Float,Int,Double])
11

>>> add1 (toVariantAt @2 10 :: V '[Int,Float,Int, Double])
11

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 (Remove a cs) ds)

Update a variant value with a variant and fold the result

>>> newtype Odd  = Odd Int  deriving (Show)
>>> newtype Even = Even Int deriving (Show)
>>> let f x = if even x then V (Even x) else V (Odd x) :: V '[Odd, Even]
>>> foldMapVariant @Int f (V @Int 10 :: V '[Float,Int,Double])
Even 10

>>> foldMapVariant @Int f (V @Float 0.5 :: V '[Float,Int,Double])
0.5

type family Member (x :: k) (xs :: [k]) :: Constraint where ...

Constraint: x member of xs

Equations

Member (x :: k) (xs :: [k]) = MemberAtIndex (IndexOf x xs) x xs

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

Remove a in l

Equations

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

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

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

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

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

Generic operations with type classes

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

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.

reduceVariant :: forall c (a :: [*]) r. ReduceVariant c 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.

>>> let v = V "Yes" :: V '[String,Bool,Char]
>>> reduceVariant @Show show v
"\"Yes\""

>>> let n = V (10 :: Int) :: V '[Int,Word,Integer]
>>> reduceVariant @Integral fromIntegral n :: Int
10

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

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

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

Minimal complete definition

traverseVariant'

Instances

TraverseVariant c ([] :: [Type]) 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

class ReduceVariant c (b :: [*])

Minimal complete definition

reduceVariant'

Instances

ReduceVariant c ([] :: [Type])

Defined in Haskus.Utils.Variant

Methods

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

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

Defined in Haskus.Utils.Variant

Methods

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

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

liftVariant :: forall ys xs. LiftVariant xs ys => V xs -> V ys

Lift a variant into another

Set values to the first matching type

nubVariant :: LiftVariant 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

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

Flatten variants in a variant

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.

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

Split a variant in two

type LiftVariant xs ys = (LiftVariant' xs ys, xs :<< ys)

xs is liftable in ys

class Flattenable a rs

Minimal complete definition

toFlattenVariant

Instances

Flattenable (V ([] :: [Type])) 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

type family ExtractM m f where ...

Equations

ExtractM m '[] = '[]

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

class JoinVariant m xs

Minimal complete definition

joinVariant

Instances

JoinVariant m ([] :: [Type])

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

class SplitVariant as rs xs

Minimal complete definition

splitVariant'

Instances

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

Defined in Haskus.Utils.Variant

Methods

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

(n ~ MaybeIndexOf x as, m ~ MaybeIndexOf 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 rs) (V 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 ~ Tuple (Map Maybe l)) => V l -> t

Get variant possible values in a tuple of Maybe types

Continuations

class ContVariant xs where

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 ': ([] :: [Type])))))))))))))

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 ': ([] :: [Type]))))))))))))

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 ': ([] :: [Type])))))))))))

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 ': ([] :: [Type]))))))))))

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 ': ([] :: [Type])))))))))

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 ': ([] :: [Type]))))))))

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 ': ([] :: [Type])))))))

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 ': ([] :: [Type]))))))

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 ': ([] :: [Type])))))

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 ': ([] :: [Type]))))

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 ': ([] :: [Type])))

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 ': ([] :: [Type]))

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 (Remove 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

xs is liftable in ys

Minimal complete definition

liftVariant'

Instances

LiftVariant' ([] :: [Type]) 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 ([] :: [Type])

Defined in Haskus.Utils.Variant

Methods

popVariant' :: V [] -> Either (V (Remove a [])) a

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

Defined in Haskus.Utils.Variant

Methods

popVariant' :: V (y ': ys) -> Either (V (Remove a (y ': ys))) a

showsVariant :: (Typeable xs, ShowTypeList (V xs), ShowVariantValue (V xs)) => Int -> V xs -> ShowS

Haskell code corresponding to a Variant

>>> showsVariant 0 (V @Double 5.0 :: V '[Int,String,Double]) ""
"V @Double 5.0 :: V '[Int, [Char], Double]"