H      !"#$%&'()*+,-./012345678 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 bcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./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/u0v0w0x0y0z0{0|0}0~0000000000000000000000000059Given two orderings, returns the second if the first is  " and returns the first otherwise. 6Given a file path, if the first character is a ~ then  expands the ~ to the users' home directory. :Remove whitespace from the beginning and end of a string. 2Compute the Cartesian product of a list of lists.  -Returns true iff the list has no duplicates. AReplaces the last item in a list. Assumes the list is non empty.         *The width, in spaces, of a tab character. IPretty prints an integer and separates it into groups of 3, separated by  commas. Show a double d printing only places! places after the decimal place. Indent a document by  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 first, second etc. #Equivalent to [d1, sep   d2, sep   d3, ...]. I !"# ! "#  !"#$%A boolean (TODO: remove). &6An integer. This is finite size, as per the FDR spec. $%&$&%$&%%&+?A class to allow catching of SourceErrors in arbitrary monads. ,->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 0An unexpected internal error 19An error message that resulted from something in the user' s input. Used for sorting into order.  The message. 23Given a ( and a pretty printed  creates an 1. 4Constructs a warning from a ( and a pretty printed ,  prepending  Warning:  to the . 5Throw an error message as a /. 6Given a string causes a 0 to be thrown. 7Throws an arbitrary . +,-./01234567-0/.7+,653412 +,,-0/../01234567 89:;<=>?@ABCD 89:;<=>?@ABCD 89:;<=>?@ABCD 89:;<=>?@ABCD EF >EFGHIJKLM EGHIJKLMF>EF NAn alias for ease O#Events, as represented in the LTS. P+Any event defined in a channel definition. Q3The internal event tick, representing termination. R The internal special event tau. NOPQRORQPNNORQPPQR STUVWCreates/$updates a key in the top level map. XY1Looks up a key in any map, starting from the top Z[\]^_`aCreates a new map STUVWXYZ[\]^_`aUVSTWXYZ[\]^_`aSTTUVVWXYZ[\]^_`a '()*bcdefghijklmnopqrstuvwxyz{|} '()*bcdefghijklmnopqrstuvwxyz{|}%)vuwxy(pmkjqrstqnsotqrlz{*'ghibcdef|} 'ghi(pmkjqrstqnsotqrl)vuwxy*bcdefcdefghijklmnopqrstuvwxyz{|}1 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. *BPretty prints several types using the same variable substitutions ###  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. .A boolean 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 nametype declaration, e.g. nametype T2 = T.T. 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. 1Used only for parsing - never appears in an AST. 1Used only for parsing - never appears in an AST. 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). '()*Sliding choice, e.g. P |> Q. +,-Sequential composition, e.g. P; Q. ./0Event renaming, e.g.  P [[ a.x < - b.x | x <- X ]]. 1The process that is renamed. 2.The events that are renamed, in the format of  (old, new). 3The statements for the ties. 4Event prefixing, e.g.  c$x?y!z -> P. 56789:;<= 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. ABCInternal choice, e.g. P |~| Q. DEFHiding of events, e.g. P  A. G&The process the hiding is applied to. H The set of events to be hidden. IGuarded expressions, e.g. b & P where b is a boolean expression.  This is equivalent to if b then P else STOP. JKLGeneralised parallel, e.g. P [| A |] Q. MNOPExternal choice, e.g. P [] Q. QRSException operator, e.g.  P [| A |> Q. TUVWAlphabetised parallel, e.g.  P [A || B] Q. X Process 1. YAlphabet of process 1. ZAlphabet of process 2. [ Process 2. \Variables, e.g. x. ]^ Tuples, e.g. (1,2). _`@The bounded set of integers between the two given values, e.g.  {5..6}. aThe lower bound. bThe upper bound. c8The infinite set of integers from the given value, e.g. {5..}. deSet comprehension version of h, e.g.  {| c.x | x <- xs |}. fgh:Enumerated Sets, i.e. sets that complete the events, e.g.  {| c.x |}. ijSet comprehensions, e.g.  {x,y | (x,y) <- e}. klmSet literals, e.g. {1,2,3}. noA user provided bracket, e.g. (e). pq*Application of unary maths operator, e.g. -x. rst+Application of binary maths operator, e.g. x+y. uvwxThe length of the list, e.g. #list. yz8Bounded list of integers between the given values, e.g.  1..3. {|}5Infinite list of integers from the given value, e.g.  1... ~List 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       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}zxtqomjhec`^\WSPLIFC@=840-*&# ~{|yuvwrspnklifgdab_]XYZ[TUVQRMNOJKGHDEAB>?9:;<567123./+,'()$%!"              }zxtqomjhec`^\WSPLIFC@=840-*&# ~{|yuvwrspnklifgdab_]XYZ[TUVQRMNOJKGHDEAB>?9:;<567123./+,'()$%!" !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~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. 4The name of this process (recal Name s are unique). AThe arguments applied to this process, in case it was a function  call. GGiven a process, returns the initial process and all processes that it  calls. HPretty prints the given process and all processes that it depends upon. Q      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGY      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGYGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      QOGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!            !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN5HIJKLMNHIJKLMN5HIJKLMN"OPQRSTUVWXYZ[\]^_`abcdefghijklmn OPQRSTUVWXYZ[\]^_`abcdefghijklmn OXYZ[PQRSTUVW_cb\]^da`efghijkmln OPQRSTUVWQRSTUVWXYZ[YZ[\]]^_`abcdefghijklmn)opqrstuvwxyz{|}~Same as 3, but applies only to the left side of the string. Same as 4, but applies only to the right side of the string. opqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop)y}|{zuxwvptsrqo~)optsrqqrstuxwvvwxy}|{zz{|}~Implements non-recursive lets. Implements recursive lets.  ~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. <Implements CSPM comparisons (note that Ord Value does not). q3The number of fields this datatype or channel has. 7Takes two values and dots then together appropriately. BThis assumes that the value is a VDot with the left is a VChannel 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. DTakes a datatype or a channel value and computes v.x for all x that  complete the value. /OPQR~/~ORQP~ 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. rEA set of two value sets. Note that the tree of sets may be infinite. ) NB. Composite sets are always infinite. -The infinite set of integers starting at lb. sAn explicit set of values Set of all processes Set of all integers t2Returns the powerset of a ValueSet. This requires 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. ,Is the specified value a member of the set. 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. uv     wxyz{|}~Initialises the renamer. LRuns the renamer starting at the given state and returning the given state. HGiven something annotated and a function that mutates the inner object, D returns the inner object annotated with the same outer annotation. /Renames the declarations in the current scope. 9Rename a variable on the left hand side of a definition. @renameVarLHS :: NameMaker -> UnRenamedName -> RenamerMonad Name renameVarLHS nm v = do :Rename a variable on the right hand side of a definition.  !DGiven 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. "%Evaluates the statements, evaluating prog for each possible = assingment to the generators that satisfies the qualifiers. FTakes a VEvent and then computes all events that this is a prefix of. #=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.   $     CThrows an error if a declaration that is not allowed inside a let  expression is found. %Parse as string as an . Parses a string as an . +Parse the given file, returning the parsed s. GParse a string, as though it were an entire file, returning the parsed  s. O`O`& -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.                    '(8 !:The type environment, which is a map from names to types. ".List of names that correspond to channels and / datatypes - used when detecting dependencies. #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). (#Are we currently in an error state )*+,*Runs the typechecker, starting from state st. If any errors are  encountered then a /" will be thrown with the relevent  error messages. -./0123456789:#Sets the SrcSpan only within prog. ;<=>?.Report the error if first parameter is False. @ABCDReport a message as an error EFGHGet the type of n# and throw an exception if it doesn' t exist. IISets the type of n to be t in the current scope only. No unification is  performed.  JKLMNO-Apply compress to the type of a type scheme. PGTakes a type and compresses the type by reading all type variables and > if they point to another type, it returns that type instead. 66 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP6FGHIKMNJLPO,+ !"#$%&'()-/.*329:;<=>78546CD6@A?EB013  !"#$%&'() !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP)QQQQ*RSMap compress. RSRSRSS+TUVW!X"TUVWXYVWXYTUTUUVWWX-#?Return the free type variables (and their constraints) for all s  that occur in . $[8Generalise 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). \<Instantiates the typescheme with some fresh type variables. %Does a occur somewhere in t. ]CUnifys 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. ^/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. _JThe 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] /0<Applies a subtitution directly to the type. This is used in E type instantiation where we create a fresh type for each universal  variable `7Takes a type and attempts to simplify all TDots inside , by combining TDotable t1 t2 and arguments. 1[\]^_`[\_]`^[\]^_`.abcdefghijklmnabcdefghijklmnabcdefghijklmnabcdebcdefghijklmn23234FThe first argument is a type constructor, which given a type, returns + that type encapsulate in some other type. 5KType check a series of statements. For each statement a new scope is added @ to ensure that clauses only depend on variables already bound. 6"Shortcut for replicated operators ,Z;Type check a list of possibly mutually recursive functions 78EType 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. 9ATakes 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. ZZZ45/opqrst:Returns the list of names that this expression depends on ,opqrst rqstp,oopqrst0(uA basic implementation of v , using the :; monad. This $ prints out any warnings to stdout. vGThe CSPMMonad is the main monad in which all functions must be called. 0 Whilst there is a build in representation (see u) it is recommended  that you define an instance of v over whatever monad you use. wGet the current session. xUpdate the current session. y.This is called whenever warnings are emitted. zA z3 represents the internal states of all the various  components. <=The state of the renamer. >The state of the type checker. ?The state of the evaluator. { Create a new z. |6Executes an operation giving it access to the current z. @/Modifies the session using the given function. }FGiven a program that can return warnings, runs the program and raises  any warnings found using y. ~Runs a u; function, returning the result and the resulting session. Runs the parser.  Parse a file fp . Throws a / on any parse error. AParses a string, treating it as though it were a file. Throws a  / on any parse error.  Parses a  . Throws a / on any parse error.  Parses an  . Throws a / on any parse error. #Runs renamer in the current state. Renames a file. Renames an expression. "Rename ian interactive statement. JRuns the typechecker in the current state, saving the resulting state and % returning any warnings encountered. AType checks a file, also desugaring and annotating it. Throws a  /* if an error is encountered and will call y on / any warnings. This also performs desugaraing. Type checks a . Type checkes a 1, returning the desugared and annotated version. Given a , ensures that the ! is of that type. It returns the $ annoated and desugared expression. 8Gets the type of the expression in the current context.  Returns the 5s that the given type checked expression depends on. -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. 8Get a list of currently bound names in the environment. 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. 2Return the version of libcspm that is being used. OPQR~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~uvwxyz{|}~#z{vwxy|u~}#uvwxywxyz{|}~A6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno p q r s t u v w x y z { | } ~  F K J           a CJK      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{8|}~D      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuuvwxyz{||}~K                 LFGHI   ! " " ## # ####$$$%%%%&&&&&&&&&&&&&&K'''' '!'"'#'$(%(&(&(('((()(*(+(,(-(.(/(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/b/a/o/p000q0r0s0t0u0v0w0x0y0z00000{0|0}0~0000000p000000000666@Fi 11111111111      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde fghijkSTlmnopqrstuvwxyz{|}~!S!T!!!$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$(( ( ( ( + +---------------333 3!3",#,$,%&'(&'(0u0)0*0+0,- libcspm-0.2.0Util.Exception Util.Prelude Util.Monad Util.ListCSPM.Compiler.SetUtil.PrettyPrintCSPM.DataStructures.LiteralsUtil.AnnotatedUtil.PartialFunctionsCSPM.Compiler.MapCSPM.Compiler.EventsUtil.HierarchicalMapCSPM.Evaluator.ValuesCSPM.Evaluator.ValueSetCSPM.DataStructures.NamesCSPM.DataStructures.TypesCSPM.DataStructures.SyntaxCSPM.Compiler.ProcessesCSPM.PrettyPrinter CSPM.DesugarCSPM.DataStructures.TokensCSPM.Parser.ExceptionsCSPM.Parser.MonadCSPM.Parser.LexerCSPM.Evaluator.EnvironmentCSPM.Evaluator.MonadCSPM.Evaluator.ExceptionsCSPM.Evaluator.Expr CSPM.Prelude CSPM.RenamerCSPM.Evaluator.BuiltInFunctionsCSPM.Evaluator.PatBindCSPM.Evaluator.DeclBindCSPM.Evaluator.ModuleCSPM.EvaluatorCSPM.Parser.Parser CSPM.ParserCSPM.TypeChecker.EnvironmentCSPM.TypeChecker.ExceptionsCSPM.TypeChecker.Monad!CSPM.TypeChecker.BuiltInFunctionsCSPM.TypeChecker.CompressorCSPM.TypeChecker.DependenciesCSPM.TypeChecker.DeclCSPM.TypeChecker.UnificationCSPM.TypeChecker.CommonCSPM.TypeCheckerCSPM Paths_libcspmCSPM.TypeChecker.PatCSPM.TypeChecker.Expr CSPM.TypeChecker.InteractiveStmtCSPM.TypeChecker.Modulebase GHC.Exception ExceptionthenCmp expandPathIOtrim cartProduct concatMapMandMorM$$noDups replaceLastcartesianProductSetnullemptyunionsunion differencefromListtoListmembersubsetequnionMapsplitPrettyPrintable prettyPrinttabWidthcommaSeparatedInt shortDouble tabIndentanglesbarsdotSeplistspeakNthpunctuateFrontLiteralBoolIntLocatedSrcSpanSrcLoc combineSpansMonadIOExceptiontryMLibCSPMException UserError SourceErrorPanic ErrorMessage ErrorMessagesmkErrorMessagemkWarningMessagethrowSourceErrorpanicthrowExceptionPartialFunctionfunctionDomain functionImageidentityFunctioninvertapply applyRelation safeApplycomposeFunctionsmapPF safeMapPFupdatePF removeEntryMapRelationlookupinsertdomain unSafeLookupEventSetEvent UserEventTickTauHierarchicalMapExceptionValueNotFoundExceptionHierarchicalMapupdate updateMulti maybeLookupmaybeLookupInTopLayerpopLayerflattennewLayernewLayerAndBindnewRecursiveLayerAndBindnew AnnotatedAnloc annotationinnerL locatedLoc locatedInnerUnknown SrcSpanPoint srcSpanColSrcSpanMultiLine srcSpanSLine srcSpanELineSrcSpanOneLine srcSpanFile srcSpanLine srcSpanSCol srcSpanEColNoLoc srcLocFile srcLocLine srcLocCol srcSpanStart srcSpanEnddummyAnnotation unAnnotateValueValueSetcompareValueSetsNameType WiredInName InternalName ExternalNameNamenameTypenameOccurrencenameDefinition nameUniquenameIsConstructor UnRenamedNameUnQualOccNamemkExternalNamemkInternalNamemkFreshInternalName mkWiredInNameisNameDataConstructor PSymbolTablePType SymbolTable TypeVarRefType TDatatypeTDotable TFunctionTTupleTDotTSeqTSet TEventableTEventTBoolTIntTProcTVar Constraint InputableOrdEq TypeSchemeForAllTypeVar freshTypeVarfreshTypeVarWithConstraints readPTypesetPType freshPTypereadPSymbolTablesetPSymbolTablefreshPSymbolTableprettyPrintTypesPatPCompDot pDotItemspDotOriginalpattern PCompListpListStartItemspListMiddleEndItemspListOriginalPattern PWildCardPVar pVarIdentityPTuple pTupleItemsPSet pSetItemsPParen pParenPatternPLit pLitLiteralPList pListItemsPDoublePatternpDoublePatLeftPatpDoublePatRightPatPDotApp pDotLeftPat pDotRightPatPConcatpConcatLeftPatpConcatRightPatMatch matchPatternsmatchRightHandSideDataTypeClausedataTypeClauseNamedataTypeClauseTypeExpressionSemanticPropertyLivelockFreedom DeterministicDeadlockFreedom ModelOption TauPriorityModelRevivalsDivergencesRevivalsRefusalsDivergencesRefusalsFailuresDivergencesFailuresTraces AssertionASNot BoolAssertion PropertyCheckpropertyCheckProcesspropertyCheckPropertypropertyCheckModel RefinementrefinementSpecificationrefinementModelrefinementImplementationrefinementModelOptionsDeclDataTypeChannel TransparenttransparentImportedNamesExternalexternalImportedNamesAssertPatBindFunBindInteractiveStmt RunAssertionBindEvaluateStmt Qualifier GeneratorField NonDetInputInputOutputExpExpPatDoublePatternExpPatWildCardReplicatedParallelrepParAlphabetrepParReplicatedStatements repParProcessReplicatedLinkParallelrepLinkParTiedChannelsrepLinkParTieStatementsrepLinkParReplicatedStatementsrepLinkParProcessReplicatedInternalChoice repIntChoiceReplicatedStatementsrepIntChoiceProcessReplicatedInterleave!repInterleaveReplicatedStatementsrepInterleaveProcessReplicatedExternalChoice repExtChoiceReplicatedStatementsrepExtChoiceProcessReplicatedAlphaParallelrepAlphaParReplicatedStatementsrepAlphaParAlphabetrepAlphaParProcess SlidingChoiceslidingChoiceLeftProcessslidingChoiceRightProcessSequentialCompseqCompLeftProcessseqCompRightProcessRename renameProcessrenameTiedEventsrenameTieStatementsPrefix prefixChannel prefixFields prefixProcess LinkParallellinkParLeftProcesslinkParTiedEventslinkParTieStatementslinkParRightProcess InterleaveinterleaveLeftProcessinterleaveRightProcess InterruptinterruptLeftProcessinterruptRightProcessInternalChoiceintChoiceLeftProcessintChoiceRightProcessHiding hidingProcesshidingAlphabet GuardedExpguardedExpConditionguardedExpProcess GenParallelgenParallelLeftProcessgenParallelAlphabetgenParallelRightProcessExternalChoiceextChoiceLeftProcessextChoiceRightOperatorexceptionLeftProcessexceptionAlphabetexceptionRightProcess AlphaParallelalphaParLeftProcessalphaParAlphabetLeftProcessalphaParAlphabetRightProcessalphaParRightProcessVar varIdentityTuple tupleItems SetEnumFromTosetEnumFromToLowerBoundsetEnumFromToUpperBound SetEnumFromsetEnumFromLowerBound SetEnumCompsetEnumCompItemssetEnumCompStatementsSetEnum setEnumItemsSetComp setCompItemssetCompStatementssetItemsParenparenExpression MathsUnaryOpmathsUnaryOpOperatormathsUnaryOpExpression MathsBinaryOpmathsBinaryOpOperatormathsBinaryOpLeftExpressionmathsBinaryOpRightExpression ListLengthlistLengthExpressionListEnumFromTolistEnumFromToLowerBoundlistEnumFromToUpperBound ListEnumFromlistEnumFromLowerBoundListComp listCompItemslistCompStatementsList listItemsLit litLiteralLetletDeclarations letExpressionLambdalambdaBindingPatternlambdaRightHandSideIf ifCondition ifThenBranch ifElseBranchDotAppdotAppLeftArgumentdotAppRighArgumentConcatconcatLeftListconcatRightListBooleanUnaryOpunaryBooleanOpOperatorunaryBooleanExpressionBooleanBinaryOpbooleanBinaryOpOperatorbooleanBinaryOpLeftExpressionbooleanBinaryOpRightExpressionApp appFunction appArguments BinaryMathsOpTimesPlusModMinusDivide UnaryMathsOpNegateUnaryBooleanOpNotBinaryBooleanOp GreaterThanEq LessThanEq GreaterThanLessThan NotEqualsEqualsOrAndModule GlobalModuleTCInteractiveStmt TCAssertionTCDataTypeClauseTCStmtTCFieldTCExpTCPatTCMatchTCDeclTCModulePInteractiveStmt PAssertionPDataTypeClausePFieldPStmtPExpPPatPMatchPDeclPModuleAnInteractiveStmt AnAssertionAnDataTypeClauseAnStmtAnFieldAnExpAnPatAnMatchAnDeclAnModulegetTypegetSymbolTableProc PProcCallPSlidingChoicePSequentialCompPRenamePPrefix POperator PLinkParallel PInterleave PInterruptPInternalChoicePHide PGenParallelPExternalChoice PExceptionPAlphaParallel ProcOperator WeakBisim TauLoopFactor StrongBisim ModelCompress Normalize ExplicateDiamondChaseProcNamename argumentsprettyPrintAllRequiredProcessesprettyPrintMatch DesugarabledesugardesugarWithTypeLTokenTokenTEOF TParallel TRExceptionTSlidingChoice TInterruptTPrefix TInterleave TIntChoice TExtChoice TRSqBracket TLSqBracketTRPipeSqBracketTLPipeSqBracketTRDoubleSqBracketTLDoubleSqBracket TRPipeBrace TLPipeBraceTRBraceTLBraceTRParenTLParenTHashTConcat TEmptySeq TCloseSeqTModTDivideTTimesTMinusTPlusTGtTLtTGtEqTLtEqTNotEqTEqTOrTAndTNotTGuard TSemiColon TNameType TTransparent TExternal TDataTypeTAssertTChannel TLambdaDot TBackSlashTWithinTLetTElseTThenTIf TWildCard TDoubleAtTTie TDrawnFromTColon TDoubleDotTPipeTDollar TQuestionMarkTExclamationMarkTComma TDefineEqualTNewLineTDeterministic TLivelockFreeTDivergenceFree TDeadlockFree TTauPriorityTModelTRefinesTIdentTTrueTFalseTIntegerinvalidPatternErrorMessageinvalidDeclarationErrorMessageinvalidExpressionErrorMessageinvalidIncludeErrorMessagelexicalErrorMessageparseErrorMessagefileAccessErrorMessage ParseMonadFileParserState tokenizerPosfileNameinput previousCharcurrentStartCode sequenceStack ParserStaterootDir fileStack FilePositionfilePositionToSrcLocmovePos runParsergetTopFileParserStategetParserStatesetParserStatemodifyTopFileParserStatepushFilepushFileContentsgetTokenizerPos getFileNamegetInputgetPreviousChargetCurrentStartCodegetSequenceStacksetCurrentStartCodesetSequenceStack AlexAccPredAlexAccAlexAccSkipPred AlexAccSkip AlexLastAcc AlexLastSkipAlexNone AlexReturn AlexTokenAlexSkip AlexErrorAlexEOFAlexAddrAlexA# AlexInput alex_base alex_table alex_check alex_defltwscharsstriplstriprstripgtsoakToktokstok takeChars nestedComment switchInputbeginalexInputPrevChar alexGetByte alexGetChar getNextTokengetNextTokenWrappersem_propsoak Environment LazyEvalMonadunLazyEvalMonadEvaluationMonadEvaluationState environmentrunLazyEvalMonadgetsmodify runEvaluatorgetStategetEnvironment lookupVaraddScopeAndBindaddScopeAndBindM throwErrorVProc VFunctionVSetVList VDataTypeVChannelVDotVTupleVBoolVInt compareValues combineDotsprocIdvalueEventToEventoneFieldExtensions extensions productionspatternMatchFailureMessageheadEmptyListMessagetailEmptyListMessage!funBindPatternMatchFailureMessage+replicatedInternalChoiceOverEmptySetMessagetypeCheckerFailureMessage"cannotConvertIntegersToListMessage#cannotConvertProcessesToListMessagecannotCheckSetMembershipErrorcardOfInfiniteSetMessagecannotUnionSetsMessagecannotIntersectSetsMessagecannotDifferenceSetsMessageeventIsNotValidMessage IntSetFrom ProcessesIntegerspowerset allSequencesemptySetsingletonValuecard intersections intersectionvalueSetToEventSet EvaluatableevalBuiltIn stringName isDeprecateddeprecatedReplacement typeScheme isTypeUnsafe isExternal isTransparentbuiltinstransparentFunctionForOccNameexternalFunctionForOccNamerename RenamerMonad RenamerState initRenamerrunFromStateToStatenewScope builtInNameinjectBuiltInFunctionsBindablebindbindAll bindDecls bindModules bindModule initEvaluator evaluateExp evaluateDecl evaluateFile getBoundNamesaddToEnvironment parseFile_parseInteractiveStmt_parseExpression_parseInteractiveStmtparseExpression parseFileparseStringAsFileSymbolInformationdeprecationReplacementmkSymbolInformationdeleteWarningErrorincorrectArgumentCountMessageinfiniteUnificationMessageunificationErrorMessage!constraintUnificationErrorMessagedeprecatedNameUsedunsafeNameUsedTypeCheckMonadTypeInferenceStatedataTypesAndChannelssrcSpan errorContextserrorswarningsunificationStackinErrorsymUnificationAllowed ErrorContextnewTypeInferenceStaterunTypeCheckerlocaladdDataTypeOrChannelisDataTypeOrChannelgetErrorContextsaddErrorContext getWarnings resetWarnings addWarning getInError setInError getSrcSpan setSrcSpangetUnificationStackaddUnificationPairsymmetricUnificationAlloweddisallowSymmetricUnification errorIfFalsemanyErrorsIfFalse errorIfFalseMfailMraiseMessageAsErrorraiseMessagesAsError tryAndRecover readTypeRef writeTypeRefsetTypemarkAsDeprecatedmarkTypeAsUnsafereplacementForDeprecatedNamecompressTypeSchemecompress Compressable mcompressFreeVarsfreeVars Dependencies dependenciesnamesBoundByDeclnamesBoundByDecl'typeCheckDeclsgeneraliseGroup instantiateunifyAll typeToDotListunify evaluateDots TypeCheckable typeChecktypeCheckExpect typeCheck' errorContextensureAreEqual ensureIsList ensureIsSet ensureIsBool ensureIsIntensureIsChannel ensureIsEvent ensureIsProcensureHasConstraintinitTypeChecker typeOfExpdependenciesOfExp CSPMMonad getSession setSessionhandleWarnings CSPMSessionnewCSPMSession withSessionreportWarningsunCSPMrunParserInCurrentStaterunRenamerInCurrentState renameFilerenameExpressionrenameInteractiveStmtrunTypeCheckerInCurrentState typeCheckFiletypeCheckInteractiveStmttypeCheckExpressionensureExpressionIsOfTypetypeOfExpression desugarFiledesugarExpressiondesugarInteractiveStmtrunEvaluatorInCurrentStatebindDeclarationbindFileevaluateExpressiongetLibCSPMVersionghc-prim GHC.OrderingEQpretty-1.1.0.0Text.PrettyPrint.HughesPJnestDoc GHC.Classes<>GHC.Base. fullRenderrender renderStylefcatfsepcatsep<+><>$+$ zeroWidthText sizedTextptexttextcharisEmpty punctuatehangvcathsephcatbracesbracketsparens doubleQuotesquotesrationaldoublefloatintegerintrbracelbracerbracklbrackrparenlparenequalsspacecommacolonsemistyleribbonsPerLine lineLengthmodeStylePageMode ZigZagModeLeftMode OneLineModeModeChrStrPStr TextDetailsWarningMessagelocationmessageEventMapcatchIOversionbindirlibdirdatadir libexecdir getBinDir getLibDir getDataDir getLibexecDirgetDataFileNamenameUniqueSupplytakeNameUnique IORefMaybe typeVarSupplytakeTypeVarFromSupplyprettyPrintTypecollectConstraintssplitProcIntoComponentsppTieppRenameppRepOpppCompppComp'ppBinOpppBinOp'startPossetFileParserState alex_acceptopenseqcloseseqskip 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_100alexIndexInt16OffAddralexIndexInt32OffAddr quickIndexalexScan alexScanUser alex_scan_tkn alexAndPredalexPrevCharIsalexPrevCharMatchesalexPrevCharIsOneOfalexRightContextiUnboxarityOfDataTypeClause CompositeSet ExplicitSet flipOrder allBuiltins makeBuiltins NameMaker RenamableRenameEnvironmentaddScope lookupNamesetNameexternalNameMakerinternalNameMakerreAnnotatePure reAnnotaterenameDeclarations renamePatterncheckDuplicates renameVarRHS renameFieldsrenameStatementsduplicatedDefinitionsMessageduplicatedDefinitionsMessage' transparentFunctionNotRecognisedexternalFunctionNotRecognisedvarNotInScopeMessagebuiltInFunctionsbindDecl evalTypeExprevalTypeExprToList evalProcsevalProcevalTies evalStmts completeEvent extendEvent 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 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTable happyThen happyReturn happyReturn1 happyError' combineDeclsconvDecl checkLetDeclscheckExp dotAppToListconvPatannotate annotate2 annotate2Listannotate2List'annotateWithSymbolTableliftLoc parseError notHappyAtAll happyTcHack happyDoSeq happyDontSeqsetEnvironment getErrors addErrorsgetSymbolInformationsetSymbolInformation dependencies'dependenciesStmts freeTypeVars freeTypeVars'occursunifyConstraint reduceDotable toNormalFormisVar isDotableisSimplecombineTypeLists unifyNoStkraiseUnificationErrorapplySubstitutionsubstituteType evalTypeListcheckFunctionCalltypeCheckField typeCheckStmttypeCheckStmtstypeCheckReplicatedOpregisterChannelsAndDataTypestypeCheckMutualyRecursiveGroupevalTypeExpressiontransformers-0.2.2.0Control.Monad.Trans.State.LazyStateTrnStatetcStateevState modifySession