!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                             non-portable experimentalsweirich@cis.upenn.eduNoneA class of representable types A heterogeneous list Cons for a list of types An empty list of types ,Information about a datatype, including its , fully qualified name and representation of  its type arguments. %An embedding between a list of types l and  a datatype a*, based on a particular data constructor. 7 The to function is a wrapper for the constructor, the 3 from function pattern matches on the constructor. 1Representation of a data constructor includes an : embedding between the datatype and a list of other types < as well as the representation of that list of other types. A value of type R a is a representation of a type a. @  !"#$%&'()*+,-./01 !"#$%&'()*+,.  !"#$%&'()*+,-./010*)('&%$#"!   +,-./01"    *)('&%$#"! +,-./01 !"#$%&'()*+, non-portable experimentalsweirich@cis.upenn.edu Safe-InferedC'Access a representation, given a proxy D/Transform a parameterized rep to a vanilla rep #23456789:;<=>?@ABCDEF-./0123456789:23456789:;<=>?@ABCDEF6BA@?>=<;:9874523CDEF23456 BA@?>=<;:987CDEF-./0123456789: non-portable experimentalsweirich@cis.upenn.eduNoneGFGenerate representations (both basic and parameterized) for a list of  types. H7Generate abstract representations for a list of types. GH;GHGHGH; non-portable experimentalsweirich@cis.upenn.eduNoneIJKLMNOPQRSTUVWXYZ<IJKLMNOPQRSTUVWXYZZYXWVUTSRQPONMLKJIIJKLMNOPQRSTUVWXYZ< non-portable experimentalsweirich@cis.upenn.eduNonecSYB style monadic map type dSYB style query type eA SYB style traversal f0A datastructure to store the results of findCon h,Determine if two reps are for the same type i1The type-safe cast operation, explicit arguments j1The type-safe cast operation, implicit arguments k9Leibniz equality between types, explicit representations l9Leibniz equality between types, implicit representations mHeterogeneous Ordering n<Given a list of constructor representations for a datatype, 2 determine which constructor formed the datatype. oFA fold right operation for heterogeneous lists, that folds a function G expecting a type type representation across each element of the list. p$A fold left for heterogeneous lists qA map for heterogeneous lists r5Transform a heterogeneous list in to a standard list smapM for heterogeneous lists t,Generate a heterogeneous list from metadata u8Generate a heterogeneous list from metadata, in a monad v&Generate a normal lists from metadata w4Map a traversal across the kids of a data structure '[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=>?$[\]^_`abcdefghijklmnopqrstuvwxyz{|}~$hjilkmnfgpoqrstuvedcwxyba`z{|^_[]\}~#[]\^_`abcdefghijklmnopqrstuvwxyz{|}~=>? non-portable experimentalsweirich@cis.upenn.edu Safe-Infered'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.edu Safe-Infered6Apply 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  None1Polymorphic equality, given an R1 representation $Minimal completion of the Ord class To generate the Bounded class To generate the Bounded class %Minimal completion of the show class @ABC @ABC  non-portable experimentalsweirich@cis.upenn.eduNoneDD  non-portable experimentalsweirich@cis.upenn.eduNone7All of the functions below are defined using instances  of the following class 9A general version of fold left, use for Fold class below :A general version of fold right, use for Fold class below ;Given an element, return smaller elements of the same type G for example, to automatically find small counterexamples when testing 0enumerate 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   ' ( zero :: ((Int, Maybe Int), Float))  ((0, Nothing), 0.0)   Add together all of the Ints in a datastructure  For example:  gsum ( 1 , True, (a , Maybe 3, [] ) , Nothing)  4 BProduce all children of a datastructure with the same type. Note C that subtrees is available for all representable types. For those C that are not recursive datatypes, subtrees will always return the E empty list. But, these trivial instances are convenient to have for  the Shrink operation below. .Recursively force the evaluation of the first  argument. For example,    deepSeq ( x , y ) z where  x = ...  y = ...    will evaluate both x and y then return z 4Force the evaluation of *datatypes* to their normal 3 forms. Other types are left alone and not forced. 3Fold a bindary operation left over a datastructure Multiply all elements together Ensure all booleans are true $Ensure at least one boolean is true Convert to list Count number of as that appear in the argument 4Compose all functions in the datastructure together 4Concatenate all lists in the datastructure together "Ensure property holds of all data &Ensure property holds of some element (Is an element stored in a datastructure EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~<<rEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None<Generic unifyStep. almost identical to polymorphic equality (     !     !           non-portable experimentalsweirich@cis.upenn.eduNone  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     !!"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoppqrstuvwxyz{|}~                                                          !"#$%&'()*+,-./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 g h i j k l m n o p q r s t u v w x y z { | } ~                           RepLib-0.5.3.1Generics.RepLibGenerics.RepLib.RGenerics.RepLib.R1Generics.RepLib.DeriveGenerics.RepLib.PreludeRepsGenerics.RepLib.RepAuxGenerics.RepLib.SYB.AliasesGenerics.RepLib.SYB.SchemesGenerics.RepLib.PreludeLibGenerics.RepLib.AbstractRepsGenerics.RepLib.LibGenerics.RepLib.Unifytype-equality-0.1.0.2Data.Type.EqualityRefl:=:eqTEqTReprepMTup:+:MNil:*:NilDTFixityInfixrInfixlInfixprecNonfixEmbtofromlabelsnamefixityConREqualAbstractDataArrowIOIOErrorRationalDoubleFloatIntegerCharIntrUnitEmbrUnitrTup2rPairEmbrListrNilEmbrConsEmbRep1rep1SatdictR1Equal1 Abstract1Data1Arrow1IO1IOError1 Rational1Double1Float1Integer1Char1Int1getRepCtoRrTup2_1rList1derivederive_abstractrBoolrBool1rMayberMaybe1rEitherrEither1 rOrdering rOrdering1rTup3rTup3_1rTup4rTup4_1rTup5rTup5_1rTup6rTup6_1rTup7rTup7_1Spine:<>ConstrTyped:::MapM1Query1 Traversal1MapMQuery TraversalValeqRcastRcastgcastRgcastcompareRfindConfoldr_lfoldl_lmap_lmapQ_lmapM_lfromTupfromTupMtoListgmapTgmapQgmapMgmapT1gmapQ1gmapM1toSpine fromSpine GenericM'GMunGM GenericQ'GQunGQ GenericT'GTunGTGeneric' unGeneric'GenericGenericRGenericBGenericMGenericQGenericTmkTmkQmkMmkMpmkRext0extTextQextMextMpextBextRorElsechoiceMpchoiceQ recoverMprecoverQ everywhere everywhere' everywhereBut everywhereM everythinglistify something synthesizegsizeglengthgdepthgcount gnodecount gtypecount gfindtypeShowDBoundedDOrdDEqDeqR1 compareR1 minBoundR1 maxBoundR1 showsPrecR1rMaprMap1rSetrSet1Fold foldRightfoldLeftLreducelreduceRreducerreduceLreduceDlreduceDRreduceDrreduceDShrinkshrinkShrinkDshrinkD Enumerate enumerate EnumerateD enumerateDGenerategenerate GenerateD generateDZeroDZDzeroDZerozeroGSumDgsumDGSumgsumsubtreesdeepSeqrnfrnfRdeepSeqRgsumR1zeroR1 generateR1 enumerateR1 lreduceR1 rreduceR1crushgproductgandgorflattencountcompgconcatgallganygelemOccurs occursCheckSubstsubstHasVaris_varvarUnify unifyStepUnificationStateUState uConstraintsuSubst UConstraintUC UnifySubD unifyStepDsubstD occursCheckDUM UnifyErrorProxy unifyStepR1addConstraintsRL1 unifyStepEqdequeueConstraintqueueConstraintextendSubstitutionsolveUnificationsolveUnification'substR1 occursCheckR1$fRep[]$fRep(,)$fRep()$fRep:=: $fRep(->)$fRepIO$fRepIOException $fRepRatio $fRepDouble $fRepFloat $fRepInteger $fRepChar$fRepInt$fOrdR$fEqR $fShowMTup$fShowDT$fShowR $fRep1ctx[] $fRep1ctx(,) $fRep1ctx() $fRep1ctx:=: $fRep1ctx(->) $fRep1ctxIO$fRep1ctxRatio$fRep1ctxIOException$fRep1ctxDouble$fRep1ctxFloat$fRep1ctxInteger $fRep1ctxChar $fRep1ctxInt$fShowR1 $fQuasiQN $fRepBool$fOrdDT$fEqDT$fEqTR $fSatShowD $fSatBoundedD $fSatOrdD$fSatEqD$fRepMap $fFoldMap $fFoldSet$fFold[] $fRreducebSet $fRreducec[] $fRreducec(,)$fRreducebBool$fRreducebChar $fRreduceb() $fRreducebInt $fLreducebSet $fLreducec[] $fLreducec(,)$fLreducebBool$fLreducebChar $fLreduceb() $fLreducebInt $fSatLreduceD $fSatRreduceD $fShrinkMap $fShrinkSet $fShrink(,) $fShrink() $fShrinkChar $fShrink[] $fShrinkInt$fMonadM $fSatShrinkD$fEnumerateMap$fEnumerateSet $fEnumerate[]$fEnumerate(,) $fEnumerate()$fEnumerateBool$fEnumerateDouble$fEnumerateFloat$fEnumerateInteger$fEnumerateChar$fEnumerateInt$fSatEnumerateD $fGenerateMap $fGenerateSet $fGenerate[] $fGenerate(,) $fGenerate()$fGenerateDouble$fGenerateFloat$fGenerateInteger$fGenerateChar $fGenerateInt$fSatGenerateD $fZeroSet $fZeroMap$fZero[] $fZero(,) $fZeroBool$fZero()$fZeroIOException $fZeroDouble $fZeroFloat $fZeroInteger $fZero(->) $fZeroChar $fZeroInt $fSatZeroD $fGSumSet $fGSumMap$fGSum[] $fGSum(,) $fGSumDouble $fGSumChar $fGSumInteger$fGSum() $fGSumBool $fGSumInt $fGSumFloat $fSatGSumD $fOccursnaa $fOccursnab $fSubstatt $fSubstatt' $fUnifynaa $fUnifynab$fSatUnifySubD