cL"x      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , -./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                        % NoneType of package identifiers.$Type of type variable substitutions. Return the = value. If no =$ value is given, an error is raised. Return the > value. If no >$ value is given, an error is raised.MMake a substitution based on an association between type variables and types.>Splits a function kind into its argument kinds and its result. For example: =splitKindFunTys (* -> * -> Constraint) = ([*, *], Constraint)LCreate a type representing an equality constraint between the two arguments. For example:  mkEqualityCtType a Int = a ~ Int9Returns the source code location of the given constraint.The package identifier for the base package.2Access the package identifier of the given module.ACheck if the given element is imported from the given module. 9 if it is a local definition.Wrap a  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 environmentTurns a unique set into a list Safe$Type of class names the plugin uses.%Type of module names the plugin uses. Name of the Control.Supermonad module. Name of the Control.Super.Monad module. Name of the Control.Supermonad.Constrained module. Name of the Control.Super.Monad.Constrained module. Name of the Bind4 type class. Also used as dictionary key for the Bind class. Name of the Return4 type class. Also used as dictionary key for the Return class. Name of the Functor/ class. Also used as dictionary key for the Functor class. Name of the  Applicative4 type class. Also used as dictionary key for the  Applicative class. Name of the Control.Supermonad.Prelude module. Name of the Control.Super.Monad.Prelude module. Name of the &Control.Supermonad.Constrained.Prelude module. Name of the 'Control.Super.Monad.Constrained.Prelude module. Name of the  Data.Functor module. Name of the Control.Super.Arrow module. Name of the Control.Super.Arrow.Constrained module. Name of the ArrowArr4 type class. Also used as dictionary key for the ArrowArr class. Name of the  ArrowSequence/ class. Also used as dictionary key for the  ArrowSequence class. Name of the  ArrowSelect4 type class. Also used as dictionary key for the  ArrowSelect class. Name of the  ArrowParallel/ class. Also used as dictionary key for the  ArrowParallel class. Name of the  ArrowFanOut/ class. Also used as dictionary key for the  ArrowFanOut class.NoneAConvert some generic outputable to a string (potentially unsafe). Convert an " to a string (potentially unsafe)..Check if the string reprentation of the given  contains any of the given strings..Check if the string reprentation of the given  contains all of the given strings..Check if the string reprentation of the given  contains none of the given strings.None0A set with elements of type a.The empty set.&Create a set with exactly one element.Is the set empty?*Compute the number of elements in the set.%Check if a given element is in a set.)Check if a given element is not in a set.KCheck if the first set is a subset of the second. The sets may be equal.OCheck if the first set is a subset of the second. The sets may not be equal.Insert a given element into a set. This will replace any preexisting element with the same unique reprentation in the set.Delete a given element from a set. This will remove any preexisting element with the same unique reprentation in the set.2Map the element of a set using the given function.jFilter the elements of a set using the given predicate. Only those elements where the predicate yields < are kept.%Merge two sets into one with a union.,Merge a list of sets into one using a union.OMerge two set, but only keep those elements that were present in both sets.ARemove all element that are in the second set from the first one.ARemove all element that are in the second set from the first one.\Convert the set into a list. There is not guarenteed order for the elements to appear in.Convert a list into a set. If there are several elements with the same unique representation only one of them will be kept.(Monoid based on union and the empty set.<Sets can be checked for equality if their elements allow it.None0TA map with keys of type k and elements of type a.The empty map.Is the map empty?'Count the number of entries in the map./Check if the given key has an entry in the map.9Check if the given key does not have an entry in the map.iInsert the given key value pair in the map. Any preexisting entry with the same key will be replaced.@Retrieve the associated entry of the given key, if there is one.2Remove the entry with the given key, if it exists.{Merge together two maps. If there are two entries with the same key, the left (first) map will be prefered (left bias).Merge several maps together. If there are two entries with the same key, the left-most map in the list will be prefered (left bias).3Maps the entries of a map using the given function.eFilter the value of a map using the given predicate. Only thoes entries that the predicate yields < for will be kept./Convert the map into a list of key value pairs.Create a map from a list of key value pairs. If there are several pairs with the same key the entry of the last pair in the list with that key will be kept.VCreate a list of all entries in the map. There is no guarenteed order for the list. Create a Set$ containing all the keys in the map._Create a list containing all the keys in the map. There is no guarenteed order for the list.(Monoid based on union and the empty map.EMaps can be checked for equality if their elements and keys allow it.NoneA dictionary associating supermonad type constructors and classes with their instances. This is essentially a lookup table for instances associated with a given type constructor and class.The empty instance dictionary.+Insert an entry into a instance dictionary.0Try to lookup an entry in a instance dictionary.  Retrieve the P of all type constructors in that have an entry in the supermonad dictionary. Looks up all entries with the given type constructor as key. Returns a mapping between the classes and their instances for that type constructor. NConvert the instance dictionary into a list of key value pairs for inspection.               None)Indentation to be used in error messages.Retrieve 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.IReturns the name of the class (The literal name of its type constructor).DGet the element of a list at a given index (If that element exists).Select first element of triple. Select second element of triple. Select thrid element of triple.!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)] ]'kEfficient removal of duplicate elements in O(n * log(n)). The result list is ordered in ascending order.(QRemoval of duplicate elements in a list, based on their unique representation.)^Efficient removal of duplicate entries by key in O(n * log(n)). The result list is ordered.*IEfficient removal of duplicate entries by key, based on equality of keys.+bEfficient removal of duplicate entries by key, based on the unique representation of the keys., 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.0YPartition a list into two lists based on a predicate involving a monadic computation. !"$%&'()*+,-./0 !"$%&'()*+,-.0 !"$%&'()*+,-./0None1)Type synonym to label wanted constraints.2*Type synonym to label derived constraints.33Type synonym to label given or derived constraints.4Create 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.5Create 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.6Creates 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.7GCheck if the given constraint is a class constraint of the given class.8CChecks if the given constraint belongs to any of the given classes.9Retrieves 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 9.;JRetrieves the type constructor of the given type class constraint. See 9.<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.A1Sorts constraints by the line of their occurence.123456789:;<=>?@A123456789:;<=>?@A123456789:;<=>?@ANoneB8Checks if the given instance is of the given type class.C-Returns the type class of the given instance.DDReturns the type constructors of the class is instance instantiates.E=Collects the top type constructors of the instance arguments.F1Returns the arguments of the given instance head.G7Check 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.HsChecks if the given instance is from the given class, but does not form a mono type constructor instance as in G.BCDEFGHBCDEFGHBCDEFGHNoneIprefixMsg prefix msg* prefixes a message with the given string.JMessage prefix of the plugin.K'Prefix a message with the error prefix.L)Prefix a message with the warning prefix.M0Prefix a message with the standard debug prefix.NSPrefix a message with the debug prefix and a note that this is a printed object.O}Used to emit an error with a message describing the missing case. The string is the function that misses the case and the  is the object being matched.PJFormat a list of source spans by grouping spans in the same file together.QFormat a source span.RbFormat a constraint in a readable way, without displaying information irrelevant to the plugin.Example:5[G] Supermonad m Identity m (129:12-131:41, CDictCan))[D] m_a1kdW ~ m (134:3-14, CNonCanonical)SPrint the result of calling  on the given object.TPrint the result of the  instance of the given object.U5Internal function for printing from within the monad.V,Print a message using the plugin formatting.W3Print an error message using the plugin formatting.X4Print a warning message using the plugin formatting.Y,Print an object using the plugin formatting.Z2Throw a type checker error with the given message.[YIf the given condition is false this will fail the compiler with the given error message.IJKLMNOPQRSTUVWXYZ[\KLMNOPQRSTVWXYZ[IJKLMNOPQRSTUVWXYZ[None]wTry 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.aTry 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.bTry 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.c<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 9' when another constraint type is given.dUtility helper for c that checks class constraints.]^`__The given constraints that can be used when producing evidence. Be aware that only actually given constraints (as in et) 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 (fc). 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.a9The given constraints to be used when producing evidence.'The constraint to produce evidence for.b9The given constraints to be used when producing evidence.8The constraint to produce evidence for, given as a type.c9The 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.d9The 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 constraint^`_ac]^`_abcdNonegLA group of constraints that is connected by common ambiguous type variables.hChecks if the given component only involved exactly one top-level type constructor in its supermonad constraints. Which classes make up the supermonad constraints is given by the list of classes.iZCollect all top-level type constructors for the given list of wanted constraints. See .jdCollect all top-level type constructors variables for the given list of wanted constraints. See .kUtility 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.l*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.gmhijknlghijlgmhijknlNone o_Dictionary type to lookup classes and their available instances based on string identifiers.p(Flag to indicate if a class is optional.qThe empty class dictionary.r(Insert an entry into a class dictionary.sBInsert the entry of an optional missing class into the dictionary.t1Check if the given class is optional for solving.u-Try to lookup an entry in a class dictionary.v.Try to lookup the class in a class dictionary.wTry to lookup the " instance of the type constructor.x Retrieve the yP of all type constructors in that have an entry in the supermonad dictionary.z;Retrives all of the entries stored in the class dictionary.{See |.o}pqrstuvwxz~{ opqrstuvwxz o}pqrstuvwxz~{NoneqRepresentation of instance implying the existence of other instances that are using the same type constructor.1Find a collection of classes in the given module.#Formulates queries to find modules.WSearch for a specific module using its name and optionally its unit ID (module ID).Find either of the modules described by the given subqueries. If only one of the queries delivers a result, it will be used otherwise an error will be returned. The error message is customizable using the optional function.Find any of the modules described by the given subqueries. The first one found (in order of the queries) will be delivered as result, the rest will be ignored. If no module could be found an error message will be returned.dCheck if there are any supermonad instances that clearly do not belong to a specific supermonad.4Tries to find a module using the given module query.XChecks if the module with the given name is imported and, if so, returns that module.Makes sure that only one of the given modules was found and returns that found module. If many or none of them were found an error is returned. The returned error message can be customized using the optional function.Makes sure that at least one of the given modules was found and, if so, returns the first one found (in order of the list). If none of the modules was found an error message will be returned. The returned error message can be customized using the optional function.'Default error message function in case  fails.'Default error message function in case  fails.?Check if the classes requested by the given query are optional.EGet the names of the classes that are queried for by the given query.HGet the module query this class query uses to lookup modules of classes.Search for a collection of classes using the given query. If any one of the classes could not be found an error is returned.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.6Use a class query to find classes and their instances.PReturns a list of all instances for the given class that are currently in scope.Constructs the map between type constructors and their supermonad instances. It essentially collects all of the instances that only use a single top-level constructor and stores them in the instance dictionary. If there are several instances for a single type constructor none is added to the dictionary. This function only searches for the instances and constructs the lookup table.SInstance of first class implies the existence of an instance from the second class.>Instances of either class imply the respective other instance.GInstance implication based on lookup of names in class dictionary. See .GInstance equivalence based on lookup of names in class dictionary. See .3Check a given instance dictionary against a set of 8s and return error messages if there are violations."=The class dictionary to lookup instances of specific classes.]The instance dictionary to check for validity. This should be the instances calculated by Y from the given class dict. If not the validity of the checks cannot be guarenteed.DThe instance implications to check on the given instance dictionary.KThe set of classes and instances to calculate the instance dictionary from.EAssociation between type constructors and their supermonad instances.77None-#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. Custom state of the environment.'The read-only environent of the plugin.0The given and derived constraints (all of them).%The wanted constraints (all of them).$Class dictionary of the environment.The plugin monad.2The error type used as result if the plugin fails.Runs the given supermonad plugin solver within the type checker plugin monad. Handles errors and produces a plugin result based on the environment.QRuns the given supermonad plugin solver within the type checker plugin monad.Execute the given % computation within the plugin monad."Returns the type class dictionary.!Returns the plugins custom state. Writes the plugins custom state."Modifies the plugins custom state.SLooks up a class by its name in the class dictionary of the plugin environment.MCheck if the given class name refers that is optional in the solving process.Returns all of the given and derived! constraints of this plugin call.:Returns all of the wanted constraints of this plugin call.-Shortcut to access the instance environments.JRetrieves the associated instance of the given type constructor and class.=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.*Initialize the custom state of the plugin.,Plugin code to run. Result value is ignored.The plugin result.Given and derived constraints. Wanted constraints.*Initialize the custom state of the plugin.Plugin code to run.3Either an error message or an actual plugin result.!'NoneSee a.See _.See c.See ".See 3. In addition to calling the function from the Detect module it also throws an error if the call fails. Otherwise, inserts the found classes and instances into the provided class dictionary and returns the updated dictionary.NoneAttempts to solve the given wantedk constraints in a constraint group. The given list of classes indicates which are required to be solved.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.0Only solves the constraint of the given classes.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.  None0Type of the state used in the supermonad plugin.+The supermonad type checker plugin for GHC.+The classes that the plugin will solve for.;The sets of class names that require being solved together.The depedencies between different class instances, that cannot be implemented using the Haskell type class definitiisOptionalClassQueryons.Safe  ~}|{zyxwvuts !"#  $%qp&'()*de`_ca[Zb]\^+CB,-9<./0123:;4?@A5678=>DEFGHIJKLMNOPQRSTUVWXYfghijklmnor-9<3:;8=>i4?@A.$ 120/57#  &! ~}|{zyxwvuts(',"*edcba`_^]\[Z+CB WVUTYXSmklj)r%qpQoPn6ONMLKJIfHGFDEhRgNone+The supermonad type checker plugin for GHC.=Configure which groups of classes need to be solved together.4Queries the module providing the supermonad classes.Queries the supermonad classes.hEnsures that all supermonad instance implications with the group of one type constructor are obeyed.>Function to produce proper error messages in the module query.>Function to produce proper error messages in the module query.>Function to produce proper error messages in the module query. NoneNone*DQRNClass 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.3      !0      !4None*-9;<=DQRT">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.-TODO44 is defined in terms of return.dTODO / FIXME: Still need to figure out how and if we can generalize the continuation implementation.dTODO / FIXME: Still need to figure out how and if we can generalize the continuation implementation."#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"#$%&'()*+,-./01234)*+,&'(#$%-./01234""#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~+1,1142434None):3RStandard 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.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  . 9Make arguments and result of a pure function applicative. A variant of 1 with the arguments reversed.LLift a function to actions. Does what fmap does with applicative operations.9Make arguments and result of a pure function applicative.Like filterM. but with an applicative predicate and result.Applicative version of  ignoring the result.ped version of . ignoring the result.Specialization of the  Traversable# variant for list and applicatives. ignoring the result.Specialization of the  Traversable# variant for list and applicatives.Like  mapAndUnzipM. but with an applicative predicate and result.Like . but with an applicative predicate and result.Like . but with an applicative predicate and result.Like  but with applicatves.Like , but discards the result./When the condition is true do the given action.0When the condition is false do the given action.3     3     3     3     111 4 4$None  ~}|{zyxwvuts !#  $%qp&'()*de`_ca[Zb]\^+CB,-9<./0123:;4?@A5678=>DEFGHIJKLMNOPQRSTUVWXYfghijklmnor"#$%&'()*+,-./01234None *<=DQR The encoding of the " operation.-L is not a superclass, because the indices or constraints involved in an  Alternative2 instance may differ from those involved with the - instance.WARNING:) This module is an experiment to see how  Alternative_ may be encoded. The authors are not aware of any generalized applicatives that make use of  Alternative. Hence, we do not know if this encoding of it is sufficient. Therefore, the encoding is not in its final form and may change in the future.#The encoding of the % operation.&L is not a superclass, because the indices or constraints involved in an #2 instance may differ from those involved with the & instance.WARNING:) This module is an experiment to see how  Alternative_ may be encoded. The authors are not aware of any generalized applicatives that make use of  Alternative. Hence, we do not know if this encoding of it is sufficient. Therefore, the encoding is not in its final form and may change in the future.& !"#$%&'()*+,-./0123456789:;<=>?@ABCDE !"#$%#$% !"" !"#$%&'()*+,-./0123456789:;<=>?@ABCDENone *<=DQRFThe encoding of the H operation)L is not a superclass, because the indices or constraints involved in an F2 instance may differ from those involved with the ) instance.WARNING:) This module is an experiment to see how  MonadPlus_ may be encoded. The authors are not aware of any generalized applicatives that make use of  MonadPlus. Hence, we do not know if this encoding of it is sufficient. Therefore, the encoding is not in its final form and may change in the future.IThe encoding of the K operation.&L is not a superclass, because the indices or constraints involved in an I2 instance may differ from those involved with the & instance.WARNING:) This module is an experiment to see how  MonadPlus_ may be encoded. The authors are not aware of any generalized applicatives that make use of  MonadPlus. Hence, we do not know if this encoding of it is sufficient. Therefore, the encoding is not in its final form and may change in the future."FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgFGHIJKIJKFGHFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg%None  ~}|{zyxwvuts !#  $%qp&'()*de`_ca[Zb]\^+CB,-9<./0123:;4?@A5678=>DEFGHIJKLMNOPQRSTUVWXYfghijklmnor"#$%&'()*+,-./01234&None"#$%&'()*+,-./01234 None*-9;<=DQRT h>A short-hand for writing polymorphic standard monad functions.iSee o& for details on laws and requirements.lSee o or Ap& for details on laws and requirements.ojRepresentation of bind operations for supermonads. A proper supermonad consists of an instance for o, l and optionally i.hThe instances are required to follow a certain scheme. If the type constructor of your supermonad is M" there may only be exactly one o and one l# 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: n a q k = k a m q n = m m q (\x -> k x q h) = (m q k) q h  f xs = xs q n . fsTODOxx is defined in terms of return.-TODO / FIXME: This has the same issue as the o instance for .-TODO / FIXME: This has the same issue as the o instance for .dTODO / FIXME: Still need to figure out how and if we can generalize the continuation implementation..TODO / FIXME: The wrapped monad instances for " and  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 % here or by fixing the version of 9 in base. Once this issue is fixed we can replace the  constraint with a " constraint. rinstance (Functor m) => Functor (App.WrappedMonad m) where fmap f m = App.WrapMonad $ fmap (App.unwrapMonad m) f dTODO / FIXME: Still need to figure out how and if we can generalize the continuation implementation..TODO / FIXME: The wrapped monad instances for " and  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 % here or by fixing the version of 9 in base. Once this issue is fixed we can replace the  constraint with a " constraint. rinstance (Functor m) => Functor (App.WrappedMonad m) where fmap f m = App.WrapMonad $ fmap (App.unwrapMonad m) fhijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,"hijklmnopqrstuvwxopqrlmnijkstuvwx"hhijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,q1r1u4v4w4None):1-RStandard implementation of if-then-else. Necessary because we are going to use RebindableSyntax together with this prelude..Same as q&, but with the arguments interchanged./"Left-to-right Kleisli composition.0"Right-to-left Kleisli composition.1/When the condition is true do the given action.20When the condition is false do the given action.3KMap the given function on each element of the list and collect the results.43 ignoring the result.5ped version of 3.65 ignoring the result.7Monadic join operation.8NIgnore the result of a computation, but allow morphing the computational type.9NIgnore 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.A9Fold the given foldable using a monadic function. See foldl.BSame as A, but ignores the result.CiRepeats the given monadic operation for the given amount of times and returns the accumulated results.DSame as C, but ignores the results.E5Make arguments and result of a pure function monadic.FJMake arguments and result of a pure function monadic with allowed morphingG5Make arguments and result of a pure function monadic.H5Make arguments and result of a pure function monadic.I/Make the resulting function a monadic function.JStrict version of <$>.K9Make arguments and result of a pure function applicative.L A variant of u with the arguments reversed.MLLift a function to actions. Does what fmap does with applicative operations.N9Make arguments and result of a pure function applicative.OLike filterM. but with an applicative predicate and result.PApplicative version of 3QP ignoring the result.Rped version of P.SR ignoring the result.TSpecialization of the  Traversable# variant for list and applicatives.UT ignoring the result.VSpecialization of the  Traversable# variant for list and applicatives.WLike  mapAndUnzipM. but with an applicative predicate and result.XLike ?. but with an applicative predicate and result.YLike @. but with an applicative predicate and result.ZLike C but with applicatves.[Like Z, but discards the result.\/When the condition is true do the given action.]0When the condition is false do the given action.1-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]4-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]43456:;./0<97=>?@ABCD12EFGHIJ-NKM8LPQRSOTUVXYWZ[\]1-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\].1/101J4'None4-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\](None  ~}|{zyxwvuts !"#  $%qp&'()*de`_ca[Zb]\^+CB,-9<./0123:;4?@A5678=>DEFGHIJKLMNOPQRSTUVWXYfghijklmnorhijklmnopqrstuvwx-.34:;4;.3:- None *<=DQR^The encoding of the ` operation.sL is not a superclass, because the indices or constraints involved in an  Alternative2 instance may differ from those involved with the s instance.WARNING:) This module is an experiment to see how  Alternative_ may be encoded. The authors are not aware of any generalized applicatives that make use of  Alternative. Hence, we do not know if this encoding of it is sufficient. Therefore, the encoding is not in its final form and may change in the future.aThe encoding of the c operation.ReturnL is not a superclass, because the indices or constraints involved in an a2 instance may differ from those involved with the Return instance.WARNING:) This module is an experiment to see how  Alternative_ may be encoded. The authors are not aware of any generalized applicatives that make use of  Alternative. Hence, we do not know if this encoding of it is sufficient. Therefore, the encoding is not in its final form and may change in the future.&^_`abcdefghijklmnopqrstuvwxyz{|}~^_`abcabc^_`"^_`abcdefghijklmnopqrstuvwxyz{|}~ None *<=DQRThe encoding of the  operation.oL is not a superclass, because the indices or constraints involved in an 2 instance may differ from those involved with the o instance.WARNING:) This module is an experiment to see how  MonadPlus_ may be encoded. The authors are not aware of any generalized applicatives that make use of  MonadPlus. Hence, we do not know if this encoding of it is sufficient. Therefore, the encoding is not in its final form and may change in the future.The encoding of the  operation.lL is not a superclass, because the indices or constraints involved in an 2 instance may differ from those involved with the l instance.WARNING:) This module is an experiment to see how  MonadPlus_ may be encoded. The authors are not aware of any generalized applicatives that make use of  MonadPlus. Hence, we do not know if this encoding of it is sufficient. Therefore, the encoding is not in its final form and may change in the future.")None  ~}|{zyxwvuts !"#  $%qp&'()*de`_ca[Zb]\^+CB,-9<./0123:;4?@A5678=>DEFGHIJKLMNOPQRSTUVWXYfghijklmnorhijklmnopqrstuvwx-.34:;None"hijklmnopqrstuvwx*+,-./*01*02*34*56*57*+8*+9*+:*;<*;=*>?*@A*@B*@C*@D-EF-EG*;H*+I*>J*>K*>L*>M*+N*+O*+P*@Q*@R-ES*TU*>V*>W*+"*;X-EY*Z[*>\*T]*>^*_`*ab*cd*+e-fg-fh-fi-fj-fklmn*+o-fp*>q-fr-fs*tu-fv*+w*+x-fy*tz*t{-f|-f}-f~*c*c*3*3*3*3*3*3*3*3*3*3*3*3****a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a****t*****Z*Z*Z*Z**T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T*T***>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*@*@*@*@*@*@*_*_*_*_*_*_*_*_*0*0*0*0*0*0*0*0*0*0*0*0*0*0*0*0*0 *0 *0 *0 *0 *0*0*0*0*0*0**5*5*;*;*;*;*;*+*+*+*+ *+!*+"*+#*+$*+%*&'*&(-E)-E*-E+-E,-E--E.-E/-E0-E1-E23"4I$56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij#klmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ d e f g h i j # k l m  n q r s t u v w x y z { | } ~                                                                                                                                                               ! " # $ % & ' ( ) * + ,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                           a91a91      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ*KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmjn`opqrstuvwxyz{|}~qUeHEFGDQOS**+d&supermonad-0.2.0-J5eKOSoIDgNaZEKq3WQ4V'Control.Super.Monad.PreludeWithoutMonadControl.Super.Monad.FunctionsControl.Super.Monad.Plugin'Control.Super.Monad.Constrained.FunctorControl.Super.Monad.Constrained)Control.Super.Monad.Constrained.Functions+Control.Super.Monad.Constrained.Alternative)Control.Super.Monad.Constrained.MonadPlusControl.Super.MonadControl.Super.Monad.AlternativeControl.Super.Monad.MonadPlusControl.Super.Plugin.WrapperControl.Super.Plugin.NamesControl.Super.Plugin.Debug#Control.Super.Plugin.Collection.Set#Control.Super.Plugin.Collection.Map!Control.Super.Plugin.InstanceDictControl.Super.Plugin.UtilsControl.Super.Plugin.ConstraintControl.Super.Plugin.InstanceControl.Super.Plugin.LogControl.Super.Plugin.EvidenceControl.Super.Plugin.SeparationControl.Super.Plugin.ClassDictControl.Supermonad ApplicativeControl.Super.Plugin.Detect Control.Super.Plugin.Environment%Control.Super.Plugin.Environment.LiftControl.Super.Plugin.SolvingControl.Super.Plugin.PrototypeControl.Supermonad.PluginPreludeFunctorBind'Control.Super.Monad.Constrained.Prelude&Control.Supermonad.Constrained.PreludeControl.Supermonad.ConstrainedControl.Supermonad.FunctionsControl.Super.Monad.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 toRationalmemptymappendmconcatBoundedEnumEq GHC.FloatFloating FractionalIntegralNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShow 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 Data.Functorvoid<$>lcmgcd^^^oddevendivModquotRemmoddivremquotrecip/floorceilingroundtruncateproperFractionmaxBoundminBoundfromEnumtoEnumpredsucc showParen showStringshowCharshowsShowSshowListshow showsPrecunzip3unzipzipWith3zipWithzip3!!lookupreversebreakspansplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl1scanlinitlasttailhead Data.Maybemaybeuncurrycurrysubtractsignumabs*+asTypeOfuntil$!flip.constid<$StringGHC.Err undefinederror/=compare<=&&||not<>maxminplugin FunctorCts$fFunctorWriterT$fFunctorWriterT0$fFunctorStateT$fFunctorStateT0$fFunctorReaderT $fFunctorRWST$fFunctorRWST0$fFunctorMaybeT$fFunctorListT$fFunctorIdentityT$fFunctorExceptT$fFunctorContT $fFunctorSet $fFunctorM1 $fFunctor:.: $fFunctor:*: $fFunctorRec1 $fFunctorU1 $fFunctorSTM$fFunctorWrappedMonad$fFunctorArrowMonad $fFunctorST $fFunctorST0$fFunctorReadPrec$fFunctorReadP$fFunctorCompose$fFunctorProduct$fFunctorNonEmpty$fFunctorComplex$fFunctorProxy $fFunctorLast$fFunctorFirst$fFunctorOption $fFunctorMax $fFunctorMin $fFunctorAlt $fFunctorDual$fFunctorProduct0 $fFunctorSum$fFunctorLast0$fFunctorFirst0$fFunctorEither $fFunctorIO$fFunctorMaybe $fFunctor[]$fFunctorIdentity $fFunctor(->)MonadFailFailCtsfailReturn ReturnCtsreturnBindCts>>=>>ApplicativeCtsApplicativeCtsRApplicativeCtsL<*>*><*pure $fFailWriterT$fFailWriterT0 $fFailStateT $fFailStateT0 $fFailReaderT $fFailRWST $fFailRWST0 $fFailMaybeT $fFailListT$fFailIdentityT $fFailExceptT $fFailContT $fFailSet$fFailM1 $fFail:*: $fFailRec1$fFailU1 $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 $fReturnM1 $fReturn:.: $fReturn:*: $fReturnRec1 $fReturnU1 $fReturnSTM$fReturnWrappedMonad$fReturnArrowMonad $fReturnST $fReturnST0$fReturnReadPrec $fReturnReadP$fReturnCompose$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 $fBindM1M1M1$fBind:*::*::*:$fBindRec1Rec1Rec1 $fBindU1U1U1$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(->)(->)(->)"$fApplicativeWriterTWriterTWriterT#$fApplicativeWriterTWriterTWriterT0$fApplicativeStateTStateTStateT $fApplicativeStateTStateTStateT0"$fApplicativeReaderTReaderTReaderT$fApplicativeRWSTRWSTRWST$fApplicativeRWSTRWSTRWST0$fApplicativeMaybeTMaybeTMaybeT$fApplicativeListTListTListT($fApplicativeIdentityTIdentityTIdentityT"$fApplicativeExceptTExceptTExceptT$fApplicativeContTContTContT$fApplicativeSetSetSet$fApplicativeM1M1M1$fApplicative:.::.::.:$fApplicative:*::*::*:$fApplicativeRec1Rec1Rec1$fApplicativeU1U1U1$fApplicativeSTMSTMSTM1$fApplicativeWrappedMonadWrappedMonadWrappedMonad+$fApplicativeArrowMonadArrowMonadArrowMonad$fApplicativeSTSTST$fApplicativeSTSTST0%$fApplicativeReadPrecReadPrecReadPrec$fApplicativeReadPReadPReadP"$fApplicativeComposeComposeCompose"$fApplicativeProductProductProduct%$fApplicativeNonEmptyNonEmptyNonEmpty"$fApplicativeComplexComplexComplex$fApplicativeProxyProxyProxy$fApplicativeLastLastLast$fApplicativeFirstFirstFirst$fApplicativeOptionOptionOption$fApplicativeMaxMaxMax$fApplicativeMinMinMin$fApplicativeAltAltAlt$fApplicativeDualDualDual#$fApplicativeProductProductProduct0$fApplicativeSumSumSum$fApplicativeLastLastLast0$fApplicativeFirstFirstFirst0$fApplicativeEitherEitherEither$fApplicativeIOIOIO$fApplicativeMaybeMaybeMaybe$fApplicative[][][]%$fApplicativeIdentityIdentityIdentity$fApplicative(->)(->)(->) ifThenElse=<<>=><=<whenunlessmapMmapM_forMforM_joinvoidAvoidMsequence sequence_foreverfilterM mapAndUnzipMzipWithM zipWithM_foldMfoldM_ replicateM replicateM_liftMliftM'liftM2liftM3ap<$!>liftA2<**>liftAliftA3filterAmapAmapA_forAforA_ sequenceA_ mapAndUnzipAzipWithA zipWithA_ replicateA replicateA_whenAunlessAAlternativeAltAlternativeAltCts<|>AlternativeEmptyAlternativeEmptyCtsempty$fAlternativeAltM1M1M1$fAlternativeAlt:.::.::.:$fAlternativeAlt:*::*::*:$fAlternativeAltRec1Rec1Rec1$fAlternativeAltU1U1U1%$fAlternativeAltComposeComposeCompose%$fAlternativeAltProductProductProduct$fAlternativeAltAltAltAlt$fAlternativeAltProxyProxyProxy"$fAlternativeAltOptionOptionOption$fAlternativeAltSTMSTMSTM($fAlternativeAltReadPrecReadPrecReadPrec$fAlternativeAltReadPReadPReadP$fAlternativeAltIOIOIO$fAlternativeAltMaybeMaybeMaybe$fAlternativeAlt[][][]$fAlternativeEmptyM1$fAlternativeEmpty:.:$fAlternativeEmpty:*:$fAlternativeEmptyRec1$fAlternativeEmptyU1$fAlternativeEmptyCompose$fAlternativeEmptyProduct$fAlternativeEmptyAlt$fAlternativeEmptyProxy$fAlternativeEmptyOption$fAlternativeEmptySTM$fAlternativeEmptyReadPrec$fAlternativeEmptyReadP$fAlternativeEmptyIO$fAlternativeEmptyMaybe$fAlternativeEmpty[] MonadPlusAddMonadPlusAddCtsmplus MonadPlusZeroMonadPlusZeroCtsmzero$fMonadPlusAddM1M1M1$fMonadPlusAdd:*::*::*:$fMonadPlusAddRec1Rec1Rec1$fMonadPlusAddU1U1U1#$fMonadPlusAddProductProductProduct$fMonadPlusAddAltAltAlt$fMonadPlusAddProxyProxyProxy $fMonadPlusAddOptionOptionOption$fMonadPlusAddSTMSTMSTM&$fMonadPlusAddReadPrecReadPrecReadPrec$fMonadPlusAddReadPReadPReadP$fMonadPlusAddIOIOIO$fMonadPlusAddMaybeMaybeMaybe$fMonadPlusAdd[][][]$fMonadPlusZeroM1$fMonadPlusZero:*:$fMonadPlusZeroRec1$fMonadPlusZeroU1$fMonadPlusZeroProduct$fMonadPlusZeroAlt$fMonadPlusZeroProxy$fMonadPlusZeroOption$fMonadPlusZeroSTM$fMonadPlusZeroReadPrec$fMonadPlusZeroReadP$fMonadPlusZeroIO$fMonadPlusZeroMaybe$fMonadPlusZero[]UnitId TypeVarSubstfromLeft fromRightmkTypeVarSubstsplitKindFunTysmkEqualityCtTypeconstraintSourceLocation baseUnitId moduleUnitIdisImportedFrom mkTcCoercionghcTyCoRepCoercion TcEvidence TcCoercionproduceTupleEvidence isTupleTyCon lookupInstEnv uniqSetToListPluginClassNamePluginModuleNamelegacySupermonadModuleNamesupermonadModuleNamelegacySupermonadCtModuleNamesupermonadCtModuleName bindClassNamereturnClassNamefunctorClassNameapplicativeClassName!legacySupermonadPreludeModuleNamesupermonadPreludeModuleName#legacySupermonadCtPreludeModuleNamesupermonadCtPreludeModuleNamefunctorModuleNamesuperarrowModuleNamesuperarrowCtModuleNamearrowArrClassNamearrowSequenceClassNamearrowSelectClassNamearrowParallelClassNamearrowFanOutClassNamepprToStr sDocToStr OutputableSDoc containsAnyOf containsAllOfcontainsNoneOfSet singletonsizemember notMember isSubsetOfisProperSubsetOfinsertdeleteunionunions intersection difference\\toListfromList $fMonoidSet$fEqSetunSet$fOutputableSetMapelemskeysSetkeys $fMonoidMap$fEqMapunMap$fOutputableMap InstanceDict emptyInstDictinsertInstDictlookupInstDictallInstDictTyConslookupInstDictByTyConinstDictToList$fOutputableInstanceDict$fMonoidInstanceDict errIndentcollectTopTyConscollectTopTcVarscollectTopTcVarsWithArity collectTyVars mkTcVarSubstskolemVarsBindFunUnifySkolemInstEnvinstanceBindFuneqTyVareqTyVar' tyVarArity getTyConName getClassNameatIndext1stt2ndt3rdisAmbiguousTypepartiallyApplyTyCons TcPluginM newFlexiTyVar applyTyConsplitKindFunOfTcTv associations removeDupremoveDupUniqueremoveDupByIndexremoveDupByIndexEqremoveDupByIndexUniquelookupByallManyMquantM partitionMWantedCt DerivedCtGivenCtmkDerivedTypeEqCtOfTypesmkDerivedTypeEqCtmkDerivedClassCtisClassConstraintisAnyClassConstraintconstraintClassTypeconstraintClassTyArgsconstraintClassTyConconstraintTopTyConsconstraintTopTcVarsconstraintLocationconstraintPredicateTypeconstraintTyVarssortConstraintsByLineisClassInstance instanceClassinstanceClassTyConinstanceTopTyConsinstanceTyArgsisMonoTyConInstanceisPolyTyConInstance prefixMsgpluginMsgPrefixsmErrMsg smWarnMsg smDebugMsgsmObjMsgmissingCaseErrorformatGroupSrcSpans formatSpanformatConstraint printTrace printObjTrace internalPrintprintMsgprintErr printWarnprintObjpluginFailSDoc pluginAssert Debug.Tracetrace evaluateTypematchInstanceTyVarsproduceEvidenceFormatchInstanceTyVars'produceEvidenceForCtproduceEvidenceForCtTypeisPotentiallyInstantiatedCtisPotentiallyInstantiatedCtType TcRnTypes isGivenCtis_tvsConstraintGroupcomponentMonoTyConcomponentTopTyConscomponentTopTcVarscollectseparateContraintsSCNodecollectInternalSet ClassDictOptional emptyClsDict insertClsDictinsertOptionalClsDictisOptionalClass lookupClsDictlookupClsDictClasslookupClsDictInstancesallClsDictKeyscontainers-0.5.7.1 Data.Set.BaseallClsDictEntries$fMonoidClassDict Data.Map.Base$fOutputableClassDictInstanceImplication ClassQuery ModuleQuery ThisModule EitherModule AnyModulecheckInstancesfindModuleByQuery findModulefindEitherModule findAnyModuledefaultFindEitherModuleErrMsgdefaultFindAnyModuleErrMsgisOptionalClassQueryqueriedClasses moduleQueryOffindClassesByQuery findClassisClassfindClassesAndInstancesInScopefindInstancesInScopefindMonoTopTyConInstances===><==>clsDictInstImpclsDictInstEquivcheckInstanceImplicationsInstanceImpliescollectModuleNamesisModuleInQuery$fOutputableInstanceImplication$fOutputableClassQuery$fOutputableModuleQuerySupermonadPluginStatesmStateTyVarEqualitiessmStateTypeEqualitiessmStateWarningQueue smStateCustomSupermonadPluginEnvsmEnvGivenConstraintssmEnvWantedConstraintssmEnvClassDictionarySupermonadPluginMSupermonadErrorrunSupermonadPluginAndReturnrunSupermonadPlugin runTcPlugingetClassDictionarygetCustomStateputCustomStatemodifyCustomStategetClassgetGivenConstraintsgetWantedConstraints getInstEnvsgetInstanceForaddTyVarEqualityaddTyVarEqualitiesaddTypeEqualityaddTypeEqualitiesgetTyVarEqualitiesgetTypeEqualities addWarning whenNoResultsdisplayWarningsassertassertMthrowPluginErrorthrowPluginErrorSDoccatchPluginErrorprintFormattedObjprintConstraintsstringToSupermonadErrorsolveConstraintssolveMonoConstraintGroupsolvePolyConstraintGroup#determineValidConstraintGroupAssocssolveSolvedTyConIndicesTcTvSettctvIntersectiontctvNull tctvUnion tctvToListSupermonadStatepluginPrototype solvingGroupssupermonadModuleQuerysupermonadClassQuerysupermonadInstanceImplicationsfindSupermonadModulesErrMsgfindAlternativeModulesErrMsgfindMonadPlusModulesErrMsgalternativeEmptyClassNamealternativeAltClassNamealternativeModuleNamealternativeCtModuleNamemonadPlusZeroClassNamemonadPlusAddClassNamemonadPlusModuleNamemonadPlusCtModuleNamealternativeModuleQuerymonadPlusModuleQueryalternativeClassQuerymonadPlusClassQueryDefaultAppCtsLDefaultAppCtsR defaultAppR defaultAppLControl.Applicative WrappedMonad