rS'      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      BSD-like (see LICENSE)*Stephanie Weirich <sweirich@cis.upenn.edu>portableSafe oA partial permutation consists of two maps, one in each direction (inputs -> outputs and outputs -> inputs).A  permutation is a bijective function from names to names which is the identity on all but a finite set of names. They form the basis for nominal approaches to binding, but can also be useful in general.0Apply a permutation to an element of the domain..Create a permutation which swaps two elements.!The empty (identity) permutation.OCompose two permutations. The right-hand permutation will be applied first.!Is this the identity permutation?Join two permutations by taking the union of their relation graphs. Fail if they are inconsistent, i.e. map the same element to two different elements. The support@ of a permutation is the set of elements which are not fixed. +Restrict a permutation to a certain domain.pConvert a partial permutation into a full permutation by closing off any remaining open chains into a cycles.  mkPerm l1 l2" creates a permutation that sends l1 to l2. Fail if there is no such permutation, either because the lists have different lengths or because they are inconsistent (which can only happen if l1 or l2 have repeated elements).-Permutations form a monoid under composition.   !       !BSD-like (see LICENSE)PBrent Yorgey <byorgey@cis.upenn.edu>, Stephanie Weirich <sweirich@cis.upenn.edu>GHC only (-XKitchenSink)Safe %A simple representation of multisets.Collections are foldable types that support empty, singleton, union, and map operations. The result of a free variable calculation may be any collection. Instances are provided for lists, sets, and multisets..An empty collection. Must be the identity for union.Create a singleton collection.)An associative combining operation. The Ord/ constraint is in order to accommodate sets.,Collections must be functorial. The normal Functor" class won't do because of the Ord constraint on sets.&Combine a list of containers into one.,Create a collection from a list of elements. Remove the Nothings from a collection.aSets are containers under union, which preserve only occurrence, not multiplicity or ordering.IMultisets are containers which preserve multiplicity but not ordering.cLists are containers under concatenation. Lists preserve ordering and multiplicity of elements.     BSD-like (see LICENSE) +Stephanie Weirich <sweirich@cis.upenn.edu>  GHC only None !"3457INRs are things that get bound. This type is intentionally abstract; to create a  you can use . or -". The type parameter is a tag, or sortX, which tells us what sorts of things this name may stand for. The sort must be a  representable type, i.e. an instance of the " type class from the RepLib generic programming framework. To hide the sort of a name, use  . ^A name with a hidden (existentially quantified) sort. To hide the sort of a name, use the  D constructor directly; to extract a name with a hidden sort, use ,.$Test whether a name is a bound variable (i.e. a reference to some binding site, represented as a de Bruijn index). Normal users of the library should not need this function, as it is impossible to encounter a bound name when using the abstract interface provided by Unbound.LocallyNameless.%Test whether a name is a free variable. Normal users of the library should not need this function, as all the names encountered will be free variables when using the abstract interface provided by Unbound.LocallyNameless.(Get the integer index of a .)Get the string part of a .*Get the integer index of an  .+Get the string part of an  .,NCast a name with an existentially hidden sort to an explicitly sorted name.-Create a free  from an #..Create a free  from a $./Convenient synonym for ..0Create a free  from a String and an Integer index.1Determine the sort of a .2Change the sort of a name.% !"#$%&&'()*+,-./012'()*+ !"#$%&'()*+,-./012 !-./0()*+,21$%"#&'% !"#$%&&'()*+,-./012'()*+BSD-like (see LICENSE)$Brent Yorgey <byorgey@cis.upenn.edu> experimentalunportable (GHC 7 only)None3457C3+A convenient monad which is an instance of 7. It keeps track of a set of names to avoid, and when asked for a fresh one will choose the first unused numerical name.4The LFresh monad transformer. Keeps track of a set of names to avoid, and when asked for a fresh one will choose the first numeric prefix of the given name which is currently unused.7This is the class of monads that support freshness in an (implicit) local scope. Generated names are fresh for the current local scope, not necessarily globally fresh.8?Pick a new name that is fresh for the current (implicit) scope.9qAvoid the given names when freshening in the subcomputation, that is, add the given names to the in-scope set.:-Get the set of names currently being avoided.;+A convenient monad which is an instance of ?k. It keeps track of a global index used for generating fresh names, which is incremented every time @ is called.<The FreshM monad transformer. Keeps track of the lowest index still globally unused, and increments the index every time it is asked for a fresh name.?The FreshE type class governs monads which can generate new globally unique s based on a given .@;Generate a new globally unique name based on the given one.ARun a <6 computation (with the global index starting at zero).BRun a <A computation given a starting index for fresh name generation.CBRun a FreshM computation (with the global index starting at zero).D0Run a FreshM computation given a starting index.ERun an 4! computation in an empty context.FRun an 4+ computation given a set of names to avoid.G.Run a LFreshM computation in an empty context.H8Run a LFreshM computation given a set of names to avoid.83456789:;<=>?@ABCDEFGH,-./0123456789:;<=>?@ABCDEFGHIJKLM3456789:;<=>?@ABCDEFGH?@;CD<=>AB789:3GH456EF03456789:;<=>?@ABCDEFGH,-./0123456789:;<=>?@ABCDEFGHIJKLMBSD-like (see LICENSE)$Brent Yorgey <byorgey@cis.upenn.edu> experimentalGHC onlyNone3457NI7Shift the scope of an embedded term one level outwards.KEmbed allows for terms to be embedded within patterns. Such embedded terms do not bind names along with the rest of the pattern. For examples, see the tutorial or examples directories.If t is a  term type, then Embed t is a  pattern type.Embedz is not abstract since it involves no binding, and hence it is safe to manipulate directly. To create and destruct Embed terms, you may use the Embed: constructor directly. (You may also use the functions embed and unembedM, which additionally can construct or destruct any number of enclosing Is at the same time.)MTRec is a standalone variant of O): the only difference is that whereas O p is a pattern type, TRec p is a  term type. It is isomorphic to U (O p) (). Note that TRec corresponds to Pottier's  abstraction1 construct from alpha-Caml. In this context, K t corresponds to alpha-Caml's inner t, and I (K t) corresponds to alpha-Caml's outer t.OIf p is a pattern type, then Rec p# is also a pattern type, which is  recursive in the sense that pm may bind names in terms embedded within itself. Useful for encoding e.g. lectrec and Agda's dot notation.QRebind allows for nested bindings. If p1 and p2 are pattern types, then  Rebind p1 p28 is also a pattern type, similar to the pattern type (p1,p2) except that p1  scopes over p2+. That is, names within terms embedded in p2 may refer to binders in p1.VGThe most fundamental combinator for expressing binding structure is U. The  term type Bind p t represents a pattern p paired with a term t, where names in p are bound within t.Like , U4 is also abstract. You can create bindings using bind and take them apart with unbind and friends.1IJKLMNOPQRSTUVWNOPQRSTUVWXXYYZZ[[\\]^_`abcdefghij, !"#$%&'()*+,-./012IJKLMNOPQRSTUVWXYZ[\VWUTSQROPMNKLIJXZY[\+IJKLMNOPQRSTUVWNOPQRSTUVWXXYYZZ[[\\]^_`abcdefghijBSD-like (see LICENSE) %Brent Yorgey <byorgey@cis.upenn.edu> GHC only (-XKitchenSink) None !"4>ILN$]bClass constraint hackery to allow us to override the default definitions for certain classes. ]0 is essentially a reified dictionary for the  class.lA mode is basically a flag that tells us whether we should be looking at the names in the term, or if we are in a pattern and should onlyL be looking at the names in the annotations. The standard mode is to use m$; many functions do this by default.oMany of the operations in the  class take an o: stored information about the iteration as it progresses. This type is abstract, as classes that override these operations should just pass the context on.sA continuation which takes the remaining index and searches for that location in a pattern, yielding a name or a remaining index if the end of the pattern was reached too soon.vThe result of an  operation.w%The name found at the given index.xWe haven't yet reached the required index; this is the index into the remainder of the pattern (which decreases as we traverse the pattern).yThe result of a  operation.z*The (first) index of the name we sought{ZWe haven't found the name (yet), but have seen this many others while looking for it|&Type class for embedded terms (either Embed or Shift).~4Construct an embedded term, which is an instance of K! with any number of enclosing I s. That is, embed can have any of the types  t -> Embed t t -> Shift (Embed t) t -> Shift (Shift (Embed t)) and so on.Destruct an embedded term. unembed can have any of the types  Embed t -> t Shift (Embed t) -> t and so on.The Alpha: type class is for types which may contain names. The k constraint means that we can only make instances of this class for types that have generic representations (which can be automatically derived by RepLib.)Note that the methods of Alpha should almost never be called directly. Instead, use other methods provided by this module which are defined in terms of Alpha methods.Most of the time, the default definitions of these methods will suffice, so you can make an instance for your data type by simply declaring instance Alpha MyTypebOccasionally, however, it may be useful to override the default implementations of one or more AlphaE methods for a particular type. For example, consider a type like 1data Term = ... | Annotation Stuff Term where the  Annotation constructor of Term associates some sort of annotation with a term --- say, information obtained from a parser about where in an input file the term came from. This information is needed to produce good error messages, but should not be taken into consideration when, say, comparing two Term.s for alpha-equivalence. In order to make aeq? ignore annotations, you can override the implementation of aeq' like so: instance Alpha Term where aeq' c (Annotation _ t1) t2 = aeq' c t1 t2 aeq' c t1 (Annotation _ t2) = aeq' c t1 t2 aeq' c t1 t2 = aeqR1 rep1 t1 t2Note how the call to ) handles all the other cases generically.See swaps.See fv.See lfreshen.See freshen.See aeq.See acompare."Replace free names by bound names."Replace bound names by free names.isPat x dynamically checks whether xB can be used as a valid pattern. The default instance returns JustX if at all possible. If successful, returns a list of names bound by the pattern.isTerm x dynamically checks whether x> can be used as a valid term. The default instance returns True if at all possible.isEmbed3 is needed internally for the implementation of isPat. isEmbed is true for terms wrapped in Embed$ and zero or more occurrences of Shift0. The default implementation simply returns False. p n looks up the nth name in the pattern pJ (zero-indexed), returning the number of names encountered if not found.Find the (first) index of the name in the pattern if one exists; otherwise, return the number of names encountered instead.@Find the (first) index of the name in the pattern, if it exists.If we see a name, check whether the index is 0: if it is, we've found the name we're looking for, otherwise continue with a decremented index. b n looks up up the nth name in the pattern bV (zero-indexed). PRECONDITION: the number of names in the pattern must be at least n.$Open a term using the given pattern. openP p1 p2 opens the pattern p2 using the pattern p1.%Close a term using the given pattern. closeP p1 p2 closes the pattern p2 using the pattern p1.NthContU forms a monoid: function composition which short-circuits once a result is found. FindResult; forms a monoid which combines information from several  operations. mappend takes the leftmost zj, and combines the number of names seen to the left of it so we can correctly compute its global index.l]^_`abcdefghijklmnopqrstuvwxyz{|}~Q]^_`abcdefghijklmnopqrstuvwxyz{|}~l|}~yz{vwxstuopqrlmn]^_`abcdefghijkC]^_`abcdefghijklmnopqrstuvwxyz{|}~ BSD-like (see LICENSE)$Brent Yorgey <byorgey@cis.upenn.edu>GHC only (-XKitchenSink)None !"3457>LNReified class dictionary for .The Subst class governs capture-avoiding substitution. To derive this class, you only need to indicate where the variables are in the data type, by overriding the method .This is the only method which normally needs to be implemented explicitly. If the argument is a variable, return its name wrapped in the  constructor. Return lN for non-variable arguments. The default implementation always returns l."This is an alternative version to , useable in the case that the substituted argument doesn't have *exactly* the same type as the term it should be substituted into. The default implementation always returns l. nm sub tm substitutes sub for nm in tm:. It has a default generic implementation in terms of isvar.rPerform several simultaneous substitutions. This method also has a default generic implementation in terms of isvar.See  See .((BSD-like (see LICENSE)$Brent Yorgey <byorgey@cis.upenn.edu>GHC only (-XKitchenSink)None35N!A smart constructor for binders, also sometimes referred to as "close". Free variables in the term are taken to be references to matching binders in the pattern. (Free variables with no matching binders will remain free.)#A destructor for binders that does not* guarantee fresh names for the binders.oBind the pattern in the term "up to permutation" of bound variables. For example, the following 4 terms are all alpha-equivalent: Spermbind [a,b] (a,b) permbind [a,b] (b,a) permbind [b,a] (a,b) permbind [b,a] (b,a)YNote that none of these terms is equivalent to a term with a redundant pattern such as permbind [a,b,c] (a,b)For binding constructors which do! render these equivalent, see  and .YBind the list of names in the term up to permutation and dropping of unused variables.'For example, the following 5 terms are all alpha-equivalent: esetbind [a,b] (a,b) setbind [a,b] (b,a) setbind [b,a] (a,b) setbind [b,a] (b,a) setbind [a,b,c] (a,b)There is also a variant, , which ignores name sorts.lBind the list of (any-sorted) names in the term up to permutation and dropping of unused variables. See .#Constructor for rebinding patterns.lDestructor for rebinding patterns. It does not need a monadic context for generating fresh names, since Rebind' can only occur in the pattern of a U; hence a previous call to R (or something similar) must have already freshened the names at this point.#Constructor for recursive patterns."Destructor for recursive patterns.'Constructor for recursive abstractions.ZDestructor for recursive abstractions which picks globally fresh names for the binders.2Destructor for recursive abstractions which picks locally! fresh names for binders (see 7).-Determine the alpha-equivalence of two terms.Determine (alpha-)equivalence of patterns. Do they bind the same variables in the same patterns and have alpha-equivalent annotations in matching positions?;An alpha-respecting total order on terms involving binders.?Calculate the free variables (of any sort) contained in a term.ICalculate the free variables of a particular sort contained in a term.Calculate the variables (of any sort) that occur freely in terms embedded within a pattern (but are not bound by the pattern).Calculate the variables of a particular sort that occur freely in terms embedded within a pattern (but are not bound by the pattern).;Calculate the binding variables (of any sort) in a pattern.GCalculate the binding variables (of a particular sort) in a pattern. Apply a permutation to a term. oApply a permutation to the binding variables in a pattern. Embedded terms are left alone by the permutation. kApply a permutation to the embedded terms in a pattern. Binding names are left alone by the permutation. a"Locally" freshen a pattern, replacing all binding names with new names that are not already "in scope". The second argument is a continuation, which takes the renamed term and a permutation that specifies how the pattern has been renamed. The resulting computation will be run with the in-scope set extended by the names just generated. /Freshen a pattern by replacing all old binding s with new fresh !s, returning a new pattern and a   specifying how s were replaced.Unbind (also known as "open") is the simplest destructor for bindings. It ensures that the names in the binding are globally fresh, using a monad which is an instance of the ? type class.Unbind two terms with the same fresh names, provided the binders have the same binding variables (both number and sort). If the patterns have different binding variables, return NothingF. Otherwise, return the renamed patterns and the associated terms.Unbind three terms with the same fresh names, provided the binders have the same number of binding variables. See the documentation for  for more details.lunbind opens a binding in an 7> monad, ensuring that the names chosen for the binders are locally: fresh. The components of the binding are passed to a  continuation, and the resulting monadic action is run in a context extended to avoid choosing new names which are the same as the ones chosen for this binding.4For more information, see the documentation for the 7 type class.Unbind two terms with the same locally fresh names, provided the patterns have the same number of binding variables. See the documentation for  and  for more details.Unbind three terms with the same locally fresh names, provided the binders have the same number of binding variables. See the documentation for  and  for more details.Compare for alpha-equality.)     '     )     )      BSD-like (see LICENSE) %Brent Yorgey <byorgey@cis.upenn.edu>  experimental GHC only (-XKitchenSink) Nonejmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./k0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\"]^_`  !"()*+,-./0234789:;<?@ACEGIJKLMOQUXYZ[\~     t !-./0()*+2,UKL~QOMIJ       ?@;C<A 789:3G4E"XZY[\a      !"#$%&'(()*+,-./0123456789:;;<=>?@ABBCDEFGHIJKLMNNOOPPQQRSTUVWXYZ[\]^^_`abcdefghijklmnopqrsstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn$%opqprpsptpupvpwpxpypzp{p|p}p~pppppppppppppppppppppppppppppppppppppppppppppp     mmm m!m"m#m$m%m&m'm(m)m*m+m,m-m.m/m0m123456789:;<=>?@A#BCSDDEFGHIJJKLMNOPQQRRSSTUVW$XY$XZ$X[$X\]unbou_Ha8rNq3UN2lDbE01BQdBge Unbound.PermM Unbound.UtilUnbound.LocallyNameless.NameUnbound.LocallyNameless.FreshUnbound.LocallyNameless.TypesUnbound.LocallyNameless.AlphaUnbound.LocallyNameless.SubstUnbound.LocallyNameless.OpsUnbound.LocallyNamelessPerm permValidapplysingleemptycomposeisidjoinsupportrestrictmkPermMultiset CollectionemptyC singletonunioncmapunionsfromListfilterCdisjoint$fCollectionSet$fCollectionMultiset$fFoldableMultiset$fCollection[]NameNmBnrRrR1AnyNamerNamerName1isBoundisFreerAnyName rAnyName1 name2Integer name2StringanyName2IntegeranyName2String toSortedName integer2Name string2Names2nmakeNamegetR translateLFreshMLFreshMT unLFreshMTLFreshlfreshavoid getAvoidsFreshMFreshMT unFreshMTFreshfresh runFreshMT contFreshMT runFreshM contFreshM runLFreshMT contLFreshMT runLFreshM contLFreshMShiftEmbedTRecRecRebindR SetPlusBindSetBindBindGenBindBrGenBindrEmbedrRebindrRecrShiftAlphaDisPatDisTermDisEmbedDswapsDfvDfreshenD lfreshenDaeqD acompareDcloseDopenDfindpatDnthpatDModeTermPatAlphaCtxACmodelevelNthCont runNthCont NthResultFoundCurIndex FindResultIndex NamesSeenIsEmbedEmbeddedembedunembedAlphaswaps'fv' lfreshen'freshen'aeq' acompare'closeopenisPatisTermisEmbed nthpatrec findpatrecfindpatnthNamenthpatinitialincrdecrpattermopenTopenPcloseTclosePcloseR1openR1swapsR1fvR1fv1aeqR1aeq1 freshenR1freshenL lfreshenR1 lfreshenL findpatR1findpatLnthpatR1nthpatLcombineisPatR1isTermR1 acompareR1 compareTupM$fAlphaR $fAlpha(,,,,) $fAlpha(,,,) $fAlpha(,,) $fAlpha(,) $fAlphaEither $fAlphaMaybe $fAlphaChar $fAlphaDouble$fAlphaInteger $fAlphaInt $fAlpha[] $fAlpha() $fAlphaFloat $fAlphaBool$fIsEmbedShift $fAlphaShift$fIsEmbedEmbed $fAlphaEmbed $fAlphaRec $fAlphaRebind$fAlphaGenBind$fAlphaAnyName $fAlphaName $fSatAlphaD$fMonoidNthCont$fMonoidFindResultSubstDisvarDsubstDsubstsDSubstisvar isCoerceVarsubstsubsts SubstCoerce SubstName substDefaultsubstR1substsR1 $fSubstcRec $fSubstcEmbed $fSubstcShift$fSubstcRebind$fSubstcGenBind$fSubstcEither $fSubstcMaybe $fSubstc[]$fSubstc(,,,,) $fSubstc(,,,) $fSubstc(,,) $fSubstc(,) $fSubstbName $fSubstbR$fSubstbAnyName$fSubstbDouble $fSubstbFloat$fSubstbInteger $fSubstbChar $fSubstb() $fSubstbBool $fSubstbInt $fSatSubstDbind unsafeUnbind permCloseAnystrength permClosepermbindsetbind setbindAnyrebindunrebindrecunrectrecuntrecluntrecaeq aeqBindersacomparefvAnyfvpatfvAnypatfv bindersAnybindersswaps swapsBinders swapsEmbedslfreshenfreshenunbindunbind2unbind3lunbindlunbind2lunbind3 unbind2Plus unbind3Plus lunbind2Plus lunbind3Plus $fEqRebind $fReadGenBind PartialPermppToPerm $fMonoidPermPPemptyPPextendPP $fShowPerm$fEqPermRepLi_4Lheh6lwqNkKB1olrC5cDqGenerics.RepLib.RRep integer-gmpGHC.Integer.TypeIntegerbaseGHC.BaseString $fRep1ctxR $fRep1ctxName $fShowName $fOrdAnyName $fEqAnyName $fShowAnyName$fRep1ctxAnyName$fMonadWriterwLFreshMT$fMonadReaderrLFreshMT$fMonadStatesLFreshMT$fMonadErroreLFreshMT$fMonadContLFreshMT$fMonadTransLFreshMT$fLFreshWriterT$fLFreshWriterT0$fLFreshStateT$fLFreshStateT0$fLFreshReaderT$fLFreshMaybeT $fLFreshListT$fLFreshIdentityT$fLFreshExceptT $fLFreshContT$fLFreshLFreshMT$fMonadWriterwFreshMT$fMonadReaderrFreshMT$fMonadStatesFreshMT$fMonadErroreFreshMT$fMonadContFreshMT$fMonadTransFreshMT$fFreshWriterT$fFreshWriterT0 $fFreshStateT$fFreshStateT0$fFreshReaderT $fFreshMaybeT $fFreshListT$fFreshIdentityT$fFreshExceptT $fFreshContT$fFreshFreshMT StrictCard RelaxedCard StrictOrder RelaxedOrder $fShowShift $fShowEmbed $fShowTRec $fShowRec $fShowRebind $fShowGenBind rGenBind1rEmbed1rRebind1rRec1rShift1$fRep1ctxShift rRelaxedOrderrRelaxedOrder1 rStrictOrder rStrictOrder1 rRelaxedCard rRelaxedCard1 rStrictCard rStrictCard1 $fBinaryEmbed$fBinaryRebind$fBinaryGenBind $fBinaryName$fRep1ctxStrictCardGenerics.RepLib.R1Rep1NothingGenerics.RepLib.Libgelemganygallgconcatcompcountflattengorgandgproductcrush rreduceR1 lreduceR1 enumerateR1 generateR1zeroR1gsumR1deepSeqRrnfRrnfdeepSeqsubtreesgsumGSumgsumDGSumDzeroZerozeroDZDZeroD generateD GenerateDgenerateGenerate enumerateD EnumerateD enumerate EnumerateshrinkDShrinkDshrinkShrinkrreduceDRreduceDlreduceDLreduceDrreduceRreducelreduceLreducefoldLeft foldRightFoldGenerics.RepLib.PreludeLib showsPrecR1 maxBoundR1 minBoundR1 compareR1eqR1EqDOrdDBoundedDShowDGenerics.RepLib.SYB.Schemes gfindtype gtypecount gnodecountgcountgdepthglengthgsize synthesize somethinglistify everything everywhereM everywhereBut everywhere' everywhereGenerics.RepLib.SYB.AliasesrecoverQ recoverMpchoiceQchoiceMporElseextRextBextMpextMextQextText0mkRmkMpmkMmkQmkTGenericTGenericQGenericMGenericBGenericRGeneric unGeneric'Generic'unGTGT GenericT'unGQGQ GenericQ'unGMGM GenericM'Generics.RepLib.RepAux fromSpinetoSpinegmapM1gmapQ1gmapT1gmapMgmapQgmapTtoListfromTupMfromTupmapM_lmapQ_lmap_lfoldl_lfoldr_lfindConcompareRgcastgcastRcastcastReqRVal TraversalQueryMapM Traversal1Query1MapM1:::Typed:<>ConstrSpineGenerics.RepLib.PreludeRepsrTup7_1rTup7rTup6_1rTup6rTup5_1rTup5rTup4_1rTup4rTup3_1rTup3 rOrdering1 rOrderingrEither1rEitherrMaybe1rMayberBool1rBoolGenerics.RepLib.Derivederive_abstractderiverList1rTup2_1toRgetRepCEqual1 Abstract1Data1Arrow1IO1IOError1 Rational1Double1Float1Integer1Char1Int1R1dictSatrep1rConsEmbrNilEmbrListrPairEmbrTup2rUnitrUnitEmbEqualAbstractDataArrowIOIOErrorRationalDoubleFloatCharIntConfixitynamelabelsfromtoEmbInfixrInfixlprecInfixNonfixFixityDTNil:*::+:MNilMTuprepData.Type.Equality TestEquality testEquality:~:Refl