| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Data.Vinyl.CoRec
Description
Co-records: open sum types.
Consider a record with three fields A, B, and C. A record is
a product of its fields; that is, it contains all of them: A,
B, and C. If we want to talk about a value whose type is one
of those three types, it is any one of type A, B, or
C. The type CoRec '[A,B,C] corresponds to this sum type.
Synopsis
- data CoRec :: (k -> *) -> [k] -> * where
- foldCoRec :: (forall a. RElem a ts (RIndex a ts) => f a -> b) -> CoRec f ts -> b
- type Field = CoRec Identity
- newtype Op b a = Op {
- runOp :: a -> b
- coRecToRec :: RecApplicative ts => CoRec f ts -> Rec (Maybe :. f) ts
- coRecToRec' :: RecApplicative ts => CoRec Identity ts -> Rec Maybe ts
- class FoldRec ss ts where
- coRecMap :: (forall x. f x -> g x) -> CoRec f ts -> CoRec g ts
- coRecTraverse :: Functor h => (forall x. f x -> h (g x)) -> CoRec f ts -> h (CoRec g ts)
- foldRec1 :: FoldRec (t ': ts) ts => (CoRec f (t ': ts) -> CoRec f (t ': ts) -> CoRec f (t ': ts)) -> Rec f (t ': ts) -> CoRec f (t ': ts)
- firstField :: FoldRec ts ts => Rec (Maybe :. f) ts -> Maybe (CoRec f ts)
- lastField :: FoldRec ts ts => Rec (Maybe :. f) ts -> Maybe (CoRec f ts)
- onCoRec :: forall (cs :: [* -> Constraint]) f ts b. (AllAllSat cs ts, Functor f, RecApplicative ts) => Proxy cs -> (forall a. AllSatisfied cs a => a -> b) -> CoRec f ts -> f b
- onField :: forall cs ts b. (AllAllSat cs ts, RecApplicative ts) => Proxy cs -> (forall a. AllSatisfied cs a => a -> b) -> Field ts -> b
- reifyDicts :: forall cs f proxy (ts :: [*]). (AllAllSat cs ts, RecApplicative ts) => proxy cs -> (forall a. AllSatisfied cs a => f a) -> Rec f ts
- asA :: (t ∈ ts, RecApplicative ts) => proxy t -> CoRec Identity ts -> Maybe t
- match :: CoRec Identity ts -> Handlers ts b -> b
- class RIndex t ts ~ i => Match1 t ts i where
- match1 :: (Match1 t ts (RIndex t ts), RecApplicative ts, FoldRec (RDelete t ts) (RDelete t ts)) => Handler r t -> CoRec Identity ts -> Either r (CoRec Identity (RDelete t ts))
- matchNil :: CoRec f '[] -> r
- newtype Handler b a = H (a -> b)
- type Handlers ts b = Rec (Handler b) ts
Documentation
data CoRec :: (k -> *) -> [k] -> * where Source #
Generalize algebraic sum types.
foldCoRec :: (forall a. RElem a ts (RIndex a ts) => f a -> b) -> CoRec f ts -> b Source #
Apply a function to a CoRec value. The function must accept
any variant.
A function type constructor that takes its arguments in the reverse order.
coRecToRec :: RecApplicative ts => CoRec f ts -> Rec (Maybe :. f) ts Source #
coRecToRec' :: RecApplicative ts => CoRec Identity ts -> Rec Maybe ts Source #
Shorthand for applying coRecToRec with common functors.
class FoldRec ss ts where Source #
Fold a field selection function over a Rec.
Minimal complete definition
Methods
foldRec :: (CoRec f ss -> CoRec f ss -> CoRec f ss) -> CoRec f ss -> Rec f ts -> CoRec f ss Source #
coRecMap :: (forall x. f x -> g x) -> CoRec f ts -> CoRec g ts Source #
Apply a natural transformation to a variant.
coRecTraverse :: Functor h => (forall x. f x -> h (g x)) -> CoRec f ts -> h (CoRec g ts) Source #
This can be used to pull effects out of a CoRec.
foldRec1 :: FoldRec (t ': ts) ts => (CoRec f (t ': ts) -> CoRec f (t ': ts) -> CoRec f (t ': ts)) -> Rec f (t ': ts) -> CoRec f (t ': ts) Source #
Fold a field selection function over a non-empty Rec.
onCoRec :: forall (cs :: [* -> Constraint]) f ts b. (AllAllSat cs ts, Functor f, RecApplicative ts) => Proxy cs -> (forall a. AllSatisfied cs a => a -> b) -> CoRec f ts -> f b Source #
Apply a type class method on a CoRec. The first argument is a
Proxy value for a list of Constraint constructors. For
example, onCoRec [pr|Num,Ord|] (> 20) r. If only one constraint
is needed, use the pr1 quasiquoter.
onField :: forall cs ts b. (AllAllSat cs ts, RecApplicative ts) => Proxy cs -> (forall a. AllSatisfied cs a => a -> b) -> Field ts -> b Source #
Apply a type class method on a Field. The first argument is a
Proxy value for a list of Constraint constructors. For
example, onCoRec [pr|Num,Ord|] (> 20) r. If only one constraint
is needed, use the pr1 quasiquoter.
reifyDicts :: forall cs f proxy (ts :: [*]). (AllAllSat cs ts, RecApplicative ts) => proxy cs -> (forall a. AllSatisfied cs a => f a) -> Rec f ts Source #
Build a record whose elements are derived solely from a list of constraint constructors satisfied by each.
Extracting values from a CoRec/Pattern matching on a CoRec
asA :: (t ∈ ts, RecApplicative ts) => proxy t -> CoRec Identity ts -> Maybe t Source #
Given a proxy of type t and a 'CoRec Identity' that might be a t, try to convert the CoRec to a t.
match :: CoRec Identity ts -> Handlers ts b -> b Source #
Pattern match on a CoRec by specifying handlers for each case. Note that the order of the Handlers has to match the type level list (t:ts).
>>>:{let testCoRec = Col (Identity False) :: CoRec Identity [Int, String, Bool] in match testCoRec $ (H $ \i -> "my Int is the successor of " ++ show (i - 1)) :& (H $ \s -> "my String is: " ++ s) :& (H $ \b -> "my Bool is not: " ++ show (not b) ++ " thus it is " ++ show b) :& RNil :} "my Bool is not: True thus it is False"
class RIndex t ts ~ i => Match1 t ts i where Source #
Helper for handling a variant of a CoRec: either the function
is applied to the variant or the type of the CoRec is refined to
reflect the fact that the variant is not compatible with the type
of the would-be handler.
Minimal complete definition