!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None!"#$%&',-.1=>?@ACHMPSUVXgkmSkcomposite-baseSome value of type ab tagged with a symbol indicating its field name or label. Used as the usual type of elements in a  or .&Recommended pronunciation: record val.composite-baseConstraint expressing that r is in rs and providing the index of r in rs . Equal to  rs ( r rs).composite-baseIThe type of regular plain records where each field has a value, equal to  . composite-base*Constraint which reflects that an element r can be removed from rs using . composite-base.Type function which removes the first element r from a list rs, and doesn't expand if r is not present in rs. composite-base Class with | but which gives the natural transformation evidence that the value its working over is contained within the overall record ss. composite-base$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. composite-base8Class which reifies the symbols of a record composed of  fields as .composite-baseGiven a  f rs where each r in rs is of the form s  a, make a record which adds the  for each s.composite-base>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)composite-base>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)composite-base-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).composite-baseABidirectional 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).composite-baseABidirectional 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.composite-base Convenience function to make an  (s  a)= with a particular symbol, used for named field construction. For example:  type FFoo = "foo" :-> Int type FBar = "bar" :-> String type FBaz = "baz" :-> Double type MyRecord = [FFoo, FBar, FBaz] myRecord1 :: Record MyRecord myRecord1 = val "foo" 123 :& val "bar" "foobar" :& val V"baz" 3.21 :& RNil myRecord2 :: Record MyRecord myRecord2 = rcast $ val "baz" 3.21 :& val "foo" 123 :& val "bar" "foobar" :& RNil In this example, both  myRecord1 and  myRecord2 have the same value, since  can reorder records.composite-base-Reflect the type level name of a named value s :-> a to a Text. For example, given  "foo" :-> Int , yields  "foo" :: Textcomposite-base8Extract the value and reflect the name of a named value.composite-baseReify the type of a val.composite-base1Lens 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 composite-base9Lens 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 composite-base for Rec's.composite-baseConvert a provably nonempty  ( a) rs to a  a.composite-baseGiven 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.composite-baseRemove an element r from a  f rs'. Note this is just a type constrained .   55None!"#$%&',-.1=>?@ACHMPSUVXgkm@!Acomposite-base A record of Case' eliminators for each r in rs2 representing the pieces of a total function from K f to b.Bcomposite-baseAn extractor function f a -> b which can be passed to `, to eliminate one possible alternative of a K.Ecomposite-base%Helper newtype containing a function a -> b) but with the type parameters flipped so Op b0 has a consistent codomain for a varying domain.Hcomposite-base#Typeclass which allows folding ala  over a  , using a K as the accumulator.Icomposite-baseGiven 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.Jcomposite-baseThe common case of a K with f ~ , i.e. a regular value.Kcomposite-base CoRef f rs# represents a single value of type f r for some r in rs.Lcomposite-base Witness that r is an element of rs using  ( with  ) from Vinyl.Mcomposite-baseInject a value f r into a K f rs given that r is one of the valid rs.Equivalent to L) the constructor, but exists to parallel O.Ncomposite-base/Produce a prism for the given alternative of a K.Ocomposite-baseInject a value r into a J rs given that r is one of the valid rs.Equivalent to L . .Pcomposite-baseInject a value a into a J rs given that s :-> a is one of the valid rs.Equivalent to L .  . .Qcomposite-base/Produce a prism for the given alternative of a J.Rcomposite-baseProduce a prism for the given :-> alternative of a J", given a proxy to identify which s :-> a you meant.Scomposite-base Apply an extraction to whatever f r is contained in the given K. For example -foldCoVal getConst :: CoRec (Const a) rs -> a.Tcomposite-baseMap a K f to a K g using a natural transform from f to g (forall x. f x -> g x).Ucomposite-baseApply some kleisli on h to the f x contained in a K f and yank the h outside. Like  but for K.Vcomposite-base Project a K f into a  (  f) where only the single r held by the K is 4 in the resulting record, and all other fields are .Wcomposite-base Project a J into a   where only the single r held by the J is 4 in the resulting record, and all other fields are .Xcomposite-baseIK for records with at least one field that doesn't require an initial value.Ycomposite-baseGiven 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.Zcomposite-baseGiven a   rs , yield a  Just field for the first field which is Just, or Nothing if there are no Just fields in the record.[composite-baseGiven 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.\composite-baseGiven a   rs , yield a  Just field for the last field which is Just, or Nothing if there are no Just fields in the record.]composite-baseGiven a list of constraints csG required to apply some function, apply the function to whatever value r (not f r ) which the K contains.^composite-baseGiven a list of constraints csG required to apply some function, apply the function to whatever value r which the J contains._composite-baseGiven some target type r that's a possible value of J rs, yield Just1 if that is indeed the value being stored by the J, or Nothing if not.`composite-baseFold a K f using Cases'1 which eliminate each possible value held by the K, yielding the b$ produced by whichever case matches.acomposite-baseFold a K f using Cases'1 which eliminate each possible value held by the K, yielding the b$ produced by whichever case matches.Equivalent to `5 but with its arguments flipped so it can be written matchCoRec coRec $ cases.bcomposite-baseFold a J using =1 which eliminate each possible value held by the J, yielding the b$ produced by whichever case matches.ccomposite-baseFold a J using =1 which eliminate each possible value held by the J, yielding the b$ produced by whichever case matches.Equivalent to `5 but with its arguments flipped so it can be written matchCoRec coRec $ cases.dcomposite-baseWiden a K f rs to a K f ss given that rs " ss.ecomposite-baseWiden a J rs to a J ss given that rs " ss.)=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde)KLJMNOPQRSTUVWHIXYZ[\EFG]^_BCDA`a>?@=bcde None "#$%&',-.1=>?@ACHMPSUVXgkm None "#$%&',-.1=>?@ACHMPSUVXgkmjcomposite-baseMake  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.kcomposite-baseMake  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 m but without the prisms.lcomposite-baseMake R 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 = fieldValPrism 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 m but without the prisms.mcomposite-baseMake , R, 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 = fieldValPrism 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.composite-baseTH splice which implements k, l, and mjklmjklmNone""#$%&',-.1=>?@ACHMPSUVXgkm. ncomposite-baseVMonad transformer which adds an implicit environment which is a record. Isomorphic to ReaderT (Record c) m.qcomposite-baseVClass 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.rcomposite-base.Fetch the context record from the environment.scomposite-baseMRun some action which has the same type of context with the context modified.tcomposite-base7Project some value out of the context using a function.ucomposite-baseLProject some value out of the context using a lens (typically a field lens).vcomposite-base2Run some action in a given context, equivalent to p but with the arguments flipped.wcomposite-base`Permute the current context with a function and then run some action with that modified context.xcomposite-base!Transform the monad underlying a n using a natural transform. nopqrstuvwx nopvwxqrstu None!"#$%&',-.1=>?@ACHMPSUVXgkm    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMMNOPPQRRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzz{|}~       -composite-base-0.7.4.0-4VUx68GeZvBCuOuNzxiWc5Composite.RecordComposite.CoRecord Composite.THControl.Monad.Composite.Context Data.VinylrmapData.Vinyl.Lensrcast CompositeControl.Monad.Reader MonadReaderPaths_composite_base#vinyl-0.13.0-85P9x7eT4R9ILQKoq4J8eaData.Vinyl.Core:&RNilRec:->ValgetValRElemRecord_Val RDeletableRDeleteRecWithContextrmapWithContext ReifyNames reifyNames ValuesAllHaveAllHave HasInstances:^::*:valvalName valWithNamereifyValrlensrlens' zipRecsWithrecordToNonEmpty reifyDictsrdelete$fIsoHKDTYPEIdentity:-> $fShow:-> $fNFDataRec $fNFDataRec0 $fNFData:-> $fMonad:->$fTraversable:-> $fFoldable:->$fApplicative:-> $fFunctor:-> $fWrapped:->$fRewrapped:->t $fReifyNames:$fReifyNames[]$fRecWithContextss:$fRecWithContextss[] $fStorable:->$fSemigroup:-> $fRealFrac:->$fRealFloat:-> $fReal:->$fOrd:->$fNum:-> $fMonoid:-> $fIsString:-> $fIntegral:->$fFractional:-> $fFloating:->$fEq:-> $fEnum:-> $fBounded:->CasesCaseunCaseCases'Case'unCase'OprunOpFoldRecfoldRecFieldCoRecCoValcoRec coRecPrismfieldfieldVal fieldPrism fieldValPrism foldCoValmapCoRec traverseCoRec coRecToRec fieldToRecfoldRec1 firstCoRec firstField lastCoRec lastFieldonCoReconFieldasA foldCoRec matchCoRec foldField matchField widenCoRec widenField $fEqCoRec $fFoldRecass:$fFoldRecuss[] $fShowCoRec withProxieswithLensesAndProxieswithPrismsAndProxieswithOpticsAndProxiesContextT runContextT MonadContext askContext localContext asksContextaskField runInContext withContext mapContextT$fMonadContextcRWST$fMonadContextcRWST0$fMonadContextcContT$fMonadContextcExceptT$fMonadContextcIdentityT$fMonadContextcStateT$fMonadContextcStateT0$fMonadContextcWriterT$fMonadContextcWriterT0$fMonadContextcMaybeT$fMonadContextcReaderT$fMonadContextc->$fMonadMaskContextT$fMonadCatchContextT$fMonadThrowContextT$fMonadContContextT$fMonadPlusContextT$fMonadErroreContextT$fMonadFailContextT$fMonadFixContextT$fMonadRWSrwsContextT$fMonadStatesContextT$fMonadWriterwContextT$fMonadReaderrContextT$fMonadUnliftIOContextT$fMonadBaseControlbContextT$fMonadBasebContextT$fMonadTransControlContextT$fMonadTransContextT$fMonadIOContextT$fMonadContextT$fAlternativeContextT$fApplicativeContextT$fFunctorContextT$fMonadContextcContextTData.Vinyl.TypeLevelRIndexbaseData.Functor.IdentityIdentity text-1.2.3.1Data.Text.InternalText GHC.MaybeMaybeGHC.ListzipWithData.Vinyl.FunctorConstGHC.BaseNonEmpty Data.FoldablefoldMap∈Data.Traversabletraverse:.JustNothing Data.ProxyProxywithBoilerplateversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName