$g      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefNonegAConvert some generic outputable to a string (potentially unsafe).h Convert an i" to a string (potentially unsafe).j.Check if the string reprentation of the given k contains any of the given strings.l.Check if the string reprentation of the given k contains all of the given strings.m.Check if the string reprentation of the given k contains none of the given strings.ghjlmghjlmghjlm NonenType of package identifiers.o$Type of type variable substitutions.p Return the A value. If no A$ value is given, an error is raised.q Return the B value. If no B$ value is given, an error is raised.rMMake a substitution based on an association between type variables and types.s>Splits a function kind into its argument kinds and its result. For example: =splitKindFunTys (* -> * -> Constraint) = ([*, *], Constraint)tLCreate a type representing an equality constraint between the two arguments. For example:  mkEqualityCtType a Int = a ~ Intu9Returns the source code location of the given constraint.vThe package identifier for the base package.w2Access the package identifier of the given module.xACheck if the given element is imported from the given module. = if it is a local definition.yWrap a z into a {.|Evidence production step for "Control.Supermonad.Plugin.EvidenceJ module to produce evidence for tuple constraints (prior to GHC 8.0.1).}9Check if a given type constructor is a tuple constructor.~bLookup an instance for the class applied to the type arguments within the instance environmentnopqrstuvwxy|}~nopqrstuvwxy|}~nopqrstuvwxy|}~ NoneRetrieve the type constructors at top level involved in the given types. If there are type constructors nested within the type they are ignored.Example:&collectTopTyCons [Maybe (Identity ())] { Maybe }Retrieve the type constructor variables at the top level involved in the given types. If there are nested type variables they are ignored. There is no actual check if the returned type variables are actually type constructor variables.Example:'collectTopTcVars [m a b, Identity c, n]{ m, n }kRetrieve the type constructor variables at the top level involved in the given types. If there are nested type variables they are ignored. There is no actual check if the returned type variables are actually type constructor variables. Also associates the appearant arity of the given type variables by looking at how many arguments it was applied to.Example:'collectTopTcVars [m a b, Identity c, n]{ (m, 2), (n, 0) }Try to collect all type variables in a given expression. Does not work for Pi or ForAll types. If the given type is not supported an empty set is returned.hCreate a substitution that replaces the given type variables with their associated type constructors.@Override the standard bind flag of a given list of variables to 0. The standard bind flag is determined using . This can be used to keep  tcUnifyTysD from unifying the given variables and to view them as constants.TCheck if both types contain type variables and if those type variables are equal.aCheck if the given type constrains a type variable and it is equal to the given type variable.+Returns the arity of a given type variable.SReturns the string representation of the given type constructor in the source code.DGet the element of a list at a given index (If that element exists).7Checks if the given type is an ambiguous type variable.Takes a list of type variables that are associated with certain type constructors or type constructor variables and partially applies them to match the kind of the type variable. Example:7partiallyApplyTyCons [(n :: *, Left (Maybe :: * -> *))](Right [(n :: *, Maybe i :: *, [i :: *])]EpartiallyApplyTyCons [(n :: * -> *, Right (k :: * -> Int -> * -> *))]:Right [(n :: * -> *, k i j :: * -> *, [i :: *, j :: Int])]4partiallyApplyTyCons [(n :: * -> *, Left (Int :: *)]Left ...;partiallyApplyTyCons [(n :: * -> *, Left (Maybe :: * -> *)]*Right [(n :: * -> *, Maybe :: * -> *, [])]HThe variables generated for the partial application are flexi vars (see  and ).Applies the given type constructor or type constructor variable to new correctly kinded variables to make it a (partially) applied type. The (partially) applied type is returned together with the variables that were applied to the type constructor.Retrieves the kind of the given type constructor or variables and splits it into its arguments and result. If the kind is not a function kind then the arguments will be empty.Takes a list of keys and all of their possible values and returns a list of all possible associations between keys and valuesExamples:+associations [('a', [1,2,3]), ('b', [4,5])],[ [('a', 1), ('b', 4)], [('a', 1), ('b', 5)],, [('a', 2), ('b', 4)], [('a', 2), ('b', 5)]., [('a', 3), ('b', 4)], [('a', 3), ('b', 5)] ]0Generates the set of all subsets of a given set.kEfficient removal of duplicate elements in O(n * log(n)). The result list is ordered in ascending order. Exactly like . Searches the list for the entry with the right key and returns the associated value if an entry is found. Uses a custom function to check equality.WIterate over a list of items and check if the given predicate holds for all of them.`Iterate over a list of items and check if the given predicate holds for at least one of them.Generalization of  and 6 that is used to implement each of those functions.YPartition a list into two lists based on a predicate involving a monadic computation.pq None8Checks if the given instance is of the given type class.-Returns the type class of the given instance.DReturns the type constructors of the class is instance instantiates.1Returns the arguments of the given instance head.7Check if the given instance has the following head C (M ...) ... (M ...) where M& is the given type constructor and C* is the given class. The arguments of the M+s do not have to be equal to each other.sChecks if the given instance is from the given class, but does not form a mono type constructor instance as in . None Name of the Control.Supermonad module. Name of the Control.Supermonad.Constrained module. Name of the   type class. Name of the   type class. Name of the Data.Functor.Identity module. Name of the  type constructor. Name of the Control.Supermonad.Prelude module. Name of the &Control.Supermonad.Constrained.Prelude module. Name of the  class. Name of the  Data.Functor module.@Checks if a module providing the supermonad classes is imported.Checks if the module Control.Supermonad or Control.Supermonad.Prelude+ is imported and, if so, returns either.Checks if the module Control.Supermonad.Constrained or &Control.Supermonad.Constrained.Prelude+ is imported and, if so, returns either.3Check if the given module is the supermonad module.3Checks if the given class matches the shape of the  2 type class and is defined in the right module.3Checks if the given class matches the shape of the 2 type class and is defined in the right module.=Checks if a type class matching the shape and name of the   type class is in scope.=Checks if a type class matching the shape and name of the  type class is in scope.Checks if the module Data.Functor.Identity/ is imported and, if so, returns the module.Tries to find the ^ type constructor in the imported modules. Only looks for imports through specific modules.rTries to find all of the given modules using the given search functions. Returns the list of all found modules.XChecks if the module with the given name is imported and, if so, returns that module.QChecks if a type class matching the shape of the given predicate is in scope.mCheck if the given class has the given name, arity and if the classes module fulfills the given predicate.Try to find a type constructor given its name and the modules it is exported from. The type constructor needs to be imported from one of these modules.=Try to convert the given typed thing into a type constructor.*Check if the given element has no parents.PReturns a list of all instances for the given class that are currently in scope.dCheck if there are any supermonad instances that clearly do not belong to a specific supermonad.KConstructs the map between type constructors and their supermonad instance.  type class. type class.  type class. type class.1Association between type constructor and its   and  instance in that order.None*DRNClass for constrained functors. Obeys all of the same laws as the standard 9 class, but allows to constrain the functors result type.dTODO / FIXME: Still need to figure out how and if we can generalize the continuation implementation.-     *     None*-9;<=DRT>A short-hand for writing polymorphic standard monad functions. See && for details on laws and requirements.#See && for details on laws and requirements.&See Control.Supermonad. & for details on laws and requirements.dTODO / FIXME: Still need to figure out how and if we can generalize the continuation implementation. !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()&'()#$% !" !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None)Type synonym to label wanted constraints.*Type synonym to label derived constraints.3Type synonym to label given or derived constraints.Create a derived type equality constraint. The constraint will be located at the location of the given constraints and equate the given types with each other.Create a derived type equality constraint. The constraint will be located at the location of the given constraints and equate the given variable with the given type.Creates a derived class constraint using the given location as origin. It is the programmers responsibility to supply the correct number of type arguments for the given class.GCheck if the given constraint is a class constraint of the given class.Retrieves the class and type arguments of the given type class constraint. Only works if the constraint is a type class constraint, otherwise returns >.{Retrieves the arguments of the given constraints. Only works if the given constraint is a type class constraint. See .JRetrieves the type constructor of the given type class constraint. See .Collects the type constructors in the arguments of the constraint. Only works if the given constraint is a type class constraint. Only collects those on the top level (See ).Collects the type variables in the arguments of the constraint. Only works if the given constraint is a type class constraint. Only collects those on the top level (See ).BRetrieve the source location the given constraint originated from.2Retrieves the type that represents the constraint.3Collect all type variables in the given constraint.1Sorts constraints by the line of their occurence.uNoneprefixMsg prefix msg* prefixes a message with the given string.Message prefix of the plugin.'Prefix a message with the error prefix.)Prefix a message with the warning prefix.0Prefix a message with the standard debug prefix.SPrefix a message with the debug prefix and a note that this is a printed object.}Used to emit an error with a message describing the missing case. The string is the function that misses the case and the k is the object being matched.JFormat a list of source spans by grouping spans in the same file together.Format a source span.bFormat a constraint in a readable way, without displaying information irrelevant to the plugin.Example:4[G] Polymonad m Identity m (129:12-131:41, CDictCan))[D] m_a1kdW ~ m (134:3-14, CNonCanonical)Print the result of calling  on the given object.Print the result of the k instance of the given object.5Internal function for printing from within the monad.,Print a message using the plugin formatting.3Print an error message using the plugin formatting.4Print a warning message using the plugin formatting.,Print an object using the plugin formatting.2Throw a type checker error with the given message.YIf the given condition is false this will fail the compiler with the given error message.ghNone-#The modifiable state of the plugin.QEqualities between type variables and types that have been derived by the plugin.>Eqaulities between types that have been derived by the plugin.IA queue of warnings that are only displayed if no progress could be made.'The read-only environent of the plugin.The  module.The Bind class.The Return class.Collection of all Bind instances.0The given and derived constraints (all of them).%The wanted constraints (all of them).dThe supermonads currently in scope. Associates the type constructor of each supermonad with its   and  instance.The plugin monad.2The error type used as result if the plugin fails.QRuns the given supermonad plugin solver within the type checker plugin monad.Execute the given % computation within the plugin monad. Returns the   class. Returns the  class.The  module.Returns all of the given and derived! constraints of this plugin call.:Returns all of the wanted constraints of this plugin call.7Returns all bind instances including those given by getBindApplyInstance and getBindFunctorInstance.-Shortcut to access the instance environments.Retrieves the supermonad bind and return instance (in that order) of the given type constructor, if the type constructor represents a supermonad in scope.=Add another type variable equality to the derived equalities.AAdd a list of type variable equalities to the derived equalities.4Add another type equality to the derived equalities.6Add a list of type equality to the derived equalities.UReturns all derived type variable equalities that were added to the results thus far.UReturns all derived type variable equalities that were added to the results thus far.]Add a warning to the queue of warnings that will be displayed when no progress could be made.MExecute the given plugin code only if no plugin results were produced so far.BDisplays the queued warning messages if no progress has been made.EAssert the given condition. If the condition does not evaluate to @F, an error with the given message will be thrown the plugin aborts.$Assert the given condition. Same as ! but with a monadic condition.\Throw an error with the given message in the plugin. This will abort all further actions.\Throw an error with the given message in the plugin. This will abort all further actions.-Catch an error that was thrown by the plugin.>Print some generic outputable object from the plugin (Unsafe).  Print a message from the plugin. 'Print an error message from the plugin. (Print a warning message from the plugin. 5Internal function for printing from within the monad. ZPrint the given string as if it was an object. This allows custom formatting of object.9Print the given constraints in the plugins custom format.0Given and derived constraints. Wanted constraints.Plugin code to run.3Either an error message or an actual plugin result.        $     NonewTry to evaluate the given type as far as possible by evaluating contained type families and expanding type synonyms.Trys to see if the given arguments match the class instance arguments by unification. This only works if the number of arguments given is equal to the arguments taken by the class the instance is of. If the given arguments match the class arguments, a list with a type for each free variable in the instance is returned. This list is in the same order as the list of free variables that can be retrieved from the instance.3This function is meant for use in conjunction with  isInstanceOf, isInstantiatedBy and .The second element of the pair shows how each ambiguous type variable in the given list type arguments would be bound by the instance.Trys to see if the given arguments match the class instance arguments by unification. This only works if the number of arguments given is equal to the arguments taken by the class the instance is of. If the given arguments match the class arguments, a list with a type for each free variable in the instance is returned. This list is in the same order as the list of free variables that can be retrieved from the instance.eThe first argument gives those variables that should be bound and their substitution be returned.The second element of the pair shows how each given type variable in the list type argumproduceEvidenceForCtents would be bound by the instance.sApply the given instance dictionary to the given type arguments and try to produce evidence for the application.This function should properly work with type synonyms and type functions. It only produces evidence for type equalities if they are trivial, i.e., a ~ a.Handles Bind constraints that can be resolved with the functor or apply instance specially. This leads to 'Bind Identity Identity Identity' being solved although there is no unique matching instance for it.Try to find evidence that proves the given constraint. Only works properly if there is only one instance matching the given constraint and if the constraint does not contain ambiguous variables.Handles Bind constraints that can be resolved with the functor or apply instance specially. This leads to 'Bind Identity Identity Identity' being solved although there is no unique matching instance for it.Try to find evidence that proves the given constraint given by the type representing the constraint predicate. Only works properly if there is only one instance matching the given constraint and if the constraint does not contain ambiguous variables.Handles Bind constraints that can be resolved with the functor or apply instance specially. This leads to 'Bind Identity Identity Identity' being solved although there is no unique matching instance for it.<Check if a given class constraint can potentially be instantiated using the given type constructors. By potentially we mean: First, check if an instance can actually be applied to the instance. Then check if all resulting constraints that do not contain free variables actually can be instantiated.Note: A constraint is only potentially instantiable if there is only one matching instance for the constraint and all of its implied constraints.NNote: This function only handle class constraints. It will always deliver =' when another constraint type is given.Utility helper for  that checks class constraints._The given constraints that can be used when producing evidence. Be aware that only actually given constraints (as in t) are useful here, because only those produce evidence for themselves. All other constraints will be ignored.%The instance to produce evidence for.gThe type arguments of the instance. These have to be given in order of the instance variables (c). It has to match the number of open variables of the given instance dictionary in length. See  to achieve this.IEither an error if evidence can not be produced or the actual evidence.9The given constraints to be used when producing evidence.'The constraint to produce evidence for.9The given constraints to be used when producing evidence.8The constraint to produce evidence for, given as a type.9The given constraints to be used when producing evidence.The constraint to check.DAssociations to use for type constructor variables in the constraintOWill deliver false of the constraint definitly can not be instantiated. If @` is returned the constraint either can be instantiated or it is unknown of that is possible.9The given constraints to be used when producing evidence.A class and the type arguments for that class to check if the class is potentially instantiated for those arguments. The arguments are given in the actual representational order used in Haskell.DAssociations to use for type constructor variables in the constraintNoneSee .See .See .See  and . See  and .!See . ! ! !None"tChecks if the given component only involved exactly one top-level type constructor in its supermonad constraints.#ZCollect all top-level type constructors for the given list of wanted constraints. See .$dCollect all top-level type constructors variables for the given list of wanted constraints. See .%Utility function that applies the given collection functions to all type arguments of the given constraints and returns a list of the collected results. Duplicates are removed from the result list.&*Creates a graph of the constraints and how they are conntected by their top-level ambiguous type constructor variables. Returns the connected components of that graph. These components represent the groups of constraints that are in need of solving and have to be handeled together.'"#$%&"#$&'"#$%&None(Attempts to solve the given wanted constraints.)Solves constraint groups that only involve exactly one supermonad type constructor. This is done by associating every ambiguous supermonad type constructor variable with that type constructor.If necessary the associated type constructors are partially applied to new ambiguous variables to match the kind of type variable they are associated with.*Solves constraint groups that have more them one supermonad type constructor (variable) involved. This is done by looking at all possible association between ambiguous type constructor variables and available type constructors and checking their (approximate) satisfiability. If there is exactly one such association that is satisfiable, constraints for it are produced, otherwise this solver step aborts with an error.If necessary the associated type constructors are partially applied to new ambiguous variables to match the kind of type variable they are associated with.+Given a constraint group this calculates the set of type constructors involved with that constraint group and then generates all potentially satisfiable (see `) associations between ambiguous supermonad type variables and type constructor (variables).,SSolves the indices of constraints that have been associated a type constructor.()*+,(()*+,None+The supermonad type checker plugin for GHC.-The type checker plugin..$No initialization needs takes place./ No clean up needs to take place.0>The plugin code wrapper. Handles execution of the monad stack.1The actual plugin code.2-./0132-./013None):RStandard implementation of if-then-else. Necessary because we are going to use RebindableSyntax together with this prelude.Same as (&, but with the arguments interchanged."Left-to-right Kleisli composition."Right-to-left Kleisli composition./When the condition is true do the given action.0When the condition is false do the given action.KMap the given function on each element of the list and collect the results. ignoring the result.ped version of . ignoring the result.Monadic join operation.#Ignore the result of a computation.NIgnore the result of a computation, but allow morphing the computational type.NExecute all computations in the list in order and returns the list of results. ignoring the result.1Execute the given computation repeatedly forever.Like filter) but with a monadic predicate and result.CMap a given monadic function on the list and the unzip the results./Zip together two list using a monadic function.Same as , but ignores the results.9Fold the given foldable using a monadic function. See foldl.Same as , but ignores the result.iRepeats the given monadic operation for the given amount of times and returns the accumulated results.Same as , but ignores the results.5Make arguments and result of a pure function monadic.JMake arguments and result of a pure function monadic with allowed morphing5Make arguments and result of a pure function monadic.5Make arguments and result of a pure function monadic./Make the resulting function a monadic function.8Apply the given function to the result of a computation.Strict version of .111Safe  !"~}|{zyxw# $%&  '(ut)*+,-.hidcge_^fa`b/GF01=@234567>?8CDE9:;<ABHIJKLMNOPQRSTUVWXYZ[\]jklmnopqrsv1=@7>?<ABm8CDE2!' 56439;&  )$# "~}|{zyxw+*0%-.ihgfedcba`_^/GF [ZYX]\Wqopn,v(utUsTr:SRQPONMjLKJHIlVkNone  !"~}|{zyxw# $&  '(ut)*+,-.hidcge_^fa`b/GF01=@234567>?8CDE9:;<ABHIJKLMNOPQRSTUVWXYZ[\]jklmnopqrsv !"#$%&'()None*-9;<=DRT>A short-hand for writing polymorphic standard monad functions.See & for details on laws and requirements.See & for details on laws and requirements.jRepresentation of bind operations for supermonads. A proper supermonad consists of an instance for ,  and optionally .hThe instances are required to follow a certain scheme. If the type constructor of your supermonad is M" there may only be exactly one  and one # instance that look as follows: Uinstance Bind (M ...) (M ...) (M ...) where ... instance Return (M ...) where ...}This is enforced by the plugin. A compilation error will result from either instance missing or multiple instances for M.7For supermonads we expect the usual monad laws to hold:  a  k = k a m   = m m  (\x -> k x  h) = (m  k)  h  f xs = xs   . f-TODO / FIXME: This has the same issue as the  instance for 4.-TODO / FIXME: This has the same issue as the  instance for 4.+dTODO / FIXME: Still need to figure out how and if we can generalize the continuation implementation.-.TODO / FIXME: The wrapped monad instances for % and 5 are both based on mN being a monad, although the functor instance should only be dependend on mh being a functor (as can be seen below). This can only be fixed by either giving a custom version of 4% here or by fixing the version of 49 in base. Once this issue is fixed we can replace the 5 constraint with a % constraint. rinstance (Functor m) => Functor (App.WrappedMonad m) where fmap f m = App.WrapMonad $ fmap (App.unwrapMonad m) f      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG  |      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGNone):HRStandard implementation of if-then-else. Necessary because we are going to use RebindableSyntax together with this prelude.ISame as &, but with the arguments interchanged.J"Left-to-right Kleisli composition.K"Right-to-left Kleisli composition.L/When the condition is true do the given action.M0When the condition is false do the given action.NKMap the given function on each element of the list and collect the results.ON ignoring the result.Pped version of N.QP ignoring the result.RMonadic join operation.S#Ignore the result of a computation.TNIgnore the result of a computation, but allow morphing the computational type.UNExecute all computations in the list in order and returns the list of results.VU ignoring the result.W1Execute the given computation repeatedly forever.XLike filter) but with a monadic predicate and result.YCMap a given monadic function on the list and the unzip the results.Z/Zip together two list using a monadic function.[Same as Z, but ignores the results.\9Fold the given foldable using a monadic function. See foldl.]Same as \, but ignores the result.^iRepeats the given monadic operation for the given amount of times and returns the accumulated results._Same as ^, but ignores the results.`5Make arguments and result of a pure function monadic.aJMake arguments and result of a pure function monadic with allowed morphingb5Make arguments and result of a pure function monadic.c5Make arguments and result of a pure function monadic.d/Make the resulting function a monadic function.e8Apply the given function to the result of a computation.fStrict version of e.HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefNOPQUVIJKWSTRXYZ[\]^_LM`abcdfeHHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefI1J1K1None  !"~}|{zyxw# $%&  '(ut)*+,-.hidcge_^fa`b/GF01=@234567>?8CDE9:;<ABHIJKLMNOPQRSTUVWXYZ[\]jklmnopqrsvHINOUVOVINUH6 !"#$%&%'()*+*, - . /01023456575859":;":<0= >3?3@3A3B C D E F G H5I5J":KLM3N3O 0P":QRS3TLU3VWX YZ[\] ^"_`"_a"_b"_c"_defg h"_i3j"_k"_lmn"_o p q"_rmsmt"_u"_v"_w\x\y(z({(|(}(~(((((((ZZZZZZZZZZZZZZZZZZZmRRRRLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL3333333333333333333555555WWWWWWWW%%%%%%%%%%%%%%%%%%%%%%%%%% %   * *00000           ":!":"":#":$":%":&":'":(":)":*+,>-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ \]^_`abcdefghijklmnopqrstuvwxyz{|}~VWXYZ[ \]^_`abcdefghijlmnopqrstuvwxyz{|}~                           ! " # $%& ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S TUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~%urstqz~$ V%supermonad-0.1-Gc8nGGoVggdH73AI2Rrto0&Control.Supermonad.PreludeWithoutMonad&Control.Supermonad.Constrained.FunctorControl.Supermonad.ConstrainedControl.Supermonad.Plugin(Control.Supermonad.Constrained.FunctionsControl.SupermonadControl.Supermonad.FunctionsControl.Supermonad.Plugin.Debug!Control.Supermonad.Plugin.WrapperControl.Supermonad.Plugin.Utils"Control.Supermonad.Plugin.Instance Control.Supermonad.Plugin.DetectBindData.Functor.IdentityIdentity Data.FunctorFunctorReturnPrelude$Control.Supermonad.Plugin.ConstraintControl.Supermonad.Plugin.Log%Control.Supermonad.Plugin.EnvironmentControl Supermonad"Control.Supermonad.Plugin.Evidence*Control.Supermonad.Plugin.Environment.Lift$Control.Supermonad.Plugin.Separation!Control.Supermonad.Plugin.Solving&Control.Supermonad.Constrained.PreludeControl.Supermonad.PreludebaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negatefmap fromIntegral realToFrac toInteger toRationalmemptymappendmconcat<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalIntegralNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShow Applicative Data.FoldableFoldableData.Traversable TraversableMonoid GHC.TypesBoolCharDoubleFloatInt integer-gmpGHC.Integer.TypeIntegerMaybeOrderingRationalIOWord Data.EitherEitherFalseNothingJustTrueLeftRightLTEQGT sequenceAtraversereadIOreadLn appendFile writeFilereadFileinteract getContentsgetLinegetCharputStrLnputStrputChar Text.ReadreadreadsGHC.IO.ExceptionioErrornotElemallanyorand concatMapconcatproductsumminimummaximumelemlengthnullfoldl1foldr1foldlfoldrfoldMapGHC.IOFilePath userErrorIOErroreither Data.OldListunwordswordsunlineslineslex readParenreadList readsPrecText.ParserCombinators.ReadPReadSatanhacoshasinhtanhcoshsinhatanacosasintancossinlogBase**sqrtlogexppiatan2isIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadix<$>lcmgcd^^^oddevendivModquotRemmoddivremquotrecip/floorceilingroundtruncateproperFractionmaxBoundminBoundfromEnumtoEnumpredsucc showParen showStringshowCharshowsShowSshowListshow showsPrecunzip3unzipzipWith3zipWithzip3!!lookupreversebreakspansplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl1scanlinitlasttailhead Data.Maybemaybeuncurrycurrysubtractsignumabs*+asTypeOfuntil$!flip.constid<$<*StringGHC.Err undefinederror/=compare<=&&||not<>maxminCFunctor CFunctorCts$fCFunctorWriterT$fCFunctorWriterT0$fCFunctorStateT$fCFunctorStateT0$fCFunctorReaderT$fCFunctorRWST$fCFunctorRWST0$fCFunctorMaybeT$fCFunctorListT$fCFunctorIdentityT$fCFunctorExceptT$fCFunctorContT $fCFunctorSet $fCFunctorSTM$fCFunctorWrappedMonad$fCFunctorArrowMonad $fCFunctorST $fCFunctorST0$fCFunctorReadPrec$fCFunctorReadP$fCFunctorProduct$fCFunctorNonEmpty$fCFunctorComplex$fCFunctorProxy$fCFunctorLast$fCFunctorFirst$fCFunctorOption $fCFunctorMax $fCFunctorMin $fCFunctorAlt$fCFunctorDual$fCFunctorProduct0 $fCFunctorSum$fCFunctorLast0$fCFunctorFirst0$fCFunctorEither $fCFunctorIO$fCFunctorMaybe $fCFunctor[]$fCFunctorIdentity$fCFunctor(->)MonadFailFailCtsfail ReturnCtsreturnBindCts>>=>> $fFailWriterT$fFailWriterT0 $fFailStateT $fFailStateT0 $fFailReaderT $fFailRWST $fFailRWST0 $fFailMaybeT $fFailListT$fFailIdentityT $fFailExceptT $fFailContT $fFailSet $fFailSTM$fFailWrappedMonad$fFailArrowMonad$fFailST $fFailST0$fFailReadPrec $fFailReadP $fFailProduct$fFailNonEmpty $fFailComplex $fFailProxy $fFailLast $fFailFirst $fFailOption $fFailMax $fFailMin $fFailAlt $fFailDual$fFailProduct0 $fFailSum $fFailLast0 $fFailFirst0 $fFailEither$fFailIO $fFailMaybe$fFail[]$fFailIdentity $fFail(->)$fReturnWriterT$fReturnWriterT0$fReturnStateT$fReturnStateT0$fReturnReaderT $fReturnRWST $fReturnRWST0$fReturnMaybeT $fReturnListT$fReturnIdentityT$fReturnExceptT $fReturnContT $fReturnSet $fReturnSTM$fReturnWrappedMonad$fReturnArrowMonad $fReturnST $fReturnST0$fReturnReadPrec $fReturnReadP$fReturnProduct$fReturnNonEmpty$fReturnComplex $fReturnProxy $fReturnLast $fReturnFirst$fReturnOption $fReturnMax $fReturnMin $fReturnAlt $fReturnDual$fReturnProduct0 $fReturnSum $fReturnLast0$fReturnFirst0$fReturnEither $fReturnIO $fReturnMaybe $fReturn[]$fReturnIdentity $fReturn(->)$fBindWriterTWriterTWriterT$fBindWriterTWriterTWriterT0$fBindStateTStateTStateT$fBindStateTStateTStateT0$fBindReaderTReaderTReaderT$fBindRWSTRWSTRWST$fBindRWSTRWSTRWST0$fBindMaybeTMaybeTMaybeT$fBindListTListTListT!$fBindIdentityTIdentityTIdentityT$fBindExceptTExceptTExceptT$fBindContTContTContT$fBindSetSetSet$fBindSTMSTMSTM*$fBindWrappedMonadWrappedMonadWrappedMonad$$fBindArrowMonadArrowMonadArrowMonad $fBindSTSTST $fBindSTSTST0$fBindReadPrecReadPrecReadPrec$fBindReadPReadPReadP$fBindProductProductProduct$fBindNonEmptyNonEmptyNonEmpty$fBindComplexComplexComplex$fBindProxyProxyProxy$fBindLastLastLast$fBindFirstFirstFirst$fBindOptionOptionOption$fBindMaxMaxMax$fBindMinMinMin$fBindAltAltAlt$fBindDualDualDual$fBindProductProductProduct0$fBindSumSumSum$fBindLastLastLast0$fBindFirstFirstFirst0$fBindEitherEitherEither $fBindIOIOIO$fBindMaybeMaybeMaybe $fBind[][][]$fBindIdentityIdentityIdentity$fBind(->)(->)(->)plugin ifThenElse=<<>=><=<whenunlessmapMmapM_forMforM_joinvoidvoid'sequence sequence_foreverfilterM mapAndUnzipMzipWithM zipWithM_foldMfoldM_ replicateM replicateM_liftMliftM'liftM2liftM3ap<$!>pprToStr sDocToStrghc OutputableSDoc containsAnyOf containsAllOfcontainsNoneOfUnitId TypeVarSubstfromLeft fromRightmkTypeVarSubstsplitKindFunTysmkEqualityCtTypeconstraintSourceLocation baseUnitId moduleUnitIdisImportedFrom mkTcCoercionTyCoRepCoercion TcEvidence TcCoercionproduceTupleEvidence isTupleTyCon lookupInstEnvcollectTopTyConscollectTopTcVarscollectTopTcVarsWithArity collectTyVars mkTcVarSubstskolemVarsBindFunUnifySkolemInstEnvinstanceBindFuneqTyVareqTyVar' tyVarArity getTyConNameatIndexisAmbiguousTypepartiallyApplyTyCons TcPluginM newFlexiTyVar applyTyConsplitKindFunOfTcTv associationssubsets removeDuplookupByallManyMquantM partitionMisClassInstance instanceClassinstanceClassTyConinstanceTyArgsisMonoTyConInstanceisPolyTyConInstancesupermonadModuleNamesupermonadCtModuleName bindClassNamereturnClassNameidentityModuleNameidentityTyConNamesupermonadPreludeModuleNamesupermonadCtPreludeModuleNamefunctorClassNamefunctorModuleNamefindSupermonadModulefindSupermonadUnCtModulefindSupermonadCtModuleisSupermonadModule isBindClass isReturnClass findBindClassfindReturnClassfindIdentityModulefindIdentityTyCon findModules getModule findClassisClassfindTyConByNameAndModuletcTyThingToTyCon hasNoParentfindInstancesInScopecheckSupermonadInstancesfindSupermonadsWantedCt DerivedCtGivenCtmkDerivedTypeEqCtOfTypesmkDerivedTypeEqCtmkDerivedClassCtisClassConstraintconstraintClassTypeconstraintClassTyArgsconstraintClassTyConconstraintTopTyConsconstraintTopTcVarsconstraintLocationconstraintPredicateTypeconstraintTyVarssortConstraintsByLine prefixMsgpluginMsgPrefixsmErrMsg smWarnMsg smDebugMsgsmObjMsgmissingCaseErrorformatGroupSrcSpans formatSpanformatConstraint printTrace printObjTrace internalPrintprintMsgprintErr printWarnprintObjpluginFailSDoc pluginAssert Debug.TracetraceSupermonadPluginStatesmStateTyVarEqualitiessmStateTypeEqualitiessmStateWarningQueueSupermonadPluginEnvsmEnvSupermonadModulesmEnvBindClasssmEnvReturnClasssmEnvBindInstancessmEnvGivenConstraintssmEnvWantedConstraintssmEnvSupermonadsSupermonadPluginMSupermonadErrorrunSupermonadPlugin runTcPlugin TcRnTypes getBindClassgetReturnClassgetSupermonadModulegetGivenConstraintsgetWantedConstraintsgetBindInstances getInstEnvsgetSupermonadForaddTyVarEqualityaddTyVarEqualitiesaddTypeEqualityaddTypeEqualitiesgetTyVarEqualitiesgetTypeEqualities addWarning whenNoResultsdisplayWarningsassertassertMthrowPluginErrorthrowPluginErrorSDoccatchPluginErrorprintFormattedObjprintConstraintsstringToSupermonadError evaluateTypematchInstanceTyVarsproduceEvidenceFormatchInstanceTyVars'produceEvidenceForCtproduceEvidenceForCtTypeisPotentiallyInstantiatedCtisPotentiallyInstantiatedCtType isGivenCtis_tvsisBindConstraintisReturnConstraintcomponentMonoTyConcomponentTopTyConscomponentTopTcVarscollectseparateContraintsSCNodesolveConstraintssolveMonoConstraintGroupsolvePolyConstraintGroup#determineValidConstraintGroupAssocssolveSolvedTyConIndicessupermonadPluginsupermonadInitsupermonadStopsupermonadSolvesupermonadSolve'SupermonadStatenoResultControl.Applicative WrappedMonad