XZӔ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW 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 { | } ~         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./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+[+\+]+^+_+`+a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+s+t+u+v+w+x+y+z+{+|+}+~++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,----..............//// / / / / /////////////////// /!/"/#/$/%/&/'/(/)/*/+/,/-/.///0/1/2/3/4/5/6/7/8/9/:/;/</=/>0?1@1A2B3C3D3E3F3G3H3I3J3K4L4M4N4O4P4Q4R4S4T4U4V4W4X4Y4Z5[5\5]5^5_5`6a6b6c6d6e6f6g6h6i6j6k6l6m6n6o6p6q6r6s6t6u6v6w6x6y6z6{6|6}6~66666666667777777=portablestable(Warren Harris <warrensomebody@gmail.com> Safe-Inferred-BA document of height and width 1, containing a literal character. 4A document of height 1 containing a literal string.   satisfies the following laws:   s 5  t =  (st)  "" 5 x = x, if x non-empty 8The side condition on the last law is necessary because  ""  has height 1, while  has no height. Same as text#. Used to be used for Bytestrings. Some text with any width. (text s = sizedText (length s) s) <Some text, but without any width. Use for non-printing text  such as a HTML or Latex tags 1The empty document, with no height and no width.   is the identity for 5, 6, 3 and 4, and anywhere  in the argument list for 7, -, ., /, 9 etc. Returns  if the document is empty A ';' character A ',' character A : character A space character A '=' character A '(' character A ')' character A '[' character A ']' character !A '{' character "A '}' character # int n = text (show n)$ integer n = text (show n)% float n = text (show n)& double n = text (show n)' rational n = text (show n)(Wrap document in (...) )Wrap document in [...] *Wrap document in {...} +Wrap document in '...' ,Wrap document in "..." -List version of 5. .List version of 6. /List version of 3. 0;Nest (or indent) a document by a given number of positions  (which may also be negative). 0 satisfies the laws:  0 0 x = x 0 k (0 k' x) = 0 (k+k') x 0 k (x 5 y) = 0 k z 5 0 k y 0 k (x 3 y) = 0 k x 3 0 k y 0 k  =  x 5 0 k y = x 5 y, if x non-empty 5The side condition on the last law is needed because   is a left identity for 5. 1 !hang d1 n d2 = sep [d1, nest n d2]2 punctuate p [d1, ... dn] = [d1 <> p, d2 <> p, ... dn-1 <> p, dn]3@Above, except that if the last line of the first argument stops C at least one position before the first line of the second begins, / these two lines are overlapped. For example:  ' text "hi" $$ nest 5 (text "there")  lays out as   hi there  rather than   hi  there 3 is associative, with identity , and also satisfies  (x 3 y) 5 z = x 3 (y 5 z), if y non-empty. 4Above, with no overlapping.  4 is associative, with identity . 5Beside.  5 is associative, with identity . 6;Beside, separated by space, unless one of the arguments is .  6 is associative, with identity . 7Either . or /. 8Either - or /. 9"Paragraph fill" version of 8. :"Paragraph fill" version of 7. ; Render the Doc to a String using the default Style. < Render the Doc to a String using the given Style. =!The general rendering interface. - !"#$%&'()*+,-./0123456789:;<=Rendering mode  Line length Ribbons per line What to do with text What to do at the end  The document Result =  !"#$%&'()*+,-./0123456789:;<==#$%&' !"()*+,56-.34/78:9012; < =- !"#$%&'()*+,-./0123456789:;<=None>?@AB>?@AB>?@AB>?@AB Safe-InferredDBSearch for possible matches to the users input in the given list, , returning a small number of ranked results CDCDCDCD Safe-InferredE-Returns true iff the list has no duplicates. FAReplaces the last item in a list. Assumes the list is non empty. EFGEFGEFGEFGNoneH A graph of as in the state thread s. GWe store the successors in an unboxed array and store indexes into the ' array for the index at which at a node'!s successors start. This is very & memory efficient and cache friendly. O%An optimised implementation of Tarjan's SCC algorithm. %An optimised implementation of Tarjan's SCC algorithm. KReturns the SCCs according to a reverse topological sort of the DAG of the E SCCs (i.e. if an scc x has an edge to an scc y, then x preceeds y). PJGiven a graph, computes the transitive (but not reflexive) closure of the M graph and then returns the relation (a,b) such that b is the representative M member for a. Note, no pairs of the form a == b are returned, even if there H is an edge from a to b. This is to minimise the size of the transitive  closure. HIJKLMNOP HIJKLMNOP HMNLIKJOP HIKJLMNOP Safe-InferredRSTUVRSTUVRSTUVRSTUV  Safe-InferredW9Given two orderings, returns the second if the first is  " and returns the first otherwise. X6Given a file path, if the first character is a ~ then  expands the ~ to the users' home directory. Y:Remove whitespace from the beginning and end of a string. Z2Compute the Cartesian product of a list of lists. WXYZWXYZWXYZWXYZ  Safe-Inferred\GReturns the binding strength of the operator. Higher numbers bind more  loosely. ]+Returns the associativity of the operator. ^DTrue if the two items are the same operator. This is used to decide  when to paranthesise. _!The associativity of an operator [\]^_`ab[\]^_`ab[\]^_ba`[\]^_ba`  Safe-Inferred e2As prettyPrint, but yields a briefer description. 'Maybe parenthesise the given document. j*The width, in spaces, of a tab character. kIPretty prints an integer and separates it into groups of 3, separated by  commas. lShow a double d printing only places! places after the decimal place. mIndent a document by j characters, on each line  (uses 0). n Surrounds a  with  and . o Surrounds a  with '|'. pSeparates a list of s by . qSeparates a list of s by ','. rConverts a number into first, second etc. sEquivalent to [d1, sep   d2, sep   d3, ...]. cdefghijklmnopqrstO  !"#$%&'()*+,-./0123456789:;<=cdefghijklmnopqrstcdefghijmlknoqprstcdefghijklmnopqrst  Safe-Inferred w*The width, in spaces, of a tab character. xIPretty prints an integer and separates it into groups of 3, separated by  commas. yShow a double d printing only places! places after the decimal place. zIndent a document by w characters, on each line  (uses ). { Surrounds a  with  and . | Surrounds a  with '|'. }Separates a list of s by . ~Separates a list of s by ','. Converts a number into , second etc. Equivalent to [d1, sep   d2, sep   d3, ...]. uvwxyz{|}~K uvwxyz{|}~ uvwzyx{|~} uvwxyz{|}~ Safe-Inferred A string.  A character.  A boolean. 6An integer. This is finite size, as per the FDR spec.  Safe-Inferred?A class to allow catching of SourceErrors in arbitrary monads. ERuns the action, catching any non-fatal LibCSPMExecptions (i.e. non-  Panic). ;Runs the action, catching all exceptions including panics. :Converts arbitrary exceptions to panics, rethrowing them. FRuns the action, running the finaliser if an exception is thrown. The  exception is always rethrown. >Exceptions that cause LibCSPM to abort whatever it is doing. BAn error occured. Normally this is caught by the application and ! then turned into a SourceError. An error in the user's input occured An unexpected internal error 9An error message that resulted from something in the user' s input. Used for sorting into order. Used for sorting into order.  The message.  The message. Given a  and a pretty printed  creates an . Constructs a warning from a  and a pretty printed ,  prepending  Warning:  to the . Throw an error message as a . Given a string causes a  to be thrown. Throws an arbitrary .  NoneA builtin thing /!& Safe-Inferred  Safe-InferredCreates/$updates a key in the top level map. 1Looks up a key in any map, starting from the top Creates a new map 8 Safe-Inferred  None DA compiled process. Note this is an infinite data structure (due to @ PProcCall) as this makes compilation easy (we can easily chase  dependencies). CLabels the process this contains. This allows infinite loops to be  spotted. .An operator that can be applied to processes. 'ProcNames uniquely identify processes. #Events, as represented in the LTS. +Any event defined in a channel definition. 3The internal event tick, representing termination.  The internal special event tau.  JGives the operator of a process. If the process is a ProcCall an error is  thrown.  +Returns the components of a given process.  GGiven a process, returns the initial process and all processes that it  calls. ;      1   1          None A built in name. 1A name created by the renamer, but from the users' source (e.g. from  a lambda). :An externally visible name (like a top level definition). GA renamed name and is the exclusive type used after the renamer. Names H are guaranteed to be unique, meaning that two names are equal iff they N refer to the same binding instance. For example, consider the following CSPM  code:    f = 1 " g = let f = 2 within (f, f) This will be renamed to:   f0 = 1 % g = let f1 = 2 within (f1, f1) The type of this name. ?The original occurence of this name (used for error messages). BWhere this name was defined. If this occurs in a pattern, then it D will be equal to the location of the pattern, otherwise it will be B equal to the location of the definition that this name binds to.  >The unique identifier for this name. Inserted by the renamer. !?Is this name a type constructor, i.e. a datatype or a channel? "=A name that has not yet been renamed. Created by the parser. '1A name that occurs in the source code somewhere. -GDoes the given Name correspond to a data type or a channel definition. # !"#$%&'(  )*+,- !"#$%&'()*+,-'("&#$% !)*,+- !"&#$%'(  )*+,-NoneCGThis type is used only during type-checking, and is guaranteed to only F ever appear at the top-level of the left-hand side of a TExtendable. D?Something that can be extended via some means to a given type. CAfter type-checking, the TypeVarRef will simply be a variable that H contains Nothing. This means that it can be converted into an explicit B TDotable via some unknown means, or directly to the return type. >The variable argument here has a slightly special role during F unification. If it contains Nothing then this is extendable via some I unknown means to the specified type. If it contains a TDotable argt rt, C then we know that one of the arguments is argt, and the remaining E arguments are rt, which must either be a Dotable or a variable. The J meaning in the former sense is recursive, the meaning in the latter case J is clear. If it contains TVar tvref, then this means tvref has replaced  this argument variable. @We need to do the above as we may have multiple things that are H extendable in the same way, so we need to sync the arguments together. N?Is something that can be yielded on the right hand side of =>. OCan form sets of the type. PCan be input on a channel Q Orderable RComparable for equality eBPretty prints several types using the same variable substitutions G./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef !"#$%9./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef;WSTUVMRQPON8LKJIHGDCBA@=<;:9EF>?142567563eZXYf[]\^0.dbc/a_`$./01425675638LKJIHGDCBA@=<;:9EF>?MRQPONSTUVWXYZ[\]^_`abcdef !"#$%None}gA syntatic type. xA syntatic type constraint. |A syntatic type scheme.  Like with a + we flatten nested dot patterns to make it  easier to evaluate. +Since you can write list patterns such as:   f(<x,y>^xs^<z,p>^<9,0>)  f(<x,y>)  f(xs^<x,y>) 7we need an easy may of matching them. Thus, we compile  the patterns to a  PCompList instead. PCompList ps (Just (p, ps')) corresponds to a list A where it starts with ps (where each p in ps matches exactly one E list element, has a middle of p (which must be a variable pattern, / or a wildcard) and and end matching exactly ps' (again, where each p , in ps matches exactly one list component). 'Matches anything but does not bind it. A variable pattern, e.g. x, or A where A is a datatype clause. I If the variable is a datatype clause then it only matches that datatype 5 tag, whereas for anything else it matches anything. A tuple pattern, e.g.  (p1,p2,p3). HA set pattern. Only singleton patterns, or zero patterns are supported. 0 This is checked by the desugarer. For example, {p1,p2} is not allowed,  but {p1} and {} are allowed. *A user supplied parenthesis in a pattern. A literal pattern, e.g. true, or 0. A literal pattern list, e.g.  p1,p2,p3. A double pattern match, e.g. p1@@p2. The dot of two patterns, e.g. p1.p2. (The concatenation of two patterns, e.g. p1^p2. HMatches occur on the left hand side of a function declaration and there  is one < for each clause of the declaration. For example, given the  declaration:    f( ) = 0  f( x^xs) = 1+f(xs) there would be two matches. AThe patterns that need to be matched. This is a list of lists as  functions may be curried, like f(x,y)(z) = .... 6The expression to be evaluated if the match succeeds. >The clause of a datatype, e.g. if a datatype declaration was:  & datatype T = A.Int.Bool | B.Bool | C IThen T would have three datatype clauses, one for each of its tags (i.e.  A, B and C). !The name of the datatype clause. ?The expression that gives the set of values that can be dotted B with this clause. For example, in the above example the datatype  clause for A would have Int.Bool as its type expression. 7The negation of an assertion, not currently supported. 2A check of property, like deadlock freedom, e.g.  assert P :[deadlock free [F]]. A refinement assertion, e.g. assert P [F= Q. A print statement, e.g. print x. !The name of the module instance. /The name of the module this is an instance of. 9The arguments of the module that this is an instance of. 6Map from name of this module to name of inner module. 'The module that this is an instance of DA type annotation for the given names. This is only used inside the + parser and never appears in outside ASTs. A timed section, e.g. Timed(f) { P = a -> b -> P }. -The tock instance used - set by the renamer. A module declaration, e.g. &module X(Y,Z) ... export ... endmodule. A nametype declaration, e.g. nametype T2 = T.T. A subtype declaration, e.g. subtype T = Clause1 | Clause2. A datatype declaration, e.g. datatype T = Clause1 | Clause2. A channel declaration, e.g. channel c, d : {0..1}.{0..1}. *An import of a transparent function, e.g. transparent normal. (An import of an external function, e.g.  external test, An assertion in a file, e.g. assert P [T= Q. 0The binding of a pattern to an expression, e.g.  (p,q) = e. A function binding, e.g. func(x,y)(z) = 0. 'A statement in an interactive session. $x:A (see P395 UCS)  ?x:A !xAn expression. 0A timed prefix - only appears after desugaring. /The name used to recurse back to this process. :The original Prefix clause (it MUST be a regular Prefix). 1Used only for parsing - never appears in an AST. 1Used only for parsing - never appears in an AST. /Replicated synchronising external choice, e.g. [+ A +] x : X @ P(x). #Replicated sequential choice, e.g. ; x :  0,1 @ P(x). Replicated parallel, e.g. [| A |] x : X @ P(x).  Replicated link parallel, e.g.  [a.x < - b.x | x <- X(y)] y : Y @ P(y). The tied events. The statements for the ties. The 8s - the process (and ties) are evaluated once for each  value generated by these.  The process !Replicated internal choice, e.g.  |~| x : X @ P(x). Replicated interleave, e.g.  ||| x : X @ P(x). !Replicated external choice, e.g. [] x : X @ P(x). 'Replicated alphabetised parallel, e.g.  || x : X @ [| A(x) |] P(x).  Synchronising interrupt, e.g. P /+A+ Q. $Synchronising external choice, e.g. P [+A+] Q. Sliding choice, e.g. P |> Q. Sequential composition, e.g. P; Q. Event renaming, e.g.  P [[ a.x < - b.x | x <- X ]]. The process that is renamed. .The events that are renamed, in the format of  (old, new). The statements for the ties. Event prefixing, e.g.  c$x?y!z -> P. ' Interleaving of processes, e.g. P ||| Q. *GInterrupt (where the left process is turned off once the right process  performs an event), e.g. P / Q. -Internal choice, e.g. P |~| Q. 0Hiding of events, e.g. P  A. 1&The process the hiding is applied to. 2 The set of events to be hidden. 3Guarded expressions, e.g. b & P where b is a boolean expression.  This is equivalent to if b then P else STOP. 6Generalised parallel, e.g. P [| A |] Q. :External choice, e.g. P [] Q. =Exception operator, e.g.  P [| A |> Q. AAlphabetised parallel, e.g.  P [A || B] Q. B Process 1. CAlphabet of process 1. DAlphabet of process 2. E Process 2. FVariables, e.g. x. H Tuples, e.g. (1,2). JGSet of integers between the given values, concatenating all items into  one set, e.g. {x..y | (x,y) < - {(0,1)}}. NASet of integers from the given value, concatenating all adjacent  sets, e.g.  {x.. | x <- {0}}. Q@The bounded set of integers between the two given values, e.g.  {5..6}. RThe lower bound. SThe upper bound. T8The infinite set of integers from the given value, e.g. {5..}. VSet comprehension version of Y, e.g.  {| c.x | x <- xs |}. Y:Enumerated Sets, i.e. sets that complete the events, e.g.  {| c.x |}. [Set comprehensions, e.g.  {x,y | (x,y) <- e}. ^Set literals, e.g. {1,2,3}. `A user provided bracket, e.g. (e). b*Application of unary maths operator, e.g. -x. e+Application of binary maths operator, e.g. x+y. iA literal map, e.g.  (| 1 => 2 |). kThe length of the list, e.g. #list. mHList of integers between the given values, concatenating all items into  one list, e.g.  x..y| (x,y) <- <(0,1)>. qBList of integers from the given value, concatenating all adjacent  lists, e.g.  x.. | x <- <0>. t8Bounded list of integers between the given values, e.g.  1..3. w5Infinite list of integers from the given value, e.g.  1... yList comprehensions, e.g.  x,y | (x,y) <- e. |List literals, e.g.  1,2,3. ~Literals, e.g. true or 1. Let declarations, e.g. let func = e1 within e2. Lambda functions, e.g. (x,y) @ e(x,y). If statements, e.g. if cond then e1 else e2. The condition of the if. The then branch. Dot operator application, e.g. c.x. List concatenation, e.g. x^y. )Application of a unary boolean operator. *Application of a binary boolean operator. Function application. The function. &The arguments applied to the function sghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~sghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~s~|ywtqmkieb`^[YVTQNJHFA=:630-*'" }z{xuvrsnopljfghcda_\]ZWXURSOPKLMIGBCDE>?@;<7894512./+,()#$%& !    |}~xyz{gwvutsrqponmlkjih?gwvutsrqponmlkjihxyz{|}~ ~|ywtqmkieb`^[YVTQNJHFA=:630-*'" }z{xuvrsnopljfghcda_\]ZWXURSOPKLMIGBCDE>?@;<7894512./+,()#$%& !    None&'()*+,-./0123456789:;<=>?vv&'()*+,-./0123456789:;<=>?Noneg      !"#$%&'()*+,-./0123456789:;<=>?@Am      !"#$%&'()*+,-./0123456789:;<=>?m?>=<;:9876543210/.-,+*)('&%$#"!      c?>=<;:9876543210/.-,+*)('&%$#"!      @ANone@DA datatype used to hold which errors and warnings to actually emit. @ABCDEFGHBIJKLM@ABCDEFGHIJKLMEDGHFIJKL@ABCM @ABCDEFGHBIJKLMNoneNOPQRCDEFGHIJKLMNOPQRSTUVNOPQRQRNOPNOPQRCDEFGHIJKLMNOPQRSTUVNoneSTUVWXYZ[\]W^_`aXYZSTUVWXYZ[\]^_`aSTUVWXYZ[\]_^`a S TUVWXYZ[\]W^_`aXYZNone[&The current rename map for variables. \+The current rename map for type-variables. ]/The last source span seen, for error messages. ^Errors that have occured. _1The modules that names should be qualified with. `:The modules that are in scope. Used for module instances. a+The visibility of the names in the module. eInitialises the renamer. fLRuns the renamer starting at the given state and returning the given state. bLReport a message as an error. This will be raised at the outer monad level. cGGiven a module name, runs the provided program in a new scope in which I all variables that were bound with the given module name as a prefix in  scope. dHGiven something annotated and a function that mutates the inner object, D returns the inner object annotated with the same outer annotation. e/Renames the declarations in the current scope. f:Rename a variable on the right hand side of a definition. KIf the variable does not exist it returns an error thunk and adds an error 2 that will be raised when the monad is evaluated. ghijklmnobcdp[\]^_`qrstuvawxyz{|}~efghbcdefbcdefghdcfebhgkghijklmnobcdp[\]^_`qtruvawxyz{|}~sefghbcdefNone.ijk     ijkijk'ijk     NonelmnolmnolmnolmnoNoneImplements non-recursive lets. Implements recursive lets. pqrstuvwxyz{|}~pqrstuvwxyz{|}~qrstuvwxpyz{|}~pqrstuvwxyz{|}~NoneDA disambiguator between different occurences of either processes or K functions. This works by storing the values that are bound (i.e. the free  variables the inner thing# may depend on). This is used as a  and  for s. $The free variables this is bound in AIf A is a datatype clause that has 3 fields a b c then a runtime 0 instantiation of this would be VDot [VDataType A , a, b, c] where a,b  and c can contain other VDots. JGiven a program that yields a value, returns a second program that can be K inserted into the environment, but will cause the environment not to save L the actual value, but to recompute it everytime. This is useful for cheap, H to compute, but high cost in terms of memory, computations (like named  processes). <Implements CSPM comparisons (note that Ord Value does not). BThis assumes that the value is a VDot with the left is a VChannel 8c !"#$%&'()*+T  None!Q,-./0123456789:;<=>?@ Q QQ234567,-./0189:;<=>?@NoneJAttempts to decompose the set into a cartesian product, returning Nothing  if it cannot. ,Is the specified value a member of the set. CCompares two value sets using subseteq (as per the specification). DProduces a ValueSet of the carteisan product of several ValueSets,  using vc9 to convert each sequence of values into a single value. Converts a list to a set Converts a set to list. >The set of all maps from the given domain to the given image. The powerset of the given set %A cartesian product of several sets. 3A set containing all sequences over the given set. A union of several sets. -The infinite set of integers starting at lb. An explicit set of values Set of all processes Set of all integers FReturns the set of all sequences over the input set. This is infinite  so we use a CompositeSet. The empty set 6Returns the value iff the set contains one item only. DThe cardinality of the set. Throws an error if the set is infinite. Is the specified set empty? Replicated union. Replicated intersection. IUnion two sets throwing an error if it cannot be done in a way that will  terminate. JIntersects two sets throwing an error if it cannot be done in a way that  will terminate. '  ABCD#  #     ABCD9None EFGHIJKLM EFGHIJKLM"None N3The number of fields this datatype or channel has. O/Returns true if the value is a complete field. 7Takes two values and dots then together appropriately. KReturns an x such that ev.x has been extended by exactly one atomic field. / This could be inside a subfield or elsewhere. GTakes a datatype or a channel value and then computes all x such that  ev.x is a full datatype/1event. Each of the returned values is guaranteed  to be a VDot. PJTakes a value and returns a set of fields such that ev.x is a full thing. F Further, the field sets are guaranteed to be representable as a full  carteisan product. QJGiven a set of dotted values, and a dotted value, scans the set of dotted F values and calls the specified function for each value that matches. RHGiven two dot lists, the second of which may be an incomplete dot-list, : returns True if the first is a production of the second. DTakes a datatype or a channel value and computes v.x for all x that  complete the value. JTakes a set of dotted values (i.e. a set of VDot _) and returns a list of D sets such that the cartesian product is equal to the original set. 6This throws an error if the set cannot be decomposed. 7Takes a set and returns a list of values xs such that  Union({productions(x) | x <0- xs}) == xs. For example, if c is a channel of + type {0,1} then {c.0, c.1} would return [c]. -This is primarily used for display purposes. NOSPQRTUVWXY  NOSPQRTUVWXY#NoneZ[Z[$NoneHPretty prints the given process and all processes that it depends upon. \]^_`abcdefghijklmnopqrstuvw\]^_`abcdefghijklmnopqrstuvw!None%NonexHTakes a set and returns a function from value to set of values that are  mapped to. y Compute the 'min transitive closure'% of a relation. FDR actually returns G something rather odd in this case. In particular, it takes a relation K (specified as a set of pairs), and a set. It then computes the symmetric, G transitive closure of the relation (note NOT reflexive). It returns a O relation where each element x of the second set is mapped to a representative L value of the second set (if one exists). As this is not reflexive it omits  all pairs of the form (x,x). KNOTE: FDR actually represents the second relation as (rep(x), x), for some  reason. zxy^^zxy&NoneDGiven a list of declarations, returns a sequence of names bounds to  values that can be passed to  in order to bind them in  the current scope. {|}{|}'None None~%Evaluates the statements, evaluating prog for each possible = assingment to the generators that satisfies the qualifiers. %Evaluates the statements, evaluating prog for each possible = assingment to the generators that satisfies the qualifiers. ~~(None=The environment to use initially. This uses the IO monad as A the EvaluationMonad cannot be used without a valid environment. #Evaluates the declaration but doesn'%t add it to the current environment. #Evaluates the declaration but doesn'%t add it to the current environment. >Attempts to convert a process name to a process, if possible.  !"#$%&'()*+     pq{p{q )None                    *None! !"#$%&'()*+,-./012345  !"#$%&'()*+,-./012345  !"&*)#$%+(',-./012435 !"#$%&'()*+,-./012345+NoneOSame as N3, but applies only to the left side of the string. PSame as N4, but applies only to the right side of the string. 6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~HIJKL@DCBA<?>=7;:986MNOPQRSTUVWXYZ[G\]^_`abcedfghijklmnopqrstuvwxyz{|}~EF67;:98<?>=@DCBAEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~,NoneCThrows an error if a declaration that is not allowed inside a let  expression is found. U      !"#$%&'()*+,-./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 [ \ ] ^ _ ` 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 { | } ~    N      !"#$%&'()*+,-./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 [ \ ] ^ _ ` 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 { | } ~    -NoneParse as string as an . Parses a string as an . +Parse the given file, returning the parsed PModules. GParse a string, as though it were an entire file, returning the parsed  PModules. ''.None-Used to represent information about a symbol The type of the symbol Is this symbol deprecated Is this symbols' type too general (if so * use of it will emit a soundness warning) >Make symbol information for the type assuming that the symbol / is not deprecated and its type is not unsafe.  /None:The type environment, which is a map from names to types.  5Location of the current AST element - used for error  pretty printing  3Error stack - provides context information for any  errors that might be raised  Errors that have occured  #List of warnings that have occured  2Stack of attempted unifications - the current one 2 is at the front. In the form (expected, actual). 8The stack of names that we are currently type-checking. #Are we currently in an error state 8The set of datatypes that can be compared for equality. The error options to use *Runs the typechecker, starting from state st. If any errors are  encountered then a " will be thrown with the relevent  error messages. "#Sets the SrcSpan only within prog. ,.Report the error if first parameter is False. 1Report a message as an error 5Get the type of n# and throw an exception if it doesn' t exist. 6ISets the type of n to be t in the current scope only. No unification is  performed. <-Apply compress to the type of a type scheme. =GTakes a type and compresses the type by reading all type variables and > if they point to another type, it returns that type instead. >        !"#$%&'()*+,-./01234 56 789:;<=<[]      !"#$%&'()*+,-./0123456789:;<=<34[]568:;79=<     !"#$'( )+*%&01-.,2/2         !"#$%&'()*+,-./01234 56 789:;<=0None>>>>1None@Map compress. ?@ ?@?@?@ 3None ?Return the free type variables (and their constraints) for all Ws  that occur in 8. B8Generalise the types of the declarations. The parameter names gives the O names that were bound by all the declarations that we are interested in. This = is done because we convert a type T into forall vs T where  vs = fvts (T) - fvts(Env) H where Env does not contain the function whose type we are generalizing E (this is because when we type a declaration we are really typing a  lambda function). C<Instantiates the typescheme with some fresh type variables. Does a occur somewhere in t. ECUnifys all types to a single type. The first type is used as the " expected Type in error messages. JTakes a constraint and a type and returns True iff the type satisfies the J constraint, or can be made to satsify the constraint by appropriate type D substitutions, in which case the type substitutions are performed. F/Takes a type and converts TDot t1 t2 to [t1, t2]. Takes a :$ and returns a tuple consisting of: @ the arguments that it takes and the ultimate return type. Note C that due to the way that TDotables are introduced the return type  is guaranteed to be simple. 0 This requires that its argument is compressed. )We convert all TDotable (TDot t1 t2) to A TDotable t1 (TDotable t2...). Thus every argument of a TDotable  is not a TDot. :Takes two type lists and unifies them into one type list. HJThe main type unification algorithm. This adds values to the unification 6 stack in order to ensure error messages are helpful. Unifies the types but doesn't add a pair to the stack. =Raises a unification error. If the passed flag is True then O any dots are not evaluated in the error. This is to avoid infinite loops that + can occur, for example, whilst unifiying: ! [TDotable TInt (TDatatype (Name A)),TBool] ! [TDotable TInt (TDatatype (Name A)),TBool] <Applies a subtitution directly to the type. This is used in E type instantiation where we create a fresh type for each universal  variable J7Takes a type and attempts to simplify all TDots inside , by combining TDotable t1 t2 and arguments.     BCD E FG H   I J   BCDEFGHIJ BCHEJFGID    BCD E FG H   I J  4NoneKLMNOPQRSTUVWXY KLMNOPQRSTUVWXYKLMNOPQRSTUVWXY KLMNOPQRSTUVWXY :None    ;None FThe first argument is a type constructor, which given a type, returns + that type encapsulate in some other type. KType check a series of statements. For each statement a new scope is added @ to ensure that clauses only depend on variables already bound. "Shortcut for replicated operators               2NoneA;Type check a list of possibly mutually recursive functions EType checks a group of certainly mutually recursive functions. Only H functions that are mutually recursive should be included otherwise the ( types could end up being less general. ATakes a type and returns the inner type, i.e. the type that this @ is a set of. For example TSet t1 -> t, TTuple [TSet t1, TSet t2] -> (t1, t2). E The type that is returned is guaranteed to satisfy Eq since, at the H recursion only bottoms out on reaching something that is of type TSet. A      ! " # $ % & ' ( )AAA      ! " # $ % & ' ( )<None * + * +=None , - , -5NoneZ[\]^_ @Z[\]^_ ]\^_@[ZZ[\]^_6None+`A basic implementation of a , using the  . monad. This $ prints out any warnings to stdout. aGThe CSPMMonad is the main monad in which all functions must be called. 0 Whilst there is a build in representation (see `) it is recommended  that you define an instance of a over whatever monad you use. bGet the current session. cUpdate the current session. d.This is called whenever warnings are emitted. eA e3 represents the internal states of all the various  components. /The state of the renamer. 0The state of the type checker. 1The state of the evaluator. f Create a new e. g6Executes an operation giving it access to the current e. 2/Modifies the session using the given function. hFGiven a program that can return warnings, runs the program and raises  any warnings found using d. iRuns a `; function, returning the result and the resulting session. jRuns the parser. k Parse a file fp . Throws a  on any parse error. lAParses a string, treating it as though it were a file. Throws a   on any parse error. m Parses a  . Throws a  on any parse error. n Parses an  . Throws a  on any parse error. o#Runs renamer in the current state. pRenames a file. qRenames an expression. r"Rename ian interactive statement. s8Get a list of currently bound names in the environment. tJRuns the typechecker in the current state, saving the resulting state and % returning any warnings encountered. uAType checks a file, also desugaring and annotating it. Throws a  * if an error is encountered and will call d on / any warnings. This also performs desugaraing. vType checks a . wType checkes a 1, returning the desugared and annotated version. xGiven a 8, ensures that the ! is of that type. It returns the $ annoated and desugared expression. y8Gets the type of the expression in the current context. zJReturns all currently bound process names, optionally including functions  that evaluate to processes {;Returns the type of the given name in the current context. LThe file in which this name has been bound must have been typechecked using  typeCheckFile. }-Desugar a file, preparing it for evaulation. ~Desugars an expression. #Desugars an interactive statement. ERuns the evaluator in the current state, saving the resulting state. ITakes a declaration and adds it to the current environment. Requires the  declaration to be desugared. GBinds all the declarations that are in a particular file. Requires the  file to be desugared. IEvaluates the expression in the current context. Requires the expression  to be desugared. CObtains the profiling data that the evaluator has produced so far. HGiven a process name, attempts to convert the name into a process. This 7 is only possible for top-level function applications. DTakes an expression string and a type and evaluates the expression, 2 providing the expression is of the correct type. 2Return the version of libcspm that is being used. /`abcde 3 / 0 1fg 2hijklmnopqrstuvwxyz7If true includes functions that evaluate to processes. {|}~ 4 5X !"#$%&'()*+ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~`abcdefghijklmnopqrstuvwxyz{|}~2efabcdg`ilkmnprqsuvwxy|{z}~joth(`abcde 3 / 0 1fg 2hijklmnopqrstuvwxyz{|}~ 4 57None!The type of options for libcspm. The default set of options. "All options for the type-checker. $All available command line options. &Sets the options to the values given.  6>?@ABCABDABEABFABGABHABIABJABKABLABLABMABNABOABPABQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~t                            !"#$%&'()*+,-./01123456789:;<=>?@ABCDEFGHIJJKLMNOPQRSTUUVWXYZ[\]^_`^abcdefghijklmnopqrstuvwxyz{|}~F      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc@defghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHlIJKLMNOPQRSTUVWXYZ[\]^_`tabbcdefghijklmnopqrstuvwxyz{|}~  !!!!!!!!!!!!!!W"""""""""###$ ! ! ! ! !!%&'((((((((((((())) )!)")#)$)%)&)')()))*)+*,*-*-*.*/*0*1*2*3*4*4*5*6*7*7*8*9*:*;*<*=*>*?*@*A*B*C*D*E*F*G*H+I+J+K+I+L+J+M+N+M+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+{+|+}+~+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,----....x.v..y. ..... .E/ / / // ///////////////////// /!/"/#/$/%/&/'/(/)/*/+/,/-/.///0/1/2/3/4/5/6//7/v/y/8/9/:/;/<01=1>2?3@3A3B3C3D3E3F3G3H4I4J4K4L4M4N4O4P4Q4R4S4T4U4V4W55X5K5J5Y5Z666[6\6]6^6_6`6a6b6c6d66666e6f6g6h66i6j6k6l6m6n6o6Z6p6q6r6s6t6u66v666w6x7y7y7z7{7|7}7~> >     ABqABAB~AB}AB|AB{ABzAByABxABwABvABuABtABsABrABpABoABnABABkABjABiABmABlABhABgABfABeABdABcABbABaAB`AB_AB^AB]AB\AB[ABZABYABXABWABVABUABTABSABR              88888888888       !"#$%&'fop(())*+,-.,/0123456789:;<<=>??@ABCDEFGH7IJKLMNOPQRSTUV$WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  op>>>>>>>>>>>>>>>>>999999999""""""""""""##$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$%%%& &!&" # $ % & ' ( ) * + , - . / 0 1 2*3+4,5,6,7,8,8,9,:,;,<,=,>,?,@,@,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,[,\,],^,_,`,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,{,|,},~,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, , , , , ,,,,,,,,,,,,,,,,,,, ,!,",#,$,%,&,',(,),*,+,,,-,.,/,0,1,2,3,4,5,6,7,8,9,:,;,<,=,>,?,@,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,[,\,],^,_,`,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,{,|,},~,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, :, ;, <, =, >, ?, @, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, [, \, ], ^, _, `, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, {, |, }, ~, , , , , , / / /#/ / 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 3x3 3 3 3 3 3 3 3t3 3 3 3 3 3 3 3 3 3 3 3 4 : : ; ; ; ; ; ; ; 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 < < = =  6 6 6 6 6_6 6 libcspm-1.0.0Util.ExceptionUtil.MonadicPrettyPrintInternalData.Set.MutableBitUtil.FuzzyLookup Util.List Data.Graph.STCSPM.Evaluator.Profiler Util.Monad Util.PreludeUtil.PrecedenceUtil.MonadicPrettyPrintUtil.PrettyPrintUtil.AnnotatedCSPM.DataStructures.LiteralsUtil.PartialFunctionsUtil.HierarchicalMapCSPM.Evaluator.ValuesCSPM.Evaluator.ProcessValuesCSPM.Evaluator.ValueSetCSPM.DataStructures.NamesCSPM.DataStructures.TypesCSPM.DataStructures.SyntaxCSPM.PrettyPrinterCSPM.Parser.TokensCSPM.TypeChecker.ExceptionsCSPM.DataStructures.FreeVars CSPM.Prelude CSPM.Renamer CSPM.DesugarCSPM.Evaluator.EnvironmentCSPM.Evaluator.MonadCSPM.Evaluator.ExprCSPM.Evaluator.ExceptionsCSPM.Evaluator.DotCSPM.Evaluator.PatBind!CSPM.Evaluator.ValuePrettyPrinterCSPM.Evaluator.BuiltInFunctionsCSPM.Evaluator.DeclBindCSPM.Evaluator.FileCSPM.EvaluatorCSPM.Parser.ExceptionsCSPM.Parser.MonadCSPM.Parser.LexerCSPM.Parser.Parser CSPM.ParserCSPM.TypeChecker.EnvironmentCSPM.TypeChecker.Monad!CSPM.TypeChecker.BuiltInFunctionsCSPM.TypeChecker.CompressorCSPM.TypeChecker.DeclCSPM.TypeChecker.UnificationCSPM.TypeChecker.CommonCSPM.TypeCheckerCSPMCSPM.CommandLineOptions Paths_libcspmCSPM.Evaluator.DeepSeqCSPM.TypeChecker.PatCSPM.TypeChecker.ExprCSPM.TypeChecker.File CSPM.TypeChecker.InteractiveStmtbase GHC.Exception Exceptionpretty-1.1.1.0Text.PrettyPrint.HughesPJstyleDocChrStrPStr TextDetailsribbonsPerLine lineLengthmodeStylePageMode ZigZagModeLeftMode OneLineModeModechartextptext sizedText zeroWidthTextemptyisEmptysemicommacolonspaceequalslparenrparenlbrackrbracklbracerbraceintintegerfloatdoublerationalparensbracketsbracesquotes doubleQuoteshcathsepvcatnesthang punctuate$$$+$<><+>sepcatfcatfseprender renderStyle fullRenderSetnewSizedmemberinsertremove fuzzyMatch fuzzyLookupnoDups replaceLastcartesianProductGraphSCC CyclicSCC AcyclicSCCsuccessorNodesnewGraphnewGraphNoDupeNodessccs#nonReflexiveRepresentativesForNodes ProfilerState concatMapMandMorMwhenMthenCmp expandPathIOtrim cartProduct Precedence precedence associativity sameOperator Associativity AssocRight AssocLeft AssocNoneMonadicPrettyPrintable prettyPrintprettyPrintBriefprettyPrintPrecprettyPrintBriefPrec ppBinaryOp ppBinaryOp'tabWidthcommaSeparatedInt shortDouble tabIndentanglesbarsdotSeplistspeakNthpunctuateFrontellipsisPrettyPrintableLocatedSrcSpanSrcLoc combineSpansLiteralStringCharBoolIntMonadIOExceptiontryMtryM'convertExceptionsToPanicsfinallyLibCSPMException UserError SourceErrorPanic ErrorMessageWarningMessagelocationmessage ErrorMessagesmkErrorMessagemkWarningMessagethrowSourceErrorpanicthrowException AnnotatedAnloc annotationinnerL locatedLoc locatedInnerBuiltInUnknown SrcSpanPoint srcSpanColSrcSpanMultiLine srcSpanSLine srcSpanELineSrcSpanOneLine srcSpanFile srcSpanLine srcSpanSCol srcSpanEColNoLoc srcLocFile srcLocLine srcLocCol srcSpanStart srcSpanEnddummyAnnotation unAnnotatePartialFunctionfunctionDomain functionImageidentityFunctioninvertapply applyRelation safeApplycomposeFunctionsmapPF safeMapPFupdatePF removeEntryHierarchicalMapExceptionValueNotFoundExceptionHierarchicalMapupdate updateMultilookup maybeLookupmaybeLookupInTopLayerpopLayerflattennewLayernewLayerAndBindnewRecursiveLayerAndBindnewmapScopeIdentifierValuetrimValueForProcessNameUnCompiledProcOperatorUnCompiledOperatorUnCompiledProcProc PProcCallPOp PBinaryOpPUnaryOp CSPOperatorPSynchronisingInterruptPSynchronisingExternalChoicePSlidingChoicePSequentialCompPRenamePPrefix POperator PLinkParallel PInterleave PInterruptPInternalChoicePHide PGenParallelPExternalChoice PExceptionPAlphaParallel ProcOperator WeakBisim TauLoopFactor StrongBisim Prioritise ModelCompress Normalize ExplicateDiamond DeterminiseChaseProcNameEventSetEventMapEvent UserEventTickTaueventSetFromList trimProcessoperator componentssplitProcIntoComponentsCartProductType CartTupleCartDotValueSet difference unDotProductcompareValueSetsfromListtoListNameType WiredInName InternalName ExternalNameNamenameTypenameFullyQualifiednameDefinition nameUniquenameIsConstructor UnRenamedNameQualunRenamedNameModuleNameunRenamedNameMemberNameUnQualOccNamemkExternalNamemkInternalNamemkFreshInternalName mkWiredInNameisNameDataConstructor PSymbolTablePType SymbolTable TypeVarRefRigidTypeVarRef rigidNametypeVar constraints typePointerType TDatatypeTDotable TFunctionTTupleTMap mapKeyType mapValueTypeTDotTSeqTSetTExtendableEmptyDotList TExtendableextendableUltimateTypeextendableArgumentTEventTCharTBoolTIntTProcTVar Constraint CYieldableCSet CInputableCOrdCEq TypeSchemeForAlltypeSchemeVariablestypeSchemeTypeTypeVarconstraintImpliedByreduceConstraintsisRigid freshTypeVarfreshTypeVarReffreshTypeVarWithConstraints freshRigidTypeVarWithConstraints readPTypesetPType freshPTypereadPSymbolTablesetPSymbolTablefreshPSymbolTableprettyPrintTypescollectConstraintsSTypeSTEventSTCharSTBoolSTIntSTProc STDatatypeSTMapSTParen STDotable STFunctionSTTupleSTDotSTSeqSTSet STExtendableSTVarSTypeConstraintstypeConstraintNamestypeConstraintVariable STypeSchemestypeSchemeFreeVarsstypeSchemeTypeConstraintsstypeSchemeTypePatPCompDot pDotItemspDotOriginalpattern PCompListpListStartItemspListMiddleEndItemspListOriginalPattern PWildCardPVar pVarIdentityPTuple pTupleItemsPSet pSetItemsPParen pParenPatternPLit pLitLiteralPList pListItemsPDoublePatternpDoublePatLeftPatpDoublePatRightPatPDotApp pDotLeftPat pDotRightPatPConcatpConcatLeftPatpConcatRightPatMatch matchPatternsmatchRightHandSideDataTypeClausedataTypeClauseNamedataTypeClauseTypeExpressionSemanticPropertyLivelockFreedom DeterministicDeadlockFreedom ModelOption TauPriorityModelRevivalsDivergencesRevivalsRefusalsDivergencesRefusalsFailuresDivergencesFailuresTraces AssertionASNot PropertyCheckpropertyCheckProcesspropertyCheckPropertypropertyCheckModel RefinementrefinementSpecificationrefinementModelrefinementImplementationrefinementModelOptionsDeclPrintStatementprintStatementModuleInstancemoduleInstanceNamemoduleInstanceOfmoduleInstanceOfArgumentsmoduleInstanceNameMapmoduleInstanceOfDeclarationParsedTypeAnnotation TimedSectiontimedSectionTockNametimedSectionFunctiontimedSectionContentsModule moduleNamemoduleArgumentsmodulePrivateDeclarationsmoduleExportedDeclarationsSubTypeDataTypeChannel TransparenttransparentImportedNamesExternalexternalImportedNamesAssertPatBindFunBindInteractiveStmt RunAssertionBindEvaluateStmt Qualifier GeneratorField NonDetInputInputOutputExp TimedPrefixtimedPrefixRecursionNametimedPrefixOriginalPrefixExpPatDoublePatternExpPatWildCard%ReplicatedSynchronisingExternalChoice!repSynchronisingExtChoiceAlphabet-repSynchronisingExtChoiceReplicatedStatements repSynchronisingExtChoiceProcessReplicatedSequentialComprepSeqCompStatementsrepSeqCompProcessReplicatedParallelrepParAlphabetrepParReplicatedStatements repParProcessReplicatedLinkParallelrepLinkParTiedChannelsrepLinkParTieStatementsrepLinkParReplicatedStatementsrepLinkParProcessReplicatedInternalChoice repIntChoiceReplicatedStatementsrepIntChoiceProcessReplicatedInterleave!repInterleaveReplicatedStatementsrepInterleaveProcessReplicatedExternalChoice repExtChoiceReplicatedStatementsrepExtChoiceProcessReplicatedAlphaParallelrepAlphaParReplicatedStatementsrepAlphaParAlphabetrepAlphaParProcessSynchronisingInterrupt!synchronisingInterruptLeftProcesssynchronisingInterruptAlphabet"synchronisingInterruptRightProcessSynchronisingExternalChoice&synchronisingExternalChoiceLeftProcess#synchronisingExternalChoiceAlphabet'synchronisingExternalChoiceRightProcess SlidingChoiceslidingChoiceLeftProcessslidingChoiceRightProcessSequentialCompseqCompLeftProcessseqCompRightProcessRename renameProcessrenameTiedEventsrenameTieStatementsPrefix prefixChannel prefixFields prefixProcess LinkParallellinkParLeftProcesslinkParTiedEventslinkParTieStatementslinkParRightProcess InterleaveinterleaveLeftProcessinterleaveRightProcess InterruptinterruptLeftProcessinterruptRightProcessInternalChoiceintChoiceLeftProcessintChoiceRightProcessHiding hidingProcesshidingAlphabet GuardedExpguardedExpConditionguardedExpProcess GenParallelgenParallelLeftProcessgenParallelAlphabetgenParallelRightProcessExternalChoiceextChoiceLeftProcessextChoiceRightOperatorexceptionLeftProcessexceptionAlphabetexceptionRightProcess AlphaParallelalphaParLeftProcessalphaParAlphabetLeftProcessalphaParAlphabetRightProcessalphaParRightProcessVar varIdentityTuple tupleItemsSetEnumFromToCompsetEnumFromToCompLowerBoundsetEnumFromToCompUpperBoundsetEnumFromToCompStatementsSetEnumFromCompsetEnumFromCompLowerBoundsetEnumFromCompStatements SetEnumFromTosetEnumFromToLowerBoundsetEnumFromToUpperBound SetEnumFromsetEnumFromLowerBound SetEnumCompsetEnumCompItemssetEnumCompStatementsSetEnum setEnumItemsSetComp setCompItemssetCompStatementssetItemsParenparenExpression MathsUnaryOpmathsUnaryOpOperatormathsUnaryOpExpression MathsBinaryOpmathsBinaryOpOperatormathsBinaryOpLeftExpressionmathsBinaryOpRightExpressionMapmapKeyValuePairs ListLengthlistLengthExpressionListEnumFromToComplistEnumFromToCompLowerBoundlistEnumFromToCompUpperBoundlistEnumFromToCompStatementsListEnumFromComplistEnumFromCompLowerBoundlistEnumFromCompStatementsListEnumFromTolistEnumFromToLowerBoundlistEnumFromToUpperBound ListEnumFromlistEnumFromLowerBoundListComp listCompItemslistCompStatementsList listItemsLit litLiteralLetletDeclarations letExpressionLambdalambdaBindingPatternslambdaRightHandSideIf ifCondition ifThenBranch ifElseBranchDotAppdotAppLeftArgumentdotAppRighArgumentConcatconcatLeftListconcatRightListBooleanUnaryOpunaryBooleanOpOperatorunaryBooleanExpressionBooleanBinaryOpbooleanBinaryOpOperatorbooleanBinaryOpLeftExpressionbooleanBinaryOpRightExpressionApp appFunction appArguments BinaryMathsOpTimesPlusModMinusDivide UnaryMathsOpNegateUnaryBooleanOpNotBinaryBooleanOp GreaterThanEq LessThanEq GreaterThanLessThan NotEqualsEqualsOrAndCSPMFileTCSTypeTCSTypeConstraint TCSTypeSchemeTCInteractiveStmt TCAssertionTCDataTypeClauseTCStmtTCFieldTCExpTCPatTCMatchTCDecl TCCSPMFilePSTypePSTypeConstraint PSTypeSchemePInteractiveStmt PAssertionPDataTypeClausePFieldPStmtPExpPPatPMatchPDecl PCSPMFileAnSTypeAnSTypeConstraint AnSTypeSchemeAnInteractiveStmt AnAssertionAnDataTypeClauseAnStmtAnFieldAnExpAnPatAnMatchAnDecl AnCSPMFilegetTypegetSymbolTableallAssertionsInFileallPrintStatementsInFileprettyPrintMatchLTokenTokenTEOFTRMapTLMapTRSyncExtChoiceTLSyncExtChoiceTRSyncInterruptTLSyncInterrupt TParallel TRExceptionTSlidingChoice TInterruptTPrefix TInterleave TIntChoice TExtChoice TRSqBracket TLSqBracketTRPipeSqBracketTLPipeSqBracketTRDoubleSqBracketTLDoubleSqBracket TRPipeBrace TLPipeBraceTRBraceTLBraceTRParenTLParenTHashTConcat TEmptySeq TCloseSeqTModTDivideTTimesTMinusTPlusTGtTLtTGtEqTLtEqTNotEqTEqTOrTAndTNotTGuard TSemiColon TNameType TTransparent TExternalTSubType TDataType TAssertNotTAssertTChannel TLambdaDot TBackSlashTWithinTLetTElseTThenTIf TWildCard TDoubleAtTTie TDrawnFromTColon TDoubleDotTPipeTDollar TQuestionMarkTExclamationMarkTCommaTTimed TYieldStarTYieldTOfType TInstanceTScope TEndModuleTExportsTModule TDefineEqualTNewLineTDeterministic TLivelockFreeTDivergenceFree TDeadlockFree TTauPriorityTModelTRefinesTPrintTIdentTTrueTFalseTStringTInteger ErrorOptionswarnDeprecatedNamesUsedwarnUnsafeNamesUsedWarningErrorincorrectArgumentCountMessageinfiniteUnificationMessageunificationErrorMessage!constraintUnificationErrorMessagedeprecatedNameUsedunsafeNameUsed&illegalModuleInstanceCycleErrorMessagedefaultErrorOptionsFreeVarsfreeVars freeVars' BoundNames boundNamesname stringName isDeprecateddeprecatedReplacement typeScheme isTypeUnsafe isExternalisHidden isTransparent builtInNamebuiltinstransparentFunctionForOccNameexternalFunctionForOccNamerename RenamerMonad RenamerState initRenamerrunFromStateToState getBoundNamesnewScope Desugarabledesugar runDesugar EnvironmentEvaluationMonadEvaluationState environmentparentScopeIdentifiercurrentExpressionLocation timedSection profilerStatedoRuntimeRangeChecksgetsmodify runEvaluatorgetStategetEnvironmentlookupVarMaybeThunkaddScopeAndBindaddScopeAndBindM throwErrorgetParentScopeIdentifierupdateParentScopeIdentifiersetCurrentExpressionLocationgetCurrentExpressionLocation throwError' setTimedCSP maybeTimedCSPFunctionIdentifier FMatchBindargumentGroupsscopeIdentifierFLambdalambdaExpressionparentFunctionIdentifierFBuiltInFunction functionName arguments SVariableBindvariablesBound SFunctionBindscopeFunctionNamescopeFunctionArgumentsVThunkVProc VFunctionVSetVMapVList VDataTypeVChannelVDotVTupleVBoolVCharVInt UProcOperatorUProc tupleFromListnoSave maybeSave removeThunk lookupVar compareValuesprocNamescopeIdannonymousScopeIdvalueEventToEvent Evaluatableeval ProfilingDataProfilerOptionsisActiveflattenRecursiveCallsdefaultProfilerOptionsprofilerActiveinitialProfilerStatemaybeRegisterCall registerCallgetProfilingDatasetNotRectangularErrorMessagedotIsNotValidMessagecannotDifferenceSetsMessagecardOfInfiniteSetMessagecannotCheckSetMembershipError#cannotConvertProcessesToListMessage"cannotConvertIntegersToListMessagetypeCheckerFailureMessage,replicatedInternalChoiceOverEmptySetMessage'+replicatedInternalChoiceOverEmptySetMessage!funBindPatternMatchFailureMessagetailEmptyListMessageheadEmptyListMessagepatternMatchFailureMessageAllMapsPowersetCartesianProduct AllSequences CompositeSet IntSetFrom ExplicitSet ProcessesIntegerspowerset allSequencesallMapsemptySettoSeqsingletonValuecardunionsinfiniteUnions intersectionsunion intersectionvalueSetToEventSetfastUnDotCartProduct dataTypeInfo combineDotsoneFieldExtensions extensions extensionsSet productionsproductionsSetsplitIntoFieldscompressIntoEnumeratedSetBindablebindbindAllprettyPrintAllRequiredProcessesprintCallStackpatternMatchesFailureMessageprioritiseEmptyListMessagedivideByZeroMessagekeyNotInDomainOfMapMessage)replicatedLinkParallelOverEmptySeqMessageinjectBuiltInFunctions bindDeclsbindFileEvaluatorOptionsruntimeRangeChecksprofilerOptionsdefaultEvaluatorOptions initEvaluator evaluateExp evaluateDecl evaluateFileaddToEnvironmentmaybeProcessNameToProcess profilingDatainvalidPatternErrorMessage!invalidLetDeclarationErrorMessage$invalidModuleDeclarationErrorMessage*invalidTimedSectionDeclarationErrorMessageinvalidExpressionErrorMessageinvalidFunctionArgsErrorMessageinvalidIncludeErrorMessagelexicalErrorMessageparseErrorMessagefileAccessErrorMessageambiguousTypeAnnotationsErrorunusedTypeAnnotationsErrorunknownConstraintErrordefinitionSpanFileError ParseMonadFileParserState tokenizerPosfileNameinput previousCharcurrentStartCode sequenceStack ParserStaterootDir fileStack FilePositionfilePositionToSrcLocmovePos runParsergetTopFileParserStategetParserStatesetParserStatemodifyTopFileParserStatepushFilepushFileContentsgetTokenizerPos getFileNamegetInputgetPreviousChargetCurrentStartCodegetSequenceStacksetCurrentStartCodesetSequenceStack AlexAccPredAlexAccAlexAccSkipPred AlexAccSkip AlexLastAcc AlexLastSkipAlexNone AlexReturn AlexTokenAlexSkip AlexErrorAlexEOFAlexAddrAlexA# AlexInput alex_base alex_table alex_check alex_deflt alex_acceptwscharsstriplstriprstripopenseqcloseseqgtsoakToksoakTok'tokstokskip takeChars nestedComment switchInputbeginbegin'alexInputPrevChar alexGetByte alexGetChar getNextTokengetNextTokenWrapperassertsem_propsoak alex_action_0 alex_action_1 alex_action_2 alex_action_3 alex_action_4 alex_action_5 alex_action_6 alex_action_7 alex_action_8 alex_action_9alex_action_10alex_action_11alex_action_12alex_action_13alex_action_14alex_action_15alex_action_16alex_action_17alex_action_18alex_action_19alex_action_20alex_action_21alex_action_22alex_action_23alex_action_24alex_action_25alex_action_26alex_action_27alex_action_28alex_action_29alex_action_30alex_action_31alex_action_32alex_action_33alex_action_34alex_action_35alex_action_36alex_action_37alex_action_38alex_action_39alex_action_40alex_action_41alex_action_42alex_action_43alex_action_44alex_action_45alex_action_46alex_action_47alex_action_48alex_action_49alex_action_50alex_action_51alex_action_52alex_action_53alex_action_54alex_action_55alex_action_56alex_action_57alex_action_58alex_action_59alex_action_60alex_action_61alex_action_62alex_action_63alex_action_64alex_action_65alex_action_66alex_action_67alex_action_68alex_action_69alex_action_70alex_action_71alex_action_72alex_action_73alex_action_74alex_action_75alex_action_76alex_action_77alex_action_78alex_action_79alex_action_80alex_action_81alex_action_82alex_action_83alex_action_84alex_action_85alex_action_86alex_action_87alex_action_88alex_action_89alex_action_90alex_action_91alex_action_92alex_action_93alex_action_94alex_action_95alex_action_96alex_action_97alex_action_98alex_action_99alex_action_100alex_action_101alex_action_102alex_action_103alex_action_104alex_action_105alex_action_106alex_action_107alex_action_108alex_action_109alex_action_110alex_action_111alex_action_112alex_action_113alex_action_114alex_action_115alex_action_116alex_action_117alex_action_118alex_action_119alex_action_120alex_action_121alex_action_122alex_action_123alex_action_124alex_action_125alexIndexInt16OffAddralexIndexInt32OffAddr quickIndexalexScan alexScanUser alex_scan_tkn alexAndPredalexPrevCharIsalexPrevCharMatchesalexPrevCharIsOneOfalexRightContextiUnbox parseFile_parseInteractiveStmt_parseExpression_parseInteractiveStmtparseExpression parseFileparseStringAsFileSymbolInformationdeprecationReplacementmkSymbolInformationdeleteTypeCheckMonadTypeInferenceStatesrcSpan errorContextserrorswarningsunificationStackdefinitionStackinErrorsymUnificationAllowedcomparableForEqualityDataTypes errorOptions ErrorContextnewTypeInferenceStaterunTypeCheckermodifyErrorOptionslocalgetErrorContextsaddErrorContext getWarnings resetWarnings addWarning getInError setInError getSrcSpan setSrcSpangetUnificationStackaddUnificationPairaddDefinitionNamegetDefinitionStacksymmetricUnificationAlloweddisallowSymmetricUnification#markDatatypeAsComparableForEquality%unmarkDatatypeAsComparableForEqualitydatatypeIsComparableForEquality errorIfFalsemanyErrorsIfFalse errorIfFalseMfailMraiseMessageAsErrorraiseMessagesAsError tryAndRecover readTypeRef writeTypeRefsetTypemarkAsDeprecatedmarkTypeAsUnsafereplacementForDeprecatedNamecompressTypeSchemecompress Compressable mcompresstypeCheckDeclsgeneraliseGroup instantiate instantiate'unifyAll typeToDotListdotableToDotListunifysubstituteTypes evaluateDots TypeCheckable typeChecktypeCheckExpect typeCheck' errorContextensureAreEqual ensureIsList ensureIsSet ensureIsBool ensureIsIntensureIsChannelensureIsExtendable ensureIsEvent ensureIsProcensureHasConstraintinitTypeChecker typeOfExp typeOfName CSPMMonad getSession setSessionhandleWarnings CSPMSessionnewCSPMSession withSessionreportWarningsunCSPMrunParserInCurrentStaterunRenamerInCurrentState renameFilerenameExpressionrenameInteractiveStmtrunTypeCheckerInCurrentState typeCheckFiletypeCheckInteractiveStmttypeCheckExpressionensureExpressionIsOfTypetypeOfExpressionboundProcessNamesmodifyTypeCheckerErrorOptions desugarFiledesugarExpressiondesugarInteractiveStmtrunEvaluatorInCurrentStatebindDeclarationevaluateExpression stringToValuegetLibCSPMVersionOptions tcOptionsdefaultOptionstypeCheckerOptions allOptions setOptionsGHC.Base++ghc-prim GHC.TypesTrueBucketbucketBitCount$restrictedDamerauLevenshteinDistance/restrictedDamerauLevenshteinDistanceWithLengths%restrictedDamerauLevenshteinDistance'*restrictedDamerauLevenshteinDistanceWorkersizedComplement matchVectorsintSccsnodeMap invNodeMapsuccessorsArraysuccessorStarts nodeCount HashTable nodesOfSccmapM'successorsForNodeEQ maybeParen GHC.Classes<>.ArgumentRightArgLeftArgprettyPrintPrec' needsParenfirst reduceDoc$fPrettyPrintableLiteral$fMonadIOExceptionStateT$fMonadIOExceptionStateT0$fMonadIOExceptionIO$fExceptionLibCSPMException$fShowLibCSPMException$fShowErrorMessage$fPrettyPrintableErrorMessage$fPrettyPrintable[]$fOrdErrorMessage$fEqErrorMessage$fHashableAnnotated $fOrdLocated$fOrdAnnotated $fEqLocated $fEqAnnotated$fPrettyPrintableLocated$fPrettyPrintableAnnotated $fShowLocated$fShowAnnotated$fPrettyPrintableSrcSpan $fShowSrcSpan $fOrdSrcSpan $fOrdSrcLoc#$fExceptionHierarchicalMapExceptioncatchIOversionbindirlibdirdatadir libexecdir getBinDir getLibDir getDataDir getLibexecDirgetDataFileName errorThunk trimEvent trimOperator $fHashableSeq $fOrdProc$fHashableProc$fEqProc$fHashableCSPOperator$fHashableProcOperator$fHashableEventnameUniqueSupplytakeNameUnique $fShowName$fMonadicPrettyPrintablemName$fPrettyPrintableName $fOrdName$fHashableName$fEqName&$fMonadicPrettyPrintablemUnRenamedName$fPrettyPrintableUnRenamedName $fMonadicPrettyPrintablemOccName$fPrettyPrintableOccNameVarMap typeVarSupplytakeTypeVarFromSupplyvariableMapForTypeVars$fPrettyPrintableTypeScheme#$fMonadicPrettyPrintableReaderTType$fPrecedenceType$fPrettyPrintableType$fPrettyPrintableConstraint$fShowTypeVarRef$fOrdTypeVarRef$fEqTypeVarRef$fPrettyPrintableTypeVarppTieppRenameppRepOpppCompppComp'ppBinOpppBinOp'$fPrettyPrintableStmt$fPrettyPrintableField$fPrettyPrintableExp$fPrettyPrintableUnaryMathsOp$fPrettyPrintableBinaryMathsOp$fPrettyPrintableUnaryBooleanOp $fPrettyPrintableBinaryBooleanOp$fPrettyPrintablePat$fPrettyPrintableDataTypeClause!$fPrettyPrintableSemanticProperty$fPrettyPrintableModelOption$fPrettyPrintableModel$fPrettyPrintableAssertion$fPrettyPrintableDecl$fPrettyPrintableSType $fPrettyPrintableSTypeConstraint$fPrettyPrintableSTypeScheme $fPrettyPrintableInteractiveStmt$fPrettyPrintableCSPMFile$fPrettyPrintableToken $fShowToken printOrigins freeVarsStmts$fFreeVarsDataTypeClause$fFreeVarsMatch$fFreeVarsModelOption$fFreeVarsAssertion$fFreeVarsDecl$fFreeVarsField$fFreeVarsStmt $fFreeVarsExp $fFreeVarsPat$fFreeVarsAnnotated$fFreeVarsMaybe $fFreeVars[]$fBoundNamesField$fBoundNamesStmt$fBoundNamesPat$fBoundNamesDataTypeClause$fBoundNamesDecl$fBoundNames[]$fBoundNamesAnnotatedbMap allBuiltins makeBuiltins $fEqBuiltIntypeEnvironmentcurrentModuleQualificationStack foundModulesnameVisibility addErrorsprefixNamesFromScope reAnnotaterenameDeclarations renameVarRHSModuleNameCheckFreeVarElement NameMaker RenamableModuleInformationModuleInstanceInformationresolvedTarget declarationrenamedDeclarationtypeNameVisibilitypublicBoundModulesprivateBoundModulespublicBoundLabelsprivateBoundLabelspublicBoundNamesprivateBoundNamespublicTypeNamesprivateTypeNamesTypeRenameEnvironmentRenameEnvironment RenamedType renamedTyperenamedTypeVisibility RenamedName renamedNamerenamedNameIsModulerenamedNameVisibility VisibilityInstancePrivatePublic addTypeScope lookupTypesetTypeWithVisibilityaddScope lookupNamelookupMaybeHiddenName lookupName'currentVisibilityOfNamequalify qualifyNamesetNamesetNameWithVisibility setModuleNamesetRenamedNameinformationForModuleinformationForModuleNameaddModuleContextresetModuleContext addModuleaddModuleInstanceupdateModuleInformationaddBoundModuleModulesaddBoundModuleLabelsaddBoundModuleBoundNamesaddBoundModuleTypeNamesaddBoundModuleRenamedVersionsetNameVisibilityInModulenameVisibilityInModuletypeNameVisibilityInModulehideBoundNamesunhideModuleNamesexternalNameMakerinternalNameMakerreAnnotatePure timedNamesjoinName concatMapM' renamePatterncheckModuleNameDuplicatescheckDuplicatescheckDuplicates'renameModuleVarcheckFieldsValid renameFieldsrenameStatementssubstituteTyperenameTypeVarThunkrenameTypeVar' renameTypeVar freeTypeVarsduplicatedDefinitionsMessageduplicatedDefinitionsMessage' transparentFunctionNotRecognisedexternalFunctionNotRecognisedvarNotInScopeMessagetypeVarNotInScopeMessagequalifiedVarNotAllowedInPatinvalidFieldsErrorMessageinvalidExtendableTypeVariableinvalidTypeConstraintVariableinvalidTypeConstraintLocation$fRenamableSTypeSType)$fRenamableSTypeConstraintSTypeConstraint!$fRenamableSTypeSchemeSTypeScheme$fRenamableExpExp!$fRenamableModelOptionModelOption$fRenamableAssertionAssertion$fRenamableCSPMFileCSPMFile)$fRenamableInteractiveStmtInteractiveStmt$fRenamableMatchMatch$fFreeVarsModuleNameCheck$fFreeVarsFreeVarElement$fRenamable(,)(,)$fRenamableAnnotatedAnnotated$fRenamableMaybeMaybe$fRenamable[][] DesugarMonad DesugarStateinTimedSection currentLocvariableSubstitutionparentSubstitutionForModulesmaybeTimedSectionaddParentModuleSubstitutionparentModuleSubstitutioncomposeSubstitutionsbindSubtitutionsubstituteName desugarDecl desugarDeclsinvalidSetPatternMessagelinkedParallelTimedSectionErrornondetFieldTimedSectionError mkApplication$fDesugarableType$fDesugarableLiteral$fDesugarablePat$fDesugarableInteractiveStmt$fDesugarableStmt$fDesugarableField$fDesugarableExp$fDesugarableMatch$fDesugarableDataTypeClause$fDesugarableModelOption$fDesugarableModel$fDesugarableSemanticProperty$fDesugarableAssertion$fDesugarableCSPMFile$fDesugarable(,)$fDesugarableAnnotated$fDesugarableAnnotated0$fDesugarableMaybe$fDesugarable[]trimFunctionIdentifier $fOrdValue $fEqValue$fHashableValue$fHashableArray$fOrdFunctionIdentifier$fHashableFunctionIdentifier$fEqFunctionIdentifier$fOrdScopeIdentifier$fHashableScopeIdentifier$fEqScopeIdentifierGHC.ArrIxrangeindexinRange rangeSizeArrayarraybounds listArray!indiceselemsassocs accumArray//accumixmaptotalCallCountshierachicalTableHierarchicalCallCount CallCountsoptions tableLock callCountshiearchicalCallCountsprofilingStackCallCountTableincrementCallCounterincrementCountercreateHierarchicalCallCountextractProfilingDataprintInColumnsprettyPrintOverallTableprettyPrintHierarchicalData$fPrettyPrintableProfilingData flipOrder $fOrdValueSet $fEqValueSet$fHashableValueSet $fNFDataEvent$fNFDataProcName$fNFDataProcOperator$fNFDataCSPOperator $fNFDataProc$fNFDataValueSet $fNFDataValue$fNFDataFunctionIdentifier$fNFDataScopeIdentifierarityOfDataTypeClauseisCompleteFieldextensionsSetsslowMatchDotPrefixisProductionOf maybeNamedDotproductionsSets takeFieldstakeFirstFieldisDotmanuallySplitValues isMixedList $fBindablePat$fBindableAnnotatedppOperatorWithArgppBriefOperatorWithArgppBriefBinaryOp maybeNull maybeNull'($fMonadicPrettyPrintableIdentityValueSet'$fMonadicPrettyPrintableReaderTValueSet$fMonadicPrettyPrintablemValue$fMonadicPrettyPrintablemProc$fPrecedenceProc$$fMonadicPrettyPrintablemCSPOperator($fMonadicPrettyPrintablemScopeIdentifier!$fMonadicPrettyPrintablemProcName!$fMonadicPrettyPrintableIdentityf $fMonadicPrettyPrintableReaderTf%$fMonadicPrettyPrintablemProcOperator$fMonadicPrettyPrintablemEvent $fPrettyPrintableScopeIdentifier$fPrettyPrintableProcOperator$fPrettyPrintableProc$fPrettyPrintableValueSet$fPrettyPrintableValue$fPrettyPrintableProcName$fPrettyPrintableSeq$fPrettyPrintableEvent"$fMonadicPrettyPrintablemAnnotated$fMonadicPrettyPrintablemExprelationalImagefdrSymmetricTransitiveClosurebuiltInFunctionsbindDecl evalTypeExprevalTypeExprToList evalStmts evalStmts' evalProcsevalProcremoveDuplicateTiesevalTiesunzipSqtimedCSPSyncSettSTOP maybeTSTOPtock tockValuetockSet makeTocker$fEvaluatableExp$fEvaluatableAnnotatedstartPos$fFunctorAlexLastAcc checkLetDecls HappyAddrHappyA#HappyStk Happy_IntList HappyCons LocatablegetLocunLocmkLocHappyAny HappyAbsSynhappyIn6 happyOut6happyIn7 happyOut7happyIn8 happyOut8happyIn9 happyOut9 happyIn10 happyOut10 happyIn11 happyOut11 happyIn12 happyOut12 happyIn13 happyOut13 happyIn14 happyOut14 happyIn15 happyOut15 happyIn16 happyOut16 happyIn17 happyOut17 happyIn18 happyOut18 happyIn19 happyOut19 happyIn20 happyOut20 happyIn21 happyOut21 happyIn22 happyOut22 happyIn23 happyOut23 happyIn24 happyOut24 happyIn25 happyOut25 happyIn26 happyOut26 happyIn27 happyOut27 happyIn28 happyOut28 happyIn29 happyOut29 happyIn30 happyOut30 happyIn31 happyOut31 happyIn32 happyOut32 happyIn33 happyOut33 happyIn34 happyOut34 happyIn35 happyOut35 happyIn36 happyOut36 happyIn37 happyOut37 happyIn38 happyOut38 happyIn39 happyOut39 happyIn40 happyOut40 happyIn41 happyOut41 happyIn42 happyOut42 happyIn43 happyOut43 happyIn44 happyOut44 happyIn45 happyOut45 happyIn46 happyOut46 happyIn47 happyOut47 happyIn48 happyOut48 happyIn49 happyOut49 happyIn50 happyOut50 happyIn51 happyOut51 happyIn52 happyOut52 happyIn53 happyOut53 happyIn54 happyOut54 happyIn55 happyOut55 happyIn56 happyOut56 happyIn57 happyOut57 happyIn58 happyOut58 happyIn59 happyOut59 happyIn60 happyOut60 happyIn61 happyOut61 happyIn62 happyOut62 happyIn63 happyOut63 happyIn64 happyOut64 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nonterms happyReduce_3happyReduction_3 happyReduce_4happyReduction_4 happyReduce_5happyReduction_5 happyReduce_6happyReduction_6 happyReduce_7happyReduction_7 happyReduce_8happyReduction_8 happyReduce_9happyReduction_9happyReduce_10happyReduction_10happyReduce_11happyReduction_11happyReduce_12happyReduction_12happyReduce_13happyReduction_13happyReduce_14happyReduction_14happyReduce_15happyReduction_15happyReduce_16happyReduction_16happyReduce_17happyReduction_17happyReduce_18happyReduction_18happyReduce_19happyReduction_19happyReduce_20happyReduction_20happyReduce_21happyReduction_21happyReduce_22happyReduction_22happyReduce_23happyReduction_23happyReduce_24happyReduction_24happyReduce_25happyReduction_25happyReduce_26happyReduction_26happyReduce_27happyReduction_27happyReduce_28happyReduction_28happyReduce_29happyReduction_29happyReduce_30happyReduction_30happyReduce_31happyReduction_31happyReduce_32happyReduction_32happyReduce_33happyReduction_33happyReduce_34happyReduction_34happyReduce_35happyReduction_35happyReduce_36happyReduction_36happyReduce_37happyReduction_37happyReduce_38happyReduction_38happyReduce_39happyReduction_39happyReduce_40happyReduction_40happyReduce_41happyReduction_41happyReduce_42happyReduction_42happyReduce_43happyReduction_43happyReduce_44happyReduction_44happyReduce_45happyReduction_45happyReduce_46happyReduction_46happyReduce_47happyReduction_47happyReduce_48happyReduction_48happyReduce_49happyReduction_49happyReduce_50happyReduction_50happyReduce_51happyReduction_51happyReduce_52happyReduction_52happyReduce_53happyReduction_53happyReduce_54happyReduction_54happyReduce_55happyReduction_55happyReduce_56happyReduction_56happyReduce_57happyReduction_57happyReduce_58happyReduction_58happyReduce_59happyReduction_59happyReduce_60happyReduction_60happyReduce_61happyReduction_61happyReduce_62happyReduction_62happyReduce_63happyReduction_63happyReduce_64happyReduction_64happyReduce_65happyReduction_65happyReduce_66happyReduction_66happyReduce_67happyReduction_67happyReduce_68happyReduction_68happyReduce_69happyReduction_69happyReduce_70happyReduction_70happyReduce_71happyReduction_71happyReduce_72happyReduction_72happyReduce_73happyReduction_73happyReduce_74happyReduction_74happyReduce_75happyReduction_75happyReduce_76happyReduction_76happyReduce_77happyReduction_77happyReduce_78happyReduction_78happyReduce_79happyReduction_79happyReduce_80happyReduction_80happyReduce_81happyReduction_81happyReduce_82happyReduction_82happyReduce_83happyReduction_83happyReduce_84happyReduction_84happyReduce_85happyReduction_85happyReduce_86happyReduction_86happyReduce_87happyReduction_87happyReduce_88happyReduction_88happyReduce_89happyReduction_89happyReduce_90happyReduction_90happyReduce_91happyReduction_91happyReduce_92happyReduction_92happyReduce_93happyReduction_93happyReduce_94happyReduction_94happyReduce_95happyReduction_95happyReduce_96happyReduction_96happyReduce_97happyReduction_97happyReduce_98happyReduction_98happyReduce_99happyReduction_99happyReduce_100happyReduction_100happyReduce_101happyReduction_101happyReduce_102happyReduction_102happyReduce_103happyReduction_103happyReduce_104happyReduction_104happyReduce_105happyReduction_105happyReduce_106happyReduction_106happyReduce_107happyReduction_107happyReduce_108happyReduction_108happyReduce_109happyReduction_109happyReduce_110happyReduction_110happyReduce_111happyReduction_111happyReduce_112happyReduction_112happyReduce_113happyReduction_113happyReduce_114happyReduction_114happyReduce_115happyReduction_115happyReduce_116happyReduction_116happyReduce_117happyReduction_117happyReduce_118happyReduction_118happyReduce_119happyReduction_119happyReduce_120happyReduction_120happyReduce_121happyReduction_121happyReduce_122happyReduction_122happyReduce_123happyReduction_123happyReduce_124happyReduction_124happyReduce_125happyReduction_125happyReduce_126happyReduction_126happyReduce_127happyReduction_127happyReduce_128happyReduction_128happyReduce_129happyReduction_129happyReduce_130happyReduction_130happyReduce_131happyReduction_131happyReduce_132happyReduction_132happyReduce_133happyReduction_133happyReduce_134happyReduction_134happyReduce_135happyReduction_135happyReduce_136happyReduction_136happyReduce_137happyReduction_137happyReduce_138happyReduction_138happyReduce_139happyReduction_139happyReduce_140happyReduction_140happyReduce_141happyReduction_141happyReduce_142happyReduction_142happyReduce_143happyReduction_143happyReduce_144happyReduction_144happyReduce_145happyReduction_145happyReduce_146happyReduction_146happyReduce_147happyReduction_147happyReduce_148happyReduction_148happyReduce_149happyReduction_149happyReduce_150happyReduction_150happyReduce_151happyReduction_151happyReduce_152happyReduction_152happyReduce_153happyReduction_153happyReduce_154happyReduction_154happyReduce_155happyReduction_155happyReduce_156happyReduction_156happyReduce_157happyReduction_157happyReduce_158happyReduction_158happyReduce_159happyReduction_159happyReduce_160happyReduction_160happyReduce_161happyReduction_161happyReduce_162happyReduction_162happyReduce_163happyReduction_163happyReduce_164happyReduction_164happyReduce_165happyReduction_165happyReduce_166happyReduction_166happyReduce_167happyReduction_167happyReduce_168happyReduction_168happyReduce_169happyReduction_169happyReduce_170happyReduction_170happyReduce_171happyReduction_171happyReduce_172happyReduction_172happyReduce_173happyReduction_173happyReduce_174happyReduction_174happyReduce_175happyReduction_175happyReduce_176happyReduction_176happyReduce_177happyReduction_177happyReduce_178happyReduction_178happyReduce_179happyReduction_179happyReduce_180happyReduction_180happyReduce_181happyReduction_181happyReduce_182happyReduction_182happyReduce_183happyReduction_183happyReduce_184happyReduction_184happyReduce_185happyReduction_185happyReduce_186happyReduction_186happyReduce_187happyReduction_187happyReduce_188happyReduction_188happyReduce_189happyReduction_189happyReduce_190happyReduction_190happyReduce_191happyReduction_191happyReduce_192happyReduction_192happyReduce_193happyReduction_193happyReduce_194happyReduction_194happyReduce_195happyReduction_195happyReduce_196happyReduction_196happyReduce_197happyReduction_197happyReduce_198happyReduction_198happyReduce_199happyReduction_199happyReduce_200happyReduction_200happyReduce_201happyReduction_201 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError'happySeq combineDeclsconstraintForNameattachTypeAnnotationsconvDeclcheckModuleDeclcheckTimedDeclcheckExp getFuncArgs dotAppToListconvPatgetIntgetChar getStringgetNamegetRefinesModel getPropModelgetPrintStringannotate annotate2 annotate2Listannotate2List'annotateWithSymbolTableliftLoc parseError happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeq$fLocatableAnnotated$fLocatableLocatedsetEnvironment getErrorsgetSymbolInformationsetSymbolInformation$fCompressableSTypeScheme$fCompressableLiteral$fCompressableModel$fCompressableSemanticProperty$fCompressablePat$fCompressableInteractiveStmt$fCompressableStmt$fCompressableField$fCompressableMatch$fCompressableDataTypeClause$fCompressableModelOption$fCompressableAssertion$fCompressableDecl$fCompressableCSPMFile$fCompressableExp$fCompressable(,)$fCompressableMaybe$fCompressable[]$fCompressableAnnotated$fCompressableAnnotated0$fCompressableAnnotated1occursunifyConstraint reduceDotable toNormalFormcombineTypeLists unifyNoStkraiseUnificationError TypeListMode LongestMatch ShortestMatch freeTypeVars'isVar isDotable isExtendableisSimplesafeWriteTypeRefapplySubstitution evalTypeList evalTypeList'$fTypeCheckableLiteralType$fTypeCheckablePatType$fTypeCheckableAnnotatedType typeCheckStmttypeCheckStmtstypeCheckReplicatedOpcheckFunctionCalltypeCheckField$fTypeCheckableExpTypetypeCheckMutualyRecursiveGroupevalTypeExpression$fTypeCheckableSTypeType$$fTypeCheckableSTypeSchemeTypeScheme"$fTypeCheckableAnnotatedTypeScheme$fTypeCheckableMatchType$fTypeCheckableAnnotatedType0 $fTypeCheckableDataTypeClause(,)$fTypeCheckableAnnotated(,)$fTypeCheckableModelOption()$fTypeCheckableAssertion()$fTypeCheckableAnnotated()$fTypeCheckableDecl[]$fTypeCheckableAnnotated[]$fTypeCheckableCSPMFile() $fTypeCheckableInteractiveStmt()transformers-0.3.0.0Control.Monad.Trans.State.LazyStateTrnStatetcStateevState modifySession$fMonadicPrettyPrintablema$fCSPMMonadStateT