ڡo      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe  6(C) 2012-2016 Nicolas Frisby, (C) 2015-2016 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottPortableNone +69:;DRWrap a  to be used as a member of .Any  * -> * -> *; type parametric in both arguments permits an instance of  Invariant2.,Instances should satisfy the following laws: ~invmap2 id id id id = id invmap2 f2 f2' g2 g2' . invmap2 f1 f1' g1 g1' = invmap2 (f2 . f1) (f1' . f2') (g2 . g1) (g1' . g2')Wrap a # functor to be used as a member of . Wrap a  to be used as a member of .Any * -> *9 type parametric in the argument permits an instance of  Invariant.,Instances should satisfy the following laws: Ninvmap id id = id invmap f2 f2' . invmap f1 f1' = invmap (f2 . f1) (f1' . f2')Every  is also an  functor.Every  functor is also an  functor.Every  is also an  functor.Every  is also an  functor.A generic implementation of .from  GHC.Genericsfrom  GHC.Genericsfrom  GHC.Genericsfrom  GHC.Genericsfrom  GHC.Generics from  GHC.Generics!from  GHC.Generics"from  GHC.Generics#from  GHC.Generics$from  GHC.Generics8 from the  transformers package9 from the tagged package: from the  profunctors package; from the  profunctors package< from the  profunctors package= from the  profunctors package> from the  profunctors package? from the  profunctors package@ from the  profunctors packageA from the  profunctors packageB from the  profunctors packageC from the  profunctors packageD from the  profunctors packageE from the  profunctors packageF from the  profunctors packageG from the  profunctors packageH from the  profunctors packageI from the  profunctors packageJ from the  profunctors packageK from the  profunctors packageL from the  profunctors packageM from the  profunctors packageN from the  profunctors packageO from the  profunctors packageP from the  contravariant packageQ from the comonad packageR from the  bifunctors packageS from the  bifunctors packageT from the  bifunctors packageU from the  bifunctors packageV from the  bifunctors packageW from the  bifunctors packageX from the  bifunctors packageY from the  bifunctors packageZfrom Data.Semigroup[from  Control.Arrow\from Control.Applicative]from Control.Applicativep from the unordered-containers packageq from the  transformers packager from the  transformers packages from the  transformers packaget from the  transformers packageu from the  transformers packagev from the  transformers packagew from the  transformers packagex from the  transformers packagey from the  transformers packagez from the  transformers package{ from the  transformers package| from the  transformers package} from the  transformers package from the  transformers package from the  transformers package from the  transformers package from the tagged package from the stm package from the StateVar package from the StateVar package from the  profunctors package from the  profunctors package from the  profunctors package from the  profunctors package from the  profunctors package from the  profunctors package from the  profunctors package from the  profunctors package from the  profunctors package from the  profunctors package from the  profunctors package from the  profunctors package from the  profunctors package from the  profunctors package from the  profunctors package from the  contravariant package from the  contravariant package from the  contravariant package from the  contravariant package from the  contravariant package from the  contravariant package from the  contravariant package from the  containers package from the  containers package from the  containers package from the  containers package from the  containers package from the  containers package from the comonad package from the  bifunctors package from the  bifunctors package from the  bifunctors package from the  bifunctors package from the  bifunctors package from the  bifunctors package from the  bifunctors package from the  bifunctors package from the array packagefrom System.Console.GetOptfrom System.Console.GetOptfrom System.Console.GetOptfrom Data.Semigroupfrom Data.Semigroupfrom Data.Semigroupfrom Data.Semigroupfrom Data.Semigroupfrom Data.Semigroupfrom  Data.Proxyfrom  Data.Monoidfrom  Data.Monoidfrom  Data.Monoidfrom  Data.Monoidfrom  Data.Monoidfrom  Data.Monoidfrom  Data.Monoidfrom Data.List.NonEmptyfrom Data.Functor.Sumfrom Data.Functor.Productfrom Data.Functor.Identityfrom Data.Functor.Composefrom  Data.Complexfrom Control.Exceptionfrom  Control.Arrowfrom  Control.Arrowfrom Control.Applicativefrom Control.Applicativefrom Control.Applicativefrom Control.Applicative  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~6(C) 2012-2016 Nicolas Frisby, (C) 2015-2016 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone"A mapping of type variable Names to their map function Names. For example, in a Invariant declaration, a TyVarMap might look like:,(a ~> (covA, contraA), b ~> (covB, contraB))where a and b are the last two type variables of the datatype, and covA and covB are the two map functions for a and b in covariant positions, and contraA and contraB are the two map functions for a and b in contravariant positions.EWhether a type is not of kind *, is of kind *, or is a kind variable.A representation of which  Invariant is being used.BExpands all type synonyms in a type. Written by Dan Rosn in the  genifunctors package (licensed under BSD3).A type-restricted version of . This constrains the map functions that are autogenerated by Template Haskell to be the correct type, even if they aren't actually used in an invmap(2) expression. This is useful in makeInvmap(2), since a map function might have its type inferred as a instead of a -> b (which is clearly wrong).8Does a Type have kind * or k (for some kind variable k)?Returns  the kind variable  of a # if it exists. Otherwise, returns .jConcat together all of the StarKindStatuses that are IsKindVar and extract the kind variables' Names out."Returns True if a Type has kind *.GGets all of the type/kind variable names mentioned somewhere in a Type.GGets all of the type/kind variable names mentioned somewhere in a Kind.hasKindVarChain n kind Checks if kindj is of the form k_0 -> k_1 -> ... -> k_(n-1), where k0, k1, ..., and k_(n-1) can be * or kind variables.EIf a Type is a SigT, returns its kind signature. Otherwise, return *. KIf a VarT is missing an explicit kind signature, steal it from a TyVarBndr. Monadic version of concatMap #Extracts the name of a constructor. KGenerate a list of fresh names with a common prefix, and numbered suffixes. #Extracts the kind from a TyVarBndr.Convert a TyVarBndr to a Type.)Applies a typeclass constraint to a type.Checks to see if the last types in a data family instance can be safely eta- reduced (i.e., dropped), given the other types. This checks for three conditions: +All of the dropped types are type variables%All of the dropped types are distinct<None of the remaining types mention any of the dropped typesiExtract Just the Name from a type variable. If the argument Type is not a type variable, return Nothing.dExtract the Name from a type variable. If the argument Type is not a type variable, throw an error.6Peel off a kind signature from a Type (if it has one).Is the given type a variable?PIs the given type a type family constructor (and not a data family constructor)?AAre all of the items in a list (which have an ordering) distinct?HThis uses Set (as opposed to nub) for better asymptotic time complexity.9Does the given type mention any of the Names in the list?@Does an instance predicate mention any of the Names in the list?)Construct a type via curried application.7Fully applies a type constructor to its type variables.HSplit an applied type into its individual components. For example, this: Either Int Char would split to this: [Either, Int, Char] ESplit a type signature by the arrows on its spine. For example, this: .forall a b. (a ~ b) => (a -> b) -> Char -> () would split to this: (a ~ b, [a -> b, Char, ()]) )Like uncurryType, except on a kind level.D !"#$%&'()*+,-./0  123   456789:;<=>?C !"#$%&'()*+,-./0  123   456789:;<=>? !"#$%&'()*+,-./0  123   456789:;<=>?6(C) 2012-2016 Nicolas Frisby, (C) 2015-2016 Ryan Scott BSD-style (see the file LICENSE) Ryan ScottTemplate HaskellNone Generates an !G instance declaration for the given data type or data family instance. Generates an "G instance declaration for the given data type or data family instance.1Generates a lambda expression which behaves like invmap (without requiring an ! instance).1Generates a lambda expression which behaves like invmap2 (without requiring an " instance).@`Derive an Invariant(2) instance declaration (depending on the InvariantClass argument's value).AGenerates a declaration defining the primary function corresponding to a particular class (invmap for Invariant and invmap2 for Invariant2).BfGenerates a lambda expression which behaves like invmap (for Invariant), or invmap2 (for Invariant2).CuGenerates a lambda expression for invmap(2) for the given constructors. All constructors must be from the same type.DEGenerates a lambda expression for invmap(2) for a single constructor.EMGenerates a lambda expression for invmap(2) for an argument of a constructor.FGenerates a lambda expression for invmap(2) for a specific type. The generated expression depends on the number of type variables.GVExtracts a plain type constructor's information. | Boilerplate for top level splices.-The given Name must meet one of two criteria: JIt must be the name of a type constructor of a plain data type or newtype.NIt must be the name of a data family instance or newtype instance constructor.,Any other value will result in an exception.H6Deduces the instance context and head for an instance.IAttempt to derive a constraint on a Type. If successful, return Just the constraint and any kind variable names constrained to *. Otherwise, return Nothing and the empty list.dSee Note [Type inference in derived instances] for the heuristics used to come up with constraints.JEither the given data type doesn't have enough type variables, or one of the type variables to be eta-reduced cannot realize kind *.KZThe data type has a DatatypeContext which mentions one of the eta-reduced type variables.LbThe data type has an existential constraint which mentions one of the eta-reduced type variables.MThe data type mentions one of the n eta-reduced type variables in a place other than the last nth positions of a data type in a constructor's field.N}One of the last type variables cannot be eta-reduced (see the canEtaReduce function for the criteria it would have to meet).@ABCDOEFGHInvariant or Invariant2(The type constructor or data family nameThe datatype context=The type variables from the data type/data family declaration; the types used to instantiate a data family instance, or  if it's a plain data typePInvariant or Invariant2(The type constructor or data family nameThe datatype context*The types to instantiate the instance with+True if it's a data family, False otherwiseIQJKLMN@ABCDOEFGHPIQJKLMNR      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0 123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`$invariant-0.4-LrNb1efg8SEFbxUD7ZVH6RData.Functor.InvariantData.Functor.Invariant.THPaths_invariant"Data.Functor.Invariant.TH.Internal%bifunctors-5.4-21nQkpnOsL4LQMbVs5dXHAData.Bifunctor.WrappedunwrapBifunctor WrapBifunctorWrappedBifunctorWrappedProfunctorWrapProfunctorunwrapProfunctor Invariant2invmap2WrappedContravariantWrapContravariantunwrapContravariantWrappedFunctor WrapFunctor unwrapFunctor Invariantinvmap invmapFunctorinvmapContravariantinvmap2Bifunctorinvmap2Profunctor genericInvmap$fInvariantURec$fInvariantURec0$fInvariantURec1$fInvariantURec2$fInvariantURec3$fInvariantURec4$fInvariant:.:$fInvariantRec1$fInvariantPar1 $fInvariantM1$fInvariant2K1 $fInvariantK1$fInvariant:*:$fInvariant:+: $fInvariantU1 $fInvariantV1$$fProfunctorComonadWrappedProfunctor"$fProfunctorMonadWrappedProfunctor$$fProfunctorFunctorWrappedProfunctor$fMappingWrappedProfunctor$fTraversingWrappedProfunctor$fClosedWrappedProfunctor$fCochoiceWrappedProfunctor$fCostrongWrappedProfunctor$fChoiceWrappedProfunctor$fStrongWrappedProfunctor$fArrowLoopWrappedProfunctor$fArrowChoiceWrappedProfunctor$fArrowPlusWrappedProfunctor$fArrowZeroWrappedProfunctor$fArrowWrappedProfunctor$fCategorykWrappedProfunctor$fProfunctorWrappedProfunctor$fInvariantWrappedProfunctor$fInvariant2WrappedProfunctor$fInvariant2Constant$fInvariant2Tagged$fInvariant2TambaraSum$fInvariant2CotambaraSum$fInvariant2CopastroSum$fInvariant2Cotambara$fInvariant2Pastro$fInvariant2FreeTraversing$fInvariant2CofreeTraversing$fInvariant2FreeMapping$fInvariant2CofreeMapping$fInvariant2PastroSum$fInvariant2Tambara$fInvariant2Ran$fInvariant2Rift$fInvariant2Procompose$fInvariant2Codensity$fInvariant2Environment$fInvariant2Closure$fInvariant2Cayley$fInvariant2Forget$fInvariant2WrappedArrow$fInvariant2Costar$fInvariant2Star$fInvariant2Op$fInvariant2Cokleisli$fInvariant2WrappedBifunctor$fInvariant2Tannen$fInvariant2Sum$fInvariant2Product$fInvariant2Joker$fInvariant2Flip$fInvariant2Clown$fInvariant2Biff$fInvariant2Arg$fInvariant2Kleisli$fInvariant2WrappedArrow0$fInvariant2Const$fInvariant2(,,,,)$fInvariant2(,,,)$fInvariant2(,,)$fInvariant2(,)$fInvariant2Either$fInvariant2(->)$fDecidableWrappedContravariant$fDivisibleWrappedContravariant#$fContravariantWrappedContravariant$fInvariantWrappedContravariant$fTraversableWrappedFunctor$fFoldableWrappedFunctor$fMonadPlusWrappedFunctor$fMonadWrappedFunctor$fAlternativeWrappedFunctor$fApplicativeWrappedFunctor$fFunctorWrappedFunctor$fInvariantWrappedFunctor$fInvariantHashMap$fInvariantReverse$fInvariantConstant$fInvariantWriterT$fInvariantWriterT0$fInvariantStateT$fInvariantStateT0$fInvariantReaderT$fInvariantRWST$fInvariantRWST0$fInvariantMaybeT$fInvariantListT$fInvariantIdentityT$fInvariantExceptT$fInvariantErrorT$fInvariantContT$fInvariantLift$fInvariantBackwards$fInvariantTagged$fInvariantSTM$fInvariantSettableStateVar$fInvariantStateVar$fInvariantTambaraSum$fInvariantCotambaraSum$fInvariantCotambara$fInvariantTambara$fInvariantRan$fInvariantRift$fInvariantProcompose$fInvariantPrep$fInvariantCoprep$fInvariantCodensity$fInvariantClosure$fInvariantForget$fInvariantWrappedArrow$fInvariantCostar$fInvariantStar$fInvariantComposeFC$fInvariantComposeCF$fInvariantCompose $fInvariantOp$fInvariantEquivalence$fInvariantComparison$fInvariantPredicate$fInvariantTree$fInvariantViewR$fInvariantViewL$fInvariantSeq$fInvariantMap$fInvariantIntMap$fInvariantCokleisli$fInvariantWrappedBifunctor$fInvariantTannen$fInvariantJoker$fInvariantJoin$fInvariantFlip$fInvariantFix$fInvariantClown$fInvariantBiff$fInvariantArray$fInvariantOptDescr$fInvariantArgOrder$fInvariantArgDescr$fInvariantArg$fInvariantOption$fInvariantLast$fInvariantFirst$fInvariantMax$fInvariantMin$fInvariantProxy$fInvariantAlt$fInvariantSum$fInvariantProduct$fInvariantLast0$fInvariantFirst0$fInvariantEndo$fInvariantDual$fInvariantNonEmpty$fInvariantSum0$fInvariantProduct0$fInvariantIdentity$fInvariantCompose0$fInvariantComplex$fInvariantHandler$fInvariantKleisli$fInvariantArrowMonad$fInvariantWrappedArrow0$fInvariantWrappedMonad$fInvariantZipList$fInvariantConst$fInvariant(,,,,)$fInvariant(,,,)$fInvariant(,,)$fInvariant(,)$fInvariantEither$fInvariant(->)$fInvariantReadPrec$fInvariantReadP $fInvariantST$fInvariantST0 $fInvariantIO $fInvariant[]$fInvariantMaybe$fEqWrappedFunctor$fOrdWrappedFunctor$fReadWrappedFunctor$fShowWrappedFunctor$fEqWrappedContravariant$fOrdWrappedContravariant$fReadWrappedContravariant$fShowWrappedContravariant$fEqWrappedProfunctor$fOrdWrappedProfunctor$fReadWrappedProfunctor$fShowWrappedProfunctorderiveInvariantderiveInvariant2 makeInvmap makeInvmap2catchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName&profunctors-5.2-GWCcdx8UMARBBOUwXyLf8NData.Profunctor.Unsafe Profunctor(contravariant-1.4-DzaLxukcYo81MHO5zSdeePData.Functor.Contravariant ContravariantbaseGHC.BaseFunctorData.Bifunctor BifunctorTyVarMapStarKindStatusInvariantClass expandSyn invmapConstconstcanRealizeKindStarstarKindStatusToNameJusttemplate-haskellLanguage.Haskell.TH.SyntaxNameNothingcatKindVarNames hasKindStartyVarNamesOfTypetyVarNamesOfKindhasKindVarChaintyKindstealKindForType concatMapMconstructorName newNameListtvbKind tvbToType applyClass canEtaReducevarTToName_maybe varTToNameunSigTisTyVar isTyFamily allDistinct mentionsNamepredMentionsNameapplyTy applyTyCon unapplyTy uncurryTy uncurryKind NotKindStarKindStar IsKindVar KindSubst TypeSubst expandSynKind expandSynAppmkSubst substType substKindsubstNameWithKindsubstNamesWithKindStarinvmapConstNameinvariantClassName invmapName invmap2Const isStarOrVarfst3thd3lookup2createKindChaininvariantPackageKeymkInvariantName_tcmkInvariantName_vinvariantTypeNameinvariant2TypeName invmapValNameinvmap2ValNameinvmapConstValNameinvmap2ConstValName errorValName$fEnumInvariantClassderiveInvariantClass invmapDecsmakeInvmapClassmakeInvmapForConsmakeInvmapForConmakeInvmapForArgmakeInvmapForTypewithTypebuildTypeInstancederiveConstraintderivingKindErrordatatypeContextErrorexistentialContextErroroutOfPlaceTyVarErroretaReductionErrormakeInvmapForArgsbuildTypeInstanceFromTys reifyConTys