!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None!!"#$%&*+,/9:;<=?DILOQRTbfh Class with | but which gives the natural transformation evidence that the value its working over is contained within the overall record ss. $Apply a natural transformation from f to g| to each field of the given record, except that the natural transformation can be mildly unnatural by having evidence that r is in ss. 8Class which reifies the symbols of a record composed of  fields as . Given a  f rs where each r in rs is of the form s  a, make a record which adds the  for each s. >Type function which produces the cross product of constraints cs$ and the values carried in a record rs. For example, 9ValuesAllHave '[Eq, Ord] '["foo" :-> Int, "bar" :-> Text] is equivalent to $(Eq Int, Ord Int, Eq Text, Ord Text) >Type function which produces the cross product of constraints cs and types as. For example, AllHave '[Eq, Ord] '[Int, Text] is equivalent to $(Eq Int, Ord Int, Eq Text, Ord Text)-Type function which produces a constraint on a for each constraint in cs. For example, HasInstances Int '[Eq, Ord] is equivalent to (Eq Int, Ord Int).ABidirectional pattern matching the first field of a record using  values and any functor._This pattern is bidirectional meaning you can use it either as a pattern or a constructor, e.g. X let rec = Just 123 :^: Just "foo" :^: RNil Just foo :^: Just bar :^: RNil = rec  Mnemonic: ^- for products (record) of products (functor).ABidirectional pattern matching the first field of a record using  values and the  functor._This pattern is bidirectional meaning you can use it either as a pattern or a constructor, e.g. I let rec = 123 :*: Just "foo" :*: RNil foo :*: bar :*: RNil = rec  Mnemonic: * for products.-Reflect the type level name of a named value s :-> a to a Text. For example, given  "foo" :-> Int , yields  "foo" :: Text8Extract the value and reflect the name of a named value.1Lens to a particular field of a record using the  functor.For example, given: k type FFoo = "foo" :-> Int type FBar = "bar" :-> String fBar_ :: Proxy FBar fBar_ = Proxy rec ::  0 '[FFoo, FBar] rec = 123 :*: "hello!" :*: Nil Then:  view (rlens fBar_) rec == "hello!" set (rlens fBar_) "goodbye!" rec == 123 :*: "goodbye!" :*: Nil over (rlens fBar_) (map toUpper) rec == 123 :*: "HELLO!" :*: Nil 9Lens to a particular field of a record using any functor.For example, given: k type FFoo = "foo" :-> Int type FBar = "bar" :-> String fBar_ :: Proxy FBar fBar_ = Proxy rec ::  : '[FFoo, FBar] rec = Just 123 :^: Just "hello!" :^: Nil Then:  view (rlens' fBar_) rec == Just "hello!" set (rlens' fBar_) Nothing rec == Just 123 :^: Nothing :^: Nil over (rlens' fBar_) (fmap (map toUpper)) rec == Just 123 :^: Just "HELLO!" :^: Nil  for Rec's.Convert a provably nonempty  ( a) rs to a  a.Given a list of constraints cs, apply some function for each r in the target record type rs, with proof that those constraints hold for r;, generating a record with the result of each application.   !        !55None!!"#$%&*+,/9:;<=?DILOQRTbfh3VMonad transformer which adds an implicit environment which is a record. Isomorphic to ReaderT (Record c) m.6VClass of monad (stacks) which have context reading functionality baked in. Similar to 5 but can coexist with a another monad that provides ) and requires the context to be a record.7.Fetch the context record from the environment.8MRun some action which has the same type of context with the context modified.97Project some value out of the context using a function.:LProject some value out of the context using a lens (typically a field lens).;`Permute the current context with a function and then run some action with that modified context.<!Transform the monad underlying a 3 using a natural transform. 3456789:;<=>?@ABCDEFGHIJKLMNOPQR 3456789:;< 345;<6789:3456789:;<=>?@ABCDEFGHIJKLMNOPQRNone!!"#$%&*+,/9:;<=?DILOQRTbfhW A record of Case' eliminators for each r in rs2 representing the pieces of a total function from a f to b.XAn extractor function f a -> b which can be passed to t, to eliminate one possible alternative of a a.[%Helper newtype containing a function a -> b) but with the type parameters flipped so Op b0 has a consistent codomain for a varying domain.^#Typeclass which allows folding ala  over a  , using a a as the accumulator._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.`The common case of a a with f ~ , i.e. a regular value.a CoRef f rs# represents a single value of type f r for some r in rs.b Witness that r is an element of rs using '"' ( with  ) from Vinyl.cInject a value f r into a a f rs given that r is one of the valid rs.Equivalent to b) the constructor, but exists to parallel e.d/Produce a prism for the given alternative of a a", given a proxy to identify which r you meant.eInject a value r into a ` rs given that r is one of the valid rs.Equivalent to b . .f/Produce a prism for the given alternative of a `", given a proxy to identify which r you meant.g Apply an extraction to whatever f r is contained in the given a. For example -foldCoVal getConst :: CoRec (Const a) rs -> a.hMap a a f to a a g using a natural transform from f to g (forall x. f x -> g x).iApply some kleisli on h to the f x contained in a a f and yank the h outside. Like  but for a.j Project a a f into a  (  f) where only the single r held by the a is 4 in the resulting record, and all other fields are .k Project a ` into a   where only the single r held by the ` is 4 in the resulting record, and all other fields are .l_K for records with at least one field that doesn't require an initial value.mGiven a  (  f) rs , yield a  Just coRec for the first field which is Just, or Nothing if there are no Just fields in the record.nGiven a   rs , yield a  Just field for the first field which is Just, or Nothing if there are no Just fields in the record.oGiven a  (  f) rs , yield a  Just coRec for the last field which is Just, or Nothing if there are no Just fields in the record.pGiven a   rs , yield a  Just field for the last field which is Just, or Nothing if there are no Just fields in the record.qGiven a list of constraints csG required to apply some function, apply the function to whatever value r (not f r ) which the a contains.rGiven a list of constraints csG required to apply some function, apply the function to whatever value r which the ` contains.sGiven some target type r that's a possible value of ` rs, yield Just1 if that is indeed the value being stored by the `, or Nothing if not.tFold a a f using Cases'1 which eliminate each possible value held by the a, yielding the b$ produced by whichever case matches.uFold a a f using Cases'1 which eliminate each possible value held by the a, yielding the b$ produced by whichever case matches.Equivalent to t5 but with its arguments flipped so it can be written matchCoRec coRec $ cases.vFold a ` using S1 which eliminate each possible value held by the `, yielding the b$ produced by whichever case matches.wFold a ` using S1 which eliminate each possible value held by the `, yielding the b$ produced by whichever case matches.Equivalent to t5 but with its arguments flipped so it can be written matchCoRec coRec $ cases.)STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{%STUVWXYZ[\]^_`abcdefghijklmnopqrstuvw)ab{z`cdefghijk^_yxlmnop[\]qrsXYZWtuTUVSvw!STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{None !"#$%&*+,/9:;<=?DILOQRTbfh|Make  definitions for each of the type synonyms in the given block of declarations. The proxies have the same names as the synonyms but with the first letter lowercased. For example: 7 withProxies [d| type FFoo = "foo" :-> Int |] Is equivalent to: @ type FFoo = "foo" :-> Int fFoo :: Proxy FFoo fFoo = Proxy Note: the trailing |]K of the quasi quote bracket has to be indented or a parse error will occur.}Make  and  definitions for each of the type 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 _ suffix. For example: @ withLensesAndProxies [d| type FFoo = "foo" :-> Int |] Is equivalent to:  type FFoo = "foo" :-> Int fFoo :: FFoo " rs => Lens' (Record rs) Int fFoo = rlens fFoo_ fFoo_ :: Proxy FFoo fFoo_ = Proxy Note: the trailing |]K of the quasi quote bracket has to be indented or a parse error will occur.This is equivalent to  but without the prisms.~Make f and  definitions for each of the typep synonyms in the given block of declarations. The prisms have the same names as the synonyms but prefixed with _a. The proxies will have the same name as the synonym but with the first character lowercased and _ appended. For example: @ withPrismsAndProxies [d| type FFoo = "foo" :-> Int |] Is equivalent to:  type FFoo = "foo" :-> Int _FFoo :: FFoo " rs => Prism' (Field rs) Int _FFoo = fieldPrism fFoo_ . _Wrapped fFoo_ :: Proxy FFoo fFoo_ = Proxy Note: the trailing |]K of the quasi quote bracket has to be indented or a parse error will occur.This is equivalent to  but without the prisms.Make , f, and  definitions for each of the type synonyms in the given block of declarations. The lenses have the same names as the synonyms but with the first letter lowercased, e.g. FFoo becomes fFoo;. The prisms have the same names as the synonyms but with _ prepended, e.g. FFoo becomes _FFood. The proxies have the same names as the synonyms but with the first letter lowercase and trailing _, e.g. FFoo becomes fFoo_. For example: @ withOpticsAndProxies [d| type FFoo = "foo" :-> Int |] Is equivalent to:  type FFoo = "foo" :-> Int fFoo :: FFoo " rs => Lens' (Record rs) Int fFoo = rlens fFoo_ _FFoo :: FFoo " rs => Prism' (Field rs) Int _FFoo = fieldPrism fFoo_ . _Wrapped fFoo_ :: Proxy FFoo fFoo_ = Proxy Note: the trailing |]K of the quasi quote bracket has to be indented or a parse error will occur.TH splice which implements }, ~, and |}~|}~|}~ |}~ None !"#$%&*+,/9:;<=?DILOQRTbfh     !"#$%&'()*+,-./0123456789:;<=>??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^__`abbcddefghijklmnopqrstuvwxyz{|}~    -composite-base-0.4.1.0-J16lva6j70tIvBIyYiEDqeComposite.RecordControl.Monad.Composite.ContextComposite.CoRecord Composite.TH Data.VinylrmapControl.Monad.Reader MonadReader Composite"vinyl-0.5.3-AlVcFvvXpE6Bz1gmYs9V5fData.Vinyl.Core:&RNilRec:->ValgetValRElemRecordRecWithContextrmapWithContext ReifyNames reifyNames ValuesAllHaveAllHave HasInstances:^::*:valName valWithNamerlensrlens' zipRecsWithrecordToNonEmpty reifyDicts$fRecWithContextss:$fRecWithContextss[] $fReifyNames:$fReifyNames[] $fShow:-> $fMonad:->$fTraversable:-> $fFoldable:->$fApplicative:-> $fFunctor:-> $fWrapped:->$fRewrapped:->t $fStorable:->$fSemigroup:-> $fRealFrac:->$fRealFloat:-> $fReal:->$fOrd:->$fNum:-> $fMonoid:-> $fIsString:-> $fIntegral:->$fFractional:-> $fFloating:->$fEq:-> $fEnum:-> $fBounded:->ContextT runContextT MonadContext askContext localContext asksContextaskField withContext mapContextT$fMonadMaskContextT$fMonadCatchContextT$fMonadThrowContextT$fMonadContContextT$fMonadPlusContextT$fMonadErroreContextT$fMonadFailContextT$fMonadFixContextT$fMonadRWSrwsContextT$fMonadStatesContextT$fMonadWriterwContextT$fMonadReaderrContextT$fMonadBaseControlbContextT$fMonadBasebContextT$fMonadTransControlContextT$fMonadTransContextT$fMonadIOContextT$fMonadContextT$fAlternativeContextT$fApplicativeContextT$fFunctorContextT$fMonadContextcContextTCasesCaseunCaseCases'Case'unCase'OprunOpFoldRecfoldRecFieldCoRecCoValcoRec coRecPrismfield fieldPrism foldCoValmapCoRec traverseCoRec coRecToRec fieldToRecfoldRec1 firstCoRec firstField lastCoRec lastFieldonCoReconFieldasA foldCoRec matchCoRec foldField matchField $fFoldRecass:$fFoldRecuss[] $fEqCoRec $fShowCoRec withProxieswithLensesAndProxieswithPrismsAndProxieswithOpticsAndProxies#text-1.2.2.1-9Yh8rJoh8fO2JMLWffT3QsData.Text.InternalTextbaseData.Functor.IdentityIdentityGHC.BaseMaybeGHC.ListzipWithData.Vinyl.FunctorConstData.List.NonEmptyNonEmptyD:R:Unwrapped:-> Data.FoldablefoldMapData.Vinyl.LensData.Vinyl.TypeLevelRIndexData.Traversabletraverse:.JustNothing Data.ProxyProxywithBoilerplateFieldDec fieldName fieldBindersfieldTypeAppliedfieldValueType fieldDecMay lensNameFor prismNameFor proxyNameFor proxyDecFor lensDecFor prismDecFor