9g      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;< = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f XXX  experimental +Stephanie Weirich <sweirich@cis.upenn.edu> 6A name with a hidden (existentially quantified) sort. 9s are things that get bound. This type is intentionally  abstract; to create a  you can use  or  ". The type parameter is a tag, or sort, which tells B us what sorts of things this name may stand for. The sort must  be an instance of the g type class.  Get the integer index of a . Get the string part of a . Get the integer index of an . Get the string part of an .  Create a  from an hi.  Create a  from a j. Convenient synonym for .  Create a  from a String and an Integer index. Determine the sort of a . Change the sort of a name    portable*Stephanie Weirich <sweirich@cis.upenn.edu>A  permutation- is a bijective function from names to names A 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. kl1Apply a permutation to an element of the domain. /Create a permutation which swaps two elements. "The empty (identity) permutation. >Compose two permutations. The right-hand permutation will be  applied first. !"Is this the identity permutation? "Join8 two permutations by taking the union of their relation D graphs. Fail if they are inconsistent, i.e. map the same element  to two different elements. #The support3 of a permutation is the set of elements which are  not fixed. $,Restrict a permutation to a certain domain. % mkPerm l1 l2" creates a permutation that sends l1 to l2. B Fail if there is no such permutation, either because the lists B have different lengths or because they are inconsistent (which  can only happen if l1 or l2 have repeated elements). mnop.Permutations form a monoid under composition.  !"#$%  #!"$%  !"#$%{&'('9 supports recursive patterns --- that is, patterns where @ any variables anywhere in the pattern are bound in the pattern & itself. Useful for lectrec (and Agda's dot notation). ()>Rebinding is for telescopes --- i.e. to support patterns that ' also bind variables that appear later *+8Shift the scope of an embedded term one level outwards. ,-An annotation is a hole in a pattern where variables > can be used, but not bound. For example patterns may include A type annotations, and those annotations can reference variables  without binding them. D Annotations do nothing special when they appear elsewhere in terms ./9Type of a binding. Morally, the type a should be in the  class Pattern' and the type b should be in the class Q. 7 The Pattern class contains the constructor and a safe  destructor for these types.  We can Bind an a object in a b object if we  can create fresh a objects, and Names can be  swapped in b objects. Often a is Name  but that need not be the case. 0123456789:;<=>?Locally fresh monad  This is the class of D monads that support freshness in an (implicit) local scope. Names D drawn are fresh for this particular scope, but not globally fresh. < This class has a basic instance based on the reader monad. @@pick a new name that is fresh for the current (implicit) scope. A9avoid these names when freshening in the subcomputation. BA monad m supports the fresh operation if it " can generate a new unique names. CDA monad m* supports the nextInteger operation if it ! can generate new fresh integers EFGHIJKLMNOPQ:The Alpha class is for all terms that may contain binders  The q) class constraint means that we can only 2 make instances of this class for types that have 5 generic representations. (Derive these using TH and  RepLib.) RS5swap everything, including bound and free variables,  parts in annots, etc. T The method swaps' applys a compound permutation U+calculate the free variables (aka support) V2list the binding variables in a pattern, in order WMatch'- compares two data structures and produces a 9 permutation of their free variables that will make them  alpha-equivalent to eachother. XAn object of type a can be freshened if a new  copy of a% can be produced where all old Names  in a, are replaced with new fresh Names, and the 9 permutation reports which names were swapped by others. YSee v ZMany of the operations in the Q class take an Z: D stored information about the iteration as it progresses. This type I is abstract, as classes that override these operations should just pass  the context on. [\]^_`abcdefghiSmart constructor for binders j7A destructor for binders that does not guarantee fresh  names for the binders. k$Constructor for binding in patterns l4destructor for binding patterns, the external names  should have already  been freshen'4ed. We swap the internal names so that they use the  external names mnop)calculate the free variables of the term q(List the binding variables in a pattern r@Set of variables that occur freely in annotations (not binding) s The method swaps, applys a permutation to all free variables  in the term. t;Apply a permutation to the binding variables in a pattern. 5 Embedded terms are left alone by the permutation. u=Apply a permutation to the annotations in a pattern. Binding * names are left alone by the permutation. vLocally freshen an object wA pattern of type b can be freshened if a new  copy of b/ can be produced where all old *binding* Names  in b, are replaced with new fresh Names, and the 9 permutation reports which Names were swapped by others. x>Match compares two data structures and produces a permutation 8 of their Names that will make them alpha-equivalent to C eachother. (Names that appear in annotations must match exactly.) > Also note that two terms are alpha-equivalent when the empty  permutation is returned. yACompare two patterns, ignoring the names of binders, and produce B a permutation of their annotations to make them alpha-equivalent  to eachother. Return r" if no such renaming is possible. z?Compare two patterns for equality and produce a permutation of  their binding Names- to make them alpha-equivalent to each other  (9s that appear in annotations must match exactly). Return  r" if no such renaming is possible. {|}~7Unbind is the destructor of a binding. It ensures that ' the names in the binding b are fresh. >Destruct two bindings simultanously, if they match, using the  same list of fresh names (Destruct a binding in the LFresh monad. @Capture-avoiding substitution, in a monad so that we can rename 2 variables at binding locations and avoid capture s1Reader monad instance for local freshness class. &'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~tuvwxyz{|}~z&21/0-.+,)*'(hgfedcba`_^]ijklmnopqrstuvwxyzZ\[{|}~QRSTUVWXYGHIJKLMNOPDEFBC?@A;<=>789:3654z&'(()**+,,-../00123654456789:89:;<=><=>?@A@ABCCDEFEFG HIJKLMNOPHIJKLMNOPQRSTUVWXYRSTUVWXYZ\[[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ non-portable (-XKitchenSink)  experimental +Stephanie Weirich <sweirich@cis.upenn.edu> J ')+-./;<=>?@ABCDEFQRSTUVWXYZ]_acegijklmnopqrsvwxJ/-.)'+ QRSTUVWXYsxqrpoijBCwDEF?@Avklmn;<=>Zegac_]GHC only (-XKitchenSink)$Brent Yorgey <byorgey@cis.upenn.edu>&A simple representation of multisets. >Collections are foldable types that support empty, singleton, = union, and map operations. The result of a free variable B 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. =Multisets are containers which preserve multiplicity but not  ordering. :Lists are containers under concatenation. Lists preserve * ordering and multiplicity of elements.  GHC only %Brent Yorgey <byorgey@cis.upenn.edu> 9s are things that get bound. This type is intentionally  abstract; to create a  you can use  or  ". The type parameter is a tag, or sort, which C tells us what sorts of things this name may stand for. The sort  must be a  representable type, i.e. an instance of the g  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  constructor directly; to * extract a name with a hidden sort, use . BTest whether a name is a bound variable (i.e. a reference to some E binding site, represented as a de Bruijn index). Normal users of E the library should not need this function, as it is impossible to E 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 . ?Cast a name with an existentially hidden sort to an explicitly  sorted name. Create a free  from an hi. Create a free  from a j. Convenient synonym for . Create a free  from a String and an Integer index. Determine the sort of a . Change the sort of a name. unportable (GHC 7 only)  experimental %Brent Yorgey <byorgey@cis.upenn.edu> +A convenient monad which is an instance of  . It keeps D track of a set of names to avoid, and when asked for a fresh one 0 will choose the first unused numerical name. @The LFresh monad transformer. Keeps track of a set of names to E avoid, and when asked for a fresh one will choose the first numeric 5 prefix of the given name which is currently unused. 9This is the class of monads that support freshness in an F (implicit) local scope. Generated names are fresh for the current 0 local scope, not necessarily globally fresh. @Pick a new name that is fresh for the current (implicit) scope. =Avoid the given names when freshening in the subcomputation, 5 that is, add the given names to the in-scope set. +A convenient monad which is an instance of  . It keeps E track of a global index used for generating fresh names, which is  incremented every time  is called. The FreshM5 monad transformer. Keeps track of the lowest index D still globally unused, and increments the index every time it is  asked for a fresh name. The Fresh2 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. Run a 7 computation (with the global index starting at zero). Run a 3 computation given a starting index for fresh name  generation. CRun a FreshM computation (with the global index starting at zero). 1Run a FreshM computation given a starting index. Run an " computation in an empty context. Run an , computation given a set of names to avoid. .Get the set of names currently being avoided. /Run a LFreshM computation in an empty context. 9Run a LFreshM computation given a set of names to avoid. GHC only experimental$Brent Yorgey <byorgey@cis.upenn.edu>8Shift the scope of an embedded term one level outwards. Embed allows for terms to be embedded within patterns. Such ? embedded terms do not bind names along with the rest of the E pattern. For examples, see the tutorial or examples directories. If t is a  term type, then Embed t is a  pattern type. Embed9 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 unembed, which B additionally can construct or destruct any number of enclosing  s at the same time.) TRec is a standalone variant of : the only difference is  that whereas  p is a pattern type, TRec p  is a  term type. It is isomorphic to  ( p) ().  Note that TRec corresponds to Pottier's  abstraction construct & from alpha-Caml. In this context,  t corresponds to  alpha-Caml's inner t, and  ( t) corresponds to  alpha-Caml's outer t. If p is a pattern type, then Rec p is also a pattern type,  which is  recursive in the sense that p may bind names in terms ? embedded within itself. Useful for encoding e.g. lectrec and  Agda's dot notation. Rebind allows for nested bindings. If p1 and p2 are  pattern types, then  Rebind p1 p2 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. AThe most fundamental combinator for expressing binding structure  is . The  term type Bind p t represents a pattern p  paired with a term t, where names in p are bound within t. Like , + is also abstract. You can create bindings  using bind and take them apart with unbind and friends. )GHC only (-XKitchenSink) %Brent Yorgey <byorgey@cis.upenn.edu> T=Class constraint hackery to allow us to override the default % definitions for certain classes.  is essentially a  reified dictionary for the   class. >A mode is basically a flag that tells us whether we should be C looking at the names in the term, or if we are in a pattern and  should only1 be looking at the names in the annotations. The  standard mode is to use %; many functions do this by default. Many of the operations in the   class take an : D stored information about the iteration as it progresses. This type I is abstract, as classes that override these operations should just pass  the context on. @A continuation which takes the remaining index and searches for D that location in a pattern, yielding a name or a remaining index 3 if the end of the pattern was reached too soon. The result of an  operation. We haven't yet reached the  required index; this is the # index into the remainder of the " pattern (which decreases as we  traverse the pattern). The name found at the given  index. The result of a  operation. We haven't found the name " (yet), but have seen this many  others while looking for it !The (first) index of the name we  sought  &Type class for embedded terms (either Embed or Shift).   4Construct an embedded term, which is an instance of   with any number of enclosing  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 Alpha7 type class is for types which may contain names. The  q: constraint means that we can only make instances of this C 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 A 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 E suffice, so you can make an instance for your data type by simply  declaring   instance Alpha MyType @Occasionally, however, it may be useful to override the default " implementations of one or more Alpha methods for a particular , type. For example, consider a type like   data Term = ... # | Annotation Stuff Term  where the  Annotation constructor of Term associates some sort B of annotation with a term --- say, information obtained from a A parser about where in an input file the term came from. This D information is needed to produce good error messages, but should < not be taken into consideration when, say, comparing two Terms , for alpha-equivalence. In order to make aeq ignore 7 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 t2 Note 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 x can be used as a valid * pattern. The default instance returns Just if at all B 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. isEmbed0 is needed internally for the implementation of  isPat. isEmbed is true for terms wrapped in Embed and zero  or more occurrences of Shift. The default implementation  simply returns False.  p n looks up the nth name in the pattern p B (zero-indexed), returning the number of names encountered if not  found. 9Find the (first) index of the name in the pattern if one = exists; otherwise, return the number of names encountered  instead. AFind 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 b C (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. '()*+,-./0123456789:;NthCont, forms a monoid: function composition which * short-circuits once a result is found.  FindResult0 forms a monoid which combines information from  several  operations. mappend takes the leftmost  :, and combines the number of names seen to the left of it 1 so we can correctly compute its global index. R      !"#$%&'()*+,-./0123456789:;R      !"#$%&'()*+,-./0123456789:;R         !"#$%&'()*+,-./0123456789:; GHC only (-XKitchenSink)$Brent Yorgey <byorgey@cis.upenn.edu><Reified class dictionary for A. =>?@AThe Subst2 class governs capture-avoiding substitution. To D derive this class, you only need to indicate where the variables 2 are in the data type, by overriding the method B. B?This is the only method which normally needs to be implemented ? explicitly. If the argument is a variable, return its name  wrapped in the FE constructor. Return r for > non-variable arguments. The default implementation always  returns r. CC nm sub tm substitutes sub for nm in tm . It has 0 a default generic implementation in terms of isvar. D>Perform several simultaneous substitutions. This method also 4 has a default generic implementation in terms of isvar. ESee B. FGHI<=>?@ABCDEFGHIEFABCD<=>?@GHI<=>?@=>?@ABCDBCDEFFGHI GHC only (-XKitchenSink)$Brent Yorgey <byorgey@cis.upenn.edu>J?A smart constructor for binders, also sometimes referred to as  "close"9. 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.) K#A destructor for binders that does not guarantee fresh  names for the binders. L$Constructor for rebinding patterns. M?Destructor for rebinding patterns. It does not need a monadic - context for generating fresh names, since Rebind can only occur  in the pattern of a ; hence a previous call to a (or D something similar) must have already freshened the names at this  point. N$Constructor for recursive patterns. O#Destructor for recursive patterns. P(Constructor for recursive abstractions. QADestructor for recursive abstractions which picks globally fresh  names for the binders. R2Destructor for recursive abstractions which picks locally fresh  names for binders (see ). S.Determine the alpha-equivalence of two terms. TBDetermine (alpha-)equivalence of patterns. Do they bind the same < variables in the same patterns and have alpha-equivalent & annotations in matching positions? U<An alpha-respecting total order on terms involving binders. V@Calculate the free variables (of any sort) contained in a term. WACalculate the free variables of a particular sort contained in a  term. XACalculate the variables (of any sort) that occur freely in terms A embedded within a pattern (but are not bound by the pattern). YBCalculate the variables of a particular sort that occur freely in G terms embedded within a pattern (but are not bound by the pattern). Z<Calculate the binding variables (of any sort) in a pattern. [<Calculate the binding variables (of a particular sort) in a  pattern. \Apply a permutation to a term. ];Apply a permutation to the binding variables in a pattern. 5 Embedded terms are left alone by the permutation. ^@Apply a permutation to the embedded terms in a pattern. Binding , names are left alone by the permutation. _"Locally"5 freshen a pattern, replacing all binding names with " new names that are not already "in scope". The second argument E is a continuation, which takes the renamed term and a permutation C that specifies how the pattern has been renamed. The resulting A 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. aUnbind (also known as "open"!) is the simplest destructor for C bindings. It ensures that the names in the binding are globally 4 fresh, using a monad which is an instance of the  type  class. bUnbind two terms with the same fresh names, provided the > binders have the same number of binding variables. If the @ patterns have different numbers of binding variables, return  Nothing2. Otherwise, return the renamed patterns and the  associated terms. c;Unbind three terms with the same fresh names, provided the ? binders have the same number of binding variables. See the  documentation for b for more details. dlunbind opens a binding in an  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 E monadic action is run in a context extended to avoid choosing new A names which are the same as the ones chosen for this binding. 4For more information, see the documentation for the  type  class. eAUnbind two terms with the same locally fresh names, provided the @ patterns have the same number of binding variables. See the  documentation for b and d for more details. f?Unbind three terms with the same locally fresh names, provided C the binders have the same number of binding variables. See the  documentation for b and d for more details. Compare for alpha-equality. JKLMNOPQRSTUVWXYZ[\]^_`abcdefJKLMNOPQRSTUVWXYZ[\]^_`abcdefJKLMNOPQRSTUVWXYZ[\]^_`abcdef GHC only (-XKitchenSink)  experimental %Brent Yorgey <byorgey@cis.upenn.edu> _      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLqMNOPQRSTUhVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzg !"#$%   ABCDEFJLMNOPQRSTUVWXYZ[\]^_`abcdeflJadbcef  LMNOPQRSTUWVYX[ZABCDEF #!"$%\^]`_ {   !"#$%&'()*+,-./0123345667789:;<=>?@@ABCDEFGHIJKLMNOOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~2:;  lm !"#$%&'GHIJK6677334589dfhjnOORSVWPbcaX[\`_Y @ @ A B C D   p q r t u v  w  y  x z { | } ~    (2    !egiko"# $%&%'%(%)%*%+%,%-%./0/1/2/3/4/5/6/7/8/9/:/;/</=/>/?/@/A/B/C/D/E/F/G/H/I/I/J/K/L/M/N/O/P/P/Q/R/S/T/T/U/V/W/X/X/Y/Z/[/\/\/]/^/^/_/`/a/b/c/d/efgfhfifjfkflfmfnfofpfqfrfsftfuvwvxvyvzv{v|v}v~vvvvvvvvvvvvvvvvvvvvvvvvvvv5     unbound-0.2.2Unbound.Nominal.Name Unbound.PermMUnbound.Nominal.Internal Unbound.UtilUnbound.LocallyNameless.NameUnbound.LocallyNameless.FreshUnbound.LocallyNameless.TypesUnbound.LocallyNameless.AlphaUnbound.LocallyNameless.SubstUnbound.LocallyNameless.OpsUnbound.NominalUnbound.LocallyNamelessAnyNameNameNmrAnyName rAnyName1name1name2name3name4name5name6name7name8name9name10name11 name2Integer name2StringanyName2IntegeranyName2String toSortedName integer2Name string2Names2nmakeNamegetR translatePermapplysingleemptycomposeisidjoinsupportrestrictmkPerm<>RecRebindRShiftEmbedBindBrRrR1ExpLAVSubstDsubstDsubstsDSubstisvarlsubstlsubstsLFreshlfreshavoidFreshfreshHasNext nextInteger resetNextAlphaDaeqDswapallDswapsDfvDbindersDmatchDfreshenD lfreshenDAlphaaeq'swapall'swaps'fv'binders'match'freshen' lfreshen'AlphaCtxPatTermrShiftrShift1rRecrRec1rRebindrRebind1rEmbedrEmbed1rNamerName1rBindrBind1bind unsafeUnbindrebindreopenrecunrecaeqfvbinderspatfvswaps swapsBinders swapsEmbedslfreshenfreshenmatch matchEmbeds matchBindersinitialpattermmodeaeqR1aeq1swapsR1 swapallR1fvR1fv1 bindersR1binders1matchR1match1 freshenR1freshenL lfreshenR1 lfreshenLunbindunbind2unbind3lunbindlunbind2lunbind3substsubstssubstR1substsR1rExprExp1nameAnameBnameCassertdo_testsemptyNEmkbigMultiset CollectionemptyC singletonunioncmapunionsfromListfilterCBnisBoundisFreeLFreshMLFreshMT unLFreshMTFreshMFreshMT unFreshMT runFreshMT contFreshMT runFreshM contFreshM runLFreshMT contLFreshMT getAvoids runLFreshM contLFreshMTRecisPatDisTermDisEmbedDcloseDopenDfindpatDnthpatD acompareDModeAClevelNthCont runNthCont NthResultCurIndexFound FindResult NamesSeenIndexIsEmbedEmbeddedembedunembed acompare'closeopenisPatisTermisEmbed nthpatrec findpatrecfindpatnthNamenthpatincrdecropenTopenPcloseTclosePcloseR1openR1 findpatR1findpatLnthpatR1nthpatLcombineisPatR1isTermR1 acompareR1lexord compareTupMisvarD SubstName substDefaultunrebindtrecuntrecluntrec aeqBindersacomparefvAnypatfvAny bindersAny RepLib-0.4.0Generics.RepLib.RRepInteger integer-gmpGHC.Integer.TypebaseGHC.BaseStringseteq $fMonoidPermGenerics.RepLib.R1Rep1 Data.MaybeNothing$fLFreshReaderTpermnaeqa10aa10ba10ca10d tests_aeqtests_fv tests_substbig1big2 tests_big$fCollectionSet$fCollectionMultiset$fCollection[]$fMonoidNthCont$fMonoidFindResult $fEqRebindGenerics.RepLib.PreludeLib showsPrecR1 maxBoundR1 minBoundR1 compareR1eqR1EqDOrdDBoundedDShowDGenerics.RepLib.Libgelemganygallgconcatcompcountflattengorgandgproductcrush rreduceR1 lreduceR1 enumerateR1 generateR1zeroR1gsumR1deepSeqRrnfRrnfdeepSeqsubtreesgsumGSumgsumDGSumDzeroZerozeroDZDZeroD generateD GenerateDgenerateGenerate enumerateD EnumerateD enumerate EnumerateshrinkDShrinkDshrinkShrinkrreduceDRreduceDlreduceDLreduceDrreduceRreducelreduceLreducefoldLeft foldRightFoldGenerics.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:::TypedConstr:<>SpineGenerics.RepLib.PreludeRepsrBool1rBoolrMaybe1rMayberEither1rEither rOrdering1 rOrderingrTup3_1rTup3rTup4_1rTup4rTup5_1rTup5rTup6_1rTup6rTup7_1rTup7Generics.RepLib.Derivederive_abstractderiverList1rTup2_1toRgetRepCInt1Char1Integer1Float1Double1 Rational1IOError1IO1Arrow1Data1 Abstract1R1dictSatrep1rConsEmbrNilEmbrListrPairEmbrTup2rUnitrUnitEmbIntCharFloatDoubleRationalIOErrorIOArrowDataAbstractConfixitynamelabelsfromtoEmbNonfixprecInfixInfixlInfixrFixityDTNil:*:ExMNil:+:MExMTuprep