{      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                    non-portable experimentalsweirich@cis.upenn.edu,  !"#$%&'()*+,  !"#$%&'()*+.$#"!   %&'()*+,    $#"!  !"#$%&'()*+ non-portable experimentalsweirich@cis.upenn.edu,-./0123456789:;'Access a representation, given a proxy </Transform a parameterized rep to a vanilla rep =>?@,-./0123456789:;<=>?@0:987654321./,-;<=>?@,--.//0 :987654321123456789:;<=>?@ non-portable experimentalsweirich@cis.upenn.edu'ABCDEFGHISYB style monadic map type JSYB style query type KA SYB style traversal L0A datastructure to store the results of findCon MN,Determine if two reps are for the same type O1The type-safe cast operation, explicit arguments P1The type-safe cast operation, implicit arguments Q9Leibniz equality between types, explicit representations R:Leibniz equality between types, implicity representations S=Given a list of constructor representations for a datatype, 2 determine which constructor formed the datatype. TGA fold right operation for heterogeneous lists, that folds a function G expecting a type type representation across each element of the list. U$A fold left for heterogeneous lists VA map for heterogeneous lists W5Transform a heterogeneous list in to a standard list XmapM for heterogeneous lists Y,Generate a heterogeneous list from metadata Z8Generate a heterogeneous list from metadata, in a monad [&Generate a normal lists from metadata \5Map a traversal across the kids of a data structure ]^_`abc#ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc#NPORQSLMUTVWXYZ[KJI\]^HGF_`aDEACBbc#ACBBCDEEFGHIJKLMMNOPQRSTUVWXYZ[\]^_`abcdefgh1Polymorphic equality, given an R1 representation  i$Minimal completion of the Ord class !jTo generate the Bounded class kTo generate the Bounded class "l%Minimal completion of the show class defghijkl ghfiejkdl defghijkl non-portable experimentalsweirich@cis.upenn.edu#$%&'()*mn+,-op./01mnopqmnopqmnop non-portable experimentalsweirich@cis.upenn.edurstuvwxyz{|}~rstuvwxyz{|}~~}|{zyxwvutsrrstuvwxyz{|}~ non-portable experimentalsweirich@cis.upenn.eduA230enumerate the elements of a type, in DFS order. 2Generate elements of a type up to a certain depth  Create a zero element of a type Add together all of the Ints in a datastructure ;Produce all children of a datastructure with the same type N Note that subtrees is available for all representable types. For those that > are not recursive datatypes, subtrees will always return the B empty list. But, these trivial instances are convenient to have ! for the Shrink operation below. 8deepSeq recursively forces the evaluation of its entire  argument. :rnf forces the evaluation of *datatypes* to their normal = forms. However, other types are left alone and not forced. 456<<< non-portable experimentalsweirich@cis.upenn.edu/7!The type constructor for readers 89:!The type constructor for queries ;<=)The type constructor for transformations >?@)The type constructor for transformations AB'Other first-class polymorphic wrappers Wrapped generic functions;  recall: [Generic c] would be legal but [Generic' c] not. 0The general scheme underlying generic functions 5 assumed by gfoldl; there are isomorphisms such as  GenericT = Generic T. 'Generic readers, say monadic builders,  i.e., produce an "a" with the help of a monad "m". Generic builders  i.e., produce an "a". !Generic monadic transformations,  i.e., take an "a" and compute an "a" Generic queries of type "r",  i.e., take any "a" and return an "r" Generic transformations,  i.e., take an "a" and return an "a" Make a generic transformation; $ start from a type-specific case;  preserve the term otherwise Make a generic query; $ start from a type-specific case;  return a constant otherwise 'Make a generic monadic transformation; $ start from a type-specific case;  resort to return otherwise 5Make a generic monadic transformation for MonadPlus;  use " const mzero"/ (i.e., failure) instead of return as default. Make a generic builder; # start from a type-specific ase; . resort to no build (i.e., mzero) otherwise Flexible type extension 8Extend a generic transformation by a type-specific case /Extend a generic query by a type-specific case @Extend a generic monadic transformation by a type-specific case BExtend a generic MonadPlus transformation by a type-specific case Extend a generic builder Extend a generic reader Left-biased choice on maybies #Choice for monadic transformations Choice for monadic queries ?Recover from the failure of monadic transformation by identity 8Recover from the failure of monadic query by a constant ###  non-portable experimentalsweirich@cis.upenn.edu6Apply a transformation everywhere in bottom-up manner 5Apply a transformation everywhere in top-down manner 5Variation on everywhere with an extra stop condition  Monadic variation on everywhere 2Apply a monadic transformation at least somewhere 6 somewhere :: MonadPlus m => GenericM m -> GenericM m 5Summarise all nodes in top-down, left-to-right order 1Get a list of all entities that meet a predicate 3Look up a subterm by means of a maybe-typed filter )Bottom-up synthesis of a data structure; < 1st argument z is the initial element for the synthesis; = 2nd argument o is for reduction of results from subterms; K 3rd argument f updates the synthesised data according to the given term ,Compute size of an arbitrary data structure 9Count the number of immediate subterms of the given term "Determine depth of the given term ;Determine the number of all suitable nodes in a given term 2Determine the number of all nodes in a given term >Determine the number of nodes of a given type in a given term :Find (unambiguously) an immediate subterm of a given type   <Generic unifyStep. almost identical to polymorphic equality     !  C                 non-portable experimentalsweirich@cis.upenn.edu  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~D   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                         jklm !"#$%&'()*+,,-./!!0112,,3445 67 RepLib-0.2.2 Data.RepLib.RData.RepLib.R1Data.RepLib.RepAuxData.RepLib.PreludeLibData.RepLib.DeriveData.RepLib.PreludeRepsData.RepLib.LibData.RepLib.SYB.AliasesData.RepLib.SYB.SchemesData.RepLib.Unify Data.RepLibReprepMTup:+:MNil:*:NilConDTFixityInfixrInfixlInfixprecNonfixEmbtofromlabelsnamefixityRDataArrowIOIOErrorRationalDoubleFloatIntegerCharIntrUnitEmbrUnitrTup2rPairEmbrListrNilEmbrConsEmbRep1rep1SatdictR1Data1Arrow1IO1IOError1 Rational1Double1Float1Integer1Char1Int1getReptoRrTup2_1rList1rNil1rCons1Spine:<>ConstrTyped:::MapM1Query1 Traversal1MapMQuery TraversalValcompRcastRcastgcastRgcastfindConfoldr_lfoldl_lmap_lmapQ_lmapM_lfromTupfromTupMtoListgmapTgmapQgmapMgmapT1gmapQ1gmapM1toSpine fromSpineShowDBoundedDOrdDEqDeqR1 compareR1 minBoundR1 maxBoundR1 showsPrecR1reprreprsrepr1repr1sderiverTup7rTup7_1rTup6rTup6_1rTup5rTup5_1rTup4rTup4_1rTup3rTup3_1 rOrdering rOrdering1rEitherrEither1rMayberMaybe1rBoolrBool1Fold foldRightfoldLeftLreducelreduceRreducerreduceLreduceDlreduceDRreduceDrreduceDShrinkshrinkShrinkDshrinkD Enumerate enumerate EnumerateD enumerateDGenerategenerate GenerateD generateDZeroDZDzeroDZerozeroGSumDgsumDGSumgsumsubtreesdeepSeqrnfrnfRdeepSeqRgsumR1zeroR1 generateR1 enumerateR1 lreduceR1 rreduceR1crushgproductgandgorflattencountcompgconcatgallganygelem GenericM'GMunGM GenericQ'GQunGQ GenericT'GTunGTGeneric' unGeneric'GenericGenericRGenericBGenericMGenericQGenericTmkTmkQmkMmkMpmkRext0extTextQextMextMpextBextRorElsechoiceMpchoiceQ recoverMprecoverQ everywhere everywhere' everywhereBut everywhereM everythinglistify something synthesizegsizeglengthgdepthgcount gnodecount gtypecount gfindtypeOccurs occursCheckSubstsubstHasVaris_varvarUnify unifyStepUnificationStateUState uConstraintsuSubst UConstraintUC UnifySubD unifyStepDsubstD occursCheckDUM UnifyErrorProxy unifyStepR1addConstraintsRL1dequeueConstraintqueueConstraintextendSubstitutionsolveUnificationsolveUnification'substR1 occursCheckR1compDTcompRTuptoSpineR toSpineRl showsPrecD minBoundD maxBoundDcompareDeqDeqRL1lexord compareTup getFixityreptyrNamerName1repconrfromrtorembrepDT ctx_params lookupNamerepcon1 stringNametypeInfo simpleName tyVarBndrNameM deepSeq_lgenEnum enumerateConsunRQunQunMTunT unifyStepEq