Contains basic actions for interpretation.

Type specifiers of actions are defined as follows:
More...

Static Public Member Functions
static IReadOnlyList < InterpreterAction< T > >	GetAllActions ()
	Provides basic Mercury actions More...

static IReadOnlyDictionary < string, string >	GetAliases ()
	Returns aliases for basic actions. It contains the following aliases: More...

static InterpreterAction< T >	CreateTracer (string name, TextWriter writer)
	Creates custom trace action with stream, useful for logging. More...

Static Public Attributes
static readonly InterpreterAction< T >	ParseInteger
	Converts a string representation of an integer. `ParseInteger :: String -> Integer` More...

static readonly InterpreterAction< T >	ParseReal
	Converts a string representation of a decimal number. `ParseReal :: String -> Real` More...

static readonly InterpreterAction< T >	ParseBoolean
	Converts a string representation of a boolean. `ParseBoolean :: String -> Boolean` More...

static readonly InterpreterAction< T >	Round = new ConvertAction<T, double, int>("Round", x => Convert.ToInt32(Math.Round(x)))
	Rounds a real number. `Round :: Real -> Integer` More...

static readonly InterpreterAction< T >	Ceiling = new ConvertAction<T, double, int>("Ceiling", x => Convert.ToInt32(Math.Ceiling(x)))
	Returns a ceiling of a real number. `Ceiling :: Real -> Integer` More...

static readonly InterpreterAction< T >	Floor = new ConvertAction<T, double, int>("Floor", x => Convert.ToInt32(Math.Floor(x)))
	Returns a floor of a real number. `Floor :: Real -> Integer` More...

static readonly InterpreterAction< T >	ToReal = new ConvertAction<T, int, double>("ToReal", x => Convert.ToDouble(x))
	Converts an integer value to decimal. `ToReal :: Integer -> Real` More...

static readonly InterpreterAction< T >	String = new ConvertAction<T, object, string>("String", x => x.ToString())
	Call ToString() method on its argument. `String :: Any -> String` More...

static readonly InterpreterAction< T >	Add = new ArithmeticAction<T>("Add", (x, y) => x + y)
	Sum of the arguments. `Add[a = Integer\|Real] :: a -> a -> ... -> a` More...

static readonly InterpreterAction< T >	Sub = new ArithmeticAction<T>("Sub", (x, y) => x - y)
	Subtracts the arguments. `Sub[a = Integer\|Real] :: a -> a -> ... -> a` More...

static readonly InterpreterAction< T >	Mul = new ArithmeticAction<T>("Mul", (x, y) => x * y)
	Multiplies the arguments. `Mul[a = Integer\|Real] :: a -> a -> ... -> a` More...

static readonly InterpreterAction< T >	Div = new ArithmeticAction<T>("Div", (x, y) => x / y)
	Divides the values. `Div[a = Integer\|Real] :: a -> a -> ... -> a` More...

static readonly InterpreterAction< T >	Pow = new ArithmeticAction<T>("Pow", (x, y) => Math.Pow(x, y))
	Exponentiates the values. `Pow[a = Integer\|Real] :: a -> a -> ... -> a` More...

static readonly InterpreterAction< T >	FDiv = new OperationAction<T, double, double>("FDiv", (x, y) => x / y)
	Floating point division. `FDiv :: Real -&gt Real -> Real` More...

static readonly InterpreterAction< T >	Mod = new OperationAction<T, int, int>("Mod", (x, y) => x % y)
	Modulo. `Mod :: Integer -> Integer -> Integer` More...

static readonly InterpreterAction< T >	IsNull = new ConvertAction<T, object, bool>("IsNull", x => x == null, ArgumentType.Null)
	Indicates whether the object is `null`. `IsNull :: Any -> Boolean` More...

static readonly InterpreterAction< T >	And = new FoldingAction<T, bool, bool>("And", 2, (x, y) => x && y, true)
	Logical multiplication. `And :: Boolean -> Boolean -> ... -> Boolean` More...

static readonly InterpreterAction< T >	Or = new FoldingAction<T, bool, bool>("Or", 2, (x, y) => x && y, false)
	Logical addition. `Or :: Boolean -> Boolean -> ... -> Boolean` More...

static readonly InterpreterAction< T >	Not = new ConvertAction<T, bool, bool>("Not", x => !x)
	Logical negation. `Not :: Boolean -> Boolean` More...

static readonly InterpreterAction< T >	Xor = new OperationAction<T, bool, bool>("Xor", (x, y) => x ^ y)
	Exclusive disjunction. `Xor :: Boolean -> Boolean -> Boolean` More...

static readonly InterpreterAction< T >	Eq = new OperationAction<T, object, bool>("Eq", (x, y) => (x != null) && x.Equals(y), ArgumentType.Null)
	Indicates whether provided objects are equal. If any of arguments is `null`, the result is always `false`. `Eq :: Any -> Any -> Boolean` More...

static readonly InterpreterAction< T >	Neq = new OperationAction<T, object, bool>("Neq", (x, y) => (x == null) \|\| !x.Equals(y), ArgumentType.Null)
	Complement of Eq. `Neq :: Any -> Any -> Boolean` More...

static readonly InterpreterAction< T >	Gr = new OperationAction<T, double, bool>("Gr", (x, y) => x > y)
	Comparison "Greater than". `Gr :: Real -> Real -> Boolean` More...

static readonly InterpreterAction< T >	Ls = new OperationAction<T, double, bool>("Ls", (x, y) => x < y)
	Comparison "Less than". `Ls :: Real -> Real -> Boolean` More...

static readonly InterpreterAction< T >	Geq = new OperationAction<T, double, bool>("Geq", (x, y) => x >= y)
	Comparison "Greater than or equal to". `Geq :: Real -> Real -> Boolean` More...

static readonly InterpreterAction< T >	Leq = new OperationAction<T, double, bool>("Leq", (x, y) => x <= y)
	Comparison "Less than or equal to". `Leq :: Real -> Real -> Boolean` More...

static readonly InterpreterAction< T >	Empty = new ConstantAction<T, string>("Empty", "")
	Returns an empty string. `Empty :: String` More...

static readonly InterpreterAction< T >	Join = new JoinAction<T>()
	Converts all arguments to strings and joins them with a given separator. `Join :: String -> [Any...] -> String` More...

static readonly InterpreterAction< T >	Concat = new ConcatAction<T>()
	Converts all arguments to strings and concatenates them. `Concat :: [Any...] -> String` More...

static readonly InterpreterAction< T >	Flatten = new FlattenAction<T>()
	Converts a tree into its string representation. An optional argument specifies the depth. `Flatten :: Tree -> [Integer] -> String` More...

static readonly InterpreterAction< T >	Name = new ConvertAction<T, Symbol, string>("Name", x => x.Name)
	Returns the name of the given symbol. `Name :: Symbol -> String` More...

static readonly InterpreterAction< T >	Symbol = new ConvertAction<T, Tree<Symbol>, Symbol>("Symbol", x => x.Value)
	Returns the root symbol of the given tree. `Symbol :: Tree -> Symbol` More...

static readonly InterpreterAction< T >	Depth = new ConvertAction<T, Tree<Symbol>, int>("Depth", x => x.Depth)
	Returns the depth of the given tree. `Depth :: Tree -> Integer` More...

static readonly InterpreterAction< T >	Leaves = new ConvertAction<T, Tree<Symbol>, int>("Leaves", x => x.LeavesCount)
	Returns the count of leaves of the given tree. `Leaves :: Tree -> Integer` More...

static readonly InterpreterAction< T >	SubTree = new SubTreeAction<T>()
	Returns a child of a given tree at index specified as the second parameter. If no such child exists, the action returns `null`. `SubTree :: Tree -> Integer -> Tree` More...

static readonly InterpreterAction< T >	Preterminal
	Returns a string value of a preterminal rule (of the form `A -&gt b` where `b` is the terminal. If the tree was not generated by a preterminal rule, returns `null`. `Preterminal :: Tree -> String` More...

static readonly InterpreterAction< T >	If = new IfAction<T>()
	Condition. The semantics of `(if c0 a0 c1 a1 ... e)` is `if (c0) then a1; else if (c1) then a1; ... else e;`. All values and conditions are evaluated lazily. Moreover, types of `a_` must be equal otherwise the type inference would fail. `If[a = Any] :: [Boolean,a...] -> a -> a` More...

static readonly InterpreterAction< T >	Select = new SelectAction<T>()
	Selection. The semantics of `(select i c0 c1 ... cn def)` is `if (0 <= i <= n) then ci; else def;`. All values are evaluated lazily. Moreover, types of `c_` must be equal otherwise the type inference would fail. `Select[a = Any] :: Integer -> [a...] -> a -> a` More...

static readonly InterpreterAction< T >	Case = new CaseAction<T>()
	Case. The semantics of `(case x c0 v0 c1 v1 ... def)` is `switch (x) { case c0: v0; break; case c1: v1; break; ... default: def; }`. Moreover, types of `c_` and `x` must be equal, as well as types of `v_`. `Case[v = Any, e = Any] :: v -> [v,e...] -> e -> e` More...

static readonly InterpreterAction< T >	Eval = new EvaluateAction<T>()
	Recursively evaluates the given tree. `Eval :: Tree -> TValue` More...

static readonly InterpreterAction< T >	Simple = new SimpleAction<T>()
	Evaluates the subtree of a given tree provided that it is the only subtree; otherwise returns `null`. `Simple :: Tree -> TValue` More...

static readonly InterpreterAction< T >	Fail = new FailAction<T>()
	Returns `null`. `Fail :: Any` More...

static readonly InterpreterAction< T >	Try = new TryAction<T>()
	Try action. The semantics of `(try e1 e2)` is `try { e1; } catch (Mercury.Exceptions.ErrorActionException) { e2; }`. If the second argument is not specified, it will behave like `(try e1 (fail))`. Moreover, the types of `e1` and `e2` must be equal. `Try[a = Any] :: a -> a -> a` More...

static readonly InterpreterAction< T >	Error = new ConvertAction<T, string, object>("Error", x => { throw new ErrorActionException(x); })
	Throws an instance of Mercury.Exceptions.ErrorActionException with the specified text. `Error :: String -> Any` More...

static readonly InterpreterAction< T >	Identity = new IdentityAction<T>()
	Returns the same value. `Identity[a = Any] :: a -> a` More...

static readonly InterpreterAction< T >	Let = new LetAction<T>()
	Saves the value in the current context. The semantics of `(Let x v0 y v1 ... act)` is `let (x = v0; y = v1; ...) in (act);`. The return type is same as the type of `act`. `Let[a = Any] :: [String,Any...] -> a -> a` More...

static readonly InterpreterAction< T >	Var = new VarAction<T>()
	Retrieves the value stored by Let, but only in the same context. The function also performs runtime type check; if the value stored does not exist or match the type required, it will throw an exception. `Var :: String -> Any` More...

static readonly InterpreterAction< T >	ArgsCount = new ArgsCountAction<T>()
	Returns the number of arguments. Useful to determine number of values captured by a Mercury.Interpreting.Wildcard. `ArgsCount :: [Any...] -> Integer` More...

static readonly InterpreterAction< T >	Trace = new TraceAction<T>()
	Logs an event to the entry tree. `Trace[a = Any] -> a -> String -> [Any...] -> a` More...

Detailed Description

Contains basic actions for interpretation.

Type specifiers of actions are defined as follows:

f :: type defines an action f of type type.
f[a = X] :: type defines an action f of type type, where a gets replaced by X and is always of the same type.

Syntax of action types is as follows:

a -> b -> c is a function that takes two arguments of type a and b and returns an argument of type c.
[X] is an optional argument of type X.
[X...] is an arbitrary number of arguments of type X.
[X,Y...] is an arbitrary number of arguments in the form of X -> Y -> X -> Y etc.
... arbitrary number of same arguments as previous, i.e. Integer -> ... is at least one Integer.

Note that if f :: a -> [b] -> [c] -> d, the third argument of type c cannot be specified without the second argument of type b.

Template Parameters

T	Interpreter return type.

Type Constraints

T

:

class

Definition at line 39 of file BasicActions.cs.

Member Function Documentation

static InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.CreateTracer	(	string	name,
		TextWriter	writer
	)

static

Creates custom trace action with stream, useful for logging.

Parameters

name	The name of the action
writer	The output writer

Returns: The interpreter action

Definition at line 352 of file BasicActions.cs.

static IReadOnlyDictionary<string,string> Mercury.Interpreting.BasicActions< T >.GetAliases ( )

static

Returns aliases for basic actions.

It contains the following aliases:

    + Add      - Sub      * Mul     / Div
   // FDiv     % Mod     ** Pow 
    @ String  ++ Concat   # Var
    & And      | Or       ^ Xor     ! Not
   == Eq      /= Neq
    > Gt       < Lt      >= Geq     <= Leq
    $ Eval    id Identity

Definition at line 332 of file BasicActions.cs.

static IReadOnlyList<InterpreterAction<T> > Mercury.Interpreting.BasicActions< T >.GetAllActions ( )

static

Provides basic Mercury actions

Template Parameters

T	Output type parameter

Returns: List of actions

Definition at line 304 of file BasicActions.cs.

Member Data Documentation

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Add = new ArithmeticAction<T>("Add", (x, y) => x + y)

static

Sum of the arguments.
Add[a = Integer|Real] :: a -> a -> ... -> a

Definition at line 96 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.And = new FoldingAction<T, bool, bool>("And", 2, (x, y) => x && y, true)

static

Logical multiplication.
And :: Boolean -> Boolean -> ... -> Boolean

Definition at line 123 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.ArgsCount = new ArgsCountAction<T>()

static

Returns the number of arguments. Useful to determine number of values captured by a Mercury.Interpreting.Wildcard.
ArgsCount :: [Any...] -> Integer

Definition at line 296 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Case = new CaseAction<T>()

static

Case. The semantics of (case x c0 v0 c1 v1 ... def) is
switch (x) { case c0: v0; break; case c1: v1; break; ... default: def; }.
Moreover, types of c_ and x must be equal, as well as types of v_.
Case[v = Any, e = Any] :: v -> [v,e...] -> e -> e

Definition at line 238 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Ceiling = new ConvertAction<T, double, int>("Ceiling", x => Convert.ToInt32(Math.Ceiling(x)))

static

Returns a ceiling of a real number.
Ceiling :: Real -> Integer

Definition at line 81 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Concat = new ConcatAction<T>()

static

Converts all arguments to strings and concatenates them.
Concat :: [Any...] -> String

Definition at line 168 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Depth = new ConvertAction<T, Tree<Symbol>, int>("Depth", x => x.Depth)

static

Returns the depth of the given tree.
Depth :: Tree -> Integer

Definition at line 186 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Div = new ArithmeticAction<T>("Div", (x, y) => x / y)

static

Divides the values.
Div[a = Integer|Real] :: a -> a -> ... -> a

Definition at line 105 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Empty = new ConstantAction<T, string>("Empty", "")

static

Returns an empty string.
Empty :: String

Definition at line 159 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Eq = new OperationAction<T, object, bool>("Eq", (x, y) => (x != null) && x.Equals(y), ArgumentType.Null)

static

Indicates whether provided objects are equal. If any of arguments is null, the result is always false.
Eq :: Any -> Any -> Boolean

Definition at line 138 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Error = new ConvertAction<T, string, object>("Error", x => { throw new ErrorActionException(x); })

static

Throws an instance of Mercury.Exceptions.ErrorActionException with the specified text.
Error :: String -> Any

Definition at line 267 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Eval = new EvaluateAction<T>()

static

Recursively evaluates the given tree.
Eval :: Tree -> TValue

Definition at line 241 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Fail = new FailAction<T>()

static

Returns null.
Fail :: Any

Definition at line 251 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.FDiv = new OperationAction<T, double, double>("FDiv", (x, y) => x / y)

static

Floating point division.
FDiv :: Real -&gt Real -> Real

Definition at line 111 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Flatten = new FlattenAction<T>()

static

Converts a tree into its string representation. An optional argument specifies the depth.
Flatten :: Tree -> [Integer] -> String

Definition at line 174 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Floor = new ConvertAction<T, double, int>("Floor", x => Convert.ToInt32(Math.Floor(x)))

static

Returns a floor of a real number.
Floor :: Real -> Integer

Definition at line 84 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Geq = new OperationAction<T, double, bool>("Geq", (x, y) => x >= y)

static

Comparison "Greater than or equal to".
Geq :: Real -> Real -> Boolean

Definition at line 150 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Gr = new OperationAction<T, double, bool>("Gr", (x, y) => x > y)

static

Comparison "Greater than".
Gr :: Real -> Real -> Boolean

Definition at line 144 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Identity = new IdentityAction<T>()

static

Returns the same value.
Identity[a = Any] :: a -> a

Definition at line 273 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.If = new IfAction<T>()

static

Condition. The semantics of (if c0 a0 c1 a1 ... e) is if (c0) then a1; else if (c1) then a1; ... else e;. All values and conditions are evaluated lazily.
Moreover, types of a_ must be equal otherwise the type inference would fail.
If[a = Any] :: [Boolean,a...] -> a -> a

Definition at line 221 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.IsNull = new ConvertAction<T, object, bool>("IsNull", x => x == null, ArgumentType.Null)

static

Indicates whether the object is null.
IsNull :: Any -> Boolean

Definition at line 120 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Join = new JoinAction<T>()

static

Converts all arguments to strings and joins them with a given separator.
Join :: String -> [Any...] -> String

Definition at line 165 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Leaves = new ConvertAction<T, Tree<Symbol>, int>("Leaves", x => x.LeavesCount)

static

Returns the count of leaves of the given tree.
Leaves :: Tree -> Integer

Definition at line 189 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Leq = new OperationAction<T, double, bool>("Leq", (x, y) => x <= y)

static

Comparison "Less than or equal to".
Leq :: Real -> Real -> Boolean

Definition at line 153 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Let = new LetAction<T>()

static

Saves the value in the current context.
The semantics of (Let x v0 y v1 ... act) is let (x = v0; y = v1; ...) in (act);.
The return type is same as the type of act.
Let[a = Any] :: [String,Any...] -> a -> a

Definition at line 282 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Ls = new OperationAction<T, double, bool>("Ls", (x, y) => x < y)

static

Comparison "Less than".
Ls :: Real -> Real -> Boolean

Definition at line 147 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Mod = new OperationAction<T, int, int>("Mod", (x, y) => x % y)

static

Modulo.
Mod :: Integer -> Integer -> Integer

Definition at line 114 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Mul = new ArithmeticAction<T>("Mul", (x, y) => x * y)

static

Multiplies the arguments.
Mul[a = Integer|Real] :: a -> a -> ... -> a

Definition at line 102 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Name = new ConvertAction<T, Symbol, string>("Name", x => x.Name)

static

Returns the name of the given symbol.
Name :: Symbol -> String

Definition at line 180 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Neq = new OperationAction<T, object, bool>("Neq", (x, y) => (x == null) || !x.Equals(y), ArgumentType.Null)

static

Complement of Eq.
Neq :: Any -> Any -> Boolean

Definition at line 141 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Not = new ConvertAction<T, bool, bool>("Not", x => !x)

static

Logical negation.
Not :: Boolean -> Boolean

Definition at line 129 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Or = new FoldingAction<T, bool, bool>("Or", 2, (x, y) => x && y, false)

static

Logical addition.
Or :: Boolean -> Boolean -> ... -> Boolean

Definition at line 126 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.ParseBoolean

static

Initial value:

= new ConvertAction<T, string, bool>("ParseBoolean",

x => { bool b; return bool.TryParse(x, out b) ? b : default(bool); })

Converts a string representation of a boolean.
ParseBoolean :: String -> Boolean

Definition at line 71 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.ParseInteger

static

Initial value:

= new ConvertAction<T, string, int>("ParseInteger",

x => { int i; return int.TryParse(x, NumberStyles.Integer, cinf, out i) ? i : default(int); })

Converts a string representation of an integer.
ParseInteger :: String -> Integer

Definition at line 55 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.ParseReal

static

Initial value:

= new ConvertAction<T, string, double>("ParseReal",

x => { double d; return double.TryParse(x, NumberStyles.Float, cinf, out d) ? d : default(double); })

Converts a string representation of a decimal number.
ParseReal :: String -> Real

Definition at line 63 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Pow = new ArithmeticAction<T>("Pow", (x, y) => Math.Pow(x, y))

static

Exponentiates the values.
Pow[a = Integer|Real] :: a -> a -> ... -> a

Definition at line 108 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Preterminal

static

Initial value:

= new ConvertAction<T, Tree<Symbol>, string>("Preterminal", x =>
                {
                    return ((x.Children.Count != 1)
                        || ((x[0].Value.Type & (SymbolType.Terminal | SymbolType.Epsilon)) == SymbolType.None))
                        ? null : x[0].Value.Name;
                })

Returns a string value of a preterminal rule (of the form A -&gt b where b is the terminal. If the tree was not generated by a preterminal rule, returns null.
Preterminal :: Tree -> String

Definition at line 204 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Round = new ConvertAction<T, double, int>("Round", x => Convert.ToInt32(Math.Round(x)))

static

Rounds a real number.
Round :: Real -> Integer

Definition at line 78 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Select = new SelectAction<T>()

static

Selection. The semantics of (select i c0 c1 ... cn def) is if (0 <= i <= n) then ci; else def;. All values are evaluated lazily.
Moreover, types of c_ must be equal otherwise the type inference would fail.
Select[a = Any] :: Integer -> [a...] -> a -> a

Definition at line 230 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Simple = new SimpleAction<T>()

static

Evaluates the subtree of a given tree provided that it is the only subtree; otherwise returns null.
Simple :: Tree -> TValue

Definition at line 248 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.String = new ConvertAction<T, object, string>("String", x => x.ToString())

static

Call ToString() method on its argument.
String :: Any -> String

Definition at line 90 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Sub = new ArithmeticAction<T>("Sub", (x, y) => x - y)

static

Subtracts the arguments.
Sub[a = Integer|Real] :: a -> a -> ... -> a

Definition at line 99 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.SubTree = new SubTreeAction<T>()

static

Returns a child of a given tree at index specified as the second parameter. If no such child exists, the action returns null.
SubTree :: Tree -> Integer -> Tree

Definition at line 196 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Symbol = new ConvertAction<T, Tree<Symbol>, Symbol>("Symbol", x => x.Value)

static

Returns the root symbol of the given tree.
Symbol :: Tree -> Symbol

Definition at line 183 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.ToReal = new ConvertAction<T, int, double>("ToReal", x => Convert.ToDouble(x))

static

Converts an integer value to decimal.
ToReal :: Integer -> Real

Definition at line 87 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Trace = new TraceAction<T>()

static

Logs an event to the entry tree.
Trace[a = Any] -> a -> String -> [Any...] -> a

Definition at line 299 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Try = new TryAction<T>()

static

Try action. The semantics of (try e1 e2) is try { e1; } catch (Mercury.Exceptions.ErrorActionException) { e2; }.
If the second argument is not specified, it will behave like (try e1 (fail)). Moreover, the types of e1 and e2 must be equal.
Try[a = Any] :: a -> a -> a

Definition at line 260 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Var = new VarAction<T>()

static

Retrieves the value stored by Let, but only in the same context. The function also performs runtime type check; if the value stored does not exist or match the type required, it will throw an exception.
Var :: String -> Any

Definition at line 290 of file BasicActions.cs.

readonly InterpreterAction<T> Mercury.Interpreting.BasicActions< T >.Xor = new OperationAction<T, bool, bool>("Xor", (x, y) => x ^ y)

static

Exclusive disjunction.
Xor :: Boolean -> Boolean -> Boolean

Definition at line 132 of file BasicActions.cs.

The documentation for this class was generated from the following file:

Mercury/Mercury/Interpreting/BasicActions.cs

Static Public Member Functions

Static Public Attributes

Detailed Description

Member Function Documentation

Member Data Documentation