<      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw x y z { | } ~  #(c) 2008--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe%&DQR4#(c) 2008--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafeDsDatatype to represent the fixity of a constructor. An infix declaration directly corresponds to an application of  . [Class for datatypes that represent data constructors. For non-symbolic constructors, only  L has to be defined. The weird argument is supposed to be instantiated with C$ from base, hence the complex kind.      #(c) 2008--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe %&<=DOQRT.Semi-decidable equality for types of a family.BClass that contains the shallow conversion functions for a family."Class for the members of a family.7Type family describing the pattern functor of a family.Unlifted version of 1. Unlifted version of 4.#Represents constructors.%5Represents composition with functors of kind * -> *.(GIs used to indicate the type that a particular constructor injects to.*;Represents products (sequences of fields of a constructor).,/Represents sums (choices between constructors)./'Represents constructors without fields.1;Represents constant types that do not belong to the family.4WRepresents recursive positions. The first argument indicates which type to recurse on.7Destructor for '(:>:)'.8Destructor for #.9+For backwards-compatibility: a synonym for .( !"#$%&'()*+,-./0123456789:;<2  !"#$%&'()*+,.-/0123456789%456123/0,-.*+()7%&'#$8 !"9 !"#$%&'()*+,-./0123456789:;<(6*7+7,5#(c) 2008--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe %&9;<=OQRT? The function ? takes a functor fP. All the recursive instances in that functor are wrapped by an application of r. The argument to ?# takes a function that transformes r occurrences into r' occurrences, for every ix". In order to associate the index ix with the correct family phi, the argument to hmap5 is additionally parameterized by a witness of type phi ix. @Monadic version of ?. =>?@ABCDEFGH=>?@ =>HGFEDCBA?@ =>?@ABCDEFGH#(c) 2008--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe %&:DNOQRTIJKLMNOPQRSTUVWXYZ[\]^_IJKLMNOPQRSTUVWXYZ[\]^_VUTSWXRQPOYZNMLK[\JI]^_IJKLMNOPQRSTUVWXYZ[\]^_I ]5#(c) 2008--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe:OT`Normal version.aMonadic version of `.bApplicative version of `.`ab`ab`ab`ab#(c) 2008--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe %&9:;<=OQRTnCFor constant types, we make use of the standard equality function.cdefghijklmnopqcdefgefcdqponmlkjihg cdefghijklmnopq#(c) 2008--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe:DRrstuvrstuvrstuvrstuv #(c) 2008--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableNone%&DMw;Given the name of the family index GADT, derive everything.xIGiven a list of datatype names, derive datatypes and instances of class  . Not needed if w is used.yCompatibility. Use w instead.Given the name of the index GADT, the names of the types in the family, and the name (as string) for the pattern functor to derive, generate the Ix and  instances.  IMPORTANTg: It is assumed that the constructors of the GADT have the same names as the datatypes in the family.zCompatibility. Use w instead.{Derive only the  instance. Not needed if w is used.|Derive only the  instances. Not needed if w is used.}Derive only the  instance. Not needed if w is used.~Derive only the  instance. Not needed if w is used.Process the reified info of the index GADT, and extract its constructor names, which are also the names of the datatypes that are part of the family.MProcess the reified info of the index GADT, and extract its type parameters.ZTurn a record-constructor into a normal constructor by just removing all the field names.Takes the name of a datatype (element of the family). By reifying the datatype, we obtain its constructors. For each constructor, we then generate a constructor-specific datatype, and an instance of the   class.@Given a constructor, create an empty datatype of the same name./Given a constructor, create an instance of the  9 class for the datatype associated with the constructor.Takes all the names of datatypes belonging to the family, and a particular of these names. Produces the right hand side of the ' type family instance for this family.Takes all the names of datatypes belonging to the family, and a particular name of a constructor of one of the datatypes. Creates the product structure for this constructor.Takes all the names of datatypes belonging to the family, and a particular type (that occurs as a field in one of these datatypes). Produces the structure for this type. We have to distinguish between recursive calls, compositions, and constants.TODO: We currently treat all applications as compositions. However, we can argue that applications should be treated as compositions only if the entire construct cannot be treated as a constant.$wxyz{|}~    wxyz{|}~wxyz{|}~$wxyz{|}~    #(c) 2008--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe:DOQRT    #(c) 2009--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe %&:DNOQRT 5 #(c) 2008--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe %&9:;<=OQRTThe list in the result type allows us to get at the fields of a constructor individually, which in turn allows us to insert additional stuff in between if record notation is used.?For constant types, we make use of the standard show function.  #(c) 2009--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe%&9:;DNOQRT?The class fold explains how to convert a convenient algebra [ back into a function from functor to result, as required by the standard fold function.The algebras passed to the fold have to work for all index types in the family. The additional witness argument is required only to make GHC's typechecker happy.;The type family we use to describe the convenient algebras.Fold with convenient algebras.For constructing algebras that are made of nested pairs rather than n-ary tuples, it is helpful to use this pairing combinator.5#(c) 2009--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe%&9:;DNOQRT?The class fold explains how to convert a convenient algebra [ back into a function from functor to result, as required by the standard fold function.The algebras passed to the fold have to work for all index types in the family. The additional witness argument is required only to make GHC's typechecker happy.;The type family we use to describe the convenient algebras.Fold with convenient algebras.For constructing algebras that are made of nested pairs rather than n-ary tuples, it is helpful to use this pairing combinator. 5#(c) 2009--2010 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe%&9:;<=DOQRT(c) 2008 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafec  !"#$%&'()*+,.-/0123456789=>?@IJKLMNOPQRSTUVWXYZ[\]^_`abcdefgrstuv  !"#$%&'()*+,-../0012234567889:;<<==>??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i    _   a g _ag %multirec-0.7.6-9uTidF64Bxt6w4cpPphwJtGenerics.MultiRec.TEqGenerics.MultiRec.ConstructorGenerics.MultiRec.BaseGenerics.MultiRec.HFunctorGenerics.MultiRec.FoldGenerics.MultiRec.ComposGenerics.MultiRec.EqGenerics.MultiRec.HFixGenerics.MultiRec.THGenerics.MultiRec.ConNamesGenerics.MultiRec.FoldKGenerics.MultiRec.ShowGenerics.MultiRec.FoldAlgGenerics.MultiRec.FoldAlgKGenerics.MultiRec.ReadGenerics.MultiRec:=:Reflcast AssociativityLeftAssociativeRightAssociativeNotAssociativeFixityPrefixInfix ConstructorconName conFixity$fEqAssociativity$fShowAssociativity$fOrdAssociativity$fReadAssociativity $fEqFixity $fShowFixity $fOrdFixity $fReadFixityEqSeqSFamfromtoElproofPFK0unK0I0unI0C:.:DunD:>:Tag:*::+:LRUKunKIunIunTagunCindex $fFunctorK0$fApplicativeI0 $fFunctorI0HFunctorhmapAhmaphmapM$fHFunctorphiC$fHFunctorphi:.:$fHFunctorphi:>:$fHFunctorphi:*:$fHFunctorphi:+:$fHFunctorphiU$fHFunctorphiK$fHFunctorphiI:->AlgPart ParaAlgebraF ParaAlgebraF' ParaAlgebra ParaAlgebra' CoAlgebraF CoAlgebraF' CoAlgebra CoAlgebra'AlgebraF AlgebraF'AlgebraAlgebra'foldfoldMunfoldunfoldMparaparaM&tagconcomposcomposMcomposAEq1eq1HEqheqeq $fHEqphiC $fHEqphi:>: $fHEqphi:.: $fHEqphi:*: $fHEqphi:+: $fHEqphiU $fHEqphiK $fHEqphiI $fEq1Maybe$fEq1[]HFixHInhouthfromhto deriveAllderiveConstructors deriveFamily deriveSystemderivePFderiveEl deriveFam deriveEqSConNames hconNamesconNames $fConNames:>: $fConNamesI $fConNames:.: $fConNames:*: $fConNamesU $fConNamesK $fConNames:+: $fConNamesCShow1show1HShow hShowsPrecAlg showsPrecshowspacescommas intersperse $fShow1[] $fShow1Maybe $fHShowphiC $fHShowphi:.: $fHShowphi:>: $fHShowphi:*: $fHShowphi:+: $fHShowphiU $fHShowphiK $fHShowphiIFoldalgCompAlg$fFoldC $fFold:>: $fFold:*: $fFold:*:0 $fFold:+: $fFold:.:$fFoldI$fFoldU$fFoldKRead1read1 HReadPrechreader CountAtoms countatomsreadConsreadPrefixCons readInfixConsreadNoArgsConsappPrecreadPrec readsPrecread$fHReadPrecphiC$fHReadPrecphiC0$fHReadPrecphiC1$fHReadPrecphiC2$fHReadPrecphiC3 $fRead1Maybe $fRead1[]$fHReadPrecphi:.:$fHReadPrecphi:>:$fHReadPrecphi:*:$fHReadPrecphi:+:$fHReadPrecphiI$fHReadPrecphiK$fHReadPrecphiU$fCountAtoms:*: $fCountAtomsI $fCountAtomsKextractConstructorNamesextractParametersstripRecordNamesconstrInstancemkData mkInstancepfTypepfConpfFieldderivePFInstanceextractFromBndrfixityassocunApp elInstancemkFrommkTomkProoffromContoCon fromField fromFieldFuntoField toFieldFunfieldlrPlrE remakeName