Module

Data.Variant

Package: purescript-variant
Repository: natefaubion/purescript-variant

#Variant Source

data Variant :: Row Type -> Type

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 Source

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

Inject into the variant at a given label.

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

#prj Source

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

Attempt to read a variant at a given label.

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

#on Source

on :: forall r2 r1 b a sym. Cons sym a r1 r2 => IsSymbol sym => SProxy 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 Source

onMatch :: forall b r3 r2 r1 r rl. 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.

#case_ Source

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

Combinator for exhaustive pattern matching.

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

#match Source

match :: forall b r2 r1 r rl. 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 Source

default :: forall r a. 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 (SProxy :: SProxy "foo") (\foo -> "Foo: " <> show foo)
 # on (SProxy :: SProxy "bar") (\bar -> "Bar: " <> bar)

#expand Source

expand :: forall gt a lt. 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 Source

contract :: forall f gt lt. 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.

#VariantEqs Source

class VariantEqs (rl :: RowList)  where

Members

variantEqs :: RLProxy rl -> List (VariantCase -> VariantCase -> Boolean)

Instances

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

#VariantOrds Source

class VariantOrds (rl :: RowList)  where

Members

variantOrds :: RLProxy rl -> List (VariantCase -> VariantCase -> Ordering)

Instances

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

#VariantShows Source

class VariantShows (rl :: RowList)  where

Members

variantShows :: RLProxy rl -> List (VariantCase -> String)

Instances

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

#VariantBounded Source

class VariantBounded (rl :: RowList)  where

Members

variantBounded :: RLProxy rl -> List (BoundedDict VariantCase)

Instances

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

#VariantBoundedEnums Source

class (VariantBounded rl) <= VariantBoundedEnums rl  where

Members

variantBoundedEnums :: RLProxy rl -> List (BoundedEnumDict VariantCase)

Instances

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

Re-exports from Data.Symbol

#SProxy Source

data SProxy (sym :: Symbol)

A value-level proxy for a type-level symbol.

Constructors

SProxy

Re-exports from Data.Variant.Internal

#Contractable Source

class Contractable gt lt

Instances

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

#VariantMatchCases Source

class VariantMatchCases (rl :: RowList) (vo :: Row Type) 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

Modules: Data.Functor.Variant; Data.Variant; Data.Variant.Internal