Data.Functor.Variant

data VariantF :: Row (Type -> Type) -> Type -> Typedata VariantF f a

Instances

• Functor (VariantF r)
• (RowToList row rl, FoldableVFRL rl row) => Foldable (VariantF row)
• (RowToList row rl, TraversableVFRL rl row) => Traversable (VariantF row)
• (RowToList r rl, VariantTags rl, VariantFShows rl a, Show a) => Show (VariantF r a)

inj :: forall proxy sym f a r1 r2. Cons sym f r1 r2 => IsSymbol sym => Functor f => proxy sym -> f a -> VariantF r2 a

Inject into the variant at a given label.

maybeAtFoo :: forall r. VariantF (foo :: Maybe | r) Int
maybeAtFoo = inj (Proxy :: Proxy "foo") (Just 42)

prj :: forall proxy sym f a r1 r2 g. Cons sym f r1 r2 => Alternative g => IsSymbol sym => proxy sym -> VariantF r2 a -> g (f a)

Attempt to read a variant at a given label.

case prj (Proxy :: Proxy "foo") maybeAtFoo of
  Just (Just i) -> i + 1
  _ -> 0

on :: forall proxy sym f a b r1 r2. Cons sym f r1 r2 => IsSymbol sym => proxy sym -> (f a -> b) -> (VariantF r1 a -> b) -> VariantF r2 a -> b

Attempt to read a variant at a given label by providing branches. The failure branch receives the provided variant, but with the label removed.

onMatch :: forall rl r r1 r2 r3 a b. RowToList r rl => VariantFMatchCases rl r1 a b => Union r1 r2 r3 => Record r -> (VariantF r2 a -> b) -> VariantF r3 a -> b

Match a VariantF with a Record containing functions for handling cases. This is similar to on, except instead of providing a single label and handler, you can provide a record where each field maps to a particular VariantF case.

onMatch
 { foo: \foo -> "Foo: " <> maybe "nothing" id foo
 , bar: \bar -> "Bar: " <> snd bar
 }

Polymorphic functions in records (such as show or id) can lead to inference issues if not all polymorphic variables are specified in usage. When in doubt, label methods with specific types, such as show :: Int -> String, or give the whole record an appropriate type.

case_ :: forall a b. VariantF () a -> b

Combinator for exhaustive pattern matching.

caseFn :: VariantF (foo :: Maybe, bar :: Tuple String, baz :: Either String) Int -> String
caseFn = case_
 # on (Proxy :: Proxy "foo") (\foo -> "Foo: " <> maybe "nothing" show foo)
 # on (Proxy :: Proxy "bar") (\bar -> "Bar: " <> show (snd bar))
 # on (Proxy :: Proxy "baz") (\baz -> "Baz: " <> either id show baz)

match :: forall rl r r1 r2 a b. RowToList r rl => VariantFMatchCases rl r1 a b => Union r1 () r2 => Record r -> VariantF r2 a -> b

Combinator for exhaustive pattern matching using an onMatch case record.

matchFn :: VariantF (foo :: Maybe, bar :: Tuple String, baz :: Either String) Int -> String
matchFn = match
 { foo: \foo -> "Foo: " <> maybe "nothing" show foo
 , bar: \bar -> "Bar: " <> show (snd bar)
 , baz: \baz -> "Baz: " <> either id show baz
 }

default :: forall a b r. a -> VariantF r b -> a

Combinator for partial matching with a default value in case of failure.

caseFn :: forall r. VariantF (foo :: Maybe, bar :: Tuple String | r) Int -> String
caseFn = default "No match"
 # on (Proxy :: Proxy "foo") (\foo -> "Foo: " <> maybe "nothing" show foo)
 # on (Proxy :: Proxy "bar") (\bar -> "Bar: " <> show (snd bar))

expand :: forall lt mix gt a. Union lt mix gt => VariantF lt a -> VariantF gt a

Every VariantF lt a can be cast to some VariantF gt a as long as lt is a subset of gt.

contract :: forall lt gt f a. Alternative f => Contractable gt lt => VariantF gt a -> f (VariantF lt a)

A VariantF gt a can be cast to some VariantF lt a, where lt is is a subset of gt, as long as there is proof that the VariantF's runtime tag is within the subset of lt.

newtype UnvariantF :: Row (Type -> Type) -> Type -> Typenewtype UnvariantF r a

Constructors

• UnvariantF (forall x. UnvariantF' r a x -> x)

type UnvariantF' :: Row (Type -> Type) -> Type -> Type -> Typetype UnvariantF' r a x = forall proxy s f o. IsSymbol s => Cons s f o r => Functor f => proxy s -> f a -> x

unvariantF :: forall r a. VariantF r a -> UnvariantF r a

A low-level eliminator which reifies the IsSymbol, Cons and Functor constraints require to reconstruct the Variant. This lets you work generically with some VariantF at runtime.

revariantF :: forall r a. UnvariantF r a -> VariantF r a

Reconstructs a VariantF given an UnvariantF eliminator.

class VariantFShows :: RowList (Type -> Type) -> Type -> Constraintclass VariantFShows rl x  where

Members

• variantFShows :: forall proxy1 proxy2. proxy1 rl -> proxy2 x -> List (VariantCase -> String)

Instances

• VariantFShows Nil x
• (VariantFShows rs x, TypeEquals a f, Show (f x), Show x) => VariantFShows (Cons sym a rs) x

class TraversableVFRL :: RowList (Type -> Type) -> Row (Type -> Type) -> Constraintclass (FoldableVFRL rl row) <= TraversableVFRL rl row | rl -> row where

Members

• traverseVFRL :: forall proxy f a b. Applicative f => proxy rl -> (a -> f b) -> VariantF row a -> f (VariantF row b)

Instances

• TraversableVFRL Nil ()
• (IsSymbol k, Traversable f, TraversableVFRL rl r, Cons k f r r', Union r rx r') => TraversableVFRL (Cons k f rl) r'

class FoldableVFRL :: RowList (Type -> Type) -> Row (Type -> Type) -> Constraintclass FoldableVFRL rl row | rl -> row where

Members

• foldrVFRL :: forall proxy a b. proxy rl -> (a -> b -> b) -> b -> VariantF row a -> b
• foldlVFRL :: forall proxy a b. proxy rl -> (b -> a -> b) -> b -> VariantF row a -> b
• foldMapVFRL :: forall proxy a m. Monoid m => proxy rl -> (a -> m) -> VariantF row a -> m

Instances

• FoldableVFRL Nil ()
• (IsSymbol k, Foldable f, FoldableVFRL rl r, Cons k f r r') => FoldableVFRL (Cons k f rl) r'

class Contractable :: forall k. Row k -> Row k -> Constraintclass Contractable gt lt 

Instances

• (RowToList lt ltl, Union lt a gt, VariantTags ltl) => Contractable gt lt

class VariantFMatchCases :: RowList Type -> Row (Type -> Type) -> Type -> Type -> Constraintclass VariantFMatchCases rl vo a b | rl -> vo a b

Instances

• (VariantFMatchCases rl vo' a b, Cons sym f vo' vo, TypeEquals k (f a -> b)) => VariantFMatchCases (Cons sym k rl) vo a b
• VariantFMatchCases Nil () a b