ây(u      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstSafeuvwxyz{|}~uvwxyz{|}~uvwxyz{|}~NoneF'An alternative is either a datatype constructor or the inclusion of some other type. The types are arbitrary funcon terms (with possible variables) that may require evaluation to be resolved to a .OA datatype has `zero or more' type parameters and `zero or more' alternatives.DA type parameter is of the form X:T where the name of the parameter,X, is optional. When present, X1 can be used to specify the type of constructors.@The typing environment maps datatype names to their definitions. Representation of builtin types.Types optionally attached to $. Computation type S=>T7 reflects a type of term whose given value is of type S and result is of type T."=>T#S=>T$+Postfix operators for specifying sequences.(This datatype provides a number of builtin value types. Composite values are only built up out of other values. The only exception is :3 which stores a thunked computation (funcon term).<Tuples are split in ; and <L to avoid singleton tuples. Tuples should be constructed by applications of d. >(Funcon term representation identical to K, but with meta-variables. KCInternal representation of funcon terms. The generic constructors L and M} use names to represent nullary funcons and applications of funcons to other terms. Funcon terms are easily created using W, or via the smart constructors exported by  Funcons.Core.WBuild funcon terms by applying a funcon name to `zero or more' funcon terms. This function is useful for defining smart constructors, e,g, Shandle_thrown_ :: [Funcons] -> Funcons handle_thrown_ = applyFuncon "handle-thrown"or alternatively, fhandle_thrown_ :: Funcons -> Funcons -> Funcons handle_thrown_ x y = applyFuncon "handle-thrown" [x,y]XCreates a list of funcon terms.YCreates a set of funcon terms.Z>Lookup the definition of a datatype in the typing environment.[ The empty .\Unites a list of s.] Unites two s.^ Creates a  from a list._Creates an integer literal.`Creates a natural literal.Creates an atom from a . Creates a rational literal.aCreates a string literal.bCreates an empty tuple as a (.The empty map as a K.cThe empty map as a K.The empty set as a K.d Creates a tuple of funcon terms.e Returns the rationalX representation of a value if it is a subtype. Otherwise it returns the original value.f Returns the integerX representation of a value if it is a subtype. Otherwise it returns the original value.g Returns the naturalX representation of a value if it is a subtype. Otherwise it returns the original value.h Returns the unicodeL representation of an assci value. Otherwise it returns the original value.i-Attempt to downcast a funcon term to a value.j,Attempt to downcast a funcon term to a type.k&Attempt to downcast a value to a type.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|]  !"#$%&'()*+,-./0123456789:;<=> ?@ABCDEFGHIJK LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|None NoneF??9None}Pretty-print a (.~Pretty-print a K.Pretty-print a . }~     }~  }~     None  None35F !"# ! !"# None35FINU%A map storing the values of input entities.a map storing the values of output entities.a map storing the values of control entities.a map storing the values of  inherited entities.A map storing the values of mutable entities.Monadic type for the propagation of semantic entities and meta-information on the evaluation of funcons. The meta-information includes a library of funcons (see ), a typing environment (see ), runtime options, etc.4The semantic entities are divided into five classes:Cinherited entities, propagated similar to values of a reader monad.@mutable entities, propagated similar to values of a state monad.@output entities, propagation similar to values of a write monad.Jcontrol entities, similar to output entities except only a single control signal= can be emitted at once (signals do not form a monoid).input entities, propagated like values of a state monad, but access like value of a reader monad. This package provides simulated input/outout and real interaction via the $ monad. See  Funcons.Tools.xFor each entity class a map is propagated, mapping entity names to values. This enables modular access to the entities.Monadic type for the implicit propagation of meta-information on the evaluation of funcon terms (no semantic entities). It is separated from u to ensure that side-effects (access or modification of semantic entities) can not occur during syntactic rewrites.After a term is fully rewritten it is either a value or a term that requires a computational step to proceed. This types forms the interface between syntactic rewrites and computational steps.%Fully rewritten to a value.&GFully rewritten to a term and the step required to continue evaluation.CDenotes whether an argument of a funcon should be evaluated or not.=Type synonym for the evaluation functions of nullary funcons."Type synonym for value operations.?Type synonym for the evaluation function of non-strict funcons.EType synonym for the evaluation function of fully non-strict funcons.ZType synonym for the evaluation function of strict funcons. The evaluation function of a $ receives fully evaluated arguments.Evaluation functions capture the operational behaviour of a funcon. Evaluation functions come in multiple flavours, each with a different treatment of the arguments of the funcon. Before the application of an evaluation funcon, any argument may be evaluated, depending on the  of the argument. Funcons for which arguments are not evaluated.-Strict funcons whose arguments are evaluated.Funcons for which some arguments are evaluated. Synonym for , for value operations.Funcons without any arguments.AA funcon library maps funcon names to their evaluation functions.Creates an empty . Unites two s.Unites a list of s. Creates a  from a list. Function  implements a backtracking procedure. It receives two lists of alternatives as arguments, the first containing all rewrite rules of a funcon and the second all step rules. The first successful rule is the only rule fully executed. A rule is  unsuccessfulM if it throws an exception. Some of these exceptions (partial operation, sort error or pattern-match failure) cause the next alternative to be tried. Other exceptions (different forms of internal errors) will be propagated further. All side-effects of attempting a rule are discarded when a rule turns out not to be applicable.First all rewrite rules are attempted, therefore avoiding performing a step until it is absolutely necessary. This is a valid strategy as valid (I)MSOS rules can be considered in any order.ZWhen no rules are successfully executed to completetion a 'no rule exception' is thrown.~Yields an error signaling that no rule is applicable. The funcon term argument may be used to provide a useful error message.YYields an error signaling that a sort error was encountered. These errors render a rule  inapplicableB and a next rule is attempted when a backtracking procedure like U is applied. The funcon term argument may be used to provide a useful error message.Yields an error signaling that a partial operation was applied to a value outside of its domain (e.g. division by zero). These errors render a rule  inapplicableB and a next rule is attempted when a backtracking procedure like U is applied. The funcon term argument may be used to provide a useful error message.+Returns a value as a fully rewritten term. aYield a funcon term as the result of a syntactic rewrite. This function must be used instead of return%. The given term is fully rewritten.(Yield a funcon term as the result of an 5 computation. This function must be used instead of return. Execute a premise as either a rewrite or a step. Depending on whether rewrites were performed or a step was performed a different continuation is applied (first and second argument). Example usage: VstepScope :: NonStrictFuncon --strict in first argument stepScope [FValue (Map e1), x] = premiseEval x rule1 step1 where rewrite1 v = rewritten v step1 stepX = do Map e0 <- getInh "environment" x' <- withInh "environment" (Map (union e1 e0)) stepX stepTo (scope_ [FValue e1, x']) "Execute a computational step as a premise7. The result of the step is the returned funcon term.  Yield an ~ computation as a fully rewritten term. This function must be used in order to access entities in the definition of funcons.'()*+,-./0123456789:;<=>?@ABCDEF%&GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~h$%&'W}~ !)*+,-./0123456789:;<=>?@ABCDEF%&HIJLMNOPQRSUY[_fghqrsxb'()*+,-./0123456789:;<=>?@ABCDEF%&GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ NoneUAn environment mapping meta-variables to funcon terms. This environment is used by a substitution procedure to transform funcon terms from > representation to K.OThe empty substitution environment. Bindings are inserted by pattern-matching. Variant of  that applies substitution. Variant of  that applies substitution.   NoneUCSB supports five kinds of side conditions. Each of the side conditions are explained below. When a side condition is not accepted an exception is thrown that is caught by the backtrackign procedure . A value is a  ground value9 if it is not a thunk (and not composed out of thunks).T1 == T2. Accepted only when T1 and T2 rewrite to equal ground values. T1 =/= T2. Accepted only when T1 and T2 rewrite to unequal ground values.T1 : T2. Accepted only when T2 rewrites to a type and T1" rewrites to a value of that type. ~(T1 : T2). Accepted only when T2 rewrites to a type and T1 rewrites to a value not of that type.T = P. Accepted only when T. rewrites to a value that matches the pattern P. (May produce new bindings in ).Patterns for matching values (().$Patterns for matching funcon terms (>). Variant of  that is lifted into the  monad.aMatching values with value patterns patterns. If the list of patterns is a singleton list, then F attempts to match the values as a tuple against the pattern as well.#Match stricly values with patterns. Variant of . that applies substitute and pattern-matching. Variant of  that is lifted into the - monad. If all given terms are values, then  is used instead.4Match a sequence of terms to a sequence of patterns. Variant of  that is lifted into the  monad.$Executes a side condition, given an U environment, throwing possible exceptions, and possibly extending the environment.7Parameterisable evaluation function function for types.66# NoneU0Default values of entities can be specified for  inherited and mutable entities. For the purpose of unit-testing it is advised to notify an interpreter of the existence of control, output and input entities as well. A list of 9s is used to declare (and possibly initialise) entities.%Get the value of some mutable entity. Variant of  that performs pattern-matching.%Set the value of some mutable entity. Variant of  that applies substitution.|Consume a single value from the input stream. | Throws an 'unsufficient input' exception, if not enough input is available. Provides extraJ values to a certain input entity, available to be consumed by the given  computation argument. Provides an exact8 amount of input for some input entity, that is to be  completely consumed by the given _ computation. If less output is consumed a 'insufficient input consumed' exception is thrown. Variant of  that binds the given % to the consumed value in the given .  Variant of  that performs substitution. Variant of  that performs substitution.3Receive the value of a control entity from a given  computation. Variant of  that performs pattern-matching.&Signal a value of some control entity. Variant of  that applies substitution.%Get the value of an inherited entity. Version of  that applies pattern-matching.9Set the value of an inherited entity. The new value is only set for ' computation given as a third argument. Variant of  that performs substitution.*Add new values to a certain output entity. Variant of  that applies substitution.MRead the values of a certain output entity. The output is obtained from the ( computation given as a second argument. Variant of  that performs pattern-matching.$None0A funcon library with funcons for builtin types.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~KLMNOPQRSTUV()*+,-./0123456789:;<=  !"#$%&'WXdYcb_`a|y{z}~wspoqrvxlmuntijkgfeh>?@ABCDEFGHIJZ]\^[NoneNoneleft-to-right(X1,...,Xn) executes X1 ,...,Xn; from left to right, computing a tuple of result values  (V1,...,VN) .None atomic(X)# treats the complete evaluation of XM as one step, regardless of how many steps that evaluation actually takes.Nonesequential(X1,...,Xn) executes X1 ,...,Xnd from left to right, computing a tuple of results. Any result values that are the empty tuple ()9 are discarded, so the resultant tuple may be smaller.Nonevector-map(F,V) maps the computation F over the vector V% , from left to right, evaluating F for each given value in V . None set-map(F,S) maps the computation F over the set S , interleaved, evaluating F for each given value in S , uniting the results.None list-map(F,L) maps the computation F over the list L% , from left to right, evaluating F for each given value in L .None tuple-map(F,Tup) maps the computation F over a tuple Tup% , from left to right, evaluating F for each given value in the Tup .            None map-map(X,M) maps the computation F over the map M , interleaved, evaluating F for each given keyentry pair in M/ , uniting the results.   Nonelists-map(F,(List+)) maps the computation FE over N lists of equal length L, in parallel from left to right. F is evaluated L times, once for each given tuple of argument values, where the Nth component of each tuple is drawn from the Nth argument list.Nonemultiset-filter(P,MS)* deletes all values from the the multiset MS& that do not satisfy the predicate P . P is given a values /naturals pair.Noneset-filter(P,S)& deletes all entries from the the set S& that do not satisfy the predicate P .   None$map-filter(P,M)# discards all entries from the map M' that do not satisify the predicate P . P is given a key/value pair.!"#$%!"#$%!"#$%None)list-filter(P,L)% discards all elements from the list L' that do not satisify the predicate P .&'()*&'()*&'()*None.list-foldl(F,A,L) reduces a list L9 to a single value by folding it from the left, using Al as the initial accumulator value, and iteratively updating the accumulator by executing the computation F^ with the accumulator value and the head of the remaining list as its pair of arguments.+,-./+,-./+,-./None3list-foldr(F,A,L) reduces a list L: to a single value by folding it from the right, using Al as the initial accumulator value, and iteratively updating the accumulator by executing the computation Fj with the the last element of the remaining list and the accumulator value as its pair of arguments.012340123401234None8 while(B,C) first evaluates B1 . Depending on whether the computed value is true or false , it then executes C% and repeats, or terminates normally.567895678956789 None= do-while(C,B) first executes C . Then it evaluates B& . Depending on whether the value is true or false/ , it then repeats, or terminates normally.:;<=>:;<=>:;<=>!NoneBif-then-else(B,X,Y) first evaluates B1 . Depending on whether the computed value is true or false , it then evaluates X or Y .?@ABC?@ABC?@ABC"NoneGstuck cannot be evaluated.DEFGHDEFGHDEFGH#NoneIJKIJKIJK$NoneOhandle-thrown(E,H) evaluates E . If E terminates normally with value V , then V is returned and H is ignored. If E terminates abruptly with value V , then H is executed with  given-value V .LMNOPLMNOPLMNOP%NoneT finally(C,F) first executes C . If C terminates normally, then F executes. If C) abruptly terminates with a thrown value V , then F executes, and then V is rethrown.QRSTUQRSTUQRSTU&NoneYthrow(V) terminates abruptly with value V .VWXYZVWXYZVWXYZ'None^handle-recursively behaves similarly to  handle-thrown , except that another copy of the handler attempts to handle any values thrown by the handler. Thus, many thrown values may get caught by the same handler. [\]^_[\]^_[\]^_(Nonec plug(E,V) plugs the value V into a hole4 that occurs as a subterm within the computation E , provided the hole is in an evaluable position.`abcd`abcd`abcd)Noneefgefgefg*Nonekshift(F) emits a control-signal' that, when handled by an enclosing reset , will cause F to the current continuation of shift(F) , Unlike control^ , any application of the captured continuation delimits any control operators in its body.hijklhijklhijkl+Nonepprompt is a delimiter for the control and call-cc operators.mnopqmnopqmnopq,Noneu control(F) emits a control-signal' that, when handled by an enclosing prompt , will cause F to the current continuation of  control(F)5 , instead of continuing the current computation.rstuvrstuvrstuv-Nonez call-cc(F) emits a control-signal' that, when handled by an enclosing prompt , applies F to the current continuation. If that current continuation argument is invoked, then the current computation will terminate up to the enclosing prompt# when that continuation terminates.wxyz{wxyz{wxyz{.Nonereset is a delimiter for the shift; operator. A consequence of our choice of definition of shift is that the semantics of reset! conincide exactly with those of prompt3 , and thus the two can be used interchangeably.|}~|}~|}~/NoneA hole. in a term cannot proceed until it receives a  resume-signal% containing a value to fill the hole.0Noneabort(V) emits a control-signal' that, when handled by an enclosing prompt7 , aborts the current computation up to that enclosing prompt , returning the value V .1None2Noneelse(X1,X2,...,XN) evaluates each computation XZ in turn, until one does *not*fail, returning the result of the successful computation.3None check-true(B) fails if B is false .4Nonefail terminates abruptly.5None6Nonedereference(P) fails if the pointer P is null3 , otherwise it returns the value referenced by P .7None8None print-list(L)( emits the values contained in the list L on the  standard-out .9Noneprint(E) evaluates E) and emits the resulting value on the  standard-out .:None;Noneread" consumes a single value from the  standard-in , and returns it.<None=None effect(E) evaluates E$ , then discards the computed value.>Noneallocate-map(M)7 computes a map where the entries are uninitialised  variables of types given by M .?Nonegeneral-assign(Var,Val)+ assigns the (potentially composite) value Val+ to the (potentialy composite) variable Var .@Nonegeneral-assigned(V)' takes a (potentially composite) value V , which may contain  variables , and computes the value of Vc with all such contained variables replaced by the values currently assigned to those variables.ANoneallocate-vector(T,N) computes a vector of length N , containing uninitialised  variables of type T .BNoneCNoneIf V is a variable, current-value(V)- computes the value currently assigned to V . Otherwise it evaluates to V .DNone assigned(Var)4 gives the value currently assigned to the variable Var . If this value is  uninitialised , then computation fail s.ENone"allocate-initialised-variable(T,V): computes a simple variable for storing values of type T , and initialises its value to V . This fail s if the type of V is not a subtype of T .FNoneallocate-variable(T)I computes an (uninitialised) simple variable for storing values of type T .GNonedeallocate-variable(V) deletes the variable V from the current store .HNoneassign(Var,Val) assigns Val to the the variable Var , provided Var! has not been deallocated and Val+ is of the appropriate type for storing in Var .INoneJNonevariable-accepting-type(Var)! returns the type of values that Var accepts. variable-producing-type(Var)! returns the type of values that Var can produce.               KNoneallocate-initialised-link(T,V)# computes a link to values of type T , and sets its value to V . This fail s if the type of V is not a subtype of T .LNoneallocate-link(T)# computes a link to values of type T .MNoneIf V is a link, then follow-if-link(V)& gives the value to which the link V has been set. Otherwise, V is returned.NNoneONone'link-accepting-type(L)! returns the type of values that L accepts. link-producing-type(L)! returns the type of values that L can produce. !"#$%&'()*+,- !"#$%&'()*+,- !"#$%&'()*+,-PNone1follow-link(L) gives the value linked to by L . If this value is  uninitialised , then computation fail s../012./012./012QNone345673456734567RNone; set-link(L,V) sets the value linked to by L to be V . If L0 has already been set, then computation instead fail s.89:;<89:;<89:;<SNone@given! returns the current given value.Bgiven1> returns the first component of the currently given tuple. given2? returns the second component of the currently given tuple. given3: returns the third component of the currently given tuple. =>?@ABCDEFG =>?@ABCDEFG =>?@ABCDEFGTNoneK give(V,X) evaluates X with V as the given value.HIJKLHIJKLHIJKLUNoneMNOMNOMNOVNonePQRPQRPQRWNoneV fresh-atom0 computes a fresh atom, distinct from all other atoms. previously generated by other occurrences of  fresh-atom .STUVWSTUVWSTUVWXNone[ fresh-bindery generates a fresh binder, distinct from all identifiers and any binders previously generated by other occurrences of  fresh-binder .XYZ[\XYZ[\XYZ[\YNone`recursive(Bs,D) evaluates D/ with potential recursion on the binders in Bs< (which need not be the same as the set of binders bound by D ). ]^_`abcdefg ]^_`abcdefg ]^_`abcdefgZNonekbind-recursively(B,E) binds B to the result of evaluating E% , which may recursively refer to B (using bound-recursively ). hijklhijklhijkl[Nonepbound-recursively(B)& returns the value currently bound to B , unless that value is a linksz , in which case it returns the value linked to by that link. This is intended to be used in situations when the binder B+ may be a recursive binding formed using  recursive or bind-recursively .mnopqmnopqmnopq\Noneubound(B)1 returns the value currently bound to the binder B ,rstuvrstuvrstuv]None wxyz{|}~ wxyz{|}~ wxyz{|}~^None scope(Rho,X)@ extends (possibly overriding) the current environment with Rho for the execution of X ._Noneaccumulate(D1,D*) first evaluates D1 to Rho1 . It then lets Rho1> override the current environment during the evaluation of accumulate(D*) to Rho2 , and finally computes Rho2 overriding Rho1 .  accumulate() computes  map-empty .`None bind(B,V)* gives the environment binding the binder B to the value V .aNonebNoneis-in-type(V,T)( tests membership of a value in a type. cNonedNoneeNone variants(M) is the type of tagged values  variant(K,V) where V . variant-tag(V) returns the tag of a variant V variant-value(V)' returns the tagged value of a variant V   fNone   gNonehNoneis-null9 tests an arbitrary value to determine if it is equal to null . iNone   jNonekNonenewline6 is the string containing only a line feed character (LF or "n"). lNonemNonenNoneAn  ieee-floats+ is either one of four special values: quiet-not-a-number , signals-not-a-number , positive-infinity , negative-infinity or is represented (internally) as a triple (S,C,Q). S is a sign bit: 0 denotes "+" and 1 denotes "-". C and Q determine the value. - In binary format the value is: C x 2^Q - In decimal format the value is: C x 10^QoNonebooleans! is the type of truth-values. not(_) is logical negation. and(...)& is logical conjunction of a tuple of booleans . or(...)& is logical disjunction of a tuple of booleans . xor(_,_)! is exclusive disjunction of two booleans .  implies(_,_)$ is logical implication between two booleans .  is-equal(_,_) tests equality of arbitrary values .               pNoneclose(_)I closes a thunked computation with respect to the current environment.qNoneclosure(X,Rho) evaluates X using Rho as the current environment.rNonepattern-prefer(P1,P2): is a pattern that attempts to match the value against P1l . If this succeeds then the resulting environment is returned. Otherwise, the value is matched against P2 . sNone! match(V,P)+ matches the (potentially composite) value V0 against the (potentially composite) pattern P . !" !" !"tNone#$%&'#$%&'#$%&'uNone+pattern-unite(P1,P2)? is a pattern that requires the matched value to match both P1 and P2 , uniting the resulting  environments . ()*+,()*+,()*+,vNone0 pattern-anyI is a pattern that matches any value, computing the empty environment.-./01-./01-./01wNone5 case(P,X)/ attempts to match the (potentially composite)  given-value- against the (potentially composite) pattern P . If successful, XL is executed in the scope of any computed bindings. Otherwise, it fails.234562345623456xNone:match-loosely(V,P)3 loosely matches the (potentially composite) value V- against the (potentially composite) pattern P . In the case of sets , maps and vectors , the pattern may be a sub-set sub-multisetHsub-map/ sub-vector of the value being matched against (recursively).789:;789:;789:;yNone?pattern-bind(B)% is a pattern that matches any value V* , computing the singleton environment  {B |-> V} <=>?@<=>?@<=>?@zNoneDhA ground-value is any (potentially composite) value that does not contain thunks anywhere within it.ABCDEABCDEABCDE{NoneI apply(F,V) applies the function F to the value V .FGHIJFGHIJFGHIJ|NoneN supply(V,F) supplies V! as the argument to the function Fp , without executing the function. The result is a thunk that does not depend on an argument when forced.KLMNOKLMNOKLMNO}NoneSbinding-lambda(B,E)Z computes a statically scoped function (i.e. a closed thunk). When applied to a value V , free occurrences of bound(B) in E refer to V .PQRSTPQRSTPQRST~NoneXcurry(F) converts a function that takes a pair of arguments into a function that takes the first argument of the pair, and returns a function that takes the second argument of the pair.UVWXYUVWXYUVWXYNone] lambda(E)Y computes a statically scoped function (i.e. a closed thunk). When applied to a value V , free occurrences of given in E refer to V .Z[\]^Z[\]^Z[\]^Noneb uncurry(F)l converts a function that computes a function into a single function that takes both arguments as a pair._`abc_`abc_`abcNonegpartial-apply(F,V) provides V as the first argument to a function expecting a pair of arguments, returning a function expecting only the second argument.defghdefghdefghNonel compose(G,F) composes two functions G and F by giving the result of F as the argument to G .ijklmijklmijklmNonenop0   $%)*./3489=>BCGHOPTUYZ^_cdklpquvz{     #$%&'()*+,-1267;<@ABCDEFGKLVW[\`abcdefgklpquvz{|}~     !"&'+,0156:;?@DEIJNOSTXY]^bcghlmnopnopNoneqqqNonersrsrsNoneNonetuvwxyz{|}~tuvwxyz{|}~tuvwxyz{|}~None   None(Funcons for inserting a value to a list.$Funcons representing the empty list.NoneqComputes the union over a sequence of maps. If the maps do not have disjoint domains a failure signal is raised.-Computes the left-biased union over two maps.None   NoneNonetuple-index(_,N) selects the N!th component of a tuple. e.g. tuple-index((true,"hello",B),2) = `"hello"None"Concatenate a sequence of strings.   NoneNoneNoneM      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRM      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRM      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRNone STUVWXYZ[\]^_ STUVWXYZ[\]^_ STUVWXYZ[\]^_None`a`a`aNonebcdbcdbcdNoneefghefghefghNoneijkijkijkNonelsuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRTUVWXYZ[\]^_acdfghjkllNonem(The empty collection of entity defaults.n Creates a mainU function for the default interpreter (no extension). The executable made from this main? function receives command line argumenst as explained above ( Funcons.Tools). o Creates a maina function for the interpreter obtained by extending the default library with the funcons in the  argument.p Creates a mainc function for the interpreter obtained by extending the main interpreter with the funcons in the ? argument and with default values for entities defined in the  argument.q Creates a mainb function for the interpreter obtained by extending the main interpreter with the funcons in the  argument and with a = mapping datatypes to their constructors and type arguments.r Creates a mainX function for the interpreter obtained by extending the main interpreter with funcons,  and a . sSame as ta, except receiving additional interpreter extensions as arguments. Useful when a translation to K- has been implemented in Haskell as well as K8, entities or datatypes specific to the object language.taCreates a main function by passing in a list of command line arguments and an optional initial K to execute. The K argument is optional as one of the command line arguments may refer to an .fct file or .config file that specifies an initial K% term. Useful when a translation to K! has been implemented in Haskell. mnopqrst[\]^mnopqrstnopqrts[]\^m mnopqrstNoneXY_`ad   $%)*./3489=>BCGHOPTUYZ^_cdklpquvz{     #$%&'()*+,-1267;<@ABCDEFGKLVW[\`abcdefgklpquvz{|}~     !"&'+,0156:;?@DEIJNOSTXY]^bcghlmsuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRTUVWXYZ[\]^_acdfghjklXdY_`anop      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmlqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk                   ! " # $ " # !   % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T UVWXYZ[\]^_`abcdefghijklmnopqrstuvwxtuvyztuv{|tuv}~tuvtuvtuvtuvtuvtuvtuvtuvtuvtuvtuvtuvtuv t u v  !t!u!v!!"t"u"v""#t#u#v$t$u$v$$%t%u%v%%&t&u&v&&'t'u'v''(t(u(v(()t)u)v*t*u*v**+t+u+v++,t,u,v,,-t-u-v--.t.u.v../t/u/v//0t0u0v001t1u1v2t2u2v223t3u3v334t4u4v445t5u5v556t6u6v667t7u7v8t8u8v889t9u9v99:t:u:v;t;u;v;;<t<u<v=t=u=v==>t>u>v>>?t?u?v??@t@u@v@@AtAuAvAABtBuBvBBBBCtCuCvCCDtDuDvDDEtEuEvEEFtFuFvFFGtGuGvGGHtHuHvHHItIuIvJtJuJvJJJJJJJJJJJKtKuKvKKLtLuLvLLMtMuMvMMNtNuNvOtOuOvOOOOOOOOOOOPtPuPvPPQtQuQvQQRtRuRvRRStSuSvSSSSSSS S TtTuTvT T UtUuUvVtVuVvWtWuWvW WXtXuXvXXYtYuYvYYYYYYYYZtZuZvZZ[t[u[v[[\t\u\v\\]t]u]v]] ]!]"]#]$^t^u^v^%^&_t_u_v_'_(`t`u`v`)`*atauavbtbubvb+b,ctcucvc-c.dtdudvd/d0eteueve1e2e3e4e5e6ftfufvf7f8f9f:f;f<gtgugvg=g>g?g@hthuhvhAhBhChDitiuiviEiFiGiHiIiJjtjujvjKjLjMjNjOjPjQjRjSjTjUjVktkukvkWkXkYkZltlulvl[l\mtmumvm]m^m_m`ntnunvnanbncndnenfngnhninjnknlnmnnotouovooopoqorosotouovowoxoyozo{o|o}ptpupvp~pqtquqvqqrtrurvrrstsusvsstttutvttutuuuvuuvtvuvvvvwtwuwvwwxtxuxvxxytyuyvyyztzuzvzz{t{u{v{{|t|u|v||}t}u}v}}~t~u~v~~tuvtuvtuvtuvvtusssssssssss     s !"#$%&'()*+,s-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxsyz{|}~sssss      !"#$ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 :;<= > ? @ @  A B B C D E F F G H I J J K L  M N N O P P Q 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 { | } ~                                                         funcons-tools-0.1.0.0 Funcons.EDSL Funcons.Tools Funcons.Core Funcons.Lexer Funcons.TypesFuncons.ParserFuncons.RunOptionsFuncons.PrinterFuncons.ExceptionsFuncons.Simulation Funcons.MSOSFuncons.SubstitutionFuncons.PatternsFuncons.EntitiesFuncons.Core.Computations.SortsCFuncons.Core.Computations.ControlFlow.Normal.Sequencing.LeftToRight>Funcons.Core.Computations.ControlFlow.Normal.Sequencing.AtomicBFuncons.Core.Computations.ControlFlow.Normal.Sequencing.Sequential\Funcons.Core.Computations.ControlFlow.Normal.Iterating.Definite.MappingCollections.VectorMapYFuncons.Core.Computations.ControlFlow.Normal.Iterating.Definite.MappingCollections.SetMapZFuncons.Core.Computations.ControlFlow.Normal.Iterating.Definite.MappingCollections.ListMap[Funcons.Core.Computations.ControlFlow.Normal.Iterating.Definite.MappingCollections.TupleMapYFuncons.Core.Computations.ControlFlow.Normal.Iterating.Definite.MappingCollections.MapMap[Funcons.Core.Computations.ControlFlow.Normal.Iterating.Definite.MappingCollections.ListsMapcFuncons.Core.Computations.ControlFlow.Normal.Iterating.Definite.FilteringCollections.MultisetFilter^Funcons.Core.Computations.ControlFlow.Normal.Iterating.Definite.FilteringCollections.SetFilter^Funcons.Core.Computations.ControlFlow.Normal.Iterating.Definite.FilteringCollections.MapFilter_Funcons.Core.Computations.ControlFlow.Normal.Iterating.Definite.FilteringCollections.ListFilter]Funcons.Core.Computations.ControlFlow.Normal.Iterating.Definite.ReducingCollections.ListFoldl]Funcons.Core.Computations.ControlFlow.Normal.Iterating.Definite.ReducingCollections.ListFoldrGFuncons.Core.Computations.ControlFlow.Normal.Iterating.Indefinite.WhileIFuncons.Core.Computations.ControlFlow.Normal.Iterating.Indefinite.DoWhile@Funcons.Core.Computations.ControlFlow.Normal.Choosing.IfThenElse4Funcons.Core.Computations.ControlFlow.Abnormal.Stuck>Funcons.Core.Computations.ControlFlow.Abnormal.Throwing.ThrownDFuncons.Core.Computations.ControlFlow.Abnormal.Throwing.HandleThrown?Funcons.Core.Computations.ControlFlow.Abnormal.Throwing.Finally=Funcons.Core.Computations.ControlFlow.Abnormal.Throwing.ThrowIFuncons.Core.Computations.ControlFlow.Abnormal.Throwing.HandleRecursivelyAFuncons.Core.Computations.ControlFlow.Abnormal.Continuations.PlugIFuncons.Core.Computations.ControlFlow.Abnormal.Continuations.ResumeSignalBFuncons.Core.Computations.ControlFlow.Abnormal.Continuations.ShiftCFuncons.Core.Computations.ControlFlow.Abnormal.Continuations.PromptDFuncons.Core.Computations.ControlFlow.Abnormal.Continuations.ControlCFuncons.Core.Computations.ControlFlow.Abnormal.Continuations.CallCcBFuncons.Core.Computations.ControlFlow.Abnormal.Continuations.ResetAFuncons.Core.Computations.ControlFlow.Abnormal.Continuations.HoleBFuncons.Core.Computations.ControlFlow.Abnormal.Continuations.AbortJFuncons.Core.Computations.ControlFlow.Abnormal.Continuations.ControlSignal;Funcons.Core.Computations.ControlFlow.Abnormal.Failing.Else@Funcons.Core.Computations.ControlFlow.Abnormal.Failing.CheckTrue;Funcons.Core.Computations.ControlFlow.Abnormal.Failing.Fail>Funcons.Core.Computations.ControlFlow.Abnormal.Failing.SignalsBFuncons.Core.Computations.ControlFlow.Abnormal.Failing.Dereference=Funcons.Core.Computations.ControlFlow.Abnormal.Failing.Failed8Funcons.Core.Computations.DataFlow.Interacting.PrintList4Funcons.Core.Computations.DataFlow.Interacting.Print:Funcons.Core.Computations.DataFlow.Interacting.StandardOut3Funcons.Core.Computations.DataFlow.Interacting.Read9Funcons.Core.Computations.DataFlow.Interacting.StandardIn)Funcons.Core.Computations.DataFlow.EffectGFuncons.Core.Computations.DataFlow.Storing.GeneralVariables.AllocateMapIFuncons.Core.Computations.DataFlow.Storing.GeneralVariables.GeneralAssignKFuncons.Core.Computations.DataFlow.Storing.GeneralVariables.GeneralAssignedJFuncons.Core.Computations.DataFlow.Storing.GeneralVariables.AllocateVector1Funcons.Core.Computations.DataFlow.Storing.StoresGFuncons.Core.Computations.DataFlow.Storing.SimpleVariables.CurrentValueCFuncons.Core.Computations.DataFlow.Storing.SimpleVariables.AssignedVFuncons.Core.Computations.DataFlow.Storing.SimpleVariables.AllocateInitialisedVariableKFuncons.Core.Computations.DataFlow.Storing.SimpleVariables.AllocateVariableMFuncons.Core.Computations.DataFlow.Storing.SimpleVariables.DeallocateVariableAFuncons.Core.Computations.DataFlow.Storing.SimpleVariables.Assign0Funcons.Core.Computations.DataFlow.Storing.Store4Funcons.Core.Computations.DataFlow.Storing.VariablesBFuncons.Core.Computations.DataFlow.Linking.AllocateInitialisedLink7Funcons.Core.Computations.DataFlow.Linking.AllocateLink7Funcons.Core.Computations.DataFlow.Linking.FollowIfLink4Funcons.Core.Computations.DataFlow.Linking.LinkStore0Funcons.Core.Computations.DataFlow.Linking.Links5Funcons.Core.Computations.DataFlow.Linking.FollowLink5Funcons.Core.Computations.DataFlow.Linking.LinkStores2Funcons.Core.Computations.DataFlow.Linking.SetLink/Funcons.Core.Computations.DataFlow.Giving.Given.Funcons.Core.Computations.DataFlow.Giving.Give4Funcons.Core.Computations.DataFlow.Giving.GivenValue;Funcons.Core.Computations.DataFlow.Generating.AtomGenerator7Funcons.Core.Computations.DataFlow.Generating.FreshAtom9Funcons.Core.Computations.DataFlow.Generating.FreshBinder>Funcons.Core.Computations.DataFlow.Binding.Recursion.RecursiveDFuncons.Core.Computations.DataFlow.Binding.Recursion.BindRecursivelyEFuncons.Core.Computations.DataFlow.Binding.Recursion.BoundRecursively0Funcons.Core.Computations.DataFlow.Binding.Bound7Funcons.Core.Computations.DataFlow.Binding.Environments0Funcons.Core.Computations.DataFlow.Binding.Scope5Funcons.Core.Computations.DataFlow.Binding.Accumulate/Funcons.Core.Computations.DataFlow.Binding.Bind6Funcons.Core.Computations.DataFlow.Binding.EnvironmentFuncons.Core.Values.Types>Funcons.Core.Values.CompositeValues.Collections.DirectedGraphs6Funcons.Core.Values.CompositeValues.Collections.TuplesDFuncons.Core.Values.CompositeValues.AlgebraicDatatypeValues.VariantsCFuncons.Core.Values.CompositeValues.AlgebraicDatatypeValues.RecordsFFuncons.Core.Values.CompositeValues.AlgebraicDatatypeValues.References,Funcons.Core.Values.PrimitiveValues.UnitType5Funcons.Core.Values.PrimitiveValues.UnicodeCharacters(Funcons.Core.Values.PrimitiveValues.Bits+Funcons.Core.Values.PrimitiveValues.Strings4Funcons.Core.Values.PrimitiveValues.Numbers.Integers5Funcons.Core.Values.PrimitiveValues.Numbers.Rationals6Funcons.Core.Values.PrimitiveValues.Numbers.IeeeFloats,Funcons.Core.Values.PrimitiveValues.Booleans(Funcons.Core.Abstractions.Closures.Close*Funcons.Core.Abstractions.Closures.Closure0Funcons.Core.Abstractions.Patterns.PatternPrefer(Funcons.Core.Abstractions.Patterns.Match+Funcons.Core.Abstractions.Patterns.Patterns/Funcons.Core.Abstractions.Patterns.PatternUnite-Funcons.Core.Abstractions.Patterns.PatternAny'Funcons.Core.Abstractions.Patterns.Case/Funcons.Core.Abstractions.Patterns.MatchLoosely.Funcons.Core.Abstractions.Patterns.PatternBind'Funcons.Core.Abstractions.IsGroundValue)Funcons.Core.Abstractions.Functions.Apply*Funcons.Core.Abstractions.Functions.Supply1Funcons.Core.Abstractions.Functions.BindingLambda)Funcons.Core.Abstractions.Functions.Curry*Funcons.Core.Abstractions.Functions.Lambda+Funcons.Core.Abstractions.Functions.Uncurry0Funcons.Core.Abstractions.Functions.PartialApply+Funcons.Core.Abstractions.Functions.ComposeFuncons.Core.Library6Funcons.Core.Computations.DataFlow.Generating.AtomSeed6Funcons.Core.Computations.DataFlow.Generating.NextAtom)Funcons.Core.Values.Primitive.BoolBuiltin.Funcons.Core.Values.Composite.Collections.Sets3Funcons.Core.Values.Composite.Collections.Multisets/Funcons.Core.Values.Composite.Collections.Lists.Funcons.Core.Values.Composite.Collections.Maps1Funcons.Core.Values.Composite.Collections.VectorsHFuncons.Core.Values.Composite.AlgebraicDatatypeValues.AlgebraicDatatypes7Funcons.Core.Values.Composite.Collections.TuplesBuiltin,Funcons.Core.Values.Primitive.StringsBuiltin)Funcons.Core.Values.Primitive.BitsBuiltin.Funcons.Core.Values.Primitive.Numbers.Integers7Funcons.Core.Values.Primitive.Numbers.IeeeFloatsBuiltin6Funcons.Core.Values.Primitive.Numbers.RationalsBuiltin#Funcons.Core.Values.Primitive.Atoms(Funcons.Core.Values.Primitive.CharactersFuncons.Core.Abstractions.ThunkFuncons.Core.Abstractions.ForceFuncons.Core.Manual DataTypeAltDataTypeInclusionDataTypeConstructorDataTypeMembers TypeParamTypeEnvTypesADTsADTAsciiCharactersAtomsBitsBoundedIntegersComputationTypes EmptyType IEEEFloatsIntegersListsMaps MultisetsNaturals RationalsSetsStringsThunksTuplesUnicodeCharactersUnionValuesVectorsType ComputesTypeComputesFromType SeqSortOpStarOpPlusOpQuestionMarkOpADTValAsciiAtomBitCharComputationTypeFloat IEEE_Float_32 IEEE_Float_64IntListMapMultisetNatRationalSetStringThunk EmptyTuple NonEmptyTupleVectorFTermTVarTNameTAppTTupleTListTSetTMapTFunconTSortSeq TSortUnion TSortComputesTSortComputesFromFunconsFNameFAppFTupleFListFSetFMapFValueFSortSeq FSortUnion FSortComputesFSortComputesFrom applyFunconlist_set_ typeLookup emptyTypeEnv typeEnvUnions typeEnvUniontypeEnvFromListint_nat_string_ empty_tuple_ map_empty_tuple_upcastRationalsupcastIntegersupcastNaturals upcastUnicode downcastValue downcastTypedowncastValueTypeisAsciiisCharisIdisNatisIntisListisMapisStringisThunkisTupisTypeisValisVec integers_unicode_characters_strings_values_ showValues showFuncons showTypesInputOutputControl InheritedMutableMSOSRewrite Rewritten StrictnessStrict NonStrict NullaryFunconValueOpPartiallyStrictFunconNonStrictFuncon StrictFuncon EvalFunction FunconLibrarylibEmptylibUnion libUnions libFromList evalRulesnorulesortErr partialOp rewritten rewriteTostepTo premiseEval premiseStepcompstepEnvemptyEnv rewriteTermTo stepTermTo SideCondition SCEquality SCInequality SCIsInSort SCNotInSortSCPatternMatchVPatternPADT VPWildCard PEmptySetPTuplePList VPMetaVar VPAnnotatedVPSeqVarVPLitFPatternPValuePMetaVarPSeqVar PAnnotated PWildCardlifted_vsMatchvsMatchpremiselifted_fsMatchfsMatchlifted_sideCondition sideCondition rewriteType EntityDefault DefMutable DefInherited DefOutput DefControlDefInputEntityDefaultsgetMut getMutPattputMut putMutTerm consumeInputwithExtraInputwithExactInput assignInputwithExtraInputTermswithExactInputTerms receiveSignalreceiveSignalPatt raiseSignal raiseTermgetInh getInhPattwithInh withInhTermwriteOut writeOutTermreadOut readOutPattlibraryentitiestypesfunconssorts_ stepSortsleft_to_right_stepLeft_to_rightatomic_ stepAtomic sequential_stepSequential vector_map_stepVector_mapset_map_ stepSet_map list_map_ stepList_map tuple_map_ stepTuple_mapmap_map_ stepMap_map lists_map_ stepLists_mapmultiset_filter_stepMultiset_filter set_filter_stepSet_filter map_filter_stepMap_filter list_filter_stepList_filter list_foldl_stepList_foldl list_foldr_stepList_foldrwhile_ stepWhile do_while_ stepDo_while if_then_else_stepIf_then_elsestuck_ stepStuckhandle_thrown_stepHandle_thrownfinally_ stepFinallythrow_ stepThrowhandle_recursively_stepHandle_recursivelyplug_stepPlugshift_ stepShiftprompt_ stepPromptcontrol_ stepControlcall_cc_ stepCall_ccreset_ stepResethole_stepHoleabort_ stepAbortelse_stepElse check_true_stepCheck_truefail_stepFail stepSignal stepSignals dereference_stepDereference print_list_stepPrint_listprint_ stepPrintread_stepReadeffect_ stepEffect allocate_map_stepAllocate_mapgeneral_assign_stepGeneral_assigngeneral_assigned_stepGeneral_assignedallocate_vector_stepAllocate_vectorstores_ stepStoresstepUninitialisedstepUninitialised_valuescurrent_value_stepCurrent_value assigned_ stepAssignedallocate_initialised_variable_!stepAllocate_initialised_variableallocate_variable_stepAllocate_variabledeallocate_variable_stepDeallocate_variableassign_ stepAssign variables_ stepVariablesall_variables_stepAll_variablesvariable_accepting_type_stepVariable_accepting_typevariable_producing_type_stepVariable_producing_typestepSimple_variablestepReynolds_variablestepReynolds_variablesallocate_initialised_link_stepAllocate_initialised_linkallocate_link_stepAllocate_linkfollow_if_link_stepFollow_if_linklinks_ stepLinks all_links_ stepAll_linkslink_accepting_type_stepLink_accepting_typelink_producing_type_stepLink_producing_typestepSimple_linkstepReynolds_linkstepReynolds_links follow_link_stepFollow_link link_stores_stepLink_stores set_link_ stepSet_linkgiven_ stepGivengiven1_ stepGiven1given2_ stepGiven2given3_ stepGiven3give_stepGive fresh_atom_stepFresh_atom fresh_binder_stepFresh_binder recursive_ stepRecursivebind_to_forward_links_stepBind_to_forward_linksset_forward_links_stepSet_forward_linksreclose_ stepReclosebind_recursively_stepBind_recursivelybound_recursively_stepBound_recursivelybound_ stepBound environments_stepEnvironmentsnamespace_names_stepNamespace_namesstepId_in_namespace stepBindersscope_ stepScope accumulate_stepAccumulatebind_stepBind is_in_type_stepIs_in_typedirected_graphs_stepDirected_graphstuples_ stepTuples variant_tag_stepVariant_tagvariant_value_stepVariant_value stepVariant stepVariantsrecord_field_map_stepRecord_field_maprecord_select_stepRecord_select stepRecord stepRecords pointers_ stepPointers stepReferencestepReferencesis_null_ stepIs_nullstepNull stepUnit_typeunicode_character_stepUnicode_characterunicode_codes_stepUnicode_codesutf_32_ stepUtf_32bytes_ stepBytesunsigned_bits_maximum_stepUnsigned_bits_maximumsigned_bits_maximum_stepSigned_bits_maximumsigned_bits_minimum_stepSigned_bits_minimumis_in_signed_bits_stepIs_in_signed_bitsis_in_unsigned_bits_stepIs_in_unsigned_bitsids_stepIdsnewline_ stepNewlineinteger_negate_stepInteger_negatenegate_ stepNegateexponent_notation_stepExponent_notationquiet_not_a_number_stepQuiet_not_a_numbersignals_not_a_number_stepSignals_not_a_numberpositive_infinity_stepPositive_infinitynegative_infinity_stepNegative_infinity stepBinary32 stepBinary64 stepBinary128 stepDecimal64stepDecimal128stepIeee_formatsnot_stepNotimplies_ stepImpliesand_stepAndor_stepOrxor_stepXor is_equal_ stepIs_equal stepFalsestepTrue stepBooleansclose_ stepCloseclosure_ stepClosurepattern_prefer_stepPattern_prefermatch_ stepMatch patterns_ stepPatternspattern_unite_stepPattern_unite pattern_any_stepPattern_anycase_stepCasematch_loosely_stepMatch_loosely pattern_bind_stepPattern_bindis_ground_value_stepIs_ground_valueapply_ stepApplysupply_ stepSupplybinding_lambda_stepBinding_lambdacurry_ stepCurrylambda_ stepLambdauncurry_ stepUncurrypartial_apply_stepPartial_applycompose_ stepCompose next_atom set_to_list stepSetToList is_set_emptyis_set_empty_opset_size set_size_op set_intersectset_intersect_opset_differenceset_difference_op some_elementstepSome_Element is_subset stepIs_SubsetstepSet stepIsInSet set_unite set_unite_op set_insertstepSet_Insert list_to_setstepList_To_Setis_sub_multisetstepIsSubMultisetmultiset_deletestepMultisetDeletemultiset_insertstepMultisetInsertmultiset_occurrencesstepMultisetOccurrencesmultiset_to_setstepMultisetToSetsets_to_multisetstepSetsToMultisetsstepListstepList_LengthstepHeadstepTailcons_nil_stepConsstepIs_In_List stepIs_NilstepList_SuffixstepList_Prefixlist_to_tuple_stepList_To_TuplestepList_InterspersestepList_RepeatstepList_Reverselist_to_tuple_oplist_append_op is_map_emptystepIsMapEmpty map_to_list stepMapToList map_delete stepMapDelete map_unite_ unite_mapslookup_ lookup_op map_override_stepMapOverride stepDomain set_to_map set_to_map_op list_to_maplist_to_map_opstepVector_RepeatstepVector_To_List vector_emptyvector_length_opstepVector_Index vector_appendvector_append_op stepVector vector_repeatlist_to_vectorlist_to_vector_opevalADT evalADT_Con getADT_Valuesdiscard_empty_tuples_discard_empty_tuples_op tuple_index_stepTupleIndexstepString_To_List stepStringdecimal_natural_decimal_natural_opstepDecimal_RationalstepList_To_Stringstring_append_string_append_oplist_to_string_op readRational stepTo_String stepBits_Not stepBits_Andbits_or stepBits_Orbits_xor stepBits_Xorbits_shift_leftstepBits_Shift_Leftbits_arithmetic_shift_rightstepBits_Arithmetic_Shift_Rightbits_logical_shift_rightstepBits_Logical_Shift_Rightbits_to_integerstepBits_To_Integerbits_to_naturalstepBits_To_Naturalinteger_to_bitsstepInteger_To_Bits integer_op integer_add_integer_add_opinteger_multiply_integer_multiply_opinteger_divide_integer_divide_opinteger_subtractinteger_subtract_op integer_powerinteger_power_opinteger_negatestepInteger_Negate integer_liststepInteger_Listinteger_modulostepInteger_Modulointeger_modulo_opinteger_absolute_valuestepInteger_Absolute_Valueieee_float_truncatestepIEEE_Float_TruncatestepIEEE_Float_AddstepIEEE_Float_MultiplystepIEEE_Float_SubtractstepIEEE_Float_NegatestepIEEE_Float_DividestepIEEE_Float_Powersigned_bits_maximumstepSigned_Bits_Maximumsigned_bits_minimumstepSigned_Bits_Minimumieee_float_acosstepIEEE_Float_Acosieee_float_asinstepIEEE_Float_Asinieee_float_atanstepIEEE_Float_Atanieee_float_atan2stepIEEE_Float_Atan2ieee_float_cosstepIEEE_Float_Cosieee_float_coshstepIEEE_Float_Coshieee_float_expstepIEEE_Float_Expieee_float_logstepIEEE_Float_Logieee_float_log10stepIEEE_Float_Log10ieee_float_sinstepIEEE_Float_Sinieee_float_sinhstepIEEE_Float_Sinhieee_float_sqrtstepIEEE_Float_Sqrtieee_float_tanstepIEEE_Float_Tanieee_float_tanhstepIEEE_Float_Tanhieee_float_ceilingstepIEEE_Float_Ceilingieee_float_floorstepIEEE_Float_Floorieee_float_absolute_valuestepIEEE_Float_Absolute_ValuestepIEEE_Float_RemainderstepIEEE_Float_Is_LessstepIEEE_Float_Is_GreaterstepIEEE_Float_Is_Less_Or_Equal"stepIEEE_Float_Is_Greater_Or_Equal ieee_float_opieee_float_addieee_float_add_opieee_float_multiplyieee_float_multiply_opieee_float_divideieee_float_divide_opieee_float_remainderieee_float_remainder_opieee_float_negateieee_float_negate_opieee_float_subtractieee_float_subtract_opieee_float_float_powerieee_float_power_opieee_float_is_lessieee_float_is_less_opieee_float_is_greaterieee_float_is_greater_opieee_float_is_less_or_equalieee_float_is_less_or_equal_opieee_float_is_greater_or_equal!ieee_float_is_greater_or_equal_op isIEEEFormatdoubleFromIEEEFormatis_less_ is_less_opis_less_or_equal_is_less_or_equal_op is_greater_ is_greater_opis_greater_or_equal_is_greater_or_equal_opstepRational_To_IEEE_Float rational_opaddadd_opstepAtomascii_characterstepAscii_Characterthunk_ stepThunk stepThunksforce_ stepForcenoEntityDefaultsmkMainmkMainWithLibrarymkMainWithLibraryEntitiesmkMainWithLibraryTypesmkMainWithLibraryEntitiesTypesrunWithExtensionsrunlexertypes_keywordsparensbracketsbraces identifiernaturalreserved reservedOpcomma stringLiteralperiodcommaSep commaSep1 whiteSpacebar doubleArrow barredArrowbarSep2atom_baseGHC.Base rational_ empty_map_ empty_set_ IEEEFormatsBinary32Binary64TTParamNameMetaVarbinary32binary64adtval nullaryTypes unaryTypes binaryTypesboundedIntegerTypes floatTypes bitsTypes tuple_val_type_vectypeValsafe_tuple_val tuple_unval types_unvalfvalueslistvalsetvalsetval_mapvalmapval_ mk_rationals mk_integers mk_naturalscastTyperecursiveFunconValue====/=isGroundisEnvisSet isString_isType_SuffixSuffixOp SuffixSort SuffixBarNoSuffixpFuncons pFuncons0pOppValues pIEEEFormatparseparserreader $fReadValues $fReadFuncons RunOptions mfuncon_term general_optsbuiltin_funconsexpected_outcomes given_inputs InputValues TestOptionsBuiltinFunconsOptionsGeneralOptionsdefaultRunOptionsoptionsOverride funcon_termbool_opt_defaultbool_opt do_refocus max_restartsdo_abrupt_terminatepp_full_environments show_result show_counts show_mutable hide_output hide_input hide_controlinteractive_modepp_string_outputs string_inputs show_testsshow_output_only auto_config inputValuesbooleanOptionsbooleanOptions_ stringOptionsstringOptions_ allOptions allOptions_ run_optionsparseAndApplyConfig pRunOptionspGeneralpBool pStringValue pFunconName pFunconTermpBuiltinFuncons pTestOutcomes pInputValues languageDeflanguageequalscolon semiColon whitespacekeywordsemiSep ppFunconsppValuesppComputationTypesppTypesppOpshowFnshowArgsIESortErrErr PartialOpInternalNoRule SideCondFailInsufficientInputInsufficientInputConsumedPatternMismatch StepOnValue IExceptionshowIException failsRule$fShowIESimIO Interactivefreadfprintfexec$fInteractiveStateT$fInteractiveIOghc-prim GHC.TypesIOValTermCompTermCountersrunMSOS MSOSStateinp_es mut_entitiesestate MSOSWriter ctrl_entities out_entitiesewriter MSOSReaderereader inh_entities runRewriteRewriteWriterrcounters RewriteState RewriteReader funconlibty_envrun_opts global_fct local_fct lookupFunconemptyRewriteState liftRewrite eval_catch eval_elserewrite_rethrow rewrite_throwevalctxt2exceptionctxt2exception rewriteRulesemptyMSOSState stepRules msos_throwgiveOptsgiveINH doRefocus modifyCTXTmodifyRewriteCTXTemptyINH emptyCTRL singleCTRL unionCTRLunionOUTemptyOUTreadOuts emptyCounters count_stepcount_delegation count_refocus count_restart count_rewrite exceptioninternal buildStepbuildStepCountbuildStepCounter optRefocusrefocus stepRewrittenif_abruptly_terminatesif_violates_refocus premiseContpremiseStepApp evalFunconsrewriteFunconsevalStrictSequence evalSequencetupleTypeTemplate evalTupleType stepTrans$fShowCounters$fMonoidCounters$fMonoidMSOSWriter $fMonadMSOS $fFunctorMSOS$fApplicativeMSOS$fMonoidRewriteWriterr$fMonadRewrite$fFunctorRewrite$fApplicativeRewrite$fShowRewrittenLevelled ValueTerm ValuesTerm FunconTerm FunconsTerm envLookup envInsertfsLevelfLevel substitute subsFlattensubsAndRewritestrict_vsMatch SeqVarInfoMatcher singleMatcher seqMatchermatchingordered_subsequences f2vPatternstrict_fsMatchfsMatchStrictnessfMatchlifted_vMaybeMatch vMaybeMatch lifted_vMatchvMatchadtMatch fpSeqVarInfo vpSeqVarInfomatchTypeParamsisInMaybeTermTypeisInisInType isInTupleType typeEnvLookupsetEntityDefaultsemptyMUTgiveMUT modifyMUTnewMUT withInputwithInputTerms congruence1_1 congruence1_2 congruence2_2 congruence1_3 congruence2_3 congruence3_3toboolemulateemulate' withResultsprintTestResults