b      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 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 T UVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu v w!x!y!z!{!|!}!~!!!"""""""##########################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%&''''''''''(((((((((( ( ( ( ( (((((((((((((())))) )!)" # $ % & ' (*)***+ , - . / 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+T+U+V+W+X+Y+Z+[+\,],^,_,`-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){)|)})~)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) * * * * ******************* *!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@0A0B0C0D0E0F0G0H0I0J0K0L0M0NOPQRSTUVWXYZ[\]^_`abcdefghijklm1n1o1p1q1r1s1t1u1v2w2x2y2z2{2|2}2~22223333333333344444444455)))))))))))))))6666666677777777777777777777777777777777 7 7 7 7 7777777777777777777 7!7"7#7$7%7&7'7(7)7*7+7,8-8.8/808182838485868788898:8;8<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K8L8M9N9O9P9Q9R9S:T:U:V:W:X:Y:Z;[;\;];^;_<`<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={=|>}>~>>>>>>???????????@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAABBCCCCCCCCCCCCCC6666666666666666666666666666666666666DEEEEEEEEEE)))))))))))))))))FFFFFF F F F F FFFFFFFGSafe$(*-/09:;<=?DFMOTbHA fully qualified name, including the name of the module it is from.A hierarchical module name.Read a string like HI as a module name.4Check whether this is the name of the "Main" module.FCheck whether a module name matches the given file path of the module.HIf the module is named M1.M2.M3 then the file needs to be called PATHM1/M2/M3.EXT for some base PATH and extension EXT. JSafe$(*-/09:;<=?DFMOTb4Define a foreign value being imported into a module.8Value imported from a module that we compiled ourselves. ,Value imported via the C calling convention. -Name of the module that we're importing from. +Name of the the value that we're importing. 'Type of the value that we're importing. mCalling convention for this value, including the number of type parameters, value parameters, and boxings.pName of the symbol being imported. This can be different from the name that we give it in the core language.'Type of the value that we're importing.9Define a foreign capability being imported into a module.Capability imported abstractly. For capabilities like (Read r) for some top-level region r we can just say that we have the capability.+Define a type being imported into a module.Type imported abstractly.&Used for phantom types of kind Data, as well as regions, effects, and any other type that does not have kind Data. When a type is imported abstractly it has no associated values, so we can just say that we have the type without worrying about how to represent its associated values.Type of some boxed data.The objects follow the standard heap object layout, but the code that constructs and destructs them may have been written in a different language.?This is used when importing data types defined in Salt modules.Take the kind of an .#Apply a function to the kind of an Take the type of an .#Apply a function to the type in an ImportCapability.#Take the type of an imported thing./Apply a function to the type in an ImportValue.    KSafe$(*-/09:;<=?DFMOTb$Define thing exported from a module.5A name defined in this module, with an explicit type. A named defined in this module, without a type attached. We use this version for source language where we infer the type of the exported thing.#4Take the type of an imported thing, if there is one.$0Apply a function to any type in an ExportSource. !"#$ !"#$ !"!#$LSafe$(*-/09:;<=?DFMOTb %Symbol tokens.&Like '(''Like ')'(Like '[')Like ']'*Like '{'+Like '}', Like '[:'- Like ':]'. Like '{:'/ Like ':}'0Like /\\1Like ~>2Like '->'3Like '<-'4Like '=>'5Like '@'6Like 7Like 8Like '|'9Like ',':Like '=';Like ''<Like ';'=Like \\>Like ''?Like '_'@(Yield the string name of a symbol token.Scanner for a %.#Match a potential symbol character.!Accept a double character symbol.!Accept a single character symbol. %&'()*+,-./0123456789:;<=>?@%&'()*+,-./0123456789:;<=>?@%&'()*+,-./0123456789:;<=>?@MSafe$(*-/09:;<=?DFMOTb Scan a deBruijn index.   NSafe$(*-/09:;<=?DFMOTbA)Language feature supported by a fragment.BTrack effect type information.CTrack closure type information.D(Attach latent effects to function types.E)Attach latent closures to function types.FTreat effects as capabilities.G5Insert implicit run casts for effectful applications.H5Insert implicit box casts for bodies of abstractions.I&Partially applied primitive operators.JPartially applied functionsKFunction application where the thing being applied is not a variable. Most backend languages (like LLVM) don't support this.LVNested function bindings. The output of the lambda-lifter should not contain these.MTRecursive let-expressions where the right hand sides are not lambda abstractions.N^Debruijn binders. Most backends will want to use real names, instead of indexed binders.OAllow data and witness vars without binding occurrences if they are annotated directly with their types. This lets us work with open terms.PAllow non-primitive functions to be instantiated at unboxed types. Our existing backends can't handle this, because boxed and unboxed objects have different representations.QAllow name shadowing.R-Allow unused named data and witness bindings.SAllow unused named matches.ABCDEFGHIJKLMNOPQRSABCDEFGHIJKLMNOPQRSABCDEFGHIJKLMNOPQRSSafe$(*-/09:;<=?DFMOTbTUTUTUTUSafe$(*-/09:;<=?DFMOTbV%Other constructors at the spec level.W+The unit data type constructor is baked in.XPure function.YA suspended computation.ZRead of some region.[$Read the head region in a data type.\,Read of all material regions in a data type.]Write of some region.^0Write to all material regions in some data type._Allocation into some region.`7Allocation into all material regions in some data type.aWitness type constructors.cPurity of some effect.dConstancy of some region.e*Constancy of material regions in some typefMutability of some region.g,Mutability of material regions in some type.hDistinctness of some n regionsi=Non-interfering effects are disjoint. Used for rewrite rules.jKind constructor.kPFunction kind constructor. This is only well formed when it is fully applied.lKind of witnesses.mKind of data values.nKind of regions.oKind of effects.pKind of closures.qSort constructor.rSort of witness kinds.sSort of computation kinds.VWXYZ[\]^_`abcdefghijklmnopqrsVWXYZ[\]^_`abcdefghijklmnopqrsqrsjklmnopabcdefghiVWXYZ[\]^_`V WXYZ[\]^_`abcdefghijklmnopqrsSafe$(*-/09:;<=?DFMOTb#$Kind, type and witness constructors.SThese are grouped to make it easy to determine the universe that they belong to.$(level 3) Builtin Sort constructors.$(level 2) Builtin Kind constructors.?(level 1) Builtin Spec constructors for the types of witnesses.=(level 1) Builtin Spec constructors for types of other kinds.User defined type constructor.sAn existentially quantified name, with its kind. Used during type checking, but not accepted in source programs.6Wraps a variable or constructor that can be added the  array.)Hash value used to insert types into the  array of a .%A least upper bound of several types.mWe keep type sums in this normalised format instead of joining them together with a binary operator (like (+)o). This makes sums easier to work with, as a given sum type often only has a single physical representation.%The kind of the elements in this sum.Where we can see the outer constructor of a type, its argument is inserted into this array. This handles common cases like Read, Write, Alloc effects.A map for named type variables.#A map for anonymous type variables.7Types that can't be placed in the other fields go here.*INVARIANT: this list doesn't contain more s.Alias for closure types.Alias for effect types.Alias for region types.Kinds are types at level 2Sorts are types at level 3.A value type, kind, or sort.jWe use the same data type to represent all three universes, as they have a similar algebraic structure. Constructor. Variable. Abstraction. Application.Universal Quantification.Least upper bound.0A bound occurrence of a variable, with its type.JIf variable hasn't been annotated with its real type then this can be tBot (an empty sum).7Nameless variable that should be on the deBruijn stack.1Named variable that should be in the environment.\Named primitive that has its type attached to it. The types of primitives must be closed. A variable binder with its type.8A variable with no uses in the body doesn't need a name.(Nameless variable on the deBruijn stack."Named variable in the environment.,JVWXYZ[\]^_`abcdefghijklmnopqrsKqrsjklmnopabcdefghiVWXYZ[\]^_` OSafe$(*-/09:;<=?DFMOTb!"#$%&'(!"#$%&'(PSafe$(*-/09:;<=?DFMOTbJVWXYZ[\]^_`abcdefghijklmnopqrsKqrsjklmnopabcdefghiVWXYZ[\]^_`Safe$(*-/09:;<=?DFMOTblLookup the type of a bound thing from the binder stack. The binder stack contains the binders of all the  s we've entered under so far.Safe$(*-/09:;<=?DFMOTb.Construct an empty type sum of the given kind.)6Construct an empty type sum of the given kind, but in  form. This isn't exported.1Construct a type sum containing a single element..Check whether an element is a member of a sum.1Returns True when the first argument is $0 or !0.5Returns False when the first argument is another sum.qMay return False if the first argument is miskinded but still alpha-equivalent to some component of the sum. Insert a new element into a sum.Delete an element from a sum.Add two type sums.Union a list of  s together.8Delete all members of the second sum from the first one.Take the kind of a sum.7Flatten out a sum, yielding a list of individual terms.Convert a list of types to a  Yield the  of a , or * if there isn't one.+ Yield the  of a  TyConBuiltin, or * if there isn't one.,The range of hashes that can be produced by . Yield the  corresponding to a , or , if there isn't one.-]If this type can be put in one of our arrays then split it into the hash and the argument.. Inverse of -.)+-.)+-.QSafe$(*-/09:;<=?DFMOTbWitness constructors.Witness constructors defined in the environment. In the interpreter we use this to hold runtime capabilities. The attached type must be closed.// Safe$(*-/09:;<=?DFMOTbK_Take the variable name of a bind. If this is an anonymous binder then there won't be a name.Take the type of a bind.*Replace the type of a bind with a new one.Take the binder of a bind.'Make a bind from a binder and its type.,Make lists of binds that have the same type.[Take the name of bound variable. If this is a deBruijn index then there won't be a name.Get the attached type of a  , if any.)Check whether a bound maches a bind.  and ' match if they have the same name. UIx 0 _ and BAnon _ always match. Yields 0, for other combinations of bounds and binds.=Check whether a named bound matches a named bind. Yields 0/ if they are not named or have different names. Convert a  to a , ready for substitution.Returns  for , UIx 0 for  and * for (, because there's nothing to substitute. Convert some s to BoundsIf this  is a Q then replace it's embedded type with a new one, otherwise return it unharmed.Construct a deBruijn index.)Take an existential variable from a type.Construct an empty type sum.Construct a type application.Construct a type application.*Construct a sequence of type applications.XFlatten a sequence ot type applications into the function part and arguments, if any.jFlatten a sequence of type applications, returning the type constructor and arguments, if there is one.Flatten a sequence of type applications, returning the type constructor and arguments, if there is one. Only accept primitive type constructors.Flatten a sequence of type applications, returning the type constructor and arguments, if there is one. Only accept data type constructors.}Take the prime region variable of a data type. This corresponds to the region the outermost constructor is allocated into.=Build an anonymous type abstraction, with a single parameter.nBuild an anonymous type abstraction, with a single parameter. Starting the next index from the given value.nBuild an anonymous type abstraction, with several parameters. Starting the next index from the given value.nBuild an anonymous type abstraction, with several parameters. Starting the next index from the given value.6Split nested foralls from the front of a type, or * if there was no outer forall. Erase all  quantifiers from a type.The unit type.Construct a kind function.Construct some kind functions.Destruct a kind function5Destruct a chain of kind functions into the argumentsLike 8, but return argument and return kinds in the same list.iTake the result kind of a kind function, or return the same kind unharmed if it's not a kind function.Construct a pure function type.PConstruct a function type from a list of parameter types and the return type.[Construct a function type from a list containing the parameter and return types. Yields * if the list is empty.6Yield the argument and result type of a function type.NDestruct the type of a function, returning just the argument and result types.Destruct the type of a function, returning the witness argument, value argument and result types. The function type must have the witness implications before the value arguments, eg T1 => T2 -> T3 -> T4 -> T5.Destruct the type of a possibly polymorphic function returning all kinds of quantifiers, witness arguments, and value arguments in the order they appear, along with the type of the result.kDetermine the arity of an expression by looking at its type. Count all the function arrows, and foralls.^This assumes the type is in prenex form, meaning that all the quantifiers are at the front.KThe data arity of a type is the number of data values it takes. Unlike ' we ignore type and witness parameters.%Construct a witness implication type.Construct a suspension type.5Take the effect and result type of a suspension type.%Split off enclosing suspension types.%Sort of kinds of computational types.%Sort of kinds of propositional types.Kind of data types.Kind of region types.Kind of effect types.Kind of closure types. Kind of witness types. Read effect type constructor. "Head Read effect type constructor. "Deep Read effect type constructor. Write effect type constructor.#Deep Write effect type constructor.Alloc effect type constructor. #Deep Alloc effect type constructor.Pure witness type constructor.Const witness type constructor.$Deep Const witness type constructor.!Mutable witness type constructor.&Deep Mutable witness type constructor."Distinct witness type constructor.1AWrap a computation type constructor applied to a single argument.2=Wrap a witness type constructor applied to a single argument.39Wrap a witness type constructor applied to two arguments.3Build a nullary type constructor of the given kind.5Build a type constructor application of one argumnet.L     123I     I     L     123    Safe$(*-/09:;<=?DFMOTbCheck whether a type is a "Test if some type is an empty TSumCheck whether a type is a ,  or is Bottom.3Check whether this type is an existential variable. $Check if some kind is the data kind.!&Check if some kind is the region kind."&Check if some kind is the effect kind.#'Check if some kind is the closure kind.$'Check if some kind is the witness kind.%2Check whether this type is that of algebraic data.It needs to have an explicit data constructor out the front, and not a type variable. The constructor must not be the function constructor, and must return a value of kind 4.&+Check whether type is a witness constructor'$Check whether this is the type of a Const witness.($Check whether this is the type of a Mutable witness.)$Check whether this is the type of a Distinct witness.*0Check if this is the TyFun or KiFun constructor.+,Check whether this is an atomic read effect.,-Check whether this is an atomic write effect.--Check whether this is an atomic alloc effect..@Check whether an effect is some sort of read effect. Matches Read HeadRead and DeepRead./FCheck whether an effect is some sort of allocation effect. Matches Alloc and  DeepAlloc0FCheck whether an effect is some sort of allocation effect. Matches Alloc and  DeepAlloc !"#$%&'()*+,-./0 !"#$%&'()*+,-./0 !"#$%&'()*+,-./0 !"#$%&'()*+,-./0 Safe$(*-/09:;<=?DFMOTb2Apply a function to all bound variables in the program. The function is passed the current binding depth. This is used to defined both 4 and 6.3<Lift debruijn indices less than or equal to the given depth.4 Wrapper for  liftAtDepthX that starts at depth 0. 5=Lower debruijn indices less than or equal to the given depth.6 Wrapper for  lowerAtDepthX that starts at depth 0. 123Number of levels to lift.Current binding depth.&Lift expression indices in this thing.45Number of levels to lower.Current binding depth.'Lower expression indices in this thing.65789:123456436512 1234565789: Safe$(*-/09:;<=?DFMOTb;$Type synonym to improve readability.<$Type synonym to improve readability.=$Type synonym to improve readability.>A type environment.@Types of named binders.A$Types of anonymous deBruijn binders.BThe length of the above stack.C#Types of baked in, primitive names.DAn empty environment.E'Construct a singleton type environment.FmExtend an environment with a new binding. Replaces bindings with the same name already in the environment.GvExtend an environment with a list of new bindings. Replaces bindings with the same name already in the environment.H:Set the function that knows the types of primitive things.I.Check if the type of a name is defined by the C.JConvert a list of s to an environment.K4Convert a list of name and types into an environmentL1Convert a map of names to types to a environment.MCombine two environments. If both environments have a binding with the same name, then the one in the second environment takes preference.NICombine multiple environments, with the latter ones taking preference.O<Check whether a bound variable is present in an environment.PCheck whether a binder is already present in the an environment. This can only return True for named binders, not anonymous or primitive ones.Q,Lookup a bound variable from an environment.R(Lookup a bound name from an environment.S,Yield the total depth of the deBruijn stack.TOLift all free deBruijn indices in the environment by the given number of steps.;<=>?@ABCDEFGHIJKLMNOPQRST;<=>?@ABCDEFGHIJKLMNOPQRST>?@ABC=<;DEFGMNJKLSOPQRHIT;<=>?@ABCDEFGHIJKLMNOPQRSTSafe$(*-/09:;<=?DFMOTbU*Describes a data constructor, used in the f table.WName of data constructor.X3Tag of constructor (order in data type declaration)YField types of constructor.ZResult type of constructor.[#Name of result type of constructor.\Parameters of data type ]/Describes a data type constructor, used in the f table._Name of data type constructor.`(Kinds of type parameters to constructor.a4Names of data constructors of this data type, or *( if it has infinitely many constructors.b#Whether the data type is algebraic.c\The mode of a data type records how many data constructors there are. This can be set to Large for large primitive types like Int and Float. In this case we don't ever expect them all to be enumerated as case alternatives.fiA table of data type definitions, unpacked into type and data constructors so we can find them easily.j%The definition of a single data type.lName of the data type.mBinders for type parameters.nConstructors of the data type, or Nothing if the data type is algbraic but there are too many constructors to list (like with 6).oGWhether the data type is algebraic. These can be deconstructed with 'case' expressions.p2Get the kind of the type constructor defined by a j.qcGet the type associated with a data definition, that is, the type produced by the constructors.rkGet the list of data constructor names that this type defines, or Nothing if there are too many to list.sShortcut for constructing a j for an algebraic type.DValues of algebraic type can be deconstructed with case-expressions.tShortcut for constructing a j for an abstract type.FValues of abstract type cannot be deconstructed with case-expressions.uGet the type of Uv(An empty table of data type definitions.w Union two j tables.x1Insert a data type definition into some DataDefs.yBuild a f table from a list of jzDYield the list of data constructor names for some data type, or *4 for large types with too many constructors to list.{2Get the kind of the type constructor defined by a j.*UVWXYZ[\]^_`abcdefghijklmnopqrsName of data type.Type parameters.,Constructor names and field types, or * if there are too many to list.tuvwxyz{|}~'UVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{'jklmnopqrstfghicdevxwy]^_`ab{zUVWXYZ[\uUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe$(*-/09:;<=?DFMOTbRewrite  bounds to  bounds and attach their types. Primitives have their types attached because they are so common in the language, their types are closed, and we don't want to keep having to look them up from the environment.  Safe$(*-/09:;<=?DFMORTb!3Synonym for show constraints of all language types.\Wrapper for primitive constructors that adds the ones common to SystemF based languages.The void constructor.The unit constructor.The function constructor.-Take the least upper bound at the given kind.$The least element of the given kind.<The universal quantifier with a parameter of the given kind.>The existential quantifier with a parameter of the given kind.Primitive constructor.Bound constructor.'Generic type expression representation.An annotated type.Type constructor or literal.Type variable.Type abstracton.Type application.'Yield the type of primitive type names.4Yield the type of bound occurrences of constructors.6Yield the type of binding occurrences of constructors.1Yield the type of bound occurrences of variables.3Yield the type of binding occurrences of variables.Yield the type of annotations..Representation of primitive type constructors.'Representation of a union of two types.2Representation of the bottom type at a given kind.$Representation of the function type. Representation of the unit type. Representation of the void type.'Applcation of a type to five arguments.'Applcation of a type to four arguments.(Applcation of a type to three arguments.&Applcation of a type to two arguments.!!! Safe$(*-/09:;<=?DFMOTbSafe$(*-/09:;<=?DFMOTbCheck whether a type is a  or .Safe$(*-/09:;<=?DFMORTb2Class of languages that support anonymous binding.SEvaluate a function given a new anonymous binding and matching bound occurrence.-Class of languages that include name binding.CGet the bound occurrence that matches the given binding occurrence.@Check if the given bound occurence matches a binding occurrence.Safe$(*-/09:;<=?DFMOTb5Take a type constructor, looking through annotations.2Take a type variable, looking through annotations.5Take a type abstraction, looking through annotations.5Take a type application, looking through annotations.*Construct a sequence of type applications.XFlatten a sequence of type applications into the function part and arguments, if any.CConstruct a function type with the given parameter and result type.Like makeFun& but taking a list of parameter types.Like 5 but taking the parameter and return types as a list.KDestruct a function type into its parameter and result types, returning * if this isn't a function type.Destruct a function type into into all its parameters and result type, returning an empty parameter list if this isn't a function type.Like takeFuns<, but yield the parameter and return types in the same list.=Construct a forall quantified type using an anonymous binder.@Construct a forall quantified type using some anonymous binders.2Destruct a forall quantified type, if this is one.TThe kind we return comes from the abstraction rather than the Forall constructor.>Construct an exists quantified type using an anonymous binder.3Destruct an exists quantified type, if this is one.UThe kind we return comes from the abstraction rather than the Exists constructor. 70Take a bottom type, looking through annotations.6Take the kind, left and right types from a union type.:Make a union type from a kind and list of component types.kSplit a union type into its components. If this is not a union, or is an ill kinded union then Nothing.Split a union of the given kind into its components. When we split a sum we need to check that the kind attached to the sum type constructor is the one that we were expecting, otherwise we risk splitting ill-kinded sums without noticing it.77  RSafe$(*-/09:;<=?DFMOTb--Safe$(*-/09:;<=?DFMORTb%Safe$(*-/09:;<=?DFMORTb How to pretty print a doc.Render the doc with indenting.!Render the doc without indenting.Wrap a 8$ in parens if the predicate is true.!Render a doc with the given mode. Convert a 8! to a string without indentation. Convert a 8 to a string with indentationPut a 8 to stdout using the given mode.Put a 8 to stdout using the given mode.]9:;<=8>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe$(*-/09:;<=?DFMORTbA located thing.$A position in a source file. qIf there is no file path then we assume that the input has been read from an interactive session and display ''<interactive>'' when pretty printing.,Take the source position of a located thing.3Take the parsec source position of a located thing.)Yield the source name of a located thing.)Yield the line number of a located thing.+Yield the column number of a located thing.-Yield the contained value of a located thing.   Safe$(*-/09:;<=?DFMORTb9Synonym for pretty constraints on the configurable types.2Pretty print a type using the generic, raw syntax.Like ", but take the initial precedence. >Pretty print a type constructor using the generic, raw syntax.    Safe$(*-/09:;<=?DFMOTb   SSafe$(*-/09:;<=?DFMOTb) Safe$(*-/09:;<=?DFMOTb         Safe$(*-/09:;<=?DFMOTb (Universes of the Disciple Core language. A numbered universe (levels 4..):(level 3). The universe of sorts. Sorts classify kinds.C(level 2). The universe of kinds. Kinds classify specifications.(level 1). The universe of specifications. Specifications classify both witnesses and data values. In the vanilla Haskell world "specifications" are known as "types", but here we use the former term because we overload the word "type" to refer to kinds and sorts as well.(level 0). The universe of witnesses. The existence of a witness in the program guarantees that some property about how it operates at runtime. For example, a witness of constancy of some region guarantees objects in that region will not be updated. This is like the Prop# universe in constructive logic.~(level 0). The universe of data values. These are physical data objects that take up space at runtime. This is like the Set[ universe in constructive logic, but the expressions may diverge or cause side effects.0Take the next highest universe of the given one.xGiven the type of the type of the type of some thing (up three levels), yield the universe of the original thing, or * it was badly formed.jGiven the type of the type of some thing (up two levels), yield the universe of the original thing, or * if it was badly formed.]Given the type of some thing (up one level), yield the universe of the original thing, or * if it was badly formed. Yield the universe of some type. ^ universeOfType (tBot kEffect) = UniverseSpec universeOfType kRegion = UniverseKind   TSafe$(*-/09:;<=?DFMOTb}Pretty print a binder, adding spaces after names. The RAnon and None binders don't need spaces, as they're single symbols.,Print a group of binders with the same type.]9:;<=8>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe$(*-/09:;<=?DFMOTbCompound names can be extended to create new names. This is useful when generating fresh names during program transformation.(Build a new name based on the given one. 'Build a new name from the given string.!'Split the extension string from a name.#cProduce a flat string from a name. The resulting string should be re-lexable as a bindable name. !"# !"#"# ! !"#Safe$(*-/09:;<=?DFMOTb$Take the head of a list, or * if it's empty.%Take the tail of a list, or * if it's empty.&Take the init of a list, or * if it's empty.'Take the maximum of a list, or * if it's empty.(JRetrieve the element at the given index, or `Nothing if it's not there.)$Find the duplicate values in a list.*#Drops the given suffix from a list.$%&'()*$%&'()*$%&'()*$%&'()*USafe$(*-/09:;<=?DFMOTb Scanner for variable anmes.Match a variable name.Accept a variable name.+(Check if this string is a variable name.,#Charater can start a variable name.-)Character can be part of a variable body.Scanner for constructor names.Match a constructor name.Accept a constructor name..String is a constructor name./'Character can start a constructor name.0+Charater can be part of a constructor body. +,-./0 +,-./0 +,-./0VSafe$(*-/09:;<=?DFMOTb1Keyword tokens.Q#Yield the string name of a keyword.Scanner for a 1.Accept a keyword token.#123456789:;<=>?@ABCDEFGHIJKLMNOPQ"123456789:;<=>?@ABCDEFGHIJKLMNOPQ123456789:;<=>?@ABCDEFGHIJKLMNOPQSafe$(*-/09:;<=?DFMOTbR<Generic environment that maps a variable to a thing of type a. T Named things.UAnonymous things.VLength of the stack.W!A bound occurrence of a variable.XIndex an anonymous binder.YNamed variable.Z#A binding occurrence of a variable.[JNo binding, or alternatively, bind a fresh name that has no bound uses.\Anonymous binder.] Named binder.^Convert a list of Zs to an environment._Convert a list of Zs to an environment.`*Convert a map of things to an environment.a)An empty environment, with nothing in it.b"Construct a singleton environment.cmExtend an environment with a new binding. Replaces bindings with the same name already in the environment.dvExtend an environment with a list of new bindings. Replaces bindings with the same name already in the environment.eCombine two environments. If both environments have a binding with the same name, then the one in the second environment takes preference.fICombine multiple environments, with the latter ones taking preference.g<Check whether a bound variable is present in an environment.h,Lookup a bound variable from an environment.i6Lookup a value from the environment based on its name.j7Lookup a value from the environment based on its index.k-Yield the total depth of the anonymous stack.RSTUVWXYZ[\]^_`abcdefghijkRSTUVWXYZ[\]^_`abcdefghijkZ[\]WXYRSTUV^_`abcdefghijkRSTUVWXYZ[\]^_`abcdefghijkSafe$(*-/09:;<=?DFMOTbrThis function has a show instance that prints "CANNED" for any contained type. We use it to wrap functional fields in data types that we still want to derive Show instances for.rstrsrsrst Safe$(*-/09:;<=?DFMOTb!Common use of a unicode operator.u&Unicode operators that are used infix.KSymbols from the Unicode Range 2200-22ff "Mathematical Operators". From +http://www.unicode.org/charts/PDF/U2200.pdfWe restrict the allowable unicode to the common ones that most people know how to pronounce, that do not conflict with other symbols, and that are tradionally used infix.uuuuWSafe$(*-/09:;<=?DFMOTb "Scanner for operators used prefix.Patch a prefix operator name.Accept a prefix operator name.!Scanner for operators used infix.Match an operator name.Accept an operator name.$String is the name of some operator. Character can start an operator.*Character can be part of an operator body.  !Safe$(*-/09:;<=?DFMOTbw.Types of literal values known to the compiler.Note that literals are embedded in the name type of each fragment rather than in the expression itself so that fragments can choose which types of literals they support. wxyz{|}~wxyz{|}~wxyz{|}~wxyz{|}~XSafe$(*-/09:;<=?DFMOTb-A flattened set of features, for easy lookup.kThe fragment profile describes the language features and primitive operators available in the language.The name of this profile.Permitted language features.!Primitive data type declarations.Kinds of primitive types.Types of primitive operators.WCheck whether a type is an unboxed type. Some fragments limit how these can be used.\Check whether some name represents a hole that needs to be filled in by the type checker.Convert a literal to a name, given the source position, literal value and whether the literal should be taken as a language primitive (with a trailing #).Apply a function to the  of a .;A language profile with no features or primitive operators.,This provides a simple first-order language.,An emtpy feature set, with all flags set to 0.Set a language Flag in the ."" YSafe$(*-/09:;<=?DFMOTb Match a literal character.Accept a literal. String is the name of a literal.Character can start a literal.(Character can be part of a literal body.Read a signed integer.7Read an integer with an explicit format specifier like 1234i.?Read an integer literal with an explicit format specifier like 1234i.<Read an size literal with an explicit format specifier like 1234s..Read a word with an explicit format speficier.<Read a float literal with an explicit format specifier like  123.00f32#.!Read a binary string as a number.Read a hex string as a number.wxyz{|}~"Safe$(*-/09:;<=?DFMOTb~The type checker for witnesses adds this annotation to every node in the, giving the type of each component of the witness.#Safe$(*-/09:;<=?DFMOTbA type environment.#Types of baked in, primitive names.9Map of constructor name to bound type for type equations.'Map of globally available capabilities.*Kinds of named variables and constructors.&Types of anonymous deBruijn variables.The length of the above stack.An empty environment.'Construct a singleton type environment.mExtend an environment with a new binding. Replaces bindings with the same name already in the environment.vExtend an environment with a list of new bindings. Replaces bindings with the same name already in the environment.:Set the function that knows the types of primitive things..Check if the type of a name is defined by the  envPrimFun.Convert a list of s to an environment.4Convert a list of name and types into an environment1Convert a map of names to types to a environment. Extract a KindEnv from an .Combine two environments. If both environments have a binding with the same name, then the one in the second environment takes preference.ICombine multiple environments, with the latter ones taking preference.<Check whether a bound variable is present in an environment.Check whether a binder is already present in the an environment. This can only return True for named binders, not anonymous or primitive ones.,Lookup a bound variable from an environment.(Lookup a bound name from an environment.,Yield the total depth of the deBruijn stack.OLift all free deBruijn indices in the environment by the given number of steps.$Safe$(*-/09:;<=?DFMOTb Environment of term expressions. Environment of type expressions.#Types of baked in, primitive names.Data type definitions.*Types of named variables and constructors.&Types of anonymous deBruijn variables.The length of the above stack.An empty environment. Build an  from prim environments.'Construct a singleton type environment.mExtend an environment with a new binding. Replaces bindings with the same name already in the environment.vExtend an environment with a list of new bindings. Replaces bindings with the same name already in the environment.<Extend the environment with the kind of a new type variable.3Extend the environment with some new type bindings.:Set the function that knows the types of primitive things..Check if the type of a name is defined by the  envPrimFun.Convert a list of s to an environment.4Convert a list of name and types into an environment1Convert a map of names to types to a environment. Extract a KindEnv from an EnvX.Extract TypeEnv from an `EnvX.Combine two environments. If both environments have a binding with the same name, then the one in the second environment takes preference.ICombine multiple environments, with the latter ones taking preference.<Check whether a bound variable is present in an environment.Check whether a binder is already present in the an environment. This can only return True for named binders, not anonymous or primitive ones.,Lookup a bound variable from an environment.,Lookup a bound variable from an environment.(Lookup a bound name from an environment.,Yield the total depth of the deBruijn stack.OLift all free deBruijn indices in the environment by the given number of steps.Primitive kind environment.Primitive type environment. Primitive data type definitions.''%Safe$(*-/09:;<=?DFMOTb Check equivalence of types.dChecks equivalence up to alpha-renaming, as well as crushing of effects and trimming of closures.Return 0 if we find any free variables.We assume the types are well-kinded, so that the type annotations on bound variables match the binders. If this is not the case then you get an indeterminate result.Like - but take the initial stacks of type binders.If we have a UName and UPrim with the same name then these won't match even though they pretty print the same. This will only happen due to a compiler bugs, but is very confusing when it does, so we check for this case explicitly.,Unpack single element sums into plain types. Check if two TyCons& are equivalent. We need to handle + specially incase it's kind isn't attached, Crush effects in the given type.3Crush compound effects and closure terms. We check for a crushable term before calling crushT because that function will recursively crush the components. As equivT is already recursive, we don't want a doubly-recursive function that tries to re-crush the same non-crushable type over and over.2Crush compound effect terms into their components.For example, crushing DeepRead (List r1 (Int r2)) yields (Read r1 + Read r2).QIf this type has first order kind then wrap with the appropriate read effect.QIf this type has first order kind then wrap with the appropriate read effect.QIf this type has first order kind then wrap with the appropriate read effect. Environment of types. Stack of binders for first type.!Stack of binders for second type.First type to compare.Second type to compare. &Safe$(*-/09:;<=?DFMOTb1Check whether the first type subsumes the second.Both arguments are converted to sums, and we check that every element of the second sum is equivalent to an element in the first.\This only works for well formed types of effect and closure kind. Other types will yield 0.ZSafe$(*-/09:;<=?DFMOTbVWXYZ[\]^_`abcdefghijklmnopqrs      !"#$%&'()+,-./0qrsjklmnopabcdefghiVWXYZ[\]^_` !"#$%&'()+,-./0     'Safe$(*-/09:;<=?DFMOTbgThe type checker adds this annotation to every node in the AST, giving its type, effect and closure. Promote an  to an ? by filling in the effect and closure portions with bottoms. (Safe$(*-/09:;<=?DFMOTbIStack of anonymous binders that we've entered under during substitution. Holds anonymous binders that were already in the program, as well as named binders that are being rewritten to anonymous ones. In the resulting expression all these binders will be anonymous.JHolds all binders, independent of whether they are being rewritten or not. Number of  in . Number of  in .Substitution state. Keeps track of the binders in the environment that have been rewrittten to avoid variable capture or spec binder shadowing.+Bound variable that we're substituting for.We've decended past a binder that shadows the one that we're substituting for. We're no longer substituting, but still may need to anonymise variables in types. This can only happen for level-0 named binders. 9Level-1 names that need to be rewritten to avoid capture. 9Level-0 names that need to be rewritten to avoid capture. "Rewriting stack for level-1 names. "Rewriting stack for level-0 names.YRewrite names in some thing to anonymous form if they conflict with any names in the F state. We use this to avoid variable capture during substitution.aPush several binds onto the bind stack, anonymyzing them if need be to avoid variable capture.WPush a bind onto a bind stack, anonymizing it if need be to avoid variable capture. Compare a ( against the one we're substituting for.+Push a level-1 binder on the rewrite stack./Push some level-1 binders on the rewrite stack.+Push a level-0 binder on the rewrite stack./Push some level-0 binders on the rewrite stack./Rewrite the use of a level-1 binder if need be./Rewrite the use of a level-0 binder if need be.      Names that need to be rewritten.Current bind stack. Bind to push.'New stack and possibly anonymised bind.'Current Bind stack during substitution.Bound we're substituting for.Bound we're looking at now.               [Safe$(*-/09:;<=?DFMOTb'An element in the type checker context.A context position marker.Kind of some variable.Type of some variable. Existential variable declaration-Existential variable solved to some monotype.An existential variable.The role of some type variable.Concrete type variables are region variables that have been introduced in an enclosing lexical scope. All the capabilities for these will also be in the context. Abstract type variables are the ones that are bound by type abstraction Inside the body of a type abstraction we can assume a region supports any given capability. We only need to worry about if it really does when we actually run the enclosed computation.A position in the type checker context. A position is used to record a particular position in the context stack, so that we can pop elements higher than it.)Wrap an existential variable into a type.Take an Exists from a type.3Slurp all the existential variables from this type.@Take the existential from this context element, if there is one.\Safe$(*-/09:;<=?DFMOTb6What mode we're performing type checking/inference in.Reconstruct the type of the expression, requiring type annotations on parameters as well as type applications to already be present.The ascending smoke of incense.kSynthesise the type of the expression, producing unification variables for bidirectional type inference.Any new unification variables introduced may be used to define the given existentials, so the need to be declared outside their scopes. If the list is empty we can add new variables to the inner most scope.The descending tongue of flame. Check the type of an expression against this expected type, and unify expected types into unification variables for bidirecional type inference.]Safe$(*-/09:;<=?DFMOTb1Take the superkind of an atomic kind constructor.Yields *U for the kind function (~>) as it doesn't have a sort without being fully applied.Take the kind of a , if there is one. ,Take the kind of a witness type constructor.!0Take the kind of a computation type constructor. ! ! !^Safe$(*-/09:;<=?DFMOTb "Data constructors.#Baked in unit data constructor.$KPrimitive data constructor used for literals and baked-in constructors.  The type of the constructor needs to be attached to handle the case where there are too many constructors in the data type to list, like for Int literals. In this case we determine what data type it belongs to from the attached type of the data constructor.%2Data constructor that has a data type declaration.&Name of the data constructor.'Type of the data constructor.(6Take the name of data constructor, if there is one.)ITake the type annotation of a data constructor, if we know it locally.*The unit data constructor. "#$%&'()* "#$%&'()*"#$%&'&()*_Safe$(*-/09:;<=?DFMOTb+eWhen a witness exists in the program it guarantees that a certain property of the program is true.,Witness variable.-Witness constructor..Witness application./2Type can appear as the argument of an application.0 Type casts.1^Weaken the effect of an expression. The given effect is added to the effect of the body.2,Purify the effect (action) of an expression.3IBox up a computation, capturing its effects in the S computation type.4ARun a computation, releasing its effects into the environment.5Pattern matching.6$The default pattern always succeeds.70Match a data constructor and bind its arguments.8Case alternatives.:Possibly recursive bindings.;!Non-recursive expression binding.<)Recursive binding of lambda abstractions.=CBind a private region variable, and witnesses to its properties.>*Well-typed expressions have types of kind Data.?(Value variable or primitive operation.@Data constructor or literal.AType abstraction (level-1).B(Value and Witness abstraction (level-0).C Application.DPossibly recursive bindings.ECase branching.F Type cast.G2Type can appear as the argument of an application.H5Witness can appear as the argument of an application.$+,-./0123456789:;<=>?@ABCDEFGHpVWXYZ[\]^_`abcdefghijklmnopqrs"#$%&'+,-./0123456789:;<=>AB?@CDEFGH +,-./0123456789:;<=> ?@ABCDEFGH+Safe$(*-/09:;<=?DFMOTbIA one-hole context for >.JThe top-level context.KBody of a type abstraction.L'Body of a value or witness abstraction.MLeft of an application.NRight of an application.OBody of a let-expression.PVIn a non-recursive let-binding. We store the binder and body of the let expression.QIn a recursive binding.RScrutinee of a case expression.SIn a case alternative.TBody of a type castVyCheck if the context is a top-level let-binding. All bindings in the top-level chain of lets and letrecs are included.WGet the top level of a context.X4Take the enclosing context from a nested one, or *" if this is the top-level context.YZTake the name of the outer-most enclosing let-binding of this context, if there is one.ZxGet the set of value names defined at top-level, including top-level let-bindings and the top level type environment.[ Encode a context into a unique string. This is a name for a particlar program context, which is guaranteed to be from names of other contexts. This encoding can be used as a fresh name generator if you can base the names on the context they are created in.IJKLMNOPQRSTUVWXYZ[IJKLMNOPQRSTUVWXYZ[IJKLMNOPQRSTUVWXYZ[I JKLMNOPQRSTUVWXYZ[,Safe$(*-/09:;<=?DFMOTbNumber of levels to lift.Current binding depth.Lift exp indices in this thing.)Lifted, and how much to increase depth by\]^_12344312\]^_-Safe$(*-/09:;<=?DFMOTb`Apply a function to all possibly open types in a thing. Not the types of primitives because they're guaranteed to be closed. `abcdefgh`` `abcdefgh.Safe$(*-/09:;<=?DFMOTbi          i Safe$(*-/09:;<=?DFMOTbpVWXYZ[\]^_`abcdefghijklmnopqrs"#$%&'+,-./0123456789:;<=>AB?@CDEFGH'>?@ABCDEFGH:;<=8956701234+,-./"#$%&'&/Safe$(*-/09:;<=?DFMOTbkApply a function to all bound variables in the program. The function is passed the current binding depth. This is used to defined both m and o.l<Lift debruijn indices less than or equal to the given depth.m Wrapper for l that starts at depth 0. n=Lower debruijn indices less than or equal to the given depth.o Wrapper for n that starts at depth 0. jklNumber of levels to lift.Current binding depth.&Lift expression indices in this thing.mnNumber of levels to lower.Current binding depth.'Lower expression indices in this thing.oNumber of levels to lift.Current binding depth.Lift exp indices in this thing.)Lifted, and how much to increase depth bypqrstjklmnomlonjk jklmnopqrst`Safe$(*-/09:;<=?DFMOTbu=Things that can go wrong when checking data type definitions.v'A duplicate data type constructor name.w"A duplicate data constructor name.x.A data constructor with the wrong result type.uvwxyz{|uvwxyz{|uvwxyzz{|aSafe$(*-/09:;<=?DFMOTbbSafe$(*-/09:;<=?DFMOTb};Things that can go wrong when checking the kind of at type.~_Tried to check a type using the wrong universe, for example: asking for the kind of a kind.Generic kind mismatch.Cannot construct infinite type.An undefined type variable.-Found an unapplied kind function constructor.Found a naked sort constructor.An undefined type constructor.CA type application where the thing being applied is not a function.FA type application where the parameter and argument kinds don't match.MA witness implication where the premise or conclusion has an invalid kind.;A forall where the body does not have data or witness kind.5A type sum where the components have differing kinds.5A type sum that does not have effect or closure kind.&}~&}~}.~cSafe$(*-/09:;<=?DFMOTb6PAll the things that can go wrong when type checking an expression or witness.(Found a kind error when checking a type.,Found an error in the data type definitions.Exported value is undefined.)Exported name is exported multiple times.UType signature of exported binding does not match the type at the definition site.)Imported name is imported multiple times.6An imported capability that does not have kind Effect..An imported value that doesn't have kind Data.5Generic mismatch between expected and inferred types.An undefined type variable.>A data constructor that wasn't in the set of data definitions.DA function application where the parameter and argument don't match.0Tried to apply something that is not a function.,Cannot infer type of polymorphic expression.^A type abstraction that tries to shadow a type variable that is already in the environment.rAn abstraction where the body has a visible side effect that is not supported by the current language fragment.KA value function where the parameter does not have data or witness kind.6An abstraction where the body does not have data kind.BA function abstraction without a type annotation on the parameter.>A type abstraction without a kind annotation on the parameter.-A type abstraction parameter with a bad sort.YA let-expression where the type of the binder does not match the right of the binding.HA let-expression where the right of the binding does not have data kind.8A let-expression where the body does not have data kind.YA recursive let-expression where the right of the binding is not a lambda abstraction.7A recursive let-binding with a missing type annotation.PA recursive let-expression that has more than one binding with the same name.XA letregion-expression where the some of the bound variables do not have region kind.XA letregion-expression that tried to shadow some pre-existing named region variables.hA letregion-expression where some of the the bound region variables are free in the type of the body.NA letregion-expression that tried to create a witness with an invalid type.BA letregion-expression that tried to create conflicting witnesses.gA letregion-expression where a bound witnesses was not for the the region variable being introduced.SA witness application where the argument type does not match the parameter type.:Tried to perform a witness application with a non-witness.BA witness provided for a purify cast that does not witness purity.<A case-expression where the scrutinee type is not algebraic.ZA case-expression where the scrutinee type is not in our set of data type declarations.'A case-expression with no alternatives.[A case-expression where the alternatives don't cover all the possible data constructors.A case-expression where the alternatives don't cover all the possible constructors, and the type has too many data constructors to list.0A case-expression with overlapping alternatives.AA case-expression where one of the patterns has too many binders.pA case-expression where the pattern types could not be instantiated with the arguments of the scrutinee type.\A case-expression where the type of the scrutinee does not match the type of the pattern.xA case-expression where the annotation on a pattern variable binder does not match the field type of the constructor.RA case-expression where the result types of the alternatives are not identical.AA weakeff-cast where the type provided does not have effect kind.'A run cast applied to a non-suspension.CA run cast where the context does not support the suspended effect.A run cast where we cannot infer the type of the suspended computation and thus cannot check if its effects are suppored by the context.Found a naked G, that wasn't the argument of an application.Found a naked H, that wasn't the argument of an application.]]dSafe$(*-/09:;<=?DFMOTbeSafe$(*-/09:;<=?DFMOTbBuiltin name tokens.#Yield the string name of a Builtin.Scanner for builtin names.Accept a builtin name.  fSafe$(*-/09:;<=?DFMOTb *Check whether an expression is a variable. -Check whether an expression is a constructor. !Check whether an expression is a ? or an @#, or some type or witness atom. Check whether a witness is a , or -. <Check whether an expression is a spec abstraction (level-1).HCheck whether an expression is a value or witness abstraction (level-0).ECheck whether an expression is a spec, value, or witness abstraction."Check whether an expression is an C.(Check whether this is a cast expression.!Check whether this is a box cast.!Check whether this is a run cast.!Check whether an expression is a D."Check whether an expression is an G."Check whether an expression is an H."Check whether an alternative is a 6.     ' !"#$%&'()*+,-./0          gSafe$(*-/09:;<=?DFMOTb%Parameters of a function.1Take the outermost annotation from an expression.4Apply a function to the annotation of an expression.Make some nested type lambdas.*Make some nested value or witness lambdas. :Split type lambdas from the front of an expression, or * if there aren't any.!MSplit nested value or witness lambdas from the front of an expression, or * if there aren't any."Make some nested lambda abstractions, using a flag to indicate whether the lambda is a level-1 (True), or level-0 (False) binder.#Split nested lambdas from the front of an expression, with a flag indicating whether the lambda was a level-1 (True), or level-0 (False) binder.$"Take the parameters of a function.%%Build sequence of value applications.&.Build sequence of applications. Similar to %/ but also takes list of annotations for the C constructors.'@Flatten an application into the function part and its arguments.Returns *" if there is no outer application.(@Flatten an application into the function part and its arguments. This is like '6 above, except we know there is at least one argument.)EFlatten an application into the function parts and arguments, if any.*1Destruct sequence of applications. Similar to )& but also keeps annotations for later.+JFlatten an application of a primop into the variable and its arguments.Returns *. if the expression isn't a primop application.,WFlatten an application of a data constructor into the constructor and its arguments.Returns *3 if the expression isn't a constructor application.-,Wrap some let-bindings around an expression..IWrap some let-bindings around an expression, with individual annotations./;Split let-bindings from the front of an expression, if any.0ESplit let-bindings from the front of an expression, with annotations.1Take the binds of a :.8The level-1 and level-0 binders are returned separately.2Like 1* but only take the spec (level-1) binders.3Like 17 but only take the value and witness (level-0) binders.4#Take the pattern of an alternative.5=Take the constructor name of an alternative, if there is one.6Take the binds of a 5.7*Wrap an expression in the given number of run casts.8Construct a witness application9,Construct a sequence of witness applications:#Take the annotation from a witness.;Take the witness from an H argument, if any.<EFlatten an application into the function parts and arguments, if any.=[Flatten an application of a witness into the witness constructor name and its arguments.DReturns nothing if there is no witness constructor in head position.>Take the type from an G argument, if any.?Construct a value of unit type.( !"#$%&'()*+,-./0123456789:;<=>?t     ()* !"#$%&'()*+,-./0123456789:;<=>?% !"#$%&'()*+,-./0123456789:;<=>?0Safe$(*-/09:;<=?DFMOTb D Enter the body of a type lambda.E!Enter the body of a value lambda.F!Enter the left of an application.G"Enter the right of an application.H#Enter the body of a let-expression.IEnter the binding of a LLetJ Enter a binding of a LRec group.K)Enter the scrutinee of a case-expression.L"Enter the right of an alternative.MEnter the body of a cast@ABCDEFGHIJKLM@ABCDEFGHIJKLM@ABCDEFGHIJKLM @ABCDEFGHIJKLM*Safe$(*-/09:;<=?DFMOTb VWXYZ[\]^_`abcdefghijklmnopqrs      !"#$%&'()*+,-./0"#$%&'()*+,-./0123456789:;<=>AB?@CDEFGH      !"#$%&'()*+,-./0123456789:;<=>?a>?@ABCDEFGH:;<=8956701234+,-./"#$%&'&     " !#$%&'()*,+-./0123456789:;<=>?*()Safe$(*-/09:;<=?DFMOTbNMap of module names to modules.O6A module can be mutually recursive with other modules.QName of this module.RWhether this is a module header only. Module headers contain type definitions, as well as imports and exports, but no function definitions. Module headers are used in interface files.SKinds of exported types.TTypes of exported values.UDefine imported types.VDefine imported capabilities.WDefine imported values.X&Data defs imported from other modules.Y&Type defs imported from other modules.Z"Data types defined in this module.[ Type definitions in this module.\The module body consists of some let-bindings wrapping a unit data constructor. We're only interested in the bindings, with the unit being just a place-holder.]Check if this is the Main module.^2Get the data type definitions visible in a module._2Get the data type definitions visible in a module.`KGet the top-level kind environment of a module, from its imported types.aLGet the top-level type environment of a module, from its imported values.bExtract the top-level  environment from a module.This includes kinds for abstract types, data types, and type equations, but not primitive types which are fragment specific.cExtract the top-level " environment from several modules.dExtract the top-level  environment from a module.eExtract the top-level " environment from several modules.f4Get the set of top-level value bindings in a module.g5Get a map of named top-level bindings to their types.h_Apply a function to all the top-level bindings in a module, producing a list of the results.iHAdd the kind environment exported by all these modules to the given one.jHAdd the type environment exported by all these modules to the given one.NOPQRSTUVWXYZ[\]^_`abPrimitive kind environment.#Module to extract environemnt from.cPrimitive kind environment."Modules to build environment from.dPrimitive kind environment.Primitive type environment. Primitive data type definitions.#Module to extract environemnt from.ePrimitive kind environment.Primitive type environment. Primitive data type definitions."Modules to build environment from.fghijkB  !"#$NOPQRSTUVWXYZ[\]^_`abcdefghijCOPQRSTUVWXYZ[\]^_`abdcefghNij !"!#$ NO PQRSTUVWXYZ[\]^_`abcdefghijk1Safe$(*-/09:;<=?DFMOTbm=Apply the given function to every annotation in a core thing. mnopqrstumnomnomnopqrstu2Safe$(*-/09:;<=?DFMOTbwqSpread type annotations from binders and the environment into bound occurrences of variables and constructors. Also convert s to 9 form if the environment says that they are primitive.vwxyz{|}~vwvwvwxyz{|}~hSafe$(*-/09:;<=?DFMORTbOPretty print a binder, showing its type annotation only if it's not bottom.XWhen we pretty print witness binders, suppress the underscore when there is no name.,Print a group of binders with the same type.Wrap a 8$ in parens if the predicate is true.i9:;<=8>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~3Safe$(*-/09:;<=?DFMORTb)Pretty print an exported type definition.*Pretty print an exported value definition.Pretty print a type import.!Pretty print a capability import.Pretty print a value import.$Pretty print a data type definition.+Pretty print a data constructor definition.Pretty print a type definition.t9:;<=8>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe$(*-/09:;<=?DFMOTb!A token with a user-defined name.Atomic tokens are keywords, punctuation and baked-in constructor names. They don't contain user-defined names or primops specific to the language fragment.Pragmas.Symbols. Keywords.Builtin names.Infix operators, like in 1 + 2."Wrapped operator, like in (+) 1 2.Debrujn indices.Literal values.YMeta tokens contain out-of-band information that is eliminated before parsing proper.Comment string.This is injected by dropCommentBlock0 when it finds an unterminated block comment.This is injected by  applyOffside[ when it finds an explit close brace in a position where it would close a synthetic one.,Tokens accepted by the core language parser.1Some junk symbol that isn't part of the language.)The first part of an unterminated string.XMeta tokens contain out-of-band information that is eliminated before parsing proper.KAtomic tokens are keywords, punctuation and baked-in constructor names.jA named token that is specific to the language fragment (maybe it's a primop), or a user defined name.The family of a token. This is used to help generate parser error messages, so we can say ''the constructor Cons'' and ''the keyword case'' etc.3Describe a token family, for parser error messages.'Apply a function to all the names in a Tok.+Describe a token for parser error messages.-Describe a TokMeta, for lexer error messages. Describe a TokAtom, for parser error messages. Describe a TokNamed, for parser error messages.'Apply a function to all the names in a TokNamed.&  ~%&'()*+,-./0123456789:;<=>?@+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQwxyz{|}~~123456789:;<=>?@ABCDEFGHIJKLMNOP%&'()*+,-./0123456789:;<=>?wxyz{|}~Q@+,-./0   4Safe$(*-/09:;<=?DFMOTb  9What column number the current layout context started in. )Parenthesis that we're currently inside. KHolds a real token or start symbol which is used to apply the offside rule.2Signal that we're starting a block in this column.,Apply the offside rule to this token stream.iIt should have been processed with addStarts first to add the LexemeStartLine/LexemeStartLine tokens.Unlike the definition in the Haskell 98 report, we explicitly track which parenthesis we're inside. We use these to partly implement the layout rule that says we much check for entire parse errors to perform the offside rule./Add block and line start tokens to this stream.}This is identical to the definition in the Haskell98 report, except that we also use multi-token starting strings like imports foreign 'type'. 0Drop newline tokens at the front of this stream.0Drop newline tokens at the front of this stream.:Check if a token is one that starts a block of statements.(Test whether this wrapper token matches.(Test whether this wrapper token matches.eWhen generating new source tokens, take the position from the first non-newline token in this listThis is injected by [ when it finds an explit close brace in a position where it would close a synthetic one.  What parenthesis we're inside.Current layout context.Input lexemes.    5None$(*-/09:;<=?DFMOTbScanner for core tokens tokens.(Lex a module and apply the offside rule.@Automatically drop comments from the token stream along the way.Lex a string into tokens.@Automatically drop comments from the token stream along the way."Scanner for source and core files.The lexical structure for source and core is a bit different, but close enough that there's no point writing a separate lexer yet.(Path to source file, for error messages.Starting line number.String containing program text.(Path to source file, for error messages.Starting line number.String containing program text.5Name of source file, which is attached to the tokens.Starting line number.Text to tokenize.%&'()*+,-./0123456789:;<=>?@+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQwxyz{|}~iSafe$(*-/09:;<=?DFMOTb]jSafe$(*-/09:;<=?DFMOTbuvwxyz{|}~kSafe$(*-/09:;<=?DFMOTb(Language fragment compliance violations.&Found an unsupported language feature.&Found an undefined primitive operator.Found an unbound variable.kFound a variable binder that shadows another one at a higher scope, but the profile doesn't permit this.LFound a bound variable with no uses, but the profile doesn't permit this.:Found a naked type that isn't used as a function argument.=Found a naked witness that isn't used as a function argument.   lSafe$(*-/09:;<=?DFMOTb !Compliance checking monad.>Class of things we can check language fragment compliance for.ECheck whether a core thing complies with a language fragment profile.Like % but with some starting environments."2Check for compliance violations at a binding site.#`Check for compliance violations at a binding site. The binders must all be at the same level.$*Check the function part of an application.%?The top level context, used at the top-level scope of a module.&3Record that we've entered into an abstraction body.'DRecord that the expression is being directly applied to an argument.((Reset the argument counter of a context.)Throw an error in the monad.*#Take the result from a check monad.!+,-./0SFragment profile giving the supported language features and primitive operators.The thing to check.SFragment profile giving the supported language features and primitive operators.Starting kind environment.Starting type environment.The thing to check."The current language profile.The current environmentThe binder at this site.Names used under the binder.Names used above the binder.#$%&'()*123456!+,-./0"#$%&'()*123456None$(*-/09:;<=?DFMOTb gCarries all the information we need to work on a particular fragment of the Disciple Core language.#Language profile for this fragment.<File extension to use when dumping modules in this fragment. Read a name.RLex module source into tokens, given the source name and starting line number. ULex expression source into tokens, given the source name and starting line number.6Perform language fragment specific checks on a module.;Perform language fragment specific checks on an expression..Apply a function to the profile in a fragment. JABCDEFGHIJKLMNOPQRSJABCDEFGHIJKLMNOPQRSmNone$(*-/09:;<=?DFMOTbcStatic configuration for the type checker. These fields don't change as we decend into the tree.The starting configuration should be converted from the profile that defines the language fragment you are checking. See DDC.Core.Fragment and use  below.Kinds of primitive types.Types of primitive operators.Data type definitions.cThis name represents some hole in the expression that needs to be filled in by the type checker.Track effect type information.Track closure type information.,Attach effect information to function types.-Attach closure information to function types.Treat effects as capabilities.Allow general let-rec)Automatically run effectful applications.)Automatically box bodies of abstractions.;Convert a language profile to a type checker configuration. nNone$(*-/09:;<=?DFMOTbWConfiguration and information from the context. Used for context sensitive parsing.uCheck whether the given fragment includes literals of this sort, and convert it to the appropriate primitive name.Slurp an initital  from a language .oSafe$(*-/09:;<=?DFMORTb'3Synonym for Show constraints of all language types.Witness constructors.Witness constructors defined in the environment. In the interpreter we use this to hold runtime capabilities. The attached type must be closed. Witnesses.Witness variable.Witness constructor.Witness application.8Type can appear as an argument of a witness application. Type casts.#Weaken the effect of an expression.#Purify the effect of an expression.hBox up a computation, suspending its evaluation and capturing its effects in the S computaiton type.:Run a computation, releasing its effects into the context. Patterns.$The default pattern always succeeds.0Match a data constructor and bind its arguments.Case alternatives.Possibly recursive bindings.Non-recursive binding.Recursive binding.GIntroduce a private region variable and witnesses to its properties. Arguments.7Carries an argument that can be supplied to a function.Type argument.Value argument.Witness argument. Abstractions.GThis indicates what sort of object is being abstracted over in an XAbs.Level-1 abstraction (spec)'Level-0 abstraction (value and witness)'Generic term expression representation.An annotated expression.Primitive operator or literal. Data constructor. $Value or Witness variable (level-0). Function abstraction. Function application. Possibly recursive bindings.Case branching. Type casting.5Type functions associated with a language definition.nThese produce the types used for annotations, bindings, bound occurrences and primitives for that language.-     -           pSafe$(*-/09:;<=?DFMOTb *Check whether an expression is a variable.-Check whether an expression is a constructor.9Check whether an expression is an atomic value, eg an  ,  , or .-Check whether an argument is an atomic value,Check whether a witness is a  or ..Check whether an expression is an abstraction.<Check whether an expression is a spec abstraction (level-1).HCheck whether an expression is a value or witness abstraction (level-0)."Check whether an expression is an  .!Check whether an expression is a  . "Check whether an alternative is a .  # !"#$%&'()*+,-./0   qSafe$(*-/09:;<=?DFMORTb !Make some nested abstractions."QSplit type and value/witness abstractions from the front of an expression, or * if there aren't any.#Make some nested type lambdas.$:Split type lambdas from the front of an expression, or * if there aren't any.%*Make some nested value or witness lambdas.&MSplit nested value or witness lambdas from the front of an expression, or * if there aren't any.'Build sequence of applications.(vFlatten an application into the functional expression and its arguments, or `Nothing if this is not an application.)Flatten an application into a functional expression and its arguments, or just return the expression with no arguments if this is not an application.*bFlatten an application of a primitive operators into the operator itself and its arguments, or *1 if this is not an application of a primitive.+bFlatten an application of a data constructor into the constructor itself and its arguments, or *9 if this is not an application of a data constructor. !"#$%&'()*+W     ()*!"#$%&'()*+ !"#$%&'()*+rSafe$(*-/09:;<=?DFMORTb 75Synonym for Pretty constraints on all language types.8+Mode to use when pretty printing arguments.91Mode to use when pretty printing let expressions.:.Mode to use when pretty printing alternatives.;Use letcase) for single alternative case expressions.<9Insert a line or a space depending on a boolean argument.=Wrap a 8$ in parens, and indent it one level.>Wrap a 8$ in parens if the predicate is true.?cCheck if this is a simple expression that does not need extra spacing when being pretty printed.@aCheck if this is a simple argument that does not need extra spacing when being pretty printed.7ABCDEFG89:;<=>?@HIJKLMNOPQRSTGCAE9:;DB8F7<=>?@7<=>?@HIJLKABMONCDPRQEFTSG89:;7Safe$(*-/09:;<=?DFMOTb      !"#$%&'()*+,-./0()*      !"#$%&'()*+F      !"#$%&'()+**()sSafe$(*-/09:;<=?DFMOTb UThe type checker context.gHolds a position counter and a stack of elements. The top of the stack is at the front of the list.V Top level environment for terms.W+Fresh name generator for context positions.X/Fresh name generator for existential variables.YThe current context stack.ZTypes of solved existentials. When solved constraints are popped from the main context stack they are added to this map. The map is used to fill in type annotations after type inference proper. It's not used as part of the main algorithm.[An empty context.\Wrap an EnvT into a Context.]Wrap an  into a context.^'Build a context from prim environments._'Take the type equations from a context.`%Take the capabilities from a context.a%Take the capabilities from a context.b:Take the top level environment for types from the context.c6Push the type of some value variable onto the context.d!Push many types onto the context.e5Push the kind of some type variable onto the context.f!Push many kinds onto the context.gXPush an existential declaration onto the context. If this is not an existential then ,.h]Push the first existential into the context just before the declaration of the second one.i%Mark the context with a new position.j>Pop elements from a context to get back to the given position.kWGiven a bound level-0 (value) variable, lookup its type (level-1) from the context.lUGiven a bound level-1 (type) variable, lookup its kind (level-2) from the context.m0Lookup the type bound to an existential, if any.n,See if this type variable is in the context.o,See if this kind variable is in the context.p]See if the name on a named binder is in the contexts. Returns False for non-named binders.qGet the numeric location of an existential in the context stack, or Nothing if it's not there. Returned value is relative to the TOP of the stack, so the top element has location 0.r3Update (solve) an existential in the context stack.3If the existential is not part of the context then *.sBLift free debruijn indices in types by the given number of levels.tCLower free debruijn indices in types by the given number of levels.#UuVWXYZ[\]^_`abcdefghvijklmnopqrAOther existential declarations to add before the updated one.Existential to update. New monotype.stw"UuVWXYZ[\]^_`abcdefghvijklmnopqrstUuVWXYZ[\]^_`abcdefghvijklmnopqrstwtSafe$(*-/09:;<=?DFMOTbxApply a context to a type, updating any existentials in the type. This uses just the solved constraints on the stack, but not in the solved set.DIf we find a loop through the existential equations then return y2 the existential and what is was locally bound to.zLike x, but for the solved types.xType checker context..Indexes of existentials we've already entered.Type to apply context to.zType checker context..Indexes of existentials we've already entered.Type to apply context to.xzxzuSafe$(*-/09:;<=?DFMOTb{vCheck whether this effect is supported by the given context. This is used when effects are treated as capabilities.FThe overall function can be passed a compound effect, it returns *5 if the effect is supported, or `Just e`, where e" is some unsuported atomic effect.{{{vSafe$(*-/09:;<=?DFMOTb9UuVWXYZ[\]^_`abcdefghvijklmnopqrstxz{wNone$(*-/09:;<=?DFMOTb|!Check some data type definitions.}Check a data type definition.~?Check the data constructor definitions from a single data type.+Check a single data constructor definition.|Type equations.Names of existing data types.#Names of existing data constructor.Errors found so far.Checked data defs.Data defs still to check.}Environment of types.Names of existing data types.$Names of existing data constructors.Data type definition to check.~Environment of types$Names of existing data constructors.Errors found so far.)The DataDef these constructors relate to.Checked constructor defs. Constructor defs still to check.Environment of types.$Names of existing data constructors.&Def of data type for this constructor.Data constructor to check.||}~8Safe$(*-/09:;<=?DFMOTb .What level this binder is at.2#Describes how a variable was bound.<BA description of the binding structure of some type or expression.=An abstract binding expression.>Use of a variable.?Use of a constructor.@.Check if a boundlevel is expression or witnessAGet the . corresponding to a 2.BHelper for constructing the < for a type binder.C5Collect the free Spec variables in a thing (level-1).E\Collect all the bound variables in a thing, independent of whether they are free or not.F0Collect all the spec and exp binders in a thing.,-./0123456789:;<=>?@ABCDEF,-./0123456789:;<=>?@ABCDEF<=>?23456789:;./01,-@ABCDEF,-./012 3456789:;<=>?@ABCDEF9Safe$(*-/09:;<=?DFMOTbNACollect the free type variables and constructors used in a thing.O*Collect the free type variables in a type.MNOPQRMNOMNOMNOPQR:Safe$(*-/09:;<=?DFMOTbSACollect the free Data and Witness variables in a thing (level-0).THelper for constructing the <% for an expression or witness binder.STUVWXYSTSTSTUVWXY;Safe$(*-/09:;<=?DFMORTbZ[\]^^]\[ZZ[\]^<Safe$(*-/09:;<=?DFMOTbc)Type constructors used in the expression.dCType constructors used in the argument of a value-type application.e%Free spec variables in an expression.fCType constructors used in the argument of a value-type application.gGFree witness variables in an expression. (from the Witness universe)hBFree value variables in an expression. (from the Data universe)iGet a description of the type and value environment from a Support. Type (level-1) variables are tagged with True, while value and witness (level-0) variables are tagged with False._`abcdefghijklmnopqr _`abcdefghi abcdefgh_`i _`abcdefghijklmnopqrxSafe$(*-/09:;<=?DFMOTb#,-./0123456789:;<=>?CEFOS_`abcdefgh#COSEF<=>?23456789:;./01,-abcdefgh_`=Safe$(*-/09:;<=?DFMOTbv Wrapper for uo that determines the set of free names in the type being substituted, and starts with an empty binder stack.w Wrapper for u to substitute multiple things..Rewrite or substitute into a witness variable. tuvwxyz{tuvwtuvwtuvwxyz{>Safe$(*-/09:;<=?DFMOTb}Substitute a type into some thing. In the target, if we find a named binder that would capture a free variable in the type to substitute, then we rewrite that binder to anonymous form, avoiding the capture.~ Substitute a  for the  corresponding to a  in a thing. Wrapper for ~ to substitute multiple things. Substitute a  for  in some thing.|}~|}~~|}|}~?Safe$(*-/09:;<=?DFMOTb Substitute a  for the  corresponding to some  in a thing. Wrapper for ~ to substitute multiple types. Substitute a  for a  in some thing.  @Safe$(*-/09:;<=?DFMOTb Wrapper for substituteWithXu that determines the set of free names in the expression being substituted, and starts with an empty binder stack. Wrapper for  substituteX$ to substitute multiple expressions.bSubstitute the argument of an application into an expression. Perform type substitution for an G& and witness substitution for an H Wrapper for " to substitute multiple arguments.2Rewrite or substitute into an expression variable.  ASafe$(*-/09:;<=?DFMOTbOne component of a super call.Give a type to a type lambda.Give a value to a value lambda.Run a suspended computation.`One component of the call pattern of a super. This is the "outer wrapper" of the computation,With /(a : k). (x : t). box (x + 1) the call pattern consists of the two lambdas and the box. These three things need to be eliminated before we can construct any new values..A type lambda that needs a type of this kind./A value lambda that needs a value of this type.,A suspended expression that needs to be run.Check if this is an .Check if this is an .Check if this is an .&Get the call pattern of an expression.Infer the call pattern of an expression from its type. If the type has a function constructor then we assume there is a corresponding lambda abstraction in the expression, and so on.Like splitStdCallElim, but for the constructor side.Given the type of a super, and the number of type parameters, value parameters and boxings, produce the corresponding list of call constructors.Example:  takeStdCallConsFromType [| forall (a : k1) (b : k2). a -> b -> S e b |] 2 2 1 => [ ConsType [|k1|], ConsType [|k2|] , ConsValue [|a], ConsValue [|b|] , ConsBox ] lWhen we're considering the parts of the type, if the given arity does not match what is in the type then *.Check if this is an .Check if this is an .Check if this is an .%Apply an eliminator to an expression.ZSplit the application of some object into the object being applied and its eliminators.0Group eliminators into sets for a standard call.The standard call sequence is a list of type arguments, followed by some objects, and optionally running the result suspension. run f [T1] [T2] x1 x2If fa is a super, and this is a saturating call then the super header will look like the following: f = (t1. t2. v1. v2. box. body)Check if this an eliminator for the given constructor. This only checks the general form of the eliminator and constructor, not the exact types or kinds.Given lists of constructors and eliminators, check if the eliminators satisfy the constructors, and return any remaining unmatching constructors and eliminators.xWe assume that the application is well typed and that applying the given eliminators will not cause variable capture.Given a type of a function and eliminators, discharge foralls, abstractions and boxes to get the result type of performing the application.-We assume that the application is well typed. Type of superNumber of type parameters.Number of value parameters.Number of boxings.BSafe$(*-/09:;<=?DFMOTbdInstantiate a type with an argument. The type to be instantiated must have an outer forall, else *.Instantiate a type with several arguments. The type to be instantiated must have at least as many outer foralls as provided type arguments, else *.Type to instantiate.Argument type.Type to instantiate.Argument types.CSafe$(*-/09:;<=?DFMORTb ?A parser state that keeps track of the name of the source file.?A generic parser, parameterised over token and return types.8Run a generic parser, making sure all input is consumed.Accept the given token.6Accept the given token, returning its source position.*Accept a token and return the given value.[Accept a token and return the given value, along with the source position of the token.'Accept a token if the function returns . &Accept a token if the function return 7, also returning the source position of that token.0When we get a parse error, parsec adds multiple  Unexpected8 messages, but we only want to display the first one. Show a token.File name for error messages.Parser to run.Tokens to parse. ySafe$(*-/09:;<=?DFMOTb!A parser of core language tokens.3Parse a module name. %Parse a single component module name./Parse a qualified variable or constructor name.%Parse a constructor or variable name.Parse a constructor name.Parse a constructor name.Parse a literal..Parse a numeric literal, with source position.Parse a variable.'Parse a variable, with source position.>Parse a variable of a specific name, with its source position.Parse a deBruijn index.-Parse a deBruijn index, with source position.Parse an infix operator.+Parse an infix operator used as a variable.Parse a pragma.Parse a %.Parse a 1.Parse an atomic token.4Parse an atomic token, yielding its source position.,Parse an atomic token and return some value.;Parse an atomic token and return source position and value.zNone$(*-/09:;<=?DFMOTb  Parse a type.Parse a binder.Parse a quantified type.Parse a function type.Parse a type application.4Parse a variable, constructor or parenthesised type.!Parse a builtin sort constructor.!Parse a builtin kind constructor.!Parse a builtin type constructor.)Parse a builtin witness type constructor. &Parse a user defined type constructor.      {None$(*-/09:;<=?DFMOTb &Parse a type parameter to a data type. %Parse a data constructor declaration.   Name of data type constructor.)Type parameters of data type constructor.jklmno    |None$(*-/09:;<=?DFMOTb!Parse some export specifications.Parse an export specification."Parse a foreign value export spec.}None$(*-/09:;<=?DFMOTb An imported thing.During parsing the specifications of all imported things are bundled into this common type. The caller can split them out into separate buckets if it wants to.Foreign imported types.Foreign imported capabilities.Foreign imported values."Imported types from other modules..Imported data declarations from other modules.!Parse some import specifications.*Parse a foreign type import specification.0Parse a foreign capability import specification.Parse a type import.#Parse a value import specification."Parse a foreign value import spec. ~None$(*-/09:;<=?DFMOTbSpecification of a function parameter. We can determine the contribution to the type of the function, as well as its expression based on the parameter.mBuild the expression of a function from specifications of its parameters, and the expression for the body.`Build the type of a function from specifications of its parameters, and the type of the body.XParse a function parameter specification, with an optional type (or kind) annotation.XParse a function parameter specification, requiring a full type (or kind) annotation.Spec of parameters.Body of function.Expression of whole function.Spec of parameters. Type of body.Type of whole function.None$(*-/09:;<=?DFMOTbParse a witness expression.Parse a witness join.Parse a witness application. Parse a witness argument.7Parse a variable, constructor or parenthesised witness.!ZParse a variable, constructor or parenthesised witness, also returning source position. ! !None$(*-/09:;<=?DFMOTb !Parse a core language expression.Parse a function application.:Parse a variable, constructor or parenthesised expression."]Parse a variable, constructor or parenthesised expression, also returning source position.# Parse some :;, also returning the source position where they started.$A binding for let expression.%Parse a single statement.&Parse some statements.'(Make an expression from some statements.()*+,"-./#0$%&'"#()*+,"-./#0$%&'None$(*-/09:;<=?DFMOTb 1?Wrapper for a declaration that can appear in the module header.2Import specifications.3Export specifications.4Data type definitions.5Type equations.6XArity pragmas. Number of type parameters, value parameters, and boxes for some super.Parse a core module.7AParse one of the declarations that can appear in a module header.8Parse a type equation.9>Parse one of the pragmas that can appear in the module header. 1234567891234567896None$(*-/09:;<=?DFMOTb--DSafe$(*-/09:;<=?DFMOTb;Print an error message and exit the compiler, ungracefully.mThis function should be called when we end up in a state that is definately due to a bug in the compiler.  Package name,Function name.EError message that makes some suggestion of what caused the error.ESafe$(*-/09:;<=?DFMOTbKChecker monad maintains some state and manages errors during type checking.DRun a checker computation, returning the result and new state.<Run a checker computation, ignoreing the final state. Throw a type error in the monad.Get the state from the monad.Put a new state into the monad.  None$(*-/09:;<=?DFMOTb)Human readable trace of the type checker.:2Type checker monad. Used to manage type errors.;Allocate a new existential.<&Allocate a new context stack position.=$Apply the checker context to a type.>*Substitute solved constraints into a type.?"Append a doc to the checker trace. :;<=>?@ABCDEFGHIJKLM*NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvVWXYZ[\]^_`abcdefghijklmnopqrs      !"#$%&'()*+,-./0;<UVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{9:;<=8>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~$%&'()*"#$%&'()*+,-./0123456789:;<=>AB?@CDEFGHuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?UuVWXYZ[\]^_`abcdefghvijklmnopqrstxz{,-./0123456789:;<=>?CEFOS_`abcdefgh:;<=>? :;<=>?@ANone$(*-/09:;<=?DFMOTbw`Make two types equivalent to each other, or throw the provided error if this is not possible.wwwNone$(*-/09:;<=?DFMOTbxnMake the left type an instantiation of the right type, or throw the provided error if this is not possible.xxxNone$(*-/09:;<=?DFMOTb>Check a type returning its kind, or a kind returning its sort.The unverse of the thing to check is directly specified, and if the thing is not actually in this universe they you'll get an error.7We track what universe the provided kind is in for defence against transform bugs. Types like ([a : [b : Data]. b]. a -> a), should not be accepted by the source parser, but may be created by bogus program transformations. Quantifiers cannot be used at the kind level, so it's better to fail early.yLike 5 but do several, chaining the contexts appropriately.z?Synthesise the type of a kind function applied to its argument.Type checker configuration.Context of type to check.&What universe the type to check is in.)The type to check (can be a Spec or Kind)Type checker mode.yType checker configuration.Local context.(What universe the types to check are in.Type checker mode.The types to check.zyzNone$(*-/09:;<=?DFMOTb{gMake the left type a subtype of the right type, or throw the provided error if this is not possible.xThe inferred type may already be a subtype of the expected type, and in that case we don't need to do anything extra.OIf the inferred type is a 'S e a' computation type and the expected type is a then we can force the inferred type to be the expected one by running the computation. In this case we end up with more effects.{Type checker configuration.Current annotation.Input context.)Original expression, for error reporting.+Expression that we've inferred the type of. Inferred type of the expression. Expected type of the expression.-Error to throw if we can't force subsumption.{{None$(*-/09:;<=?DFMOTbCheck a witness.If it's good, you get a new version with types attached to all the bound variables, as well as the type of the overall witness.0If it's bad, you get a description of the error.[The returned expression has types attached to all variable occurrences, so you can call  on any open subterm.The kinds and types of primitives are added to the environments automatically, you don't need to supply these as part of the starting environments.Like $, but check in an empty environment.As this function is not given an environment, the types of free variables must be attached directly to the bound occurrences. This attachment is performed by  above.|Like  but using the : monad to manage errors.'Take the type of a witness constructor.Type checker configuration.Type checker environment.Witness to check.Type checker configuration.Type checker environment.Witness to check.|Type checker configuration.Type checker context.Witness to check.||None$(*-/09:;<=?DFMOTb}CTable of environment things that do not change during type checking~We've got the static config, global kind and type environments, and a type checking function for each node of the AST.2We split the type checker into separate functions and dispatch them via this table so we can handle each AST node in a separate module, while avoiding the explicit mutual recursion. If the functions were explicitly mutually recursive then we'd need to write GHC boot modules, which is annoying.~;Type of the function that checks some node of the core AST.8Demand placed on suspensions by the surrounding context.%Run suspensions as we encounter them.#Ignore suspensions, don't run them.Helper function for building the return value of checkExpM' It builts the AnTEC annotation and attaches it to the new AST node, as well as returning the current effect and closure in the appropriate form as part of the tuple.1If an expression has suspension type then run it.Check the type of a bind.}~Static configuration.Input context.Type checker mode.Demand on the expression.Expression to check.'Annotation for the returned expression.$Fn to build the returned expression.Type of expression.Effect sum of expression.Input context.Type checker config.Annotation for newDemand placed on expression.Expression to inspect.Type of the expression.Effect of the expression.Checker configuration. Type context."Universe for the type of the bind.Check this bind. Mode for bidirectional checking.>BCDEFGHIJKLM*NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvVWXYZ[\]^_`abcdefghijklmnopqrs      !"#$%&'()*+,-./0123456;<UVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{9:;<=8>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~$%&'()*"#$%&'()*+,-./0123456789:;<=>AB?@CDEFGHuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?mnoUuVWXYZ[\]^_`abcdefghvijklmnopqrstxz{,-./0123456789:;<=>?CEFOS_`abcdefgh|}~:;<=>?wx{|}~} ~None$(*-/09:;<=?DFMOTb\Decide what type checker mode to use when checking the discriminant of a case expression.HWith plain type reconstruction then we also reconsruct the discrim type.sWith bidirectional checking we use the type of the patterns as the expected type when checking the discriminant.Check some case alternatives.BCheck the inferred type for a field against any annotation for it.Get the constructor type associated with a pattern, or Nothing for the default pattern. If the data constructor isn't defined then the spread transform won't have given it a proper type. Note that we can't simply check whether the constructor is in theSGet the data type associated with a pattern, or Nothing for the default pattern.Yields the data type with outer quantifiers for its type parametrs. For example, given pattern (Cons x xs), return (forall [a : Data]. List a)ACheck for overlapping alternatives, and throw an error in the : monad if there are any.JCheck that the alternatives are exhaustive, and throw and error in the : monad if they're not.Checker table.Annotation for error messages.Current context.,Mode for checking enclosing case expression.$Alternatives in the case expression. Checker table.Annotation for error messages.*Whole case expression, for error messages.Type of discriminant.)Args to type constructor of discriminant. Check mode for the alternatives.)Demand on the result of the alternatives.Alternatives to check.%Context to check the alternatives in.Checker table."Use bi directional type inference.Annotation for error messages.)Whole case expression for error messages.&List of inferred and annotation types.Checker table.Type checker contextAnnotation for error messages.Pattern.Checker table.Type Checker context.Annotation for error messages.Pattern.Annotation for error messages.Expression for error messages.Alternatives to check.Annotation for error messages.Expression for error messages.DMode of data type. Tells us how many data constructors to expect.Alternatives to check.None$(*-/09:;<=?DFMOTb-Check a data constructor, returning its type.Type checker context.'The full expression for error messages.Annotation for error messages.Data constructor to check.None$(*-/09:;<=?DFMOTbDCheck some let bindings, and push their binders onto the context.6Check the annotations on a group of recursive binders.Check some recursive bindings. Doing this won't push any more bindings onto the context, though it may solve some existentials in it.Check that the given list of binds does not contain duplicates that would conflict if we added them to the environment at the same level. If so, then throw and error.<Take elements of a list that have more than once occurrence.Check that all the bindings in a recursive let are syntactic lambdas. We don't support value recursion, so can only define recursive functions. If one of the expression is not a lambda then throw an error.Use bidirectional inference.Expression for error messages.Static configuration.Input context.Demand placed on the bindings.Let-bindings to check.Use bidirectional checking.Annotation for error messages.Expression for error messages.Original context.Input binding group.Use bidirectional checking.Annotation for error messages.Original context.Demand placed on bindings.#Bindings and exps for rec bindings.Annotation for error messages.Expression for error messages.List of bindings to check.Annotation for error messages.Expression for error message.Expressions to check.None$(*-/09:;<=?DFMOTbECheck the set of witness bindings bound in a letregion for conflicts.Type checker config.Annotation for error messages.Context)The whole expression, for error messages.(Region variables bound in the letregion.'Other witness bindings in the same set.None$(*-/09:;<=?DFMOTbCApply the given expression to existentials to instantiate its type.vThe new existentials are inserted into the context just before the given one so that the context scoping works out.NStrip quantifiers from the front of a type, looking through any type synonyms.ISSUE #385: Make type inference work for non trivial type synonyms. If the synonym is higher kinded then we need to reduce the application. trying to strip the TForall.Annotation for new AST nodes.Current type checker context.%Add new existentials before this one.'Expression to add type applications to.Forall quantifiers.Body of the forall.None$(*-/09:;<=?DFMOTbCheck a spec application.KSynthesise the type of a polymorphic function applied to its type argument.None$(*-/09:;<=?DFMOTb%Check a value expression application.:Synthesize the type of a function applied to its argument.Split a function-ish type into its parts. This works for implications, as well as the function constructor with and without a latent effect.None$(*-/09:;<=?DFMOTb)Synthesize the type of a run computation.XCheck if the provided effect is supported by the context, if not then throw an error.Static config.Annotation for error messages.Expression for error messages.Input context.Effect to checkNone$(*-/09:;<=?DFMOTbNone$(*-/09:;<=?DFMOTbCheck a lambda abstraction.<Construct a function type with the given effect and closure.[Whether this is a witness or data abstraction depends on the kind of the parameter type.For data abstractions, the way the effect and closure is handled is set by the Config, which depends on the specific language fragment that we're checking. Type checker config.Annotation for error messages.Expression for error messages.!Binder of the function parameter.Parameter type of the function.Kind of the parameter.Body of the function.Result type of the function. Effect sum.None$(*-/09:;<=?DFMOTbdLookup the type of this data constructor from the context, or throw an error if we can't find it.None$(*-/09:;<=?DFMOTbNone$(*-/09:;<=?DFMOTbType check an expression.}If it's good, you get a new version with types attached every AST node, as well as every binding occurrence of a variable.0If it's bad, you get a description of the error.The kinds and types of primitives are added to the environments automatically, you don't need to supply these as part of the starting kind and type environment.Like 2, but only return the value type of an expression.Like  but using the : monad to handle errors.Static configuration.Environment of expression. Check mode. Demand placed on the expression.Expression to check.Static configuration.Environment of expresion.Expression to check.Static config.Input context. Check mode. Demand placed on the expression.Expression to check.3U[:}None$(*-/09:;<=?DFMOTb Type check a module.UIf it's good, you get a new version with types attached to all the bound variables0If it's bad, you get a description of the error.Like  but using the : monad to handle errors.Check exported types.Check exported types.Check kinds of imported types.oCheck kinds of data type definitions, returning a map of data type constructor constructor name to its kind.'Check kinds of imported type equations.%Check types of imported capabilities.Check types of imported values.ECheck that the exported signatures match the types of their bindings.JIf some bind is exported, then check that it matches the exported version.ICheck that an exported top-level value is actually defined by the module. Static configuration.Module to check.Type checker mode.Static configuration.Module to check.Type checker mode.Starting environment.Exported types.Exported values:Environment of top-level bindings defined by the moduleEnvironment of types.Exported types.Exported values.3Environment containing binds defined by the module.Name of an exported binding. )None$(*-/09:;<=?DFMOTbCheck a type in the given universe with the given environment Returns the updated type and its classifier (a kind or sort), depeding on the universe of the type being checked.FCheck a spec in the given environment, returning an error or its kind.ECheck a spec in an empty environment, returning an error or its kind.ECheck a kind in an empty environment, returning an error or its sort. !uvwxyz{|}~; !}~uvwxyzz{|FNone$(*-/09:;<=?DFMOTb 3Things that can go wrong when loading a core thing. /Parse and type check a core module from a file. 1Parse and type check a core module from a string. 4Parse and type check a core module from some tokens. 2Parse and type-check and expression from a string.UParse and check an expression returning it along with its spec, effect and closureGParse and check a type from a string, returning it along with its kind.JParse and check a type from some tokens, returning it along with its kind.JParse and check a witness from a string, returning it along with its kind.MParse and check a witness from some tokens, returning it along with its type.  Language fragment definition.File containing source code.Type checker mode. Language fragment definition.'Path to source file for error messages.(Starting line number for error messages.Type checker mode. Program text. Language fragment definition.'Path to source file for error messages.Type checker mode.Source tokens. Language fragment definition.MOther modules currently in scope. We add their exports to the environment.'Path to source file for error messages.Type checker mode.Source string.Language fragment definition.MOther modules currently in scope. We add their exports to the environment.'Path to source file for error messages.Type checker mode.Source tokens.Language fragment definition.(Universe this type is supposed to be in.'Path to source file for error messages.Source string.Language fragment definition.(Universe this type is supposed to be in.'Path to source file for error messages.Source tokens.Language fragment profile.'Path to source file for error messages.Source string.Language fragment profile.'Path to source file for error messages.Source tokens.                GGGGGGGJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNNNNNNNNNNNNNN      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aQbQc d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                          L M     V   Q R            !"#./01$%&'()*+,-./0123456789:;<=>?l@ABCDwEFGHIJKLMNrOPQR-SSTUVWXYZ[\]^_`abcdefghijklmnooppqrstuvwxyz{|}~UUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV45689:;VLMQR_J`\I  !!!!!!!!!!XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYY" " " " " " "#########L#M#####V####Q#R######$$$$$$$$$L$$M$$ $!$"$$$V$$$#$$$Q$R$%$&$'$($)$$%*%+%,%-%.%/&0'1'1' '2'3' '4'5'6'7(8(8(9(:(;(<(=(=(>(?(@(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^[^\^]^^^_^`^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_{_|_}_~_+++++++++++++++++++,,,,---------.///////////````````bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccc c c c c ccccccccccccccccccc c!c"c#c$c%c&c'c(c)c*c+c,c-c.c/c0c1c2c3c4e5e6e7e8e9e:e;e<e=f>f?f@fAfBfCfDfEfFfGfHfIfJfKfLgMgNgOgPgQgRgSgTgUgVgWgXgYgZg[g\g]g^g_g`gagbgcgdgegfggghgigjgkglgmgngogpgqgrgsgt0u0u0v0w0x0y0z0{0|0}0~0001111111112222222222223333333333344444444455kkkkkkk k lllmmmmmmmmmm m m m m mnununnnnnnooocoocodoeofoohoiojokoomonoopoorosotooooo o!o"o#o$o%owovo&ozo{o|o}o'o(o)o*oyoxp>p?p@p+pAp,pBpCpEpIpLq-q.q/qUq0qVq1q\q2q`qa838485868788898:8;8<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K8L8M8N8O8P8Q8R8S9T9U9V9W9X9Y:Z:[:\:]:^:_:`;a;b;c;d;e<f<g<h<h<i<j<k<l<m<n<o<p<q<r<s<t<u<v<w<x<y=z={=|=}=~===>>>>>>>>???????????@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAABBCCCCCCCCCCCCCCyyyyyyyyyyyyyyyyyyzzzz~~N~~O~~~~DEEEEEEEEEE))))FFFFFFFFFF F F F F FFFGGJJJKLLLLM O!O"O#O$O%O&O'O()*+,-./Q0123 4 5 678 912:;<=><=?<=@<=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<=[<=\<=]<=^<=_<=`<=a<=b<=c<=d<=e<=f<=g<=h<=i<=j<=k<=l<=m<=n<=o<=p<=q<=r<=L<=s<=t<=u<=v<=w<=x<=y<=z<={<=|<=}<=~<=<=<=<=<=<=<=<=<=<=<=TTTTTTTTUUUUUUVV     WWWWWWWWWYYY%%%%%[[[[[[[[[[[[[[[[[[[[[[[\]^______,,9--//9aaddeee22222hhhhhhhhhhhhhhhhhhhhhhhhhhhhhh3333334u444 4 4 4 4 44444444555iikllllllllll llulul!l"l#llll$l%l&r'r(rrrrrrrr)rrrrr*r+rrr,r-r.r/r0r1r2r3r4r5r6r7sus8s9s:s;s<s=s>s?s@sAsBsCsDsEsFsGsHsIsJsKsLsMsNsOsPsQsRsSsTsUsVsusWsXtYZ[t\u]w^w_w`wawb8c8d8e:f=g@hAijCkClCmCnCopqrpqspqtpqupqvpqwpqxpqypqzpq{pq|p}~p}p}p}p}p}p}p}p}p}p}p}p}p}p}pp}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}p}ppppppppppppppppppppppppppIppLpppppppppppp|ppyyyyyzzzzzzzz{{{|||||}}}}}}}}}}}}      !"#$%&'()*+,+-.!/!0!1!2!3!4!5!6!7!8!9!:!;!<+=>?>@>A>BCDEFEGEHEIEJEKELEMENOPQRSTUVWXYZ[\]^_`abcdefgchijklmnopqrstuvwxyz{|}~'ddc-core-0.4.3.1-A1OkYyS5JkUKWhaaKQoS5LDDC.Core.ModuleDDC.Core.Lexer.TokensDDC.Core.Fragment DDC.VersionDDC.Type.Exp.TyConDDC.Type.Exp.Simple.Exp DDC.Type.Bind DDC.Type.Sum DDC.Core.ExpDDC.Type.Exp.Simple.CompoundsDDC.Type.Exp.Simple.PredicatesDDC.Type.Transform.BoundT DDC.Type.EnvDDC.Type.DataDefDDC.Type.Transform.SpreadTDDC.Type.Exp.Generic.ExpDDC.Type.Exp.Generic.NFDataDDC.Type.Exp.Generic.PredicatesDDC.Type.Exp.Generic.BindingDDC.Type.Exp.Generic.CompoundsDDC.Type.Exp.Flat.ExpDDC.Data.PrettyDDC.Data.SourcePosDDC.Type.Exp.Generic.PrettyDDC.Type.Exp.Flat.PrettyDDC.Type.Exp.PrettyDDC.Type.Universe DDC.Data.NameDDC.Data.ListUtils DDC.Data.EnvDDC.Data.CannedDDC.Core.Lexer.UnicodeDDC.Core.Exp.LiteralDDC.Core.Exp.Annot.AnTDDC.Core.Env.EnvTDDC.Core.Env.EnvXDDC.Type.Exp.Simple.EquivDDC.Type.Exp.Simple.SubsumesDDC.Core.Exp.Annot.AnTECDDC.Type.Transform.RenameDDC.Core.CheckDDC.Core.Exp.AnnotDDC.Core.Exp.Annot.CtxDDC.Core.Transform.BoundTDDC.Core.Transform.MapTDDC.Core.Transform.RenameDDC.Core.Transform.BoundXDDC.Core.Exp.Annot.ContextDDC.Core.Transform.ReannotateDDC.Core.Transform.SpreadXDDC.Core.PrettyDDC.Core.Lexer.OffsideDDC.Core.LexerDDC.Core.ParserDDC.Core.Exp.GenericDDC.Core.Collect.BindStructDDC.Core.Collect.FreeTDDC.Core.Collect.FreeXDDC.Core.Exp.Generic.BindStructDDC.Core.Collect.SupportDDC.Core.Transform.SubstituteWXDDC.Type.Transform.SubstituteTDDC.Core.Transform.SubstituteTXDDC.Core.Transform.SubstituteXX DDC.Core.CallDDC.Type.Transform.InstantiateDDC.Control.ParserDDC.Control.PanicDDC.Control.Check DDC.Core.LoadDDC.Core.Module.NameM1.M2M3DDC.Core.Module.ImportDDC.Core.Module.ExportDDC.Core.Lexer.Token.SymbolDDC.Core.Lexer.Token.IndexDDC.Core.Fragment.FeatureDDC.Type.Exp.Simple.NFData DDC.Type.ExpDDC.Core.Exp.WiConDDC.Type.Exp.GenericDDC.Type.Exp.FlatDDC.Type.Exp.Simple.PrettyDDC.Core.Lexer.Token.NamesDDC.Core.Lexer.Token.KeywordDDC.Core.Lexer.Token.OperatorDDC.Core.Fragment.ProfileDDC.Core.Lexer.Token.LiteralDDC.Type.Exp.SimpleDDC.Core.Check.Context.ElemDDC.Core.Check.Context.ModeDDC.Core.Check.Judge.Kind.TyConDDC.Core.Exp.DaConDDC.Core.Exp.Annot.ExpDDC.Core.Check.Error.ErrorData%DDC.Core.Check.Error.ErrorDataMessageDDC.Core.Check.Error.ErrorTypeDDC.Core.Check.Error.ErrorExp%DDC.Core.Check.Error.ErrorTypeMessageDDC.Core.Lexer.Token.BuiltinDDC.Core.Exp.Annot.PredicatesDDC.Core.Exp.Annot.CompoundsDDC.Core.Exp.Annot.Pretty$DDC.Core.Check.Error.ErrorExpMessageDDC.Core.Check.ErrorDDC.Core.Fragment.ErrorDDC.Core.Fragment.ComplianceDDC.Core.Check.ConfigDDC.Core.Parser.ContextDDC.Core.Exp.Generic.ExpDDC.Core.Exp.Generic.PredicatesDDC.Core.Exp.Generic.CompoundsDDC.Core.Exp.Generic.PrettyDDC.Core.Check.Context.BaseDDC.Core.Check.Context.ApplyDDC.Core.Check.Context.EffectDDC.Core.Check.ContextDDC.Core.Check.Judge.DataDefsDDC.Core.CollectDDC.Core.Parser.BaseDDC.Core.Parser.TypeDDC.Core.Parser.DataDefDDC.Core.Parser.ExportSpecDDC.Core.Parser.ImportSpecDDC.Core.Parser.ParamDDC.Core.Parser.WitnessDDC.Core.Parser.ExpDDC.Core.Parser.ModuleDDC.Core.Check.BaseDDC.Core.Check.Judge.EqTDDC.Core.Check.Judge.InstDDC.Core.Check.Judge.KindDDC.Core.Check.Judge.SubDDC.Core.Check.Judge.WitnessDDC.Core.Check.Judge.Type.BaseDDC.Core.Check.Judge.Type.CaseDDC.Core.Check.Judge.Type.DaConDDC.Core.Check.Judge.Type.Let$DDC.Core.Check.Judge.Type.LetPrivateDDC.Core.Check.Judge.Type.SubDDC.Core.Check.Judge.Type.AppTDDC.Core.Check.Judge.Type.AppXDDC.Core.Check.Judge.Type.CastDDC.Core.Check.Judge.Type.LamTDDC.Core.Check.Judge.Type.LamX DDC.Core.Check.Judge.Type.VarCon!DDC.Core.Check.Judge.Type.WitnessDDC.Core.Check.ExpDDC.Core.Check.Judge.ModuleQualName ModuleNamereadModuleNameisMainModuleNamemoduleNameMatchesPath ImportValueImportValueModuleImportValueSeaimportValueModuleNameimportValueModuleVarimportValueModuleTypeimportValueModuleArityimportValueSeaVarimportValueSeaType ImportCapImportCapAbstractimportCapAbstractType ImportTypeImportTypeAbstractImportTypeBoxedimportTypeAbstractTypeimportTypeBoxedkindOfImportTypemapKindOfImportTypetypeOfImportCapmapTypeOfImportCaptypeOfImportValuemapTypeOfImportValue ExportSourceExportSourceLocalExportSourceLocalNoTypeexportSourceLocalNameexportSourceLocalTypetakeTypeOfExportSourcemapTypeOfExportSourceSymbol SRoundBra SRoundKet SSquareBra SSquareKet SBraceBra SBraceKetSSquareColonBraSSquareColonKetSBraceColonBraSBraceColonKetSBigLambdaSlash SArrowTildeSArrowDashRightSArrowDashLeft SArrowEqualsSAtSHatSDotSBarSCommaSEqualsSLambda SSemiColon SBackSlash SBigLambda SUnderscore saySymbolFeatureTrackedEffectsTrackedClosuresFunctionalEffectsFunctionalClosuresEffectCapabilities ImplicitRun ImplicitBox PartialPrimsPartialApplicationGeneralApplicationNestedFunctions GeneralLetRecDebruijnBindersUnboundLevel0VarsUnboxedInstantiation NameShadowingUnusedBindings UnusedMatchessplashversionTcCon TcConUnitTcConFun TcConSusp TcConRead TcConHeadRead TcConDeepRead TcConWriteTcConDeepWrite TcConAllocTcConDeepAllocTwCon TwConImpl TwConPure TwConConstTwConDeepConst TwConMutableTwConDeepMutable TwConDistinct TwConDisjointKiConKiConFun KiConWitness KiConData KiConRegion KiConEffect KiConClosureSoCon SoConProp SoConComp $fEqSoCon $fOrdSoCon $fShowSoCon $fEqKiCon $fOrdKiCon $fShowKiCon $fEqTwCon $fOrdTwCon $fShowTwCon $fEqTcCon $fOrdTcCon $fShowTcConTyCon TyConSort TyConKind TyConWitness TyConSpec TyConBound TyConExists TypeSumVarCon TypeSumVar TypeSumCon TyConHashTypeSum TypeSumBot TypeSumSet typeSumKind typeSumElemstypeSumBoundNamedtypeSumBoundAnon typeSumSpillClosureEffectRegionKindSortTypeTConTVarTAbsTAppTForallTSumBoundUIxUNameUPrimBindBNoneBAnonBNameBinderRNoneRAnonRName $fShowBinder $fEqTyConHash$fShowTyConHash$fOrdTyConHash $fIxTyConHash $fShowTyCon $fShowType $fShowTypeSum$fShowTypeSumVarCon $fShowBound $fShowBind getBindTypeempty singletoneleminsertdeleteunionunions difference kindOfSumtoListfromList hashTyConhashTyConRange unhashTyCon$fOrdTypeSumVarCon$fEqTypeSumVarCon $fOrdBound $fEqTypeSum$fEqType$fEqBind $fEqBound $fEqTyConWiCon WiConBoundtakeNameOfBind typeOfBindreplaceTypeOfBind binderOfBindmakeBindFromBinderpartitionBindsByTypetakeNameOfBoundtakeTypeOfBoundboundMatchesBindnamedBoundMatchesBindtakeSubstBoundOfBindtakeSubstBoundsOfBindsreplaceTypeOfBoundtIx takeTExiststBottApp$:tApps takeTApps takeTyConAppstakePrimTyConAppstakeDataTyConAppstakePrimeRegiontForalltForall'tForalls tForalls' takeTForalls eraseTForallstSumtUnitkFunkFunstakeKFun takeKFuns takeKFuns'takeResultKindtFuntFunOfParamResult tFunOfListtakeTFuntakeTFunArgResulttakeTFunWitArgResulttakeTFunAllArgResult arityOfTypedataArityOfTypetImpltSusp takeTSusp takeTSuspssCompsPropkDatakRegionkEffectkClosurekWitnesstRead tHeadRead tDeepReadtWrite tDeepWritetAlloc tDeepAlloctPuretConst tDeepConsttMutable tDeepMutable tDistinct tConData0 tConData1isBNoneisBAnonisBNameisTVarisBotisAtomT isTExists isDataKind isRegionKind isEffectKind isClosureKind isWitnessKind isAlgDataType isWitnessTypeisConstWitTypeisMutableWitTypeisDistinctWitType isFunishTCon isReadEffect isWriteEffect isAllocEffectisSomeReadEffectisSomeWriteEffectisSomeAllocEffect MapBoundTmapBoundAtDepthT liftAtDepthTliftT lowerAtDepthTlowerT$fMapBoundTTypeSumn$fMapBoundTTypen$fMapBoundTBoundn$fMapBoundTBindnTypeEnvKindEnvSuperEnvEnvenvMapenvStackenvStackLength envPrimFunextendextends setPrimFunisPrim fromListNT fromTypeMapmember memberBindlookup lookupNamedepthliftDataCtor dataCtorName dataCtorTagdataCtorFieldTypesdataCtorResultTypedataCtorTypeNamedataCtorTypeParamsDataType dataTypeNamedataTypeParams dataTypeModedataTypeIsAlgebraicDataMode DataModeSmall DataModeLargeDataDefs dataDefsTypes dataDefsCtorsDataDefdataDefTypeName dataDefParams dataDefCtorsdataDefIsAlgebraic kindOfDataDefdataTypeOfDataDefdataCtorNamesOfDataDefmakeDataDefAlgmakeDataDefAbstypeOfDataCtor emptyDataDefs unionDataDefs insertDataDeffromListDataDefslookupModeOfDataTypekindOfDataType$fMonoidDataDefs$fNFDataDataCtor$fNFDataDataDef$fShowDataMode$fShowDataType$fShowDataCtor$fShowDataDefs $fShowDataDefSpreadTspreadT$fSpreadTDataCtor$fSpreadTDataType$fSpreadTDataDefs$fSpreadTDataDef$fSpreadTTyCon$fSpreadTBound $fSpreadTBind$fSpreadTTypeSum $fSpreadTType ShowGTypeGTyCon TyConVoid TyConUnitTyConFun TyConUnionTyConBot TyConForall TyConPrimGTypeTAnnotGTPrim GTBoundCon GTBindCon GTBoundVar GTBindVarGTAnnotTPrimTUnionTBotTFunTUnitTVoidTApp5TApp4TApp3TApp2 $fShowGTyCon $fShowGType $fEqGTyCon $fEqGTypeNFDataLanguage$fNFDataGTyCon $fNFDataGTypeAnon withBinding withBindingsBinding boundOfBindtakeTContakeTVartakeTAbstakeTApp makeTAppsmakeTFun~> makeTFuns makeTFuns' takeTFuns takeTFuns' makeTForall makeTForalls takeTForall makeTExists takeTUnion makeTUnions takeTUnionssplitTUnionsOfKindFlat $fShowFlat RenderMode RenderPlain RenderIndentPretty PrettyModepprDefaultModepprpprPrec pprModePrecpprParenpadLrender renderPlain renderIndentputDocputDocLn $fPretty(,) $fPrettySet $fPretty[] $fPrettyChar$fPrettyInteger $fPrettyInt $fPrettyBool $fPretty()$fEqRenderMode$fShowRenderModeLocated SourcePossourcePosSource sourcePosLinesourcePosColumnsourcePosOfLocatedparsecSourcePosOfLocated nameOfLocated lineOfLocatedcolumnOfLocatedvalueOfLocated$fPrettySourcePos$fNFDataSourcePos $fEqSourcePos$fShowSourcePos $fEqLocated $fShowLocated PrettyConfigpprRawT pprRawPrecTpprRawC $fPrettyText $fPrettyTcCon $fPrettyTwCon $fPrettyKiCon $fPrettySoConUniverse UniverseLevel UniverseSort UniverseKind UniverseSpecUniverseWitness UniverseData universeUpuniverseFromType3universeFromType2universeFromType1universeOfType$fPrettyUniverse$fShowUniverse $fEqUniverse CompoundName extendName newVarName splitName StringName stringNametakeHeadtakeTailtakeInit takeMaximumindexfindDuplicates stripSuffix isVarName isVarStart isVarBody isConName isConStart isConBodyKeywordEModuleEImportEExportEForeignEType ECapabilityEValueEDataEWithEWhereEInELetELetCaseELetRecEPrivateEExtendEUsingECaseEOfEWeakEffEWeakCloEPurifyEForgetEBoxERunEDoEMatchEIfEThenEElse EOtherwise sayKeyword fromNameList fromNameMaplookupIx $fOrdBindCanned $fShowCannedunicodeOperatorsInfix $fShowUseLiteralLIntLNatLSizeLWordLFloatLCharLString $fEqLiteral $fShowLiteralFeaturesfeaturesTrackedEffectsfeaturesTrackedClosuresfeaturesFunctionalEffectsfeaturesFunctionalClosuresfeaturesEffectCapabilitiesfeaturesImplicitRunfeaturesImplicitBoxfeaturesPartialPrimsfeaturesPartialApplicationfeaturesGeneralApplicationfeaturesNestedFunctionsfeaturesGeneralLetRecfeaturesDebruijnBindersfeaturesUnboundLevel0VarsfeaturesUnboxedInstantiationfeaturesNameShadowingfeaturesUnusedBindingsfeaturesUnusedMatchesProfile profileNameprofileFeaturesprofilePrimDataDefsprofilePrimKindsprofilePrimTypesprofileTypeIsUnboxedprofileNameIsHoleprofileMakeLiteralNamemapFeaturesOfProfile zeroProfile zeroFeatures setFeature isLitName isLitStart isLitBodyreadLitInteger readLitNat readLitInt readLitSizereadLitWordOfBitsreadLitFloatOfBits readBinaryreadHexAnT annotType annotTail $fPrettyAnT $fNFDataAnT $fShowAnTEnvT envtPrimFun envtEquationsenvtCapabilitiesenvtMap envtStackenvtStackLength kindEnvOfEnvTEnvXenvxEnvT envxPrimFun envxDataDefsenvxMap envxStackenvxStackLength fromPrimEnvsextendXextendsXextendTextendsT kindEnvOfEnvX typeEnvOfEnvXmemberX memberBindXlookupTlookupX lookupNameXequivTequivWithBindsT equivTyCon crushHeadT crushSomeT crushEffect subsumesTAnTEC annotEffect annotClosurefromAnT $fPrettyAnTEC $fNFDataAnTEC $fShowAnTEC BindStack stackBindsstackAll stackAnons stackNamedSubsubBound subShadow0 subConflict1 subConflict0 subStack1 subStack0Rename renameWith pushBindspushBind substBoundbind1bind1sbind0bind0suse1use0 $fRenameBind$fRenameTypeSum $fRenameTypeModeReconSynthChecktakeSortOfKiCon kindOfTwCon kindOfTcConDaCon DaConUnit DaConPrim DaConBound daConName daConTypetakeNameOfDaContakeTypeOfDaCondcUnitWitnessWVarWConWAppWTypeCastCastWeakenEffect CastPurifyCastBoxCastRunPatPDefaultPDataAltAAltLetsLLetLRecLPrivateExpXVarXConXLAMXLamXAppXLetXCaseXCastXTypeXWitnessCtxCtxTopCtxLAMCtxLam CtxAppLeft CtxAppRight CtxLetBody CtxLetLLet CtxLetLRec CtxCaseScrut CtxCaseAlt CtxCastBodyctxEnvX isTopLetCtxtopOfCtxtakeEnclosingCtxtakeTopNameOfCtxtakeTopLetEnvNamesOfCtx encodeCtx$fMapBoundTAltn$fMapBoundTCastn$fMapBoundTWitnessn$fMapBoundTExpnmapT $fMapTmBound $fMapTmBind $fMapTmCast$fMapTmWitness $fMapTmPat $fMapTmAlt $fMapTmLets $fMapTmExp$fRenameWitness MapBoundXmapBoundAtDepthX liftAtDepthXliftX lowerAtDepthXlowerX$fMapBoundXAltn$fMapBoundXCastn$fMapBoundXWitnessn$fMapBoundXExpn$fMapBoundXBoundn ErrorDataErrorDataDupTypeNameErrorDataDupCtorNameErrorDataWrongResulterrorDataDupTypeNameerrorDataCtorNameerrorDataCtorResultActualerrorDataCtorResultExpected ErrorTypeErrorTypeUniverseMalfunctionErrorTypeMismatchErrorTypeInfiniteErrorTypeUndefinedErrorTypeUnappliedKindFunErrorTypeNakedSortErrorTypeUndefinedTypeCtorErrorTypeAppNotFunErrorTypeAppArgMismatchErrorTypeWitnessImplInvalidErrorTypeForallKindInvalidErrorTypeSumKindMismatchErrorTypeSumKindInvalid errorTypeTypeerrorTypeUniverseerrorTypeInferrederrorTypeExpectederrorTypeChecking errorTypeVar errorTypeBinderrorTypeBound errorTypeSorterrorTypeFunTypeerrorTypeFunTypeKinderrorTypeArgTypeerrorTypeFunKinderrorTypeArgKinderrorTypeLeftTypeerrorTypeLeftKinderrorTypeRightTypeerrorTypeRightKind errorTypeBody errorTypeKinderrorTypeKindExpectederrorTypeTypeSumerrorTypeKindserrorTypeCheckingSumErrorErrorExportUndefinedErrorExportDuplicateErrorExportMismatchErrorImportDuplicateErrorImportCapNotEffectErrorImportValueNotData ErrorMismatchErrorUndefinedVarErrorUndefinedCtorErrorAppMismatchErrorAppNotFunErrorAppCannotInferPolymorphicErrorLamShadowErrorLamNotPureErrorLamBindBadKindErrorLamBodyNotDataErrorLamParamUnannotatedErrorLAMParamUnannotatedErrorLAMParamBadSortErrorLetMismatchErrorLetBindingNotDataErrorLetBodyNotDataErrorLetrecBindingNotLambdaErrorLetrecMissingAnnotErrorLetrecReboundErrorLetRegionsNotRegionErrorLetRegionsReboundErrorLetRegionFreeErrorLetRegionWitnessInvalidErrorLetRegionWitnessConflictErrorLetRegionsWitnessOtherErrorWAppMismatchErrorWAppNotCtorErrorWitnessNotPurityErrorCaseScrutineeNotAlgebraic ErrorCaseScrutineeTypeUndeclaredErrorCaseNoAlternativesErrorCaseNonExhaustiveErrorCaseNonExhaustiveLargeErrorCaseOverlappingErrorCaseTooManyBindersErrorCaseCannotInstantiateErrorCaseScrutineeTypeMismatchErrorCaseFieldTypeMismatchErrorCaseAltResultMismatchErrorWeakEffNotEffErrorRunNotSuspensionErrorRunNotSupportedErrorRunCannotInferErrorNakedTypeErrorNakedWitnesserrorTypeError errorData errorNameerrorExportType errorDefType errorAnnot errorInferred errorExpected errorChecking errorBound errorUniverse errrorAnnoterrorParamType errorArgTypeerrorNotFunType errorBind errorEffect errorType errorKind errorSorterrorExp errorBinds errorKindserrorBindWitness1errorBindWitness2errorBoundRegionserrorBindWitness errorWitnesserrorTypeScrutineeerrorCtorNamesMissingerrorCtorDaConerrorCtorFieldserrorPatternFields errorTypeCtorerrorTypePatternerrorTypeAnnoterrorTypeField errorAltType1 errorAltType2BuiltinBSoConBKiConBTwConBTcConBPureBEmpty BDaConUnit sayBuiltinisXVarisXConisAtomXisAtomWisXLAMisXLam isLambdaXisXAppisXCast isXCastBox isXCastRunisXLetisXType isXWitness isPDefaultParam ParamType ParamValueParamBox annotOfExp mapAnnotOfExpxLAMsxLams takeXLAMs takeXLams makeXLamFlags takeXLamFlags takeXLamParamxAppsmakeXAppsWithAnnots takeXApps takeXApps1takeXAppsAsListtakeXAppsWithAnnots takeXPrimApps takeXConAppsxLets xLetsAnnot splitXLetssplitXLetsAnnot bindsOfLetsspecBindsOfLetsvalwitBindsOfLetspatOfAlttakeCtorNameOfAlt bindsOfPatmakeRunswAppwAppsannotOfWitness takeXWitnesstakeWAppsAsListtakePrimWiConApps takeXTypexUnitContext contextEnv contextCtxenterLAMenterLam enterAppLeft enterAppRight enterLetBody enterLetLLet enterLetLRecenterCaseScrut enterCaseAlt enterCastBody ModuleMapModule ModuleCore moduleNamemoduleIsHeadermoduleExportTypesmoduleExportValuesmoduleImportTypesmoduleImportCapsmoduleImportValuesmoduleImportDataDefsmoduleImportTypeDefsmoduleDataDefsLocalmoduleTypeDefsLocal moduleBody isMainModulemoduleDataDefsmoduleTypeDefs moduleKindEnv moduleTypeEnv moduleEnvT modulesEnvT moduleEnvX modulesEnvXmoduleTopBindsmoduleTopBindTypes mapTopBindsmodulesExportTypesmodulesExportValues$fNFDataModule $fShowModule Reannotate reannotate reannotateM$fReannotateWitness$fReannotateCast$fReannotateAlt$fReannotateLets$fReannotateExp$fReannotateModuleSpreadXspreadX$fSpreadXBound $fSpreadXBind$fSpreadXWiCon$fSpreadXWitness $fSpreadXLets $fSpreadXAlt $fSpreadXPat $fSpreadXCast $fSpreadXExp$fSpreadXModule pprExportTypepprExportValue pprImportTypepprImportValue pprDataDef pprDataCtor pprTypeDef$fPrettyDataCtor$fPrettyDataDef$fPrettyModule$fPrettyModuleName TokenNamedKConKVar TokenAtomKPragmaKSymbolKKeywordKBuiltinKOpKOpVarKIndexKLiteral TokenMetaKNewLineKCommentKCommentUnterminatedKOffsideClosingBraceToken KErrorJunk KErrorUntermKMKAKN renameToken describeTokendescribeTokenMetadescribeTokenAtomdescribeTokenNamed $fEqTokenMeta$fShowTokenMeta $fEqTokenAtom$fShowTokenAtom$fEqTokenNamed$fShowTokenNamed $fEqToken $fShowTokenLexeme LexemeTokenLexemeStartLineLexemeStartBlock applyOffside addStarts $fEqLexeme $fShowLexeme $fShowParenlexModuleWithOffsidelexExpErrorUnsupportedErrorUndefinedPrimErrorShadowedBindErrorUnusedBindCompliescompliescompliesWithEnvsFragmentfragmentProfilefragmentExtensionfragmentReadNamefragmentLexModulefragmentLexExpfragmentCheckModulefragmentCheckExpmapProfileOfFragment$fShowFragmentConfigconfigPrimKindsconfigPrimTypesconfigPrimDataDefsconfigNameIsHoleconfigTrackedEffectsconfigTrackedClosuresconfigFunctionalEffectsconfigFunctionalClosuresconfigEffectCapabilitiesconfigGeneralLetRecconfigImplicitRunconfigImplicitBoxconfigOfProfilecontextTrackedEffectscontextTrackedClosurescontextFunctionalEffectscontextFunctionalClosurescontextMakeLiteralNamecontextOfProfile ShowLanguageGWiConGWitnessGCastGPatGAltGLetsGArgRTypeRExpRWitnessGAbsALAMALamGExpXAnnotXPrimXAbsGPrimGBoundGBindGAnnotisAtomRisXAbsmakeXAbstakeXAbs makeXLAMs makeXLams makeXApps splitXApps BindStruct slurpBindTree BoundLevel BoundSpecBoundExpBoundWitBindWayBindTAbs BindForallBindLAMBindLamBindLet BindLetRecBindLetRegionsBindLetRegionWith BindCasePatBindTreeBindDefBindUseBindCon isBoundExpWitboundLevelOfBindWaybindDefTfreeT freeOfTreeT collectBound collectBinds $fEqBindWay $fShowBindWay$fEqBoundLevel$fShowBoundLevel $fEqBindTree$fShowBindTree FreeVarConT freeVarConT freeVarsT$fFreeVarConTType$fBindStructTyConn$fBindStructTypenfreeXbindDefX$fBindStructWitnessn$fBindStructAltn$fBindStructCastn$fBindStructExpn$fBindStructModulen$fBindStructGWitnessl$fBindStructGCastl$fBindStructGAltl$fBindStructGArgl$fBindStructGExplSupportXsupportSupport supportTyConsupportTyConXArg supportSpVarsupportSpVarXArg supportWiVar supportDaVarsupportEnvFlags$fSupportXBind$fSupportXLets$fSupportXCast$fSupportXWitness $fSupportXAlt $fSupportXExp$fSupportXModule$fSupportXType$fMonoidSupport $fShowSupport SubstituteWXsubstituteWithWX substituteWX substituteWXs$fSubstituteWXWitness$fSubstituteWXCast$fSubstituteWXAlt$fSubstituteWXExp SubstituteTsubstituteWithT substituteT substituteTssubstituteBoundT$fSubstituteTTypeSum$fSubstituteTType$fSubstituteTBind SubstituteTXsubstituteWithTX substituteTX substituteTXssubstituteBoundTX$fSubstituteTXType$fSubstituteTXBind$fSubstituteTXWitness$fSubstituteTXCast$fSubstituteTXAlt$fSubstituteTXExp SubstituteXXsubstituteWithXX substituteXX substituteXXssubstituteXArgsubstituteXArgs$fSubstituteXXCast$fSubstituteXXAlt$fSubstituteXXExpElimElimType ElimValueElimRunConsConsType ConsValueConsBox isConsType isConsValue isConsBoxtakeCallConsFromExptakeCallConsFromTypesplitStdCallConstakeStdCallConsFromTypeArity isElimType isElimValue isElimRun applyElim takeCallElimsplitStdCallElims elimForConsdischargeConsWithElimsdischargeTypeWithElims $fShowCons $fShowElim instantiateT instantiateTs ParserState ParseStatestateTokenShow stateFileNameParserrunTokenParserpTokpTokSPpTokAspTokAsSP pTokMaybe pTokMaybeSP$fPrettyMessage$fPrettyParseError pModuleNamepNamepConpConSPpLitpLitSPpVarpVarSPpIndexpIndexSPpOpSPpOpVarSPpSympKeypTypepBinderpTypeApp pTypeAtom ParamSpec ParamWitness expOfParamsfunTypeOfParamspBindParamSpecpBindParamSpecAnnotpWitness pWitnessApp pWitnessAtompExppExpApppExpAtompModulepanicCheckMrunCheck evalCheckthrowgetput $fMonadCheckM$fApplicativeCheckM$fFunctorCheckM CheckTrace checkTraceDoc checkTypeM checkWitness typeOfWitness typeOfWiConDemand DemandRun DemandNonecheckExp typeOfExp checkModule checkType checkSpec kindOfSpec sortOfKind ErrorRead ErrorParserErrorCheckType ErrorCheckExpErrorCompliance ErrorFragmentloadModuleFromFileloadModuleFromStringloadModuleFromTokensloadExpFromStringloadExpFromTokensloadTypeFromStringloadTypeFromTokensloadWitnessFromStringloadWitnessFromTokens $fPrettyError$fNFDataQualName$fNFDataModuleName$fNFDataImportValue$fNFDataImportCap$fNFDataImportType$fNFDataExportSourcebaseGHC.Real^GHC.Base. scanSymbol matchSymbol2 acceptSymbol2 acceptSymbol1 scanIndex $fNFDataTyCon$fNFDataTypeSumVarCon$fNFDataTyConHash$fNFDataTypeSum $fNFDataType $fNFDataBound $fNFDataBind$fNFDataBinderemptySetNothing hashTcConGHC.ErrerrortakeSumArrayElemmakeSumArrayElem $fNFDataWiConghc-prim GHC.TypesFalsetcCon1twCon1twCon2GHC.Num* countBAnonsInttakeTBot$wl-pprint-1.2-Kh8hiQGh95lIkosLx1aTQUText.PrettyPrint.LeijenDoc SimpleDocSEmptySCharSTextSLinewidthvsepvcattupledtextstringsquotessquotespacesoftline softbreaksep semiBracessemirparen renderCompactrbracketrbracerationalrangle punctuateparensnestingnestlparenlist linebreaklinelbracketlbracelangleintegerintindenthsephcathanghPutDocgroupfloatfillSepfillCat fillBreakfillequals encloseSepenclosedquotesdquotedoubledotdisplayS displayIOcommacolumncoloncharcatbracketsbracesbool backslashanglesalign<><+><$><$$> pprBinderSeppprBinderGroup $fPrettyTyCon$fPrettyTypeSum $fPrettyType $fPrettyBound$fPrettyBinder $fPrettyBind scanVarName matchVarName acceptVarName scanConName matchConName acceptConName scanKeyword acceptKeywordUseunicodeOperatorTableDeniedInfixPrefixscanPrefixOperatormatchPrefixOperatoracceptPrefixOperatorscanInfixOperatormatchInfixOperatoracceptInfixOperatorisOpName isOpStartisOpBody matchLiteral acceptLiteral scanLiteral checkBounds unpackSumT makeDeepRead makeDeepWrite makeDeepAllocElemElemPosElemKindElemTypeElemExistsDecl ElemExistsEqExistsRole RoleConcrete RoleAbstractPos typeOfExists takeExists slurpExiststakeExistsOfElem $fPrettyElem$fPrettyExists $fOrdExists $fEqExists $fPrettyRole $fPrettyPos $fPrettyModetakeKindOfTyCon $fNFDataDaCon$fNFDataWitness $fNFDataPat $fNFDataAlt $fNFDataLets $fNFDataCast $fNFDataExpmapBoundAtDepthTLetsMapTMAPTmapBoundAtDepthXLetsppr'$fPrettyErrorData$fPrettyErrorType scanBuiltin acceptBuiltinacceptTwConWithArityspreadExportSourceTspreadImportTypeTspreadImportCapXspreadImportValueX spreadDaCon pprPatBind pprWitBind pprParen'PrettyModeLets modeLetsExpmodeLetsSuppressTypes PrettyModeAlt modeAltExp PrettyModeExp modeExpLets modeExpAltmodeExpVarTypesmodeExpConTypesmodeExpUseLetCase pprBinder breakWhen isSimpleXparens' $fPrettyWiCon$fPrettyWitnessD:R:PrettyModeLets0 $fPrettyLets $fPrettyCast $fPrettyDaConD:R:PrettyModeAlt0 $fPrettyAlt $fPrettyPatD:R:PrettyModeExp0 $fPrettyExp pprImportCapPrettyModeModulemodeModuleLetsmodeModuleSuppressImportsmodeModuleSuppressExportsD:R:PrettyModeModule0 TokenFamilydescribeTokenFamilyrenameTokenNamed ConstructorIndexPragmadescribeTokenAtom'Paren dropNewLinesdropNewLinesLexemesplitBlockStartisToken isKNTokennewCBranewOffsideClosingBrace ParenRound ParenBrace isKeyword addStarts'newCKet newSemiColontakeTokScannerscannerlexText checkBind checkBinds checkFunction contextTopsetBodyaddArgresetresultcontextAbsBodycontextFunArgs compliesX $fCompliesAlt $fCompliesExp$fCompliesModulePrettyLanguage modeExpArg isSimpleR PrettyModeArg modeArgExp$fPrettyGWiCon$fPrettyGWitnessD:R:PrettyModeGLets0 $fPrettyGLets $fPrettyGCastD:R:PrettyModeGAlt0 $fPrettyGAlt $fPrettyGPatD:R:PrettyModeGArg0 $fPrettyGArgD:R:PrettyModeGExp0 $fPrettyGExp contextEnvX contextGenPoscontextGenExists contextElems contextSolved emptyContext contextOfEnvT contextOfEnvXcontextOfPrimEnvscontextEquationscontextCapabilitiescontextDataDefs contextEnvTpushType pushTypespushKind pushKinds pushExistspushExistsBefore markContextpopToPos lookupType lookupKindlookupExistsEq memberType memberKindmemberKindBindlocationOfExists updateExists liftTypes lowerTypespushExistsScope$fPrettyContextapplyContextEither Data.EitherLeftapplySolvedEithereffectSupported checkDataDefs checkDataDefcheckDataCtors checkDataCtorcheckDataDefs'collectBoundOfTreecollectSpecBindsOfTreecollectExpBindsOfTree freeOfTreeXsubstWsubstXinstantiateConsTJust packMessages PrettyMessagePrettyParseErrorD:R:PrettyModeMessage0D:R:PrettyModeParseError0$parsec-3.1.11-4YGM1rC8DTwKPt2nwbL11JText.Parsec.Pos SourceNameLineColumn sourceName sourceLine sourceColumn setSourceName setSourceLinesetSourceColumn incSourceLineincSourceColumnText.Parsec.PrimStreamunconsState stateInputstatePos stateUserReplyOkParsecTParsecConsumedEmptyText.Parsec.Error ParseError updateStateupdateParserState unknownError unexpectedtrytokens tokenPrimEx tokenPrimtokensysUnExpectErrorskipManysetState setPositionsetParserStatesetInput runParserT runParser runParsecTrunPTrunPputState parserZero parserReturn parserPlus parserFail parserBind parsecMap parseTestparse modifyStatemkPTmergeErrorReply manyAccummany lookAheadlabelslabelgetState getPositiongetParserStategetInput<|>errorPosText.Parsec.Combinator skipMany1 sepEndBy1sepEndBysepBy1sepByoptional optionMaybeoption notFollowedBymanyTillmany1eofendBy1endBycountchoicechainr1chainrchainl1chainlbetweenanyTokenText.Parsec.CharuppertabspacessatisfyoneOfoctDigitnoneOfnewlinelowerletterhexDigit endOfLinedigitcrlfanyCharalphaNum pModuleName1 pQualName pVarNamedSP pPragmaSP pTypeForallpTypeFunpSoConpKiConpTcConpTwCon pTyConNamedpTypeSum pDataParam pDataCtorpDataDef pExportSpecs pExportValuepExportForeignValue ExportSpec ExportValue ImportSpecImportForeignTypeImportForeignCapImportForeignValue ImportData pImportSpecspImportForeignTypepImportForeignCap pImportType pImportValuepImportForeignValue pWitnessJoin pWitnessArgSPpWitnessAtomSP pExpAtomSPpLetsSP pLetBindingpStmtpStmts makeStmtsStmtStmtBind StmtMatchStmtNonepArgSPspAltpPatpBindspLetWitsHeadDeclHeadImportSpecsHeadExportSpecs HeadDataDef HeadTypeDefHeadPragmaArity pHeadDeclpTypeDef pHeadPragma newExistsnewPos applyContext applySolvedctrace$fMonoidCheckTrace$fPrettyCheckTrace Control.MonadguardjoinMonadfail>>=>>returnFunctorfmapData.TraversablemapMsequenceMaybemfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMforM Data.Foldablemsum sequence_forM_mapM_ Data.Functorvoid Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybefromJust isNothingisJustmaybeapliftM5liftM4liftM3liftM2liftMwhen=<< MonadPlusmzerompluscontainers-0.5.7.1 Data.Set.BaseSetmakeEqTmakeInst checkTypesM synthTAppArgmakeSub checkWitnessMTableCheckerreturnX runForDemand checkBindM tableConfig tableCheckExptableCheckVarContableCheckAppTtableCheckAppXtableCheckLamTtableCheckLamX tableCheckLettableCheckLetPrivatetableCheckCasetableCheckCasttableCheckWitnessisHoleT$fPrettyDemandtakeDiscrimCheckModeFromAlts checkAltsMcheckFieldAnnots ctorTypeOfPat dataTypeOfPatcheckAltsOverlappingcheckAltsExhaustive checkCase checkDaConM checkLetsM checkRecBindscheckRecBindExpscheckNoDuplicateBindings duplicatescheckSyntacticLambdascheckLetcheckWitnessBindsMcheckLetPrivate addTypeAppsstripQuantifierscheckSub dequantifyshouldDequantifyX checkAppT synthAppArgT checkAppX synthAppArg splitFunType synthRunSuspcheckEffectSupported checkCast checkLamTcheckLAM checkLamX makeFunctioncheckLamcheckDaConType checkVarConcheckWit checkExpM makeTable checkModuleMcheckExportTypescheckExportValuescheckImportTypescheckSortsOfDataTypescheckKindsOfTypeDefscheckImportCapscheckImportValuescheckModuleBindscheckModuleBindcheckBindDefined