Data.Functor.Variant
- Package
- purescript-variant
- Repository
- natefaubion/purescript-variant
#VariantF Source
data 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)
#prj Source
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
#onMatch Source
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_ Source
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 Source
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 Source
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))
#contract Source
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
.
#UnvariantF' Source
type UnvariantF' r a x = forall proxy s f o. IsSymbol s => Cons s f o r => Functor f => proxy s -> f a -> x
#unvariantF Source
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 Source
revariantF :: forall r a. UnvariantF r a -> VariantF r a
Reconstructs a VariantF given an UnvariantF eliminator.
#VariantFShows Source
class 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
#TraversableVFRL Source
class (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'
#FoldableVFRL Source
class 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'
Re-exports from Data.Symbol
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
#VariantFMatchCases Source
class 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