C'8      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy z { | } ~   non-portable experimentalgenerics@haskell.orgDetermine an identifier'(s status as infix or not. If infix, the 3 associativity and precedence are also determined. )Right-associative Infix with precedence. (Left-associative infix with precedence. 'Non-associative infix with precedence. ;Not infix. Precedence is same as function application (see ). The constructor type used in  and  to determine how to parse or  print the constructor. Infix (no record syntax) Record-style (nonfix or infix) !Standard (function-type, nonfix) GA constructor description containing useful meta-information about the E syntax used in the data declaration. This is particularly useful in   and 5 but may also be helpful in other generic functions. )Name of the constructor. If it is infix,  don't provide parentheses. Arity or number of arguments. (A list of labels used in record syntax. , They must be declared in the same order as  the data! declaration. The list should be + empty if the constructor is not a record. )Infix or not, associativity, precedence. LThe Embedding-Projection pair contains two functions for converting between I the datatype and its representation. This pair preserves an isomorphism  (ignoring _|_)s) between a datatype and its structure. Embed a datatype into its representation. Project datatype from its representation. The "product"8 encodes 2 constructor arguments. An analogous standard  Haskell type is (a, b). A pair of arguments The "sum"; encodes 2 constructor alternatives. An analogous standard  Haskell type is  a b. Right alternative Left alternative @ encodes a constructor with no arguments. An analogous standard  Haskell type is (). The only value of type  (ignoring _|_). &Get the precedence of a fixity value. Maximum precedence: 11 (Precedence for function application: 10 'Precedence for record construction: 11       non-portable experimentalgenerics@haskell.orgThe "< representation dispatcher for datatypes of functional kind  * -> *E, often called container types, type constructors, or functor types.  (No default implementation.) The "7 representation dispatcher for monomorphic types (kind *). H Every structure type and supported datatype should have an instance of   . (No default implementation.) "FThis class forms the foundation for defining generic functions with a H single generic argument. Each method represents a type case. The class N includes cases for primitive types, cases for the structural representation,  and the -, case for adding support for new datatypes. #JMany functions perform the same operation on the non-structural cases (as  well as %). The cases for constant datatypes (, ,  , , , and #) have a default implementation of  #,, thus a generic function may only override # if ; desired. Note that there is no default implementation for #  itself. DThe class context represents the intersection set of supported type  classes. $Case for the primitive type . (Default implementation:  #.) %Case for the primitive type . (Default implementation:  #.) &Case for the primitive type . (Default implementation:  #.) 'Case for the primitive type . (Default implementation:  #.) (Case for the primitive type . (Default implementation:  #.) ),Case for the structural representation type . It is used to E represent a constructor with no arguments. (Default implementation:  #.) *,Case for the structural representation type '(:+:)' , called "sum". It D is used to represent alternative choices between constructors. (No  default implementation.) +,Case for the structural representation type '(:*:)' , called "product". B It is used to represent multiple arguments to a constructor. (No  default implementation.) ,GCase for constructors. While not necessary for every generic function,  this method is required for  and . It is used to hold the ' meta-information about a constructor (  ), e.g. name, arity, 7 fixity, etc. (Since most generic functions do not use , and simply pass 2 the value through, the default implementation is const id.) -ACase for datatypes. This method is used to define the structural L representation of an arbitrary Haskell datatype. The first argument is the G embedding-projection pair, necessary for establishing the isomorphism A between datatype and representation. The second argument is the . run-time representation using the methods of ". (No default  implementation.)  !"#$%&'()*+,-"#$%&'()*+,- ! !!" #$%&'()*+,-#$%&'()*+,- non-portable experimentalgenerics@haskell.org .The 0< representation dispatcher for datatypes of functional kind  * -> *E, often called container types, type constructors, or functor types.  (No default implementation.) 0HThis class forms the foundation for defining generic functions with two K generic arguments. Each method represents a type case. The class includes M cases for primitive types, cases for the structural representation, and the  rtype, case for adding support for new datatypes. 1JMany functions perform the same operation on the non-structural cases (as  well as %). The cases for constant datatypes (, ,  , , , and #) have a default implementation of  1,, thus a generic function may only override 1 if ; desired. Note that there is no default implementation for 1  itself. DThe class context represents the intersection set of supported type  classes. 2Case for the primitive type . (Default implementation:  1.) 3Case for the primitive type . (Default implementation:  1.) 4Case for the primitive type . (Default implementation:  1.) 5Case for the primitive type . (Default implementation:  1.) 6Case for the primitive type . (Default implementation:  1.) 7,Case for the structural representation type . It is used to E represent a constructor with no arguments. (Default implementation:  1.) 8,Case for the structural representation type '(:+:)' , called "sum". It D is used to represent alternative choices between constructors. (No  default implementation.) 9,Case for the structural representation type '(:*:)' , called "product". B It is used to represent multiple arguments to a constructor. (No  default implementation.) :GCase for constructors. It is used to hold the meta-information about a  constructor (  .), e.g. name, arity, fixity, etc. (Since most  generic functions do not use rcon( and simply pass the value through, the  default implementation is const id.) ;ACase for datatypes. This method is used to define the structural J representation of an arbitrary Haskell datatype. The first two arguments D are the embedding-projection pairs, necessary for establishing the L isomorphisms between datatype and representation of the two generic types. H The third argument is the run-time representation using the methods of  0. (No default implementation.) ./0123456789:;0123456789:;././/0 123456789:;123456789:; non-portable experimentalgenerics@haskell.org <The >< representation dispatcher for datatypes of functional kind  * -> *E, often called container types, type constructors, or functor types.  (No default implementation.) >JThis class forms the foundation for defining generic functions with three K generic arguments. Each method represents a type case. The class includes M cases for primitive types, cases for the structural representation, and the  rtype, case for adding support for new datatypes. ?JMany functions perform the same operation on the non-structural cases (as  well as %). The cases for constant datatypes (, ,  , , , and #) have a default implementation of  ?,, thus a generic function may only override ? if ; desired. Note that there is no default implementation for ?  itself. DThe class context represents the intersection set of supported type  classes. @Case for the primitive type . (Default implementation:  ?.) ACase for the primitive type . (Default implementation:  ?.) BCase for the primitive type . (Default implementation:  ?.) CCase for the primitive type . (Default implementation:  ?.) DCase for the primitive type . (Default implementation:  ?.) E,Case for the structural representation type . It is used to E represent a constructor with no arguments. (Default implementation:  ?.) F,Case for the structural representation type '(:+:)' , called "sum". It D is used to represent alternative choices between constructors. (No  default implementation.) G,Case for the structural representation type '(:*:)' , called "product". B It is used to represent multiple arguments to a constructor. (No  default implementation.) HGCase for constructors. It is used to hold the meta-information about a  constructor (  .), e.g. name, arity, fixity, etc. (Since most  generic functions do not use rcon( and simply pass the value through, the  default implementation is const id.) IACase for datatypes. This method is used to define the structural L representation of an arbitrary Haskell datatype. The first three arguments D are the embedding-projection pairs, necessary for establishing the M isomorphisms between datatype and representation of the four generic types. I The fourth argument is the run-time representation using the methods of  >. (No default implementation.) <=>?@ABCDEFGHI>?@ABCDEFGHI<=<==> ?@ABCDEFGHI?@ABCDEFGHI non-portable experimentalgenerics@haskell.orgL  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI non-portable experimentalgenerics@haskell.orgJ Type for M MCollect values of type b from some value of type a. An empty list means O no values were collected. If you expected otherwise, be sure that you have an  instance such as   (KJ B) B for the type B that you are = collecting. See the description of this module for details. JKLMJKLMJKLKLM non-portable experimentalgenerics@haskell.org N Type for Q Q!Compare two values and return an  (i.e. LT, GT, or EQ). 4 This is implemented exactly as if the datatype was  deriving Ord. RLess than. Returns x < y. SLess than or equal to. Returns x <= y. TEqual to. Returns x == y. UNot equal to. Returns x /= y. VGreater than. Returns x > y. W"Greater than or equal to. Returns x >= y. XThe minimum of two values. YThe maximum of two values. NOPQRSTUVWXY NOPQTURSVWXY NOPOPQRSTUVWXY non-portable experimentalgenerics@haskell.orgZ Type for ` ].Associativity of the binary operator used for ` ^Right-associative _Left-associative `Apply a function ( a -> b -> b) to each element (a) of a container (f  a) and an accumulator value (b$) to produce an accumulated result (b). KThis is the most general form in which you must specify the associativity.  You may prefer to use a or b. aA right-associative variant of `. bA left-associative variant of `. c1Flatten the elements of a container into a list. KThis is the most general form in which you must specify the associativity.  You may prefer to use d or e. dA right-associative variant of c. Note that, for a list ls :: [a], flattenr ls == ls. eA left-associative variant of c. Note that, for a list ls :: [a], flattenl ls == reverse ls. fLExtract the first element of a container. If the container is empty, return  Nothing. KThis is the most general form in which you must specify the associativity.  You may prefer to use g or h. gA right-associative variant of f. Note that, for a list ls :: [a], fromJust (firstr ls) == head ls. hA left-associative variant of f. Note that, for a list ls :: [a], fromJust (firstl ls) == last ls. i>Determine if an element is a member of a container. This is a  generalization of the Prelude function of the same name. jBDetermine if an element is not a member of a container. This is a  generalization of the Prelude function of the same name. kLCompute the sum of all elements in a container. This is a generalization of  the Prelude function of the same name. l>Compute the product of all elements in a container. This is a  generalization of the Prelude function of the same name. mIDetermine the maximum element of a container. If the container is empty,  return ". This is a generalization of the Prelude function of the  same name. nIDetermine the minimum element of a container. If the container is empty,  return ". This is a generalization of the Prelude function of the  same name. oBCompute the conjunction of all elements in a container. This is a  generalization of the Prelude function of the same name. pBCompute the disjunction of all elements in a container. This is a  generalization of the Prelude function of the same name. q@Determine if any element in a container satisfies the predicate p. This  is a generalization of the Prelude function of the same name. r?Determine if all elements in a container satisfy the predicate p. This  is a generalization the Prelude function of the same name. Z[\]^_`abcdefghijklmnopqrZ[\]_^`bacedfhgopqrklmnijZ[\[\]_^^_`abcdefghijklmnopqr non-portable experimentalgenerics@haskell.org s Type for v GInterleave elements from two lists. Similar to (++), but swap left and 1 right arguments on every recursive application. From Mark Jones' talk at AFP2008 FDiagonalization of nested lists. Ensure that some elements from every 6 sublist will be included. Handles infinite sublists. From Mark Jones' talk at AFP2008 (Cartesian product with diagonalization. From Mark Jones' talk at AFP2008 E values starting with 0 and enumerating to the positive and negative  bounds. ENumeric and enumerable values starting with 0 and enumerating in the . positive and negative directions. Useful for , , and  . vIEnumerate the values of a datatype. If the number of values is infinite, O the result will be an infinite list. The remaining functions are derived from  v. wEnumerate the first n. values of a datatype. This is a shortcut for   n (v). x2Returns the first element of the enumeration from v . This is * often called the neutral or empty value. stuvwxstuvwxstutuvwx  non-portable experimentalgenerics@haskell.orgy Type for |  |?Apply a function to all elements of a container datatype (kind * -> *). } Replace all a -values in as with b. yz{|}yz{|}yz{z{|}  non-portable experimentalgenerics@haskell.org~ Type for   Look and trace1 - print the unconsumed part of the input string  (paren p) parses "(P0)" where p parses "P0" at precedence 0 7Read optional parentheses plus a single required pair. Read a , b without parens. Read  a , b , c without parens. Read  a , b , c , d without parens.  (paren p) parses "{P0}" where p parses "P0" at precedence 0 >Parse a Haskell token and verify that it is the one expected. Parse a record entry:  label = x[,]" where x comes from the parameter  parser p.  Generate a $ parser combinator for the datatype a that handles / operator precedence. This uses the library in  Text.ParserCombinators.ReadPrec$ and should be similar to a derived  implementation of Text.Read.readPrec. JNote that all of the other read functions in this module are derived from   . FAttempt to parse a value from the front of the string using the given  precedence.  4 returns a list of (parsed value, remaining string)  pairs. If parsing fails,   returns an empty list.  Generate a  $ parser combinator for the datatype a. This can be used  with Text.ParserCombinators.ReadP.  A variant of  " with the minimum precedence (0).  A variant of   that returns  Just value on a successful parse.  Otherwise,   returns (. Note that a successful parse requires & the input to be completely consumed. ~~~  non-portable experimentalgenerics@haskell.org Type for   KConvert a value to a readable string starting with the operator precedence K of the enclosing context. All of the remaining functions are derived from   .  A variant of  " with the minimum precedence (0).  A variant of   that returns a ! instead of .   non-portable experimentalgenerics@haskell.org Type for   FCombine two structurally equivalent containers into one by applying a ; function to every corresponding pair of elements. Returns  if f a  and f b? have different shapes. All other functions in this module are  derived from  . JCombine two containers into a single container with pairs of the original  elements. See  4 for restrictions. This is a generic version of the  Prelude function of the same name.   non-portable experimentalgenerics@haskell.org Type for   KSplits a container into two structurally equivalent containers by applying O a function to every element, which splits it into two corresponding elements. 5 All other functions in this module are derived from  . KTransforms a container of pairs into a container of first components and a B container of second components. This is a generic version of the Prelude  function of the same name. " non-portable experimentalgenerics@haskell.orgLJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ non-portable experimentalgenerics@haskell.orgEmbedding-projection pair for Bool Representation for Bool in "  non-portable experimentalgenerics@haskell.orgEmbedding-projection pair for  Either a b Representation for  Either a b in "  non-portable experimentalgenerics@haskell.orgEmbedding-projection pair for [a] Representation for [a] in " Representation for [a] in 0 Representation for [a] in >  non-portable experimentalgenerics@haskell.orgEmbedding-projection pair for Maybe a Representation for Maybe a in " Representation for Maybe a in 0 Representation for Maybe a in >  non-portable experimentalgenerics@haskell.orgEmbedding-projection pair for () Representation for () in " Embedding-projection pair for (a,b) Representation for (a,b) in " Embedding-projection pair for (a,b,c) Representation for (a,b,c) in " Embedding-projection pair for  (a,b,c,d) Representation for  (a,b,c,d) in " Embedding-projection pair for  (a,b,c,d,e) Representation for  (a,b,c,d,e) in " Embedding-projection pair for  (a,b,c,d,e,f) Representation for  (a,b,c,d,e,f) in " Embedding-projection pair for (a,b,c,d,e,f,h) Representation for (a,b,c,d,e,f,h) in " # non-portable experimentalgenerics@haskell.org$ non-portable experimentalgenerics@haskell.org  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~%&'()*+,-../012334566789::;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkklmnnopqrstuvwxyyz{|}~             emgm-0.1#Generics.EMGM.Common.RepresentationGenerics.EMGM.Common.BaseGenerics.EMGM.Common.Base2Generics.EMGM.Common.Base3Generics.EMGM.Functions.CollectGenerics.EMGM.Functions.CompareGenerics.EMGM.Functions.CrushGenerics.EMGM.Functions.EnumGenerics.EMGM.Functions.MapGenerics.EMGM.Functions.ReadGenerics.EMGM.Functions.ShowGenerics.EMGM.Functions.ZipWith!Generics.EMGM.Functions.UnzipWithGenerics.EMGM.Data.BoolGenerics.EMGM.Data.EitherGenerics.EMGM.Data.ListGenerics.EMGM.Data.MaybeGenerics.EMGM.Data.Tuplebase Text.Read Text.Show Data.Eitherghc-prim GHC.Typesinteger GHC.IntegerGenerics.EMGM.Common GHC.Ordering Data.Maybe Data.ListText.ParserCombinators.ReadPrecText.ParserCombinators.ReadP Data.CharGenerics.EMGM.FunctionsGenerics.EMGM.Data Generics.EMGMFixityInfixrInfixlInfixNonfixConTypeConIfxConRecConStdConDescrconNameconArity conLabels conFixityEPfromto:*::+:RLUnitprecmaxPrecappPrecrecPrecFRepfrepReprepGeneric rconstantrintrintegerrfloatrdoublercharrunitrsumrprodrconrtypeFRep2frep2Generic2 rconstant2rint2 rinteger2rfloat2rdouble2rchar2runit2rsum2rprod2rcon2rtype2FRep3frep3Generic3 rconstant3rint3 rinteger3rfloat3rdouble3rchar3runit3rsum3rprod3rcon3rtype3Collect selCollectcollectCompare selComparecompareltlteqeqneqgtgteqminmaxCrushselCrushAssoc AssocRight AssocLeftcrushcrushrcrushlflattenflattenrflattenlfirstfirstrfirstlelemnotElemsumproductmaximumminimumandoranyallEnumselEnumenumenumNemptyMapselMapmapreplaceReadselReadreadPrec readsPrecreadPreadsreadShowselShow showsPrecshowsshowZipWith selZipWithzipWithzip UnzipWith selUnzipWith unzipWithunzipepBoolrBoolepEitherrEitherepListrListrList2rList3epMayberMayberMaybe2rMaybe3epTuple0rTuple0epTuple2rTuple2epTuple3rTuple3epTuple4rTuple4epTuple5rTuple5epTuple6rTuple6epTuple7rTuple7GHC.ReadGHC.ShowEitherminPrecPrecIntGHC.Integer.InternalsIntegerFloatDoubleCharOrderingNothing|||diag><intEnumnumEnum genericTakeltraceparen wrapTupletuple2tuple3tuple4braceslexTrecEntryReadPrecReadPGHC.BaseStringShowS