h&NJc      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred!"%&'()*/015composite-baseSome value of type a 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-baseThe 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-baseBidirectional 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.  let rec = Just 123 :^: Just "foo" :^: RNil Just foo :^: Just bar :^: RNil = rec  Mnemonic: ^- for products (record) of products (functor).composite-baseBidirectional 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.  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 @"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:  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:  type FFoo = "foo" :-> Int type FBar = "bar" :-> String fBar_ :: Proxy FBar fBar_ = Proxy rec ::  : '[FFoo, FBar] rec = Just 123 :^: Just "hello!" :^: Nil Then:  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 composite-base Synonym for composite-baseLens to a particular field of a record using a contravariant functor.For example, given:  type FFoo = "foo" :-> Int type FBar = "bar" :-> String fBar_ :: Proxy FBar fBar_ = Proxy rec ::   Predicate '[FFoo, FBar] rec = Predicate even :!: Predicate (even . length) :!: Nil Then:  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 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 .!composite-baseWiden a record from  rs to   ss(. Note this is just a type constrainted ."composite-base2 which observes that a record with a single field s with value a" is isomorphic to the value alone.#  !"#  !"555 Safe-Inferred!"%&'()*/0158,Bcomposite-baseC specialized to S , i.e. R.Ccomposite-baseConstraint on a pair of types r and s which are  around S f rs and S f ss respectively and observes that those types can be unwrapped and the former can be widened to the latter.Dcomposite-baseConstraint showing that rs E ss$ and giving enough power to widen a S f rs to S f ss.Icomposite-base A record of Case' eliminators for each r in rs2 representing the pieces of a total function from S f to b.Jcomposite-baseAn extractor function f a -> b which can be passed to h, to eliminate one possible alternative of a S.Mcomposite-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.Pcomposite-base#Typeclass which allows folding ala  over a  , using a S as the accumulator.Qcomposite-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.Rcomposite-baseThe common case of a S with f ~ , i.e. a regular value.Scomposite-base CoRef f rs# represents a single value of type f r for some r in rs.Tcomposite-base Witness that r is an element of rs using  ( with  ) from Vinyl.Ucomposite-baseInject a value f r into a S f rs given that r is one of the valid rs.Equivalent to T) the constructor, but exists to parallel W.Vcomposite-base/Produce a prism for the given alternative of a S.Wcomposite-baseInject a value r into a R rs given that r is one of the valid rs.Equivalent to T . .Xcomposite-baseInject a value a into a R rs given that s :-> a is one of the valid rs.Equivalent to T .  . .Ycomposite-base/Produce a prism for the given alternative of a R.Zcomposite-baseProduce a prism for the given :-> alternative of a R", given a proxy to identify which s :-> a you meant.[composite-base Apply an extraction to whatever f r is contained in the given S. For example -foldCoVal getConst :: CoRec (Const a) rs -> a.\composite-baseMap a S f to a S g using a natural transform from f to g (forall x. f x -> g x).]composite-baseApply some kleisli on h to the f x contained in a S f and yank the h outside. Like  but for S.^composite-base Project a S f into a  (  f) where only the single r held by the S is 4 in the resulting record, and all other fields are ._composite-base Project a R into a   where only the single r held by the R is 4 in the resulting record, and all other fields are .`composite-baseQ for records with at least one field that doesn't require an initial value.acomposite-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.bcomposite-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.ccomposite-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.dcomposite-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.ecomposite-baseGiven a list of constraints cs required to apply some function, apply the function to whatever value r (not f r ) which the S contains.fcomposite-baseGiven a list of constraints cs required to apply some function, apply the function to whatever value r which the R contains.gcomposite-baseGiven some target type r that's a possible value of R rs, yield Just1 if that is indeed the value being stored by the R, or Nothing if not.hcomposite-baseFold a S f using Cases'1 which eliminate each possible value held by the S, yielding the b$ produced by whichever case matches.icomposite-baseFold a S f using Cases'1 which eliminate each possible value held by the S, yielding the b$ produced by whichever case matches.Equivalent to h5 but with its arguments flipped so it can be written matchCoRec coRec $ cases.jcomposite-baseFold a R using E1 which eliminate each possible value held by the R, yielding the b$ produced by whichever case matches.kcomposite-baseFold a R using E1 which eliminate each possible value held by the R, yielding the b$ produced by whichever case matches.Equivalent to h5 but with its arguments flipped so it can be written matchCoRec coRec $ cases.lcomposite-baseWiden a S f rs to a S f ss given that rs E ss.mcomposite-baseWiden a R rs to a R ss given that rs E ss.ncomposite-baseWiden a S f rs wrapped in r to a S f ss wrapped in s.ocomposite-baseWiden a R rs wrapped in r to a R ss wrapped in s.pcomposite-baseWiden a wrapped S using n and then throw it as an $ error, as a convenience when using S / R* for building up error types by set union.qcomposite-baseCatch a wrapped S thrown by an  and widen it using n. then rethrow it, as a convenience when using S / R* for building up error types by set union.rcomposite-baseSpecialized type of F for , with the type parameters in a convenient order for type application, e.g.:  valCase !"foo" ( a -> ...) :& valCase "bar" ( b -> ...) :& RNil scomposite-baseSpecialized type of J for , with the type parameters in a convenient order for type application, e.g.:  valCase' #"foo" ( fa -> ...) :& valCase' "bar" ( fb -> ...) :& RNil tcomposite-baseMake a F* which yields the symbol text for a field s :-> (). E.g.: 2 keywordCase @"foo" (Identity (Val ())) == "foo" ucomposite-baseMake a J* which yields the symbol text for a field s :-> ()/ as projected through the given function. E.g.:  keywordCase @"foo" (<> "bar") (Identity (Val ())) == "foobar" 4BCDEFHGIJLKMONPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu4STRUVWXYZ[\]^_PQ`abcdMONefgJLKIhiFHGEjklmDCBnopqrstu Safe-Inferred "%&'()*/0159j#  !" Safe-Inferred!"%&'()*/015El|composite-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 |] of the quasi quote bracket has to be indented or a parse error will occur.}composite-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 D rs => Lens' (Record rs) Int fFoo = rlens fFoo_ fFoo_ :: Proxy FFoo fFoo_ = Proxy Note: the trailing |] of the quasi quote bracket has to be indented or a parse error will occur.This is equivalent to  but without the prisms.~composite-baseMake Z and  definitions for each of the type synonyms in the given block of declarations. The prisms have the same names as the synonyms but prefixed with _. 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 D rs => Prism' (Field rs) Int _FFoo = fieldValPrism fFoo_ fFoo_ :: Proxy FFoo fFoo_ = Proxy Note: the trailing |] of the quasi quote bracket has to be indented or a parse error will occur.This is equivalent to  but without the prisms.composite-baseMake , Z, 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 _FFoo. 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 D rs => Lens' (Record rs) Int fFoo = rlens fFoo_ _FFoo :: FFoo D rs => Prism' (Field rs) Int _FFoo = fieldValPrism fFoo_ fFoo_ :: Proxy FFoo fFoo_ = Proxy Note: the trailing |] of the quasi quote bracket has to be indented or a parse error will occur.composite-baseTH splice which implements }, ~, and |}~|}~ Safe-Inferred""%&'()*/015I composite-baseMonad transformer which adds an implicit environment which is a record. Isomorphic to ReaderT (Record c) m.composite-baseClass 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.composite-base.Fetch the context record from the environment.composite-baseRun some action which has the same type of context with the context modified.composite-base7Project some value out of the context using a function.composite-baseProject some value out of the context using a lens (typically a field lens).composite-base2Run some action in a given context, equivalent to  but with the arguments flipped.composite-basePermute the current context with a function and then run some action with that modified context.composite-base!Transform the monad underlying a  using a natural transform.    Safe-Inferred!"%&'()*/015JN    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSSTUVVWXXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                -composite-base-0.8.2.2-Flokrj56sGIFpBwsihZJZNComposite.RecordComposite.CoRecord Composite.THControl.Monad.Composite.ContextData.Vinyl.Lensrcast CompositeControl.Monad.Reader MonadReaderPaths_composite_base#vinyl-0.14.3-9KWyyXbnBAN5NWp1C4ORkcData.Vinyl.Core:&RNilRec:->ValgetValRElemRecord_Val RDeletableRDeleteRecWithContextrmapWithContext ReifyNames reifyNames ValuesAllHaveAllHave HasInstances:!::^::*:valvalName valWithNamereifyValrlensrlensCorlens' rlensContra zipRecsWithrecordToNonEmpty reifyDictsrdeleterwiden _SingleVal$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:->WrappedWiderFieldWrappedWiderCoRec WiderCoRecCasesCaseunCaseCases'Case'unCase'OprunOpFoldRecfoldRecFieldCoRecCoValcoRec coRecPrismfieldfieldVal fieldPrism fieldValPrism foldCoValmapCoRec traverseCoRec coRecToRec fieldToRecfoldRec1 firstCoRec firstField lastCoRec lastFieldonCoReconFieldasA foldCoRec matchCoRec foldField matchField widenCoRec widenFieldwidenWrappedCoRecwidenWrappedField throwWidenedrethrowWidenedvalCasevalCase' keywordCase keywordCase' $fEqCoRec $fFoldRecass:$fFoldRecuss[] $fShowCoRec$fContravariantCase'$fContravariantCase withProxieswithLensesAndProxieswithPrismsAndProxieswithOpticsAndProxiesContextT runContextT MonadContext askContext localContext asksContextaskField runInContext withContext mapContextT$fMonadContextcRWST$fMonadContextcRWST0$fMonadContextcContT$fMonadContextcExceptT$fMonadContextcIdentityT$fMonadContextcStateT$fMonadContextcStateT0$fMonadContextcWriterT$fMonadContextcWriterT0$fMonadContextcMaybeT$fMonadContextcReaderT$fMonadContextcFUN$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.IdentityIdentityrmap text-1.2.5.0Data.Text.InternalText GHC.MaybeMaybeGHC.ListzipWithData.Vinyl.FunctorConstGHC.BaseNonEmpty rdowncast!lens-5.2.3-3cXTu36AL3ZDwyqobMNc8qControl.Lens.TypeIsoControl.Lens.WrappedWrapped Data.FoldablefoldMap∈Data.Traversabletraverse:.JustNothingtransformers-0.5.6.2Control.Monad.Trans.ExceptExceptT Data.ProxyProxywithBoilerplateversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir