Cy      !"#$%&'()*+,-./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 U V W X Y Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~          !!!!!""""#$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%% % % & & ''''''''''''''''''' '!'"'#'$'%(&('((()(*(+,-./0123456789:;<=>?@A)B*C*D*E*F*GHIJK+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+{+|+}+~+++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,--...//00000000"""""""""""""""""""""" " " " " """"""""""""""""""" "!"""#"$"%"&"'"(")"*"+","-"."/"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"P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u1v1w1x1y1z1{1|1}1~11222223333444444""""""""""""5555555555555555s6Safe $&)*+34579>@GINZ:%Other constructors at the spec level.+The unit data type constructor is baked in.Pure function.A suspended computation.Read 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. Witness type constructors.Purity of some effect.Constancy of some region.*Constancy of material regions in some typeMutability of some region.,Mutability of material regions in some type.Distinctness of some n regions=Non-interfering effects are disjoint. Used for rewrite rules.Kind constructor.PFunction kind constructor. This is only well formed when it is fully applied.Kind of witnesses.Kind of data values.Kind of regions.Kind of effects.Kind of closures.Sort constructor.Sort of witness kinds.Sort of computation kinds.$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.0A map for named type variables.1#A map for anonymous type variables.27Types that can't be placed in the other fields go here.*INVARIANT: this list doesn't contain more =s.8A value type, kind, or sort.iWe use the same data type to represent all three universes, as they have a similar algebraic structure.9 Variable.: Constructor.; Abstraction.< Application.=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.A\Named primitive that has its type attached to it. The types of primitives must be closed.B A variable binder with its type.C8A variable with no uses in the body doesn't need a name.D(Nameless variable on the deBruijn stack.E"Named variable in the environment.I  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHII  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI    !"#$%&'()*+,.--/0123456789:;<=>?@ABCDEFGHI7Safe $&)*+34579>@GINZ  8Safe $&)*+34579>@GINZJHA fully qualified name, including the name of the module it is from.LA hierarchical module name.NRead a string like 9: as a module name.O4Check whether this is the name of the "Main" module.JKLMNOJKLMNOJKLMNO;Safe $&)*+34579>@GINZP)Language feature supported by a fragment.QTrack effect type information.RTrack closure type information.S(Attach latent effects to function types.T)Attach latent closures to function types.UTreat effects as capabilities.V5Insert implicit run casts for effectful applications.W5Insert implicit box casts for bodies of abstractions.X&Partially applied primitive operators.YPartially applied functionsZFunction application where the thing being applied is not a variable. Most backend languages (like LLVM) don't support this.[VNested function bindings. The output of the lambda-lifter should not contain these.\TRecursive let-expressions where the right hand sides are not lambda abstractions.]^Debruijn binders. Most backends will want to use real names, instead of indexed binders.^Allow data and witness vars without binding occurrences if they are annotated directly with their types. This lets us work with open terms._Allow non-primitive functions to be instantiated at unboxed types. Our existing backends can't handle this, because boxed and unboxed objects have different representations.`Allow name shadowing.a-Allow unused named data and witness bindings.bAllow unused named matches.PQRSTUVWXYZ[\]^_`abPQRSTUVWXYZ[\]^_`abPQRSTUVWXYZ[\]^_`abSafe $&)*+34579>@GINZ!Common use of a unicode operator.c&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.ccccSafe $&)*+34579>@GINZI  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ89:;<=67543+,.--/012)*&'( !"#$%  FGHIBCDE>?@ASafe $&)*+34579>@GINZd.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.e1Construct a type sum containing a single element.f.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.g Insert a new element into a sum.hDelete an element from a sum.iAdd two type sums.jUnion a list of + s together.k8Delete all members of the second sum from the first one.lTake the kind of a sum.m7Flatten out a sum, yielding a list of individual terms.nConvert a list of types to a +o Yield the ) of a , or  if there isn't one. Yield the ) of a  TyConBuiltin, or  if there isn't one.p,The range of hashes that can be produced by o.q 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 .defghijklmnopqdefghijklmnopqdeijgmnlfhkopqdefghijklmnopqSafe $&)*+34579>@GINZ3r_Take the variable name of a bind. If this is an anonymous binder then there won't be a name.sTake the type of a bind.t*Replace the type of a bind with a new one.uTake the binder of a bind.v'Make a bind from a binder and its type.w,Make lists of binds that have the same type.x[Take the name of bound variable. If this is a deBruijn index then there won't be a name.yGet the attached type of a > , if any.z)Check whether a bound maches a bind. @ and E' match if they have the same name. UIx 0 _ and BAnon _ always match. Yields , for other combinations of bounds and binds.{=Check whether a named bound matches a named bind. Yields / if they are not named or have different names.| Convert a B to a >, ready for substitution.Returns @ for E, UIx 0 for D and  for C(, because there's nothing to substitute.} Convert some Bs to Bounds~If this > is a AQ 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.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.3Build a nullary type constructor of the given kind.5Build a type constructor application of one argumnet.Lrstuvwxyz{|}~Irstuvwxyz{|}~Irstuvwxyz{|}~Lrstuvwxyz{|}~   <Safe $&)*+34579>@GINZ 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.Name of the data constructor.Type of the data constructor.2Data constructor that has a data type declaration.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 $&)*+34579>@GINZ*Describes a data constructor, used in the  table.Name of data constructor.3Tag of constructor (order in data type declaration)Field types of constructor.Result type of constructor.#Name of result type of constructor.Parameters of data type /Describes a data type constructor, used in the  table.Name of data type constructor.(Kinds of type parameters to constructor.4Names of data constructors of this data type, or ( if it has infinitely many constructors.#Whether the data type is algebraic.\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.iA table of data type definitions, unpacked into type and data constructors so we can find them easily.%The definition of a single data type.Name of the data type.Binders for type parameters.Constructors of the data type, or Nothing if the data type is algbraic but there are too many constructors to list (like with ).GWhether the data type is algebraic. These can be deconstructed with 'case' expressions.2Get the kind of the type constructor defined by a .cGet the type associated with a data definition, that is, the type produced by the constructors.kGet the list of data constructor names that this type defines, or Nothing if there are too many to list.Shortcut for constructing a  for an algebraic type.DValues of algebraic type can be deconstructed with case-expressions.Shortcut for constructing a  for an abstract type.FValues of abstract type cannot be deconstructed with case-expressions.Get the type of (An empty table of data type definitions. Union two  tables.1Insert a data type definition into some DataDefs.Build a  table from a list of DYield 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 .*Name of data type.Type parameters.,Constructor names and field types, or  if there are too many to list.''=Safe $&)*+34579>@GINZWitness constructors.Witness constructors defined in the environment. In the interpreter we use this to hold runtime capabilities. The attached type must be closed.Safe $&)*+34579>@GINZeWhen 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. Type casts.^Weaken the effect of an expression. The given effect is added to the effect of the body.,Purify the effect (action) of an expression.IBox up a computation, capturing its effects in the S computation type.ARun a computation, releasing its effects into the environment.Pattern matching.$The default pattern always succeeds.0Match a data constructor and bind its arguments.Case 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.Type abstraction (level-1).(Value and Witness abstraction (level-0). Application.Possibly recursive bindings.Case branching. Type cast. 2Type can appear as the argument of an application. 5Witness can appear as the argument of an application.$  o  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI  '      Safe $&)*+34579>@GINZ% 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  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.#ESplit let-bindings from the front of an expression, with annotations.$Take the binds of a .8The level-1 and level-0 binders are returned separately.%Like $* but only take the spec (level-1) binders.&Like $7 but only take the value and witness (level-0) binders.'#Take the pattern of an alternative.(=Take the constructor name of an alternative, if there is one.)Take the binds of a .**Wrap an expression in the given number of run casts.+Construct a witness application,,Construct a sequence of witness applications-#Take the annotation from a witness..Take the witness from an   argument, if any./EFlatten an application into the function parts and arguments, if any.0[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.1Take the type from an   argument, if any.2Construct a value of unit type.(    !"#$%&'()*+,-./012trstuvwxyz{|}~    !"#$%&'()*+,-./012+    !"#$%&'()*+,-./012%    !"#$%&'()*+,-./012 Safe $&)*+34579>@GINZ3Apply a function to all possibly open types in a thing. Not the types of primitives because they're guaranteed to be closed. 333 3 Safe $&)*+34579>@GINZ7Check whether a type is a 98"Test if some type is an empty TSum9Check whether a type is a 9, : 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 .A+Check whether type is a witness constructorB$Check whether this is the type of a Const witness.C$Check whether this is the type of a Mutable witness.D$Check whether this is the type of a Distinct witness.E,Check whether this is an atomic read effect.F-Check whether this is an atomic write effect.G-Check whether this is an atomic alloc effect.H@Check whether an effect is some sort of read effect. Matches Read HeadRead and DeepRead.IFCheck whether an effect is some sort of allocation effect. Matches Alloc and  DeepAllocJFCheck whether an effect is some sort of allocation effect. Matches Alloc and  DeepAlloc456789:;<=>?@ABCDEFGHIJ456789:;<=>?@ABCDEFGHIJ456789:;<=>?@ABCDEFGHIJ456789:;<=>?@ABCDEFGHIJ Safe $&)*+34579>@GINZK*Check whether an expression is a variable.L-Check whether an expression is a constructor.M!Check whether an expression is a  or an #, or some type or witness atom.NCheck whether a witness is a  or .O<Check whether an expression is a spec abstraction (level-1).PHCheck whether an expression is a value or witness abstraction (level-0).QECheck whether an expression is a spec, value, or witness abstraction.R"Check whether an expression is an .S(Check whether this is a cast expression.T!Check whether this is a box cast.U!Check whether this is a run cast.V!Check whether an expression is a .W"Check whether an expression is an  .X"Check whether an expression is an  .Y"Check whether an alternative is a .KLMNOPQRSTUVWXY&456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYKLMNOPQRSTUVYWXKLMNOPQRSTUVWXYSafe $&)*+34579>@GILNZ'Z3Synonym 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.a8Type can appear as an argument of a witness application.b Type casts.c#Weaken the effect of an expression.d#Purify the effect of an expression.ehBox up a computation, suspending its evaluation and capturing its effects in the S computaiton type.f:Run a computation, releasing its effects into the context.g Patterns.h$The default pattern always succeeds.i0Match a data constructor and bind its arguments.jCase alternatives.lPossibly recursive bindings.mNon-recursive binding.nRecursive binding.oDIntroduce a private region variable and witnesses to its properties.p Arguments.7Carries an argument that can be supplied to a function.qType argument.rValue argument.sWitness argument.t Abstractions.GThis indicates what sort of object is being abstracted over in an XAbs.uLevel-1 abstraction (spec)v'Level-0 abstraction (value and witness)w"Generic expression representation.xAn annotated expression.yPrimitive operator or literal.zData 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.-Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~-Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~-wxyz{|}~tuvpqrslmnojkghibcdef]^_`a[\ZZ[\]^_`abcdefghijklmnopqrstuvw xyz{|}~Safe $&)*+34579>@GILNZ 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. Wrstuvwxyz{|}~ Safe $&)*+34579>@GINZ *Check whether an expression is a variable.-Check whether an expression is a constructor.9Check whether an expression is an atomic value, eg an {, z, or y.-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 h. "456789:;<=>?@ABCDEFGHIJ  >None $&)*+34579>@GINZ}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. ]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK None $&)*+34579>@GILNZ 5Synonym for Pretty constraints on all language types.+Mode to use when pretty printing arguments.1Mode 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 <$ in parens, and indent it one level.Wrap a <$ 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.Safe $&)*+34579>@GINZ Type casts.^Weaken the effect of an expression. The given effect is added to the effect of the body.,Purify the effect (action) of an expression.JBox up a computation, capturing its effects in the S computation type.ARun a computation, releasing its effects into the environment.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.Pattern matching.$The default pattern always succeeds.0Match a data constructor and bind its arguments.Case alternatives.Possibly recursive bindings.!Non-recursive expression binding.)Recursive binding of lambda abstractions.ABind a local region variable, and witnesses to its properties.*Well-typed expressions have types of kind Data. Annotation.(Value variable or primitive operation.Data constructor or literal.Type abstraction (level-1).(Value and Witness abstraction (level-0). Application.Possibly recursive bindings.Case branching. Type cast.2Type can appear as the argument of an application.5Witness can appear as the argument of an application.&LMNOPQq  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI)  LMNOPQSafe $&)*+34579>@GINZMake 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.%Build sequence of value applications.@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.JFlatten an application of a primop into the variable and its arguments.Returns . if the expression isn't a primop application.XFlatten 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.;Split let-bindings from the front of an expression, if any.Take the binds of a .8The level-1 and level-0 binders are returned separately.Like * but only take the spec (level-1) binders.Like 7 but only take the value and witness (level-0) binders.=Take the constructor name of an alternative, if there is one.Take the binds of a .Construct a witness application,Construct a sequence of witness applicationsTake the witness from an  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  argument, if any.Construct a value of unit type.frstuvwxyz{|}~Safe $&)*+34579>@GINZ Convert the Simple version of the AST to the Annot; version, using a the provided default annotation value.RSTUVRSTUVSafe $&)*+34579>@GINZ Convert the Annot version of the AST to the SimpleO version, using the provided function to decide when to keep the annotation.WXYZ[WXYZ[Safe $&)*+34579>@GINZApply a function to all bound variables in the program. The function is passed the current binding depth. This is used to defined both  and .<Lift debruijn indices less than or equal to the given depth. Wrapper for  liftAtDepthX that starts at depth 0. =Lower debruijn indices less than or equal to the given depth. Wrapper for  lowerAtDepthX that starts at depth 0. NFunction to apply to the bound occ. It is passed the current binding depth.Current binding depth.&Lift expression indices in this thing.Number of levels to lift.Current binding depth.&Lift expression indices in this thing.Number of levels to lower.Current binding depth.'Lower expression indices in this thing.\]^_` \]^_`?Safe $&)*+34579>@GINZaNumber of levels to lift.Current binding depth.Lift exp indices in this thing.)Lifted, and how much to increase depth bybcdefabcdefSafe $&)*+34579>@GINZIStack 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 D in . Number of E 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.ghi               ghi@Safe $&)*+34579>@GINZj          jASafe $&)*+34579>@GINZ$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.kkBSafe $&)*+34579>@GINZ4Define a foreign value being imported into a module. 8Value imported from a module that we compiled ourselves.!-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.%,Value imported via the C calling convention.&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.+3Define a foreign 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.0Take the kind of an +.1#Apply a function to the kind of an +2Take the type of an (.3#Apply a function to the type in an ImportCapability.4#Take the type of an imported thing.5/Apply a function to the type in an ImportValue. !"#$%&'()*+,-./012345lmn !"#$%&'()*+,-./012345  %!"#$&'()*+,.-/012345lmnSafe $&)*+34579>@GINZ6lLookup 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.6666CSafe $&)*+34579>@GINZoTake the kind of a , if there is one.71Take the superkind of an atomic kind constructor.Yields U for the kind function (~>) as it doesn't have a sort without being fully applied.8,Take the kind of a witness type constructor.90Take the kind of a computation type constructor.o789o789o789None $&)*+34579>@GINZ:~The type checker for witnesses adds this annotation to every node in the, giving the type of each component of the witness.:;<=pq:;<=:;<=:;<=pqNone $&)*+34579>@GINZ>gThe type checker adds this annotation to every node in the AST, giving its type, effect and closure.D Promote an : to an >? by filling in the effect and closure portions with bottoms. >?@ABCDrs>?@ABCD>?@ABCD>?@ABCDrsSafe $&)*+34579>@GINZE$Type synonym to improve readability.F$Type synonym to improve readability.G$Type synonym to improve readability.HA type environment.JTypes of named binders.K$Types of anonymous deBruijn binders.LThe length of the above stack.M#Types of baked in, primitive names.NAn empty environment.O'Construct a singleton type environment.PmExtend an environment with a new binding. Replaces bindings with the same name already in the environment.QvExtend an environment with a list of new bindings. Replaces bindings with the same name already in the environment.R:Set the function that knows the types of primitive things.S.Check if the type of a name is defined by the M.TConvert a list of Bs to an environment.U1Convert a map of names to types to a environment.VCombine two environments. If both environments have a binding with the same name, then the one in the second environment takes preference.WICombine multiple environments, with the latter ones taking preference.X<Check whether a bound variable is present in an environment.YCheck whether a binder is already present in the an environment. This can only return True for named binders, not anonymous or primitive ones.Z,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.^gWrap locally bound (non primitive) variables defined in an environment around a type as new foralls.EFGHIJKLMNOPQRSTUVWXYZ[\]^EFGHIJKLMNOPQRSTUVWXYZ[\]^HIJKLMGFENOPQVWTU\XYZ[RS^]EFGHIJKLMNOPQRSTUVWXYZ[\]^Safe $&)*+34579>@GINZ_A one-hole context for .`The top-level context.dBody of a type abstraction.e'Body of a value or witness abstraction.fLeft of an application.gRight of an application.hBody of a let-expression.iVIn a non-recursive let-binding. We store the binder and body of the let expression.jIn a recursive binding.kScrutinee of a case expression.lIn a case alternative.mBody of a type castnyCheck if the context is a top-level let-binding. All bindings in the top-level chain of lets and letrecs are included.oGet the top level of a context.p4Take the enclosing context from a nested one, or " if this is the top-level context.qZTake the name of the outer-most enclosing let-binding of this context, if there is one.rxGet the set of value names defined at top-level, including top-level let-bindings and the top level type environment.s 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._`abcdefghijklmnopqrs_`abcdefghijklmnopqrs_`defghijklmabcnopqrs_`defghijklmabcnopqrsSafe $&)*+34579>@GINZ z Enter the body of a type lambda.{!Enter the body of a value lambda.|!Enter the left of an application.}"Enter the right of an application.~#Enter the body of a let-expression.Enter the binding of a LLet Enter a binding of a LRec group.)Enter the scrutinee of a case-expression."Enter the right of an alternative.Enter the body of a casttuvwxyz{|}~tuvwxyz{|}~tuvwxyz{|}~ tuvwxyz{|}~Safe $&)*+34579>@GINZRewrite @ bounds to A 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. tuvwxyz{| tuvwxyz{|DNone $&)*+34579>@GINZ-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.!Embed a literal string in a name.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 .Set a language Flag in the .""  None $&)*+34579>@GINZ (Universes of the Disciple Core language.:(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.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 }  }ENone $&)*+34579>@GINZ=Things that can go wrong when checking data type definitions.'A duplicate data type constructor name."A duplicate data constructor name..A data constructor with the wrong result type.;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....FNone $&)*+34579>@GINZ~~!Safe $&)*+34579>@GINZ Check equivalence of types.dChecks equivalence up to alpha-renaming, as well as crushing of effects and trimming of closures.Return  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,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.  Globally available capabilities.Type to crush.  GNone $&)*+34579>@GINZ+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.'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.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.The type checker context.gHolds a position counter and a stack of elements. The top of the stack is at the front of the list.+Fresh name generator for context positions./Fresh name generator for existential variables.The current context stack.Types 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 existential variable.6What 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. Synthesise the type of the expression, producing unification variables for bidirectional type inference.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.)Wrap an existential variable into a type.Take an Exists from a type.An empty context.6Push the type of some value variable onto the context.!Push many types onto the context.5Push the kind of some type variable onto the context.!Push many kinds onto the context.XPush an existential declaration onto the context. If this is not an existential then .%Mark the context with a new position.>Pop elements from a context to get back to the given position.WGiven a bound level-0 (value) variable, lookup its type (level-1) from the context.UGiven a bound level-1 (type) variable, lookup its kind (level-2) from the context.0Lookup the type bound to an existential, if any.,See if this type variable is in the context.,See if this kind variable is in the context.]See if the name on a named binder is in the contexts. Returns False for non-named binders.Get 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.3Update (solve) an existential in the context stack.3If the existential is not part of the context then .BLift free debruijn indices in types by the given number of levels.CLower free debruijn indices in types by the given number of levels.Apply 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 2 the existential and what is was locally bound to.Like , but for the solved types.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.6AOther existential declarations to add before the updated one.Existential to update. New monotype.Type checker context..Indexes of existentials we've already entered.Type to apply context to.Type checker context..Indexes of existentials we've already entered.Type to apply context to..%HNone $&)*+34579>@GINZThe type checker monad.Allocate a new existential of sort Comp. Kind inference is only useful for type variables of kind Comp, because we don't write functions that have polymorphic witness type variables.$Apply the checker context to a type.*Substitute solved constraints into a type.m      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIrstuvwxyz{|}~456789:;<=>?@ABCDEFGHIJ#Safe $&)*+34579>@GINZ1Check 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 .ISafe $&)*+34579>@GINZACollect the free type variables and constructors used in a thing.*Collect the free type variables in a type.$Safe $&)*+34579>@GINZ What level this binder is at.#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 witnessGet the  corresponding to a .Helper for constructing the  for a type binder.5Collect the free Spec variables in a thing (level-1).\Collect all the bound variables in a thing, independent of whether they are free or not.0Collect all the spec and exp binders in a thing.%Safe $&)*+34579>@GINZSubstitute 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 8 for the > corresponding to a B in a thing.  Wrapper for  to substitute multiple things.  Substitute a 8 for > in some thing.+Bound variable that we're subsituting into.Type to substitute.2Names of free varaibles in the type to substitute. Bind stack.        &Safe $&)*+34579>@GINZ dInstantiate 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.      JSafe $&)*+34579>@GINZ   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIrstuvwxyz{|}~      !"#$%&'()*+,-./012456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYa  KLMNOPQRSTUVYWX    !"#$%&'()*+,-./012'Safe $&)*+34579>@GINZ One 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. !"#$  !"#$  !"#$  !"#$KSafe $&)*+34579>@GINZo  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI  (Safe $&)*+34579>@GINZ&Apply a function to all bound variables in the program. The function is passed the current binding depth. This is used to defined both ( and *.'<Lift debruijn indices less than or equal to the given depth.( Wrapper for ' that starts at depth 0. )=Lower debruijn indices less than or equal to the given depth.* Wrapper for ) that starts at depth 0. %&NFunction to apply to the bound occ. It is passed the current binding depth.Current binding depth.&Lift expression indices in this thing.'Number of levels to lift.Current binding depth.&Lift expression indices in this thing.()Number of levels to lower.Current binding depth.'Lower expression indices in this thing.*Number of levels to lift.Current binding depth.Lift exp indices in this thing.)Lifted, and how much to increase depth by%&'()*('*)%& %&'()*Safe $&)*+34579>@GINZ+Map of module names to modules.,6A module can be mutually recursive with other modules..Name of this module./Whether 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.0Kinds of exported types.1Types of exported values.2Define imported types.3Define imported capabilities.4Define imported values.5&Data defs imported from other modules.6"Data types defined in this module.7The 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.8Check if this is the Main module.92Get the data type definitions visible in a module.:KGet the top-level kind environment of a module, from its imported types.;LGet the top-level type environment of a module, from its imported values.<4Get the set of top-level value bindings in a module.=5Get a map of named top-level bindings to their types.>_Apply a function to all the top-level bindings in a module, producing a list of the results.?HAdd the kind environment exported by all these modules to the given one.@HAdd the type environment exported by all these modules to the given one.+,-./0123456789:;<=>?@:JKLMNO !"#$%&'()*+,-./012345+,-./0123456789:;<=>?@;,-./0123456789:;<=>+?@LMNOJK+,.-/01()*23 %!"#$&'45 +, -./0123456789:;<=>?@LSafe $&)*+34579>@GINZAACollect the free Data and Witness variables in a thing (level-0).Helper for constructing the % for an expression or witness binder.AAA*Safe $&)*+34579>@GILNZBCDEFFEDCBBCDEFMSafe $&)*+34579>@GINZNone $&)*+34579>@GILNZ G)Pretty print an exported type definition.H*Pretty print an exported value definition.IPretty print a type import.!Pretty print a capability import.JPretty print a value import.OPretty 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 <$ in parens if the predicate is true.,GHIJp      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKGHIJGHIJGHIJ+None $&)*+34579>@GINZK!A token with a user-defined name.OAtomic tokens are keywords, punctuation and baked-in constructor names. They don't contain user-defined names or primops specific to the language fragment.PLike '('QLike ')'RLike '['SLike ']'TLike '{'ULike '}'V Like '[:'W Like ':]'X Like '{:'Y Like ':}'Z Naked operator, like in 1 + 2.["Wrapped operator, like in (+) 1 2.YMeta tokens contain out-of-band information that is eliminated before parsing proper.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 .+Describe a token for parser error messages.-Describe a TokMeta, for lexer error messages. Describe a O, for parser error messages. Describe a K, for parser error messages.'Apply a function to all the names in a K.fKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     \KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~\OPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~KLMN KLMNOEPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     ,None $&)*+34579>@GINZ&Textual keywords in the core language.Read a named sort constructor.Read a named kind constructor.&Read a named witness type constructor.DRead a builtin type constructor with a non-symbolic name. ie not '->'.String is a variable name#Charater can start a variable name.)Character can be part of a variable body.$Read a named, user defined variable.String is a constructor name.'Character can start a constructor name.+Charater can be part of a constructor body.Read a named, user defined .$String is the name of some operator. Character can start an operator.*Character can be part of an operator body. String is the name of a literal.Character can start a literal.(Character can be part of a literal body.NNone $&)*+34579>@GINZ 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. !"# !"#ONone $&)*+34579>@GINZ$8Drop all the comments and newline tokens in this stream.%(Drop block comments form a token stream.&#Drop newline tokens from this list.$%+Position of outer-most block comment start.&'$&$%&'-None $&)*+34579>@GINZ(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.(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.qKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(PNone $&)*+34579>@GINZ(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. )).Safe $&)*+34579>@GINZ=Apply the given function to every annotation in a core thing. *+,-./*+,-.//Safe $&)*+34579>@GINZqSpread type annotations from binders and the environment into bound occurrences of variables and constructors. Also convert >s to A9 form if the environment says that they are primitive.0123456789:;<=>0123456789:;<=>QNone $&)*+34579>@GINZ ?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.A`Check for compliance violations at a binding site. The binders must all be at the same level.B*Check the function part of an application.C?The top level context, used at the top-level scope of a module.D3Record that we've entered into an abstraction body.EDRecord that the expression is being directly applied to an argument.F(Reset the argument counter of a context.GThrow an error in the monad.H#Take the result from a check monad.?IJKLMNSFragment profile giving the supported language features and primitive operators.Starting Kind environment.Starting Type environment.SFragment 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.ABCDEFGHOPQRST?IJKLMN@ABCDEFGHOPQRSTNone $&)*+34579>@GINZ 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. UJPQRSTUVWXYZ[\]^_`abJPQRSTUVWXYZ[\]^_`abURNone $&)*+34579>@GINZWConfiguration and information from the context. Used for context sensitive parsing.Slurp an initital  from a language .SNone $&)*+34579>@GINZcStatic 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.)Types of globally available capabilities.The inferred types of computations do not contain these capabilities as they are always available and thus do not need to be tracked in types.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.TNone $&)*+34579>@GINZV!Check some data type definitions.WCheck a data type definition.X?Check the data constructor definitions from a single data type.Y+Check a single data constructor definition.VZNames of existing data types.#Names of existing data constructor.Errors found so far.Checked data defs.Data defs still to check.WNames of existing data types.$Names of existing data constructors.Data type definition to check.X$Names of existing data constructors.Errors found so far.)The DataDef these constructors relate to.Checked constructor defs. Constructor defs still to check.Y$Names of existing data constructors.&Def of data type for this constructor.Data constructor to check.VVZWXYUNone $&)*+34579>@GINZ[`Make two types equivalent to each other, or throw the provided error if this is not possible.[[[VNone $&)*+34579>@GINZ>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.\Like 5 but do several, chaining the contexts appropriately.]?Synthesise the type of a kind function applied to its argument.Type checker configuration.Top-level kind environment.Local context.&What universe the type to check is in.)The type to check (can be a Spec or Kind)Type checker mode.\Type checker configuration.Top-level kind environment.Local context.(What universe the types to check are in.Type checker mode.The types to check.]\]None $&)*+34579>@GINZCheck 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.F789P789WNone $&)*+34579>@GINZ6PAll 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.0SA witness application where the argument type does not match the parameter type.2:Tried to perform a witness application with a non-witness.3BA witness provided for a purify cast that does not witness purity.4<A case-expression where the scrutinee type is not algebraic.6ZA case-expression where the scrutinee type is not in our set of data type declarations.7'A case-expression with no alternatives.8[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.B\A case-expression where the type of the scrutinee does not match the type of the pattern.DxA case-expression where the annotation on a pattern variable binder does not match the field type of the constructor.GRA case-expression where the result types of the alternatives are not identical.JAA weakeff-cast where the type provided does not have effect kind.K'A run cast applied to a non-suspension.LCA run cast where the context does not support the suspended effect.MA run cast where we cannot infer the type of the suspended computation and thus cannot check if its effects are suppored by the context.NFound a naked  , that wasn't the argument of an application.OFound a naked  , that wasn't the argument of an application.]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO   "#$'()*-0234678:;<@BDGJKLMNO   !!%&%%+,./1  1 1559=>?5A5CEFHI!XNone $&)*+34579>@GINZ^]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO^YNone $&)*+34579>@GINZP!A parser of core language tokens.Q3Parse a module name. _%Parse a single component module name.`/Parse a qualified variable or constructor name.R%Parse a constructor or variable name.SParse a constructor name.TParse a constructor name.UParse a literal.V.Parse a numeric literal, with source position.WParse a literal.X-Parse a literal string, with source position.YParse a variable.Z'Parse a variable, with source position.a>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.bParse a pragma._Parse an atomic token.`4Parse an atomic token, yielding its source position.a,Parse an atomic token and return some value.c;Parse an atomic token and return source position and value.PQ_`RSTUVWXYZa[\]^b_`acPQ`RSTUVWXYZa[\]^b_`acPQ_`RSTUVWXYZa[\]^b_`acZNone $&)*+34579>@GINZ b Parse a type.cParse a binder.dParse a quantified type.eParse a function type.dParse a type application.e4Parse a variable, constructor or parenthesised type.f!Parse a builtin sort constructor.g!Parse a builtin kind constructor.h!Parse a builtin type constructor.i)Parse a builtin witness type constructor.j&Parse a user defined type constructor. bkcdedefghij[_abcde bkcdedefghij[None $&)*+34579>@GINZfParse a witness expression.lParse a witness join.gParse a witness application.mParse a witness argument.h7Parse a variable, constructor or parenthesised witness.nZParse a variable, constructor or parenthesised witness, also returning source position.flgmhnfghflgmhn\None $&)*+34579>@GINZiSpecification of a function parameter. We can determine the contribution to the type of the function, as well as its expression based on the parameter.mmBuild the expression of a function from specifications of its parameters, and the expression for the body.n`Build the type of a function from specifications of its parameters, and the type of the body.oXParse a function parameter specification, with an optional type (or kind) annotation.pXParse a function parameter specification, requiring a full type (or kind) annotation.ijklmSpec of parameters.Body of function.Expression of whole function.nSpec of parameters. Type of body.Type of whole function.opijklmnopijklmnop]None $&)*+34579>@GINZ q!Parse a core language expression.rParse a function application.s:Parse a variable, constructor or parenthesised expression.o]Parse a variable, constructor or parenthesised expression, also returning source position.p Parse some ;, also returning the source position where they started.qA binding for let expression.rParse a single statement.sParse some statements.t(Make an expression from some statements.uvwxqrysoz{|p}qrstbdeqrsopuvwxqrysoz{|p}qrst^None $&)*+34579>@GINZ~&Parse a type parameter to a data type.%Parse a data constructor declaration.~Name of data type constructor.)Type parameters of data type constructor.~_None $&)*+34579>@GINZ!Parse some export specifications.Parse an export specification."Parse a foreign value export spec.`None $&)*+34579>@GINZAn 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.!Parse some import specifications.*Parse a foreign type import specification.0Parse a foreign capability import specification.#Parse a value import specification."Parse a foreign value import spec. aNone $&)*+34579>@GINZ?Wrapper for a declaration that can appear in the module header.FNumber of type parameters, value parameters, and boxes for some super.tParse a core module.AParse one of the declarations that can appear in a module header.>Parse one of the pragmas that can appear in the module header.ttt0None $&)*+34579>@GINZ-PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst-PbdetQqrsijklnmpofghSTUVWX[\YZcR]^_`a1Safe $&)*+34579>@GINZy)Type constructors used in the expression.zCType constructors used in the argument of a value-type application.{%Free spec variables in an expression.|CType constructors used in the argument of a value-type application.}GFree witness variables in an expression. (from the Witness universe)~BFree value variables in an expression. (from the Data universe)Get 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.uvwxyz{|}~ uvwxyz{|}~ wxyz{|}~uv uvwxyz{|}~)Safe $&)*+34579>@GINZAuvwxyz{|}~Awxyz{|}~uv2Safe $&)*+34579>@GINZ Substitute a 8 for the > corresponding to some B in a thing. Wrapper for  to substitute multiple types. Substitute a 8 for a > in some thing.  3Safe $&)*+34579>@GINZ Wrapper for o that determines the set of free names in the type being substituted, and starts with an empty binder stack. Wrapper for  to substitute multiple things..Rewrite or substitute into a witness variable. 4Safe $&)*+34579>@GINZ 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  & and witness substitution for an   Wrapper for " to substitute multiple arguments.2Rewrite or substitute into an expression variable.  bNone $&)*+34579>@GINZ )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.Check the type of a bind.;Check a type in the exp checking monad, returning its kind. Checker configuration.Global kind environment.Local context."Universe for the type of the bind.Check this bind. Mode for bidirectional checking.Checker configuration.Global kind environment.Local context.'Universe the type is supposed to be in.Check this type.Mode for bidirectional checking      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIrstuvwxyz{|}~      !"#$%&'()*+,-./012456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYEFAGHIJ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOuvwxyz{|}~ cNone $&)*+34579>@GINZCheck 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.Static configuration.Starting Kind Environment.Strating Type Environment.Witness to check.Data type definitions.Kind environment.Type environment. Input contextWitness to check.dNone $&)*+34579>@GINZnMake the left type an instantiation of the right type, or throw the provided error if this is not possible.eNone $&)*+34579>@GINZ`Make two types equivalent to each other, or throw the provided error if this is not possible.,Unpack single element sums into plain types.fNone $&)*+34579>@GINZgMake the left type a subtype of the right type, or throw the provided error if this is not possible.gNone $&)*+34579>@GINZCTable 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.     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.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIrstuvwxyz{|}~      !"#$%&'()*+,-./012456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY>?@ABCDEF    AGHIJ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOuvwxyz{|}~          hNone $&)*+34579>@GINZiNone $&)*+34579>@GINZCheck a spec application.KSynthesise the type of a polymorphic function applied to its type argument.jNone $&)*+34579>@GINZ%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.kNone $&)*+34579>@GINZ\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.Annotation for error messages.Pattern.Checker table.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.lNone $&)*+34579>@GINZ)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 check  mNone $&)*+34579>@GINZ!-Check a data constructor, returning its type.!'The full expression for error messages.Annotation for error messages.Data constructor to check.!!nNone $&)*+34579>@GINZ"#""#oNone $&)*+34579>@GINZ$Check 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.$$&%pNone $&)*+34579>@GINZ'DCheck 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.--'()*+,qNone $&)*+34579>@GINZ.ECheck the set of witness bindings bound in a letregion for conflicts./.Type checker config.Annotation for error messages.Kind Environment.Context)The whole expression, for error messages.(Region variables bound in the letregion.'Other witness bindings in the same set.//.rNone $&)*+34579>@GINZ000sNone $&)*+34579>@GINZ111tNone $&)*+34579>@GINZType 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.2Like  but using the  monad to handle errors.Static configuration.Starting kind environment.Starting type environment. Check mode. Demand placed on the expression.Expression to check.Static configuration.Starting Kind environmentStarting Type environment.Expression to check.2Static config.Input context. Check mode. Demand placed on the expression.Expression to check.36>?@ABC     2323uNone $&)*+34579>@GINZ 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.4Like  but using the  monad to handle errors.5Check exported types.6Check exported types.7Check kinds of imported types.8%Check types of imported capabilities.9Check 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.4Static configuration.Starting kind environment.Starting type environment.Module to check.Type checker mode.56789:Exported types.Exported values:Environment of top-level bindings defined by the module;Exported types.Exported values.<Types defined by the module.Name of an exported binding.4 456789:;<"None $&)*+34579>@GINZ>?@ABC      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO>?@ABC   "#$'()*-0234678:;<@BDGJKLMNO   !!%&%%+,./1  1 1559=>?5A5CEFHI!5None $&)*+34579>@GINZ 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.=>?@ABC>?@ABC =>vwx6y6z6{6|6}6~6666666666666666666666666666666666666666666666666666666666666666666888888;;;;;;;;;;;;;;;;;;;      !"#$%&'()*+,-./<0<1<2<3<4<5<6<7<8 9 9 : ; < = > ? @ @ A B C D E F G H H I J K K L M N O P Q R S T U V W X Y Z [=\=]^_`abcdefghijklmnopqrstuvwxyz{ | } ~                                                                            ]_`abdefgijlnopsrvwxytucdefg^_`abhijklmnopqrstuvwxyz{      !"#$%&'(A)A*A+A,A-A.A/B0B1B2B3B4B5B6B7B8B9B:B;B<B=B>B?B@BABBBCBDBEBFGCHCICJKKLMNNLOPMQRSTUUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{{|}~DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD          EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE!!!!!GGGG#III$$$$$$$$$$$$$$$$$$$$$$$$$ % % % % %&&'''''''''''''''' '!'"'#'$'%'&'''(()(*(+(,(-(./0123456789:;<=>?@ABCDLE*F*G*H*I*JKLMN+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+{+|+}+~++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,--PPPPPPPP...//QQQR{R{RRRRRRSSSSSSSSSSSSSSSSVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW WWW W W W WWWWWWWWWWWWWWWWWWWWW W!W"W#W$W%W&W'W(W)W*W+W,W-W.W/W0W1W2W3W4W5W6W7W8W9W:W;W<W=WWY>Y?Y@YAYBYCYDYEYFYGYHYIYJYKYLYMYNYOZPZQZRZS[T[U[V\W\}\X\~\Y\Z\[\\]]]^]_a`1a1b1c1c1d1e1f1g1h1i1j2k2l2m2n2o3p3q3r3s4t4u4v4w4x4ybzbzb{c|c}c~gggttu555555555555555577777777777788<   =          >>>>>>>>>>>>      !"#$%&'()*+,vw-vw.vw/vw0vw1vw2vw3vw4vw5vw6vw7vw8vw9vw:vw;<=>?@ABCDEFGHIJ?K?F?L?M?N?OPQR@SATBUBVBWCXYZ[\]^_`abcde fFgFh!i!j!k!l!mGnGoGpGqGrGsGtGuGvGwG{GxGyGzG{G|G}G~GGGGGGGGGGGGGGGGGGGGGGwG{G|GGGGGGGGHHHHHvI$$$$$$%%%'((F(((((LLLLLLLMMMM++++++++++,N{NNNNNNNNNNNNNNNNNNNNOOOO-Ph......////////// / / / / /QQQQQQQQQQQQ{Q{QQQQQQQQQ T!T"T#T$T%U&V'V(XhY)Y*Y+Y,Y-Z.Z/Z0Z1Z2Z3Z4Z5[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`<`9`0`VaWaXaYaZa[a\a]1^1_1`1a1b1c1d1e1f2g2h2i2j2k2l3m3n3o3p3q4r4s4t4ubbbbbbvbwbbxbyz{|}~vvvvvvvvvcde&ejfggggggggggggggggggghiijjjkkkkkkkklllmnnooopppppppqqrsttuuuuuuuuu5hddcco_3yDkwedp2NiHTZLaRkKO3PDDC.Core.Pretty DDC.Type.ExpDDC.Core.ModuleDDC.Core.FragmentDDC.Core.Lexer.Unicode DDC.Type.SumDDC.Type.CompoundsDDC.Core.Exp.Annot.ExpDDC.Core.Exp.Annot.CompoundsDDC.Type.DataDefDDC.Core.Transform.MapTDDC.Type.PredicatesDDC.Core.Exp.Annot.PredicatesDDC.Core.Exp.Generic.ExpDDC.Core.Exp.Generic.CompoundsDDC.Core.Exp.Generic.PredicatesDDC.Core.Exp.Generic.PrettyDDC.Core.Exp.Simple.ExpDDC.Core.Exp.Simple.CompoundsDDC.Core.Transform.AnnotateDDC.Core.Transform.DeannotateDDC.Type.Transform.BoundTDDC.Type.Transform.Rename DDC.Type.BindDDC.Type.CheckDDC.Core.Exp.Annot.AnTDDC.Core.Exp.Annot.AnTEC DDC.Type.EnvDDC.Core.Exp.Annot.CtxDDC.Core.Exp.Annot.ContextDDC.Type.Transform.SpreadTDDC.Type.UniverseDDC.Type.EquivDDC.Core.CheckDDC.Type.SubsumesDDC.Type.CollectDDC.Type.Transform.SubstituteTDDC.Type.Transform.Instantiate DDC.Core.CallDDC.Core.Transform.BoundXDDC.Core.CollectDDC.Core.Exp.Generic.BindStructDDC.Core.Lexer.TokensDDC.Core.Lexer.NamesDDC.Core.LexerDDC.Core.Transform.ReannotateDDC.Core.Transform.SpreadXDDC.Core.ParserDDC.Core.Collect.SupportDDC.Core.Transform.SubstituteTXDDC.Core.Transform.SubstituteWXDDC.Core.Transform.SubstituteXX DDC.Core.LoadDDC.Type.Exp.BaseDDC.Type.Exp.NFDataDDC.Core.Module.NameM1.M2M3DDC.Core.Fragment.FeatureDDC.Core.Exp.DaConDDC.Core.Exp.WiConDDC.Type.PrettyDDC.Core.Transform.BoundTDDC.Core.Transform.RenameDDC.Core.Module.ExportDDC.Core.Module.ImportDDC.Type.Check.CheckConDDC.Core.Fragment.ProfileDDC.Type.Check.ErrorDDC.Type.Check.ErrorMessageDDC.Type.Check.ContextDDC.Type.Check.BaseDDC.Type.Collect.FreeTDDC.Core.Exp.Annot DDC.Core.ExpDDC.Core.Collect.FreeDDC.Core.Collect.Free.SimpleDDC.Core.Lexer.OffsideDDC.Core.Lexer.CommentsDDC.Core.Fragment.ErrorDDC.Core.Fragment.ComplianceDDC.Core.Parser.ContextDDC.Type.Check.ConfigDDC.Type.Check.DataDDC.Type.Check.Judge.EqDDC.Type.Check.Judge.KindDDC.Core.Check.ErrorDDC.Core.Check.ErrorMessageDDC.Core.Parser.BaseDDC.Core.Parser.TypeDDC.Core.Parser.WitnessDDC.Core.Parser.ParamDDC.Core.Parser.ExpDDC.Core.Parser.DataDefDDC.Core.Parser.ExportSpecDDC.Core.Parser.ImportSpecDDC.Core.Parser.ModuleDDC.Core.Check.BaseDDC.Core.Check.WitnessDDC.Core.Check.Judge.InstDDC.Core.Check.Judge.EqDDC.Core.Check.Judge.SubDDC.Core.Check.Judge.Type.BaseDDC.Core.Check.Judge.Type.SubDDC.Core.Check.Judge.Type.AppTDDC.Core.Check.Judge.Type.AppXDDC.Core.Check.Judge.Type.CaseDDC.Core.Check.Judge.Type.CastDDC.Core.Check.Judge.Type.DaConDDC.Core.Check.Judge.Type.LamTDDC.Core.Check.Judge.Type.LamXDDC.Core.Check.Judge.Type.Let$DDC.Core.Check.Judge.Type.LetPrivate DDC.Core.Check.Judge.Type.VarCon!DDC.Core.Check.Judge.Type.WitnessDDC.Core.Check.ExpDDC.Core.Check.Moduleddcba_FMdeJJBwSKsFWlo2bsLk5fDDC.Base.Pretty PrettyModeTcCon TcConUnitTcConFun TcConSusp TcConRead TcConHeadRead TcConDeepRead TcConWriteTcConDeepWrite TcConAllocTcConDeepAllocTwCon TwConImpl TwConPure TwConConstTwConDeepConst TwConMutableTwConDeepMutable TwConDistinct TwConDisjointKiConKiConFun KiConWitness KiConData KiConRegion KiConEffect KiConClosureSoCon SoConProp SoConCompTyCon TyConSort TyConKind TyConWitness TyConSpec TyConBound TyConExists TypeSumVarCon TypeSumVar TypeSumCon TyConHashTypeSum TypeSumBot typeSumKind TypeSumSet typeSumElemstypeSumBoundNamedtypeSumBoundAnon typeSumSpillClosureEffectRegionKindSortTypeTVarTConTForallTAppTSumBoundUIxUNameUPrimBindBNoneBAnonBNameBinderRNoneRAnonRNameQualName ModuleNamereadModuleNameisMainModuleNameFeatureTrackedEffectsTrackedClosuresFunctionalEffectsFunctionalClosuresEffectCapabilities ImplicitRun ImplicitBox PartialPrimsPartialApplicationGeneralApplicationNestedFunctions GeneralLetRecDebruijnBindersUnboundLevel0VarsUnboxedInstantiation NameShadowingUnusedBindings UnusedMatchesunicodeOperatorsInfixempty singletoneleminsertdeleteunionunions difference kindOfSumtoListfromList hashTyConhashTyConRange unhashTyContakeNameOfBind 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 tConData1DaCon DaConUnit DaConPrim daConName daConType DaConBoundtakeNameOfDaContakeTypeOfDaCondcUnitDataCtor dataCtorName dataCtorTagdataCtorFieldTypesdataCtorResultTypedataCtorTypeNamedataCtorTypeParamsDataType dataTypeNamedataTypeParams dataTypeModedataTypeIsAlgebraicDataMode DataModeSmall DataModeLargeDataDefs dataDefsTypes dataDefsCtorsDataDefdataDefTypeName dataDefParams dataDefCtorsdataDefIsAlgebraic kindOfDataDefdataTypeOfDataDefdataCtorNamesOfDataDefmakeDataDefAlgmakeDataDefAbstypeOfDataCtor emptyDataDefs unionDataDefs insertDataDeffromListDataDefslookupModeOfDataTypekindOfDataTypeWiCon WiConBoundWitnessWVarWConWAppWTypeCastCastWeakenEffect CastPurifyCastBoxCastRunPatPDefaultPDataAltAAltLetsLLetLRecLPrivateExpXVarXConXLAMXLamXAppXLetXCaseXCastXTypeXWitnessParam ParamType ParamValueParamBox annotOfExp mapAnnotOfExpxLAMsxLams takeXLAMs takeXLams makeXLamFlags takeXLamFlags takeXLamParamxAppsmakeXAppsWithAnnots takeXApps takeXApps1takeXAppsAsListtakeXAppsWithAnnots takeXPrimApps takeXConAppsxLets xLetsAnnot splitXLetssplitXLetsAnnot bindsOfLetsspecBindsOfLetsvalwitBindsOfLetspatOfAlttakeCtorNameOfAlt bindsOfPatmakeRunswAppwAppsannotOfWitness takeXWitnesstakeWAppsAsListtakePrimWiConApps takeXTypexUnitmapTisBNoneisBAnonisBNameisTVarisBotisAtomT isTExists isDataKind isRegionKind isEffectKind isClosureKind isWitnessKind isAlgDataType isWitnessTypeisConstWitTypeisMutableWitTypeisDistinctWitType isReadEffect isWriteEffect isAllocEffectisSomeReadEffectisSomeWriteEffectisSomeAllocEffectisXVarisXConisAtomXisAtomWisXLAMisXLam isLambdaXisXAppisXCast isXCastBox isXCastRunisXLetisXType isXWitness isPDefault ShowLanguageGWiConGWitnessGCastGPatGAltGLetsGArgRTypeRExpRWitnessGAbsALAMALamGExpXAnnotXPrimXAbsGPrimGBoundGBindGAnnotmakeXAbstakeXAbs makeXLAMs makeXLams makeXApps splitXAppsisAtomRisXAbsPrettyLanguagePrettyModeLets modeLetsExp PrettyModeAlt modeAltExp PrettyModeArg modeArgExp PrettyModeExp modeExpArg modeExpLets modeExpAltmodeExpUseLetCase breakWhenparens' pprParen' isSimpleX isSimpleR $fPrettyDaCon$fPrettyGWiCon$fPrettyGWitnessTFCo:R:PrettyModeGLets $fPrettyGLets $fPrettyGCastTFCo:R:PrettyModeGAlt $fPrettyGAlt $fPrettyGPatTFCo:R:PrettyModeGArg $fPrettyGArgTFCo:R:PrettyModeGExp $fPrettyGExpWAnnotAnnotateannotate Deannotate deannotate MapBoundTmapBoundAtDepthT liftAtDepthTliftT lowerAtDepthTlowerT BindStack stackBindsstackAll stackAnons stackNamedSubsubBound subShadow0 subConflict1 subConflict0 subStack1 subStack0Rename renameWith pushBindspushBind substBoundbind1bind1sbind0bind0suse1use0 ExportSourceExportSourceLocalexportSourceLocalNameexportSourceLocalTypeExportSourceLocalNoTypetakeTypeOfExportSourcemapTypeOfExportSource ImportValueImportValueModuleimportValueModuleNameimportValueModuleVarimportValueModuleTypeimportValueModuleArityImportValueSeaimportValueSeaVarimportValueSeaType ImportCapImportCapAbstractimportCapAbstractType ImportTypeImportTypeAbstractimportTypeAbstractTypeImportTypeBoxedimportTypeBoxedkindOfImportTypemapKindOfImportTypetypeOfImportCapmapTypeOfImportCaptypeOfImportValuemapTypeOfImportValue getBindTypetakeSortOfKiCon kindOfTwCon kindOfTcConAnT annotType annotTailAnTEC annotEffect annotClosurefromAnTTypeEnvKindEnvSuperEnvEnvenvMapenvStackenvStackLength envPrimFunextendextends setPrimFunisPrim fromTypeMapmember memberBindlookup lookupNamedepthlift wrapTForallsCtxCtxTop ctxDataDefs ctxKindEnv ctxTypeEnvCtxLAMCtxLam CtxAppLeft CtxAppRight CtxLetBody CtxLetLLet CtxLetLRec CtxCaseScrut CtxCaseAlt CtxCastBody isTopLetCtxtopOfCtxtakeEnclosingCtxtakeTopNameOfCtxtakeTopLetEnvNamesOfCtx encodeCtxContextcontextKindEnvcontextTypeEnvcontextGlobalCaps contextCtxenterLAMenterLam enterAppLeft enterAppRight enterLetBody enterLetLLet enterLetLRecenterCaseScrut enterCaseAlt enterCastBodySpreadTspreadTFeaturesfeaturesTrackedEffectsfeaturesTrackedClosuresfeaturesFunctionalEffectsfeaturesFunctionalClosuresfeaturesEffectCapabilitiesfeaturesImplicitRunfeaturesImplicitBoxfeaturesPartialPrimsfeaturesPartialApplicationfeaturesGeneralApplicationfeaturesNestedFunctionsfeaturesGeneralLetRecfeaturesDebruijnBindersfeaturesUnboundLevel0VarsfeaturesUnboxedInstantiationfeaturesNameShadowingfeaturesUnusedBindingsfeaturesUnusedMatchesProfile profileNameprofileFeaturesprofilePrimDataDefsprofilePrimKindsprofilePrimTypesprofileTypeIsUnboxedprofileNameIsHoleprofileMakeStringNamemapFeaturesOfProfile zeroProfile zeroFeatures setFeatureUniverse UniverseSort UniverseKind UniverseSpecUniverseWitness UniverseDatauniverseFromType3universeFromType2universeFromType1universeOfType ErrorDataErrorDataDupTypeNameerrorDataDupTypeNameErrorDataDupCtorNameerrorDataCtorNameErrorDataWrongResulterrorDataCtorResultActualerrorDataCtorResultExpectedErrorErrorUniverseMalfunction errorType errorUniverse ErrorMismatch errorInferred errorExpected errorChecking ErrorInfinite errorTypeVar errorTypeBindErrorUndefined errorBoundErrorUnappliedKindFunErrorNakedSort errorSortErrorUndefinedTypeCtorErrorAppNotFun errorFunTypeerrorFunTypeKind errorArgTypeErrorAppArgMismatch errorFunKind errorArgKindErrorWitnessImplInvalid errorLeftType errorLeftKinderrorRightTypeerrorRightKindErrorForallKindInvalid errorBody errorKindErrorSumKindMismatcherrorKindExpected errorTypeSum errorKindsErrorSumKindInvaliderrorCheckingSumequivTequivWithBindsT equivTyCon crushSomeT crushEffectModeReconSynthCheck subsumesT FreeVarConT freeVarConT freeVarsT BindStruct slurpBindTree BoundLevel BoundSpecBoundExpBoundWitBindWay BindForallBindLAMBindLamBindLet BindLetRecBindLetRegionsBindLetRegionWith BindCasePatBindTreeBindDefBindUseBindCon isBoundExpWitboundLevelOfBindWaybindDefTfreeT collectBound collectBinds SubstituteTsubstituteWithT substituteT substituteTssubstituteBoundT instantiateT instantiateTsElimElimType ElimValueElimRunConsConsType ConsValueConsBox isConsType isConsValue isConsBoxtakeCallConsFromExptakeCallConsFromTypesplitStdCallConstakeStdCallConsFromTypeArity isElimType isElimValue isElimRun applyElim takeCallElimsplitStdCallElims elimForConsdischargeConsWithElimsdischargeTypeWithElims MapBoundXmapBoundAtDepthX liftAtDepthXliftX lowerAtDepthXlowerX ModuleMapModule ModuleCore moduleNamemoduleIsHeadermoduleExportTypesmoduleExportValuesmoduleImportTypesmoduleImportCapsmoduleImportValuesmoduleImportDataDefsmoduleDataDefsLocal moduleBody isMainModulemoduleDataDefs moduleKindEnv moduleTypeEnvmoduleTopBindsmoduleTopBindTypes mapTopBindsmodulesExportTypesmodulesExportValuesfreeX$fBindStructGWitnessl$fBindStructGCastl$fBindStructGAltl$fBindStructGArgl$fBindStructGExpl pprExportTypepprExportValue pprImportTypepprImportValueTokNamedKConKVarKLitTokAtom KRoundBra KRoundKet KSquareBra KSquareKet KBraceBra KBraceKetKSquareColonBraKSquareColonKetKBraceColonBraKBraceColonKetKOpKOpVarKHatKDotKComma KSemiColon KUnderscore KBackSlashKEqualsKBarKBigLambdaSlash KBigLambdaKLambda KArrowTilde KArrowDashKArrowDashLeft KArrowEquals KBotEffect KBotClosureKModuleKImportKExportKForeignKType KCapabilityKValueKDataKWithKWhereKInKLetKLetCaseKLetRecKPrivateKExtendKUsing KWithRegionKCaseKOfKWeakEffKWeakCloKPurifyKForgetKBoxKRunKDoKMatchKIfKThenKElse KOtherwiseKIndexKStringKPragma KSoConBuiltin KKiConBuiltin KTwConBuiltin KTcConBuiltin KDaConUnitTokMetaKNewLineKCommentLineStartKCommentBlockStartKCommentBlockEndKCommentUnterminatedKOffsideClosingBraceTok KErrorJunk KErrorUntermKMKAKN renameTok describeTokdescribeTokMetadescribeTokAtomdescribeTokNamedkeywordsreadSoConBuiltinreadKiConBuiltinreadTwConBuiltinreadTcConBuiltin isVarName isVarStart isVarBodyreadVar isConName isConStart isConBodyreadConisOpName isOpStartisOpBody isLitName isLitStart isLitBodylexModuleWithOffsidelexExpErrorUnsupportedErrorUndefinedPrimErrorUndefinedVarErrorShadowedBindErrorUnusedBindErrorNakedTypeErrorNakedWitness Reannotate reannotate reannotateMSpreadXspreadXCompliescompliescompliesWithEnvsFragmentfragmentProfilefragmentExtensionfragmentReadNamefragmentLexModulefragmentLexExpfragmentCheckModulefragmentCheckExpmapProfileOfFragmentcontextTrackedEffectscontextTrackedClosurescontextFunctionalEffectscontextFunctionalClosurescontextMakeStringNamecontextOfProfileConfigconfigPrimKindsconfigPrimTypesconfigDataDefsconfigGlobalCapsconfigNameIsHoleconfigTrackedEffectsconfigTrackedClosuresconfigFunctionalEffectsconfigFunctionalClosuresconfigEffectCapabilitiesconfigGeneralLetRecconfigImplicitRunconfigImplicitBoxconfigOfProfile checkTypeM checkType checkSpec kindOfSpec sortOfKind ErrorTypeerrorTypeError errorDataErrorExportUndefined errorNameErrorExportDuplicateErrorExportMismatcherrorExportType errorDefTypeErrorImportDuplicateErrorImportCapNotEffectErrorImportValueNotData errorAnnotErrorUndefinedCtorErrorAppMismatch errrorAnnoterrorParamTypeerrorNotFunTypeErrorAppCannotInferPolymorphicErrorLamShadow errorBindErrorLamNotPure errorEffectErrorLamBindBadKindErrorLamBodyNotDataErrorLamParamUnannotatedErrorLAMParamUnannotatedErrorLAMParamBadSortErrorLetMismatchErrorLetBindingNotDataErrorLetBodyNotDataErrorLetrecBindingNotLambdaerrorExpErrorLetrecMissingAnnotErrorLetrecReboundErrorLetRegionsNotRegion errorBindsErrorLetRegionsReboundErrorLetRegionFreeErrorLetRegionWitnessInvalidErrorLetRegionWitnessConflicterrorBindWitness1errorBindWitness2ErrorLetRegionsWitnessOthererrorBoundRegionserrorBindWitnessErrorWAppMismatch errorWitnessErrorWAppNotCtorErrorWitnessNotPurityErrorCaseScrutineeNotAlgebraicerrorTypeScrutinee ErrorCaseScrutineeTypeUndeclaredErrorCaseNoAlternativesErrorCaseNonExhaustiveerrorCtorNamesMissingErrorCaseNonExhaustiveLargeErrorCaseOverlappingErrorCaseTooManyBinderserrorCtorDaConerrorCtorFieldserrorPatternFieldsErrorCaseCannotInstantiate errorTypeCtorErrorCaseScrutineeTypeMismatcherrorTypePatternErrorCaseFieldTypeMismatcherrorTypeAnnoterrorTypeFieldErrorCaseAltResultMismatch errorAltType1 errorAltType2ErrorWeakEffNotEffErrorRunNotSuspensionErrorRunNotSupportedErrorRunCannotInferParser pModuleNamepNamepConpConSPpLitpLitSPpString pStringSPpVarpVarSPpIndexpIndexSPpOpSPpOpVarSPpTokpTokSPpTokAspTypepBinderpTypeApp pTypeAtompWitness pWitnessApp pWitnessAtom ParamSpec ParamWitness expOfParamsfunTypeOfParamspBindParamSpecpBindParamSpecAnnotpExppExpApppExpAtompModuleSupportXsupportSupport supportTyConsupportTyConXArg supportSpVarsupportSpVarXArg supportWiVar supportDaVarsupportEnvFlags SubstituteTXsubstituteWithTX substituteTX substituteTXssubstituteBoundTX SubstituteWXsubstituteWithWX substituteWX substituteWXs SubstituteXXsubstituteWithXX substituteXX substituteXXssubstituteXArgsubstituteXArgs CheckTrace checkTraceDoc checkWitness typeOfWitness typeOfWiConDemand DemandRun DemandNonecheckExp typeOfExp checkModule ErrorRead ErrorParserErrorCheckType ErrorCheckExpErrorCompliance ErrorFragmentloadModuleFromFileloadModuleFromStringloadModuleFromTokensloadExpFromStringloadExpFromTokensloadTypeFromStringloadTypeFromTokensloadWitnessFromStringloadWitnessFromTokens $fNFDataTcCon $fNFDataTwCon $fNFDataKiCon $fNFDataSoCon $fNFDataTyCon$fNFDataTypeSumVarCon$fNFDataTyConHash$fNFDataTypeSum $fNFDataType $fNFDataBound $fNFDataBind$fNFDataBinder$fNFDataQualName$fNFDataModuleNameUseunicodeOperatorTableDeniedInfixPrefixemptySetbaseGHC.BaseNothing hashTcConGHC.ErrerrortakeSumArrayElemmakeSumArrayElem$fOrdTypeSumVarCon$fEqTypeSumVarCon $fOrdBound $fEqTypeSum$fEqTypeghc-prim GHC.TypesFalsetcCon1twCon1twCon2 $fNFDataDaConInt$fMonoidDataDefs$fNFDataDataCtor$fNFDataDataDef $fNFDataWiCon$fNFDataWitness $fNFDataPat $fNFDataAlt $fNFDataLets $fNFDataCast $fNFDataExpMapTMAPT $fMapTmBound $fMapTmBind $fMapTmCast$fMapTmWitness $fMapTmPat $fMapTmAlt $fMapTmLets $fMapTmExpGHC.Num* pprBinderSeppprBinderGroup $fPrettyTcCon $fPrettyTwCon $fPrettyKiCon $fPrettySoCon $fPrettyTyCon$fPrettyTypeSum $fPrettyType $fPrettyBound$fPrettyBinder $fPrettyBindwlppr_5yN7q1pAoUb89IckasciOYText.PrettyPrint.Leijen<$$><$><+><>alignangles backslashboolbracesbracketscatcharcoloncolumncomma displayIOdisplaySdotdoubledquotedquotesenclose encloseSepequalsfill fillBreakfillCatfillSepfloatgrouphPutDochanghcathsepindentintintegerlanglelbracelbracketline linebreaklistlparennestnestingparens punctuateranglerationalrbracerbracket renderCompactrparensemi semiBracessep softbreaksoftlinespacesquotesquotesstringtexttupledvcatvsepwidth SimpleDocSCharSEmptySLineSTextDocputDocLnputDoc renderIndent renderPlainrenderpadLpprParen pprModePrecpprPrecpprpprDefaultModePretty RenderIndent RenderPlain RenderMode$fAnnotateWitnessWitness$fAnnotateAltAlt$fAnnotateLetsLets$fAnnotateCastCast$fAnnotateExpExp$fDeannotateCastCast$fDeannotateWitnessWitness$fDeannotateAltAlt$fDeannotateLetsLets$fDeannotateExpExp countBAnons$fMapBoundTTypeSumn$fMapBoundTTypen$fMapBoundTBoundn$fMapBoundTBindnmapBoundAtDepthTLets$fMapBoundTAltn$fMapBoundTCastn$fMapBoundTWitnessn$fMapBoundTExpn $fRenameBind$fRenameTypeSum $fRenameType$fRenameWitness$fNFDataExportSource$fNFDataImportValue$fNFDataImportCap$fNFDataImportTypetakeKindOfTyCon $fPrettyAnT $fNFDataAnT $fPrettyAnTEC $fNFDataAnTEC$fSpreadTDataCtor$fSpreadTDataType$fSpreadTDataDefs$fSpreadTDataDef$fSpreadTTyCon$fSpreadTBound $fSpreadTBind$fSpreadTTypeSum $fSpreadTType$fPrettyUniverse$fPrettyErrorData $fPrettyError checkBounds unpackSumT makeDeepRead makeDeepWrite makeDeepAllocRole RoleConcrete RoleAbstractElemElemPosElemKindElemTypeElemExistsDecl ElemExistsEqPos contextGenPoscontextGenExists contextElems contextSolvedExists typeOfExists takeExists emptyContextpushType pushTypespushKind pushKinds pushExists markContextpopToPos lookupType lookupKindlookupExistsEq memberType memberKindmemberKindBindlocationOfExists updateExists liftTypes lowerTypesapplyContextEither Data.EitherLeftapplySolvedEithereffectSupported $fPrettyRole $fPrettyElem $fPrettyPos$fPrettyContext$fPrettyExists $fOrdExists $fEqExists $fPrettyModeCheckM newExists applyContext applySolvednewPosDDC.Control.Monad.Checkthrow$fFreeVarConTType freeOfTreeTcollectBoundOfTreecollectSpecBindsOfTreecollectExpBindsOfTree$fBindStructTyConn$fBindStructTypen$fSubstituteTTypeSum$fSubstituteTType$fSubstituteTBindinstantiateConsTmapBoundAtDepthXLets$fMapBoundXAltn$fMapBoundXCastn$fMapBoundXWitnessn$fMapBoundXExpn$fMapBoundXBoundn$fNFDataModulebindDefX freeOfTreeX$fBindStructWitnessn$fBindStructAltn$fBindStructCastn$fBindStructExpn$fBindStructModulen pprImportCap pprPatBind pprWitBindmodeLetsSuppressTypesmodeExpVarTypesmodeExpConTypesPrettyModeModulemodeModuleLetsmodeModuleSuppressImportsmodeModuleSuppressExports pprBinder $fPrettyWiCon$fPrettyWitnessTFCo:R:PrettyModeLets $fPrettyLets $fPrettyCastTFCo:R:PrettyModeAlt $fPrettyAlt $fPrettyPatTFCo:R:PrettyModeExp $fPrettyExp$fPrettyDataCtor$fPrettyDataDefTFCo:R:PrettyModeModule$fPrettyModule$fPrettyModuleName TokenFamilydescribeTokenFamilyrenameTokNamedSymbolKeyword ConstructorIndexLiteralPragmadescribeTokAtom'readTwConWithArityParenLexemeLexemeStartBlock applyOffside addStarts dropNewLinesdropNewLinesLexemesplitBlockStartisToken isKNTokennewCBranewOffsideClosingBrace ParenRound ParenBrace LexemeTokenLexemeStartLine addStarts'newCKet newSemiColontakeTok dropCommentsdropCommentBlocklexText$fReannotateWitness$fReannotateCast$fReannotateAlt$fReannotateLets$fReannotateExp$fReannotateModule$fSpreadXBound $fSpreadXBind$fSpreadXWiCon$fSpreadXWitness $fSpreadXLets $fSpreadXAlt $fSpreadXPat $fSpreadXCast$fSpreadXDaCon $fSpreadXExp$fSpreadXImportValue$fSpreadXImportCap$fSpreadXImportType$fSpreadTExportSource$fSpreadXModule checkBind checkBinds checkFunction contextTopsetBodyaddArgresetresultcontextAbsBodycontextFunArgs compliesX $fMonadCheckM$fApplicativeCheckM$fFunctorCheckM $fCompliesAlt $fCompliesExp$fCompliesModule$fShowFragment checkDataDefs checkDataDefcheckDataCtors checkDataCtorcheckDataDefs'makeEq checkTypesM synthTAppArg pModuleName1 pQualName pVarNamedSP pPragmaSPpTokAsSP pTypeForallpTypeFunpSoConpKiConpTcConpTwCon pTyConNamedpTypeSum pWitnessJoin pWitnessArgSPpWitnessAtomSP pExpAtomSPpLetsSP pLetBindingpStmtpStmts makeStmtsStmtStmtBind StmtMatchStmtNonepArgSPspAltpPatpBindspLetWits pDataParam pDataCtorpDataDef pExportSpecs pExportValuepExportForeignValue ExportSpec ExportValue ImportSpec pImportSpecspImportForeignTypepImportForeignCap pImportValuepImportForeignValue ImportDataHeadDeclHeadPragmaArity pHeadDecl pHeadPragmaHeadImportSpecsHeadExportSpecs HeadDataDef$fSupportXBind$fSupportXLets$fSupportXCast$fSupportXWitness $fSupportXAlt $fSupportXExp$fSupportXModule$fSupportXType$fMonoidSupport$fSubstituteTXType$fSubstituteTXBind$fSubstituteTXWitness$fSubstituteTXCast$fSubstituteTXAlt$fSubstituteTXExpsubstW$fSubstituteWXWitness$fSubstituteWXCast$fSubstituteWXAlt$fSubstituteWXExpsubstX$fSubstituteXXCast$fSubstituteXXAlt$fSubstituteXXExpctrace checkBindM$fMonoidCheckTrace$fPrettyCheckTracefail>>=>>fmapreturn Control.MonadguardjoinMonadFunctormfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMData.TraversableforMsequencemapM Data.Foldablemsum sequence_forM_mapM_ Data.Functorvoid Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybefromJust isNothingisJustmaybeapliftM5liftM4liftM3liftM2liftMwhen=<<JustMaybemplusmzero MonadPlusconta_LKCPrTJwOTOLk4OU37YmeN Data.Set.BaseSet evalCheckrunCheckDDC.Data.ListUtils stripSuffixfindDuplicatesindex takeMaximumtakeInittakeTailtakeHead checkWitnessMmakeInstmakeSubTableCheckerreturnX runForDemand tableConfig tableKindEnv tableTypeEnv tableCheckExptableCheckVarContableCheckAppTtableCheckAppXtableCheckLamTtableCheckLamX tableCheckLettableCheckLetPrivatetableCheckCasetableCheckCasttableCheckWitnesscheckSub checkAppT synthAppArgT checkAppX synthAppArg splitFunTypetakeDiscrimCheckModeFromAlts checkAltsMcheckFieldAnnots ctorTypeOfPat dataTypeOfPatcheckAltsOverlappingcheckAltsExhaustive checkCase synthRunSuspcheckEffectSupported checkCast checkDaConM checkLamTcheckLAM checkLamX makeFunctioncheckLam checkLetsM checkRecBindscheckRecBindExpscheckNoDuplicateBindings duplicatescheckSyntacticLambdascheckLetcheckWitnessBindsMcheckLetPrivate checkVarConcheckWit checkExpM makeTable checkModuleMcheckExportTypescheckExportValuescheckImportTypescheckImportCapscheckImportValuescheckModuleBindscheckModuleBindcheckBindDefined