h&C?q      !"#$%&'()*+,-./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%,_syb!The type constructor for builders`syb The type constructor for readersasyb The type constructor for queriesbsyb(The type constructor for transformationscsyb(The type constructor for transformationssybThe type synonym  has a polymorphic type, and can therefore not appear in places where monomorphic types are expected, for example in a list. The data type ` wraps ) in a data type to lift this restriction.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".sybThe type synonym   has a polymorphic type, and can therefore not appear in places where monomorphic types are expected, for example in a list. The newtype  ` wraps  ' in a newtype to lift this restriction. sybGeneric monadic transformations, i.e., take an "a" and compute an "a" sybThe type synonym   has a polymorphic type, and can therefore not appear in places where monomorphic types are expected, for example in a list. The newtype  ` wraps  ' in a newtype to lift this restriction. sybGeneric queries of type "r", i.e., take any "a" and return an "r"sybThe type synonym  has a polymorphic type, and can therefore not appear in places where monomorphic types are expected, for example in a list. The newtype ` wraps ' in a newtype to lift this restriction.syb?Generic transformations, i.e., take an "a" and return an "a"sybExtend the identity function with a type-specific transformation. The function created by mkT ext behaves like the identity function on all arguments which cannot be cast to type b, and like the function ext otherwise. The name $ is short for "make transformation".Examples mkT not TrueFalse mkT not 'a''a'sybThe function created by  mkQ def f returns the default result def( if its argument cannot be cast to type b/, otherwise it returns the result of applying f to its argument. The name  is short for "make query".Examples+mkQ "default" (show :: Bool -> String) True"True")mkQ "default" (show :: Bool -> String) () "default"syb"Extend the default monadic action pure :: Monad m => a -> m a= by a type-specific monadic action. The function created by mkM act behaves like d) if its argument cannot be cast to type b, and like the monadic action act otherwise. The name , is short for "make monadic transformation".ExamplesmkM (\x -> [x, not x]) True [True,False]!mkM (\x -> [x, not x]) (5 :: Int)[5]sybExtend the default e action  const mzero by a type-specific e" action. The function created by mkMp act behaves like  const mzero) if its argument cannot be cast to type b, and like the monadic action act otherwise. The name . is short for "make MonadPlus transformation".ExamplesmkMp (\x -> Just (not x)) True Just FalsemkMp (\x -> Just (not x)) 'a'NothingsybMake a generic reader from a type-specific case. The function created by mkR f behaves like the reader f if an expression of type a can be cast to type b, and like the expression mzero otherwise. The name  is short for "make reader".ExamplesmkR (Just True) :: Maybe Bool Just TruemkR (Just True) :: Maybe IntNothingsybFlexible type extensionExamples,ext0 [1 :: Int, 2, 3] [True, False] :: [Int][1,2,3]/ext0 [1 :: Int, 2, 3] [4 :: Int, 5, 6] :: [Int][4,5,6]sybExtend a generic transformation by a type-specific transformation. The function created by  extT def ext* behaves like the generic transformation def, if its argument cannot be cast to the type b-, and like the type-specific transformation ext otherwise. The name & is short for "extend transformation".ExamplesextT id not TrueFalseextT id not 'a''a'sybExtend a generic query by a type-specific query. The function created by  extQ def ext! behaves like the generic query def, if its argument cannot be cast to the type b$, and like the type-specific query ext otherwise. The name  is short for "extend query".ExamplesextQ (const True) not TrueFalseextQ (const True) not 'a'TruesybExtend a generic monadic transformation by a type-specific case. The function created by  extM def ext* behaves like the monadic transformation def( if its argument cannot be cast to type b', and like the monadic transformation ext otherwise. The name . is short for "extend monadic transformation".Examples)extM (\x -> [x,x])(\x -> [not x, x]) True [False,True]/extM (\x -> [x,x])(\x -> [not x, x]) (5 :: Int)[5,5]sybExtend a generic MonadPlus transformation by a type-specific case. The function created by  extMp def ext behaves like e transformation def) if its argument cannot be cast to type b, and like the transformation ext otherwise. Note that  behaves exactly like  . The name 0 is short for "extend MonadPlus transformation".Examples*extMp (\x -> [x,x])(\x -> [not x, x]) True [False,True]0extMp (\x -> [x,x])(\x -> [not x, x]) (5 :: Int)[5,5]sybExtend a generic builder by a type-specific case. The builder created by  extB def ext returns def if ext cannot be cast to type a , and like ext otherwise. The name  is short for "extend builder".Examples extB True 'a'TrueextB True FalseFalsesybExtend a generic reader by a type-specific case. The reader created by  extR def ext behaves like the reader def if expressions of type b cannot be cast to type a, and like the reader ext otherwise. The name  is short for "extend reader".ExamplesextR (Just True) (Just 'a') Just TrueextR (Just True) (Just False) Just FalsesybLeft-biased choice on maybesExamplesorElse Nothing NothingNothingorElse Nothing (Just 'a')Just 'a'orElse (Just 'a') NothingJust 'a'orElse (Just 'a') (Just 'b')Just 'a'syb"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 constructors)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 constructors syb The type-specific transformationsyb$The argument we try to cast to type bsybThe default resultsyb5The transformation to apply if the cast is successfulsyb$The argument we try to cast to type bsyb(The type-specific monadic transformationsyb$The argument we try to cast to type bsyb"The type-specific MonadPlus actionsyb$The argument we try to cast to type bsybThe type-specific readersyb$The transformation we want to extendsyb The type-specific transformationsyb$The argument we try to cast to type bsybThe query we want to extendsybThe type-specific querysyb$The argument we try to cast to type bsyb,The monadic transformation we want to extendsyb(The type-specific monadic transformationsyb$The argument we try to cast to type bsybThe e! transformation we want to extendsybThe type-specific e transformationsyb$The argument we try to cast to type bsybThe default resultsyb$The argument we try to cast to type asyb$The generic reader we want to extendsybThe type-specific reader/  !"#$%&'()*+,-./ !" #$%&'()*+,-.-(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&6fghijklmnopqrstuvwxyz{|}~(c) 2008 Universiteit Utrecht BSD-stylegenerics@haskell.org experimental non-portable Safe-Inferred(n/sybConstruct the empty value for a datatype. For algebraic datatypes, the leftmost constructor is chosen.0sybReturn a list of values of a datatype. Each value is one of the possible constructors of the datatype, populated with / values./0/0-(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 everywhereAsyb1Apply a monadic transformation at least somewhereBsyb4Summarise all nodes in top-down, left-to-right orderCsyb6Variation of "everything" with an added stop conditionDsybSummarise 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.Esyb0Get a list of all entities that meet a predicateFsyb2Look up a subterm by means of a maybe-typed filterGsybBottom-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 termHsyb+Compute size of an arbitrary data structureIsyb8Count the number of immediate subterms of the given termJsyb!Determine depth of the given termKsyb:Determine the number of all suitable nodes in a given termLsyb1Determine the number of all nodes in a given termMsyb=Determine the number of nodes of a given type in a given termNsyb9Find (unambiguously) an immediate subterm of a given type=>?@ABCDEFGHIJKLMN=>?@ABCDEFGHIJKLMN-(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-Inferred1Osyb/Generic show: an alternative to "deriving Show"Psyb Generic showsQsyb/Generic read: an alternative to "deriving Read"OPQOPQ-(c) The University of Glasgow, CWI 2001--2004 BSD-style (see the LICENSE file)generics@haskell.org experimental-non-portable (local universal quantification) Safe-Inferred5[syb=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 accumulationRsybgfoldl with accumulationSsybgmapT with accumulationTsybApplicative versionUsybgmapM with accumulationVsybgmapQl with accumulationWsybgmapQr with accumulationXsybgmapQ with accumulationYsybTwin map for transformationZsyb#Twin map for monadic transformation[sybTwin 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" RSTUVWXYZ[\]^ RSUVWXTYZ[\]^-(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-Inferred66fghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0=>?@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-Inferred8 fghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0=>?@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-Inferred9/  !"#$%&'()*+,-. -(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:fghijklmnopqrstuvwxyz{|}~ -(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<5/0 -(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==>?@ABCDEFGHIJKLMN-(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>OPQ-(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?` RSTUVWXYZ[\]^ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvtuwtxytxztx{tx|tx}tx~txtxtxtxtxtxtxtxtxttxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxtxttttttttttttttttttttttttttttttttttt"syb-0.7.2.4-8UwAVuB8SsIHuyoD5S7L5CData.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.TwinsGeneric' unGeneric'GenericGenericRGenericB GenericM'GMunGMGenericM GenericQ'GQunGQGenericQ GenericT'GTunGTGenericTmkTmkQmkMmkMpmkRext0extTextQextMextMpextBextRorElsechoiceMpchoiceQ recoverMprecoverQext1ext1Text1Mext1Qext1Rext1Bext2ext2Text2Mext2Qext2Rext2Bemptyconstrs $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 gzipWithQgeqgzipgcompareBRQMTbaseGHC.Basepure MonadPlus 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