h$B      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                     None /None'(-./>?vinylThis class is used for consMatchCoercion with older versions of GHC. vinylApply a type constructor to each element of a type level list using ApplyOn. vinylApply a type constructor to a record index. Record indexes are either  or (Symbol, ). In the latter case, the type constructor is applied to the second component of the tuple. vinylConstraint that all types in a type-level list satisfy each constraint from a list of constraints.AllAllSat cs ts should be equivalent to $AllConstrained (AllSatisfied cs) ts5 if partial application of type families were legal. vinylConstraint that each Constraint in a type-level list is satisfied by a particular type. vinylConstraint that all types in a type-level list satisfy a constraint.vinylAppend for type-level lists.vinyl=A constraint-former which applies to every field in a record.vinylReify a list of type-level natural number indices as runtime s relying on instances of .vinylProduce a runtime  value corresponding to a  type.vinylA mere approximation of the natural numbers. And their image as lifted by  -XDataKinds+ corresponds to the actual natural numbers.  None'(./25678>$vinylA value with a phantom  label. It is not a Haskell /, but it is used in many of the same places a  is used in vinyl.Morally: newtype ElField (s, t) = Field t But GHC doesn't allow that0vinylUsed this instead of 3( to make a record lazy in its fields.3vinylThis is identical to the Identity from Data.Functor.Identity in "base" except for its  instance.6vinylApply a function to a value whose type is the application of the *( type constructor. This works under the * newtype wrapper.$%&'()*+,-./0123456345012-./$%*+,6)&'()9  Trustworthy'(-./>?#2fvinylAllRepsMatch f xs g ys means that xs and ys* have the same lengths, and that mapping f over xs and g over ys2 produces lists whose corresponding elements are 3 with each other. For example, the following hold:*AllRepsMatch Proxy '[1,2,3] Proxy '[4,5,6] :AllRepsMatch Sum '[Int,Word] Identity '[Min Int, Max Word]jvinylBuild a record whose elements are derived solely from a list of constraint constructors satisfied by each.lvinyl/Capture a type class instance dictionary. See  for a way to obtain a l value from an n constraint.nvinylBuild a record whose elements are derived solely from a constraint satisfied by each.pvinyl$Sometimes we may know something for all8 fields of a record, but when you expect to be able to each8 of the fields, you are then out of luck. Surely given  Dx:u.(x) we should be able to recover  x:u E (x)! Sadly, the constraint solver is not quite smart enough to realize this and we must make it patently obvious by reifying the constraint pointwise with proof.rvinyl3Wrap up a value with a capability given by its typetvinyl7A record with uniform fields may be turned into a list.vvinylMap each element of a record to a monoid and combine the results.xvinylGiven a section of some functor, records in that functor of any size are inhabited.zvinylA record of components  f r -> g r may be applied to a record of f to get a record of g.|vinyl~ _ rs with labels in kind u gives rise to a functor Hask^u -> Hask; that is, a natural transformation between two interpretation functors f,g' may be used to transport a value from ~ f rs to ~ g rs.~vinyl(A record is parameterized by a universe u, an interpretation f and a list of rows rs. The labels or indices of the record are given by inhabitants of the kind u"; the type of values at any label r :: u! is given by its interpretation f r :: *.vinyl#Two records may be pasted together.vinylA shorthand for .vinylCombine two records by combining their fields using the given function. The first argument is a binary operation for combining two values (e.g. ), the second argument takes a record field into the type equipped with the desired operation, the third argument takes the combined value back to a result type.vinylA shorthand for }.vinylAn inverted shorthand for }.vinylA shorthand for {.vinylA record may be traversed with respect to its interpretation functor. This can be used to yank (some or all) effects from the fields of the record to the outside of the record.vinylWhile 6 pulls the interpretation functor out of the record,  pushes the interpretation functor in to each field type. This is particularly useful when you wish to discharge that interpretation on a per-field basis. For instance, rather than a  Rec IO '[a,b], you may wish to have a Rec Identity '[IO a, IO b] so that you can evaluate a single field to obtain a value of type Rec Identity '[a, IO b].vinyl>Push an outer layer of interpretation functor into each field.vinyl3Given a natural transformation from the product of f and g to h8, we have a natural transformation from the product of ~ f and ~ g to ~ h. You can also think about this operation as zipping two records with the same element types but different interpretations.vinyl3A useful technique is to use 'rmap (Pair (DictOnly MyClass))' on a ~6 to pair each field with a type class dictionary for MyClass@. This helper can then be used to eliminate the original.vinylGiven that for each element x in the list xs,vinyl Hask; that is, a natural transformation between two interpretation functors f,g' may be used to transport a value from ~ f rs to ~ g rs.vinylA shorthand for .vinylAn inverted shorthand for .vinylA record of components  f r -> g r may be applied to a record of f to get a record of g.vinylA shorthand for .vinylA record may be traversed with respect to its interpretation functor. This can be used to yank (some or all) effects from the fields of the record to the outside of the record.vinyl3Given a natural transformation from the product of f and g to h8, we have a natural transformation from the product of ~ f and ~ g to ~ h. You can also think about this operation as zipping two records with the same element types but different interpretations.vinylMap each element of a record to a monoid and combine the results.vinyl7A record with uniform fields may be turned into a list.vinyl$Sometimes we may know something for all8 fields of a record, but when you expect to be able to each8 of the fields, you are then out of luck. Surely given  Dx:u.(x) we should be able to recover  x:u E (x)! Sadly, the constraint solver is not quite smart enough to realize this and we must make it patently obvious by reifying the constraint pointwise with proof.vinylBuild a record whose elements are derived solely from a constraint satisfied by each.vinylBuild a record whose elements are derived solely from a list of constraint constructors satisfied by each.None-./>?9vinylA non-unicode equivalent of (D).vinylA non-unicode equivalent of (E).vinylA shorthand for  which supplies its images.vinylA shorthand for  which supplies its image.vinylA shorthand for  which supplies its index.vinylTwo record types are equivalent when they are subtypes of each other.vinylIf one field set is a subset another, then a lens of from the latter's record to the former's is evident. That is, we can either cast a larger record to a smaller one, or we may replace the values in a slice of a record.vinylAn opportunity for instances to generate constraints based on the functor parameter of records passed to class methods.vinylThis is a lens into a slice of the larger record. Morally, we have: &rsubset :: Lens' (Rec f ss) (Rec f rs)vinylThe getter of the  lens is , which takes a larger record to a smaller one by forgetting fields.vinylThe setter of the  lens is , which allows a slice of a record to be replaced with different values.vinyl for classic vinyl ~ types.vinylThe presence of a field in a record is witnessed by a lens into its value. The fifth parameter to , i, is there to help the constraint solver realize that this is a decidable predicate with respect to the judgemental equality in k.vinylAn opportunity for instances to generate constraints based on the functor parameter of records passed to class methods.vinylWe can get a lens for getting and setting the value of a field which is in a record. As a convenience, we take a proxy argument to fix the particular field being viewed. These lenses are compatible with the lens library. Morally: 3rlensC :: Lens' (Rec f rs) (Rec f rs') (f r) (f r')vinyl&For Vinyl users who are not using the lens package, we provide a getter.vinyl&For Vinyl users who are not using the lens package, we also provide a setter. In general, it will be unambiguous what field is being written to, and so we do not take a proxy argument here.vinylThe type-changing field setter  with the type arguments re-ordered for more convenient usage with TypeApplications.vinylType-preserving field setter. This type is simpler to work with than that of .vinylType-changing field lens  with the type arguments re-ordered for more convenient usage with TypeApplications.vinylType-preserving field lens. This type is simpler to work with than that of .vinyl2A lens into a slice of the larger record. This is  with the type arguments reordered for more convenient usage with TypeApplications.vinylTakes a larger record to a smaller one by forgetting fields. This is  with the type arguments reordered for more convenient usage with TypeApplications.vinylAllows a slice of a record to be replaced with different values. This is  with the type arguments reordered for more convenient usage with TypeApplications.vinyl*Takes a smaller record to a larger one, a downcast, by layering a ! interpretation that lets us use 3 for the fields not present in the smaller record.None9None'(-./0>?Aivinyl(A more concise constraint equivalent to .vinyl1The ability to work with a particular field of a ~ stored at a .vinyl>Get the byte offset of a field from the given origin and the + dictionary needed to work with that field.vinyl Capture a ? dictionary along with a byte offset from some origin address.vinylA simpler type for  whose  and # instances are specialized to the $ functor.vinylA -backed ~. Each field of such a value has statically known size, allowing for a very efficient representation and very fast field access. The 2% suffix is due to apparently taking two functor arguments, but the first type parameter is phantom and exists so that we can write multiple instances of  and  for different functors. The first functor argument will typically be identical to the second argument. We currently provide instances for the $ functor; if you wish to use it at a different type, consider using , , and 7 which work with any functor given that the necessary  instances exist.vinyl Create an  from a ~.vinyl Create an  from a ~. This should offer very fast field access, but note that its lens API (via  and ) is restricted to the $ functor.vinyl Create a ~ from an .vinyl Create a ~ from an .vinyl$Set a field in a record stored at a .vinyl$Get a field in a record stored at a .vinylGet a field from an .vinyl Set a field.vinylA lens for a field of an .vinyl"Get a subset of a record's fields.vinyl"Set a subset of a record's fields.vinylField accessors for  specialized to $ as the functor.NoneA ~ ~None'(-./>?IXvinyl0Defines a constraint that lets us index into an  in order to produce a ~ using .vinyl$An efficient builder for ARec valuesUse the pseudo-constructors  and  to construct an  and then turn it into an  with +Example: (requires -XOverloadedLabels and ) user :: ARec ElField '[ "name" ::: String , "age" ::: Int , "active" ::: Bool] user = arec ( #name =: "Peter" `arcons` #age =: 4 `arcons` #active =: True `arcons` arnil )vinylAn array-backed extensible record with constant-time field access.vinyl Given that xs and ys$ have the same length, and mapping f over xs and g over ys- produces lists whose elements are pairwise ,  ARec f xs and  ARec g ys are .vinyl Given that forall x. Coercible (f x) (g x), produce a coercion from  ARec f xs to  ARec g xs). While the constraint looks a lot like  Coercible f g, it is actually weaker.vinyl Convert a ~ into an  for constant-time field access.vinyl%Pseudo-constructor for an ARecBuilderCons& a field to an ARec under constructionSee vinylPseudo-constructor for Build an ARec without fieldsSee vinyl Turn an ARecBuilder into an ARecSee vinyl Convert an  into a ~.vinylGet a field from an .vinylSet a field in an .vinyl Define a lens for a field of an .vinyl"Get a subset of a record's fields.vinylSet a subset of a larger record's fields to all of the fields of a smaller record.1 TrustworthyI   None'(-./>?SvinylFacilities for removing and replacing the type-level label, or column name, part of a record.vinylRemove the first component (e.g. the label) from a type-level list of pairs.vinyl3Shorthand for working with records of fields as in  and .vinyl=Defines a constraint that lets us extract the label from an $ . Used in  and .vinylProxy for label typevinylConstraint that a label is associated with a particular type in a record.vinylA proxy for field types.vinylHeterogeneous list whose elements are left as-is during list construction (cf. ).vinylHeterogeneous list whose elements are evaluated during list construction.vinylAn 7 of named fields to provide constant-time field access.vinylA record of named fields.vinylAlias for Field specvinylGet the data payload of an $.vinylGet the label name of an $.vinyl$+ is isomorphic to a functor something like Compose ElField ('(,) s).vinylSomething in the spirit of  for $) whose kind fights the standard library.vinyl Lens for an ElField's data payload.vinylOperator for creating an $ . With the -XOverloadedLabels) extension, this permits usage such as,  #foo =: 23 to produce a value of type ElField ("foo" ::: Int).vinyl Get a named field from a record.vinyl:Get the value associated with a named field from a record.vinylSet a named field. rputf' #foo 23 sets the field named #foo to 23.vinyl-Set a named field without changing its type.  rputf #foo 23 sets the field named #foo to 23.vinylA lens into a ~ identified by a .vinylA type-preserving lens into a ~ identified by a .vinyl#A lens into the payload value of a ~ field identified by a .vinyl3A type-preserving lens into the payload value of a ~ field identified by a .vinylShorthand for a  with a single field.vinyl)Map a function between functors across a ~8 taking advantage of knowledge that each element is an $.vinyl Construct a ~ with $ elements.vinylOperator synonym for .vinyl Produce a ~ of the labels of a ~ of $s.&&8 None0>?Vwvinyl-Concise record construction syntax. Example: record ( name "Joe", age 23). instance forall s a b. (KnownSymbol s, b ~ ElField '(s,a)) => IsLabel s (a -> b) where #if 810 < 802 fromLabel _ = Field s a #else fromLabel = Field s  a #endifConcise $ lenses. Example myRec & #name %~ map toUpper.Credit to Tikhon Jelvis who shared this technique on the Haskell-Cafe mailing list on December 23, 2017. None'(-./>?f;vinyl'Handlers ts b', is essentially a list of functions, one for each type in ts. All functions produce a value of type b. Hence, 'Handlers ts b' would represent something like the type-level list: [t -> b | t in ts ]vinyl#Newtype around functions for a to bvinyl#Helper for handling a variant of a : either the function is applied to the variant or the type of the 5 is refined to reflect the fact that the variant is not3 compatible with the type of the would-be handler.vinyl'Fold a field selection function over a ~.vinylHelper for writing a  instance for . This lets us ask for a  constraint on the type formed by applying a type constructor to a type index.vinylA function type constructor that takes its arguments in the reverse order.vinyl A Field of a ~ 3 is a  3.vinylGeneralize algebraic sum types.vinylA  constructor with better inference. If you have a label that should pick out a type from the list of types that index a 3, this function will help you more so than the raw  data constructor.vinylApply a function to a " value. The function must accept any variant.vinylWe can inject a a  into a ~ where every field of the ~ is  except for the one whose type corresponds to the type of the given  variant.vinylShorthand for applying  with common functors.vinyl,Apply a natural transformation to a variant.vinylGet a l from an n instance.vinylLike #, but the function mapped over the  can have a constraint.vinyl*This can be used to pull effects out of a .vinyl1Fold a field selection function over a non-empty ~.vinyl Similar to $: find the first field that is not .vinyl Similar to #: find the last field that is not .vinyl%Apply methods from a type class to a . Intended for use with TypeApplications, e.g. onCoRec @Show show rvinylApply a type class method to a . Intended for use with TypeApplications, e.g. onField @Show show r.vinylCompute a runtime : index identifying the position of the variant held by a  CoRec f ts in the type-level list ts.vinylIf a , is a variant of the requested type, return  that value; otherwise return .vinylLike %, but for any interpretation functor.vinylPattern match on a CoRec by specifying handlers for each case. Note that the order of the Handlers has to match the type level list (t:ts).:{let testCoRec = Col (Identity False) :: CoRec Identity [Int, String, Bool] inmatch testCoRec $? (H $ \i -> "my Int is the successor of " ++ show (i - 1))' :& (H $ \s -> "my String is: " ++ s) :& (H $ \b -> "my Bool is not: " ++ show (not b) ++ " thus it is " ++ show b) :& RNil:}'"my Bool is not: True thus it is False"vinylHandle a single variant of a : either the function is applied to the variant or the type of the 5 is refined to reflect the fact that the variant is not2 compatible with the type of the would-be handlervinylA  is either the first possible variant indicated by its type, or a ) that must be one of the remaining types.vinylA  whose possible types are ts may be used at a type of  whose possible types are t:ts.vinylA  is either the first possible variant indicated by its type, or a  that must be one of the remaining types. The safety is related to that of .vinylLike 3, but implemented more safely and typically slower.vinylLike %, but for any interpretation functor.'' None'(-./>?oQvinyl,Apply a typeclass method to each field of a ~ where the class constrains the field when considered as a value interpreted by the record's interpretation functor.vinyl,Apply a typeclass method to each field of a ~ where the class constrains the index of the field, but not its interpretation functor.vinylGenerate a record from fields derived from type class instances.vinylShorthand for combining  and .vinyl#The interpretation function of the  symbols.vinyl=When we wish to apply a typeclass method to each field of a ~, we typically care about typeclass instances of the record field types irrespective of the record's functor context. To expose the field types themselves, we utilize a constraint built from a defunctionalized type family in the  method. The symbols of the function space are defined by this data type.vinyl(This function differs from the original  in that it takes an argument. In some cases, you will already have a record of the type you are interested in, and that can be passed an the argument. In other situations where this is not the case, you may need the interpretation function of the argument record to be Const () or Proxy. so the you can generate the argument with y.vinyl(This function differs from the original  . See .vinyl(This function differs from the original  . See .vinyl(This function differs from the original  . See .vinyl,Apply a typeclass method to each field of a Rec f ts using the  instance for f to lift the function into the functor. This is a commonly-used specialization of  composed with .vinyl,Apply a typeclass method to each field of a . This is a specialization of .vinylLike 8, but the function between functors may be constrained.vinylPush an outer layer of interpretation functor into each named field. None'(./9>?zZvinylIsomorphism between a syntactically noisy value and a concise one. For types like, 3, we prefer to work with values of the underlying type without writing out the 3 constructor. For * f g a, aka  (f :. g) a2, we prefer to work directly with values of type f (g a).This involves the so-called higher-kinded data type family. See  8http://reasonablypolymorphic.com/blog/higher-kinded-data for more discussion.vinylConversion between  and ~). It is convenient to build and consume ' values to reduce syntactic noise, but ~9 has a richer API that is difficult to build around the  type family.vinylLike rapply: record of components  f r -> g r may be applied to a record of f to get a record of g.vinylThe implementation of  is broken into a type class to permit unrolling of the recursion across a record. The function mapped across the vector hides the  type family under a newtype constructor to help the type checker.vinylA wrapper for an ;-simplified value. That is, noisy value constructors like 3 and *# are ellided. This is used in the  type class method, but may be ignored by users whose needs are met by  and .vinylLike rmap4, but the supplied function is written against the -simplified types. This is  sandwiched in between  and .vinylThis is  specialized to a type at which it does not change interpretation functor. This can help with type inference.vinylThis is rmap for . We apply a natural transformation between interpretation functors to transport a record value between interpretations.vinyl7Record field getter that pipes the field value through  to eliminate redundant newtype wrappings. Usage will typically involve a visible type application to the field type. The definition is similar to, getHKD = toHKD . rget.vinylWork with values of type  a as if they were of type a.vinylWork with values of type  a as if they were of type a.vinylWork with values of type -  (->) f g a as if they were of type  f a -> g a.vinylWork with values of type * f g a as if they were of type f (g a).vinylWork with values of type $ '(s,a) as if they were of type a.vinylWork with values of type 3 a! as if they were simple of type a.7None./>? vinylBuild a ~= from a tuple. An example would be building a value of type  Rec f '[a,b]" from a tuple of values with type  '(f a, f b).vinylConvert between an  and an isomorphic tuple.vinyl Convert an > to a tuple. Useful for pattern matching on an entire record.vinyl Build an  from a tuple.vinyl Apply the : type constructor to a type-level tuple of its arguments.vinyl Apply the ~: type constructor to a type-level tuple of its arguments.vinylConvert a tuple of types formed by the application of a common type constructor to a tuple of the common type constructor and a list of the types to which it is applied in the original tuple. E.g. (TupleToRecArgs f (f a, f b) ~ (f, [a,b]).vinyl Convert a ~ to a tuple going through  to reduce syntactic noise. Useful for pattern matching on an entire ~.vinylBuild a ~ from a tuple passing through 6. This admits the most concise syntax for building a ~. For example, 0xrec ("joe", 23) :: Rec Identity '[String, Int].vinylBuild a FieldRec from a tuple of $ values.vinylBuild a FieldRec from a tuple and  it to another record type that is a subset of the constructed record. This is useful for re-ordering fields. For example,  namedArgs (name =: "joe",  age =: 23) can supply arguments for a function expecting a record of arguments with its fields in the opposite order.vinylOverride a record with fields from a possibly narrower record. A typical use is to supply default values as the first argument, and overrides for those defaults as the second.None$%fghijklmnopqrstuvwxyz{|}~!$%None ./T vinylFor the type-level list ts,  f ts a3 is a curried function type from arguments of type HKD f t for t in ts, to a result of type a.:set -XTypeOperators<:kind! CurriedX (Maybe :. Identity) '[Int, Bool, String] Int:CurriedX (Maybe :. Identity) '[Int, Bool, String] Int :: *0= Maybe Int -> Maybe Bool -> Maybe [Char] -> IntvinylFor the type-level list ts,  f ts a3 is a curried function type from arguments of type f t for t in ts, to a result of type a..:kind! CurriedF Maybe '[Int, Bool, String] Int,CurriedF Maybe '[Int, Bool, String] Int :: *0= Maybe Int -> Maybe Bool -> Maybe [Char] -> IntvinylFor the list of types ts,  ts a7 is a curried function type from arguments of types in ts to a result of type a.':kind! Curried '[Int, Bool, String] Int%Curried '[Int, Bool, String] Int :: *= Int -> Bool -> [Char] -> IntvinylN-ary version of  over pure records.Example specialized signatures:  rcurry' :: (Rec Identity '[Int, Double] -> Bool) -> Int -> Double -> Bool rcurry' :: (Rec Identity '[Double, String, ()] -> Int) -> Double -> String -> () -> Int rcurry' :: (Rec Identity '[] -> Bool) -> Bool vinylN-ary version of  over functorial records.Example specialized signatures:  rcurry :: (Rec Maybe '[Int, Double] -> Bool) -> Maybe Int -> Maybe Double -> Bool rcurry :: (Rec (Either Int) '[Double, String, ()] -> Int) -> Either Int Double -> Either Int String -> Either Int () -> Int rcurry :: (Rec f '[] -> Bool) -> Bool vinylN-ary version of  over functorial records.Example specialized signatures: runcurry :: (Maybe Int -> Maybe Double -> String) -> Rec Maybe '[Int, Double] -> String runcurry :: (IO FilePath -> String) -> Rec IO '[FilePath] -> String runcurry :: Int -> Rec f '[] -> Int vinylN-ary version of  over pure records.Example specialized signatures: runcurry' :: (Int -> Double -> String) -> Rec Identity '[Int, Double] -> String runcurry' :: Int -> Rec Identity '[] -> Int Example usage: f :: Rec Identity '[Bool, Int, Double] -> Either Int Double f = runcurry' $ b x y -> if b then Left x else Right y vinyl"Apply an uncurried function to an .vinyl!Apply an uncurried function to a ~ like 6 except the function enjoys a type simplified by the 5 machinery that strips away type-induced noise like 3, *, and $.vinyl0Lift an N-ary function to work over a record of  computations.)runcurryA' (+) (Just 2 :& Just 3 :& RNil)Just 5*runcurryA' (+) (Nothing :& Just 3 :& RNil)Nothingvinyl%Lift an N-ary function over types in g to work over a record of *d ) computations. A more general version of .Example specialized signatures: runcurryA :: (g x -> g y -> a) -> Rec (Compose Maybe g) '[x, y] -> Maybe a   !"#$%&'()*+,-./0123456789:;<<=>??@AABCCDEEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}}~|                                                             ;                                                                                                         #vinyl-0.14.2-1MAnS7kLKoRIFQ86daMHmp#Data.Vinyl.ARec.Internal.SmallArrayData.Vinyl.TypeLevelData.Vinyl.FunctorData.Vinyl.CoreData.Vinyl.RecursiveData.Vinyl.LensData.Vinyl.SRecData.Vinyl.ARec.InternalData.Vinyl.DerivedData.Vinyl.SyntaxData.Vinyl.CoRecData.Vinyl.Class.MethodData.Vinyl.XRecData.Vinyl.FromTupleData.Vinyl.CurrygetDictData.Vinyl.Tutorial.OverviewData.Vinyl.NotationData.Vinyl.ARec Data.MonoidFirstLast Data.VinylSmallMutableArray SmallArrayindexSmallArraywithNewSmallArraywriteSmallArraywithThawedSmallArraySimilarMapTyCon ApplyToField AllAllSat AllSatisfiedAllConstrained++RecAllRDeleteRImageRIndexRLengthSndFstIndexWitnessesindexWitnessesNatToIntnatToIntNatZS $fNatToIntS $fNatToIntZ$fIndexWitnesses:$fIndexWitnesses[]$fAllSatisfied[]k:t$fAllSatisfied[]k[]t$fSimilarkkfgxElFieldFieldConstgetConst:.Compose getComposeLiftgetLiftThunkgetThunkIdentity getIdentity onCompose$fShowIdentity$fMonadIdentity$fApplicativeIdentity $fShowThunk $fMonadThunk$fApplicativeThunk$fApplicativeLift $fFunctorLift$fFunctorLift0 $fShowCompose$fApplicativeCompose$fTraversableCompose$fFoldableCompose$fFunctorCompose$fMonoidCompose$fSemigroupCompose $fEqConst $fShowConst$fStorableElField $fShowElField$fRealFracElField$fFloatingElField$fFractionalElField $fRealElField$fMonoidElField$fSemigroupElField $fNumElField$fGenericElField$fFunctorConst$fFoldableConst$fTraversableConst$fStorableConst$fGenericConst$fStorableCompose$fGenericCompose$fFunctorThunk$fFoldableThunk$fTraversableThunk$fFunctorIdentity$fFoldableIdentity$fTraversableIdentity$fStorableIdentity $fEqIdentity $fOrdIdentity$fGenericIdentity $fOrdElField $fEqElField AllRepsMatch AllRepsMatch_TailHeadRPureConstraintsrpureConstraintsDictOnlyRPureConstrainedrpureConstrainedReifyConstraintreifyConstraintDict RecordToList recordToListRFoldMap rfoldMapAuxRecApplicativerpureRApplyrapplyRMaprmapRecRNil:&rappend<+>rcombine<<$>><<&>><<*>> rtraverse rtraverseIn rsequenceInrzipWithrfoldMapwithPairedDictrepsMatchCoercionconsMatchCoercion $fGenericRec $fGenericRec0 $fStorableRec$fStorableRec0$fOrdRec $fOrdRec0$fEqRec$fEqRec0 $fMonoidRec $fMonoidRec0$fSemigroupRec$fSemigroupRec0$fTestCoercion[]Rec$fTestEquality[]Rec$fRMapu: $fRMapu[] $fRApplyu: $fRApplyu[]$fRecApplicativeu:$fRecApplicativeu[] $fRFoldMapu: $fRFoldMapu[]$fRecordToListu:$fRecordToListu[] $fNFDataRec $fShowRec$fReifyConstraintacf:$fReifyConstraintucf[]$fRPureConstrainedac:$fRPureConstraineduc[]$fRPureConstraintskucs:$fRPureConstraintskucs[]:~:<:≅⊆∈ REquivalentRSubset RecSubset RecSubsetFCtxrsubsetCrcastC rreplaceCRElemRecElem RecElemFCtxrlensCrgetCrputCrgetrput'rputrlens'rlensrsubsetrcastrreplace rdowncast$fRecElemaRecrr'::S$fRecElemaRecrr'::Z$fRecSubsetkkRec[]ss[]$fRecSubsetkkRec:ss: FieldOffsetFieldOffsetAux fieldOffset StorableAtSRecSRecNT getSRecNTSRec2toSRec2toSRec fromSRec2fromSRec pokeField peekFieldsgetsputslens srecGetSubset srecSetSubset$fFieldOffsetAuxaf:tS$fFieldOffsetAuxaf:tZ$fRecSubset(,)(,)SRecrsssis$fRecSubset(,)(,)SRec2rsssis$fRecElem(,)SRectttstsi$fRecElem(,)SRec2tttstsi$fFieldOffsetkftstIndexableField ARecBuilderToARecARecarecRepsMatchCoercionarecConsMatchCoerciontoARecarconsarnilarecfromARecaget unsafeAput unsafeAlens arecGetSubset arecSetSubset$fRecSubsetkkARecrsssis$fRecElemaARectt'::S$fRecElemaARectt'::Z $fToAReck: $fToAReck[] $fOrdARec$fEqARec $fShowARec$fIndexableFieldktstStripFieldNames stripNames stripNames' withNames withNames' Unlabeled AllFields KnownFieldLabelHasField FieldTypeSField LazyHListHList AFieldRecFieldRec:::getFieldgetLabelfieldMap traverseFieldrfield=:rgetfrvalfrputf'rputfrlensfL'rlensfLrlensf'rlensf=:=rmapfrpuref<<$$>>rlabels $fShowSField $fOrdSField $fEqSField$fIsLabelsLabel$fKnownFieldk(,)$fStripFieldNames:$fStripFieldNames[] $fEqLabel $fShowLabel $fIsLabels->HandlersHandlerHMatch1match1'FoldRecfoldRecShowFshowfOprunOpCoReccorec foldCoRec coRecToRec coRecToRec'coRecMap coRecMapC coRecTraversefoldRec1 firstField lastFieldonCoReconFieldvariantIndexOfasAasA'matchmatch1matchNil restrictCoRec weakenCoRecrestrictCoRecSafeasASafeasA'Safe $fEqCoRec $fShowCoRec $fShowFkfa $fFoldRecass:$fFoldReckss[] $fMatch1t:S $fMatch1t:Z RecMapMethod1 rmapMethod1 RecMapMethod rmapMethod RecPointed rpointMethod PayloadTypeApplyFieldTyper FieldTyperrecEq recCompare recMempty recMappend recMconcatrecAdd recSubtract recMultiplyrecAbs recSignum recNegate recMinBound recMaxBound rmapMethodF mapFieldsrtraverseInMethodrsequenceInFields$fRecPointedacf:$fRecPointeducf[]$fRecMapMethodacf:$fRecMapMethoducf[]$fRecMapMethod1acf:$fRecMapMethod1ucf[]IsoHKDHKDunHKDtoHKDIsoXRecfromXRectoXRecXRApplyxrapplyXRMapxrmapAuxXDataunXXRecXRNil::&rmapX rmapXEndoxrmaprgetX$fIsoHKDTYPEProducta$fIsoHKDTYPESuma$fIsoHKDTYPE(,)b$fIsoHKDTYPELasta$fIsoHKDTYPEFirsta$fIsoHKDTYPEMaybea$fIsoHKDTYPEEitherb$fIsoHKDTYPEIOa$fIsoHKDkLifta$fIsoHKDkComposea$fIsoHKD(,)ElField(,)$fIsoHKDTYPEIdentitya $fIsoXRecaf: $fIsoXRecuf[] $fXRApplyafg:$fXRApplyufg[] $fXRMapafg: $fXRMapufg[]TupleRecrecordListToHKDTuple TupleXRec xrecTuplexrecX UncurriedXRec UncurriedRecTupleToRecArgsruplexrecfieldRec namedArgs withDefaults$fTupleXRecuf:$fTupleXRecuf:0$fTupleXRecuf:1$fTupleXRecuf:2$fTupleXRecuf:3$fTupleXRecuf:4$fTupleXRecuf:5$fTupleRecuf(,,,,,,,)$fTupleRecuf(,,,,,,)$fTupleRecuf(,,,,,)$fTupleRecuf(,,,,)$fTupleRecuf(,,,)$fTupleRecuf(,,)$fTupleRecuf(,)$fTupleRecuf()CurriedXCurriedFCurried RecordCurry'rcurry' RecordCurryrcurryruncurry runcurry' xruncurry runcurryX runcurryA' runcurryA$fRecordCurry':$fRecordCurry'[]$fRecordCurryu:$fRecordCurryu[]ghc-prim GHC.TypesTypeIntSymbolbaseGHC.BaseFunctorGHC.ShowShow Coercible<> GHC.MaybeMaybeNothingGHC.PtrPtrForeign.StorableStorable ForeignPtrData.TraversabletraverseJust FieldPayloadmemptymconcatGHC.EnumminBoundmaxBoundfmapData.Semigroup.InternalProductSum Data.Tuplecurryuncurry Applicative