úÎ ÔÆHÄ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…† ‡ ˆ ‰ Š ‹ Œ Ž ‘ ’ “ ” • – — ˜ ™ š › œ ž Ÿ   ¡ ¢ £ ¤ ¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂà non-portable experimentalgenerics@haskell.org non-portable experimentalgenerics@haskell.org non-portable experimentalgenerics@haskell.org non-portable experimentalgenerics@haskell.org IList of pairs mapping a (type or constructor) name to a modifier action. *Modify the action taken for a given name. 4Use this for the name of a user-defined constructor / description instead of a generated one. The + generated code assumes the existance of conX ::  ConDescr (in scope) if the argument is "X". (Change the syntactic name (of a type or 1 constructor) to the argument in the generated EP  or ConDescr& value. This results in a value named  epX or conX if the argument is "X". Ä!Normalized form of a constructor Å+Normalized form of a datatype declaration (data and newtype) Æ$Select the i-th field in an n-tuple ÇCi: initial type, f: final type, s: sum element, p: product element ÈEApply a function to each of 3 cases of a list: 0, 1, or > 1 elements ÉLGiven a unit value, an injection function, and a product operator, create a  product form out of a list. ÊJGiven a prefix string, a possible string for the type name, a name, and a O suffix string, create a function that appends either the type string name (if 8 it exists) or the base of the type name to the prefix. Ë!Report an error message and fail ÄÌÍÎÏÐÅÑÒÓÔÕÖÆÇ×ØÈÉÊËÄÌÍÎÏÐÌÍÎÏÐÅÑÒÓÔÕÑÒÓÔÕÖÆÇ×ØÈÉÊË non-portable experimentalgenerics@haskell.org An identifier'6s fixity, associativity, and precedence. If not infix  (E), the associativity and precedence of the identifier is the same as G function application. If infix, the associativity is indicated by the 6 constructor and the precedence is an argument to it. )Right-associative Infix with precedence. (Left-associative infix with precedence. 'Non-associative infix with precedence. NNot infix. Associativity and precedence are the same as function application. 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. NOTE: It is important that the   value accurately describe the K syntax in a constructor declaration. An incorrect description may lead to  faulty Ù or Ú operation. )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 ) the datatype and its representation. An EP value preserves an isomorphism  (ignoring _|_8s) between a datatype and its structure representation. 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 The "unit"@ encodes a constructor with no arguments. An analogous standard  Haskell type is (). The only value of type Unit (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.org"The &3 representation dispatcher for functor types (kind * -> *), @ sometimes called container 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 1, 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 :+: (sum). It D is used to represent alternative choices between constructors. (No  default implementation.) /,Case for the structural representation type :*: (product). B It is used to represent multiple arguments to a constructor. (No  default implementation.) 0GCase 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 0 and simply pass 2 the value through, the default implementation is const id.) 1ACase 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.) "#$%&'()*+,-./01&'()*+,-./01$%"#"##$%%& '()*+,-./01'()*+,-./01 non-portable experimentalgenerics@haskell.org2The 65 representation dispatcher for bifunctor types (kind   * -> * -> * ). (No default implementation.) 4The 63 representation dispatcher for functor types (kind * -> *), @ sometimes called container types. (No default implementation.) 6HThis 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. 7JMany functions perform the same operation on the non-structural cases (as  well as %). The cases for constant datatypes (Þ, ß,  à, á, â, and #) have a default implementation of  7,, thus a generic function may only override 7 if ; desired. Note that there is no default implementation for 7  itself. DThe class context represents the intersection set of supported type  classes. 8Case for the primitive type Þ. (Default implementation:  7.) 9Case for the primitive type ß. (Default implementation:  7.) :Case for the primitive type à. (Default implementation:  7.) ;Case for the primitive type á. (Default implementation:  7.) <Case for the primitive type â. (Default implementation:  7.) =,Case for the structural representation type . It is used to E represent a constructor with no arguments. (Default implementation:  7.) >,Case for the structural representation type :+: (sum). It D is used to represent alternative choices between constructors. (No  default implementation.) ?,Case for the structural representation type :*: (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.) AACase 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  6. (No default implementation.) 23456789:;<=>?@A6789:;<=>?@A45232334556 789:;<=>?@A789:;<=>?@A non-portable experimentalgenerics@haskell.org BThe D3 representation dispatcher for functor types (kind * -> *), @ sometimes called container types. (No default implementation.) DJThis 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. EJMany functions perform the same operation on the non-structural cases (as  well as %). The cases for constant datatypes (Þ, ß,  à, á, â, and #) have a default implementation of  E,, thus a generic function may only override E if ; desired. Note that there is no default implementation for E  itself. DThe class context represents the intersection set of supported type  classes. FCase for the primitive type Þ. (Default implementation:  E.) GCase for the primitive type ß. (Default implementation:  E.) HCase for the primitive type à. (Default implementation:  E.) ICase for the primitive type á. (Default implementation:  E.) JCase for the primitive type â. (Default implementation:  E.) K,Case for the structural representation type . It is used to E represent a constructor with no arguments. (Default implementation:  E.) L,Case for the structural representation type :+: (sum). It D is used to represent alternative choices between constructors. (No  default implementation.) M,Case for the structural representation type :*: (product). B It is used to represent multiple arguments to a constructor. (No  default implementation.) NGCase 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.) OACase 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  D. (No default implementation.) BCDEFGHIJKLMNODEFGHIJKLMNOBCBCCD EFGHIJKLMNOEFGHIJKLMNO non-portable experimentalgenerics@haskell.orgPLThe type of a generic function that takes a value of one type and returns a ! list of values of another type. KFor datatypes to work with Collect, a special instance must be given. This , instance is trivial to write. Given a type D, the $ instance looks like  this:  ( {-# LANGUAGE OverlappingInstances #-}   data D = ...  # instance Rep (Collect D) D where  rep = Collect (:[]) M(Note the requirement of overlapping instances.) This instance triggers when  the result type (the first D&) matches some value type (the second D) " contained within the argument to S$. See the source of this module for  more examples. SCollect 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 $ (QP B) B for the type B that you are  collecting. collectD works by searching a datatype for values that are the same type as L the return type specified. Here are some examples using the same value but  different return types:    ghci> let x = [Left 1, Right a, Left 2] :: [Either Int Char]  ghci> collect x :: [Int]  [1,2]  ghci> collect x :: [Char]  "a"  ghci> collect x == x  True 5Note that the numerical constants have been declared Int using the type 0 annotation. Since these natively have the type  Num a => a, you may need to M give explicit types. By design, there is no connection that can be inferred 0 between the return type and the argument type. collectE only works if there is an instance for the return type as described  in the newtype QP. PQRSPQRSPQRQRS non-portable experimentalgenerics@haskell.org TSame as U: except that you can pass a list of name modifications to  the deriving mechanism. Use  deriveWith if:  ; You want to use the generated constructor descriptions or  embedding-projection pairs and) one of your constructors or types is an : infix symbol. In other words, if you have a constructor :* , you cannot = refer to the (invalid) generated name for its description, con:*. It M appears that GHC has no problem with that name internally, so this is only  if you want access to it. I You want to define your own constructor description. This allows you to J give a precise implementation different from the one generated for you. For option 1, use  as in this example:    data U = Int :* Char  $(deriveWith [(":*" , ChangeTo "Star")] ''U)  x = ... conStar ... For option 2, use  as in this example:   ) data V = (:=) { i :: Int, j :: Char }  $(deriveWith [(":=" , DefinedAs "Equals")] ''V)  conEquals =   ":=" 2 [] ( 4) $Using the example for option 2 with Generics.EMGM.Functions.Show will print  values of V0 as infix instead of the default record syntax. HNote that only the first pair with its first field matching the type or  constructor name in the + list will be used. Any other matches will  be ignored. UADerive all appropriate instances for using EMGM with a datatype. 0Here is an example module that shows how to use derive:  * {-# LANGUAGE TemplateHaskell #-} * {-# LANGUAGE MultiParamTypeClasses #-} * {-# LANGUAGE FlexibleContexts #-} * {-# LANGUAGE FlexibleInstances #-} * {-# LANGUAGE OverlappingInstances #-} * {-# LANGUAGE UndecidableInstances #-}    module Example where  import  Generics.EMGM  data T a = C a Þ    $(derive ''T) The Template Haskell derive0 declaration in the above example generates the  following (annotated) code:   C -- (1) Constructor description declarations (1 per constructor)    conC ::    conC =   "C" 2 []    > -- (2) Embedding-projection pair declarations (1 per type)    epT ::  (T a) (a :*: Þ)  epT =  fromT toT ' where fromT (C v1 v2) = v1 :*: v2 % toT (v1 :*: v2) = C v1 v2    -- (3) $ instance (1 per type)    instance (& g, $ g a, $ g Þ) => $ g (T a) where  % = 1 epT (0 conC (/ % %))   7 -- (4) Higher arity instances if applicable (either ", 4, and  -- B together, or 2)    instance (& g) => " g T where  # ra = 1 epT (0 conC (/ ra ())   = -- In this case, similar instances would be generated for 4 and B.   3 -- (5) Function-specific instances (1 per type)    instance $ (QP â) â where  % = QP (:[]) &Note that the constructor description conC and embedding-project pair epT F are top-level values. This allows them to be shared between multiple K instances. If these names conflict with your own, you may want to put the   $(derive ...)= declaration in its own module and restrict the export list. VSame as W) except that you can pass a list of name . modifications to the deriving mechanism. See T for an example. WGenerate declarations of  ( values for all constructors in a type.  See U for an example. XSame as Y7 except that you can pass a list of name modifications  to the deriving mechanism. See T for an example. YGenerate declarations of  values for a type. See U for an  example. ZSame as [7 except that you can pass a list of name modifications  to the deriving mechanism. See T for an example. [ Generate $' instance declarations for a type. See U for an  example. \Same as ]7 except that you can pass a list of name modifications  to the deriving mechanism. See T for an example. ] Generate ", 4, and B' instance declarations for a type. See  U for an example. ^Same as _) except that you can pass a list of name . modifications to the deriving mechanism. See T for an example. _ Generate 2' instance declarations for a type. See U for an  example. ` Generate a $ QP T! instance declaration for a type T. See  U for an example. TUVWXYZ[\]^_`UTWVYX[Z]\_^` TUVWXYZ[\]^_`  non-portable experimentalgenerics@haskell.org_ÜÝ  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOTUVWXYZ[\]^_` non-portable experimentalgenerics@haskell.org aJThe type of a generic function that takes two values of the same type and  returns an ã!. d!Compare two values and return an ã! (i.e. LT, GT, or EQ). 4 This is implemented exactly as if the datatype was  deriving Ord. eLess than. Returns x < y. fLess than or equal to. Returns x <= y. gEqual to. Returns x == y. hNot equal to. Returns x /= y. iGreater than. Returns x > y. j"Greater than or equal to. Returns x >= y. kThe minimum of two values. lThe maximum of two values. abcdefghijkl abcdghefijkl abcbcdefghijkl non-portable experimentalgenerics@haskell.orgmCThe type of a generic function that takes an associativity and two M arguments of different types and returns a value of the type of the second. p.Associativity of the binary operator used for s qRight-associative rLeft-associative sApply 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 t or u. tA right-associative variant of s. uA left-associative variant of s. v1Flatten 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 w or x. wA right-associative variant of v. Note that, for a list ls :: [a], flattenr ls == ls. xA left-associative variant of v. Note that, for a list ls :: [a], flattenl ls == reverse ls. yLExtract 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 z or {. zA right-associative variant of y. Note that, for a list ls :: [a], fromJust (firstr ls) == head ls. {A left-associative variant of y. Note that, for a list ls :: [a], fromJust (firstl ls) == last ls. |>Determine if an element is a member of a container. This is a  generalization of the Prelude function of the same name. }BDetermine if an element is not a member of a container. This is a  generalization of the Prelude function of the same name. ~LCompute the sum of all elements in a container. This is a generalization of  the Prelude function of the same name. >Compute the product of all elements in a container. This is a  generalization of the Prelude function of the same name. €IDetermine the maximum element of a container. If the container is empty,  return ä"". This is a generalization of the Prelude function of the  same name. IDetermine the minimum element of a container. If the container is empty,  return ä"". This is a generalization of the Prelude function of the  same name. ‚BCompute the conjunction of all elements in a container. This is a  generalization of the Prelude function of the same name. ƒBCompute the disjunction of all elements in a container. This is a  generalization of the Prelude function of the same name. „@Determine if any element in a container satisfies the predicate p. This  is a generalization of the Prelude function of the same name. …?Determine if all elements in a container satisfy the predicate p. This  is a generalization the Prelude function of the same name. mnopqrstuvwxyz{|}~€‚ƒ„…mnoprqsutvxwy{z‚ƒ„…~€|}mnonoprqqrstuvwxyz{|}~€‚ƒ„…  non-portable experimentalgenerics@haskell.org †JThe type of a generic function that takes no arguments and returns a list  of some type. å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  á. ‰IEnumerate 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  ‰ . ŠEnumerate the first n. values of a datatype. This is a shortcut for  ê# n (‰ ). ‹2Returns the first element of the enumeration from ‰  . This is * often called the neutral or empty value. †‡ˆ‰Š‹†‡ˆ‰Š‹†‡ˆ‡ˆ‰Š‹  non-portable experimentalgenerics@haskell.orgŒLThe type of a generic function that takes a value of one type and returns a  value of a different type. ?Apply a function to all elements of a container datatype (kind * -> *).  Replace all a -values in as with b. ‘Given a datatype F a b,  bimap f g applies the function  f :: a -> c to  every a-element and the function  g :: b -> d to every b-element. The . result is a value with transformed elements: F c d. ŒŽ‘ŒŽ‘ŒŽŽ‘  non-portable experimentalgenerics@haskell.org’JThe type of a generic function that takes a constructor-type argument and , returns a parser combinator for some type. ë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. –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šIThe type of a generic function that takes a constructor-type argument, a 0 number (precedence), and a value and returns a ö function. KConvert a value to a readable string starting with the operator precedence  of the enclosing context. ž A variant of  " with the minimum precedence (0). Ÿ A variant of ž  that returns a ÷& instead of ö. š›œžŸš›œžŸš›œ›œžŸ  non-portable experimentalgenerics@haskell.org IThe type of a generic function that takes two arguments of two different 7 types and optionally returns a value of a third type. £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. ¤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¥FThe type of a generic function that takes an argument of one type and 4 returns a pair of values with two different types. ¨KSplits a container into two structurally equivalent containers by applying O a function to every element, which splits it into two corresponding elements. ©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.orgMPQRSabcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨© non-portable experimentalgenerics@haskell.orgªEmbedding-projection pair for ø( «Constructor description for ù( ¬Constructor description for ú( ûRepresentation for ø( in & ª«¬ª«¬ª«¬ non-portable experimentalgenerics@haskell.org­Embedding-projection pair for Û ®Constructor description for ü ¯Constructor description for ý þRepresentation for  Either a b in & ­®¯­®¯­®¯ non-portable experimentalgenerics@haskell.org°$Embedding-projection pair for lists ±Constructor description for ''nil'': [] ²Constructor description for ''cons'': (:) ÿRepresentation for lists in & Representation for lists in 6 Representation for lists in D °±²°±²°±² non-portable experimentalgenerics@haskell.org³Embedding-projection pair for " ´Constructor description for ä" µConstructor description for " Representation for Maybe a in & Representation for Maybe a in 6 Representation for Maybe a in D ³´µ³´µ³´µ non-portable experimentalgenerics@haskell.org¶Embedding-projection pair for () ·Constructor description for () Representation for () in & ¸Embedding-projection pair for (a,b) ¹Constructor description for (a,b) Representation for (a,b) in &  Representation for (,) in 6 ºEmbedding-projection pair for (a,b,c) »Constructor description for (a,b,c)  Representation for (a,b,c) in & ¼Embedding-projection pair for  (a,b,c,d) ½Constructor description for  (a,b,c,d)  Representation for  (a,b,c,d) in & ¾Embedding-projection pair for  (a,b,c,d,e) ¿Constructor description for  (a,b,c,d,e)  Representation for  (a,b,c,d,e) in & ÀEmbedding-projection pair for  (a,b,c,d,e,f) ÁConstructor description 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) ÃConstructor description 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ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃ+ non-portable experimentalgenerics@haskell.org Ü  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUabcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©Ÿ   !$%"#45BC23&'()*+,-./016789:;<=>?@ADEFGHIJKLMNOUTPQRSabcdghefijklmnoprqsutvxwy{z‚ƒ„…~€|}†‡ˆ‰Š‹ŒŽ‘’“”•—–˜™š›œžŸ¥¦§©¨ ¡¢¤£,-./01234567899:;<=>>?@AABCDEEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxxyz{|}~€‚ƒ„…†‡ˆˆ‰Š‹ŒŽ‘’““”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª « « ¬ ­ ® ¯ ° ° ± ² ³ ´ µ µ ¶ · ¸ ¹ º » ¼ ¼ ½ ¾ ¿ À Á Á  à ÄÅÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêãëìíîäïðñòóôõöµ÷¼ø$ù$úûüýþÿ!"     #         $%÷((( "!""#$%&'()*+,-.emgm-0.2Generics.EMGM.Common.Derive#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.Tuple$Generics.EMGM.Common.Derive.InstanceGenerics.EMGM.Common.Derive.EP$Generics.EMGM.Common.Derive.ConDescr"Generics.EMGM.Common.Derive.Commonbase 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.FunctionsGHC.BoolGenerics.EMGM.Data.THGenerics.EMGM.Data Generics.EMGM ModifiersModifier DefinedAsChangeToFixityInfixrInfixlInfixNonfixConTypeConIfxConRecConStdConDescrconNameconArity conLabels conFixityEPfromto:*::+:RLUnitprecmaxPrecappPrecrecPrecFRepfrepReprepGeneric rconstantrintrintegerrfloatrdoublercharrunitrsumrprodrconrtypeBiFRep2bifrep2FRep2frep2Generic2 rconstant2rint2 rinteger2rfloat2rdouble2rchar2runit2rsum2rprod2rcon2rtype2FRep3frep3Generic3 rconstant3rint3 rinteger3rfloat3rdouble3rchar3runit3rsum3rprod3rcon3rtype3Collect selCollectcollect deriveWithderivedeclareConDescrsWithdeclareConDescrs declareEPWith declareEP deriveRepWith deriveRepderiveFRepWith deriveFRepderiveBiFRepWith deriveBiFRep deriveCollectCompare selComparecompareltlteqeqneqgtgteqminmaxCrushselCrushAssoc AssocRight AssocLeftcrushcrushrcrushlflattenflattenrflattenlfirstfirstrfirstlelemnotElemsumproductmaximumminimumandoranyallEnumselEnumenumenumNemptyMapselMapmapreplacebimapReadselReadreadPrec readsPrecreadPreadsreadShowselShow showsPrecshowsshowZipWith selZipWithzipWithzip UnzipWith selUnzipWith unzipWithunzipepBoolconFalseconTrueepEitherconLeftconRightepListconNilconConsepMaybe conNothingconJustepTuple0 conTuple0epTuple2 conTuple2epTuple3 conTuple3epTuple4 conTuple4epTuple5 conTuple5epTuple6 conTuple6epTuple7 conTuple7NConDTselmkSop listCase3 productize mkFunName reportErrorcnamecdescr cargtypescvarstnametvarsdconsncons toMaybeStringmkSopDT foldNestedGHC.ReadGHC.ShowEitherminPrecPrecIntGHC.Integer.InternalsIntegerFloatDoubleCharOrderingNothing|||diag><intEnumnumEnum genericTakeltraceparen wrapTupletuple2tuple3tuple4braceslexTrecEntryReadPrecReadPShowSGHC.BaseStringBoolFalseTruerBoolLeftRightrEitherrListrList2rList3MaybeJustrMayberMaybe2rMaybe3rTuple0rTuple2 rTuple2_2rTuple3rTuple4rTuple5rTuple6rTuple7