!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       non-portable experimentalgenerics@haskell.org# A constructor's associativity. Declared with infix Declared with infixr Declared with infixl  A constructor')s fixity, associativity, and precedence. CAssociativity and precedence are the same as function application. :Type of constructor syntax. Used in the generic functions  and  . Record-style (any fixity) %Infix with symbol (no record syntax)  Normal prefix-style constructor Have not seen the rcon yet HContains useful meta-information about the syntax used in a constructor  declaration. 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. 9Name of the constructor (without parenthesese if infix). Number of fields. ,Uses labeled fields (a.k.a. record syntax). #Fixity, 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. KEncodes the string label for a field in a constructor defined with labeled  fields (a.k.a. record syntax). 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 LEncodes 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.%2Representation dispatcher for functor types (kind * -> * ) used with  /. &'4Representation dispatcher for bifunctor types (kind * -> * ) used with  ;. ()2Representation dispatcher for functor types (kind * -> * ) used with  ;. *+2Representation dispatcher for functor types (kind * -> * ) used with  G. ,-6Representation dispatcher for monomorphic types (kind * ) used with  G=. Every structure type and supported datatype should have an  instance of -. ./JThis class forms the foundation for defining generic functions with three  generic arguments. See G for details. The included modules using Generic3 are:  !Generics.EMGM.Functions.UnzipWith  Generics.EMGM.Functions.ZipWith 0123456789:See R5. This case is the primary difference that separates  / from G2. Since we have three generic type parameters, we  need three : values. Each translates between the Haskell type and its  generic representation. ;HThis class forms the foundation for defining generic functions with two  generic arguments. See G for details. The included modules using Generic2 are:  Generics.EMGM.Functions.Map  !Generics.EMGM.Functions.Transpose <=>?@ABCDEFSee R5. This case is the primary difference that separates  ; from G0. Since we have two generic type parameters, we  need to have two 6 values. Each translates between the Haskell type and  its generic representation. GFThis class forms the foundation for defining generic functions with a N single generic argument. Each method represents a type case. There are cases L for primitive types, structural representation types, and for user-defined  datatypes. The included modules using Generic are:  Generics.EMGM.Functions.Collect  Generics.EMGM.Functions.Compare  #Generics.EMGM.Functions.Constructor  Generics.EMGM.Functions.Crush  Generics.EMGM.Functions.Enum  Generics.EMGM.Functions.Read  Generics.EMGM.Functions.Show HCase for the primitive type . ICase for the primitive type . JCase for the primitive type . KCase for the primitive type . LCase for the primitive type . M,Case for the structural representation type  . Represents a  constructor with no arguments. N,Case for the structural representation type :+: (sum). Represents  alternative constructors. O,Case for the structural representation type :*: (product). Represents  the fields of a constructor. PGCase for constructors. It is used to hold the meta-information about a I constructor, e.g. name, arity, fixity, etc. This is not needed for many 6 generic functions, so the default implementation is:   rcon = const id QJCase for labeled field. Contains the label string. This is not needed for ; many generic functions, so the default implementation is:   rlbl = const id RACase 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 G. S  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR.GHIJKLMNOPQR;<=>?@ABCDEF/0123456789:-.+,)*'(%&.%&&'(()**+,,-../ 0123456789:0123456789:; <=>?@ABCDEF<=>?@ABCDEFG HIJKLMNOPQRHIJKLMNOPQR non-portable experimentalgenerics@haskell.orgSLThe type of a generic function that takes a value of one type and returns a ' collection 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 = ...  8 instance (Alternative f) => Rep (Collect f T) T where  rep = Collect pure L(Note that overlapping instances are required.) This instance triggers when  the result type (the T in  Collect f T%) matches the value type (the second  T#) contained within the argument to V. See the source of this  module for more examples. TUVCollect values of type b from some value of type a. An  means O no values were collected. If you expected otherwise, be sure that you have an  instance such as - (TS 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 TS. STUVSTUVSTUTUV non-portable experimentalgenerics@haskell.orgWJThe type of a generic function that takes two values of the same type and  returns an ". XY#$%Z!Compare two values and return an " (i.e. LT, GT, or EQ). 4 This is implemented exactly as if the datatype was  deriving Ord. [Less than. Returns x < y. \Less than or equal to. Returns x <= y. ]Equal to. Returns x == y. ^Not equal to. Returns x /= y. _Greater than. Returns x > y. `"Greater than or equal to. Returns x >= y. aThe minimum of two values. bThe maximum of two values. WXYZ[\]^_`ab WXYZ]^[\_`ab WXYXYZ[\]^_`ab non-portable experimentalgenerics@haskell.orgcCThe 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. def.Associativity of the binary operator used for i gRight-associative hLeft-associative &'(iApply 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 j or k. 6Associativity of the binary operator (left or right). Binary operator on a-elements with an accumulator.  The initial b -value for the binary operator.  Container of a -values. 4The result after applying the above operator on all  a -values. jA right-associative variant of i. kA left-associative variant of i. l1Flatten 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 m or n. mA right-associative variant of l. Note that, for a list ls :: [a], flattenr ls == ls. nA left-associative variant of l. Note that, for a list ls :: [a], flattenl ls == reverse ls. o*Extract the first element of a container. ) if the container is empty. NThis is the most general form in which you must specify the associativity and  the *5 instance. You may prefer to use the more convenient p or  q. pA right-associative + variant of o. Note that, for a list ls :: [a], fromJust (firstr ls) == head ls. qA left-associative + variant of o. Note that, for a list ls :: [a], fromJust (firstl ls) == last ls. r>Determine if an element is a member of a container. This is a  generalization of the Prelude function of the same name. sBDetermine if an element is not a member of a container. This is a  generalization of the Prelude function of the same name. tLCompute the sum of all elements in a container. This is a generalization of  the Prelude function of the same name. u>Compute the product of all elements in a container. This is a  generalization of the Prelude function of the same name. vIDetermine the maximum element of a container. If the container is empty,  return ,". This is a generalization of the Prelude function of the  same name. wIDetermine the minimum element of a container. If the container is empty,  return ,". This is a generalization of the Prelude function of the  same name. xBCompute the conjunction of all elements in a container. This is a  generalization of the Prelude function of the same name. yBCompute the disjunction of all elements in a container. This is a  generalization of the Prelude function of the same name. z@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. cdefghijklmnopqrstuvwxyz{cdefhgikjlnmoqpxyz{tuwvrscdedefhgghijklmnopqrstuvwxyz{ 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 /01(Cartesian product with diagonalization. From Mark Jones' talk at AFP2008 2E values starting with 0 and enumerating to the positive and negative  bounds. 3ENumeric and enumerable values starting with 0 and enumerating in the . positive and negative directions. Useful for , , and  . 456IEnumerate 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  7 n (). 2Returns the first element of the enumeration from  . This is * often called the neutral or empty value. |}~|}~|}~}~ non-portable experimentalgenerics@haskell.org&This type servers the same purpose as , 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 . JThe 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 . 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 . 89:Apply 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 .   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 . <=>Apply 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 ! with the exception of recursive K datatypes. For example, compare the example used in the documentation for   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 .  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. ?@A?Apply a function to all elements of a container datatype (kind * -> *).  Replace all a -values in f a with b. Defined as:   # replace as b = map (const 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  . =  B    instance - ( )  where  . =  (+42) 2There are no pre-defined instances, and a call to cast will not compile if O no instances for the input and output type pair are found, so you must define  instances in order to use cast.   non-portable experimentalgenerics@haskell.orgKThe type of a generic function that takes a boolean to limit recursion and H a value and returns a list of label descriptions for that constructor. LThe type of a generic function that takes one value and returns an optional  constructor description. IA class to reveal the embedding-projection pair for a given datatype and % its isomorphic representation type. %The parameter is never evaluated, so  undefined is acceptable. CGReturns a constructor description if the value is not a primitive. The & argument is not evaluated and may be  undefined. DEFGHIJLReturns a list of descriptions for all labels in the head constructor. Does I not recurse into the children. The argument is not evaluated and may be   undefined.   non-portable experimentalgenerics@haskell.orgJThe type of a generic function that takes a constructor-type argument and , returns a parser combinator for some type. KLM (paren p) parses "(P0)" where p parses "P0" at precedence 0 N7Read optional parentheses plus a single required pair. ORead a , b without parens. PRead  a , b , c without parens. QRead  a , b , c , d without parens. R (paren p) parses "{P0}" where p parses "P0" at precedence 0 S>Parse a Haskell token and verify that it is the one expected. TUVWX Generate a Y$ 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. FOperator precedence of the enclosing context (a number from 0 to 11). Equivalent to String -> [(a,String)].  Generate a Z$ parser combinator for the datatype a. This can be used  with Text.ParserCombinators.ReadP. FOperator precedence of the enclosing context (a number from 0 to 11).  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. [Ad-hoc instance for (a,b,c,d,e,f,h) \Ad-hoc instance for  (a,b,c,d,e,f) ]Ad-hoc instance for  (a,b,c,d,e) ^Ad-hoc instance for  (a,b,c,d) _Ad-hoc instance for (a,b,c) `Ad-hoc instance for (a,b) aAd-hoc instance for () bAd-hoc instance for strings cAd-hoc instance for lists   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 d function. efghijklmKConvert a value to a readable string starting with the operator precedence  of the enclosing context. FOperator precedence of the enclosing context (a number from 0 to 11). The value to be converted to a n.  A variant of " with the minimum precedence (0).  A variant of  that returns a n instead of d. oAd-hoc instance for (a,b,c,d,e,f,h) pAd-hoc instance for  (a,b,c,d,e,f) qAd-hoc instance for  (a,b,c,d,e) rAd-hoc instance for  (a,b,c,d) sAd-hoc instance for (a,b,c) tAd-hoc instance for (a,b) uAd-hoc instance for () vAd-hoc instance for strings wAd-hoc instance for lists   non-portable experimentalgenerics@haskell.org xyzFThe 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. & Fails if the spliting function fails Splitting function.  Container of a -values. Pair of containers. A specialized version of  using the identity monad and a ( splitting function that does not fail. A specialized version of  for pairs. Generic version of   Prelude.unzip.   non-portable experimentalgenerics@haskell.org IThe type of a generic function that takes two arguments of two different 7 types and returns a value of a third type in a Monad. FCombine two structurally equivalent containers into one by applying a K function to every corresponding pair of elements. Fails if (1) the binary  operator fails or (2) f a and f b have different shapes. +Binary operator on elements of containers.  Container of a -values.  Container of b -values.  Container of c-values within a Monad m. A specialized version of  for the + monad and a binary 1 operator that does not fail. Generic version of Prelude.zipWith. A specialized version of  for pairs. Generic version of   Prelude.zip.  non-portable experimentalgenerics@haskell.org JThe type of a generic function that takes a generic value and non-generic G container and returns the container filled with other generic values. 5Transposes the structure of nested containers (types f and g). ) I if the outermost container is empty, because there is no generic way to M guarantee that both have unit constructors or, if they do, decide which one  to choose. See  for an alternative approach. A convenient version of  that returns the  value on  failure.  non-portable experimentalgenerics@haskell.org Constructor description for . Constructor description for  . Representation of  for .. Representation of  for ,. Representation of  for *. Representation of  for &. Representation of  for (.  non-portable experimentalgenerics@haskell.org Constructor description for . Constructor description for . Representation of  for ,. Representation of  for .. Representation of  for *. Representation of  for (. Representation of  for &.  non-portable experimentalgenerics@haskell.org Constructor description for ''nil'': []. Constructor description for ''cons'': (:). Representation of lists for ,. Representation of lists for .. Representation of lists for *. Representation of lists for (. Representation of lists for &.  non-portable experimentalgenerics@haskell.org Constructor description for ,. Constructor description for . Representation of + for ,. Representation of + for .. Representation of + for *. Representation of + for (. Representation of + for &.  non-portable experimentalgenerics@haskell.org8Constructor description for (). Representation of () for .. Representation of () for ,. Representation of () for *. Representation of () for (. Representation of () for &. Constructor description for (,). Representation of (,) for ,. Representation of (,) for .. Representation of (,) for *. Representation of (,) for (. Representation of (,) for &. Constructor description for (,,). Representation of (,,) for ,. Representation of (,,) for .. Representation of (,,) for *. Representation of (,,) for (. Representation of (,,) for &. Constructor description for (,,,). Representation of (,,,) for ,. Representation of (,,,) for .. Representation of (,,,) for *. Representation of (,,,) for (. Representation of (,,,) for &. Constructor description for (,,,,). Representation of (,,,,) for ,. Representation of (,,,,) for .. Representation of (,,,,) for *. Representation of (,,,,) for bfrep2. Representation of (,,,,) for &. Constructor description for (,,,,,). Representation of (,,,,,) for ,. Representation of (,,,,,) for .. Representation of (,,,,,) for *. Representation of (,,,,,) for (. Representation of (,,,,,) for &. Constructor description for (,,,,,,). Representation of (,,,,,,) for ,. Representation of (,,,,,,) for .. Representation of (,,,,,,) for *.  Representation of (,,,,,,) for (.  Representation of (,,,,,,) for &. 1  1  1   non-portable experimentalgenerics@haskell.org  Constructor description for .  Representation of  for .. Representation of  for ,. Representation of  for *. Representation of  for &. Representation of  for (.           non-portable experimentalgenerics@haskell.org !%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRVZ[\]^_`abfghijklmnopqrstuvwxyz{ !GHIJKLMNOPQR;<=>?@ABCDEF/0123456789:-.+,)*%&'(VZ]^[\_`abfhgikjlnmoqpxyz{tuwvrs !"#$%&&'()*++,-..//01233456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeffghiijklmnopqrsttuvwxyz{|}~                    !"#$%&'()*+,-./012345657898:;<=>?@ABCDEFGHI5JKLMNOPQR S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g hijk l m n o p q r s tu v w x y z { | } ~5                 V   8QQemgm-0.4Generics.EMGM.RepresentationGenerics.EMGM.BaseGenerics.EMGM.Functions.CollectGenerics.EMGM.Functions.CompareGenerics.EMGM.Functions.CrushGenerics.EMGM.Functions.Enum"Generics.EMGM.Functions.EverywhereGenerics.EMGM.Functions.MapGenerics.EMGM.Functions.MetaGenerics.EMGM.Functions.ReadGenerics.EMGM.Functions.Show!Generics.EMGM.Functions.UnzipWithGenerics.EMGM.Functions.ZipWith!Generics.EMGM.Functions.TransposeGenerics.EMGM.Data.BoolGenerics.EMGM.Data.EitherGenerics.EMGM.Data.ListGenerics.EMGM.Data.MaybeGenerics.EMGM.Data.TupleGenerics.EMGM.Data.Ratio Generics.EMGMbaseText.ParserCombinators.ReadPrecminPrecPrec AssociativityNonAssoc RightAssoc LeftAssocFixityInfixPrefixConTypeRecordCInfixCNormalCUnknownCConDescrconNameconArity conRecord conFixityEPfromtoLblDescr:*::+:RLUnitprecmaxPrecappPrecrecPrecFRep3frep3BiFRep2bifrep2FRep2frep2FRepfrepReprepGeneric3rint3 rinteger3rfloat3rdouble3rchar3runit3rsum3rprod3rcon3rlbl3rtype3Generic2rint2 rinteger2rfloat2rdouble2rchar2runit2rsum2rprod2rcon2rlbl2rtype2GenericrintrintegerrfloatrdoublercharrunitrsumrprodrconrlblrtypeCollect selCollectcollectCompare selComparecompareltlteqeqneqgtgteqminmaxCrushselCrushAssoc AssocRight AssocLeftcrushcrushrcrushlflattenflattenrflattenlfirstfirstrfirstlelemnotElemsumproductmaximumminimumandoranyallEnumselEnumenumenumNempty Everywhere'selEverywhere' Everywhere selEverywhere everywhere everywhere'MapselMapmapreplacebimapcastLbls selLabelsConselConstructorHasEPepOfconDescr lblDescrsReadselReadreadPrec readsPrecreadPreadsreadShowselShow showsPrecshowsshow UnzipWith selUnzipWith unzipWithM unzipWithunzipZipWith selZipWithzipWithMzipWithzip Transpose selTranspose transpose transposeEBoolSconFalseconTruerepBoolfrepBool frep2Bool frep3Bool bifrep2BoolEitherSconLeftconRight frepEither repEither frep2Either bifrep2Either frep3EitherListSconNilconConsfrepListrepList frep2List bifrep2List frep3ListMaybeS conNothingconJust frepMayberepMaybe frep2Maybe bifrep2Maybe frep3MaybeTuple7STuple6STuple5STuple4STuple3STuple2STuple0S conTuple0 repTuple0 frepTuple0 frep2Tuple0 bifrep2Tuple0 frep3Tuple0 conTuple2 frepTuple2 repTuple2 frep2Tuple2 bifrep2Tuple2 frep3Tuple2 conTuple3 frepTuple3 repTuple3 frep2Tuple3 bifrep2Tuple3 frep3Tuple3 conTuple4 frepTuple4 repTuple4 frep2Tuple4 bifrep2Tuple4 frep3Tuple4 conTuple5 frepTuple5 repTuple5 frep2Tuple5 bifrep2Tuple5 frep3Tuple5 conTuple6 frepTuple6 repTuple6 frep2Tuple6 bifrep2Tuple6 frep3Tuple6 conTuple7 frepTuple7 repTuple7 frep2Tuple7 bifrep2Tuple7 frep3Tuple7RatioSconRatiorepRatio frepRatio frep2Ratio frep3Ratio bifrep2RatioGHC.ReadGHC.Show Data.EitherEitherghc-prim GHC.TypesInt integer-gmpGHC.Integer.TypeIntegerFloatDoubleChar rsumCollect rprodCollect rtypeCollectControl.ApplicativeLeftRightTrueGHC.NumNum GHC.OrderingOrdering rsumCompare rprodCompare rtypeCompare rsumCrush rprodCrush rtypeCrushGHC.BasefailMonad Data.MaybeMaybeNothing|||diagskewcombine><intEnumnumEnumrsumEnum rprodEnum rtypeEnum Data.List genericTakersumEverywhererprodEverywherertypeEverywhereidrsumEverywhere'rprodEverywhere'rtypeEverywhere'rsumMaprprodMaprtypeMapGHC.Real realToFracrsumConstructor rsumLabels rprodLabelscheck rconLabels rtypeLabelsnoneonecommaequalsparen wrapTupletuple2tuple3tuple4braceslexTrsumRead rprodReadrconReadrlblRead rtypeReadReadPrecText.ParserCombinators.ReadPReadP$fRepRead(,,,,,,)$fRepRead(,,,,,)$fRepRead(,,,,)$fRepRead(,,,) $fRepRead(,,) $fRepRead(,) $fRepRead() $fRepRead[] $fRepRead[]0ShowS ShowsPrec showSpace showBraces showTuplersumShow rprodShowrconShowrlblShow rtypeShowString$fRepShow(,,,,,,)$fRepShow(,,,,,)$fRepShow(,,,,)$fRepShow(,,,) $fRepShow(,,) $fRepShow(,) $fRepShow() $fRepShow[] $fRepShow[]0IdrunIdpair rsumUnzipWithrprodUnzipWithrtypeUnzipWith rsumZipWith rprodZipWith rtypeZipWithliftreplaceM rsumTransposerprodTransposertypeTransposeepBoolFalseBoolepEitherepListepMaybeJustepTuple0epTuple2epTuple3epTuple4epTuple5epTuple6epTuple7epRatio%Ratio