úÎXéRÉu      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstSafe +,<=?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 +<=?DR 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      6 6Safe *+9:;<=?D Parameterized version of Monoid.*Parameterized version of mempty in Monoid. Safe +:<=?DRParameterized 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 u NB. 3 cannot be made a superclass because type variable id is not in scope.Sequential application.Parameterized version of v in uq An instance of this should create a parameterized unary type where the parameter is an identity in respect to  NB. For   , the id s. "parameter" cannot be purely determined from m , so unlike G there is not functional dependency to help type inference. Hint: use  ppure @_ @_ .id@ to specify the id type to avoid ambiguity. 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. ! ! !  !34444!3Safe*+<=?D"Parameterized 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'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 w. NB.  still requires w) 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:;< )*+,-./01/01<;:,-.987)*+65432)*+,-./0123456789:;<None,259:;<=DIORT[.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 u with the compile time constraint that all the types in (AppendUnique a b) are distinct. NB. The state is in the snd position to be consistent with StateT.^ 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.a}Prefer this to using ChangingState to construct as it results in better type inference as it avoids ambiguous type variable st[\]^_`abcdefghij[\]^_`a^_`jihgf[\]aedcb [\]^_`abcdefghijx    !"#$%&'()*+,-./0123445667889:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab  cddefghijklmnopqrstuvwxyz{|z{}z{~,parameterized-0.5.0.0-EMeutE5jJ2JEdVqeGBcPpdParameterized.TypeLevelParameterized.Data.SemigroupParameterized.Data.Monoid!Parameterized.Control.ApplicativeParameterized.Control.Monad(Parameterized.Control.Monad.Trans.Reader.Parameterized.Control.Monad.Trans.State.StrictParameterized.DataEmpty ChangingStateAt9At8At7At6At5At4At3At2At1At0 PSemigrouppmappendPNullary&<>PMonoidPMEmptypmempty$fPMonoidknidtuv PAlternativepappendPEmptypempty PApplicativepapplyPPointedppurePUnary&<*>&*>&<*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$fMonadIOManyReaderrunChangingState ManyState runManyState changingState"$fPMonadTYPEChangingState(,)(,)(,)($fPApplicativeTYPEChangingState(,)(,)(,)$fPPointedTYPEChangingState(,)$fFunctorChangingState!$fPMonadTYPEManyStateManyManyMany'$fPAlternativeTYPEManyStateManyManyMany'$fPApplicativeTYPEManyStateManyManyMany$fPEmptyTYPEManyStateMany$fPPointedTYPEManyStateMany$fGenericManyState$fFunctorManyState$fApplicativeManyState$fMonadManyState$fAlternativeManyState$fMonadPlusManyState$fMonadFixManyState$fMonadFailManyState$fMonadIOManyState$fGenericChangingStatebaseGHC.Base Applicativepure Alternative