Data.Variant

data Variant :: Row Type -> Typedata Variant t0

Instances

• (RowToList r rl, VariantTags rl, VariantEqs rl) => Eq (Variant r)
• (RowToList r rl, VariantTags rl, VariantEqs rl, VariantOrds rl, VariantBounded rl) => Bounded (Variant r)
• (RowToList r rl, VariantTags rl, VariantEqs rl, VariantOrds rl, VariantBoundedEnums rl) => Enum (Variant r)
• (RowToList r rl, VariantTags rl, VariantEqs rl, VariantOrds rl, VariantBoundedEnums rl) => BoundedEnum (Variant r)
• (RowToList r rl, VariantTags rl, VariantEqs rl, VariantOrds rl) => Ord (Variant r)
• (RowToList r rl, VariantTags rl, VariantShows rl) => Show (Variant r)

inj :: forall sym a r1 r2. Cons sym a r1 r2 => IsSymbol sym => Proxy sym -> a -> Variant r2

Inject into the variant at a given label.

intAtFoo :: forall r. Variant (foo :: Int | r)
intAtFoo = inj (Proxy :: Proxy "foo") 42

prj :: forall sym a r1 r2 f. Cons sym a r1 r2 => IsSymbol sym => Alternative f => Proxy sym -> Variant r2 -> f a

Attempt to read a variant at a given label.

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

on :: forall sym a b r1 r2. Cons sym a r1 r2 => IsSymbol sym => Proxy sym -> (a -> b) -> (Variant r1 -> b) -> Variant r2 -> 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 b. RowToList r rl => VariantMatchCases rl r1 b => Union r1 r2 r3 => Record r -> (Variant r2 -> b) -> Variant r3 -> b

Match a Variant 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 Variant case.

onMatch
  { foo: \foo -> "Foo: " <> foo
  , bar: \bar -> "Bar: " <> 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.

over :: forall r rl ri ro r1 r2 r3. RowToList r rl => VariantMapCases rl ri ro => Union ri r2 r1 => Union ro r2 r3 => Record r -> Variant r1 -> Variant r3

Map over some labels and leave the rest unchanged. For example:

over { label: show :: Int -> String }
  :: forall r. Variant ( label :: Int | r ) -> Variant ( label :: String | r )

over r is like expand # overSome r but with a more easily solved constraint (i.e. it can be solved once the type of r is known).

overOne :: forall sym a b r1 r2 r3 r4. IsSymbol sym => Cons sym a r1 r2 => Cons sym b r4 r3 => Proxy sym -> (a -> b) -> (Variant r1 -> Variant r3) -> Variant r2 -> Variant r3

Map over one case of a variant, putting the result back at the same label, with a fallback function to handle the remaining cases.

overSome :: forall r rl ri ro r1 r2 r3 r4. RowToList r rl => VariantMapCases rl ri ro => Union ri r2 r1 => Union ro r4 r3 => Record r -> (Variant r2 -> Variant r3) -> Variant r1 -> Variant r3

Map over several cases of a variant using a Record containing functions for each case. Each case gets put back at the same label it was matched at, i.e. its label in the record. Labels not found in the record are handled using the fallback function.

case_ :: forall a. Variant () -> a

Combinator for exhaustive pattern matching.

caseFn :: Variant (foo :: Int, bar :: String, baz :: Boolean) -> String
caseFn = case_
 # on (Proxy :: Proxy "foo") (\foo -> "Foo: " <> show foo)
 # on (Proxy :: Proxy "bar") (\bar -> "Bar: " <> bar)
 # on (Proxy :: Proxy "baz") (\baz -> "Baz: " <> show baz)

match :: forall rl r r1 r2 b. RowToList r rl => VariantMatchCases rl r1 b => Union r1 () r2 => Record r -> Variant r2 -> b

Combinator for exhaustive pattern matching using an onMatch case record.

matchFn :: Variant (foo :: Int, bar :: String, baz :: Boolean) -> String
matchFn = match
  { foo: \foo -> "Foo: " <> show foo
  , bar: \bar -> "Bar: " <> bar
  , baz: \baz -> "Baz: " <> show baz
  }

default :: forall a r. a -> Variant r -> a

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

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

traverse :: forall r rl ri ro r1 r2 r3 m. RowToList r rl => VariantTraverseCases m rl ri ro => Union ri r2 r1 => Union ro r2 r3 => Applicative m => Record r -> Variant r1 -> m (Variant r3)

Traverse over some labels and leave the rest unchanged. (Implemented by expanding after traverseSome.)

traverseOne :: forall sym a b r1 r2 r3 r4 m. IsSymbol sym => Cons sym a r1 r2 => Cons sym b r4 r3 => Functor m => Proxy sym -> (a -> m b) -> (Variant r1 -> m (Variant r3)) -> Variant r2 -> m (Variant r3)

Traverse over one case of a variant (in a functorial/monadic context m), putting the result back at the same label, with a fallback function.

traverseSome :: forall r rl ri ro r1 r2 r3 r4 m. RowToList r rl => VariantTraverseCases m rl ri ro => Union ri r2 r1 => Union ro r4 r3 => Functor m => Record r -> (Variant r2 -> m (Variant r3)) -> Variant r1 -> m (Variant r3)

Traverse over several cases of a variant using a Record containing traversals. Each case gets put back at the same label it was matched at, i.e. its label in the record. Labels not found in the record are handled using the fallback function.

expand :: forall lt a gt. Union lt a gt => Variant lt -> Variant gt

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

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

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

newtype Unvariant :: Row Type -> Typenewtype Unvariant r

Constructors

• Unvariant (forall x. Unvariant' r x -> x)

type Unvariant' :: Row Type -> Type -> Typetype Unvariant' r x = forall s t o. IsSymbol s => Cons s t o r => Proxy s -> t -> x

unvariant :: forall r. Variant r -> Unvariant r

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

revariant :: forall r. Unvariant r -> Variant r

Reconstructs a Variant given an Unvariant eliminator.

class VariantEqs :: RowList Type -> Constraintclass VariantEqs rl  where

Members

• variantEqs :: Proxy rl -> List (VariantCase -> VariantCase -> Boolean)

Instances

• VariantEqs Nil
• (VariantEqs rs, Eq a) => VariantEqs (Cons sym a rs)

class VariantOrds :: RowList Type -> Constraintclass VariantOrds rl  where

Members

• variantOrds :: Proxy rl -> List (VariantCase -> VariantCase -> Ordering)

Instances

• VariantOrds Nil
• (VariantOrds rs, Ord a) => VariantOrds (Cons sym a rs)

class VariantShows :: RowList Type -> Constraintclass VariantShows rl  where

Members

• variantShows :: Proxy rl -> List (VariantCase -> String)

Instances

• VariantShows Nil
• (VariantShows rs, Show a) => VariantShows (Cons sym a rs)

class VariantBounded :: RowList Type -> Constraintclass VariantBounded rl  where

Members

• variantBounded :: Proxy rl -> List (BoundedDict VariantCase)

Instances

• VariantBounded Nil
• (VariantBounded rs, Bounded a) => VariantBounded (Cons sym a rs)

class VariantBoundedEnums :: RowList Type -> Constraintclass (VariantBounded rl) <= VariantBoundedEnums rl  where

Members

• variantBoundedEnums :: Proxy rl -> List (BoundedEnumDict VariantCase)

Instances

• VariantBoundedEnums Nil
• (VariantBoundedEnums rs, BoundedEnum a) => VariantBoundedEnums (Cons sym a rs)

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 VariantMapCases :: RowList Type -> Row Type -> Row Type -> Constraintclass VariantMapCases (rl :: RowList Type) (ri :: Row Type) (ro :: Row Type) | rl -> ri ro

Instances

• (Cons sym a ri' ri, Cons sym b ro' ro, VariantMapCases rl ri' ro', TypeEquals k (a -> b)) => VariantMapCases (Cons sym k rl) ri ro
• VariantMapCases Nil () ()

class VariantMatchCases :: RowList Type -> Row Type -> Type -> Constraintclass VariantMatchCases rl vo b | rl -> vo b

Instances

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

class VariantTraverseCases :: (Type -> Type) -> RowList Type -> Row Type -> Row Type -> Constraintclass VariantTraverseCases (m :: Type -> Type) (rl :: RowList Type) (ri :: Row Type) (ro :: Row Type) | rl -> ri ro

Instances

• (Cons sym a ri' ri, Cons sym b ro' ro, VariantTraverseCases m rl ri' ro', TypeEquals k (a -> m b)) => VariantTraverseCases m (Cons sym k rl) ri ro
• VariantTraverseCases m Nil () ()