h&+W&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]-(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimental-non-portable (local universal quantification) Safe-Inferred 1*^syb!The type constructor for builders_syb The type constructor for readers`syb The type constructor for queriesasyb(The type constructor for transformationsbsyb(The type constructor for transformationssyb&Other first-class polymorphic wrappers sybWrapped generic functions; recall: [Generic c] would be legal but [Generic' c] not. sybThe general scheme underlying generic functions assumed by gfoldl; there are isomorphisms such as GenericT = Generic T. sybGeneric readers, say monadic builders, i.e., produce an "a" with the help of a monad "m".syb)Generic builders i.e., produce an "a".sybGeneric monadic transformations, i.e., take an "a" and compute an "a"sybGeneric queries of type "r", i.e., take any "a" and return an "r"syb?Generic transformations, i.e., take an "a" and return an "a"sybMake a generic transformation; start from a type-specific case; preserve the term otherwisesybMake a generic query; start from a type-specific case; return a constant otherwisesybMake a generic monadic transformation; start from a type-specific case; resort to return otherwisesybMake a generic monadic transformation for MonadPlus; use "const mzero" (i.e., failure) instead of return as default.sybMake a generic builder; start from a type-specific ase; resort to no build (i.e., mzero) otherwisesybFlexible type extensionsyb7Extend a generic transformation by a type-specific casesyb.Extend a generic query by a type-specific casesyb?Extend a generic monadic transformation by a type-specific casesybExtend a generic MonadPlus transformation by a type-specific casesybExtend a generic buildersybExtend a generic readersybLeft-biased choice on maybessyb"Choice for monadic transformations sybChoice for monadic queries!syb>Recover from the failure of monadic transformation by identity"syb7Recover from the failure of monadic query by a constant#sybFlexible type extension$syb=Type extension of transformations for unary type constructors%syb?Type extension of monadic transformations for type constructors&syb/Type extension of queries for type constructors'syb/Type extension of readers for type constructors(syb0Type extension of builders for type constructorscsybFlexible type extension)syb=Type extension of transformations for unary type constructors*syb?Type extension of monadic transformations for type constructors+syb/Type extension of queries for type constructors,syb/Type extension of readers for type constructors-syb0Type extension of builders for type constructors.  !"#$%&'()*+,-. !" #$%&'()*+,--(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimental-non-portable (local universal quantification) Safe-InferredRdefghijklmnopqrstuvwxyz{|}~(c) 2008 Universiteit Utrecht BSD-stylegenerics@haskell.org experimental non-portable Safe-Inferred.sybConstruct the empty value for a datatype. For algebraic datatypes, the leftmost constructor is chosen./sybReturn a list of values of a datatype. Each value is one of the possible constructors of the datatype, populated with . values.././-(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimentalnon-portable (uses Data.Data) Safe-Inferred56>-(c) The University of Glasgow, CWI 2001--2003 BSD-style (see the LICENSE file)generics@haskell.org experimental-non-portable (local universal quantification) Safe-Inferred\<syb5Apply a transformation everywhere in bottom-up manner=syb4Apply a transformation everywhere in top-down manner>syb4Variation on everywhere with an extra stop condition?sybMonadic variation on everywhere@syb1Apply a monadic transformation at least somewhereAsyb4Summarise all nodes in top-down, left-to-right orderBsyb6Variation of "everything" with an added stop conditionCsybSummarise all nodes in top-down, left-to-right order, carrying some state down the tree during the computation, but not left-to-right to siblings.Dsyb0Get a list of all entities that meet a predicateEsyb2Look up a subterm by means of a maybe-typed filterFsybBottom-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 termGsyb+Compute size of an arbitrary data structureHsyb8Count the number of immediate subterms of the given termIsyb!Determine depth of the given termJsyb:Determine the number of all suitable nodes in a given termKsyb1Determine the number of all nodes in a given termLsyb=Determine the number of nodes of a given type in a given termMsyb9Find (unambiguously) an immediate subterm of a given type<=>?@ABCDEFGHIJKLM<=>?@ABCDEFGHIJKLM-(c) The University of Glasgow, CWI 2001--2003 BSD-style (see the LICENSE file)generics@haskell.org experimental(non-portable (uses Data.Generics.Basics) Safe-InferredNsyb/Generic show: an alternative to "deriving Show"Osyb Generic showsPsyb/Generic read: an alternative to "deriving Read"NOPNOP-(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimental-non-portable (local universal quantification) Safe-Inferredsyb=The type constructor needed for the definition of gmapAccumQrsybThe constant type constructor needed for the definition of gmapAccumQlsybThe identity type constructor needed for the definition of gmapAccumTsyb#A type constructor for accumulationQsybgfoldl with accumulationRsybgmapT with accumulationSsybApplicative versionTsybgmapM with accumulationUsybgmapQl with accumulationVsybgmapQr with accumulationWsybgmapQ with accumulationXsybTwin map for transformationYsyb#Twin map for monadic transformationZsybTwin map for queries[syb1Generic equality: an alternative to "deriving Eq"\sybGeneric zip controlled by a function with type-specific branches]syb4Generic comparison: an alternative to "deriving Ord" QRSTUVWXYZ[\] QRTUVWSXYZ[\]-(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimental(non-portable (uses Data.Generics.Basics) Safe-Inferreddefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\] -(c) The University of Glasgow, CWI 2001--2004/BSD-style (see the file libraries/base/LICENSE)generics@haskell.org experimental-non-portable (local universal quantification) Safe-Inferredzdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\] -(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimental-non-portable (local universal quantification) Safe-Inferred!<.  !"#$%&'()*+,- -(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimental-non-portable (local universal quantification) Safe-Inferred"/defghijklmnopqrstuvwxyz{|}~ -(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimental-non-portable (local universal quantification) Safe-Inferred#./ -(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimental-non-portable (local universal quantification) Safe-Inferred$f-(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimental-non-portable (local universal quantification) Safe-Inferred%+<=>?@ABCDEFGHIJKLM-(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimental-non-portable (local universal quantification) Safe-Inferred&NOP-(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimental-non-portable (local universal quantification) Safe-Inferred& QRSTUVWXYZ[\] !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvtuwtuxtuytuztu{tu|tu}tu~tututututututtutututututututututututututututututututututututututututututututututututututututututututututututtttttttttttttttttttttttttttttttttt"syb-0.7.2.2-Acq07xXxrPVIapkVV91I9NData.Generics.AliasesData.Generics.BuildersData.Generics.InstancesData.Generics.SchemesData.Generics.TextData.Generics.TwinsData.Generics.Basics Data.Generics Generics.SYBGenerics.SYB.AliasesGenerics.SYB.BasicsGenerics.SYB.BuildersGenerics.SYB.InstancesGenerics.SYB.SchemesGenerics.SYB.TextGenerics.SYB.Twins GenericM'GMunGM GenericQ'GQunGQ GenericT'GTunGTGeneric' unGeneric'GenericGenericRGenericBGenericMGenericQGenericTmkTmkQmkMmkMpmkRext0extTextQextMextMpextBextRorElsechoiceMpchoiceQ recoverMprecoverQext1ext1Text1Mext1Qext1Rext1Bext2Text2Mext2Qext2Rext2Bemptyconstrs $fDataFUN$fDataIO $fDataIORef$fDataST $fDataSTM $fDataMVar $fDataTVar$fDataThreadId$fDataStablePtr $fDataHandle$fDataDataType $fDataTyCon everywhere everywhere' everywhereBut everywhereM somewhere everything everythingButeverythingWithContextlistify something synthesizegsizeglengthgdepthgcount gnodecount gtypecount gfindtypegshowgshowsgread gfoldlAccum gmapAccumT gmapAccumA gmapAccumM gmapAccumQl gmapAccumQr gmapAccumQ gzipWithT gzipWithM gzipWithQgeqgzipgcompareBRQMText2base Data.DataDatatoConstrgunfoldgmapTgmapQrgmapQlgmapQigmapQgmapMpgmapMogmapMgfoldl dataTypeOf dataCast1 dataCast2Data.Typeable.InternalTypeableghc-prim GHC.TypesTyConFixityInfixPrefixDataTypeDataRepNoRepCharRepAlgRepIntRepFloatRep ConstrRep IntConstr FloatConstr AlgConstr CharConstrConstrConIndex tyconUQname tyconModule showConstr repConstr readConstr mkRealConstr mkNoRepTypemkIntegralConstr mkIntType mkFloatType mkDataType mkConstrTagmkConstr mkCharType mkCharConstrmaxConstrIndex isNorepType isAlgType indexConstr fromConstrM fromConstrB fromConstr dataTypeRep dataTypeNamedataTypeConstrs constrType constrRep constrIndex constrFixity constrFields Data.TypeableTypeRep typeRepTyContypeRepFingerprint typeRepArgstypeReptypeOf7typeOf6typeOf5typeOf4typeOf3typeOf2typeOf1typeOf splitTyConApp showsTypeRep rnfTypeRepmkFunTygcast2gcast1gcast funResultTyeqTcast tyConPackage tyConName tyConModuletyConFingerprint trLiftedReprnfTyCon Data.ProxyProxyData.Type.Equality:~~:HRefl:~:ReflQrCONSTIDA