-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Shared utilities for composite-* packages.
--   
--   Shared helpers for the various composite packages.
@package composite-base
@version 0.8.2.2

module Composite.Record

-- | A record is parameterized by a universe <tt>u</tt>, an interpretation
--   <tt>f</tt> and a list of rows <tt>rs</tt>. The labels or indices of
--   the record are given by inhabitants of the kind <tt>u</tt>; the type
--   of values at any label <tt>r :: u</tt> is given by its interpretation
--   <tt>f r :: *</tt>.
data Rec (a :: u -> Type) (b :: [u])
[RNil] :: forall {u} (a :: u -> Type). Rec a ('[] :: [u])
[:&] :: forall {u} (a :: u -> Type) (r :: u) (rs :: [u]). !a r -> !Rec a rs -> Rec a (r : rs)
infixr 7 :&

-- | The type of regular plain records where each field has a value, equal
--   to <tt><a>Rec</a> <a>Identity</a></tt>.
type Record = Rec Identity

-- | Bidirectional pattern matching the first field of a record using
--   <a>:-&gt;</a> values and the <a>Identity</a> functor.
--   
--   This pattern is bidirectional meaning you can use it either as a
--   pattern or a constructor, e.g.
--   
--   <pre>
--   let rec = 123 :*: Just "foo" :*: RNil
--       foo :*: bar :*: RNil = rec
--   </pre>
--   
--   Mnemonic: <tt>*</tt> for products.
pattern (:*:) :: () => () => a -> Rec Identity rs -> Rec Identity ((s :-> a) : rs)
infixr 5 :*:

-- | Bidirectional pattern matching the first field of a record using
--   <a>:-&gt;</a> values and any functor.
--   
--   This pattern is bidirectional meaning you can use it either as a
--   pattern or a constructor, e.g.
--   
--   <pre>
--   let rec = Just 123 :^: Just "foo" :^: RNil
--       Just foo :^: Just bar :^: RNil = rec
--   </pre>
--   
--   Mnemonic: <tt>^</tt> for products (record) of products (functor).
pattern (:^:) :: Functor f => () => f a -> Rec f rs -> Rec f ((s :-> a) : rs)
infixr 5 :^:
pattern (:!:) :: Contravariant f => () => f a -> Rec f rs -> Rec f ((s :-> a) : rs)
infixr 5 :!:

-- | Some value of type <tt>a</tt> tagged with a symbol indicating its
--   field name or label. Used as the usual type of elements in a
--   <a>Rec</a> or <a>Record</a>.
--   
--   Recommended pronunciation: record val.
newtype (:->) (s :: Symbol) a
Val :: a -> (:->) (s :: Symbol) a
[getVal] :: (:->) (s :: Symbol) a -> a
_Val :: Iso (s :-> a) (s :-> b) a b

-- | Convenience function to make an <tt><a>Identity</a> (s <a>:-&gt;</a>
--   a)</tt> with a particular symbol, used for named field construction.
--   
--   For example:
--   
--   <pre>
--   type FFoo = "foo" :-&gt; Int
--   type FBar = "bar" :-&gt; String
--   type FBaz = "baz" :-&gt; Double
--   type MyRecord = [FFoo, FBar, FBaz]
--   
--   myRecord1 :: Record MyRecord
--   myRecord1
--     =  val @"foo" 123
--     :&amp; val @"bar" "foobar"
--     :&amp; val @"baz" 3.21
--     :&amp; RNil
--   
--   myRecord2 :: Record MyRecord
--   myRecord2 = rcast
--     $  val @"baz" 3.21
--     :&amp; val @"foo" 123
--     :&amp; val @"bar" "foobar"
--     :&amp; RNil
--   </pre>
--   
--   In this example, both <tt>myRecord1</tt> and <tt>myRecord2</tt> have
--   the same value, since <a>rcast</a> can reorder records.
val :: forall (s :: Symbol) a. a -> Identity (s :-> a)

-- | Reflect the type level name of a named value <tt>s :-&gt; a</tt> to a
--   <tt>Text</tt>. For example, given <tt>"foo" :-&gt; Int</tt>, yields
--   <tt>"foo" :: Text</tt>
valName :: forall s a. KnownSymbol s => (s :-> a) -> Text

-- | Extract the value and reflect the name of a named value.
valWithName :: forall s a. KnownSymbol s => (s :-> a) -> (Text, a)

-- | Constraint expressing that <tt>r</tt> is in <tt>rs</tt> and providing
--   the index of <tt>r</tt> in <tt>rs</tt>. Equal to <tt><a>RElem</a> rs
--   (<a>RIndex</a> r rs)</tt>.
type RElem r rs = RElem r rs (RIndex r rs)

-- | Lens to a particular field of a record using the <a>Identity</a>
--   functor.
--   
--   For example, given:
--   
--   <pre>
--   type FFoo = "foo" :-&gt; Int
--   type FBar = "bar" :-&gt; String
--   fBar_ :: Proxy FBar
--   fBar_ = Proxy
--   
--   rec :: <a>Rec</a> <a>Identity</a> '[FFoo, FBar]
--   rec = 123 :*: "hello!" :*: Nil
--   </pre>
--   
--   Then:
--   
--   <pre>
--   view (rlens fBar_)               rec == "hello!"
--   set  (rlens fBar_) "goodbye!"    rec == 123 :*: "goodbye!" :*: Nil
--   over (rlens fBar_) (map toUpper) rec == 123 :*: "HELLO!"   :*: Nil
--   </pre>
rlens :: (Functor g, RElem (s :-> a) rs, Functor g) => proxy (s :-> a) -> (a -> g a) -> Rec Identity rs -> g (Rec Identity rs)

-- | Synonym for <a>rlensCo</a>
rlens' :: (Functor f, Functor g, RElem (s :-> a) rs) => proxy (s :-> a) -> (f a -> g (f a)) -> Rec f rs -> g (Rec f rs)

-- | Lens to a particular field of a record using any functor.
--   
--   For example, given:
--   
--   <pre>
--   type FFoo = "foo" :-&gt; Int
--   type FBar = "bar" :-&gt; String
--   fBar_ :: Proxy FBar
--   fBar_ = Proxy
--   
--   rec :: <a>Rec</a> <a>Maybe</a> '[FFoo, FBar]
--   rec = Just 123 :^: Just "hello!" :^: Nil
--   </pre>
--   
--   Then:
--   
--   <pre>
--   view (rlensCo fBar_)                      rec == Just "hello!"
--   set  (rlensCo fBar_) Nothing              rec == Just 123 :^: Nothing       :^: Nil
--   over (rlensCo fBar_) (fmap (map toUpper)) rec == Just 123 :^: Just "HELLO!" :^: Nil
--   </pre>
rlensCo :: (Functor f, Functor g, RElem (s :-> a) rs) => proxy (s :-> a) -> (f a -> g (f a)) -> Rec f rs -> g (Rec f rs)

-- | Lens to a particular field of a record using a contravariant functor.
--   
--   For example, given:
--   
--   <pre>
--   type FFoo = "foo" :-&gt; Int
--   type FBar = "bar" :-&gt; String
--   fBar_ :: Proxy FBar
--   fBar_ = Proxy
--   
--   rec :: <a>Rec</a> <tt>Predicate</tt> '[FFoo, FBar]
--   rec = Predicate even :!: Predicate (even . length) :!: Nil
--   </pre>
--   
--   Then:
--   
--   <pre>
--   view (rlensContra fBar_)                           rec == Predicate even
--   set  (rlensContra fBar_) Predicate (odd . length)  rec == Predicate even :!: Predicate (odd . length) :!: Nil
--   over (rlensContra fBar_) (contramap show)          rec == Predicate even :!: Predicate (odd . length . show) :!: Nil
--   </pre>
rlensContra :: (Contravariant f, Functor g, RElem (s :-> a) rs) => proxy (s :-> a) -> (f a -> g (f a)) -> Rec f rs -> g (Rec f rs)

-- | Type function which produces the cross product of constraints
--   <tt>cs</tt> and types <tt>as</tt>.
--   
--   For example, <tt>AllHave '[Eq, Ord] '[Int, Text]</tt> is equivalent to
--   <tt>(Eq Int, Ord Int, Eq Text, Ord Text)</tt>
type family AllHave (cs :: [u -> Constraint]) (as :: [u]) :: Constraint

-- | Type function which produces a constraint on <tt>a</tt> for each
--   constraint in <tt>cs</tt>.
--   
--   For example, <tt>HasInstances Int '[Eq, Ord]</tt> is equivalent to
--   <tt>(Eq Int, Ord Int)</tt>.
type family HasInstances (a :: u) (cs :: [u -> Constraint]) :: Constraint

-- | Type function which produces the cross product of constraints
--   <tt>cs</tt> and the values carried in a record <tt>rs</tt>.
--   
--   For example, <tt>ValuesAllHave '[Eq, Ord] '["foo" :-&gt; Int, "bar"
--   :-&gt; Text]</tt> is equivalent to <tt>(Eq Int, Ord Int, Eq Text, Ord
--   Text)</tt>
type family ValuesAllHave (cs :: [u -> Constraint]) (as :: [u]) :: Constraint

-- | <a>zipWith</a> for Rec's.
zipRecsWith :: (forall a. f a -> g a -> h a) -> Rec f as -> Rec g as -> Rec h as

-- | Given a list of constraints <tt>cs</tt>, apply some function for each
--   <tt>r</tt> in the target record type <tt>rs</tt> with proof that those
--   constraints hold for <tt>r</tt>, generating a record with the result
--   of each application.
reifyDicts :: forall u. forall (cs :: [u -> Constraint]) (f :: u -> Type) (rs :: [u]) (proxy :: [u -> Constraint] -> Type). (AllHave cs rs, RecApplicative rs) => proxy cs -> (forall proxy' (a :: u). HasInstances a cs => proxy' a -> f a) -> Rec f rs

-- | Reify the type of a val.
reifyVal :: proxy (s :-> a) -> (s :-> a) -> s :-> a

-- | Convert a provably nonempty <tt><a>Rec</a> (<a>Const</a> a) rs</tt> to
--   a <tt><a>NonEmpty</a> a</tt>.
recordToNonEmpty :: RecordToList rs => Rec (Const a) (r : rs) -> NonEmpty a

-- | Class which reifies the symbols of a record composed of <a>:-&gt;</a>
--   fields as <a>Text</a>.
class ReifyNames (rs :: [Type])

-- | Given a <tt><a>Rec</a> f rs</tt> where each <tt>r</tt> in <tt>rs</tt>
--   is of the form <tt>s <a>:-&gt;</a> a</tt>, make a record which adds
--   the <a>Text</a> for each <tt>s</tt>.
reifyNames :: ReifyNames rs => Rec f rs -> Rec ((,) Text :. f) rs

-- | Class with <a>rmap</a> but which gives the natural transformation
--   evidence that the value its working over is contained within the
--   overall record <tt>ss</tt>.
class RecWithContext (ss :: [Type]) (ts :: [Type])

-- | Apply a natural transformation from <tt>f</tt> to <tt>g</tt> to each
--   field of the given record, except that the natural transformation can
--   be mildly unnatural by having evidence that <tt>r</tt> is in
--   <tt>ss</tt>.
rmapWithContext :: RecWithContext ss ts => proxy ss -> (forall r. r ∈ ss => f r -> g r) -> Rec f ts -> Rec g ts

-- | Type function which removes the first element <tt>r</tt> from a list
--   <tt>rs</tt>, and doesn't expand if <tt>r</tt> is not present in
--   <tt>rs</tt>.
type family RDelete (r :: u) (rs :: [u])

-- | Constraint which reflects that an element <tt>r</tt> can be removed
--   from <tt>rs</tt> using <a>rdelete</a>.
type RDeletable r rs = (r ∈ rs, RDelete r rs ⊆ rs)

-- | Remove an element <tt>r</tt> from a <tt><a>Rec</a> f rs</tt>. Note
--   this is just a type constrained <a>rcast</a>.
rdelete :: RDeletable r rs => proxy r -> Rec f rs -> Rec f (RDelete r rs)

-- | Widen a record from <tt><a>Record</a> rs</tt> to <tt><a>Rec</a>
--   <a>Maybe</a> ss</tt>. Note this is just a type constrainted
--   <a>rdowncast</a>.
rwiden :: (RecApplicative ss, RMap rs, RMap ss, rs ⊆ ss) => Record rs -> Rec Maybe ss

-- | <a>Iso</a> which observes that a record with a single field <tt>s</tt>
--   with value <tt>a</tt> is isomorphic to the value alone.
_SingleVal :: forall s a b. Iso (Record '[s :-> a]) (Record '[s :-> b]) a b
instance GHC.Enum.Bounded a => GHC.Enum.Bounded (s Composite.Record.:-> a)
instance GHC.Enum.Enum a => GHC.Enum.Enum (s Composite.Record.:-> a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (s Composite.Record.:-> a)
instance GHC.Float.Floating a => GHC.Float.Floating (s Composite.Record.:-> a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (s Composite.Record.:-> a)
instance GHC.Real.Integral a => GHC.Real.Integral (s Composite.Record.:-> a)
instance Data.String.IsString a => Data.String.IsString (s Composite.Record.:-> a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (s Composite.Record.:-> a)
instance GHC.Num.Num a => GHC.Num.Num (s Composite.Record.:-> a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (s Composite.Record.:-> a)
instance GHC.Real.Real a => GHC.Real.Real (s Composite.Record.:-> a)
instance GHC.Float.RealFloat a => GHC.Float.RealFloat (s Composite.Record.:-> a)
instance GHC.Real.RealFrac a => GHC.Real.RealFrac (s Composite.Record.:-> a)
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (s Composite.Record.:-> a)
instance Foreign.Storable.Storable a => Foreign.Storable.Storable (s Composite.Record.:-> a)
instance Composite.Record.RecWithContext ss '[]
instance (r Data.Vinyl.Lens.∈ ss, Composite.Record.RecWithContext ss ts) => Composite.Record.RecWithContext ss (r : ts)
instance Composite.Record.ReifyNames '[]
instance (GHC.TypeLits.KnownSymbol s, Composite.Record.ReifyNames rs) => Composite.Record.ReifyNames ((s Composite.Record.:-> a) : rs)
instance ((s1 Composite.Record.:-> a1) GHC.Types.~ t) => Control.Lens.Wrapped.Rewrapped (s2 Composite.Record.:-> a2) t
instance Control.Lens.Wrapped.Wrapped (s Composite.Record.:-> a)
instance GHC.Base.Functor ((Composite.Record.:->) s)
instance GHC.Base.Applicative ((Composite.Record.:->) s)
instance Data.Foldable.Foldable ((Composite.Record.:->) s)
instance Data.Traversable.Traversable ((Composite.Record.:->) s)
instance GHC.Base.Monad ((Composite.Record.:->) s)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (s Composite.Record.:-> a)
instance Control.DeepSeq.NFData (Composite.Record.Record '[])
instance (Control.DeepSeq.NFData x, Control.DeepSeq.NFData (Composite.Record.Record xs)) => Control.DeepSeq.NFData (Composite.Record.Record (x : xs))
instance (GHC.TypeLits.KnownSymbol s, GHC.Show.Show a) => GHC.Show.Show (s Composite.Record.:-> a)
instance GHC.TypeLits.KnownSymbol s => Data.Vinyl.XRec.IsoHKD Data.Functor.Identity.Identity (s Composite.Record.:-> a)


-- | Module containing the sum formulation companion to <a>Record</a>s
--   product formulation. Values of type <tt><a>CoRec</a> f rs</tt>
--   represent a single value <tt>f r</tt> for one of the <tt>r</tt>s in
--   <tt>rs</tt>. Heavily based on the great work by Anthony Cowley in
--   Frames.
module Composite.CoRecord

-- | <tt>CoRef f rs</tt> represents a single value of type <tt>f r</tt> for
--   some <tt>r</tt> in <tt>rs</tt>.
data CoRec :: (u -> Type) -> [u] -> Type

-- | Witness that <tt>r</tt> is an element of <tt>rs</tt> using <a>∈</a>
--   (<a>RElem</a> with <a>RIndex</a>) from Vinyl.
[CoVal] :: r ∈ rs => !f r -> CoRec f rs

-- | The common case of a <a>CoRec</a> with <tt>f ~ <a>Identity</a></tt>,
--   i.e. a regular value.
type Field = CoRec Identity

-- | Inject a value <tt>f r</tt> into a <tt><a>CoRec</a> f rs</tt> given
--   that <tt>r</tt> is one of the valid <tt>rs</tt>.
--   
--   Equivalent to <a>CoVal</a> the constructor, but exists to parallel
--   <a>field</a>.
coRec :: r ∈ rs => f r -> CoRec f rs

-- | Produce a prism for the given alternative of a <a>CoRec</a>.
coRecPrism :: (RecApplicative rs, r ∈ rs) => Prism' (CoRec f rs) (f r)

-- | Inject a value <tt>r</tt> into a <tt><a>Field</a> rs</tt> given that
--   <tt>r</tt> is one of the valid <tt>rs</tt>.
--   
--   Equivalent to <tt><a>CoVal</a> . <a>Identity</a></tt>.
field :: r ∈ rs => r -> Field rs

-- | Inject a value <tt>a</tt> into a <tt><a>Field</a> rs</tt> given that
--   <tt>s :-&gt; a</tt> is one of the valid <tt>rs</tt>.
--   
--   Equivalent to <tt><a>CoVal</a> . <a>Identity</a> . <a>Val</a></tt>.
fieldVal :: forall s a rs proxy. (s :-> a) ∈ rs => proxy (s :-> a) -> a -> Field rs

-- | Produce a prism for the given alternative of a <a>Field</a>.
fieldPrism :: (RecApplicative rs, r ∈ rs) => Prism' (Field rs) r

-- | Produce a prism for the given <tt>:-&gt;</tt> alternative of a
--   <a>Field</a>, given a proxy to identify which <tt>s :-&gt; a</tt> you
--   meant.
fieldValPrism :: (RecApplicative rs, (s :-> a) ∈ rs) => proxy (s :-> a) -> Prism' (Field rs) a

-- | Apply an extraction to whatever <tt>f r</tt> is contained in the given
--   <a>CoRec</a>.
--   
--   For example <tt>foldCoVal getConst :: CoRec (Const a) rs -&gt; a</tt>.
foldCoVal :: (forall (r :: u). RElem r rs (RIndex r rs) => f r -> b) -> CoRec f rs -> b

-- | Map a <tt><a>CoRec</a> f</tt> to a <tt><a>CoRec</a> g</tt> using a
--   natural transform from <tt>f</tt> to <tt>g</tt> (<tt>forall x. f x
--   -&gt; g x</tt>).
mapCoRec :: (forall x. f x -> g x) -> CoRec f rs -> CoRec g rs

-- | Apply some kleisli on <tt>h</tt> to the <tt>f x</tt> contained in a
--   <tt><a>CoRec</a> f</tt> and yank the <tt>h</tt> outside. Like
--   <a>traverse</a> but for <a>CoRec</a>.
traverseCoRec :: Functor h => (forall x. f x -> h (g x)) -> CoRec f rs -> h (CoRec g rs)

-- | Project a <tt><a>CoRec</a> f</tt> into a <tt><a>Rec</a> (<a>Maybe</a>
--   <a>:.</a> f)</tt> where only the single <tt>r</tt> held by the
--   <a>CoRec</a> is <a>Just</a> in the resulting record, and all other
--   fields are <a>Nothing</a>.
coRecToRec :: RecApplicative rs => CoRec f rs -> Rec (Maybe :. f) rs

-- | Project a <a>Field</a> into a <tt><a>Rec</a> <a>Maybe</a></tt> where
--   only the single <tt>r</tt> held by the <a>Field</a> is <a>Just</a> in
--   the resulting record, and all other fields are <a>Nothing</a>.
fieldToRec :: (RMap rs, RecApplicative rs) => Field rs -> Rec Maybe rs

-- | Typeclass which allows folding ala <a>foldMap</a> over a <a>Rec</a>,
--   using a <a>CoRec</a> as the accumulator.
class FoldRec ss ts

-- | Given some combining function, an initial value, and a record, visit
--   each field of the record using the combining function to accumulate
--   the initial value or previous accumulation with the field of the
--   record.
foldRec :: FoldRec ss ts => (CoRec f ss -> CoRec f ss -> CoRec f ss) -> CoRec f ss -> Rec f ts -> CoRec f ss

-- | <a>foldRec</a> for records with at least one field that doesn't
--   require an initial value.
foldRec1 :: FoldRec (r : rs) rs => (CoRec f (r : rs) -> CoRec f (r : rs) -> CoRec f (r : rs)) -> Rec f (r : rs) -> CoRec f (r : rs)

-- | Given a <tt><a>Rec</a> (<a>Maybe</a> <a>:.</a> f) rs</tt>, yield a
--   <tt>Just coRec</tt> for the first field which is <tt>Just</tt>, or
--   <tt>Nothing</tt> if there are no <tt>Just</tt> fields in the record.
firstCoRec :: FoldRec rs rs => Rec (Maybe :. f) rs -> Maybe (CoRec f rs)

-- | Given a <tt><a>Rec</a> <a>Maybe</a> rs</tt>, yield a <tt>Just
--   field</tt> for the first field which is <tt>Just</tt>, or
--   <tt>Nothing</tt> if there are no <tt>Just</tt> fields in the record.
firstField :: (FoldRec rs rs, RMap rs) => Rec Maybe rs -> Maybe (Field rs)

-- | Given a <tt><a>Rec</a> (<a>Maybe</a> <a>:.</a> f) rs</tt>, yield a
--   <tt>Just coRec</tt> for the last field which is <tt>Just</tt>, or
--   <tt>Nothing</tt> if there are no <tt>Just</tt> fields in the record.
lastCoRec :: FoldRec rs rs => Rec (Maybe :. f) rs -> Maybe (CoRec f rs)

-- | Given a <tt><a>Rec</a> <a>Maybe</a> rs</tt>, yield a <tt>Just
--   field</tt> for the last field which is <tt>Just</tt>, or
--   <tt>Nothing</tt> if there are no <tt>Just</tt> fields in the record.
lastField :: (RMap rs, FoldRec rs rs) => Rec Maybe rs -> Maybe (Field rs)

-- | Helper newtype containing a function <tt>a -&gt; b</tt> but with the
--   type parameters flipped so <tt>Op b</tt> has a consistent codomain for
--   a varying domain.
newtype Op b a
Op :: (a -> b) -> Op b a
[runOp] :: Op b a -> a -> b

-- | Given a list of constraints <tt>cs</tt> required to apply some
--   function, apply the function to whatever value <tt>r</tt> (not <tt>f
--   r</tt>) which the <a>CoRec</a> contains.
onCoRec :: forall (cs :: [Type -> Constraint]) (f :: Type -> Type) (rs :: [Type]) (b :: Type) (proxy :: [Type -> Constraint] -> Type). (AllHave cs rs, Functor f, RecApplicative rs) => proxy cs -> (forall (a :: Type). HasInstances a cs => a -> b) -> CoRec f rs -> f b

-- | Given a list of constraints <tt>cs</tt> required to apply some
--   function, apply the function to whatever value <tt>r</tt> which the
--   <a>Field</a> contains.
onField :: forall (cs :: [Type -> Constraint]) (rs :: [Type]) (b :: Type) (proxy :: [Type -> Constraint] -> Type). (AllHave cs rs, RecApplicative rs) => proxy cs -> (forall (a :: Type). HasInstances a cs => a -> b) -> Field rs -> b

-- | Given some target type <tt>r</tt> that's a possible value of
--   <tt><a>Field</a> rs</tt>, yield <tt>Just</tt> if that is indeed the
--   value being stored by the <a>Field</a>, or <tt>Nothing</tt> if not.
asA :: (r ∈ rs, RMap rs, RecApplicative rs) => Field rs -> Maybe r

-- | An extractor function <tt>f a -&gt; b</tt> which can be passed to
--   <a>foldCoRec</a> to eliminate one possible alternative of a
--   <a>CoRec</a>.
newtype Case' f b a
Case' :: (f a -> b) -> Case' f b a
[unCase'] :: Case' f b a -> f a -> b

-- | A record of <tt>Case'</tt> eliminators for each <tt>r</tt> in
--   <tt>rs</tt> representing the pieces of a total function from
--   <tt><a>CoRec</a> f</tt> to <tt>b</tt>.
type Cases' f rs b = Rec (Case' f b) rs

-- | Fold a <tt><a>CoRec</a> f</tt> using <tt>Cases'</tt> which eliminate
--   each possible value held by the <a>CoRec</a>, yielding the <tt>b</tt>
--   produced by whichever case matches.
foldCoRec :: RecApplicative (r : rs) => Cases' f (r : rs) b -> CoRec f (r : rs) -> b

-- | Fold a <tt><a>CoRec</a> f</tt> using <tt>Cases'</tt> which eliminate
--   each possible value held by the <a>CoRec</a>, yielding the <tt>b</tt>
--   produced by whichever case matches.
--   
--   Equivalent to <a>foldCoRec</a> but with its arguments flipped so it
--   can be written <tt>matchCoRec coRec $ cases</tt>.
matchCoRec :: RecApplicative (r : rs) => CoRec f (r : rs) -> Cases' f (r : rs) b -> b
newtype Case b a
Case :: (a -> b) -> Case b a
[unCase] :: Case b a -> a -> b
type Cases rs b = Rec (Case b) rs

-- | Fold a <a>Field</a> using <a>Cases</a> which eliminate each possible
--   value held by the <a>Field</a>, yielding the <tt>b</tt> produced by
--   whichever case matches.
foldField :: (RMap rs, RecApplicative (r : rs)) => Cases (r : rs) b -> Field (r : rs) -> b

-- | Fold a <a>Field</a> using <a>Cases</a> which eliminate each possible
--   value held by the <a>Field</a>, yielding the <tt>b</tt> produced by
--   whichever case matches.
--   
--   Equivalent to <a>foldCoRec</a> but with its arguments flipped so it
--   can be written <tt>matchCoRec coRec $ cases</tt>.
matchField :: (RMap rs, RecApplicative (r : rs)) => Field (r : rs) -> Cases (r : rs) b -> b

-- | Widen a <tt><a>CoRec</a> f rs</tt> to a <tt><a>CoRec</a> f ss</tt>
--   given that <tt>rs ⊆ ss</tt>.
widenCoRec :: (FoldRec ss ss, RecApplicative rs, RecApplicative ss, rs ⊆ ss) => CoRec f rs -> CoRec f ss

-- | Widen a <tt><a>Field</a> rs</tt> to a <tt><a>Field</a> ss</tt> given
--   that <tt>rs ⊆ ss</tt>.
widenField :: (FoldRec ss ss, RMap rs, RMap ss, RecApplicative rs, RecApplicative ss, rs ⊆ ss) => Field rs -> Field ss

-- | Constraint showing that <tt>rs ⊆ ss</tt> and giving enough power to
--   widen a <tt><a>CoRec</a> f rs</tt> to <tt><a>CoRec</a> f ss</tt>.
type WiderCoRec rs ss = (FoldRec ss ss, RecApplicative rs, RecApplicative ss, rs ⊆ ss)

-- | Constraint on a pair of types <tt>r</tt> and <tt>s</tt> which are
--   <a>Wrapped</a> around <tt><a>CoRec</a> f rs</tt> and <tt><a>CoRec</a>
--   f ss</tt> respectively and observes that those types can be unwrapped
--   and the former can be widened to the latter.
type WrappedWiderCoRec f r rs s ss = (Wrapped r, Unwrapped r ~ CoRec f rs, Wrapped s, Unwrapped s ~ CoRec f ss, WiderCoRec rs ss)

-- | <a>WrappedWiderCoRec</a> specialized to <a>CoRec</a> <a>Identity</a>,
--   i.e. <a>Field</a>.
type WrappedWiderField r rs s ss = WrappedWiderCoRec Identity r rs s ss

-- | Widen a <tt><a>CoRec</a> f rs</tt> wrapped in <tt>r</tt> to a
--   <tt><a>CoRec</a> f ss</tt> wrapped in <tt>s</tt>.
widenWrappedCoRec :: WrappedWiderCoRec f r rs s ss => r -> s

-- | Widen a <tt><a>Field</a> rs</tt> wrapped in <tt>r</tt> to a
--   <tt><a>Field</a> ss</tt> wrapped in <tt>s</tt>.
widenWrappedField :: WrappedWiderField r rs s ss => r -> s

-- | Widen a wrapped <a>CoRec</a> using <a>widenWrappedCoRec</a> and then
--   throw it as an <a>ExceptT</a> error, as a convenience when using
--   <a>CoRec</a> / <a>Field</a> for building up error types by set union.
throwWidened :: (Monad m, WrappedWiderCoRec f e er e' er') => e -> ExceptT e' m a

-- | Catch a wrapped <a>CoRec</a> thrown by an <a>ExceptT</a> and widen it
--   using <a>widenWrappedCoRec</a> then rethrow it, as a convenience when
--   using <a>CoRec</a> / <a>Field</a> for building up error types by set
--   union.
rethrowWidened :: (Functor m, WrappedWiderCoRec f e er e' er') => ExceptT e m a -> ExceptT e' m a

-- | Specialized type of <a>Case</a> for <a>Val</a>, with the type
--   parameters in a convenient order for type application, e.g.:
--   
--   <pre>
--   valCase <tt>"foo" ( a -&gt; ...)
--     :&amp; valCase </tt>"bar" ( b -&gt; ...)
--     :&amp; RNil
--   </pre>
valCase :: forall s a b. (a -> b) -> Case b (s :-> a)

-- | Specialized type of <a>Case'</a> for <a>Val</a>, with the type
--   parameters in a convenient order for type application, e.g.:
--   
--   <pre>
--   valCase' <tt>"foo" ( fa -&gt; ...)
--     :&amp; valCase' </tt>"bar" ( fb -&gt; ...)
--     :&amp; RNil
--   </pre>
valCase' :: forall s f a b. Functor f => (f a -> b) -> Case' f b (s :-> a)

-- | Make a <a>Case</a> which yields the symbol text for a field <tt>s
--   :-&gt; ()</tt>. E.g.:
--   
--   <pre>
--   keywordCase @"foo" (Identity (Val ())) == "foo"
--   </pre>
keywordCase :: KnownSymbol s => Case Text (s :-> ())

-- | Make a <a>Case'</a> which yields the symbol text for a field <tt>s
--   :-&gt; ()</tt> as projected through the given function. E.g.:
--   
--   <pre>
--   keywordCase @"foo" (&lt;&gt; "bar") (Identity (Val ())) == "foobar"
--   </pre>
keywordCase' :: KnownSymbol s => (Text -> a) -> Case a (s :-> ())
instance Data.Functor.Contravariant.Contravariant (Composite.CoRecord.Case b)
instance GHC.Base.Functor f => Data.Functor.Contravariant.Contravariant (Composite.CoRecord.Case' f b)
instance (Composite.Record.AllHave '[GHC.Show.Show] rs, Data.Vinyl.Core.RecApplicative rs) => GHC.Show.Show (Composite.CoRecord.CoRec Data.Functor.Identity.Identity rs)
instance forall u (ss :: [u]). Composite.CoRecord.FoldRec ss '[]
instance forall a (t :: a) (ss :: [a]) (ts :: [a]). (t Data.Vinyl.Lens.∈ ss, Composite.CoRecord.FoldRec ss ts) => Composite.CoRecord.FoldRec ss (t : ts)
instance (Data.Vinyl.Core.RMap rs, Data.Vinyl.TypeLevel.RecAll GHC.Maybe.Maybe rs GHC.Classes.Eq, Data.Vinyl.Core.RecApplicative rs, Data.Vinyl.Core.RecordToList rs, Data.Vinyl.Core.ReifyConstraint GHC.Classes.Eq GHC.Maybe.Maybe rs) => GHC.Classes.Eq (Composite.CoRecord.CoRec Data.Functor.Identity.Identity rs)

module Composite

module Composite.TH

-- | Make <a>Proxy</a> definitions for each of the <tt>type</tt> synonyms
--   in the given block of declarations. The proxies have the same names as
--   the synonyms but with the first letter lowercased.
--   
--   For example:
--   
--   <pre>
--   withProxies [d|
--     type FFoo = "foo" :-&gt; Int
--     |]
--   </pre>
--   
--   Is equivalent to:
--   
--   <pre>
--   type FFoo = "foo" :-&gt; Int
--   fFoo :: Proxy FFoo
--   fFoo = Proxy
--   </pre>
--   
--   <b>Note:</b> the trailing <tt>|]</tt> of the quasi quote bracket has
--   to be indented or a parse error will occur.
withProxies :: Q [Dec] -> Q [Dec]

-- | Make <a>rlens</a> and <a>Proxy</a> definitions for each of the
--   <tt>type</tt> synonyms in the given block of declarations. The lenses
--   have the same names as the synonyms but with the first letter
--   lowercased. The proxies have that name but with <tt>_</tt> suffix.
--   
--   For example:
--   
--   <pre>
--   withLensesAndProxies [d|
--     type FFoo = "foo" :-&gt; Int
--     |]
--   </pre>
--   
--   Is equivalent to:
--   
--   <pre>
--   type FFoo = "foo" :-&gt; Int
--   fFoo :: FFoo ∈ rs =&gt; Lens' (Record rs) Int
--   fFoo = rlens fFoo_
--   fFoo_ :: Proxy FFoo
--   fFoo_ = Proxy
--   </pre>
--   
--   <b>Note:</b> the trailing <tt>|]</tt> of the quasi quote bracket has
--   to be indented or a parse error will occur.
--   
--   This is equivalent to <a>withOpticsAndProxies</a> but without the
--   prisms.
withLensesAndProxies :: Q [Dec] -> Q [Dec]

-- | Make <a>fieldValPrism</a> and <a>Proxy</a> definitions for each of the
--   <tt>type</tt> synonyms in the given block of declarations. The prisms
--   have the same names as the synonyms but prefixed with <tt>_</tt>. The
--   proxies will have the same name as the synonym but with the first
--   character lowercased and <tt>_</tt> appended.
--   
--   For example:
--   
--   <pre>
--   withPrismsAndProxies [d|
--     type FFoo = "foo" :-&gt; Int
--     |]
--   </pre>
--   
--   Is equivalent to:
--   
--   <pre>
--   type FFoo = "foo" :-&gt; Int
--   _FFoo :: FFoo ∈ rs =&gt; Prism' (Field rs) Int
--   _FFoo = fieldValPrism fFoo_
--   fFoo_ :: Proxy FFoo
--   fFoo_ = Proxy
--   </pre>
--   
--   <b>Note:</b> the trailing <tt>|]</tt> of the quasi quote bracket has
--   to be indented or a parse error will occur.
--   
--   This is equivalent to <a>withOpticsAndProxies</a> but without the
--   prisms.
withPrismsAndProxies :: Q [Dec] -> Q [Dec]

-- | Make <a>rlens</a>, <a>fieldValPrism</a>, and <a>Proxy</a> definitions
--   for each of the <tt>type</tt> synonyms in the given block of
--   declarations. The lenses have the same names as the synonyms but with
--   the first letter lowercased, e.g. <tt>FFoo</tt> becomes <tt>fFoo</tt>.
--   The prisms have the same names as the synonyms but with <tt>_</tt>
--   prepended, e.g. <tt>FFoo</tt> becomes <tt>_FFoo</tt>. The proxies have
--   the same names as the synonyms but with the first letter lowercase and
--   trailing <tt>_</tt>, e.g. <tt>FFoo</tt> becomes <tt>fFoo_</tt>.
--   
--   For example:
--   
--   <pre>
--   withOpticsAndProxies [d|
--     type FFoo = "foo" :-&gt; Int
--     |]
--   </pre>
--   
--   Is equivalent to:
--   
--   <pre>
--   type FFoo = "foo" :-&gt; Int
--   fFoo :: FFoo ∈ rs =&gt; Lens' (Record rs) Int
--   fFoo = rlens fFoo_
--   _FFoo :: FFoo ∈ rs =&gt; Prism' (Field rs) Int
--   _FFoo = fieldValPrism fFoo_
--   fFoo_ :: Proxy FFoo
--   fFoo_ = Proxy
--   </pre>
--   
--   <b>Note:</b> the trailing <tt>|]</tt> of the quasi quote bracket has
--   to be indented or a parse error will occur.
withOpticsAndProxies :: Q [Dec] -> Q [Dec]


-- | Module with a <a>ReaderT</a> style monad specialized to holding a
--   record.
module Control.Monad.Composite.Context

-- | Monad transformer which adds an implicit environment which is a
--   record. Isomorphic to <tt>ReaderT (Record c) m</tt>.
newtype ContextT (c :: [Type]) (m :: (Type -> Type)) a
ContextT :: (Record c -> m a) -> ContextT (c :: [Type]) (m :: Type -> Type) a
[runContextT] :: ContextT (c :: [Type]) (m :: Type -> Type) a -> Record c -> m a

-- | Run some action in a given context, equivalent to <a>runContextT</a>
--   but with the arguments flipped.
runInContext :: Record c -> ContextT c m a -> m a

-- | Permute the current context with a function and then run some action
--   with that modified context.
withContext :: (Record c' -> Record c) -> ContextT c m a -> ContextT c' m a

-- | Transform the monad underlying a <a>ContextT</a> using a natural
--   transform.
mapContextT :: (m a -> n b) -> ContextT c m a -> ContextT c n b

-- | Class of monad (stacks) which have context reading functionality baked
--   in. Similar to <a>MonadReader</a> but can coexist with a another monad
--   that provides <a>MonadReader</a> and requires the context to be a
--   record.
class Monad m => MonadContext (c :: [Type]) m | m -> c

-- | Fetch the context record from the environment.
askContext :: MonadContext c m => m (Record c)

-- | Run some action which has the same type of context with the context
--   modified.
localContext :: MonadContext c m => (Record c -> Record c) -> m a -> m a

-- | Project some value out of the context using a function.
asksContext :: MonadContext c m => (Record c -> a) -> m a

-- | Project some value out of the context using a lens (typically a field
--   lens).
askField :: MonadContext c m => Getter (Record c) a -> m a
instance GHC.Base.Monad m => Control.Monad.Composite.Context.MonadContext c (Control.Monad.Composite.Context.ContextT c m)
instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Composite.Context.ContextT c m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Monad.Composite.Context.ContextT c m)
instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Monad.Composite.Context.ContextT c m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Composite.Context.ContextT c)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Composite.Context.ContextT c)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.IO.Unlift.MonadUnliftIO m => Control.Monad.IO.Unlift.MonadUnliftIO (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.RWS.Class.MonadRWS r w s m => Control.Monad.RWS.Class.MonadRWS r w s (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (Control.Monad.Composite.Context.ContextT c m)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.Cont.Class.MonadCont m => Control.Monad.Cont.Class.MonadCont (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Composite.Context.ContextT c m)
instance Control.Monad.Composite.Context.MonadContext c ((->) (Composite.Record.Record c))
instance Control.Monad.Composite.Context.MonadContext c m => Control.Monad.Composite.Context.MonadContext c (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Composite.Context.MonadContext c m => Control.Monad.Composite.Context.MonadContext c (Control.Monad.Trans.Maybe.MaybeT m)
instance (Control.Monad.Composite.Context.MonadContext c m, GHC.Base.Monoid w) => Control.Monad.Composite.Context.MonadContext c (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance (Control.Monad.Composite.Context.MonadContext c m, GHC.Base.Monoid w) => Control.Monad.Composite.Context.MonadContext c (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance Control.Monad.Composite.Context.MonadContext c m => Control.Monad.Composite.Context.MonadContext c (Control.Monad.Trans.State.Strict.StateT s m)
instance Control.Monad.Composite.Context.MonadContext c m => Control.Monad.Composite.Context.MonadContext c (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Composite.Context.MonadContext c m => Control.Monad.Composite.Context.MonadContext c (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Composite.Context.MonadContext c m => Control.Monad.Composite.Context.MonadContext c (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Composite.Context.MonadContext c m => Control.Monad.Composite.Context.MonadContext c (Control.Monad.Trans.Cont.ContT r m)
instance (Control.Monad.Composite.Context.MonadContext c m, GHC.Base.Monoid w) => Control.Monad.Composite.Context.MonadContext c (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance (Control.Monad.Composite.Context.MonadContext c m, GHC.Base.Monoid w) => Control.Monad.Composite.Context.MonadContext c (Control.Monad.Trans.RWS.Lazy.RWST r w s m)