BasicActions.cs

Go to the documentation of this file.

using Mercury.Exceptions;
using Mercury.Nucleus.Trees;
using Mercury.Syntax;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;

namespace Mercury.Interpreting
{

//=============================================================================
//  BasicActions
//=============================================================================

    public static class BasicActions<T>
        where T : class
    {
        //--[  Private fields  ]-----------------------------------------------

        private static CultureInfo cinf = CultureInfo.InvariantCulture;
        
        //==<<  Actions  >>====================================================

        //--[  Parsing actions  ]----------------------------------------------

        public static readonly InterpreterAction<T> ParseInteger
            = new ConvertAction<T, string, int>("ParseInteger",
                x => { int i; return int.TryParse(x, NumberStyles.Integer, cinf, out i) ? i : default(int); });

        public static readonly InterpreterAction<T> ParseReal
            = new ConvertAction<T, string, double>("ParseReal",
                x => { double d; return double.TryParse(x, NumberStyles.Float, cinf, out d) ? d : default(double); });

        public static readonly InterpreterAction<T> ParseBoolean
            = new ConvertAction<T, string, bool>("ParseBoolean",
                x => { bool b; return bool.TryParse(x, out b) ? b : default(bool); });

        //--[  Rounding and conversions  ]-------------------------------------

        public static readonly InterpreterAction<T> Round   
            = new ConvertAction<T, double,    int>("Round",   x => Convert.ToInt32(Math.Round(x)));
        public static readonly InterpreterAction<T> Ceiling 
            = new ConvertAction<T, double,    int>("Ceiling", x => Convert.ToInt32(Math.Ceiling(x)));
        public static readonly InterpreterAction<T> Floor   
            = new ConvertAction<T, double,    int>("Floor",   x => Convert.ToInt32(Math.Floor(x)));
        public static readonly InterpreterAction<T> ToReal  
            = new ConvertAction<T,    int, double>("ToReal",  x => Convert.ToDouble(x));
        public static readonly InterpreterAction<T> String  
            = new ConvertAction<T, object, string>("String",  x => x.ToString());

        //--[  Arithmetics  ]--------------------------------------------------

        public static readonly InterpreterAction<T> Add  
            = new ArithmeticAction<T>("Add", (x, y) => x + y);
        public static readonly InterpreterAction<T> Sub  
            = new ArithmeticAction<T>("Sub", (x, y) => x - y);
        public static readonly InterpreterAction<T> Mul  
            = new ArithmeticAction<T>("Mul", (x, y) => x * y);
        public static readonly InterpreterAction<T> Div  
            = new ArithmeticAction<T>("Div", (x, y) => x / y);
        public static readonly InterpreterAction<T> Pow  
            = new ArithmeticAction<T>("Pow", (x, y) => Math.Pow(x, y));
        public static readonly InterpreterAction<T> FDiv 
            = new OperationAction<T, double, double>("FDiv", (x, y) => x / y);
        public static readonly InterpreterAction<T> Mod  
            = new OperationAction<T,    int,    int>("Mod",  (x, y) => x % y);

        //--[  Boolean operations  ]-------------------------------------------

        public static readonly InterpreterAction<T> IsNull 
            = new ConvertAction<T, object, bool>("IsNull", x => x == null, ArgumentType.Null);
        public static readonly InterpreterAction<T> And 
            = new FoldingAction<T,     bool, bool>("And", 2, (x, y) => x && y,  true);
        public static readonly InterpreterAction<T> Or  
            = new FoldingAction<T,     bool, bool>("Or", 2,  (x, y) => x && y, false);
        public static readonly InterpreterAction<T> Not 
            = new ConvertAction<T,     bool, bool>("Not",     x     =>   !x);
        public static readonly InterpreterAction<T> Xor 
            = new OperationAction<T,   bool, bool>("Xor", (x, y) => x ^ y);
        public static readonly InterpreterAction<T> Eq  
            = new OperationAction<T, object, bool>("Eq",  (x, y) => (x != null) &&  x.Equals(y), ArgumentType.Null);
        public static readonly InterpreterAction<T> Neq 
            = new OperationAction<T, object, bool>("Neq", (x, y) => (x == null) || !x.Equals(y), ArgumentType.Null);
        public static readonly InterpreterAction<T> Gr  
            = new OperationAction<T, double, bool>("Gr",  (x, y) => x >  y);
        public static readonly InterpreterAction<T> Ls  
            = new OperationAction<T, double, bool>("Ls",  (x, y) => x <  y);
        public static readonly InterpreterAction<T> Geq 
            = new OperationAction<T, double, bool>("Geq", (x, y) => x >= y);
        public static readonly InterpreterAction<T> Leq 
            = new OperationAction<T, double, bool>("Leq", (x, y) => x <= y);

        //--[  String actions  ]-----------------------------------------------

        public static readonly InterpreterAction<T> Empty   
            = new ConstantAction<T, string>("Empty", "");
        public static readonly InterpreterAction<T> Join    
            = new JoinAction<T>();
        public static readonly InterpreterAction<T> Concat  
            = new ConcatAction<T>();
        public static readonly InterpreterAction<T> Flatten 
            = new FlattenAction<T>();
        
        //--[  Tree and symbol actions  ]--------------------------------------

        public static readonly InterpreterAction<T> Name    
            = new ConvertAction<T,      Symbol,  string>("Name",   x => x.Name);
        public static readonly InterpreterAction<T> Symbol  
            = new ConvertAction<T, Tree<Symbol>, Symbol>("Symbol", x => x.Value);
        public static readonly InterpreterAction<T> Depth   
            = new ConvertAction<T, Tree<Symbol>,    int>("Depth",  x => x.Depth);
        public static readonly InterpreterAction<T> Leaves  
            = new ConvertAction<T, Tree<Symbol>,    int>("Leaves", x => x.LeavesCount);
        public static readonly InterpreterAction<T> SubTree 
            = new SubTreeAction<T>();

        public static readonly InterpreterAction<T> Preterminal
            = 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;
                });

        //--[  Control actions  ]----------------------------------------------

        public static readonly InterpreterAction<T> If     
            = new IfAction<T>();
        public static readonly InterpreterAction<T> Select 
            = new SelectAction<T>();
        public static readonly InterpreterAction<T> Case   
            = new CaseAction<T>();
        public static readonly InterpreterAction<T> Eval   
            = new EvaluateAction<T>();
        public static readonly InterpreterAction<T> Simple 
            = new SimpleAction<T>();
        public static readonly InterpreterAction<T> Fail   
            = new FailAction<T>();
        public static readonly InterpreterAction<T> Try    
            = new TryAction<T>();
        public static readonly InterpreterAction<T> Error  
            = new ConvertAction<T, string, object>("Error", x => { throw new ErrorActionException(x); });

        //--[  Utilities  ]----------------------------------------------------

        public static readonly InterpreterAction<T> Identity  
            = new IdentityAction<T>();
        public static readonly InterpreterAction<T> Let       
            = new LetAction<T>();
        public static readonly InterpreterAction<T> Var       
            = new VarAction<T>();
        public static readonly InterpreterAction<T> ArgsCount 
            = new ArgsCountAction<T>();
        public static readonly InterpreterAction<T> Trace     
            = new TraceAction<T>();

        public static IReadOnlyList<InterpreterAction<T>> GetAllActions() 
        {
            return new List<InterpreterAction<T>>()
            {
                ParseInteger, ParseReal, ParseBoolean,
                Round, Ceiling, Floor, ToReal, String,
                Add, Sub, Mul, Div, Pow, FDiv, Mod,
                IsNull, And, Or, Not, Xor, Eq, Neq, Gr, Ls, Geq, Leq,
                Empty, Join, Concat, Flatten,
                Name, Symbol, Depth, Leaves, SubTree, Preterminal,
                If, Select, Case, Eval, Simple, Fail, Try, Error,
                Identity, Let, Var, ArgsCount, Trace
            };
        }

        public static IReadOnlyDictionary<string,string> GetAliases()
        {
            return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                { "ToString", "String" },

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

        public static InterpreterAction<T> CreateTracer(string name, TextWriter writer)
        { return new TraceAction<T>(writer){ Name = name }; }

    }

//=============================================================================
//  <<  Action Templates  >>
//=============================================================================

//==<<  OperationAction  >>====================================================

    public sealed class OperationAction<T, U, V> : InterpreterAction<T, V>
        where T : class
    {
        private Func<U, U, V> f;

        //--[  Constructors  ]-------------------------------------------------

        public OperationAction(string name, Func<U, U, V> f, ArgumentType flags = ArgumentType.None)
            : base(name, Tuple.Create(2, 2), 
                new[] { Defaults.TypeToArgType<T,U>() | (flags & ArgumentType.Flags) })
        {
            if (f == null) throw new ArgumentNullException("f");
            this.f = f;
        }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  InterpreterAction  ]

        public override V Evaluate(Argument[] arguments, RecursiveEval<T> eval, 
                                   InterpreterContext<T> context)
        { return f(arguments[0].Value, arguments[1].Value); }

        #endregion

    }

//==<<  FoldingAction >>=======================================================

    public sealed class FoldingAction<T, U, V> : InterpreterAction<T, V>
        where T : class
    {
        private Func<V, U, V> f;
        private V             s;

        //--[  Constructors  ]-------------------------------------------------

        public FoldingAction(string name, int minargs, Func<V, U, V> f, V seed, 
            ArgumentType flags = ArgumentType.None)
            : base(name, Tuple.Create(minargs, int.MaxValue), 
                  new[] { Defaults.TypeToArgType<T, U>() | (flags & ArgumentType.Flags) })
        {
            if (f == null) throw new ArgumentNullException("f");
            this.f = f;
            this.s = seed;
        }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  InterpreterAction  ]

        public override V Evaluate(Argument[] arguments, RecursiveEval<T> eval, 
                                   InterpreterContext<T> context)
        { return arguments.Aggregate(s, (x, y) => f(x, y.Value)); }

        #endregion


    }

//==<<  ConvertAction  >>======================================================

    public sealed class ConvertAction<T, U, V> : InterpreterAction<T, V>
        where T : class
    {
        private Func<U, V> f;

        //--[  Constructors  ]-------------------------------------------------

        public ConvertAction(string name, Func<U, V> f, ArgumentType flags = ArgumentType.None)
            : base(name, Tuple.Create(1, 1), 
              new[] { Defaults.TypeToArgType<T, U>() | (flags & ArgumentType.Flags) })
        { 
            if (f == null) throw new ArgumentNullException("f");
            this.f = f; 
        }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  InterpreterAction  ]

        public override V Evaluate(Argument[] arguments, RecursiveEval<T> eval, 
                                   InterpreterContext<T> context)
        { return f((U) arguments[0].Data); }

        #endregion

    }

//==<<  ConstantAction  >>=====================================================

    public sealed class ConstantAction<T, U> : InterpreterAction<T, U>
        where T : class
    {
        private U value;

        //--[  Constructors  ]-------------------------------------------------

        public ConstantAction(string name, U value)
            : base(name, Tuple.Create(0, 0), new ArgumentType[0])
        { this.value = value; }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  InterpreterAction  ]

        public override U Evaluate(Argument[] arguments, RecursiveEval<T> eval, 
                                   InterpreterContext<T> context)
        { return value; }

        #endregion

    }

//==<<  ArithmeticAction  >>===================================================

    public sealed class ArithmeticAction<T> : GenericAction<T>
        where T : class
    {
        private Func<dynamic, dynamic, dynamic> f;

        //--[  Constructors  ]-------------------------------------------------

        public ArithmeticAction(string name, Func<dynamic, dynamic, dynamic> f)
            : base(name, Tuple.Create(2, int.MaxValue), new[] { ArgumentType.Integer | ArgumentType.Real })
        { 
            if (f == null) throw new ArgumentNullException("f");
            this.f = f;
        }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  GenericAction  ]

        public override ArgumentType InferReturnType(ArgumentType expected, ArgumentType[] actual)
        {
            return actual.All(x => x.HasFlag(ArgumentType.Integer))
                ? ArgumentType.Integer | ArgumentType.Real
                : ArgumentType.Real;
        }

        public override object Invoke(Argument[] arguments, RecursiveEval<T> eval, 
                                      InterpreterContext<T> context)
        {
            try
            {
                dynamic val = arguments[0].Value;
                for (int ix = 1; ix < arguments.Length; ++ix)
                    val = f(val, arguments[ix].Value);
                return val;
            } catch (ArithmeticException ex)
            { throw new ErrorActionException(ex.Message); }
        }

        #endregion

    }

//=============================================================================
//  <<  Internal implementations  >>
//=============================================================================

//==<<  Join Action  >>========================================================

    internal class JoinAction<T> : InterpreterAction<T, string>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public JoinAction()
            : base("Join", Tuple.Create(1, int.MaxValue), new[] { ArgumentType.String, ArgumentType.Any })
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  InterpreterAction  ]

        public override string Evaluate(Argument[] arguments, RecursiveEval<T> eval, 
                                        InterpreterContext<T> context)
        { return string.Join(arguments[0].Data as string, arguments.Skip(1).Select(x => x.Data.ToString())); }

        #endregion

    }

//==<<  ConcatAction  >>=======================================================

    internal class ConcatAction<T> : InterpreterAction<T, string>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public ConcatAction()
            : base("Concat", Tuple.Create(0, int.MaxValue), new[] { ArgumentType.Any })
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  InterpreterAction  ]

        public override string Evaluate(Argument[] arguments, RecursiveEval<T> eval, 
                                        InterpreterContext<T> context)
        { return string.Concat(arguments.Select(x => x.Data.ToString())); }

        #endregion

    }

//==<<  FlattenAction  >>======================================================

    internal class FlattenAction<T> : InterpreterAction<T, string>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public FlattenAction()
            : base("Flatten", Tuple.Create(1, 2), new[] { ArgumentType.Tree, ArgumentType.Integer })
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  InterpreterAction  ]

        public override string Evaluate(Argument[] arguments, RecursiveEval<T> eval, 
                                        InterpreterContext<T> context)
        {
            int maxdepth = arguments.Length == 1 ? -1 : arguments[1].Value;
            return (arguments[0].Data as Tree<Symbol>).ToString(maxdepth);
        }

        #endregion

    }

//==<<  SubTreeAction  >>======================================================

    internal class SubTreeAction<T> : InterpreterAction<T, Tree<Symbol>>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public SubTreeAction()
            : base("SubTree", Tuple.Create(2, 2), 
              new[] { ArgumentType.Integer, ArgumentType.Tree })
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  InterpreterAction  ]

        public override Tree<Symbol> Evaluate(Argument[] arguments, RecursiveEval<T> eval,
                                              InterpreterContext<T> context)
        {
            int ix = arguments[0].Value;
            var tr = arguments[1].Data as Tree<Symbol>;

            return (0 > ix || ix >= tr.Children.Count) ? null : tr[ix];
        }

        #endregion

    }

//==<<  IdentityAction  >>=====================================================

    internal class IdentityAction<T> : GenericAction<T>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public IdentityAction()
            : base("Identity", Tuple.Create(1, 1), new[] { ArgumentType.Any })
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  GenericAction  ]

        public override ArgumentType InferReturnType(ArgumentType expected, ArgumentType[] actual)
        { return actual[0] & expected; }

        public override object Invoke(Argument[] arguments, RecursiveEval<T> eval, 
                                      InterpreterContext<T> context)
        { return arguments[0].Data; }

        #endregion

    }

//==<<  LetAction  >>==========================================================

    internal class LetAction<T> : GenericAction<T>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public LetAction()
            : base("Let", Tuple.Create(3, int.MaxValue), 
              new[] { ArgumentType.Any | ArgumentType.Lazy }, false)
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  GenericAction  ]

        public override ArgumentType InferReturnType(ArgumentType expected, ArgumentType[] actual)
        {
            if (actual.Length % 2 != 1) return ArgumentType.None;

            for (int ix = 0; ix < actual.Length - 2; ix += 2)
                if (!actual[ix].HasFlag(ArgumentType.String)) return ArgumentType.None;

            return actual[actual.Length - 1];
        }

        public override object Invoke(Argument[] arguments, RecursiveEval<T> eval,
                                      InterpreterContext<T> context)
        {
            for (int ix = 0; ix < arguments.Length - 2; ix += 2)
            {
                var name = arguments[ix].Data as string;

                if (context.bindings.ContainsKey(name))
                    throw new ErrorActionException("multiple bindings of variable '{0}'", name);

                context.bindings.Add(name, arguments[ix + 1]);
            }

            context.LogEntry("{0} values binded", arguments.Length / 2);
            return arguments[arguments.Length - 1].Data;
        }

        #endregion

    }

//==<<  VarAction  >>==========================================================

    internal class VarAction<T> : InterpreterAction<T, object>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public VarAction()
            : base("Var", Tuple.Create(1, 1), new[] { ArgumentType.String })
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  InterpreterAction  ]

        public override object Evaluate(Argument[] arguments, RecursiveEval<T> eval,
                                        InterpreterContext<T> context)
        {
            var      name = arguments[0].Data as string;
            Argument bval;

            if (!context.bindings.TryGetValue(name, out bval))
                throw new ErrorActionException("variable '{0}' binding does not exist", name);

            if ((bval.Type & context.reqtp) == ArgumentType.None)
                throw new ErrorActionException("runtime type check error in the binding of '{0}'", name);

            context.LogEntry("value of {0} fetched", name);
            return bval.Data;
        }

        #endregion

    }

//==<<  TryAction  >>==========================================================

    internal class TryAction<T> : GenericAction<T>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public TryAction()
            : base("Try", Tuple.Create(1, 2), new[] { ArgumentType.Any | ArgumentType.Lazy })
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  GenericAction  ]

        public override ArgumentType InferReturnType(ArgumentType expected, ArgumentType[] actual)
        { return (actual.Length == 1 ? actual[0] : actual[0] & actual[1]) & expected; }

        public override object Invoke(Argument[] arguments, RecursiveEval<T> eval,
                                      InterpreterContext<T> context)
        {
            try
            { return arguments[0].Data; }
            catch (ErrorActionException ex)
            {
                context.LogEntryEx("EXCEPTION", "'{0}' caught in '{1}'", 
                                   ex.Message, context.action);
                return arguments.Length == 2 ? arguments[1].Data : null; 
            }
        }

        #endregion

    }

//==<<  IfAction  >>===========================================================

    internal class IfAction<T> : GenericAction<T>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public IfAction()
            : base("If", Tuple.Create(3, int.MaxValue), 
              new[] { ArgumentType.Any | ArgumentType.Lazy }, false)
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  GenericAction  ]

        public override ArgumentType InferReturnType(ArgumentType expected, ArgumentType[] actual)
        {
            if (actual.Length % 2 != 1) return ArgumentType.None;

            ArgumentType argtp = ArgumentType.Any;
            for(int ix = 0; ix < actual.Length - 1; ix += 2)
            {
                if (!(actual[ix] & ArgumentType.Any).HasFlag(ArgumentType.Boolean)) 
                    return ArgumentType.None;
                argtp &= actual[ix + 1];
            }

            return (argtp & actual[actual.Length - 1]) & expected;
        }

        public override object Invoke(Argument[] arguments, RecursiveEval<T> eval,
                                      InterpreterContext<T> context)
        {
            for (int ix = 0; ix < arguments.Length - 1; ix += 2)
                if ((arguments[ix].Data != null) && arguments[ix].Value)
                    return arguments[ix + 1].Data;

            return arguments[arguments.Length - 1].Data;
        }

        #endregion

    }

//==<<  SelectAction  >>=======================================================

    internal class SelectAction<T> : GenericAction<T>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public SelectAction()
            : base("Select", Tuple.Create(2, int.MaxValue), 
              new[] { ArgumentType.Integer, ArgumentType.Any | ArgumentType.Lazy })
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  GenericAction  ]

        public override ArgumentType InferReturnType(ArgumentType expected, ArgumentType[] actual)
        { return actual.Skip(2).Aggregate(actual[1], (x, y) => x & y) & expected; }

        public override object Invoke(Argument[] arguments, RecursiveEval<T> eval,
                                      InterpreterContext<T> context)
        {
            int ix = arguments[0].Value;
            context.LogEntry("selector value is '{0}'", ix);
            return ((0 > ix) || (ix >= arguments.Length - 2)) ? arguments[1].Value : arguments[ix + 2].Data;
        }

        #endregion

    }

//==<<  CaseAction  >>=========================================================

    internal class CaseAction<T> : GenericAction<T>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public CaseAction()
            : base("Case", Tuple.Create(2, int.MaxValue), 
              new[] { ArgumentType.Any, ArgumentType.Any | ArgumentType.Lazy }, 
              false)
        { }

        //--[  Interface implementation  ]-------------------------------------

        #region [  GenericAction  ]

        public override ArgumentType InferReturnType(ArgumentType expected, ArgumentType[] actual)
        {
            if ((actual.Length % 2) == 1)
                return ArgumentType.None;

            ArgumentType valtp = ArgumentType.Any;
            ArgumentType restp = ArgumentType.Any;

            for (int ix = 0; ix < actual.Length; ix += 2)
            {
                valtp &= actual[ix];
                restp &= actual[ix + 1];
            }

            return (valtp == ArgumentType.None) ? ArgumentType.None : restp & expected;
        }

        public override object Invoke(Argument[] arguments, RecursiveEval<T> eval,
                                      InterpreterContext<T> context)
        {
            var val = arguments[0].Data;
            context.LogEntry("selector value is '{0}'", val ?? "null");

            if (val != null)
            {
                for (int ix = 2; ix < arguments.Length; ix += 2)
                    if (val.Equals(arguments[ix].Data)) return arguments[ix + 1].Data;
            }

            return arguments[1].Data;
        }

        #endregion

    }

//==<<  ArgsCountAction  >>====================================================

    internal class ArgsCountAction<T> : InterpreterAction<T, int>
        where T : class
    {

        //--[  Constructors  ]-------------------------------------------------

        public ArgsCountAction()
            : base("ArgsCount", Tuple.Create(0, int.MaxValue), new[] { ArgumentType.Any | ArgumentType.Lazy })
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  InterpreterAction  ]

        public override int Evaluate(Argument[] arguments, RecursiveEval<T> eval,
                                     InterpreterContext<T> context)
        { return arguments.Length; }

        #endregion

    }

//==<<  EvaluateAction  >>=====================================================

    internal class EvaluateAction<T> : InterpreterAction<T, T>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public EvaluateAction()
            : base("Eval", Tuple.Create(1, 1), new[] { ArgumentType.Tree })
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  InterpreterAction  ]

        public override T Evaluate(Argument[] arguments, RecursiveEval<T> eval,
                                   InterpreterContext<T> context)
        { return eval(arguments[0].Data as Tree<Symbol>, context); }

        #endregion

    }

//==<<  FailAction  >>========================================================

    internal class FailAction<T> : GenericAction<T>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public FailAction()
            : base("Fail", Tuple.Create(0, 0), new ArgumentType[0])
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  GenericAction  ]

        public override ArgumentType InferReturnType(ArgumentType expected, ArgumentType[] actual)
        { return expected; }

        public override object Invoke(Argument[] arguments, RecursiveEval<T> eval, InterpreterContext<T> context)
        { return null; }

        #endregion

    }

//==<<  SimpleAction  >>=======================================================

    internal class SimpleAction<T> : InterpreterAction<T, T>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public SimpleAction()
            : base("Simple", Tuple.Create(1, 1), new[] { ArgumentType.Tree })
        { }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  InterpreterAction  ]

        public override T Evaluate(Argument[] arguments, RecursiveEval<T> eval,
                                   InterpreterContext<T> context)
        {
            var val = arguments[0].Data as Tree<Symbol>;
            if ((val.Children.Count != 1) || (val.Children[0].Value.Type != SymbolType.Nonterminal))
                return null;

            return eval(val.Children[0], context);
        }

        #endregion

    }

//==<<  TraceAction  >>========================================================

    internal class TraceAction<T> : GenericAction<T>
        where T : class
    {
        //--[  Private fields  ]-----------------------------------------------

        private TextWriter writer;

        //--[  Constructors  ]-------------------------------------------------

        public TraceAction()
            : this(null)
        { }

        public TraceAction(TextWriter writer)
            : base("Trace", Tuple.Create(2, int.MaxValue),
              new[] { ArgumentType.Any | ArgumentType.Lazy, ArgumentType.String, ArgumentType.Any })
        { this.writer = writer; }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  GenericAction  ]

        public override ArgumentType InferReturnType(ArgumentType expected, ArgumentType[] actual)
        { return actual[0] & expected; }

        public override object Invoke(Argument[] arguments, RecursiveEval<T> eval,
                                      InterpreterContext<T> context)
        {
            var value = arguments[0].Value; // forces evaluation
            var msgc = string.Format(arguments[1].Value.ToString(), arguments.Skip(2).Select(x => x.Value.ToString()).ToArray());
            var msg  = string.Format("{0} <ret {1}>", msgc, value == null ? "null" : "value");

            context.LogEntryEx("TRACE", msg);
            if (writer != null) writer.Write(msg);

            return value;
        }

        #endregion

    }


}