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

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

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

Pattern synonym for Variant

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

Statically unchecked matching on a Variant

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

Forall x in xs, `x :< ys`

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

Set the value with the given indexed type

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

Set the first value

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

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]

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

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

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

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

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"

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], ()]

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

Update a variant value with a variant and fold the result

Bind (>>=) for a Variant

Const bind (>>) for a Variant

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"

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

Put a value into a Variant

Use the first matching type index.

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

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

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 not found in list:
... '[Int, String, Int]
...

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

Pick the first matching type of a Variant

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

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

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

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

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

Update a variant value with a variant and fold the result

Update a variant value with a variant and fold the result

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

Constraint: x member of xs

Remove a in l

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

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

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

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

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

Extend a variant by appending other possible values

Extend a variant by prepending other possible values

Lift a variant into another

Set values to the first matching type

Nub the type list

Product of two variants

Flatten variants in a variant

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

Join on a variant in an unsafe way.

Works with IO for example but not with Maybe.

Split a variant in two

xs is liftable in ys

Retrieve a single value

Create a variant from a single value

Convert a variant of two values in a Either

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

Convert a variant into a HList of Maybes

Get variant possible values in a tuple of Maybe types

Silent pattern synonym for Variant

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

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

Remove a type from a variant

Put a value into a Variant (silent)

Use the first matching type index.

xs is liftable in ys

Put a value into a variant if possible

>>> toVariantMaybe "Test" :: Maybe (V '[Int,Float])
Nothing

>>> toVariantMaybe "Test" :: Maybe (V '[Int,Float,String])
Just "Test"

Haskell code corresponding to a Variant

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