-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A modular interpreter for executing funcons
--   
--   The PLanCompS project (<a>http://plancomps.org</a>) has developed a
--   component-based approach to formal semantics. The semantics of a
--   language is defined by translating its constructs to combinations of
--   `fundamental constructs' called <i>funcons</i>.
--   
--   This package provides a collection of highly reusable funcons in
--   <a>Funcons.Core</a>, an interpreter for these funcons and means for
--   defining new funcons.
--   
--   The executable provided by this package is an interpreter for running
--   terms constructed from the collection of funcons provided by
--   <a>Funcons.Core</a>. How this executable is used is explained in
--   <a>Funcons.Tools</a>.
--   
--   Additional funcons can be defined with the helper functions provided
--   by <a>Funcons.EDSL</a>. The module <a>Funcons.Tools</a> provides
--   functions for creating executables by extending the main interpreter
--   with additional funcons.
@package funcons-tools
@version 0.2.0.9

module Funcons.GLLParser
type Parser a = BNF Token a
fct_parse :: String -> Funcons
fvalue_parse :: String -> Funcons
fvalue_parse_ :: String -> Values
parse :: Parser a -> String -> a
parser_a :: Parser a -> String -> a
allParses :: Parser a -> String -> [a]
fct_lexerSettings :: LexerSettings
lexer :: String -> [Token]
fct_keywords :: [String]
fct_keychars :: [Char]
lName :: RE Char [Char]
data FSuffix
SuffixComputesFrom :: Funcons -> FSuffix
SuffixSeq :: SeqSortOp -> FSuffix
SuffixSortUnion :: Funcons -> FSuffix
SuffixSortInter :: Funcons -> FSuffix
SuffixPower :: Funcons -> FSuffix
pFuncons :: Parser Funcons
pFunconss :: Parser (Either Funcons [Funcons])
pFunconsSeq :: Parser [Funcons]
pKeyPair :: Parser Funcons
pOp :: Parser SeqSortOp
pValues :: Parser Values

module Funcons.Parser
fct_parse :: String -> Funcons
fvalue_parse :: String -> Funcons

module Funcons.RunOptions
type GeneralOptions = Map Name String
type BuiltinFunconsOptions = Map Name Funcons
type TestOptions = Map Name [Funcons]
type InputValues = Map Name [Values]
data RunOptions
RunOptions :: Maybe Funcons -> GeneralOptions -> BuiltinFunconsOptions -> TestOptions -> InputValues -> RunOptions
[mfuncon_term] :: RunOptions -> Maybe Funcons
[general_opts] :: RunOptions -> GeneralOptions
[builtin_funcons] :: RunOptions -> BuiltinFunconsOptions
[expected_outcomes] :: RunOptions -> TestOptions
[given_inputs] :: RunOptions -> InputValues
defaultRunOptions :: RunOptions
optionsOverride :: RunOptions -> RunOptions -> RunOptions
funcon_term :: RunOptions -> Funcons
bool_opt_default :: Bool -> Name -> Map Name String -> Bool
bool_opt :: Name -> Map Name String -> Bool
do_refocus :: RunOptions -> Bool
max_restarts :: RunOptions -> Maybe Int
do_abrupt_terminate :: RunOptions -> Bool
pp_full_environments :: RunOptions -> Bool
show_result :: RunOptions -> Bool
show_counts :: RunOptions -> Bool
show_mutable :: RunOptions -> [Name]
hide_output :: RunOptions -> [Name]
hide_input :: RunOptions -> [Name]
hide_control :: RunOptions -> [Name]
interactive_mode :: RunOptions -> Bool
pp_string_outputs :: RunOptions -> Bool
string_inputs :: RunOptions -> Bool
show_tests :: RunOptions -> Bool
show_output_only :: RunOptions -> Bool
auto_config :: RunOptions -> Bool
csv_output :: RunOptions -> Bool
csv_output_with_keys :: RunOptions -> Bool
inputValues :: RunOptions -> InputValues
booleanOptions :: [[Char]]
booleanOptions_ :: [[Char]]
stringOptions :: [[Char]]
stringOptions_ :: [[Char]]
allOptions :: [[Char]]
allOptions_ :: [[Char]]
run_options :: [String] -> IO (RunOptions, [String])
parseAndApplyConfig :: FilePath -> String -> RunOptions -> RunOptions
config_parser :: String -> RunOptions
lexer :: String -> [Token]
cfg_lexerSettings :: LexerSettings
cfg_keychars :: [Char]
cfg_keywords :: [[Char]]
pRunOptions :: Parser RunOptions
pSpec :: Parser RunOptions
pGeneral :: Parser RunOptions
chooses :: (Show t, Ord t, HasAlts (OO f j)) => String -> f (j t a) -> SymbExpr t a
pBool :: Parser String
pStringValue :: Parser String
pFunconName :: Parser String
pTestOutcomes :: Parser RunOptions
pBuiltinFuncons :: Parser RunOptions
pInputValues :: Parser RunOptions


-- | This module provides the types and the functions necessary for
--   defining funcons. The package provides a large collection of
--   predefined funcons in <a>Funcons.Core</a>. Module <a>Funcons.Tools</a>
--   provides functions for creating executables.
module Funcons.EDSL

-- | Internal representation of funcon terms. The generic constructors
--   <a>FName</a> and <a>FApp</a> use names to represent nullary funcons
--   and applications of funcons to other terms. Funcon terms are easily
--   created using <a>applyFuncon</a> or via the smart constructors
--   exported by <a>Funcons.Core</a>.
data Funcons
FName :: Name -> Funcons
FApp :: Name -> [Funcons] -> Funcons
FSet :: [Funcons] -> Funcons
FMap :: [Funcons] -> Funcons
FBinding :: Funcons -> [Funcons] -> Funcons
FValue :: Values -> Funcons
FSortSeq :: Funcons -> SeqSortOp -> Funcons
FSortPower :: Funcons -> Funcons -> Funcons
FSortUnion :: Funcons -> Funcons -> Funcons
FSortInter :: Funcons -> Funcons -> Funcons
FSortComplement :: Funcons -> Funcons
FSortComputes :: Funcons -> Funcons
FSortComputesFrom :: Funcons -> Funcons -> Funcons
type Values = Values Funcons
type Types = Types Funcons

-- | Representation of builtin types.
type ComputationTypes = ComputationTypes Funcons

-- | Postfix operators for specifying sequences.
data SeqSortOp
StarOp :: SeqSortOp
PlusOp :: SeqSortOp
QuestionMarkOp :: SeqSortOp

-- | Build funcon terms by applying a funcon name to `zero or more' funcon
--   terms. This function is useful for defining smart constructors, e,g,
--   
--   <pre>
--   handle_thrown_ :: [Funcons] -&gt; Funcons
--   handle_thrown_ = applyFuncon "handle-thrown"
--   </pre>
--   
--   or alternatively,
--   
--   <pre>
--   handle_thrown_ :: Funcons -&gt; Funcons -&gt; Funcons
--   handle_thrown_ x y = applyFuncon "handle-thrown" [x,y]
--   </pre>
applyFuncon :: Name -> [Funcons] -> Funcons
app0_ :: ([Funcons] -> Funcons) -> Funcons
app1_ :: ([Funcons] -> Funcons) -> Funcons -> Funcons
app2_ :: ([Funcons] -> Funcons) -> Funcons -> Funcons -> Funcons
app3_ :: ([Funcons] -> Funcons) -> Funcons -> Funcons -> Funcons -> Funcons

-- | Creates a set of funcon terms.
set_ :: [Funcons] -> Funcons
vec_ :: [Values] -> Funcons

-- | Create an environment from a list of bindings (String to Values) This
--   function has been introduced for easy expression of the semantics of
--   builtin identifiers
env_fromlist_ :: [(String, Funcons)] -> Funcons
null__ :: () => Values t

-- | Creates an integer <tt>literal</tt>.
int_ :: Int -> Funcons
bool_ :: Bool -> Funcons
bool__ :: Bool -> Values
list__ :: [Values] -> Values
vector__ :: [Values] -> Values
tuple__ :: [Values] -> Values
char_ :: Char -> Funcons
char__ :: Char -> Values

-- | Creates a natural <tt>literal</tt>.
nat_ :: Int -> Funcons
float_ :: Double -> Funcons
ieee_float_32_ :: Float -> Funcons
ieee_float_64_ :: Double -> Funcons

-- | Creates a string literal.
string_ :: String -> Funcons
string__ :: String -> Values

-- | Creates an atom from a <a>String</a>.
atom_ :: String -> Funcons
values_ :: Funcons
integers_ :: Funcons
vectors_ :: Types -> Funcons

-- | Creates a tuple of funcon terms. tuple_ :: [Funcons] -&gt; Funcons
--   tuple_ = FTuple
type_ :: Types -> Funcons
ty_star :: Funcons -> Funcons
ty_plus :: Funcons -> Funcons
ty_opt :: Funcons -> Funcons
ty_union :: Funcons -> Funcons -> Funcons
ty_neg :: Funcons -> Funcons
ty_inter :: Funcons -> Funcons -> Funcons
ty_power :: Funcons -> Funcons -> Funcons

-- | Pretty-print a <a>Values</a>.
showValues :: Values -> String

-- | Pretty-print a sequence of <a>Values</a>.
showValuesSeq :: [Values] -> String

-- | Pretty-print a <a>Funcons</a>.
showFuncons :: Funcons -> String

-- | Pretty-print a sequence of <a>Funcons</a>.
showFunconsSeq :: [Funcons] -> String

-- | Pretty-print a <a>Types</a>.
showTypes :: Types -> String
showTerms :: FTerm -> String
showOp :: SeqSortOp -> String
isVal :: Funcons -> Bool
isInt :: Funcons -> Bool
isNat :: Funcons -> Bool
isList :: Funcons -> Bool
isMap :: Funcons -> Bool
isType :: Funcons -> Bool
isVec :: Funcons -> Bool
isChar :: Funcons -> Bool
isTup :: () => p -> Bool
isString :: Funcons -> Bool
isString_ :: HasValues t => Values t -> Bool
unString :: HasValues t => Values t -> String
downcastValue :: Funcons -> Values

-- | Returns the <i>unicode</i> representation of an assci value. Otherwise
--   it returns the original value.
--   
--   Attempt to downcast a funcon term to a value.
downcastType :: Funcons -> Types
downcastValueType :: () => Values t -> Types t

-- | Returns the <i>natural</i> representation of a value if it is a
--   subtype. Otherwise it returns the original value.
upcastNaturals :: () => Values t -> Values t

-- | Returns the <i>integer</i> representation of a value if it is a
--   subtype. Otherwise it returns the original value.
upcastIntegers :: () => Values t -> Values t

-- | Returns the <i>rational</i> representation of a value if it is a
--   subtype. Otherwise it returns the original value.
upcastRationals :: () => Values t -> Values t
upcastCharacter :: HasValues t => Values t -> Maybe Char

-- | 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
--   <a>Strictness</a> of the argument.
data EvalFunction

-- | Funcons for which arguments are <i>not</i> evaluated.
NonStrictFuncon :: NonStrictFuncon -> EvalFunction

-- | Strict funcons whose arguments are evaluated.
StrictFuncon :: StrictFuncon -> EvalFunction

-- | Funcons for which <i>some</i> arguments are evaluated.
PartiallyStrictFuncon :: [Strictness] -> Strictness -> NonStrictFuncon -> EvalFunction

-- | Synonym for <a>EvalFunction</a>, for value operations.
ValueOp :: ValueOp -> EvalFunction

-- | Funcons without any arguments.
NullaryFuncon :: NullaryFuncon -> EvalFunction

-- | Denotes whether an argument of a funcon should be evaluated or not.
data Strictness
Strict :: Strictness
NonStrict :: Strictness

-- | Type synonym for the evaluation function of strict funcons. The
--   evaluation function of a <a>EvalFunction</a> receives fully evaluated
--   arguments.
type StrictFuncon = [Values] -> Rewrite Rewritten

-- | Type synonym for the evaluation function of non-strict funcons.
type PartiallyStrictFuncon = NonStrictFuncon

-- | Type synonym for the evaluation function of fully non-strict funcons.
type NonStrictFuncon = [Funcons] -> Rewrite Rewritten

-- | Type synonym for value operations.
type ValueOp = StrictFuncon

-- | Type synonym for the evaluation functions of nullary funcons.
type NullaryFuncon = Rewrite Rewritten

-- | A funcon library maps funcon names to their evaluation functions.
type FunconLibrary = Map Name EvalFunction

-- | Creates an empty <a>FunconLibrary</a>.
libEmpty :: FunconLibrary

-- | Unites two <a>FunconLibrary</a>s.
libUnion :: FunconLibrary -> FunconLibrary -> FunconLibrary

-- | Right-based union of <a>FunconLibrary</a>s
libOverride :: FunconLibrary -> FunconLibrary -> FunconLibrary

-- | Unites a list of <a>FunconLibrary</a>s.
libUnions :: [FunconLibrary] -> FunconLibrary

-- | Right-based union of list of <a>FunconLibrary</a>s
libOverrides :: [FunconLibrary] -> FunconLibrary

-- | Creates a <a>FunconLibrary</a> from a list.
libFromList :: [(Name, EvalFunction)] -> FunconLibrary

-- | A funcon library with funcons for builtin types.
library :: FunconLibrary
fromNullaryValOp :: ([Funcons] -> Funcons) -> ([OpExpr Funcons] -> OpExpr Funcons) -> EvalFunction
fromValOp :: ([Funcons] -> Funcons) -> ([OpExpr Funcons] -> OpExpr Funcons) -> EvalFunction
fromSeqValOp :: ([Funcons] -> Funcons) -> ([OpExpr Funcons] -> OpExpr Funcons) -> EvalFunction

-- | 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>FunconLibrary</a>), a typing
--   environment (see <a>TypeRelation</a>), runtime options, etc.
--   
--   The semantic entities are divided into five classes:
--   
--   <ul>
--   <li>inherited entities, propagated similar to values of a reader
--   monad.</li>
--   <li>mutable entities, propagated similar to values of a state
--   monad.</li>
--   <li>output entities, propagation similar to values of a write
--   monad.</li>
--   <li>control entities, similar to output entities except only a single
--   control <i>signal</i> can be emitted at once (signals do not form a
--   monoid).</li>
--   <li>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 <a>IO</a> monad. See
--   <a>Funcons.Tools</a>.</li>
--   </ul>
--   
--   For each entity class a map is propagated, mapping entity names to
--   values. This enables modular access to the entities.
data MSOS a

-- | Monadic type for the implicit propagation of meta-information on the
--   evaluation of funcon terms (no semantic entities). It is separated
--   from <a>MSOS</a> to ensure that side-effects (access or modification
--   of semantic entities) can not occur during syntactic rewrites.
data Rewrite a

-- | 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.
data Rewritten

-- | Yield a funcon term as the result of a syntactic rewrite. This
--   function must be used instead of <tt>return</tt>. The given term is
--   fully rewritten.
rewriteTo :: Funcons -> Rewrite Rewritten

-- | Yield a sequence of funcon terms as the result of a rewrite. This is
--   only valid when all terms rewrite to a value
rewriteSeqTo :: [Funcons] -> Rewrite Rewritten

-- | Yield a funcon term as the result of an <a>MSOS</a> computation. This
--   function must be used instead of <tt>return</tt>.
stepTo :: Funcons -> MSOS StepRes

-- | Yield a sequence of funcon terms as the result of a computation. This
--   is only valid when all terms rewrite to a value
stepSeqTo :: [Funcons] -> MSOS StepRes

-- | Yield an <a>MSOS</a> computation as a fully rewritten term. This
--   function must be used in order to access entities in the definition of
--   funcons.
compstep :: MSOS StepRes -> Rewrite Rewritten

-- | Returns a value as a fully rewritten term.
rewritten :: Values -> Rewrite Rewritten
premiseStep :: Funcons -> MSOS StepRes

-- | Execute 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:
--   
--   <pre>
--   stepScope :: NonStrictFuncon --strict in first argument
--   stepScope [FValue (Map e1), x] = premiseEval x rule1 step1 
--    where   rule1 v  = rewritten v
--            step1 stepX = do   
--                Map e0  &lt;- getInh "environment"
--                x'      &lt;- withInh "environment" (Map (union e1 e0)) stepX
--                stepTo (scope_ [FValue e1, x'])
--   </pre>
premiseEval :: ([Values] -> Rewrite Rewritten) -> (MSOS StepRes -> MSOS StepRes) -> Funcons -> Rewrite Rewritten

-- | Yields an error signaling that no rule is applicable. The funcon term
--   argument may be used to provide a useful error message.
norule :: Funcons -> Rewrite a

-- | Yields an error signaling that a sort error was encountered. These
--   errors render a rule <i>inapplicable</i> and a next rule is attempted
--   when a backtracking procedure like <a>evalRules</a> is applied. The
--   funcon term argument may be used to provide a useful error message.
sortErr :: Funcons -> String -> Rewrite a

-- | 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 <i>inapplicable</i> and a next rule is attempted when a
--   backtracking procedure like <a>evalRules</a> is applied. The funcon
--   term argument may be used to provide a useful error message.
partialOp :: Funcons -> String -> Rewrite a

-- | a map storing the values of <i>inherited</i> entities.
type Inherited = Map Name [Values]

-- | Get the value of an inherited entity.
getInh :: Name -> MSOS [Values]

-- | Set the value of an inherited entity. The new value is <i>only</i> set
--   for <a>MSOS</a> computation given as a third argument.
withInh :: Name -> [Values] -> MSOS a -> MSOS a

-- | A map storing the values of <i>mutable</i> entities.
type Mutable = Map Name Values

-- | Get the value of some mutable entity.
getMut :: Name -> MSOS Values

-- | Set the value of some mutable entity.
putMut :: Name -> Values -> MSOS ()

-- | a map storing the values of <i>output</i> entities.
type Output = Map Name [Values]

-- | Add new values to a certain output entity.
writeOut :: Name -> [Values] -> MSOS ()

-- | Read the values of a certain output entity. The output is obtained
--   from the <a>MSOS</a> computation given as a second argument.
readOut :: Name -> MSOS a -> MSOS (a, [Values])

-- | a map storing the values of <i>control</i> entities.
type Control = Map Name (Maybe Values)

-- | Signal a value of some control entity.
raiseSignal :: Name -> Values -> MSOS ()

-- | Receive the value of a control entity from a given <a>MSOS</a>
--   computation.
receiveSignals :: [Name] -> MSOS a -> MSOS (a, [Maybe Values])

-- | A map storing the values of <i>input</i> entities.
type Input m = Map Name ([[Values]], Maybe (m Funcons))

-- | Provides <i>extra</i> values to a certain input entity, available to
--   be consumed by the given <a>MSOS</a> computation argument.
withExtraInput :: Name -> [Values] -> MSOS a -> MSOS a

-- | Provides an <i>exact</i> amount of input for some input entity, that
--   is to be <i>completely</i> consumed by the given <a>MSOS</a>
--   computation. If less output is consumed a 'insufficient input
--   consumed' exception is thrown.
withExactInput :: Name -> [Values] -> MSOS a -> MSOS a

-- | Funcon term representation identical to <a>Funcons</a>, but with
--   meta-variables.
data FTerm
TVar :: MetaVar -> FTerm
TName :: Name -> FTerm
TApp :: Name -> [FTerm] -> FTerm
TSeq :: [FTerm] -> FTerm
TSet :: [FTerm] -> FTerm
TMap :: [FTerm] -> FTerm
TBinding :: FTerm -> FTerm -> FTerm
TFuncon :: Funcons -> FTerm
TSortSeq :: FTerm -> SeqSortOp -> FTerm
TSortPower :: FTerm -> FTerm -> FTerm
TSortUnion :: FTerm -> FTerm -> FTerm
TSortInter :: FTerm -> FTerm -> FTerm
TSortComplement :: FTerm -> FTerm
TSortComputes :: FTerm -> FTerm
TSortComputesFrom :: FTerm -> FTerm -> FTerm
TAny :: FTerm

-- | An environment mapping meta-variables to funcon terms. This
--   environment is used by a substitution procedure to transform funcon
--   terms from <a>FTerm</a> representation to <a>Funcons</a>.
type Env = Map MetaVar Levelled

-- | The empty substitution environment. Bindings are inserted by
--   pattern-matching.
emptyEnv :: () => Map k a
fvalues :: [Values] -> [Funcons]

-- | Variant of <a>rewriteTo</a> that applies substitution.
rewriteTermTo :: FTerm -> Env -> Rewrite Rewritten

-- | Variant of <a>stepTo</a> that applies substitution.
stepTermTo :: FTerm -> Env -> MSOS StepRes

-- | Variant of <a>premiseStep</a> that applies substitute and
--   pattern-matching.
premise :: FTerm -> [FPattern] -> Env -> MSOS Env

-- | Variant of <a>withInh</a> that performs substitution.
withInhTerm :: Name -> FTerm -> Env -> MSOS a -> MSOS a

-- | Version of <a>getInh</a> that applies pattern-matching.
getInhPatt :: Name -> [VPattern] -> Env -> MSOS Env

-- | Variant of <a>putMut</a> that applies substitution.
putMutTerm :: Name -> FTerm -> Env -> MSOS ()

-- | Variant of <a>getMut</a> that performs pattern-matching.
getMutPatt :: Name -> VPattern -> Env -> MSOS Env

-- | Variant of <a>writeOut</a> that applies substitution.
writeOutTerm :: Name -> FTerm -> Env -> MSOS ()

-- | Variant of <a>readOut</a> that performs pattern-matching.
readOutPatt :: Name -> VPattern -> MSOS Env -> MSOS Env

-- | Variant of <tt>receiveSignal</tt> that performs pattern-matching.
receiveSignalPatt :: Maybe Values -> Maybe VPattern -> Env -> MSOS Env

-- | Variant of <a>raiseSignal</a> that applies substitution.
raiseTerm :: Name -> FTerm -> Env -> MSOS ()

-- | Variant of <a>consumeInput</a> that matches the given <a>VPattern</a>
--   to the consumed value in the given <a>Env</a>.
matchInput :: Name -> VPattern -> Env -> MSOS Env

-- | Variant of <a>withExtraInput</a> that performs substitution.
withExtraInputTerms :: () => Name -> [FTerm] -> Env -> MSOS a -> MSOS a

-- | Variant of <a>withExactInput</a> that performs substitution.
withExactInputTerms :: () => Name -> [FTerm] -> Env -> MSOS a -> MSOS a
withControlTerm :: Name -> Maybe FTerm -> Env -> MSOS a -> MSOS a

-- | Version of <a>getControl</a> that applies pattern-matching.
getControlPatt :: Name -> Maybe VPattern -> Env -> MSOS Env

-- | Function <a>evalRules</a> 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
--   <i>unsuccessful</i> 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.
--   
--   When no rules are successfully executed to completetion a 'no rule
--   exception' is thrown.
evalRules :: [Rewrite Rewritten] -> [MSOS StepRes] -> Rewrite Rewritten
stepRules :: [IException] -> [MSOS StepRes] -> MSOS StepRes
rewriteRules :: [Rewrite Rewritten] -> Rewrite Rewritten

-- | 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>evalRules</a>. A value is a <i>ground value</i> if it is not a
--   thunk (and not composed out of thunks).
data SideCondition

-- | <i>T1 == T2</i>. Accepted only when <i>T1</i> and <i>T2</i> rewrite to
--   <i>equal</i> ground values.
SCEquality :: FTerm -> FTerm -> SideCondition

-- | <i>T1 =/= T2</i>. Accepted only when <i>T1</i> and <i>T2</i> rewrite
--   to <i>unequal</i> ground values.
SCInequality :: FTerm -> FTerm -> SideCondition

-- | <i>T1 : T2</i>. Accepted only when <i>T2</i> rewrites to a type and
--   <i>T1</i> rewrites to a value of that type.
SCIsInSort :: FTerm -> FTerm -> SideCondition

-- | <i>~(T1 : T2)</i>. Accepted only when <i>T2</i> rewrites to a type and
--   <i>T1</i> rewrites to a value <i>not</i> of that type.
SCNotInSort :: FTerm -> FTerm -> SideCondition

-- | <i>T = P</i>. Accepted only when <i>T</i> rewrites to a value that
--   matches the pattern <i>P</i>. (May produce new bindings in
--   <a>Env</a>).
SCPatternMatch :: FTerm -> [VPattern] -> SideCondition

-- | Executes a side condition, given an <a>Env</a> environment, throwing
--   possible exceptions, and possibly extending the environment.
sideCondition :: SideCondition -> Env -> Rewrite Env

-- | Variant of <a>sideCondition</a> that is lifted into the <a>MSOS</a>
--   monad.
lifted_sideCondition :: SideCondition -> Env -> MSOS Env

-- | Patterns for matching values (<a>Values</a>).
data VPattern
PADT :: Name -> [VPattern] -> VPattern
VPWildCard :: VPattern
VPMetaVar :: MetaVar -> VPattern
VPAnnotated :: VPattern -> FTerm -> VPattern
VPSeqVar :: MetaVar -> SeqSortOp -> VPattern
VPLit :: Values -> VPattern
VPType :: TPattern -> VPattern

-- | Patterns for matching funcon terms (<a>FTerm</a>).
data FPattern
PValue :: VPattern -> FPattern
PMetaVar :: MetaVar -> FPattern
PSeqVar :: MetaVar -> SeqSortOp -> FPattern
PAnnotated :: FPattern -> FTerm -> FPattern
PWildCard :: FPattern
data TPattern
TPWildCard :: TPattern
TPVar :: MetaVar -> TPattern
TPSeqVar :: MetaVar -> SeqSortOp -> TPattern
TPLit :: FTerm -> TPattern
TPComputes :: TPattern -> TPattern
TPComputesFrom :: TPattern -> TPattern -> TPattern
TPADT :: Name -> [TPattern] -> TPattern

-- | Matching values with value patterns patterns. If the list of patterns
--   is a singleton list, then <a>vsMatch</a> attempts to match the values
--   as a tuple against the pattern as well.
vsMatch :: [Values] -> [VPattern] -> Env -> Rewrite Env

-- | Match a sequence of terms to a sequence of patterns.
fsMatch :: [Funcons] -> [FPattern] -> Env -> Rewrite Env
f2vPattern :: FPattern -> VPattern

-- | Variant of <a>vsMatch</a> that is lifted into the <a>MSOS</a> monad.
lifted_vsMatch :: [Values] -> [VPattern] -> Env -> MSOS Env

-- | Variant of <a>fsMatch</a> that is lifted into the <a>MSOS</a> monad.
--   If all given terms are values, then <a>vsMatch</a> is used instead.
lifted_fsMatch :: [Funcons] -> [FPattern] -> Env -> MSOS Env
pat2term :: FPattern -> FTerm
vpat2term :: VPattern -> FTerm
typat2term :: TPattern -> FTerm

-- | Apply as many rewrites as possible to the term bound to the given
--   variable in the meta-environment
envRewrite :: MetaVar -> Env -> Rewrite Env
envStore :: MetaVar -> FTerm -> Env -> Rewrite Env
lifted_envRewrite :: MetaVar -> Env -> MSOS Env
lifted_envStore :: MetaVar -> FTerm -> Env -> MSOS Env

-- | Associates types (Terms) with meta-variables
type TypeEnv = Map MetaVar TyAssoc
data TyAssoc
ElemOf :: FTerm -> TyAssoc
SubTyOf :: FTerm -> TyAssoc

-- | Used for replacing meta-variables <tt>T</tt> in pattern annotations
--   `P:T` with the type to which <tt>T</tt> is bound in some
--   type-environment (if any)
class HasTypeVar a
subsTypeVar :: HasTypeVar a => TypeEnv -> a -> a
subsTypeVarWildcard :: HasTypeVar a => Maybe FTerm -> TypeEnv -> a -> a

-- | Version of <a>subsTypeVar</a> that does not replace the meta-variables
--   in the given set
limitedSubsTypeVar :: HasTypeVar a => Set MetaVar -> TypeEnv -> a -> a

-- | Version of <a>subsTypeVarWildcard</a> that does not replace the
--   meta-variables in the given set
limitedSubsTypeVarWildcard :: HasTypeVar a => Set MetaVar -> Maybe FTerm -> TypeEnv -> a -> a

-- | Parameterisable evaluation function function for types.
rewriteType :: Name -> [Values] -> Rewrite Rewritten

-- | A list of <a>EntityDefault</a>s is used to declare (and possibly
--   initialise) entities.
type EntityDefaults = [EntityDefault]

-- | Default values of entities can be specified for <i>inherited</i> and
--   <i>mutable</i> entities.
data EntityDefault
DefMutable :: Name -> Funcons -> EntityDefault
DefInherited :: Name -> Funcons -> EntityDefault

-- | For the purpose of unit-testing it is advised to notify an interpreter
--   of the existence of control, output and input entities as well.
DefOutput :: Name -> EntityDefault
DefControl :: Name -> EntityDefault
DefInput :: Name -> EntityDefault

-- | The typing environment maps datatype names to their definitions.
type TypeRelation = Map Name DataTypeMembers

-- | A type parameter is of the form X:T where the name of the
--   parameter,<i>X</i>, is optional. When present, <i>X</i> can be used to
--   specify the type of constructors. Variable <i>X</i> be a sequence
--   variable.
type TypeParam = (Maybe MetaVar, Maybe SeqSortOp, FTerm)

-- | A datatype has `zero or more' type parameters and `zero or more'
--   alternatives.
data DataTypeMembers
DataTypeMemberss :: Name -> [TPattern] -> [DataTypeAltt] -> DataTypeMembers

-- | 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
--   <a>Types</a>.
data DataTypeAltt
DataTypeInclusionn :: FTerm -> DataTypeAltt
DataTypeMemberConstructor :: Name -> [FTerm] -> Maybe [TPattern] -> DataTypeAltt

-- | Lookup the definition of a datatype in the typing environment.
typeLookup :: Name -> TypeRelation -> Maybe DataTypeMembers

-- | Unites two <a>TypeRelation</a>s.
typeEnvUnion :: TypeRelation -> TypeRelation -> TypeRelation

-- | Unites a list of <a>TypeRelation</a>s.
typeEnvUnions :: [TypeRelation] -> TypeRelation

-- | Creates a <a>TypeRelation</a> from a list.
typeEnvFromList :: [(Name, DataTypeMembers)] -> TypeRelation

-- | The empty <a>TypeRelation</a>.
emptyTypeRelation :: TypeRelation


-- | This module implements HGMPification of funcons based on Berger et al.
--   (2017) (First-order.)
module Funcons.MetaProgramming

-- | This function implements the ==CT=&gt; relation. Compiling programs to
--   executable funcons terms, removing occurrences of `meta-up`,
--   `meta-down` and `meta-let` and `meta-bound`.
ctRel :: Funcons -> MSOS Funcons

-- | This function implements the ==UL=&gt; relation. Translating a funcon
--   into its meta-representation
ulRel :: Funcons -> MSOS Funcons

-- | This function implements the ==DL=&gt; relation. Translating a
--   meta-representation of a program into the actual program
dlRel :: Values -> Rewrite Funcons
evalRel :: Funcons -> MSOS Values
compile :: FunconLibrary -> TypeRelation -> Funcons -> Funcons -> Funcons
env_entity :: Name
store_entity :: Name
atom_gen_entity :: Name
translationStep :: ([Funcons] -> Funcons) -> StrictFuncon
cmp_MSOSReader :: Interactive m => Map Name EvalFunction -> Map Name DataTypeMembers -> Funcons -> MSOSReader m
cmp_MSOSState :: () => MSOSState m
library :: FunconLibrary
meta_up_ :: [Funcons] -> Funcons
meta_down_ :: [Funcons] -> Funcons
meta_let_ :: [Funcons] -> Funcons
eval_ :: [Funcons] -> Funcons
code_ :: [Funcons] -> Funcons
step_meta_eval :: [Values] -> Rewrite Rewritten
step_code :: [Funcons] -> Rewrite Rewritten
ast_term :: [Funcons] -> Funcons
ast_value :: [Funcons] -> Funcons
type_of_ :: [Funcons] -> Funcons
step_ty_of :: [Values] -> Rewrite Rewritten

module Funcons.Core.Manual
library :: FunconLibrary
library :: FunconLibrary
initialise_generating_ :: Funcons
stepInitialise_generating :: [Funcons] -> Rewrite Rewritten
library :: FunconLibrary
handle_thrown_ :: [Funcons] -> Funcons
stepHandle_thrown :: [Funcons] -> Rewrite Rewritten
stepHandle_return :: [Funcons] -> Rewrite Rewritten
stepElse :: [Funcons] -> Rewrite Rewritten
sets_ :: [Funcons] -> Funcons
set_elements_ :: [Funcons] -> Funcons
set_size_ :: [Funcons] -> Funcons
set_intersect_ :: [Funcons] -> Funcons
set_difference_ :: [Funcons] -> Funcons
some_element_ :: [Funcons] -> Funcons
is_subset_ :: [Funcons] -> Funcons
set_ :: [Funcons] -> Funcons
is_in_set_ :: [Funcons] -> Funcons
set_unite_ :: [Funcons] -> Funcons
set_insert_ :: [Funcons] -> Funcons
element_not_in_ :: [Funcons] -> Funcons
set_empty_ :: [Funcons] -> Funcons
multisets_ :: [Funcons] -> Funcons
multiset_ :: [Funcons] -> Funcons
multiset_elements_ :: [Funcons] -> Funcons
multiset_occurrences_ :: [Funcons] -> Funcons
multiset_insert_ :: [Funcons] -> Funcons
multiset_delete_ :: [Funcons] -> Funcons
is_submultiset_ :: [Funcons] -> Funcons
map_ :: [Funcons] -> Funcons
maps_ :: [Funcons] -> Funcons
map_empty_ :: [Funcons] -> Funcons
is_map_empty_ :: [Funcons] -> Funcons
is_in_domain_ :: [Funcons] -> Funcons
map_insert_ :: [Funcons] -> Funcons
map_delete_ :: [Funcons] -> Funcons

-- | Computes the union over a sequence of maps. If the maps do not have
--   disjoint domains a failure signal is raised.
map_unite_ :: [Funcons] -> Funcons
lookup_ :: [Funcons] -> Funcons
map_lookup_ :: [Funcons] -> Funcons
map_override_ :: [Funcons] -> Funcons
domain_ :: [Funcons] -> Funcons
dom_ :: [Funcons] -> Funcons
map_domain_ :: [Funcons] -> Funcons
map_elements_ :: [Funcons] -> Funcons
is_cyclic_ :: [Funcons] -> Funcons
topological_sort_ :: [Funcons] -> Funcons
datatype_value_ :: [Funcons] -> Funcons
adt_val_ :: [Funcons] -> Funcons
evalADT :: [Funcons] -> Rewrite Rewritten
lazy_adt_val_ :: [Funcons] -> Funcons
evalLazyADT :: [Funcons] -> Rewrite Rewritten
adt_construct_ :: [Funcons] -> Funcons
adtConstruct :: [Values Funcons] -> Rewrite Rewritten
adt_type_construct_ :: [Funcons] -> Funcons
adtTypeConstruct :: [Values Funcons] -> Rewrite Rewritten
adt_constructor_ :: [Funcons] -> Funcons
adtConstructor :: [Values Funcons] -> Rewrite Rewritten
adt_fields_ :: [Funcons] -> Funcons
adtFields :: [Values Funcons] -> Rewrite Rewritten
to_string_ :: [Funcons] -> Funcons
bit_vector_not_ :: [Funcons] -> Funcons
bit_vector_and_ :: [Funcons] -> Funcons
bit_vector_or_ :: [Funcons] -> Funcons
bit_vector_xor_ :: [Funcons] -> Funcons
bit_vector_shift_left_ :: [Funcons] -> Funcons
bit_vector_logical_shift_right_ :: [Funcons] -> Funcons
bit_vector_arithmetical_shift_right_ :: [Funcons] -> Funcons
integer_to_bit_vector_ :: [Funcons] -> Funcons
bit_vector_to_integer_ :: [Funcons] -> Funcons
bit_vector_to_natural_ :: [Funcons] -> Funcons
ints_ :: [Funcons] -> Funcons
integers_ :: [Funcons] -> Funcons
integers_from_ :: [Funcons] -> Funcons
from_ :: [Funcons] -> Funcons
integers_up_to_ :: [Funcons] -> Funcons
up_to_ :: [Funcons] -> Funcons
natural_predecessor_ :: [Funcons] -> Funcons
nat_pred_ :: [Funcons] -> Funcons
natural_successor_ :: [Funcons] -> Funcons
nat_succ_ :: [Funcons] -> Funcons
int_add_ :: [Funcons] -> Funcons
integer_add_ :: [Funcons] -> Funcons
integer_multiply_ :: [Funcons] -> Funcons
integer_divide_ :: [Funcons] -> Funcons
integer_subtract_ :: [Funcons] -> Funcons
integer_power_ :: [Funcons] -> Funcons
integer_power_op :: () => [Values] -> Rewrite a
integer_list_ :: [Funcons] -> Funcons
integer_modulo_ :: [Funcons] -> Funcons
int_mod_ :: [Funcons] -> Funcons
integer_mod_ :: [Funcons] -> Funcons
integer_absolute_value_ :: [Funcons] -> Funcons
decimal_natural_ :: [Funcons] -> Funcons
decimal_ :: [Funcons] -> Funcons
octal_natural_ :: [Funcons] -> Funcons
octal_ :: [Funcons] -> Funcons
binary_natural_ :: [Funcons] -> Funcons
binary_ :: [Funcons] -> Funcons
hexadecimal_natural_ :: [Funcons] -> Funcons
hexadecimal_ :: [Funcons] -> Funcons
is_less_ :: [Funcons] -> Funcons
integer_is_less_ :: [Funcons] -> Funcons
is_less_or_equal_ :: [Funcons] -> Funcons
integer_is_less_or_equal_ :: [Funcons] -> Funcons
is_greater_ :: [Funcons] -> Funcons
integer_is_greater_ :: [Funcons] -> Funcons
is_greater_or_equal_ :: [Funcons] -> Funcons
integer_is_greater_or_equal_ :: [Funcons] -> Funcons
ieee_float_truncate :: [Funcons] -> Funcons
stepIEEE_Float_Truncate :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Add :: [Values] -> Rewrite Rewritten
stepIEEE_Float_Multiply :: [Values] -> Rewrite Rewritten
stepIEEE_Float_Subtract :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Negate :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Divide :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Power :: [Values Funcons] -> Rewrite Rewritten
signed_bits_maximum :: [Funcons] -> Funcons
stepSigned_Bits_Maximum :: [Values Funcons] -> Rewrite Rewritten
signed_bits_minimum :: [Funcons] -> Funcons
stepSigned_Bits_Minimum :: [Values Funcons] -> Rewrite Rewritten
ieee_float_acos :: [Funcons] -> Funcons
stepIEEE_Float_Acos :: [Values] -> Rewrite Rewritten
ieee_float_asin :: [Funcons] -> Funcons
stepIEEE_Float_Asin :: [Values] -> Rewrite Rewritten
ieee_float_atan :: [Funcons] -> Funcons
stepIEEE_Float_Atan :: [Values] -> Rewrite Rewritten
ieee_float_atan2 :: [Funcons] -> Funcons
stepIEEE_Float_Atan2 :: [Values] -> Rewrite Rewritten
ieee_float_cos :: [Funcons] -> Funcons
stepIEEE_Float_Cos :: [Values] -> Rewrite Rewritten
ieee_float_cosh :: [Funcons] -> Funcons
stepIEEE_Float_Cosh :: [Values] -> Rewrite Rewritten
ieee_float_exp :: [Funcons] -> Funcons
stepIEEE_Float_Exp :: [Values] -> Rewrite Rewritten
ieee_float_log :: [Funcons] -> Funcons
stepIEEE_Float_Log :: [Values] -> Rewrite Rewritten
ieee_float_log10 :: [Funcons] -> Funcons
stepIEEE_Float_Log10 :: [Values] -> Rewrite Rewritten
ieee_float_sin :: [Funcons] -> Funcons
stepIEEE_Float_Sin :: [Values] -> Rewrite Rewritten
ieee_float_sinh :: [Funcons] -> Funcons
stepIEEE_Float_Sinh :: [Values] -> Rewrite Rewritten
ieee_float_sqrt :: [Funcons] -> Funcons
stepIEEE_Float_Sqrt :: [Values] -> Rewrite Rewritten
ieee_float_tan :: [Funcons] -> Funcons
stepIEEE_Float_Tan :: [Values] -> Rewrite Rewritten
ieee_float_tanh :: [Funcons] -> Funcons
stepIEEE_Float_Tanh :: [Values] -> Rewrite Rewritten
ieee_float_ceiling :: [Funcons] -> Funcons
stepIEEE_Float_Ceiling :: [Values] -> Rewrite Rewritten
ieee_float_floor :: [Funcons] -> Funcons
stepIEEE_Float_Floor :: [Values] -> Rewrite Rewritten
ieee_float_absolute_value :: [Funcons] -> Funcons
stepIEEE_Float_Absolute_Value :: [Values] -> Rewrite Rewritten
stepIEEE_Float_Remainder :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Is_Less :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Is_Greater :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Is_Less_Or_Equal :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Is_Greater_Or_Equal :: [Values Funcons] -> Rewrite Rewritten
ieee_float_op :: String -> ([Funcons] -> Funcons) -> (Double -> Double -> Double) -> Double -> Values -> [Values] -> Rewrite Rewritten
ieee_float_add :: [Funcons] -> Funcons
ieee_float_add_op :: [Values] -> Rewrite Rewritten
ieee_float_multiply_ :: [Funcons] -> Funcons
ieee_float_multiply :: [Funcons] -> Funcons
ieee_float_multiply_op :: [Values] -> Rewrite Rewritten
ieee_float_divide :: [Funcons] -> Funcons
ieee_float_divide_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_remainder :: [Funcons] -> Funcons
ieee_float_remainder_op :: Values Funcons -> Values Funcons -> Values -> Rewrite Rewritten
ieee_float_negate :: [Funcons] -> Funcons
ieee_float_negate_op :: Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_subtract :: [Funcons] -> Funcons
ieee_float_subtract_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_float_power :: [Funcons] -> Funcons
ieee_float_power_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_is_less :: [Funcons] -> Funcons
ieee_float_is_less_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_is_greater :: [Funcons] -> Funcons
ieee_float_is_greater_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_is_less_or_equal :: [Funcons] -> Funcons
ieee_float_is_less_or_equal_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_is_greater_or_equal :: [Funcons] -> Funcons
ieee_float_is_greater_or_equal_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
atoms_ :: [Funcons] -> Funcons
atom_ :: [Funcons] -> Funcons
bool_ :: Bool -> Funcons
ascii_characters_ :: [Funcons] -> Funcons
ascii_chars_ :: [Funcons] -> Funcons
unicode_characters_ :: [Funcons] -> Funcons
iso_latin_1_characters_ :: [Funcons] -> Funcons
latin_1_chars_ :: [Funcons] -> Funcons
basic_multilingual_plane_characters_ :: [Funcons] -> Funcons
bmp_chars_ :: [Funcons] -> Funcons
unicode_points_ :: [Funcons] -> Funcons
basic_multilingual_plane_points_ :: [Funcons] -> Funcons
ascii_character_ :: [Funcons] -> Funcons
unicode_character_ :: [Funcons] -> Funcons
unicode_char_ :: [Funcons] -> Funcons
characters_ :: [Funcons] -> Funcons
chars_ :: [Funcons] -> Funcons
datatype_values_ :: [Funcons] -> Funcons
ground_values_ :: [Funcons] -> Funcons
ground_vals_ :: [Funcons] -> Funcons
types_ :: [Funcons] -> Funcons
value_types_ :: [Funcons] -> Funcons
empty_type_ :: [Funcons] -> Funcons
computation_types_ :: [Funcons] -> Funcons
stepComputation_Types :: Rewrite Rewritten

module Funcons.Tools

-- | Creates a <i>main</i> function for the default interpreter (no
--   extension). The executable made from this <i>main</i> function
--   receives command line argumenst as explained above
--   (<a>Funcons.Tools</a>).
mkMain :: IO ()

-- | Creates a <i>main</i> function for the interpreter obtained by
--   extending the default library with the funcons in the
--   <a>FunconLibrary</a> argument.
mkMainWithLibrary :: FunconLibrary -> IO ()

-- | Creates a <i>main</i> function for the interpreter obtained by
--   extending the main interpreter with the funcons in the
--   <a>FunconLibrary</a> argument and with default values for entities
--   defined in the <a>EntityDefaults</a> argument.
mkMainWithLibraryEntities :: FunconLibrary -> EntityDefaults -> IO ()

-- | Creates a <i>main</i> function for the interpreter obtained by
--   extending the main interpreter with the funcons in the
--   <a>FunconLibrary</a> argument and with a <a>TypeRelation</a> mapping
--   datatypes to their constructors and type arguments.
mkMainWithLibraryTypes :: FunconLibrary -> TypeRelation -> IO ()

-- | Creates a <i>main</i> function for the interpreter obtained by
--   extending the main interpreter with funcons, <a>EntityDefaults</a> and
--   a <a>TypeRelation</a>.
mkMainWithLibraryEntitiesTypes :: FunconLibrary -> EntityDefaults -> TypeRelation -> IO ()

-- | Creates a <i>main</i> function for the interpreter aware of only the
--   given <a>FunconLibrary</a>, <a>EntityDefaults</a> and
--   <a>TypeRelation</a>.
mkFullyFreshInterpreter :: FunconLibrary -> EntityDefaults -> TypeRelation -> IO ()

-- | Creates a <i>main</i> function for the interpreter aware of only the
--   given <a>FunconLibrary</a>, <a>EntityDefaults</a> and
--   <a>TypeRelation</a>, and the built-in types and operations.
mkFreshInterpreter :: FunconLibrary -> EntityDefaults -> TypeRelation -> IO ()

-- | Creates a main function by passing in a list of command line arguments
--   and an optional initial <a>Funcons</a> to execute. The <a>Funcons</a>
--   argument is optional as one of the command line arguments may refer to
--   an .fct file or .config file that specifies an initial <a>Funcons</a>
--   term. Useful when a translation to <a>Funcons</a> has been implemented
--   in Haskell.
run :: [String] -> Maybe Funcons -> IO ()

-- | Same as <a>run</a>, except receiving additional interpreter extensions
--   as arguments. Useful when a translation to <a>Funcons</a> has been
--   implemented in Haskell as well as <a>Funcons</a>, entities or
--   datatypes specific to the object language. Includes the <a>Core</a>
--   funcons.
runWithExtensions :: FunconLibrary -> EntityDefaults -> TypeRelation -> [String] -> Maybe Funcons -> IO ()

-- | Same as <a>run</a>, except receiving additional interpreter extensions
--   as arguments. Useful when a translation to <a>Funcons</a> has been
--   implemented in Haskell as well as <a>Funcons</a>, entities or
--   datatypes specific to the object language. Does not include the
--   <a>Core</a> funcons.
runWithExtensionsNoCore :: FunconLibrary -> EntityDefaults -> TypeRelation -> [String] -> Maybe Funcons -> IO ()

-- | Same as <a>run</a>, except receiving additional interpreter extensions
--   as arguments. Useful when a translation to <a>Funcons</a> has been
--   implemented in Haskell as well as <a>Funcons</a>, entities or
--   datatypes specific to the object language. Does not include the
--   <a>Core</a> funcons.
runWithExtensionsNoNothing :: FunconLibrary -> EntityDefaults -> TypeRelation -> [String] -> Maybe Funcons -> IO ()

-- | A funcon library maps funcon names to their evaluation functions.
type FunconLibrary = Map Name EvalFunction

-- | Creates an empty <a>FunconLibrary</a>.
libEmpty :: FunconLibrary

-- | Unites two <a>FunconLibrary</a>s.
libUnion :: FunconLibrary -> FunconLibrary -> FunconLibrary

-- | Right-based union of <a>FunconLibrary</a>s
libOverride :: FunconLibrary -> FunconLibrary -> FunconLibrary

-- | Unites a list of <a>FunconLibrary</a>s.
libUnions :: [FunconLibrary] -> FunconLibrary

-- | Right-based union of list of <a>FunconLibrary</a>s
libOverrides :: [FunconLibrary] -> FunconLibrary

-- | Creates a <a>FunconLibrary</a> from a list.
libFromList :: [(Name, EvalFunction)] -> FunconLibrary

-- | The typing environment maps datatype names to their definitions.
type TypeRelation = Map Name DataTypeMembers

-- | A datatype has `zero or more' type parameters and `zero or more'
--   alternatives.
data DataTypeMembers
DataTypeMemberss :: Name -> [TPattern] -> [DataTypeAltt] -> DataTypeMembers

-- | 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
--   <a>Types</a>.
data DataTypeAltt
DataTypeInclusionn :: FTerm -> DataTypeAltt
DataTypeMemberConstructor :: Name -> [FTerm] -> Maybe [TPattern] -> DataTypeAltt

-- | A type parameter is of the form X:T where the name of the
--   parameter,<i>X</i>, is optional. When present, <i>X</i> can be used to
--   specify the type of constructors. Variable <i>X</i> be a sequence
--   variable.
type TypeParam = (Maybe MetaVar, Maybe SeqSortOp, FTerm)

-- | The empty <a>TypeRelation</a>.
emptyTypeRelation :: TypeRelation

-- | Unites two <a>TypeRelation</a>s.
typeEnvUnion :: TypeRelation -> TypeRelation -> TypeRelation

-- | Unites a list of <a>TypeRelation</a>s.
typeEnvUnions :: [TypeRelation] -> TypeRelation

-- | Creates a <a>TypeRelation</a> from a list.
typeEnvFromList :: [(Name, DataTypeMembers)] -> TypeRelation

-- | A list of <a>EntityDefault</a>s is used to declare (and possibly
--   initialise) entities.
type EntityDefaults = [EntityDefault]

-- | Default values of entities can be specified for <i>inherited</i> and
--   <i>mutable</i> entities.
data EntityDefault
DefMutable :: Name -> Funcons -> EntityDefault
DefInherited :: Name -> Funcons -> EntityDefault

-- | For the purpose of unit-testing it is advised to notify an interpreter
--   of the existence of control, output and input entities as well.
DefOutput :: Name -> EntityDefault
DefControl :: Name -> EntityDefault
DefInput :: Name -> EntityDefault

-- | The empty collection of entity defaults.
noEntityDefaults :: [EntityDefault]


-- | This module exports smart constructors for building funcon terms from
--   a large collections of funcons. Module <a>Funcons.EDSL</a> can be used
--   to construct funcons. Module <a>Funcons.Tools</a> provides functions
--   for creating executables.
--   
--   Apologies for the disorganisation of this file, most of its exports
--   exports have been generated.
--   
--   If a funcon is called 'handle-thrown', its smart constructor is called
--   <a>handle_thrown_</a> (hyphens replaced by underscores and an
--   additional underscore at the end). Each smart constructors has a
--   single argument, a list (of type ([<a>Funcons</a>]) representing the
--   actual arguments of a funcon application. For example, the funcon
--   'integer-add' can be applied to an arbitrary number of (integer)
--   arguments, e.g. <a>integer_add_</a> [<a>int_</a> 3, <a>int_</a> 4,
--   <a>int_</a> 5].
module Funcons.Core

-- | Creates an integer <tt>literal</tt>.
int_ :: Int -> Funcons

-- | Creates a natural <tt>literal</tt>.
nat_ :: Int -> Funcons
funcons :: FunconLibrary
entities :: () => [a]
types :: TypeRelation
print_ :: [Funcons] -> Funcons
stepPrint :: [Values] -> Rewrite Rewritten
read_ :: Funcons
stepRead :: Rewrite Rewritten
left_to_right_ :: [Funcons] -> Funcons
l_to_r_ :: [Funcons] -> Funcons
stepLeft_to_right :: [Funcons] -> Rewrite Rewritten
right_to_left_ :: [Funcons] -> Funcons
r_to_l_ :: [Funcons] -> Funcons
stepRight_to_left :: [Funcons] -> Rewrite Rewritten
sequential_ :: [Funcons] -> Funcons
seq_ :: [Funcons] -> Funcons
stepSequential :: [Funcons] -> Rewrite Rewritten
effect_ :: [Funcons] -> Funcons
stepEffect :: [Values] -> Rewrite Rewritten
choice_ :: [Funcons] -> Funcons
stepChoice :: [Funcons] -> Rewrite Rewritten
if_true_else_ :: [Funcons] -> Funcons
if_else_ :: [Funcons] -> Funcons
stepIf_true_else :: [Funcons] -> Rewrite Rewritten
while_true_ :: [Funcons] -> Funcons
while_ :: [Funcons] -> Funcons
stepWhile_true :: [Funcons] -> Rewrite Rewritten
do_while_true_ :: [Funcons] -> Funcons
do_while_ :: [Funcons] -> Funcons
stepDo_while_true :: [Funcons] -> Rewrite Rewritten
interleave_ :: [Funcons] -> Funcons
stepInterleave :: [Values] -> Rewrite Rewritten
signal_ :: Funcons
stepSignal :: Rewrite Rewritten
yield_ :: Funcons
stepYield :: Rewrite Rewritten
yield_on_value_ :: [Funcons] -> Funcons
stepYield_on_value :: [Values] -> Rewrite Rewritten
yield_on_abrupt_ :: [Funcons] -> Funcons
stepYield_on_abrupt :: [Funcons] -> Rewrite Rewritten
yielding_ :: Funcons
stepYielding :: Rewrite Rewritten
locations_ :: Funcons
locs_ :: Funcons
stepLocations :: Rewrite Rewritten
stores_ :: Funcons
stepStores :: Rewrite Rewritten
store_clear_ :: Funcons
stepStore_clear :: Rewrite Rewritten
initialise_storing_ :: [Funcons] -> Funcons
init_storing_ :: [Funcons] -> Funcons
stepInitialise_storing :: [Funcons] -> Rewrite Rewritten
variable_ :: [Funcons] -> Funcons
var_ :: [Funcons] -> Funcons
stepVariable :: [Values] -> Rewrite Rewritten
allocate_variable_ :: [Funcons] -> Funcons
alloc_ :: [Funcons] -> Funcons
stepAllocate_variable :: [Values] -> Rewrite Rewritten
recycle_variables_ :: [Funcons] -> Funcons
recycle_ :: [Funcons] -> Funcons
stepRecycle_variables :: [Values] -> Rewrite Rewritten
initialise_variable_ :: [Funcons] -> Funcons
init_ :: [Funcons] -> Funcons
stepInitialise_variable :: [Values] -> Rewrite Rewritten
allocate_initialised_variable_ :: [Funcons] -> Funcons
alloc_init_ :: [Funcons] -> Funcons
stepAllocate_initialised_variable :: [Funcons] -> Rewrite Rewritten
assign_ :: [Funcons] -> Funcons
stepAssign :: [Values] -> Rewrite Rewritten
assigned_ :: [Funcons] -> Funcons
stepAssigned :: [Values] -> Rewrite Rewritten
current_value_ :: [Funcons] -> Funcons
stepCurrent_value :: [Values] -> Rewrite Rewritten
un_assign_ :: [Funcons] -> Funcons
stepUn_assign :: [Values] -> Rewrite Rewritten
structural_assign_ :: [Funcons] -> Funcons
stepStructural_assign :: [Values] -> Rewrite Rewritten
structural_assigned_ :: [Funcons] -> Funcons
stepStructural_assigned :: [Values] -> Rewrite Rewritten
variables_ :: Funcons
stepVariables :: Rewrite Rewritten
link_ :: [Funcons] -> Funcons
stepLink :: [Values] -> Rewrite Rewritten
initialise_linking_ :: [Funcons] -> Funcons
stepInitialise_linking :: [Funcons] -> Rewrite Rewritten
fresh_link_ :: [Funcons] -> Funcons
stepFresh_link :: [Funcons] -> Rewrite Rewritten
fresh_initialised_link_ :: [Funcons] -> Funcons
fresh_init_link_ :: [Funcons] -> Funcons
stepFresh_initialised_link :: [Funcons] -> Rewrite Rewritten
set_link_ :: [Funcons] -> Funcons
stepSet_link :: [Values] -> Rewrite Rewritten
follow_link_ :: [Funcons] -> Funcons
stepFollow_link :: [Values] -> Rewrite Rewritten
follow_if_link_ :: [Funcons] -> Funcons
stepFollow_if_link :: [Values] -> Rewrite Rewritten
links_ :: Funcons
stepLinks :: Rewrite Rewritten
initialise_giving_ :: [Funcons] -> Funcons
stepInitialise_giving :: [Funcons] -> Rewrite Rewritten
give_ :: [Funcons] -> Funcons
stepGive :: [Funcons] -> Rewrite Rewritten
given_ :: Funcons
stepGiven :: Rewrite Rewritten
no_given_ :: [Funcons] -> Funcons
stepNo_given :: [Funcons] -> Rewrite Rewritten
left_to_right_map_ :: [Funcons] -> Funcons
stepLeft_to_right_map :: [Funcons] -> Rewrite Rewritten
interleave_map_ :: [Funcons] -> Funcons
stepInterleave_map :: [Funcons] -> Rewrite Rewritten
left_to_right_repeat_ :: [Funcons] -> Funcons
stepLeft_to_right_repeat :: [Funcons] -> Rewrite Rewritten
interleave_repeat_ :: [Funcons] -> Funcons
stepInterleave_repeat :: [Funcons] -> Rewrite Rewritten
left_to_right_filter_ :: [Funcons] -> Funcons
stepLeft_to_right_filter :: [Funcons] -> Rewrite Rewritten
interleave_filter_ :: [Funcons] -> Funcons
stepInterleave_filter :: [Funcons] -> Rewrite Rewritten
fold_left_ :: [Funcons] -> Funcons
stepFold_left :: [Funcons] -> Rewrite Rewritten
fold_right_ :: [Funcons] -> Funcons
stepFold_right :: [Funcons] -> Rewrite Rewritten
fresh_atom_ :: Funcons
stepFresh_atom :: Rewrite Rewritten
use_atom_not_in_ :: [Funcons] -> Funcons
stepUse_atom_not_in :: [Values] -> Rewrite Rewritten
environments_ :: Funcons
envs_ :: Funcons
stepEnvironments :: Rewrite Rewritten
identifier_tagged_ :: [Funcons] -> Funcons
id_tagged_ :: [Funcons] -> Funcons
stepIdentifier_tagged :: [Values] -> Rewrite Rewritten
fresh_identifier_ :: Funcons
stepFresh_identifier :: Rewrite Rewritten
initialise_binding_ :: [Funcons] -> Funcons
stepInitialise_binding :: [Funcons] -> Rewrite Rewritten
bind_value_ :: [Funcons] -> Funcons
bind_ :: [Funcons] -> Funcons
stepBind_value :: [Values] -> Rewrite Rewritten
unbind_ :: [Funcons] -> Funcons
stepUnbind :: [Values] -> Rewrite Rewritten
bound_directly_ :: [Funcons] -> Funcons
stepBound_directly :: [Values] -> Rewrite Rewritten
bound_value_ :: [Funcons] -> Funcons
bound_ :: [Funcons] -> Funcons
stepBound_value :: [Values] -> Rewrite Rewritten
closed_ :: [Funcons] -> Funcons
stepClosed :: [Funcons] -> Rewrite Rewritten
scope_ :: [Funcons] -> Funcons
stepScope :: [Funcons] -> Rewrite Rewritten
accumulate_ :: [Funcons] -> Funcons
stepAccumulate :: [Funcons] -> Rewrite Rewritten
collateral_ :: [Funcons] -> Funcons
stepCollateral :: [Values] -> Rewrite Rewritten
bind_recursively_ :: [Funcons] -> Funcons
stepBind_recursively :: [Funcons] -> Rewrite Rewritten
recursive_ :: [Funcons] -> Funcons
stepRecursive :: [Funcons] -> Rewrite Rewritten
re_close_ :: [Funcons] -> Funcons
stepRe_close :: [Funcons] -> Rewrite Rewritten
bind_to_forward_links_ :: [Funcons] -> Funcons
stepBind_to_forward_links :: [Values] -> Rewrite Rewritten
set_forward_links_ :: [Funcons] -> Funcons
stepSet_forward_links :: [Values] -> Rewrite Rewritten
identifiers_ :: Funcons
stepIdentifiers :: Rewrite Rewritten
finalise_abrupting_ :: [Funcons] -> Funcons
stepFinalise_abrupting :: [Funcons] -> Rewrite Rewritten
abrupt_ :: [Funcons] -> Funcons
stepAbrupt :: [Values] -> Rewrite Rewritten
handle_abrupt_ :: [Funcons] -> Funcons
stepHandle_abrupt :: [Funcons] -> Rewrite Rewritten
finally_ :: [Funcons] -> Funcons
stepFinally :: [Funcons] -> Rewrite Rewritten
returned_ :: [Funcons] -> Funcons
stepReturned :: [Values] -> Rewrite Rewritten
finalise_returning_ :: [Funcons] -> Funcons
stepFinalise_returning :: [Funcons] -> Rewrite Rewritten
return_ :: [Funcons] -> Funcons
stepReturn :: [Values] -> Rewrite Rewritten
handle_return_ :: [Funcons] -> Funcons
stepHandle_return :: [Funcons] -> Rewrite Rewritten
returning_ :: Funcons
stepReturning :: Rewrite Rewritten
continuation_ :: [Funcons] -> Funcons
stepContinuation :: [Values] -> Rewrite Rewritten
hole_ :: Funcons
stepHole :: Rewrite Rewritten
resume_continuation_ :: [Funcons] -> Funcons
stepResume_continuation :: [Values] -> Rewrite Rewritten
control_ :: [Funcons] -> Funcons
stepControl :: [Values] -> Rewrite Rewritten
delimit_current_continuation_ :: [Funcons] -> Funcons
delimit_cc_ :: [Funcons] -> Funcons
stepDelimit_current_continuation :: [Funcons] -> Rewrite Rewritten
continuations_ :: [Funcons] -> Funcons
stepContinuations :: [Values] -> Rewrite Rewritten
thrown_ :: [Funcons] -> Funcons
stepThrown :: [Values] -> Rewrite Rewritten
finalise_throwing_ :: [Funcons] -> Funcons
stepFinalise_throwing :: [Funcons] -> Rewrite Rewritten
throw_ :: [Funcons] -> Funcons
stepThrow :: [Values] -> Rewrite Rewritten
handle_thrown_ :: [Funcons] -> Funcons
stepHandle_thrown :: [Funcons] -> Rewrite Rewritten
handle_recursively_ :: [Funcons] -> Funcons
stepHandle_recursively :: [Funcons] -> Rewrite Rewritten
catch_else_throw_ :: [Funcons] -> Funcons
stepCatch_else_throw :: [Funcons] -> Rewrite Rewritten
throwing_ :: Funcons
stepThrowing :: Rewrite Rewritten
failed_ :: Funcons
stepFailed :: Rewrite Rewritten
finalise_failing_ :: [Funcons] -> Funcons
stepFinalise_failing :: [Funcons] -> Rewrite Rewritten
fail_ :: Funcons
stepFail :: Rewrite Rewritten
else_ :: [Funcons] -> Funcons
stepElse :: [Funcons] -> Rewrite Rewritten
else_choice_ :: [Funcons] -> Funcons
stepElse_choice :: [Funcons] -> Rewrite Rewritten
check_true_ :: [Funcons] -> Funcons
check_ :: [Funcons] -> Funcons
stepCheck_true :: [Values] -> Rewrite Rewritten
checked_ :: [Funcons] -> Funcons
stepChecked :: [Values] -> Rewrite Rewritten
failing_ :: Funcons
stepFailing :: Rewrite Rewritten
stuck_ :: Funcons
stepStuck :: () => Rewrite a
broken_ :: Funcons
stepBroken :: Rewrite Rewritten
finalise_breaking_ :: [Funcons] -> Funcons
stepFinalise_breaking :: [Funcons] -> Rewrite Rewritten
break_ :: Funcons
stepBreak :: Rewrite Rewritten
handle_break_ :: [Funcons] -> Funcons
stepHandle_break :: [Funcons] -> Rewrite Rewritten
breaking_ :: Funcons
stepBreaking :: Rewrite Rewritten
continued_ :: Funcons
stepContinued :: Rewrite Rewritten
finalise_continuing_ :: [Funcons] -> Funcons
stepFinalise_continuing :: [Funcons] -> Rewrite Rewritten
continue_ :: Funcons
stepContinue :: Rewrite Rewritten
handle_continue_ :: [Funcons] -> Funcons
stepHandle_continue :: [Funcons] -> Rewrite Rewritten
continuing_ :: Funcons
stepContinuing :: Rewrite Rewritten
tags_ :: Funcons
stepTags :: Rewrite Rewritten
ast_value_ :: [Funcons] -> Funcons
stepAst_value :: [Values] -> Rewrite Rewritten
ast_term_ :: [Funcons] -> Funcons
stepAst_term :: [Values] -> Rewrite Rewritten
asts_ :: Funcons
stepAsts :: Rewrite Rewritten
record_ :: [Funcons] -> Funcons
stepRecord :: [Values] -> Rewrite Rewritten
record_map_ :: [Funcons] -> Funcons
stepRecord_map :: [Values] -> Rewrite Rewritten
record_select_ :: [Funcons] -> Funcons
stepRecord_select :: [Values] -> Rewrite Rewritten
records_ :: [Funcons] -> Funcons
stepRecords :: [Values] -> Rewrite Rewritten
strings_ :: Funcons
stepStrings :: Rewrite Rewritten
string_ :: [Funcons] -> Funcons
stepString :: [Values] -> Rewrite Rewritten
string_append_ :: [Funcons] -> Funcons
stepString_append :: [Values] -> Rewrite Rewritten
reference_ :: [Funcons] -> Funcons
stepReference :: [Values] -> Rewrite Rewritten
pointer_null_ :: Funcons
stepPointer_null :: Rewrite Rewritten
dereference_ :: [Funcons] -> Funcons
stepDereference :: [Values] -> Rewrite Rewritten
references_ :: [Funcons] -> Funcons
stepReferences :: [Values] -> Rewrite Rewritten
pointers_ :: [Funcons] -> Funcons
stepPointers :: [Values] -> Rewrite Rewritten
directed_graphs_ :: [Funcons] -> Funcons
stepDirected_graphs :: [Funcons] -> Rewrite Rewritten
vector_ :: [Funcons] -> Funcons
stepVector :: [Values] -> Rewrite Rewritten
vector_elements_ :: [Funcons] -> Funcons
stepVector_elements :: [Values] -> Rewrite Rewritten
vectors_ :: [Funcons] -> Funcons
stepVectors :: [Values] -> Rewrite Rewritten
variant_ :: [Funcons] -> Funcons
stepVariant :: [Values] -> Rewrite Rewritten
variant_id_ :: [Funcons] -> Funcons
stepVariant_id :: [Values] -> Rewrite Rewritten
variant_value_ :: [Funcons] -> Funcons
stepVariant_value :: [Values] -> Rewrite Rewritten
variants_ :: [Funcons] -> Funcons
stepVariants :: [Values] -> Rewrite Rewritten
tree_ :: [Funcons] -> Funcons
stepTree :: [Values] -> Rewrite Rewritten
tree_root_value_ :: [Funcons] -> Funcons
stepTree_root_value :: [Values] -> Rewrite Rewritten
tree_branch_sequence_ :: [Funcons] -> Funcons
stepTree_branch_sequence :: [Values] -> Rewrite Rewritten
single_branching_sequence_ :: [Funcons] -> Funcons
stepSingle_branching_sequence :: [Values] -> Rewrite Rewritten
forest_root_value_sequence_ :: [Funcons] -> Funcons
stepForest_root_value_sequence :: [Values] -> Rewrite Rewritten
forest_branch_sequence_ :: [Funcons] -> Funcons
stepForest_branch_sequence :: [Values] -> Rewrite Rewritten
forest_value_sequence_ :: [Funcons] -> Funcons
stepForest_value_sequence :: [Values] -> Rewrite Rewritten
trees_ :: [Funcons] -> Funcons
stepTrees :: [Values] -> Rewrite Rewritten
length_ :: [Funcons] -> Funcons
stepLength :: [Values] -> Rewrite Rewritten
is_in_ :: [Funcons] -> Funcons
stepIs_in :: [Values] -> Rewrite Rewritten
index_ :: [Funcons] -> Funcons
stepIndex :: [Values] -> Rewrite Rewritten
first_ :: [Funcons] -> Funcons
stepFirst :: [Values] -> Rewrite Rewritten
second_ :: [Funcons] -> Funcons
stepSecond :: [Values] -> Rewrite Rewritten
third_ :: [Funcons] -> Funcons
stepThird :: [Values] -> Rewrite Rewritten
first_n_ :: [Funcons] -> Funcons
stepFirst_n :: [Values] -> Rewrite Rewritten
drop_first_n_ :: [Funcons] -> Funcons
stepDrop_first_n :: [Values] -> Rewrite Rewritten
reverse_ :: [Funcons] -> Funcons
stepReverse :: [Values] -> Rewrite Rewritten
n_of_ :: [Funcons] -> Funcons
stepN_of :: [Values] -> Rewrite Rewritten
intersperse_ :: [Funcons] -> Funcons
stepIntersperse :: [Values] -> Rewrite Rewritten
list_ :: [Funcons] -> Funcons
stepList :: [Values] -> Rewrite Rewritten
list_elements_ :: [Funcons] -> Funcons
stepList_elements :: [Values] -> Rewrite Rewritten
list_nil_ :: Funcons
nil_ :: Funcons
stepList_nil :: Rewrite Rewritten
list_cons_ :: [Funcons] -> Funcons
cons_ :: [Funcons] -> Funcons
stepList_cons :: [Values] -> Rewrite Rewritten
list_head_ :: [Funcons] -> Funcons
head_ :: [Funcons] -> Funcons
stepList_head :: [Values] -> Rewrite Rewritten
list_tail_ :: [Funcons] -> Funcons
tail_ :: [Funcons] -> Funcons
stepList_tail :: [Values] -> Rewrite Rewritten
list_length_ :: [Funcons] -> Funcons
stepList_length :: [Values] -> Rewrite Rewritten
list_append_ :: [Funcons] -> Funcons
stepList_append :: [Values] -> Rewrite Rewritten
lists_ :: [Funcons] -> Funcons
stepLists :: [Values] -> Rewrite Rewritten
class_ :: [Funcons] -> Funcons
stepClass :: [Values] -> Rewrite Rewritten
class_instantiator_ :: [Funcons] -> Funcons
stepClass_instantiator :: [Values] -> Rewrite Rewritten
class_feature_map_ :: [Funcons] -> Funcons
stepClass_feature_map :: [Values] -> Rewrite Rewritten
class_superclass_name_sequence_ :: [Funcons] -> Funcons
stepClass_superclass_name_sequence :: [Values] -> Rewrite Rewritten
class_name_tree_ :: [Funcons] -> Funcons
stepClass_name_tree :: [Values] -> Rewrite Rewritten
is_subclass_name_ :: [Funcons] -> Funcons
stepIs_subclass_name :: [Values] -> Rewrite Rewritten
class_name_single_inheritance_feature_map_ :: [Funcons] -> Funcons
stepClass_name_single_inheritance_feature_map :: [Values] -> Rewrite Rewritten
classes_ :: Funcons
stepClasses :: Rewrite Rewritten
object_ :: [Funcons] -> Funcons
stepObject :: [Values] -> Rewrite Rewritten
object_identity_ :: [Funcons] -> Funcons
stepObject_identity :: [Values] -> Rewrite Rewritten
object_class_name_ :: [Funcons] -> Funcons
stepObject_class_name :: [Values] -> Rewrite Rewritten
object_feature_map_ :: [Funcons] -> Funcons
stepObject_feature_map :: [Values] -> Rewrite Rewritten
object_subobject_sequence_ :: [Funcons] -> Funcons
stepObject_subobject_sequence :: [Values] -> Rewrite Rewritten
object_tree_ :: [Funcons] -> Funcons
stepObject_tree :: [Values] -> Rewrite Rewritten
object_single_inheritance_feature_map_ :: [Funcons] -> Funcons
stepObject_single_inheritance_feature_map :: [Values] -> Rewrite Rewritten
objects_ :: Funcons
stepObjects :: Rewrite Rewritten
datatype_value_id_ :: [Funcons] -> Funcons
stepDatatype_value_id :: [Values] -> Rewrite Rewritten
datatype_value_elements_ :: [Funcons] -> Funcons
stepDatatype_value_elements :: [Values] -> Rewrite Rewritten
tuple_ :: [Funcons] -> Funcons
stepTuple :: [Values] -> Rewrite Rewritten
tuple_elements_ :: [Funcons] -> Funcons
stepTuple_elements :: [Values] -> Rewrite Rewritten
tuple_zip_ :: [Funcons] -> Funcons
stepTuple_zip :: [Values] -> Rewrite Rewritten
tuples_ :: [Funcons] -> Funcons
stepTuples :: [Values] -> Rewrite Rewritten
bits_ :: Funcons
stepBits :: Rewrite Rewritten
bit_vector_ :: [Funcons] -> Funcons
stepBit_vector :: [Values] -> Rewrite Rewritten
bytes_ :: Funcons
octets_ :: Funcons
stepBytes :: Rewrite Rewritten
unsigned_bit_vector_maximum_ :: [Funcons] -> Funcons
stepUnsigned_bit_vector_maximum :: [Values] -> Rewrite Rewritten
signed_bit_vector_maximum_ :: [Funcons] -> Funcons
stepSigned_bit_vector_maximum :: [Values] -> Rewrite Rewritten
signed_bit_vector_minimum_ :: [Funcons] -> Funcons
stepSigned_bit_vector_minimum :: [Values] -> Rewrite Rewritten
is_in_signed_bit_vector_ :: [Funcons] -> Funcons
stepIs_in_signed_bit_vector :: [Values] -> Rewrite Rewritten
is_in_unsigned_bit_vector_ :: [Funcons] -> Funcons
stepIs_in_unsigned_bit_vector :: [Values] -> Rewrite Rewritten
bit_vectors_ :: [Funcons] -> Funcons
stepBit_vectors :: [Values] -> Rewrite Rewritten
binary32_ :: Funcons
stepBinary32 :: Rewrite Rewritten
binary64_ :: Funcons
stepBinary64 :: Rewrite Rewritten
binary128_ :: Funcons
stepBinary128 :: Rewrite Rewritten
decimal64_ :: Funcons
stepDecimal64 :: Rewrite Rewritten
decimal128_ :: Funcons
stepDecimal128 :: Rewrite Rewritten
float_formats_ :: Funcons
stepFloat_formats :: Rewrite Rewritten
true_ :: Funcons
stepTrue :: Rewrite Rewritten
false_ :: Funcons
stepFalse :: Rewrite Rewritten
not_ :: [Funcons] -> Funcons
stepNot :: [Values] -> Rewrite Rewritten
implies_ :: [Funcons] -> Funcons
stepImplies :: [Values] -> Rewrite Rewritten
and_ :: [Funcons] -> Funcons
stepAnd :: [Values] -> Rewrite Rewritten
or_ :: [Funcons] -> Funcons
stepOr :: [Values] -> Rewrite Rewritten
exclusive_or_ :: [Funcons] -> Funcons
xor_ :: [Funcons] -> Funcons
stepExclusive_or :: [Values] -> Rewrite Rewritten
booleans_ :: Funcons
stepBooleans :: Rewrite Rewritten
null_value_ :: Funcons
null_ :: Funcons
stepNull_value :: Rewrite Rewritten
null_type_ :: Funcons
stepNull_type :: Rewrite Rewritten
unicode_point_ :: [Funcons] -> Funcons
unicode_ :: [Funcons] -> Funcons
stepUnicode_point :: [Values] -> Rewrite Rewritten
iso_latin_1_points_ :: Funcons
stepIso_latin_1_points :: Rewrite Rewritten
ascii_points_ :: Funcons
stepAscii_points :: Rewrite Rewritten
ascii_character_ :: [Funcons] -> Funcons
ascii_char_ :: [Funcons] -> Funcons
stepAscii_character :: [Values] -> Rewrite Rewritten
backspace_ :: Funcons
stepBackspace :: Rewrite Rewritten
horizontal_tab_ :: Funcons
stepHorizontal_tab :: Rewrite Rewritten
line_feed_ :: Funcons
stepLine_feed :: Rewrite Rewritten
form_feed_ :: Funcons
stepForm_feed :: Rewrite Rewritten
carriage_return_ :: Funcons
stepCarriage_return :: Rewrite Rewritten
double_quote_ :: Funcons
stepDouble_quote :: Rewrite Rewritten
single_quote_ :: Funcons
stepSingle_quote :: Rewrite Rewritten
backslash_ :: Funcons
stepBackslash :: Rewrite Rewritten
bounded_integers_ :: [Funcons] -> Funcons
bounded_ints_ :: [Funcons] -> Funcons
stepBounded_integers :: [Values] -> Rewrite Rewritten
positive_integers_ :: Funcons
pos_ints_ :: Funcons
stepPositive_integers :: Rewrite Rewritten
negative_integers_ :: Funcons
neg_ints_ :: Funcons
stepNegative_integers :: Rewrite Rewritten
natural_numbers_ :: Funcons
nats_ :: Funcons
stepNatural_numbers :: Rewrite Rewritten
integer_negate_ :: [Funcons] -> Funcons
int_neg_ :: [Funcons] -> Funcons
stepInteger_negate :: [Values] -> Rewrite Rewritten
integer_sequence_ :: [Funcons] -> Funcons
stepInteger_sequence :: [Values] -> Rewrite Rewritten
is_in_type_ :: [Funcons] -> Funcons
is_ :: [Funcons] -> Funcons
stepIs_in_type :: [Values] -> Rewrite Rewritten
is_value_ :: [Funcons] -> Funcons
is_val_ :: [Funcons] -> Funcons
stepIs_value :: [Values] -> Rewrite Rewritten
when_true_ :: [Funcons] -> Funcons
when_ :: [Funcons] -> Funcons
stepWhen_true :: [Values] -> Rewrite Rewritten
cast_to_type_ :: [Funcons] -> Funcons
cast_ :: [Funcons] -> Funcons
stepCast_to_type :: [Values] -> Rewrite Rewritten
is_equal_ :: [Funcons] -> Funcons
is_eq_ :: [Funcons] -> Funcons
stepIs_equal :: [Values] -> Rewrite Rewritten
thunk_ :: [Funcons] -> Funcons
stepThunk :: [Values] -> Rewrite Rewritten
force_ :: [Funcons] -> Funcons
stepForce :: [Values] -> Rewrite Rewritten
thunks_ :: [Funcons] -> Funcons
stepThunks :: [Values] -> Rewrite Rewritten
pattern_ :: [Funcons] -> Funcons
stepPattern :: [Values] -> Rewrite Rewritten
pattern_any_ :: Funcons
stepPattern_any :: Rewrite Rewritten
pattern_bind_ :: [Funcons] -> Funcons
stepPattern_bind :: [Values] -> Rewrite Rewritten
pattern_type_ :: [Funcons] -> Funcons
stepPattern_type :: [Funcons] -> Rewrite Rewritten
pattern_else_ :: [Funcons] -> Funcons
stepPattern_else :: [Values] -> Rewrite Rewritten
pattern_unite_ :: [Funcons] -> Funcons
stepPattern_unite :: [Values] -> Rewrite Rewritten
match_ :: [Funcons] -> Funcons
stepMatch :: [Values] -> Rewrite Rewritten
match_loosely_ :: [Funcons] -> Funcons
stepMatch_loosely :: [Values] -> Rewrite Rewritten
case_match_ :: [Funcons] -> Funcons
stepCase_match :: [Funcons] -> Rewrite Rewritten
case_match_loosely_ :: [Funcons] -> Funcons
stepCase_match_loosely :: [Funcons] -> Rewrite Rewritten
case_variant_value_ :: [Funcons] -> Funcons
stepCase_variant_value :: [Values] -> Rewrite Rewritten
patterns_ :: Funcons
stepPatterns :: Rewrite Rewritten
function_ :: [Funcons] -> Funcons
stepFunction :: [Values] -> Rewrite Rewritten
apply_ :: [Funcons] -> Funcons
stepApply :: [Values] -> Rewrite Rewritten
supply_ :: [Funcons] -> Funcons
stepSupply :: [Values] -> Rewrite Rewritten
compose_ :: [Funcons] -> Funcons
stepCompose :: [Values] -> Rewrite Rewritten
uncurry_ :: [Funcons] -> Funcons
stepUncurry :: [Values] -> Rewrite Rewritten
curry_ :: [Funcons] -> Funcons
stepCurry :: [Values] -> Rewrite Rewritten
partial_apply_ :: [Funcons] -> Funcons
stepPartial_apply :: [Values] -> Rewrite Rewritten
functions_ :: [Funcons] -> Funcons
stepFunctions :: [Values] -> Rewrite Rewritten
abstraction_ :: [Funcons] -> Funcons
stepAbstraction :: [Funcons] -> Rewrite Rewritten
closure_ :: [Funcons] -> Funcons
stepClosure :: [Funcons] -> Rewrite Rewritten
enact_ :: [Funcons] -> Funcons
stepEnact :: [Values] -> Rewrite Rewritten
abstractions_ :: [Funcons] -> Funcons
stepAbstractions :: [Values] -> Rewrite Rewritten
datatype_values_ :: [Funcons] -> Funcons
ground_values_ :: [Funcons] -> Funcons
ground_vals_ :: [Funcons] -> Funcons
types_ :: [Funcons] -> Funcons
value_types_ :: [Funcons] -> Funcons
empty_type_ :: [Funcons] -> Funcons
ascii_characters_ :: [Funcons] -> Funcons
ascii_chars_ :: [Funcons] -> Funcons
unicode_characters_ :: [Funcons] -> Funcons
iso_latin_1_characters_ :: [Funcons] -> Funcons
latin_1_chars_ :: [Funcons] -> Funcons
basic_multilingual_plane_characters_ :: [Funcons] -> Funcons
bmp_chars_ :: [Funcons] -> Funcons
unicode_points_ :: [Funcons] -> Funcons
basic_multilingual_plane_points_ :: [Funcons] -> Funcons
unicode_character_ :: [Funcons] -> Funcons
unicode_char_ :: [Funcons] -> Funcons
characters_ :: [Funcons] -> Funcons
chars_ :: [Funcons] -> Funcons
bool_ :: Bool -> Funcons
ints_ :: [Funcons] -> Funcons
integers_ :: [Funcons] -> Funcons
integers_from_ :: [Funcons] -> Funcons
from_ :: [Funcons] -> Funcons
integers_up_to_ :: [Funcons] -> Funcons
up_to_ :: [Funcons] -> Funcons
natural_predecessor_ :: [Funcons] -> Funcons
nat_pred_ :: [Funcons] -> Funcons
natural_successor_ :: [Funcons] -> Funcons
nat_succ_ :: [Funcons] -> Funcons
int_add_ :: [Funcons] -> Funcons
integer_add_ :: [Funcons] -> Funcons
integer_multiply_ :: [Funcons] -> Funcons
integer_divide_ :: [Funcons] -> Funcons
integer_subtract_ :: [Funcons] -> Funcons
integer_power_ :: [Funcons] -> Funcons
integer_power_op :: () => [Values] -> Rewrite a
integer_list_ :: [Funcons] -> Funcons
integer_modulo_ :: [Funcons] -> Funcons
int_mod_ :: [Funcons] -> Funcons
integer_mod_ :: [Funcons] -> Funcons
integer_absolute_value_ :: [Funcons] -> Funcons
decimal_natural_ :: [Funcons] -> Funcons
decimal_ :: [Funcons] -> Funcons
octal_natural_ :: [Funcons] -> Funcons
octal_ :: [Funcons] -> Funcons
binary_natural_ :: [Funcons] -> Funcons
binary_ :: [Funcons] -> Funcons
hexadecimal_natural_ :: [Funcons] -> Funcons
hexadecimal_ :: [Funcons] -> Funcons
is_less_ :: [Funcons] -> Funcons
integer_is_less_ :: [Funcons] -> Funcons
is_less_or_equal_ :: [Funcons] -> Funcons
integer_is_less_or_equal_ :: [Funcons] -> Funcons
is_greater_ :: [Funcons] -> Funcons
integer_is_greater_ :: [Funcons] -> Funcons
is_greater_or_equal_ :: [Funcons] -> Funcons
integer_is_greater_or_equal_ :: [Funcons] -> Funcons
ieee_float_truncate :: [Funcons] -> Funcons
stepIEEE_Float_Truncate :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Add :: [Values] -> Rewrite Rewritten
stepIEEE_Float_Multiply :: [Values] -> Rewrite Rewritten
stepIEEE_Float_Subtract :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Negate :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Divide :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Power :: [Values Funcons] -> Rewrite Rewritten
signed_bits_maximum :: [Funcons] -> Funcons
stepSigned_Bits_Maximum :: [Values Funcons] -> Rewrite Rewritten
signed_bits_minimum :: [Funcons] -> Funcons
stepSigned_Bits_Minimum :: [Values Funcons] -> Rewrite Rewritten
ieee_float_acos :: [Funcons] -> Funcons
stepIEEE_Float_Acos :: [Values] -> Rewrite Rewritten
ieee_float_asin :: [Funcons] -> Funcons
stepIEEE_Float_Asin :: [Values] -> Rewrite Rewritten
ieee_float_atan :: [Funcons] -> Funcons
stepIEEE_Float_Atan :: [Values] -> Rewrite Rewritten
ieee_float_atan2 :: [Funcons] -> Funcons
stepIEEE_Float_Atan2 :: [Values] -> Rewrite Rewritten
ieee_float_cos :: [Funcons] -> Funcons
stepIEEE_Float_Cos :: [Values] -> Rewrite Rewritten
ieee_float_cosh :: [Funcons] -> Funcons
stepIEEE_Float_Cosh :: [Values] -> Rewrite Rewritten
ieee_float_exp :: [Funcons] -> Funcons
stepIEEE_Float_Exp :: [Values] -> Rewrite Rewritten
ieee_float_log :: [Funcons] -> Funcons
stepIEEE_Float_Log :: [Values] -> Rewrite Rewritten
ieee_float_log10 :: [Funcons] -> Funcons
stepIEEE_Float_Log10 :: [Values] -> Rewrite Rewritten
ieee_float_sin :: [Funcons] -> Funcons
stepIEEE_Float_Sin :: [Values] -> Rewrite Rewritten
ieee_float_sinh :: [Funcons] -> Funcons
stepIEEE_Float_Sinh :: [Values] -> Rewrite Rewritten
ieee_float_sqrt :: [Funcons] -> Funcons
stepIEEE_Float_Sqrt :: [Values] -> Rewrite Rewritten
ieee_float_tan :: [Funcons] -> Funcons
stepIEEE_Float_Tan :: [Values] -> Rewrite Rewritten
ieee_float_tanh :: [Funcons] -> Funcons
stepIEEE_Float_Tanh :: [Values] -> Rewrite Rewritten
ieee_float_ceiling :: [Funcons] -> Funcons
stepIEEE_Float_Ceiling :: [Values] -> Rewrite Rewritten
ieee_float_floor :: [Funcons] -> Funcons
stepIEEE_Float_Floor :: [Values] -> Rewrite Rewritten
ieee_float_absolute_value :: [Funcons] -> Funcons
stepIEEE_Float_Absolute_Value :: [Values] -> Rewrite Rewritten
stepIEEE_Float_Remainder :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Is_Less :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Is_Greater :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Is_Less_Or_Equal :: [Values Funcons] -> Rewrite Rewritten
stepIEEE_Float_Is_Greater_Or_Equal :: [Values Funcons] -> Rewrite Rewritten
ieee_float_op :: String -> ([Funcons] -> Funcons) -> (Double -> Double -> Double) -> Double -> Values -> [Values] -> Rewrite Rewritten
ieee_float_add :: [Funcons] -> Funcons
ieee_float_add_op :: [Values] -> Rewrite Rewritten
ieee_float_multiply_ :: [Funcons] -> Funcons
ieee_float_multiply :: [Funcons] -> Funcons
ieee_float_multiply_op :: [Values] -> Rewrite Rewritten
ieee_float_divide :: [Funcons] -> Funcons
ieee_float_divide_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_remainder :: [Funcons] -> Funcons
ieee_float_remainder_op :: Values Funcons -> Values Funcons -> Values -> Rewrite Rewritten
ieee_float_negate :: [Funcons] -> Funcons
ieee_float_negate_op :: Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_subtract :: [Funcons] -> Funcons
ieee_float_subtract_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_float_power :: [Funcons] -> Funcons
ieee_float_power_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_is_less :: [Funcons] -> Funcons
ieee_float_is_less_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_is_greater :: [Funcons] -> Funcons
ieee_float_is_greater_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_is_less_or_equal :: [Funcons] -> Funcons
ieee_float_is_less_or_equal_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
ieee_float_is_greater_or_equal :: [Funcons] -> Funcons
ieee_float_is_greater_or_equal_op :: Values Funcons -> Values Funcons -> Values Funcons -> Rewrite Rewritten
bit_vector_not_ :: [Funcons] -> Funcons
bit_vector_and_ :: [Funcons] -> Funcons
bit_vector_or_ :: [Funcons] -> Funcons
bit_vector_xor_ :: [Funcons] -> Funcons
bit_vector_shift_left_ :: [Funcons] -> Funcons
bit_vector_logical_shift_right_ :: [Funcons] -> Funcons
bit_vector_arithmetical_shift_right_ :: [Funcons] -> Funcons
integer_to_bit_vector_ :: [Funcons] -> Funcons
bit_vector_to_integer_ :: [Funcons] -> Funcons
bit_vector_to_natural_ :: [Funcons] -> Funcons
atoms_ :: [Funcons] -> Funcons
atom_ :: [Funcons] -> Funcons
sets_ :: [Funcons] -> Funcons
set_elements_ :: [Funcons] -> Funcons
set_size_ :: [Funcons] -> Funcons
set_intersect_ :: [Funcons] -> Funcons
set_difference_ :: [Funcons] -> Funcons
some_element_ :: [Funcons] -> Funcons
is_subset_ :: [Funcons] -> Funcons
set_ :: [Funcons] -> Funcons
is_in_set_ :: [Funcons] -> Funcons
set_unite_ :: [Funcons] -> Funcons
set_insert_ :: [Funcons] -> Funcons
element_not_in_ :: [Funcons] -> Funcons
set_empty_ :: [Funcons] -> Funcons
multisets_ :: [Funcons] -> Funcons
multiset_ :: [Funcons] -> Funcons
multiset_elements_ :: [Funcons] -> Funcons
multiset_occurrences_ :: [Funcons] -> Funcons
multiset_insert_ :: [Funcons] -> Funcons
multiset_delete_ :: [Funcons] -> Funcons
is_submultiset_ :: [Funcons] -> Funcons
map_ :: [Funcons] -> Funcons
maps_ :: [Funcons] -> Funcons
map_empty_ :: [Funcons] -> Funcons
is_map_empty_ :: [Funcons] -> Funcons
is_in_domain_ :: [Funcons] -> Funcons
map_insert_ :: [Funcons] -> Funcons
map_delete_ :: [Funcons] -> Funcons

-- | Computes the union over a sequence of maps. If the maps do not have
--   disjoint domains a failure signal is raised.
map_unite_ :: [Funcons] -> Funcons
lookup_ :: [Funcons] -> Funcons
map_lookup_ :: [Funcons] -> Funcons
map_override_ :: [Funcons] -> Funcons
domain_ :: [Funcons] -> Funcons
dom_ :: [Funcons] -> Funcons
map_domain_ :: [Funcons] -> Funcons
map_elements_ :: [Funcons] -> Funcons
is_cyclic_ :: [Funcons] -> Funcons
topological_sort_ :: [Funcons] -> Funcons
datatype_value_ :: [Funcons] -> Funcons
adt_val_ :: [Funcons] -> Funcons
evalADT :: [Funcons] -> Rewrite Rewritten
lazy_adt_val_ :: [Funcons] -> Funcons
evalLazyADT :: [Funcons] -> Rewrite Rewritten
adt_construct_ :: [Funcons] -> Funcons
adtConstruct :: [Values Funcons] -> Rewrite Rewritten
adt_type_construct_ :: [Funcons] -> Funcons
adtTypeConstruct :: [Values Funcons] -> Rewrite Rewritten
adt_constructor_ :: [Funcons] -> Funcons
adtConstructor :: [Values Funcons] -> Rewrite Rewritten
adt_fields_ :: [Funcons] -> Funcons
adtFields :: [Values Funcons] -> Rewrite Rewritten
to_string_ :: [Funcons] -> Funcons
computation_types_ :: [Funcons] -> Funcons
stepComputation_Types :: Rewrite Rewritten
library :: FunconLibrary

module Funcons.ValueOperations
execRewrites :: Rewrite a -> Either IE a
evalOperation :: Funcons -> Either IE [Values]
type IException = (Funcons, Funcons, IE)
data IE
SortErr :: String -> IE
Err :: String -> IE
PartialOp :: String -> IE
Internal :: String -> IE
NoRule :: [IException] -> IE
NoMoreBranches :: [IException] -> IE
SideCondFail :: String -> IE
InsufficientInput :: Name -> IE
InsufficientInputConsumed :: Name -> IE
PatternMismatch :: String -> IE
StepOnValue :: [Values] -> IE
isIn :: Values -> Values -> Rewrite Bool