h&QIP      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                         None.28<=>WtenA , made by applying the argument to some type.   Safe-Inferred'(-.> W1ten5A utility "typeclass newtype" that's convenient with 2.If you want to use 3 to get an instance of the form c (d a), use entailment @(c :!: d)$. Really I wanted to use the name (:.:), but it's taken, so I just replaced the period with something else that involves a dot near the typographic base line.2tenA typeclass of GADT-like types whose existence implies an instance.(For a trivial example, the existence of  Int :~: b implies Show b, since we can discover that b is Int and use the Show Int instance.4tenA dictionary for the given arity-1 constraint constructor ("a class").6ten&Bring an instance into scope using an 2 instance.  ( (k :: Int :~: b) (x :: b) -> withEntailment @Show k (show x)) Refl 2 7tenflip 6.This is useful for "consuming" an index off the front of a function type and turning it into an instance, e.g. in the context of an  call.8ten4"s entail their own type parameter.9tenEquality to a particular type entails any instance that type has.;tenNon-GADTy types don't entail anything except parametric instances.12345672345167None .2>?=ten over arity-1 type constructors.Whereas  folds  a :: Type values to a monoid, = folds (m :: k -> Type) a' values to a monoid, parametrically in a#. That is, the type parameter of ) has arity 0, and the type parameter of = has arity 1.>ten Map each m a element parametrically to w and  the results.?tenGiven a structure over  m, return the () of all elements.@tenRight-associative fold over a =.AtenLeft-associative fold over a =.Bten8Sequence actions given by a function left-to-right in a =.)This form discards the final result; see   for a version that keeps it.CtenSequence actions in a =& left-to-right, discarding the result.,This variant expects the composition of the  being sequenced with some inner type constructor at each field.See  % for a version that keeps the result.DtenSequence actions in a =& left-to-right, discarding the result.$This variant expects just the plain m) actions with no inner type constructor.=>?@ABCD=>?@ABDCNone .2>?Oten over arity-1 type constructors.Whereas  maps  a :: Type values to  b :: Type values, O maps (m :: k -> Type) a values to m b values, parametrically in a". That is, the type parameter of ) has arity 0, and the type parameter of O has arity 1.Pten Map each m a value in f m parametrically to n a to get f m.Qten() for O.Rten() for O.Sten for O. This returns f  because Proxy :: k -> Type has the right kind and carries no runtime information. It's isomorphic to Const () but easier to spell.OPQRSOPQRSQ4R4None -.?^tenAn extension of O that provides access to some `.`ten'The index type associated with a given f.3This is often a GADT-like type, in that inspecting  Index10 f a can refine a: to some more concrete type, provide instances for it via 2, etc.atenP. with access to an instance for every element.^_`a`^_aNone -.?}ctenAn extension of = that provides access to some `.eten with an index parameter.ften with an index parameter.gten with an index parameter.hten>$ with an instance for every element.iten$ with an instance for every element.jten$ with an instance for every element.kten$ with an instance for every element. `cdefghijk `cdefghijkNone-.2>? mten A function  m a -> n a2 wrapped in a newtype for use as a type parameter.This is used to represent the partially-applied functions in the left side of (r).pten over arity-1 type constructors. See also O and .qtenLift a parametric m value into an f m.rten() for p : zip two fs with o.sten for p : zip two fs with a parametric function.tten for p.uten() for p.vten() for p.wtenq. with access to an instance for every element.xtens. with access to an instance for every element.ytent. with access to an instance for every element. mnoprqstuvwxy prqsuvtmnowxyr4u4v4 None . ten+The names of a lens and field selector, or coerce/_Wrapped.Used in deriving / ( instances for field selector newtypes.ten-Zooming in on the contents of a newtype with coerce or _Wrapped.tenZooming in on a record field with the given named selector/lens.ten Convert a  to a , with a suffix.tenConvert a list of s to a , a la .tenPretty-print a .tenPretty-print a field path.ten4Guess the name of the lens corresponding to a field.tenAccess the left side of a ().tenAccess the right side of a ().tenModify the left side of a ().tenModify the right side of a ().   None />?ten*A newtype carrying instances for use with  DerivingVia.This provides , , , and  !.tenThe  implementation of  for .tenThe  implementation of .As with , derive this only to enable using your type as a sub-record; otherwise just derive  directly.tenBuild a record where each field has a description of the field's location.This primarily powers the  and  instances of .tenA 4 type in the form of a parametric accessor function.   None >?"tenThe  implementation of .tenExtends % with support for modifying elements.If  ( f) is available, this is already possible by roundabout means, but this class lets instances provide a more direct method that doesn't require per-field equality tests.ten Update an f a at a given index.tenA "#$ to the field identified by a given . 0 ixRep :: Update f => Rep f -> Lens' (f a) a  None .>?* ten Analog of  over arity-1 type constructors.This is defined in terms of  for two reasons:First, it makes it possible to use with GeneralizedNewtypeDeriving and DerivingVia. See  https://ryanglscott.github.io/2018/06/22/quantifiedconstraints-and-the-trouble-with-traversable/ for more details.Second, it uses fewer s in some cases: when you need to re-apply a constructor tag like  or  after calling 9 on the payload, this would normally be an additional , but with  it can be fused into the underlying recursive call. Less crucially, the same trick applies when traversing multiple fields and combining them back into a product type: the first call can use $ to pre-apply the function, and use  rather than $ (which is often defined as an  followed by a ).ten with a built-in  on the final result.ten Analog of - for functors over arity-1 type constructors.8Given a parametric function that takes the wrapped type m a to n a in an  f, visit all contained m _s to convert from t m to t n.m and n here play the role of a and b in the normal 3 type; that is, instead of traversing to change a Type9, we're traversing to change a type constructor of kind  k -> Type:  traverse :: (Traversable t, Applicative f) => ( a -> f b ) -> t a -> f (t b) traverse10 :: (Traversable10 t, Applicative f) => (forall x. m x -> f (n x)) -> t m -> f (t n) ten for .$This variant expects just the plain m< actions at each field, and wraps the results in @Identity.ten for .,This variant expects the composition of the  being sequenced with some inner type constructor at each field. None  '(.2<=*tenA O6 made by applying the argument to an existential type.None -.?+ttenAn extension of  that provides access to some `.ten  with an index parameter.ten $ with an instance for every element.``None '(-./2>?-ftenConstrained10 c f means that in f m, all applications of m are to types x that satisfy constraint c.tenRecover instances of c to accompany each m element in f.ten implementation of .tenProvides a path of field selectors / lenses identifying each "field".tenA %( type as a parametric accessor function.  None-.28<=>?4; tenThe  implementation of  based on .ten Analog of  over arity-1 type constructors.If f is Representable10, then a value of type f m is isomorphic to a function forall a. Rep10 f a -> m a. This essentially means it can be thought of as a fixed-shape record with a wrapper type applied to all of its fields.6This is also equivalent to a total dependent map from Rep10 f to m3 ("total" meaning that every "key" has a "value").tenThe "index" type of an f "container".This is a type that behaves like a GADT, with a value for each possible "position" of an m a in f m and the parameter type(s) a it can have.ten Given an f m and a  Rep10 f a "index" into it, extract the m a.ten Build an f m3 by applying a parametric function to each "index".ten$Turn a record field selector into a . See also &'.ten'Turn a record field selector targeting  into a . See also &'.ten Analog of () for .9Pulls a fixed record shape to the outside of any functor.ten Analog of (* for .Gathers a fixed record shape mapped over the elements of any functor.tenAccess an element along with an instance for its type parameter.tenSuperclass appeasement; deriving via this will give infinite loops; don't!tenSuperclass appeasement; deriving via this will give infinite loops; don't!tenSuperclass appeasement; deriving via this will give infinite loops; don't!  None'(.>?8Cten;A newtype wrapper to store tables of equality witnesses in f.tenExtends % with support for modifying elements. See also .tenImplementation detail of +, ( f).!This is a pre-populated table of  (a  b)s, with s in the elements where the inner position is the same as the outer position, i.e. along the "diagonal". Then we can test two forall m. f m -> m a functions for equality, by applying them in turn to the two layers of f, and see if we reach a  or a .ten7A newtype wrapper to store field modifier functions in f.ten implementation of .ten Modify an f m at a given index.ten Update an f m at a given index.tenA "#$ to the field identified by a given . 9 ix10 :: Update10 f => Rep10 f a -> Lens' (f m) (m a)  None '(-28:<=?GtenNewtype used in implementing contravariant conversion of Fragments. See 3. Only exported because it's used in the type of /, but it can be largely ignored, like the many ALens etc. types in "lens".ten A pair of k a and m a for any (existential) a.This is a lot like a dependent pair, in that it contains a left-hand-side value that's meant to identify a type, and a right-hand-side parameterized by that type. For example, the true dependent pair type (in e.g. Idris) (n :: Nat ** Vec n Bool)& could be approximated in Haskell as SInt :** Ap10 Bool Vec.-This can be used to represent one field of a , where k is set to Rep10 f. The k a< identifies which field (and locks down its type), and the m a provides its value.ten%Check if two pairs have the same key.tenZip$ a single field of a record with a ().2Since we're only operating on a single field, the n5 type can't vary like in a traditional zip function.ten Simulate a case statement on a () with a record of functions.  caseFragment (MyRecord1 (OpCostar isJust) (OpCostar isNothing)) x Is analogous to (pseudo-code):  case x of { (_mr1A :** mx) -> isJust mx; (_mr1B :** mx) -> isNothing mx } This is just the action of  (whereby f m is isomorphic to forall a. Rep10 f a -> m a) plus some newtyping:  f (OpCostar m r) ~= (by Representable10) forall a. Rep10 f a -> OpCostar m r a ~= (by newtype) forall a. Rep10 f a -> f a -> r ~= (by GADT constructor) Rep10 f :** m -> r ten Convert a (*) to a different key type contravariantly.Example usage:data MyRecord1 m = MyRecord1 { _mr1A :: Ap10 Int m, _mr1B :: Ap10 Int m } data MyRecord2 m = MyRecord2 { _mr2A :: Ap10 Int m }- Collapse both fields _mr1A and _mr1B onto _mr2A. example :: Rep10 MyRecord1 :** Identity> Rep10 MyRecord2 :** Identity example = lmapFragment $ MyRecord2{..} -> MyRecord1 { _mr1A = _mr2A , _mr1B = _mr2A }/It looks weird that the argument converts from recB to recA in order to convert () the other way, so it merits some explanation: first, note that, by  recA, we know that recA m is isomorphic to  forall a.  recA a -> m a . That is,  Rep10 recA. effectively appears in negative position in recA m. So, a function from recB to recA hand-wavingly contains a function in the opposite direction from  Rep10 recA to  Rep10 recB.With the intuition out of the way, here's how we actually accomplish the conversion: start off with a record recB where each field is a function that trivially rebuilds the corresponding (:**) in each field with k :: Rep10 recB we literally just put (k :**) with the appropriate newtype constructors. Then, apply the user's contravariant conversion function, to turn our recB of recB-pair-builders into an recA of recB-pair-builders. If the user-provided conversion function involves changing any field types, it must have done so by  contramapping the pair-builders: instead of a function that just directly applies (k :=) to its argument, they will now contain functions equivalent to ma -> k := _f ma. Finally, unpack the recA pair and use its k to fetch that field's recB-pair-builder (potentially with a conversion inserted at the front), and apply it to the payload.Usage will typically involve applying contramap to some number of fields and leaving the rest unchanged. If you have a type-changing "-' at hand, it's probably easier to use &..  55None '(-./289<=>?Hh 1234567=>?@ABCDOPQRS^_`acdefghijkmnopsrqtuvwxy/ Safe-InferredI;01201301401501601301701899:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcddefghijklmnopqrstuvwxyz{|}~                                                     !                                    %v00000000000$000000(01((000000+00////////ten-0.1.0.1-inplaceData.Ten Data.Ten.ApData.Ten.EntailsData.Ten.FoldableData.Ten.FunctorData.Ten.Functor.WithIndexData.Ten.Foldable.WithIndexData.Ten.ApplicativeData.Ten.InternalData.Functor.FieldData.Functor.UpdateData.Ten.TraversableData.Ten.ExistsData.Ten.Traversable.WithIndexData.Ten.UpdateData.Ten.FieldData.Ten.RepresentableData.Ten.Sigma Functor10imap10 traverse10 fsequenceA10_ Data.Functorvoidfoldl10foldr10 traverse10_ Foldable10Control.ApplicativeliftA3Text.PrettyPrint.HughesPJClassPrettyUpdate Control.LensLensliftA2Rep10 Data.Ten.Lensrep10Data.Functor.Rep distributeRep collectRepData.Type.Equality TestEqualitySetter fragmented Paths_tenbase GHC.Generics:+::*::.:R1L1unComp1Comp1Ap10unAp10$fPortrayApTYPEDecoy$fPortrayApTYPEf$fDiffApTYPEDecoy $fDiffApTYPEf$fEqApTYPEDecoy $fEqApTYPEf$fOrdApTYPEDecoy $fOrdApTYPEf$fReadApTYPEDecoy $fReadApTYPEf$fShowApTYPEDecoy $fShowApTYPEf$fDefaultApTYPEDecoy$fDefaultApTYPEf$fNFDataApTYPEDecoy$fNFDataApTYPEf$fHashableApTYPEDecoy$fHashableApTYPEf $fEqDecoy $fOrdDecoy $fReadDecoy $fShowDecoy$fGenericDecoy$fDefaultDecoy $fNFDataDecoy$fHashableDecoy $fDiffDecoy$fPortrayDecoy $fGenericAp10$fHashableAp10 $fNFDataAp10 $fDefaultAp10 $fShowAp10 $fReadAp10 $fOrdAp10$fEqAp10 $fDiffAp10 $fPortrayAp10:!:Entails entailmentDict1withEntailment byEntailment$fEntailskDict1c$fEntailsk:~:c$fEntailskProxyc$fEntailskTypeRepc $f:!:kkcda foldMap10fold10 sequenceA10_$fFoldable10k:.:$fFoldable10k:*:$fFoldable10k:+:$fFoldable10kU1$fFoldable10kV1$fFoldable10kK1$fFoldable10kAp10$fFoldable10kWrapped1$fFoldable10kM1$fFoldable10kRec1fmap10<$!<$>!void10$fFunctor10k:.:$fFunctor10k:*:$fFunctor10k:+:$fFunctor10kU1$fFunctor10kV1$fFunctor10kK1$fFunctor10kAp10$fFunctor10kWrapped1$fFunctor10kM1$fFunctor10kRec1Functor10WithIndexIndex10fmap10C$fFunctor10WithIndexk:.:Foldable10WithIndex ifoldMap10ifoldl10ifoldr10 itraverse10_ foldMap10Cfoldr10Cfoldl10C traverse10C_$fFoldable10WithIndexk:.::->:Arr10runArr10 Applicative10pure10<*>!liftA210liftA310<*!*>!pure10C liftA210C liftA310C$fApplicative10k:.:$fApplicative10k:*:$fApplicative10kU1$fApplicative10kK1$fApplicative10kAp10$fApplicative10kWrapped1$fApplicative10kM1$fApplicative10kRec1 PathComponent NewtypeIso NamedFieldshowPathComponent showsPathportrayPathComponent portrayPathdropUnderscorestarFststarSnd mapStarFst mapStarSndFieldRep GTabulate gtabulate GFieldPaths gfieldPaths FieldPaths fieldPathsFieldgetField$fHashableField $fOrdField $fEqField $fDiffField$fPortrayField $fShowField$fGFieldPaths:.:$fGFieldPaths:*:$fGFieldPathsM1$fGFieldPathsM10$fGFieldPathsM11$fGFieldPathsM12$fGFieldPathsRec1$fGFieldPathsPar1$fGFieldPathsU1$fFieldPathsWrapped1$fGTabulate:.:$fGTabulate:*:$fGTabulatePar1 $fGTabulateM1$fGTabulateRec1 $fGTabulateU1$fRepresentableFieldRep$fMonadFieldRep$fApplicativeFieldRep$fDistributiveFieldRep$fFunctorFieldRepGUpdategsettersoverRep updateRepixRep $fGUpdate:.: $fGUpdate:*: $fGUpdatePar1 $fGUpdateM1 $fGUpdateRec1 $fGUpdateU1$fUpdateFieldRep Traversable10 mapTraverse10 sequenceA10 fsequenceA10$fTraversable10k:.:$fTraversable10k:*:$fTraversable10k:+:$fTraversable10kM1$fTraversable10kRec1$fTraversable10kU1$fTraversable10kV1$fTraversable10kK1$fTraversable10kAp10$fTraversable10kWrapped1Exists$fTraversable10kExists$fFoldable10kExists$fFunctor10kExists $fDiffExists$fPortrayExists$fHashableExists $fOrdExists $fEqExists $fShowExistsTraversable10WithIndeximapTraverse10 itraverse10 traverse10C$fTraversable10WithIndexk:.: EqualityTableUpdate10 equalityTable Constrained10 constrained10 GFieldPaths10 gfieldPaths10 FieldPaths10 fieldPaths10Field10 getField10$fHashableField10 $fOrdField10 $fEqField10$fGComparekField10 $fGEqkField10$fTestEqualitykField10$fFieldPaths10kAp10 $fDiffField10$fPortrayField10 $fShowField10$fGFieldPaths10k:.:$fGFieldPaths10k:*:$fGFieldPaths10kM1$fGFieldPaths10kM10$fGFieldPaths10kM11$fGFieldPaths10kM12$fGFieldPaths10kRec1$fGFieldPaths10kU1$fFieldPaths10kWrapped1$fEntailskField10c$fConstrained10kc:.:$fConstrained10kc:*:$fConstrained10kcU1$fConstrained10kcWrapped1$fConstrained10kcAp10$fConstrained10kcM1$fConstrained10kcRec1 GTabulate10 gtabulate10Representable10index10 tabulate10rep10'field10'distributeRep10 collectRep10index10C$fRepresentable10kAp10!$fTraversable10WithIndexkWrapped1$fFoldable10WithIndexkWrapped1$fFunctor10WithIndexkWrapped1$fRepresentable10kWrapped1$fGTabulate10k:.:$fGTabulate10k:*:$fGTabulate10kM1$fGTabulate10kRec1$fGTabulate10kU1 FieldSetter10FS10runFS10 GUpdate10 gsetters10 overRep10 updateRep10ixRep10$fUpdate10kAp10$fGUpdate10k:.:$fGUpdate10k:*:$fGUpdate10kM1$fGUpdate10kRec1$fGUpdate10kU1$fUpdate10kWrapped1OpCostar getOpCostar:**eqKey overFragment caseFragment lmapFragment$fTraversable10WithIndexTYPE:**$fFoldable10WithIndexTYPE:**$fFunctor10WithIndexTYPE:**$fTraversable10TYPE:**$fFoldable10TYPE:**$fFunctor10TYPE:** $fDiff:** $fPortray:** $fShow:**$fEq:** $fNFData:**$fContravariantOpCostar Data.FoldableFoldableGHC.BasemconcatData.Functor.ConstConst<> ApplicativeFunctor<$<$> Data.ProxyProxy<*><**>GHC.ShowShowString showsPrecMonadadjunctions-4.4-7089165b5951381e7554466b0d0e6788d670e85192449d7f7167069e058e87cb RepresentableGeneric1tabulateportray-0.1.0.0-56e09d61fcd70ed4c28f9998e93cef8acb7a697643c7f1813de2886a18d35a42 Data.PortrayPortrayRepghc-prim GHC.ClassesEqData.Traversable Traversablefmaptraverse sequenceA GHC.MaybeMaybe:~:JustNothingversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName