V      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~E None;=NZ 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, X< can be used to specify the type of constructors. Variable X be a sequence variable.@The typing environment maps datatype names to their definitions. Representation of builtin types.(Funcon term representation identical to /, but with meta-variables./CInternal representation of funcon terms. The generic constructors 0 and 1| use names to represent nullary funcons and applications of funcons to other terms. Funcon terms are easily created using <, or via the smart constructors exported by  Funcons.Core.<Build 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]>Creates a list of funcon terms.?Creates a set of funcon terms.@Creates an integer literal.ACreates a natural literal.BCreates an atom from a .CCreates a string literal.The empty map as a /.The empty map as a /.The empty set as a /.HOCreates a tuple of funcon terms. tuple_ :: [Funcons] -> Funcons tuple_ = FTupleK Returns the unicodeL representation of an assci value. Otherwise it returns the original value.-Attempt to downcast a funcon term to a value.^>Lookup the definition of a datatype in the typing environment._ The empty .`Unites a list of s.a Unites two s.b Creates a  from a list.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ K L   MNOPQRSTUVWXYZ[\]^_`ab   !"#$%&'()*+,-./ 0123456789:;NonebZchgfedijklmnopqrstuvwxyzijklmnopqrstcdefghuvwxyzcdefgh NonecsjkNone<Nc:{|~}:{|}~{|}~ NonehXPretty-print a .Pretty-print a sequence of .Pretty-print a /.Pretty-print a sequence of /.Pretty-print a .Pretty-print a sort or  Noneh None;=Ni !"#$%!$#"None;=NQV]*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.'pA single step on a funcon term produces either a funcon term or a (possibly empty or unary) sequence of valuesAfter 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.Right-based union of sUnites a list of s.Right-based union of 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.rYield a sequence of funcon terms as the result of a rewrite. This is only valid when all terms rewrite to a value(Yield a funcon term as the result of an 5 computation. This function must be used instead of return. vYield a sequence of funcon terms as the result of a computation. This is only valid when all terms rewrite to a valueExecute a premise as either a rewrite or a step. Depending on whether only rewrites are necessary to yield a value, or whether a computational step is necessary, a different continuation is applied (first and second argument). Example usage: SstepScope :: NonStrictFuncon --strict in first argument stepScope [FValue (Map e1), x] = premiseEval x rule1 step1 where rule1 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:;<=>?@ABCDEFGHIJ'()KLMNOPQRSTUVWXYZ[\]^_`abcd*efghijklmno pq+,-.01/23564789:;<=>?@ABCDEFHGIJ()None]An environment mapping meta-variables to funcon terms. This environment is used by a substitution procedure to transform funcon terms from  representation to /.OThe empty substitution environment. Bindings are inserted by pattern-matching. Variant of  that applies substitution. Variant of  that applies substitution.cApply as many rewrites as possible to the term bound to the given variable in the meta-environmentrstuvwxyz{|}~rstuvwxNone0N]CSB 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.jTo type check a sequence values simply checker whether all elements of the sequence are of the given type7Parameterisable evaluation function function for types.D          None "Used for replacing meta-variables T in pattern annotations `P:T` with the type to which T+ is bound in some type-environment (if any)&-Associates types (Terms) with meta-variables ' Version of !; that does not replace the meta-variables in the given set( Version of "; that does not replace the meta-variables in the given set  "!#%$&'( !"#$%None])0Default 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.0%Get the value of some mutable entity.1 Variant of 0 that performs pattern-matching.2%Set the value of some mutable entity.3 Variant of 2 that applies substitution.|Consume a single value from the input stream. | Throws an 'unsufficient input' exception, if not enough input is available.4 Provides extraJ values to a certain input entity, available to be consumed by the given  computation argument.5 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.6 Variant of  that matches the given % to the consumed value in the given . 7 Variant of 4 that performs substitution.8 Variant of 5 that performs substitution.93Receive the value of a control entity from a given  computation.: Variant of  receiveSignal that performs pattern-matching.;&Signal a value of some control entity.< Variant of ; that applies substitution.ASet the value of an downwards control entity. The new value is only set for ' computation given as a third argument.(Get the value of an down control entity.> Version of  that applies pattern-matching.?%Get the value of an inherited entity.@ Version of ? that applies pattern-matching.A9Set the value of an inherited entity. The new value is only set for ' computation given as a third argument.B Variant of A that performs substitution.C*Add new values to a certain output entity.D Variant of C that applies substitution.EMRead the values of a certain output entity. The output is obtained from the ( computation given as a second argument.F Variant of E that performs pattern-matching.)*+,-./0123456789:;<=>?@ABCDEF)*+,-.NoneGCreate an environment from a list of bindings (String to Values) This function has been introduced for easy expression of the semantics of builtin identifiers H0A funcon library with funcons for builtin types.   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL/0123456789:; <IJKL=>?IG@AEFGCDB[Y]Z\HMSRTUWXNQVOPLKH?A02CE;945 !"#$%&'()*+,-.JB@31DF:<678=>     &#$% !"'(/)*+,-. ^a`b_None]%MxThis function implements the ==CT=> relation. Compiling programs to executable funcons terms, removing occurrences of  `meta-up`,  `meta-down` and  `meta-let` and  `meta-bound`.N`This function implements the ==UL=> relation. Translating a funcon into its meta-representationOuThis function implements the ==DL=> relation. Translating a meta-representation of a program into the actual programMNOPQRSTUVWXYZ[\]^_`MNOPQRSTUVWXYZ[\]^_`None&{abcdefghijklmnoNone]'pqrstuvwNone'axyz{|}~None'None(SNone(None)-None)None*oNone*None+eL      !"#$%&'()*+,-./0123456789:;<=>?@ABNone,CDNone- EFGHIJKLM None- NOPQRSTUVWX!None- YZ[\]^_`abc"None.^ defghijkl#None.mnopqrstuvwxyz$None/<{|}~%None/ &None0V 'None0 (None2qComputes the union over a sequence of maps. If the maps do not have disjoint domains a failure signal is raised.)None3*None4&+None]4,None4-None5Y     .None5 /None6W !"#$%&'()*+,-./012340None7 56789:;<=>?1None7q@ABCDEFGHIJKLMNOPQR2None7*STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|3None8}~4None9x5None96None:7None:8None;,%9None<,     :None<;None=w !"#<None= $%&'()*+,-./0=None>A123456789:;<=>?@ABCDE>None>FGHIJKLMNOPQRST?None?S UVWXYZ[\]^_`a@None? bcdefghijklmnANone@= opqrstuvwxyBNone@defghijklmno{|}~HIJKLMQRSTUVWX\]^_`abcghijkl      !"#$%&'()*+,-./0123489:;<=>?CDEFGHIJKLMNOPQRVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|     "#'()*+,-./0456789:;<=>?@ABCDEIJKLMNOPQRSTXYZ[\]^_`aefghijklmnrstuvwxyz{|CNoneHk}~DNoneHENoneIANoneI      !"#$%&'()*+,-./0123456789:;<=>?@ABDnopqrstuvwxyz~mnopqrstuvwxyz}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDpqrstuvwNoneq (The empty collection of entity defaults. 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).  Creates a maina function for the interpreter obtained by extending the default library with the funcons in the  argument. 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. 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. Creates a mainX function for the interpreter obtained by extending the main interpreter with funcons, / and a .  Creates a main7 function for the interpreter aware of only the given , / and .  Creates a main7 function for the interpreter aware of only the given , / and *, and the built-in types and operations. Same as a, except receiving additional interpreter extensions as arguments. Useful when a translation to /- has been implemented in Haskell as well as /G, entities or datatypes specific to the object language. Includes the FG funcons.Same as a, except receiving additional interpreter extensions as arguments. Useful when a translation to /- has been implemented in Haskell as well as /O, entities or datatypes specific to the object language. Does not include the FG funcons.Same as a, except receiving additional interpreter extensions as arguments. Useful when a translation to /- has been implemented in Haskell as well as /O, entities or datatypes specific to the object language. Does not include the FG funcons.aCreates a main function by passing in a list of command line arguments and an optional initial / to execute. The / argument is optional as one of the command line arguments may refer to an .fct file or .config file that specifies an initial /% term. Useful when a translation to /! has been implemented in Haskell.% _`ab)*+,-./% _a`b/)*+,-.Noner@Adefghijklmno{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABDHIJKLMQRSTUVWX\]^_`abcghijklnopqrstuvwxyz      !"#$%&'()*+,-./0123489:;<=>?CDEFGHIJKLMNOPQRVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|     "#'()*+,-./0456789:;<=>?@ABCDEIJKLMNOPQRSTXYZ[\]^_`aefghijklmnrstuvwxy~g@Az{|STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     opqrstuvwxy$%&'()*+,-./0123456789:;<=>?@ABCDE !"#bcdefghijklmnUVWXYZ[\]^_`aFGHIJKLMNOPQRSTabcdefghijklmno     defghijkl{|}~NOPQRSTUVWXEFGHIJKLMYZ[\]^_`abcxyz{|}~@ABCDEFGHIJKLMNOPQR !"#$%&'()*+,-./0123456789:;<=>?None(HIJHKLHKMHKNHKOHKPHKQHKRHKSHKTHKUHKV 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 F z { | } ~                          ! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr    s t u v w x y z!!!!!{!|!}!~!!!"""""""""##############$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%&&&&&&&&&'''''''''''''((J((((((((((((((()))))))))))))))))))))))))*****++++++++++++++,,,,,,,----------------- - - - - -........./////////////// /!/"/#/$/%/&/'/(/)/*/+/,0000-0.0/000102030411115161718191:1;1<1=1>1?1@1A1B1C1D2222E2F2G2H2I2J2K2L2M2N2O2P2Q2R2S2T2U2V2W2X2Y2Z2[2\2]2^2_2`2a2b2c2d2e2f2g2h2i2j2k3333l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|4444}4~445555555555555555555555555556667777777888888888888888888888888888888888888899999999999999999999999999999999999999999999:::::::::::::::::;;;;;<<<<<<<<<<<<<========= = = = = ========>>>>>>>>>>>>>> >!????"?#?$?%?&?'?(?)?*?+@@@@,@-@.@/@0@1@2@3@4@5AAAA6A7A8A9A:A;A<A=BBBCC>DD?D@DADBDCDDDEDFDGDHDIDJDKDLDMDNDODPQRSTUVWXYZ[\]^_`a b  cHdeHdHfgHfhHfiHfjHfkHlmHlHlnHlHlHlHloHlpHqrHqsHqtHquHqvHqwHxyHxHxzHx{HxHx|HxHx}HxHx~HxHHHVHH#HHH!HHHHHHHHHHHHHHH HH H HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHIHHHHHHHHHHHHHHHHHHHHHHHHHH>HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH H H H HHHHHH HHHHHHHHHHHHKHKHKHKHKHKHKHKHKHKHKHKHK HK!HK"HK#HK$HK%HK&HK'HK(HK)HK*HK+HK,HK-HK.HK/HK0HK1HK2HK3HK4HK5HK6HK7HK8HK9HK:HK;HK<HK=HK>HK?HK@HKAHKBHKCHKDHKEHKFHKGHKHHKIHKJHKKHKLHKMHKNHKOHKPHKQHKRHKSHKTHKUHKVHKWHKXHKYHKZHK[HK\HK]HK^HK_HK`HKaHKbHKcHKdHKeHKfHKgHKhHKiHKjHKkHKlHKmHKnHKoHKpHKq r d 7 6 s t u v w x y z { | } ~                                          EE E!",funcons-tools-0.2.0.1-1s8WSHpteg75DjseDkACiG Funcons.EDSLFuncons.GLLParserFuncons.RunOptionsFuncons.ValueOperationsFuncons.MetaProgramming Funcons.CoreFuncons.Core.Manual Funcons.Tools Funcons.TypesFuncons.ParserFuncons.PrinterFuncons.ExceptionsFuncons.Simulation Funcons.MSOSFuncons.SubstitutionFuncons.PatternsFuncons.TypeSubstitutionFuncons.Entities)Funcons.Core.Values.ValueTypes.ValueTypes Funcons.Core.Values.TypesBuiltin'Funcons.Core.Values.Primitive.Unit.Unit/Funcons.Core.Values.Primitive.Integers.Integers+Funcons.Core.Values.Primitive.Floats.Floats/Funcons.Core.Values.Primitive.CharactersBuiltin3Funcons.Core.Values.Primitive.Characters.Characters/Funcons.Core.Values.Primitive.Booleans.Booleans)Funcons.Core.Values.Primitive.BoolBuiltin-Funcons.Core.Values.Primitive.IntegersBuiltin+Funcons.Core.Values.Primitive.FloatsBuiltin#Funcons.Core.Values.Primitive.Atoms-Funcons.Core.Values.Composite.Vectors.Vectors/Funcons.Core.Values.Composite.Variants.Variants+Funcons.Core.Values.Composite.Tuples.Tuples-Funcons.Core.Values.Composite.Strings.Strings)Funcons.Core.Values.Composite.SetsBuiltin1Funcons.Core.Values.Composite.Sequences.Sequences3Funcons.Core.Values.Composite.References.References-Funcons.Core.Values.Composite.Records.Records.Funcons.Core.Values.Composite.MultisetsBuiltin)Funcons.Core.Values.Composite.MapsBuiltin)Funcons.Core.Values.Composite.Lists.Lists+Funcons.Core.Values.Composite.Graphs.Graphs.Funcons.Core.Values.Composite.DatatypesBuiltin1Funcons.Core.Values.Composite.Datatypes.Datatypes'Funcons.Core.Values.Composite.Bits.Bits-Funcons.Core.Values.Abstraction.Thunks.Thunks1Funcons.Core.Values.Abstraction.Patterns.Patterns/Funcons.Core.Values.Abstraction.Generic.Generic3Funcons.Core.Values.Abstraction.Functions.Functions0Funcons.Core.Computations.Normal.Storing.Storing0Funcons.Core.Computations.Normal.Linking.Linking8Funcons.Core.Computations.Normal.Interacting.Interacting.Funcons.Core.Computations.Normal.Giving.Giving2Funcons.Core.Computations.Normal.GeneratingBuiltin6Funcons.Core.Computations.Normal.Generating.Generating0Funcons.Core.Computations.Normal.Flowing.Flowing0Funcons.Core.Computations.Normal.Binding.Binding4Funcons.Core.Computations.Abnormal.Throwing.Throwing+Funcons.Core.Computations.Abnormal.Sticking6Funcons.Core.Computations.Abnormal.Returning.Returning2Funcons.Core.Computations.Abnormal.Failing.Failing:Funcons.Core.Computations.Abnormal.Controlling.Controlling8Funcons.Core.Computations.Abnormal.Continuing.Continuing4Funcons.Core.Computations.Abnormal.Breaking.Breaking6Funcons.Core.Computations.Abnormal.Abrupting.AbruptingFuncons.Core.Library,Funcons.Core.Values.Primitive.StringsBuiltin)Funcons.Core.Values.Primitive.BitsBuiltin&Funcons.Core.Computations.TypesBuiltinFunconsCore-funcons-values-0.1.0.2-IQjLhXss2kaDX1FaUppOoLFuncons.Operations.Mapsmap_Funcons.Operations.Valuesnone__unString upcastUnicodeupcastNaturalsupcastIntegersupcastRationalsdowncastValueTypeQuestionMarkOpPlusOpStarOp SeqSortOp DataTypeAlttDataTypeInclusionnDataTypeMemberConstructorDataTypeMembersDataTypeMemberssTPattern TPWildCardTPVarTPSeqVarTPLit TPComputesTPComputesFromTPADT TypeParam TypeRelationTypesComputationTypes TaggedSyntaxValuesFTermTVarTNameTAppTSeqTSetTMapTFunconTSortSeq TSortPower TSortUnion TSortInterTSortComplement TSortComputesTSortComputesFromTAnyFNameFAppFSetFMapFValueFSortSeq FSortPower FSortUnion FSortInterFSortComplement FSortComputesFSortComputesFrom applyFuncontuple_list_set_int_nat_atom_string_string__float_ieee_float_32_ieee_float_64_type_vec_fvalues downcastType downcastValueisValisAsciiisString isString_isCharisNatisIntisListisMapisTupisTypeisVec integers_unicode_characters_values_vectors_atoms_ typeLookupemptyTypeRelation typeEnvUnions typeEnvUniontypeEnvFromListFSuffixSuffixComputesFrom SuffixSeqSuffixSortUnionSuffixSortInter SuffixPowerParser fct_parse fvalue_parse fvalue_parse_parseparser_a allParsesfct_lexerSettingslexer fct_keywords fct_keycharslNamepFuncons pFunconss pFunconsSeqpKeyPairpOppValues 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 csv_outputcsv_output_with_keys inputValuesbooleanOptionsbooleanOptions_ stringOptionsstringOptions_ allOptions allOptions_ run_optionsparseAndApplyConfig config_parsercfg_lexerSettings cfg_keychars cfg_keywords pRunOptionspSpecpGeneralchoosespBool pStringValue pFunconName pTestOutcomespBuiltinFuncons pInputValues showValues showValuesSeqshowOp showFunconsshowFunconsSeq showTypes showTermsIESortErrErr PartialOpInternalNoRuleNoMoreBranches SideCondFailInsufficientInputInsufficientInputConsumedPatternMismatch StepOnValue IExceptionInputOutputControl InheritedMutableMSOSRewrite Rewritten StrictnessStrict NonStrict NullaryFunconValueOpPartiallyStrictFunconNonStrictFuncon StrictFuncon EvalFunction FunconLibrary fromValOp fromSeqValOpfromNullaryValOplibEmptylibUnion libOverride libUnions libOverrides libFromList rewriteRules stepRules evalRulesnorulesortErr partialOp rewritten rewriteTo rewriteSeqTostepTo stepSeqTo premiseEval premiseStepcompstepEnvemptyEnv rewriteTermTo stepTermTolifted_envStoreenvStorelifted_envRewrite envRewrite SideCondition SCEquality SCInequality SCIsInSort SCNotInSortSCPatternMatchVPatternPADT VPWildCard VPMetaVar VPAnnotatedVPSeqVarVPLitVPTypeFPatternPValuePMetaVarPSeqVar PAnnotated PWildCard f2vPatternlifted_vsMatchvsMatchpremiselifted_fsMatchfsMatchlifted_sideCondition sideConditionisIn rewriteTypepat2term vpat2term typat2term HasTypeVar subsTypeVarsubsTypeVarWildcardTyAssocElemOfSubTyOfTypeEnvlimitedSubsTypeVarlimitedSubsTypeVarWildcard EntityDefault DefMutable DefInherited DefOutput DefControlDefInputEntityDefaultsgetMut getMutPattputMut putMutTermwithExtraInputwithExactInput matchInputwithExtraInputTermswithExactInputTermsreceiveSignalsreceiveSignalPatt raiseSignal raiseTermwithControlTermgetControlPattgetInh getInhPattwithInh withInhTermwriteOut writeOutTermreadOut readOutPatt env_fromlist_libraryapp0_app1_app2_app3_ctRelulReldlRelevalRelcompiletranslationStepcmp_MSOSReader cmp_MSOSStatemeta_up_ meta_down_ meta_let_eval_code_step_meta_eval step_codeast_step_asttype_of_ step_ty_ofentitiestypesfuncons is_in_type_is_stepIs_in_type cast_to_type_cast_stepCast_to_type is_defined_is_def_stepIs_defined is_equal_is_eq_ stepIs_equaltypes_ value_types_defined_values_nothing_datatype_values_none_ground_values_ null_value_null_stepNull_value unit_type_ stepUnit_typebounded_integers_ bounded_ints_stepBounded_integerspositive_integers_ pos_ints_stepPositive_integersnegative_integers_ neg_ints_stepNegative_integersnatural_numbers_nats_stepNatural_numbersinteger_negate_int_neg_stepInteger_negateinteger_sequence_stepInteger_sequence binary32_ stepBinary32 binary64_ stepBinary64 binary128_ stepBinary128 decimal64_ stepDecimal64 decimal128_stepDecimal128float_formats_stepFloat_formatsascii_characters_ascii_character_unicode_unicode_character_code_ characters_chars_unicode_point_stepUnicode_pointiso_latin_1_points_stepIso_latin_1_points ascii_points_stepAscii_pointsstepAscii_character backspace_ stepBackspacehorizontal_tab_stepHorizontal_tab line_feed_ stepLine_feed form_feed_ stepForm_feedcarriage_return_stepCarriage_return double_quote_stepDouble_quote single_quote_stepSingle_quote backslash_ stepBackslashtrue_stepTruefalse_ stepFalsenot_stepNotimplies_ stepImpliesand_stepAndor_stepOr exclusive_or_xor_stepExclusive_or booleans_ stepBooleansbool_ints_natural_predecessor_ nat_pred_natural_successor_ nat_succ_int_add_ integer_add_integer_multiply_integer_divide_integer_subtract_integer_power_integer_power_op integer_list_integer_modulo_ integer_mod_integer_absolute_value_decimal_natural_is_less_integer_is_less_is_less_or_equal_integer_is_less_or_equal_ is_greater_integer_is_greater_is_greater_or_equal_integer_is_greater_or_equal_ieee_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_multiply_ieee_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_opvector_ stepVectorvector_elements_stepVector_elements stepVectorsvariant_ stepVariant variant_id_stepVariant_idvariant_value_stepVariant_value variants_ stepVariants stepTupletuple_elements_stepTuple_elements tuple_zip_ stepTuple_ziptuples_ stepTuplesstrings_ stepStrings stepStringstring_append_stepString_appendsets_ set_elements_ set_size_set_intersect_set_difference_ some_element_ is_subset_ is_in_set_ set_unite_ set_insert_element_not_in_ set_empty_length_ stepLengthindex_ stepIndexfirst_ stepFirstsecond_ stepSecondthird_ stepThirdis_in_ stepIs_infirst_n_ stepFirst_n drop_first_n_stepDrop_first_nreverse_ stepReversen_of_stepN_of intersperse_stepInterspersefilter_defined_stepFilter_defined reference_ stepReference pointers_ stepPointers dereference_stepDereference references_stepReferencesrecord_ stepRecordrecord_select_stepRecord_selectrecords_ stepRecordsis_sub_multisetstepIsSubMultisetmultiset_deletestepMultisetDeletemultiset_insertstepMultisetInsertmultiset_occurrencesstepMultisetOccurrencesmultiset_to_setstepMultisetToSetsets_to_multisetstepSetsToMultisetmaps_ map_empty_ is_map_empty_ is_in_domain_ map_insert_ map_delete_ map_unite_lookup_ map_lookup_ map_override_domain_dom_ map_domain_ map_elements_ map_points_stepListlist_elements_stepList_elements list_nil_nil_ stepList_nil list_cons_cons_ stepList_cons list_head_head_ stepList_head list_tail_tail_ stepList_tail list_length_stepList_length list_append_stepList_appendlists_ stepListsdirected_graphs_stepDirected_graphsdatatype_value_adt_val_evalADT lazy_adt_val_ evalLazyADTadt_construct_ adtConstructadt_type_construct_adtTypeConstructadt_constructor_adtConstructor adt_fields_ adtFieldsdatatype_value_id_stepDatatype_value_iddatatype_value_elements_stepDatatype_value_elementsbits_stepBits bit_vector_stepBit_vectorbytes_octets_ stepBytesunsigned_bit_vector_maximum_stepUnsigned_bit_vector_maximumsigned_bit_vector_maximum_stepSigned_bit_vector_maximumsigned_bit_vector_minimum_stepSigned_bit_vector_minimumis_in_signed_bit_vector_stepIs_in_signed_bit_vectoris_in_unsigned_bit_vector_stepIs_in_unsigned_bit_vector bit_vectors_stepBit_vectorsthunk_ stepThunkforce_ stepForcethunks_ stepThunkspattern_ stepPattern pattern_any_stepPattern_any pattern_bind_stepPattern_bind pattern_type_stepPattern_type pattern_else_stepPattern_elsepattern_unite_stepPattern_unitematch_ stepMatchmatch_loosely_stepMatch_loosely case_match_stepCase_matchcase_match_loosely_stepCase_match_looselycase_variant_value_stepCase_variant_value patterns_ stepPatterns abstraction_stepAbstractionclosure_ stepClosureenact_ stepEnact abstractions_stepAbstractions function_ stepFunctionapply_ stepApplysupply_ stepSupplycompose_ stepComposeuncurry_ stepUncurrycurry_ stepCurrypartial_apply_stepPartial_apply functions_ stepFunctions locations_locs_ stepLocationsstores_ stepStores store_clear_stepStore_clearinitialise_storing_ init_storing_stepInitialise_storing variable_var_ stepVariableallocate_variable_alloc_stepAllocate_variablerecycle_variables_recycle_stepRecycle_variablesinitialise_variable_init_stepInitialise_variableallocate_initialised_variable_ alloc_init_!stepAllocate_initialised_variableassign_ stepAssign assigned_ stepAssigned un_assign_ stepUn_assignstructural_assign_stepStructural_assignstructural_assigned_stepStructural_assignedcurrent_value_stepCurrent_value variables_ stepVariableslink_stepLinkinitialise_linking_stepInitialise_linking fresh_link_stepFresh_linkfresh_initialised_link_fresh_init_link_stepFresh_initialised_link set_link_ stepSet_link follow_link_stepFollow_linkfollow_if_link_stepFollow_if_linklinks_ stepLinksprint_ stepPrintread_stepReadinitialise_giving_stepInitialise_givinggive_stepGivegiven_ stepGiven no_given_ stepNo_givenleft_to_right_map_stepLeft_to_right_mapinterleave_map_stepInterleave_mapleft_to_right_repeat_stepLeft_to_right_repeatinterleave_repeat_stepInterleave_repeatleft_to_right_filter_stepLeft_to_right_filterinterleave_filter_stepInterleave_filter fold_left_ stepFold_left fold_right_stepFold_rightinitialise_generating_stepInitialise_generating fresh_atom_stepFresh_atomuse_atom_not_in_stepUse_atom_not_in interleave_stepInterleavesignal_ stepSignalyield_ stepYieldyield_on_value_stepYield_on_valueyield_on_abrupt_stepYield_on_abruptleft_to_right_l_to_r_stepLeft_to_rightright_to_left_r_to_l_stepRight_to_left sequential_seq_stepSequentialeffect_ stepEffectchoice_ stepChoice if_true_else_if_else_stepIf_true_else while_true_while_stepWhile_truedo_while_true_ do_while_stepDo_while_true yielding_ stepYielding environments_env_envs_stepEnvironmentsidentifier_tagged_ id_tagged_stepIdentifier_taggedfresh_identifier_stepFresh_identifierinitialise_binding_stepInitialise_binding bind_value_bind_stepBind_valueunbind_ stepUnbindbound_directly_stepBound_directly bound_value_bound_stepBound_valueclosed_ stepClosedscope_ stepScope accumulate_stepAccumulate collateral_stepCollateralbind_recursively_stepBind_recursively recursive_ stepRecursive re_close_ stepRe_closebind_to_forward_links_stepBind_to_forward_linksset_forward_links_stepSet_forward_links identifiers_stepIdentifiersthrown_ stepThrownfinalise_throwing_stepFinalise_throwingthrow_ stepThrowhandle_thrown_stepHandle_thrownhandle_recursively_stepHandle_recursivelycatch_else_throw_stepCatch_else_throw throwing_ stepThrowingstuck_ stepStuck returned_ stepReturnedfinalise_returning_stepFinalise_returningreturn_ stepReturnhandle_return_stepHandle_return returning_ stepReturningfailed_ stepFailedfinalise_failing_stepFinalise_failingfail_stepFailelse_stepElse else_choice_stepElse_choice check_true_check_stepCheck_truedefined_def_ stepDefinedfailing_ stepFailing continuation_stepContinuationhole_stepHoleresume_continuation_stepResume_continuationcontrol_ stepControldelimit_continuations_stepDelimit_continuationscontinuations_stepContinuations continued_ stepContinuedfinalise_continuing_stepFinalise_continuing continue_ stepContinuehandle_continue_stepHandle_continue continuing_stepContinuingbroken_ stepBrokenfinalise_breaking_stepFinalise_breakingbreak_ stepBreak handle_break_stepHandle_break breaking_ stepBreakingfinalise_abrupting_stepFinalise_abruptingabrupt_ stepAbrupthandle_abrupt_stepHandle_abruptfinally_ stepFinally to_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_BitsnoEntityDefaultsmkMainmkMainWithLibrarymkMainWithLibraryEntitiesmkMainWithLibraryTypesmkMainWithLibraryEntitiesTypesmkFullyFreshInterpretermkFreshInterpreterrunWithExtensionsrunWithExtensionsNoCorerunWithExtensionsNoNothingrun evalOperation execRewritesbaseGHC.BaseString empty_map_ empty_set_Funcons.OperationslibAppFuncons.Operations.Eval applyEvaleval EvalResultErrorSuccessFuncons.Operations.ADTs adt_fieldsadt_constructoradtsadts_Funcons.Operations.Atomsatomatoms next_atom next_atom_ atom_seed atom_seed_Funcons.Operations.Charactersunicode_character_codenumUnicodeCodesunicodeascii_characterascii_characters charactersFuncons.Operations.FloatsdoubleFromIEEEFormat isIEEEFormatieee_float_add_ieee_float_truncate_Funcons.Operations.Integersis_greater_or_equal is_greateris_less_or_equalis_lessdecimal_naturalinteger_absolute_value integer_listnatural_successornatural_predecessor integer_powerinteger_divideinteger_subtract is_integer is_integer_integersstepModFuncons.Operations.ListstailOpheadOp list_concat list_concat_ list_appendconsis_nilis_nil_nillist_singletonlist_singleton_lists map_points map_elementsallDomainPairs map_unite map_overridedomain is_in_domain map_delete map_lookup map_insert is_map_empty map_singletonmap_singleton_ map_emptymapsmkPairsFuncons.Operations.Setselement_not_in set_insert is_subset some_elementset_differenceset_size set_elements is_in_set set_emptysetsFuncons.Operations.Strings mk_string stepTo_String to_string is_string is_string_Funcons.Operations.Types isInTupleTypeisInType type_member type_member_tyOf value_type value_type_is_value is_value_valuesnothingdefined_values value_types ground_valuesdatatype_valuesFuncons.Operations.Booleansis_equalfrombooltobool"Funcons.Operations.NonGroundValuesnon_grounded_valuesnon_grounded_values_ non_grounded non_grounded_Funcons.Operations.Optionalsnonesomesome_some__ optionals optionals_toOptFuncons.Operations.Tuples tuple_index tuple_index_ tuple_prepend empty_tupletuple_prepend_ empty_tuple_Funcons.Operations.LibrariesLibraryFuncons.Operations.Expr applyExprarityErr ternaryOpbinaryOpunaryOp nullaryOpopNamevNaryOp vTernaryOp vBinaryOpvUnaryOp vNullaryOpOPResultDomErrArityErrProjErrNormal NullaryOpUnaryOpBinaryOp TernaryOpNaryOp NullaryVOpUnaryVOp BinaryVOp TernaryVOpNaryVOpOpExprValExprTermExpr InvalidOp RewritesToNaryExpr TernaryExpr BinaryExpr UnaryExpr NullaryExpr showArgs_ppOpppTypesppComputationTypesppTaggedSyntaxppValues=/====mk_ascii_charactersmk_unicode_characters mk_naturals mk_integerscastTypestructTMcomparestructTSMcomparestructVMcomparestructCTMcomparestructVcompare traverseCTM traverseTSM traverseTM traverseT traverseVM traverseVvmapTSvmaplisttupleMVarCharFloatIntNatRationalMapSetADTValAsciiAtomBitComputationType IEEE_Float_32 IEEE_Float_64MultisetVectorVMetaVAnyTagNameTagType ValueMaps ValueSets ValueVectorsType ComputesTypeComputesFromTypeBitsADTsADT AnnotatedTypeAsciiCharactersAtoms IntegersFrom IntegersUpTo Characters Complement EmptyType GroundValues IEEEFloatsIntegers IntersectionMaps MultisetsNaturalsNothings RationalsSetsStringsUnicodeCharactersUnion DefinedValuesVectorsASTs HasValuesprojectinjectHasComputationTypes projectCTinjectCTHasTypesprojectTinjectT IEEEFormatsBinary32Binary64TTParamNameMetaVarbinary32binary64adtval tuple_val__ tuple_val_ nullaryTypes unaryTypes binaryTypesboundedIntegerTypes floatTypessort_ comp_type_vectypeVallistvalsetvalsetval_mapvalmapval_ downcastSortrecursiveFunconValueallEqual allUnEqual isNoValuehasStep isDefinedValisAscii_isEnvisSetisSortisSort_ isCharacter_ showSorts ppValuesSeq ppFunconsSeq ppFunconsppTermsshowIException failsRuleSimIO InteractivefexecfprintfreadrunSimIOghc-prim GHC.TypesIOStepResValTermCompTermpremiseStepApprunMSOS MSOSStateestateinp_es mut_entities MSOSWriterewriter ctrl_entities out_entities MSOSReaderereader inh_entitiesdctrl_entities def_fread runRewriteRewriteWriterrcounters RewriteState RewriteReader funconlibrun_optsty_env global_fct local_fcttraceLibemptyRewriteState liftRewrite eval_catchrewrite_rethrow rewrite_throwevalctxt2exceptionctxt2exceptionemptyMSOSState msos_throwgiveINHgiveCTRLemptyINH emptyDCTRL singleCTRLreadOutscount_delegation ppCounters counterKeysdisplayCounters exceptioninternalsidecond buildStep optRefocus rewrittens evalFunconsrewritesToValuerewritesToValuesrewriteToValErrrewriteFunconsWcountrewriteFunconsrewriteStrictSequenceevalStrictSequence evalSequence stepTrans toStepResCountersLevelledTypeTerm TypesTerm ValueTerm ValuesTerm FunconTerm FunconsTerm envLookup envInsertvsLevelvLevelfsLevelfLevelsubstitute_signal substitutesubsAndRewritesInEnvsubsAndRewritesToValuesubsAndRewritesToValueInEnvsubsAndRewritesToValuessubsAndRewritesToValuesInEnvstrict_vsMatchisInMaybeTupleType SeqVarInfoMatcher singleMatcher seqMatchermatchingordered_subsequences v2tPattern v2fPatternsubstitute_patt_signalstrict_fsMatchfsMatchStrictnessfMatchlifted_fMaybeMatch fMaybeMatchlifted_vMaybeMatch vMaybeMatch lifted_vMatchvMatchtsMatchstrict_tsMatchtMatchadtMatch fpSeqVarInfo vpSeqVarInfo tpSeqVarInfomatchTypeParams alwaysAcceptrewritesToAnnotatedTypeisInMaybeTermType isInTuple typeEnvLookup consumeInput withControl getControlsetEntityDefaultscomputation_types_stepComputation_Types