Composite.CoRecord

CoRef f rs represents a single value of type f r for some r in rs.

The common case of a CoRec with f ~ Identity, i.e. a regular value.

Inject a value f r into a CoRec f rs given that r is one of the valid rs.

Equivalent to CoVal the constructor, but exists to parallel field.

Produce a prism for the given alternative of a CoRec.

Inject a value r into a Field rs given that r is one of the valid rs.

Equivalent to CoVal . Identity.

Inject a value a into a Field rs given that s :-> a is one of the valid rs.

Equivalent to CoVal . Identity . Val.

Produce a prism for the given alternative of a Field.

Produce a prism for the given :-> alternative of a Field, given a proxy to identify which s :-> a you meant.

Apply an extraction to whatever f r is contained in the given CoRec.

For example foldCoVal getConst :: CoRec (Const a) rs -> a.

Map a CoRec f to a CoRec g using a natural transform from f to g (forall x. f x -> g x).

Apply some kleisli on h to the f x contained in a CoRec f and yank the h outside. Like traverse but for CoRec.

Project a CoRec f into a Rec (Maybe :. f) where only the single r held by the CoRec is Just in the resulting record, and all other fields are Nothing.

Project a Field into a Rec Maybe where only the single r held by the Field is Just in the resulting record, and all other fields are Nothing.

Typeclass which allows folding ala foldMap over a Rec, using a CoRec as the accumulator.

foldRec for records with at least one field that doesn't require an initial value.

Given a Rec (Maybe :. f) rs, yield a Just coRec for the first field which is Just, or Nothing if there are no Just fields in the record.

Given a Rec Maybe rs, yield a Just field for the first field which is Just, or Nothing if there are no Just fields in the record.

Given a Rec (Maybe :. f) rs, yield a Just coRec for the last field which is Just, or Nothing if there are no Just fields in the record.

Given a Rec Maybe rs, yield a Just field for the last field which is Just, or Nothing if there are no Just fields in the record.

Helper newtype containing a function a -> b but with the type parameters flipped so Op b has a consistent codomain for a varying domain.

Given a list of constraints cs required to apply some function, apply the function to whatever value r (not f r) which the CoRec contains.

Given a list of constraints cs required to apply some function, apply the function to whatever value r which the Field contains.

Given some target type r that's a possible value of Field rs, yield Just if that is indeed the value being stored by the Field, or Nothing if not.

An extractor function f a -> b which can be passed to foldCoRec to eliminate one possible alternative of a CoRec.

A record of Case' eliminators for each r in rs representing the pieces of a total function from CoRec f to b.

Fold a CoRec f using Cases' which eliminate each possible value held by the CoRec, yielding the b produced by whichever case matches.

Fold a CoRec f using Cases' which eliminate each possible value held by the CoRec, yielding the b produced by whichever case matches.

Equivalent to foldCoRec but with its arguments flipped so it can be written matchCoRec coRec $ cases.

Fold a Field using Cases which eliminate each possible value held by the Field, yielding the b produced by whichever case matches.

Fold a Field using Cases which eliminate each possible value held by the Field, yielding the b produced by whichever case matches.

Equivalent to foldCoRec but with its arguments flipped so it can be written matchCoRec coRec $ cases.

Widen a CoRec f rs to a CoRec f ss given that rs ⊆ ss.

Widen a Field rs to a Field ss given that rs ⊆ ss.

Constraint showing that rs ⊆ ss and giving enough power to widen a CoRec f rs to CoRec f ss.

Constraint on a pair of types r and s which are Wrapped around CoRec f rs and CoRec f ss respectively and observes that those types can be unwrapped and the former can be widened to the latter.

WrappedWiderCoRec specialized to CoRec Identity, i.e. Field.

Widen a CoRec f rs wrapped in r to a CoRec f ss wrapped in s.

Widen a Field rs wrapped in r to a Field ss wrapped in s.

Widen a wrapped CoRec using widenWrappedCoRec and then throw it as an ExceptT error, as a convenience when using CoRec / Field for building up error types by set union.

Catch a wrapped CoRec thrown by an ExceptT and widen it using widenWrappedCoRec then rethrow it, as a convenience when using CoRec / Field for building up error types by set union.

Specialized type of Case for Val, with the type parameters in a convenient order for type application, e.g.:

  valCase "foo" ( a -> ...)
    :& valCase "bar" ( b -> ...)
    :& RNil

Specialized type of Case' for Val, with the type parameters in a convenient order for type application, e.g.:

  valCase' "foo" ( fa -> ...)
    :& valCase' "bar" ( fb -> ...)
    :& RNil

Make a Case which yields the symbol text for a field s :-> (). E.g.:

  keywordCase @"foo" (Identity (Val ())) == "foo"

Make a Case' which yields the symbol text for a field s :-> () as projected through the given function. E.g.:

  keywordCase @"foo" (<> "bar") (Identity (Val ())) == "foobar"