!       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                                                         BSDsweirich@cis.upenn.edu experimental non-portableNone&';=CQSTV# RepLibA class of representable typesRepLibA heterogeneous list RepLibCons for a list of types RepLibAn empty list of types RepLiblInformation about a datatype, including its fully qualified name and representation of its type arguments.RepLib%An embedding between a list of types l and a datatype a, based on a particular data constructor. The to function is a wrapper for the constructor, the from function pattern matches on the constructor.RepLibRepresentation 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.RepLibA value of type R a is a representation of a type a.+RepLibUse a concrete  a for a  a dictionary/ *)'%!$(#& "+,-./012/*)'%!$(#& "  +,-./0127 7 7BSDsweirich@cis.upenn.edu experimental non-portableNone &';=>?STV(<VRepLib&Access a representation, given a proxyWRepLib.Transform a parameterized rep to a vanilla repEFGHIUTSRQPONMLKJVWXYIUTSRQPONMLKJGHEFVWXYTBDsweirich@cis.upenn.edu experimental non-portableNone &'KSTV5 RepLib)Given a type, produce its representation.RepLib.Generate an R-type constructor representation.RepLib<Decompose a type into a constructor and a list of arguments.RepLibIApply a type constructor to a certain number of copies of the unit type.RepLib=Generate the context parameters (see above) for a given type.RepLib6Generate a context parameter for a single constructor.RepLib*Compute the free type variables of a type.RepLibdApply a context parameter to the right number of equality proofs to get out the promised context.hRepLibOGenerate representations (both basic and parameterized) for a list of types.iRepLib6Generate abstract representations for a list of types.hihi5BSDsweirich@cis.upenn.edu experimental non-portableNone &';=>?V6qrstuvwxyz{|}~~}|{zyxwvutsrqBSDsweirich@cis.upenn.edu experimental non-portableNone &';<=>?V8BSDsweirich@cis.upenn.edu experimental non-portableNone &'DQSTVKRepLibSYB style monadic map typeRepLibSYB style query typeRepLibA SYB style traversalRepLib/A datastructure to store the results of findConRepLib+Determine if two reps are for the same typeRepLib0The type-safe cast operation, explicit argumentsRepLib0The type-safe cast operation, implicit argumentsRepLib8Leibniz equality between types, explicit representationsRepLib8Leibniz equality between types, implicit representationsRepLibHeterogeneous OrderingRepLibmGiven a list of constructor representations for a datatype, determine which constructor formed the datatype.RepLibA fold right operation for heterogeneous lists, that folds a function expecting a type type representation across each element of the list.RepLib#A fold left for heterogeneous listsRepLibA map for heterogeneous listsRepLib4Transform a heterogeneous list in to a standard listRepLibmapM for heterogeneous listsRepLib+Generate a heterogeneous list from metadataRepLib7Generate a heterogeneous list from metadata, in a monadRepLib%Generate a normal lists from metadataRepLib3Map a traversal across the kids of a data structure$$7None&'PRepLib0Polymorphic equality, given an R1 representationRepLib#Minimal completion of the Ord classRepLibTo generate the Bounded classRepLibTo generate the Bounded classRepLib$Minimal completion of the show class BSDsweirich@cis.upenn.edu non-portableNone &';<=>?VnRepLibNAll of the functions below are defined using instances of the following classRepLib8A general version of fold left, use for Fold class belowRepLib9A general version of fold right, use for Fold class belowRepLibGiven an element, return smaller elements of the same type for example, to automatically find small counterexamples when testingRepLib/enumerate the elements of a type, in DFS order.RepLib1Generate elements of a type up to a certain depthRepLib!Create a zero element of a type > ( zero :: ((Int, Maybe Int), Float)) ((0, Nothing), 0.0) RepLibAdd together all of the IntUs in a datastructure For example: gsum ( 1 , True, ("a", Maybe 3, []) , Nothing) 4RepLib)Produce all children of a datastructure with the same type. Note that subtrees is available for all representable types. For those that are not recursive datatypes, subtrees will always return the empty list. But, these trivial instances are convenient to have for the Shrink operation below.RepLibGRecursively force the evaluation of the first argument. For example, 6 deepSeq ( x , y ) z where x = ... y = ...  will evaluate both x and y then return zRepLibfForce the evaluation of *datatypes* to their normal forms. Other types are left alone and not forced.RepLib2Fold a bindary operation left over a datastructureRepLibMultiply all elements togetherRepLibEnsure all booleans are trueRepLib#Ensure at least one boolean is trueRepLibConvert to listRepLibCount number of as that appear in the argumentRepLib3Compose all functions in the datastructure together RepLib3Concatenate all lists in the datastructure together RepLib!Ensure property holds of all data RepLib%Ensure property holds of some element RepLib'Is an element stored in a datastructure<    <     ((c) The University of Pennsylvania, 2006BSDsweirich@cis.upenn.edu experimental non-portableNone&'QVRepLib The type constructor for readersRepLib(The type constructor for transformationsRepLib(The type constructor for transformationsbRepLib&Other first-class polymorphic wrapperseRepLibVWrapped generic functions; recall: [Generic c] would be legal but [Generic' c] not.hRepLib}The general scheme underlying generic functions assumed by gfoldl; there are isomorphisms such as GenericT = Generic T.iRepLib\Generic readers, say monadic builders, i.e., produce an "a" with the help of a monad "m".jRepLib)Generic builders i.e., produce an "a".kRepLibHGeneric monadic transformations, i.e., take an "a" and compute an "a"lRepLibDGeneric queries of type "r", i.e., take any "a" and return an "r"mRepLib?Generic transformations, i.e., take an "a" and return an "a"nRepLibaMake a generic transformation; start from a type-specific case; preserve the term otherwiseoRepLibXMake a generic query; start from a type-specific case; return a constant otherwisepRepLibhMake a generic monadic transformation; start from a type-specific case; resort to return otherwiseqRepLibwMake a generic monadic transformation for MonadPlus; use "const mzero" (i.e., failure) instead of return as default.rRepLibhMake a generic builder; start from a type-specific ase; resort to no build (i.e., mzero) otherwisesRepLibFlexible type extensiontRepLib7Extend a generic transformation by a type-specific caseuRepLib.Extend a generic query by a type-specific casevRepLib?Extend a generic monadic transformation by a type-specific casewRepLibAExtend a generic MonadPlus transformation by a type-specific casexRepLibExtend a generic builderyRepLibExtend a generic readerzRepLibLeft-biased choice on maybies{RepLib"Choice for monadic transformations|RepLibChoice for monadic queries}RepLib>Recover from the failure of monadic transformation by identity~RepLib7Recover from the failure of monadic query by a constant#\]^_`abcdefghijklmnopqrstuvwxyz{|}~#nopqrstuvwxymlkjihefgbcd_`a\]^z}~{| '(c) The University of Pennsylvania 2006BSDsweirich@cis.upenn.edu experimental non-portableNone&'QVRepLib5Apply a transformation everywhere in bottom-up mannerRepLib4Apply a transformation everywhere in top-down mannerRepLib4Variation on everywhere with an extra stop conditionRepLibMonadic variation on everywhereRepLibgApply a monadic transformation at least somewhere somewhere :: MonadPlus m => GenericM m -> GenericM m4Summarise all nodes in top-down, left-to-right orderRepLib0Get a list of all entities that meet a predicateRepLib2Look up a subterm by means of a maybe-typed filterRepLibBottom-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; 3rd argument f updates the synthesised data according to the given termRepLib+Compute size of an arbitrary data structureRepLib8Count the number of immediate subterms of the given termRepLib!Determine depth of the given termRepLib:Determine the number of all suitable nodes in a given termRepLib1Determine the number of all nodes in a given termRepLib=Determine the number of nodes of a given type in a given termRepLib9Find (unambiguously) an immediate subterm of a given typeBSDsweirich@cis.upenn.edu experimental non-portableNone&'l " &#($!%')*+,-./012EFGHIJKLMNOPQRSTUVWXYhiqrstuvwxyz{|}~    \]^_`abcdefghijklmnopqrstuvwxyz{|}~ None&';<=>?CV RepLib;Generic unifyStep. almost identical to polymorphic equality""     !!"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 h i j k l m n o p q r s t u v w x y z { | } ~                                                           (  %RepLib-0.5.4.1-DGJgGuwzFPC1m5VSWno85GGenerics.RepLibGenerics.RepLib.RGenerics.RepLib.R1Generics.RepLib.DeriveGenerics.RepLib.PreludeRepsGenerics.RepLib.AbstractRepsGenerics.RepLib.RepAuxGenerics.RepLib.PreludeLibGenerics.RepLib.LibGenerics.RepLib.SYB.AliasesGenerics.RepLib.SYB.SchemesGenerics.RepLib.UnifybaseData.Type.EqualityRefl:~: testEquality TestEqualityReprepMTupMNil:+::*:NilDTFixityNonfixInfixInfixlInfixrprecEmbtofromlabelsnamefixityConRIntCharIntegerFloatDoubleRationalIOErrorIOArrowDataAbstractEqualwithReprUnitEmbrUnitrTup2rPairEmbrListrNilEmbrConsEmb$fRep[]$fRep(,)$fRep()$fRep:~: $fRep(->)$fRepIO$fRepIOException $fRepRatio $fRepDouble $fRepFloat $fRepInteger $fRepChar$fRepInt$fOrdR$fEqR $fShowMTup$fShowDT$fShowRRep1rep1SatdictR1Int1Char1Integer1Float1Double1 Rational1IOError1IO1Arrow1Data1 Abstract1Equal1getRepCtoRrTup2_1rList1$fShowR1 $fRep1ctx[] $fRep1ctx(,) $fRep1ctx() $fRep1ctx:~: $fRep1ctx(->) $fRep1ctxIO$fRep1ctxRatio$fRep1ctxIOException$fRep1ctxDouble$fRep1ctxFloat$fRep1ctxInteger $fRep1ctxChar $fRep1ctxIntderivederive_abstract $fQuasiQN $fMonadQN $fFunctorQN$fMonadWriterQN $fMonadFailQN $fMonadIOQN$fApplicativeQNrBoolrBool1rMayberMaybe1rEitherrEither1 rOrdering rOrdering1rTup3rTup3_1rTup4rTup4_1rTup5rTup5_1rTup6rTup6_1rTup7rTup7_1$fRep1ctx(,,,,,,) $fRep(,,,,,,)$fRep1ctx(,,,,,) $fRep(,,,,,)$fRep1ctx(,,,,) $fRep(,,,,)$fRep1ctx(,,,) $fRep(,,,) $fRep1ctx(,,) $fRep(,,)$fRep1ctxOrdering $fRepOrdering$fRep1ctxEither $fRepEither$fRep1ctxMaybe $fRepMaybe $fRep1ctxBool $fRepBoolrMaprMap1rSetrSet1 $fRep1ctxSet$fRepSet $fRep1ctxMap$fRepMapSpineConstr:<>Typed:::MapM1Query1 Traversal1MapMQuery TraversalValeqRcastRcastgcastRgcastcompareRfindConfoldr_lfoldl_lmap_lmapQ_lmapM_lfromTupfromTupMtoListgmapTgmapQgmapMgmapT1gmapQ1gmapM1toSpine fromSpine$fOrdDT$fEqDT$fTestEqualityTYPERShowDBoundedDOrdDEqDeqR1 compareR1 minBoundR1 maxBoundR1 showsPrecR1$fSatEqD $fSatOrdD $fSatBoundedD $fSatShowDFold foldRightfoldLeftLreducelreduceRreducerreduceLreduceDlreduceDRreduceDrreduceDShrinkshrinkShrinkDshrinkD Enumerate enumerate EnumerateD enumerateDGenerategenerate GenerateD generateDZeroDZDzeroDZerozeroGSumDgsumDGSumgsumsubtreesdeepSeqrnfrnfRdeepSeqRgsumR1zeroR1 generateR1 enumerateR1 lreduceR1 rreduceR1crushgproductgandgorflattencountcompgconcatgallganygelem $fGSumSet $fGSumMap$fGSum[] $fGSum(,) $fGSumDouble $fGSumChar $fGSumInteger$fGSum() $fGSumBool $fGSumInt $fGSumFloat $fSatGSumD $fZeroSet $fZeroMap$fZero[] $fZero(,) $fZeroBool$fZero()$fZeroIOException $fZeroDouble $fZeroFloat $fZeroInteger $fZero(->) $fZeroChar $fZeroInt $fSatZeroD $fGenerateMap $fGenerateSet $fGenerate[] $fGenerate(,) $fGenerate()$fGenerateDouble$fGenerateFloat$fGenerateInteger$fGenerateChar $fGenerateInt$fSatGenerateD$fEnumerateMap$fEnumerateSet $fEnumerate[]$fEnumerate(,) $fEnumerate()$fEnumerateBool$fEnumerateDouble$fEnumerateFloat$fEnumerateInteger$fEnumerateChar$fEnumerateInt$fSatEnumerateD$fMonadM$fApplicativeM $fFunctorM $fShrinkMap $fShrinkSet $fShrink(,) $fShrink() $fShrinkChar $fShrink[] $fShrinkInt $fSatShrinkD $fRreducebSet $fRreducec[] $fRreducec(,)$fRreducebBool$fRreducebChar $fRreduceb() $fRreducebInt $fSatRreduceD $fLreducebSet $fLreducec[] $fLreducec(,)$fLreducebBool$fLreducebChar $fLreduceb() $fLreducebInt $fSatLreduceD $fFoldMap $fFoldSet$fFold[] 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 throwError unifyStepR1addConstraintsRL1 unifyStepEqdequeueConstraintqueueConstraintextendSubstitutionsolveUnificationsolveUnification'substR1 occursCheckR1 $fUnifynaa $fUnifynab $fSubstatt $fSubstatt' $fOccursnaa $fOccursnab$fSatUnifySubDreptyrepcon decomposeTyappUnits ctx_params genCtxParamtyFVapplyPfsarrMT