k      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh i j k l m n o p q r s t u v w x y z { | } ~        non-portable experimentalgenerics@haskell.org non-portable experimentalgenerics@haskell.org non-portable experimentalgenerics@haskell.org non-portable experimentalgenerics@haskell.org 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.orgThe "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 -, 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.) ,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 25 representation dispatcher for bifunctor types (kind   * -> * -> * ). (No default implementation.) 0The 23 representation dispatcher for functor types (kind * -> *), @ sometimes called container types. (No default implementation.) 2HThis 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. 3JMany functions perform the same operation on the non-structural cases (as  well as %). The cases for constant datatypes (,  ,  , , , and #) have a default implementation of  3,, thus a generic function may only override 3 if ; desired. Note that there is no default implementation for 3  itself. DThe class context represents the intersection set of supported type  classes. 4Case for the primitive type . (Default implementation:  3.) 5Case for the primitive type  . (Default implementation:  3.) 6Case for the primitive type . (Default implementation:  3.) 7Case for the primitive type . (Default implementation:  3.) 8Case for the primitive type . (Default implementation:  3.) 9,Case for the structural representation type . It is used to E represent a constructor with no arguments. (Default implementation:  3.) :,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.) =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  2. (No default implementation.) ./0123456789:;<=23456789:;<=01././/0112 3456789:;<=3456789:;<= non-portable experimentalgenerics@haskell.org >The @3 representation dispatcher for functor types (kind * -> *), @ sometimes called container 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. AJMany functions perform the same operation on the non-structural cases (as  well as %). The cases for constant datatypes (,  ,  , , , and #) have a default implementation of  A,, thus a generic function may only override A if ; desired. Note that there is no default implementation for A  itself. DThe class context represents the intersection set of supported type  classes. BCase for the primitive type . (Default implementation:  A.) CCase for the primitive type  . (Default implementation:  A.) DCase for the primitive type . (Default implementation:  A.) ECase for the primitive type . (Default implementation:  A.) FCase for the primitive type . (Default implementation:  A.) G,Case for the structural representation type . It is used to E represent a constructor with no arguments. (Default implementation:  A.) H,Case for the structural representation type :+: (sum). It D is used to represent alternative choices between constructors. (No  default implementation.) I,Case for the structural representation type :*: (product). B It is used to represent multiple arguments to a constructor. (No  default implementation.) JGCase 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.) KACase 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.) >?@ABCDEFGHIJK@ABCDEFGHIJK>?>??@ ABCDEFGHIJKABCDEFGHIJK non-portable experimentalgenerics@haskell.orgLLThe 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 T, the   instance looks like  this:  ( {-# LANGUAGE OverlappingInstances #-}   data T = ...  # instance Rep (Collect T) T where  rep = Collect (:[]) M(Note the requirement of overlapping instances.) This instance triggers when  the result type (the first T&) matches some value type (the second T) " contained within the argument to O$. See the source of this module for  more examples. OCollect 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   (ML B) B for the type B that you are  collecting. collectD works by searching a datatype for values that are the same type as M the return type specified. Here are some examples using the same value with  different return types:    ghci> let x = [ 1,  'a',  2] :: [  ]  ghci> collect x :: []  [1,2]  ghci> collect x :: []  "a"  ghci> collect x == x  ! 5Note that the numerical constants have been declared  using the type 0 annotation. Since these natively have the type " a => a, you may need G to give explicit types. By design, there is no connection that can be 9 inferred 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 ML. LMNOLMNOLMNMNO non-portable experimentalgenerics@haskell.orgP&This type servers the same purpose as TS, except that   O instances are designed to be top-down instead of bottom-up. That means, given  any type U (recursive or not), the   instance looks like this:  ) {-# LANGUAGE OverlappingInstances #-}    data U = ...    instance   (Everywhere' U) U where  ! = Everywhere' ($) /Note the requirement of overlapping instances. =This instance is triggered when the function type (the first U in    (Everywhere U) U&) matches some value type (the second U) contained within  the argument to W. SJThe type of a generic function that takes a function of one type, a value 9 of another type, and returns a value of the value type. NFor datatypes to work with Everywhere, a special instance must be given. This M instance is trivial to write. For a non-recursive type, the instance is the  same as described for QP. For a recursive type T, the    instance looks like this:  ) {-# LANGUAGE OverlappingInstances #-}    data T a = Val a | Rec (T a)    instance (  (Everywhere (T a)) (T a),   (Everywhere (T a)) a) =>   (Everywhere (T a)) (T a) where  ! = Everywhere app  where  app f x =  case x of - Val v1 -> f (Val (selEverywhere ! f v1)) - Rec v1 -> f (Rec (selEverywhere ! f v1)) /Note the requirement of overlapping instances. =This instance is triggered when the function type (the first T a in    (Everywhere (T a)) (T a)&) matches some value type (the second T a) " contained within the argument to V. VApply a transformation a -> a to values of type a within the argument  of type b5 in a bottom-up manner. Values that do not have type a are  passed through ".  everywhere! works by searching the datatype b for values that are the same $ type as the function argument type a#. Here are some examples using the , datatype declared in the documentation for TS.   3 ghci> let f t = case t of { Val i -> Val (i+(1::)); other -> other }  ghci> everywhere f (Val (1::))  Val 2 ) ghci> everywhere f (Rec (Rec (Val (1::))))  Rec (Rec (Val 2))    ghci> let x = [ 1,  'a',  2] :: [  ]  ghci> everywhere (*(3::)) x  [ 3, 'a', 6]  ghci> everywhere (\ x -> x ::  ) x == x  ! CNote the type annotations. Since numerical constants have the type " a  => a:, you may need to give explicit types. Also, the function \x -> x has  type a -> a<, but we need to give it some non-polymorphic type here. By L design, there is no connection that can be inferred between the value type  and the function type.  everywhere; only works if there is an instance for the return type as  described in the newtype TS. WApply a transformation a -> a to values of type a within the argument  of type b4 in a top-down manner. Values that do not have type a are passed  through ".  everywhere' is the same as V! with the exception of recursive K datatypes. For example, compare the example used in the documentation for  V with the following.   3 ghci> let f t = case t of { Val i -> Val (i+(1::)); other -> other }  ghci> everywhere' f (Val (1::))  Val 2  ghci> everywhere' f (Rec (Rec (Val (1::))))  Rec (Rec (Val 1))  everywhere'; only works if there is an instance for the return type as  described in the newtype QP. PQRSTUVWSTUVPQRWPQRQRSTUTUVW# non-portable experimentalgenerics@haskell.org" One of the " classes  Method from "  Method from "   Method from " ! Method from " " Method from " # Method from " $ Method from " % Method from " & Method from " ' Method from " ( One of the   classes ) Method from   XIList of pairs mapping a (type or constructor) name to a modifier action. Y*Modify the action taken for a given name. Z4Use this for the name of a user-defined constructor / description instead of a generated one. The + generated code assumes the existance of conX ::     (in scope) if the argument is "X". [(Change the syntactic name (of a type or 1 constructor) to the argument in the generated   or   & 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. 0JGiven 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. 1!Report an error message and fail 21Case the representation on the kind of the type. 3Case the representation on the " class it relies on. 4 Case the   option or the others. 5JGet the collection of names for a certain option. This allows the code to K be generic across different instance definitions. For example, we use the % same code to write the instances of   as we do for .. Some of the  differences are these names. 6LGet the actual name that is analogous to each of these function names. This F allows the code to be generic across different instance definitions. 7LMake a type as applied to its type variables from the type name and list of  parameters. 8@Make a type as applied to its type variables (if any) from a DT 9Make the rep instance context :Make the rep instance type V;<=>?@ABC !"#$%&'()DEFGHIXYZ[*JKLMN+OPQRST,-UV./012345WX6YZ[\]^_`abc78def9:ghijklmnV;<=>?@A<=>?@ABC !"#$%&'()C !"#$%&'()DIHGFEEFGHIXY[ZZ[*JKLMNJKLMN+OPQRSOPQRST,-UV./012345WX6YZ[\]^_`abc78def9:ghijklmn$ non-portable experimentalgenerics@haskell.orgN  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK non-portable experimentalgenerics@haskell.org \JThe type of a generic function that takes two values of the same type and  returns an o%. _!Compare two values and return an o% (i.e. LT, GT, or EQ). 4 This is implemented exactly as if the datatype was  deriving Ord. `Less than. Returns x < y. aLess than or equal to. Returns x <= y. bEqual to. Returns x == y. cNot equal to. Returns x /= y. dGreater than. Returns x > y. e"Greater than or equal to. Returns x >= y. fThe minimum of two values. gThe maximum of two values. \]^_`abcdefg \]^_bc`adefg \]^]^_`abcdefg  non-portable experimentalgenerics@haskell.orghCThe 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. k.Associativity of the binary operator used for n  lRight-associative mLeft-associative nApply 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 o  or p . oA right-associative variant of n . pA left-associative variant of n . q1Flatten 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 r  or s . rA right-associative variant of q . Note that, for a list ls :: [a], flattenr ls == ls. sA left-associative variant of q . Note that, for a list ls :: [a], flattenl ls == reverse ls. tLExtract 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 u  or v . uA right-associative variant of t . Note that, for a list ls :: [a], fromJust (firstr ls) == head ls. vA left-associative variant of t . Note that, for a list ls :: [a], fromJust (firstl ls) == last ls. w>Determine if an element is a member of a container. This is a  generalization of the Prelude function of the same name. xBDetermine if an element is not a member of a container. This is a  generalization of the Prelude function of the same name. yLCompute the sum of all elements in a container. This is a generalization of  the Prelude function of the same name. z>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 p&". 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 p&". 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. hijklmnopqrstuvwxyz{|}~hijkmlnpoqsrtvu}~yz|{wxhijijkmllmnopqrstuvwxyz{|}~  non-portable experimentalgenerics@haskell.org JThe type of a generic function that takes no arguments and returns a list  of some type. qGInterleave elements from two lists. Similar to (++), but swap left and 1 right arguments on every recursive application. From Mark Jones' talk at AFP2008 rFDiagonalization of nested lists. Ensure that some elements from every 6 sublist will be included. Handles infinite sublists. From Mark Jones' talk at AFP2008 s(Cartesian product with diagonalization. From Mark Jones' talk at AFP2008 tE values starting with 0 and enumerating to the positive and negative  bounds. uENumeric 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  v' n ( ). 2Returns the first element of the enumeration from   . This is * often called the neutral or empty value.   non-portable experimentalgenerics@haskell.orgLThe 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%. This is a convenience function for  the implementation   (w" b) as. 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. ICast a value of one type into a value of another. This is a configurable I function that allows you to define your own type-safe conversions for a  variety of types. cast works with instances of   (  i) o in which you choose the  input type i and the output type o$ and implement the function of type i  -> o. GHere are some examples of instances (and flags you will need or want):  + {-# LANGUAGE MultiParamTypeClasses #-} + {-# LANGUAGE FlexibleContexts #-} + {-# LANGUAGE FlexibleInstances #-} + {-# OPTIONS_GHC -fno-warn-orphans #-}    instance   (  )  where  ! =   chr    instance   (  )  where  ! =   x"    instance   (   )   where  ! =   (+42) 2There are no pre-defined instances, and a call to cast will not compile if N no instances for the input and output type pair is found, so you must define  instances in order to use cast.   non-portable experimentalgenerics@haskell.orgJThe type of a generic function that takes a constructor-type argument and , returns a parser combinator for some type. yLook and trace1 - print the unconsumed part of the input string z (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 p&(. Note that a successful parse requires & the input to be completely consumed.   non-portable experimentalgenerics@haskell.orgIThe 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.orgIThe 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 p& 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.orgFThe 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.orgVLMNOPQRSTUVW\]^_`abcdefghijklmnopqrstuvwxyz{|}~, non-portable experimentalgenerics@haskell.orgSame as : 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 Z 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 X+ list will be used. Any other matches will  be ignored. ADerive 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.Derive  data T a = C a     $(derive ''T) The Template Haskell derive0 declaration in the above example generates the  following (annotated) code:   / -- (1) Constructor description declarations    conC ::     conC =    "C" 2 []    0 -- (2) Embedding-projection pair declaration    epT ::  (T a) (a :*: )  epT =  fromT toT ' where fromT (C v1 v2) = v1 :*: v2 % toT (v1 :*: v2) = C v1 v2    -- (3) Representation values    repT :: (" g,   g a,   g  ) => g (T a)  repT = - epT (, conC (+ ! !))    frepT :: (" g) => g a1 -> g (T a1)  frepT a = - epT (, conC (+ a $))    frep2T :: (2" g) => g a1 a2 -> g (T a1) (T a2)  frep2T a = = epT epT (< conC (; a 4))    frep3T :: (@, g) => g a1 a2 a3 -> g (T a1) (T a2) (T a3)  frep3T a = K epT epT epT (J conC (I a B))    bifrep2T :: (2" g) => g a1 a2 -> g (T a1) (T a2)  bifrep2T a = = epT epT (< conC (; a 4))   # -- (4) Representation instances    instance (" g,   g a,   g ) =>   g (T a) where  ! = repT    instance (" g) =>  g T where   = frepT    instance (2 g) => 0 g T where  1 = frep2T    instance (@ g) => > g T where  ? = frep3T   % -- In this case, no instances for . is generated, because T is not K -- a bifunctor type; however, the bifrep2T value is always generated in * -- case T is used in a bifunctor type.   . -- (5) Generic function-specific instances    instance   (ML (T a)) (T a) where  ! = ML (\x -> [x])    instance (  (TS (T a)) a,   (TS (T a)) )  =>   (TS (T a)) (T a) where  ! = TS (\f x ->  case x of  C v1 v2 -> f (C (U ! f v1) (U ! f v2))    instance   (QP (T a)) (T a) where  ! = QP (\ f x -> f x) NNote that all the values are top-level. This allows them to be shared between M multiple instances. For example, if you have two mutually recursive functor + datatypes, you may need to have each other's derived code in scope. Same as 6 for a list of type names. It may be necessary to use   deriveMany3 for a collection of mutually recursive datatypes. Same as 6 for a list of type names. It may be necessary to use   deriveMany3 for a collection of mutually recursive datatypes. Same as ) except that you can pass a list of name . modifications to the deriving mechanism. See  for an example. Generate declarations of   ( values for all constructors in a type.  See  for an example. Same as 7 except that you can pass a list of name modifications  to the deriving mechanism. See  for an example. Generate declarations of  values for a type. See  for an  example. Same as ) except that you can pass a list of name . modifications to the deriving mechanism. See  for an example. KGenerate the declaration of a monomorphic representation value for a type.  This is the value used for ! in an instance of  . The difference with   is that  generates generates all " representation values (including , 1 , etc.). See  for an  example. Same as ) except that you can pass a list of name . modifications to the deriving mechanism. See  for an example. EGenerate declarations of all representation values for a type. These  functions are used in !, , ..., /. Same as 7 except that you can pass a list of name modifications  to the deriving mechanism. See  for an example.  Generate  ' instance declarations for a type. See  for an  example. Same as ) except that you can pass a list of name . modifications to the deriving mechanism. See  for an example. Same as " except that only the monomorphic   representation N value and instance are generated. This is a convenience function that can be - used instead of the following declarations:   $(declareConDescrs ''T)  $(declareEP ''T)  $(declareMonoRep ''T)  $(deriveRep ''T)  $(deriveFRep ''T)  $(deriveCollect ''T) Same as 7 except that you can pass a list of name modifications  to the deriving mechanism. See  for an example.  Generate , 0, and >' instance declarations for a type. See   for an example. Same as ) except that you can pass a list of name . modifications to the deriving mechanism. See  for an example.  Generate .' instance declarations for a type. See  for an  example.  Generate a   ML T! instance declaration for a type T. See   for an example.  Generate a   TS T! instance declaration for a type T. See   for an example.  Generate a   QP T! instance declaration for a type T. See   for an example. u  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ non-portable experimentalgenerics@haskell.orgEmbedding-projection pair for !. Constructor description for !. Constructor description for !. Representation of ! for !. Representation of ! for . Representation of ! for 1. Representation of ! for ?. Representation of ! for /.  non-portable experimentalgenerics@haskell.orgEmbedding-projection pair for . Constructor description for . Constructor description for . Representation of  for . Representation of  for !. Representation of  for 1. Representation of  for /. Representation of  for ?.  non-portable experimentalgenerics@haskell.org%Embedding-projection pair for lists. Constructor description for ''nil'': []. Constructor description for ''cons'': (:). Representation of lists for . Representation of lists for !. Representation of lists for 1. Representation of lists for /. Representation of lists for ?.  non-portable experimentalgenerics@haskell.orgEmbedding-projection pair for &. Constructor description for p&. Constructor description for &. Representation of & for . Representation of & for !. Representation of & for 1. Representation of & for /. Representation of & for ?.  non-portable experimentalgenerics@haskell.org1Embedding-projection pair for (). Constructor description for (). Representation of () for !. Representation of () for . Representation of () for 1. Representation of () for /. Representation of () for ?. Embedding-projection pair for (,). Constructor description for (,). Representation of (,) for . Representation of (,) for !. Representation of (,) for 1. Representation of (,) for /. Representation of (,) for ?. Embedding-projection pair for (,,). Constructor description for (,,). Representation of (,,) for . Representation of (,,) for !. Representation of (,,) for 1. Representation of (,,) for /. Representation of (,,) for ?. Embedding-projection pair for (,,,). Constructor description for (,,,). Representation of (,,,) for . Representation of (,,,) for !. Representation of (,,,) for 1. Representation of (,,,) for /. Representation of (,,,) for ?. Embedding-projection pair for (,,,,). Constructor description for (,,,,). Representation of (,,,,) for . Representation of (,,,,) for !. Representation of (,,,,) for 1. Representation of (,,,,) for bfrep2. Representation of (,,,,) for ?. Embedding-projection pair for (,,,,,). Constructor description for (,,,,,). Representation of (,,,,,) for . Representation of (,,,,,) for !. Representation of (,,,,,) for 1. Representation of (,,,,,) for /. Representation of (,,,,,) for ?. Embedding-projection pair for (,,,,,,). Constructor description for (,,,,,,).  Representation of (,,,,,,) for .  Representation of (,,,,,,) for !.  Representation of (,,,,,,) for 1.  Representation of (,,,,,,) for /.  Representation of (,,,,,,) for ?. 1     1     1     - non-portable experimentalgenerics@haskell.org non-portable experimentalgenerics@haskell.org  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNPQRSTUXYZ[     uY[ZX     LMNSTUPQR. non-portable experimentalgenerics@haskell.org  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !01>?./"#$%&'()*+,-23456789:;<=@ABCDEFGHIJKLMNO\]^_bc`adefghijkmlnpoqsrtvu}~yz|{wxSTUVPQRW/01234567889:;<==>?@@ABCDDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwwxyzz{||}~####              ,,,,,,,,,,,,,,,,,,,,,,,      !"#$%&'()*+,-./0(1(23456789:!;<=>?#@#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#d#e#f#g#h#i#j#M#k#l#m#n#N#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~###############%&     '>         ()/>!!&& emgm-0.3.1#Generics.EMGM.Common.RepresentationGenerics.EMGM.Common.BaseGenerics.EMGM.Common.Base2Generics.EMGM.Common.Base3Generics.EMGM.Functions.Collect"Generics.EMGM.Functions.EverywhereGenerics.EMGM.DeriveGenerics.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.TupleGenerics.EMGM.Derive.InstanceGenerics.EMGM.Derive.FunctionsGenerics.EMGM.Derive.EPGenerics.EMGM.Derive.ConDescrbase Text.Read Text.Show Data.Eitherghc-prim GHC.Typesinteger GHC.IntegerGHC.BoolPreludeGenerics.EMGM.Derive.CommonGenerics.EMGM.Common GHC.Ordering Data.Maybe Data.ListText.ParserCombinators.ReadPrecText.ParserCombinators.ReadP Data.CharGenerics.EMGM.FunctionsGenerics.EMGM.Derive.InternalGenerics.EMGM.Data.TH Generics.EMGMFixityInfixrInfixlInfixNonfixConTypeConIfxConRecConStdConDescrconNameconArity conLabels conFixityEPfromto:*::+:RLUnitprecmaxPrecappPrecrecPrecFRepfrepReprepGeneric rconstantrintrintegerrfloatrdoublercharrunitrsumrprodrconrtypeBiFRep2bifrep2FRep2frep2Generic2 rconstant2rint2 rinteger2rfloat2rdouble2rchar2runit2rsum2rprod2rcon2rtype2FRep3frep3Generic3 rconstant3rint3 rinteger3rfloat3rdouble3rchar3runit3rsum3rprod3rcon3rtype3Collect selCollectcollect Everywhere'selEverywhere' Everywhere selEverywhere everywhere everywhere' ModifiersModifier DefinedAsChangeToCompare selComparecompareltlteqeqneqgtgteqminmaxCrushselCrushAssoc AssocRight AssocLeftcrushcrushrcrushlflattenflattenrflattenlfirstfirstrfirstlelemnotElemsumproductmaximumminimumandoranyallEnumselEnumenumenumNemptyMapselMapmapreplacebimapcastReadselReadreadPrec readsPrecreadPreadsreadShowselShow showsPrecshowsshowZipWith selZipWithzipWithzip UnzipWith selUnzipWith unzipWithunzip deriveWithderivederiveManyWith deriveManydeclareConDescrsWithdeclareConDescrs declareEPWith declareEPdeclareMonoRepWithdeclareMonoRepdeclareRepValuesWithdeclareRepValues deriveRepWith deriveRepderiveMonoWith deriveMonoderiveFRepWith deriveFRepderiveBiFRepWith deriveBiFRep deriveCollectderiveEverywherederiveEverywhere'epBoolconFalseconTruerepBoolfrepBool frep2Bool frep3Bool bifrep2BoolepEitherconLeftconRight frepEither repEither frep2Either bifrep2Either frep3EitherepListconNilconConsfrepListrepList frep2List bifrep2List frep3ListepMaybe conNothingconJust frepMayberepMaybe frep2Maybe bifrep2Maybe frep3MaybeepTuple0 conTuple0 repTuple0 frepTuple0 frep2Tuple0 bifrep2Tuple0 frep3Tuple0epTuple2 conTuple2 frepTuple2 repTuple2 frep2Tuple2 bifrep2Tuple2 frep3Tuple2epTuple3 conTuple3 frepTuple3 repTuple3 frep2Tuple3 bifrep2Tuple3 frep3Tuple3epTuple4 conTuple4 frepTuple4 repTuple4 frep2Tuple4 bifrep2Tuple4 frep3Tuple4epTuple5 conTuple5 frepTuple5 repTuple5 frep2Tuple5 bifrep2Tuple5 frep3Tuple5epTuple6 conTuple6 frepTuple6 repTuple6 frep2Tuple6 bifrep2Tuple6 frep3Tuple6epTuple7 conTuple7 frepTuple7 repTuple7 frep2Tuple7 bifrep2Tuple7 frep3Tuple7GHC.ReadGHC.ShowEitherminPrecPrecIntGHC.Integer.InternalsIntegerFloatDoubleCharLeftRightTrueGHC.NumNumGHC.Baseid genericCN'rintN' rintegerN'rfloatN' rdoubleN'rcharN'runitN'rsumN'rprodN'rconN'rtypeN'repCN'repN'NConDTselmkSop listCase3 productize mkFunName reportErrorcaseKindcaseGencaseReprepNamesrintNmkAppliedType' mkAppliedType mkRepInstCxt mkRepInstT RepFunNamesrepFunNfrepFunN frep2FunN frep3FunN bifrep2FunNRepNamesRepOpt OptBiFRep2OptFRep3OptFRep2OptFRepOptRepcnamecdescr cargtypescvarstnametvarsdconsncons toMaybeStringmkSopDT foldNestedfunName genericCN rintegerNrfloatNrdoubleNrcharNrunitNrsumNrprodNrconNrtypeNrepCNrepN mkAppliedFunmkRepT mkGenericTunitEprodEsumEunitPprodPsumPdataEdataPOrderingNothing|||diag><intEnumnumEnum genericTakeconstGHC.Real realToFracltraceparen wrapTupletuple2tuple3tuple4braceslexTrecEntryReadPrecReadPShowSStringBoolFalseMaybeJust