úÎQK*q      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopSafe +,<=?DR )Get the tenth type of a value level tuple*Get the nineth type of a value level tuple)Get the eigth type of a value level tuple+Get the seventh type of a value level tuple)Get the sixth type of a value level tuple)Get the fifth type of a value level tuple*Get the fourth type of a value level tuple)Get the third type of a value level tuple*Get the second type of a value level tuple µGet the first type of a value level tuple This is useful for defining a newtype wrapper with a single "parameterized" type, around a type with many "parameterized" type variables.     Safe+<=?D HParameterized version of (<>) in Semigroup If used in conjunction with  Y, ie as a parameterized Monoid, then the instance should follow the following laws: *  pmempty'  pmappend' x = x * x  pmappend' pempty' = x * x  pmappend' (y  pmappend' z) = (x  pmappend' y)  pmappend' z      6Safe*+:<=?D  Parameterized version of Monoid.*Parameterized version of mempty in Monoid.    Safe+:<=?DParameterized version of  Alternative NB. 3 cannot be made a superclass because type variable id7 will be ambiguous. NB. PAlternative doensn't require @ as a superclass, because Some things can be made instances of  but not .An associative binary operation"Parameterized version of empty in  Alternativer. An instance of this should create a parameterized unary type where the parameter is an identity in respect to The identity of Parameterized version of ap in q NB. 3 cannot be made a superclass because type variable id is not in scope.Sequential application.Parameterized version of r in qq An instance of this should create a parameterized unary type where the parameter is an identity in respect to  lift a value.Sequential application.=Sequence actions, discarding the value of the first argument.>Sequence actions, discarding the value of the second argument.Lift a function to actions."Lift a binary function to actions.#Lift a ternary function to actions. 4443Safe*+<=?DParameterized version of Monad. gSequentially compose two actions, passing any value produced by the first as an argument to the second.!gSequentially compose two actions, passing any value produced by the first as an argument to the second.#Same as !&, but with the arguments interchanged.$,Left-to-right Kleisli composition of monads.%-Right-to-left Kleisli composition of monads. (>=>), with the arguments flipped. !"#$% !"#$% !"#$% !"#$%!1"1#1$1%1None,259:;<=DIR&Given a Reader that accepts Many a", and another Reader that accepts Many b make a reader that accepts Many (AppendUnique a b)Y with the compile time constraint that all the types in (AppendUnique a b) are distinct.)Given a Reader that accepts Which a", and another Reader that accepts Which b make a reader that accepts Which (Append a b)n and only run one of the readers for the correct Which type, with a compile-time contraint that the types in Which a are distinct from the type in Which b The advantage of ) over , is that " doesn't require the inner monad m to be an s. NB.  still requires s) but you don't need to be an instance of  (analogous to Semigroup),Given a Reader that accepts Which a", and another Reader that accepts Which b make a reader that accepts Which (AppendUnique a b)8 and runs both readers if possible, where the types in Which a and Which bj may overlap, but with the compile time constraint that all the types in (AppendUnique a b) are distinct.&'()*+,-./0123456789 &'()*+,-.,-.987)*+654&'(3210/&'()*+,-./0123456789None,259:;<=DIORTX.Given a ChangingState that changes state from s to t5, and another ChangingState that changes state from t to u! make a State that changes from s to uY with the compile time constraint that all the types in (AppendUnique a b) are distinct.[ Given a ManyState that modifies Many a%, and another ManyState that modifes Many b make a State that accepts Many (AppendUnique a b)Y with the compile time constraint that all the types in (AppendUnique a b) are distinct.XYZ[\]^_`abcdefXYZ[\][\]fedcbXYZa`_^ XYZ[\]^_`abcdeft     !"#$%&'()*+,-./0012234456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^__`aabcdefghijklmnopqrstuvwxvwyvwz{+parameterized-0.2.0.0-7fvcAhKdowtOYBAPSjLpdParameterized.TypeLevelParameterized.Data.SemigroupParameterized.Data.Monoid!Parameterized.Control.ApplicativeParameterized.Control.Monad(Parameterized.Control.Monad.Trans.Reader.Parameterized.Control.Monad.Trans.State.StrictParameterized.DataEmptyAt9At8At7At6At5At4At3At2At1At0 PSemigrouppmappend&<>PMonoidPMEmptypmempty PAlternativepappendPEmptypempty PApplicativepapplyPPointedppure&<*>&*>&<*pliftApliftA2pliftA3&<|>PMonadpbind&>>=&>>&=<<&>=>&<=< ManyReader runManyReaderDistinctWhichReaderrunDistinctWhichReaderOverlappingWhichReaderrunOverlappingWhichReader"$fPMonadTYPEManyReaderManyManyMany($fPAlternativeTYPEManyReaderManyManyMany($fPApplicativeTYPEManyReaderManyManyMany$fPEmptyTYPEManyReaderMany$fPPointedTYPEManyReaderMany4$fPAlternativeTYPEDistinctWhichReaderWhichWhichWhich$$fPEmptyTYPEDistinctWhichReaderWhich&$fPPointedTYPEDistinctWhichReaderWhich7$fPAlternativeTYPEOverlappingWhichReaderWhichWhichWhich'$fPEmptyTYPEOverlappingWhichReaderWhich)$fPPointedTYPEOverlappingWhichReaderWhich$fGenericOverlappingWhichReader$fFunctorOverlappingWhichReader#$fApplicativeOverlappingWhichReader$fMonadOverlappingWhichReader#$fAlternativeOverlappingWhichReader!$fMonadPlusOverlappingWhichReader $fMonadZipOverlappingWhichReader $fMonadFixOverlappingWhichReader!$fMonadFailOverlappingWhichReader$fMonadIOOverlappingWhichReader$fGenericDistinctWhichReader$fFunctorDistinctWhichReader $fApplicativeDistinctWhichReader$fMonadDistinctWhichReader $fAlternativeDistinctWhichReader$fMonadPlusDistinctWhichReader$fMonadZipDistinctWhichReader$fMonadFixDistinctWhichReader$fMonadFailDistinctWhichReader$fMonadIODistinctWhichReader$fGenericManyReader$fFunctorManyReader$fApplicativeManyReader$fMonadManyReader$fAlternativeManyReader$fMonadPlusManyReader$fMonadZipManyReader$fMonadFixManyReader$fMonadFailManyReader$fMonadIOManyReader ChangingStaterunChangingState ManyState runManyState"$fPMonadTYPEChangingState(,)(,)(,)($fPApplicativeTYPEChangingState(,)(,)(,)$fPPointedTYPEChangingState(,)$fFunctorChangingState!$fPMonadTYPEManyStateManyManyMany'$fPAlternativeTYPEManyStateManyManyMany'$fPApplicativeTYPEManyStateManyManyMany$fPEmptyTYPEManyStateMany$fPPointedTYPEManyStateMany$fGenericManyState$fFunctorManyState$fApplicativeManyState$fMonadManyState$fAlternativeManyState$fMonadPlusManyState$fMonadFixManyState$fMonadFailManyState$fMonadIOManyState$fGenericChangingStatebaseGHC.Base Applicativepure Alternative