Module

Data.Functor.Variant

Package
purescript-variant
Repository
natefaubion/purescript-variant

#VariantF Source

data VariantF (f :: Row Type) a

Instances

#inj Source

inj :: forall r2 r1 a f sym. RowCons sym (FProxy f) r1 r2 => IsSymbol sym => Functor f => SProxy sym -> f a -> VariantF r2 a

Inject into the variant at a given label.

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

#prj Source

prj :: forall g r2 r1 a f sym. RowCons sym (FProxy f) r1 r2 => Alternative g => IsSymbol sym => SProxy sym -> VariantF r2 a -> g (f a)

Attempt to read a variant at a given label.

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

#on Source

on :: forall r2 r1 b a f sym. RowCons sym (FProxy f) r1 r2 => IsSymbol sym => SProxy 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.

#case_ Source

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

Combinator for exhaustive pattern matching.

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

#default Source

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

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

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

#match Source

match :: forall result typearg record variant. VariantFRecordMatching variant record typearg result => Record record -> VariantF variant typearg -> result

Match a variant with a record containing methods to handle each case to produce a result.

This means that if variant contains a row of type FProxy f, a row with the same label must have type f a -> result in record, where result is the same type for every row of record.

Polymorphic methods in record may create problems with the type system if the polymorphism is not fully generalized to the whole record type or 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.

#expand Source

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

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

Re-exports from Data.Symbol

#SProxy Source

data SProxy (sym :: Symbol)

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

Constructors

Re-exports from Data.Variant.Internal

#FProxy Source

data FProxy (a :: Type -> Type)

Proxy for a Functor.

Constructors

Instances

#Contractable Source

class Contractable gt lt

Instances

Modules
Data.Functor.Variant
Data.Variant
Data.Variant.Internal