public ElaRecord AddField(string field, ElaValue value, ElaRecord rec)
 {
     var fieldList = new List<ElaRecordField>();
     fieldList.AddRange(rec);
     fieldList.Add(new ElaRecordField(field, value));
     return new ElaRecord(fieldList.ToArray());
 }

 internal CallPoint(int modHandle, EvalStack stack, ElaValue[] locals, FastList<ElaValue[]> captures)
 {
     ModuleHandle = modHandle;
     Locals = locals;
     Captures = captures;
     Stack = stack;
 }

        internal override ElaValue Divide(ElaValue left, ElaValue right, ExecutionContext ctx)
        {
            if (right.TypeId != ElaMachine.REA)
            {
                if (right.TypeId == ElaMachine.DBL)
                    return new ElaValue(left.DirectGetSingle() / right.Ref.AsDouble());
                else if (right.TypeId == ElaMachine.INT)
                    return new ElaValue(left.DirectGetSingle() / right.I4);
                else if (right.TypeId == ElaMachine.LNG)
                    return new ElaValue(left.DirectGetSingle() / right.Ref.AsLong());
                else
                {
                    NoOverloadBinary(TCF.SINGLE, right, "divide", ctx);
                    return Default();
                }
            }

            if (right.DirectGetSingle() == 0)
            {
                ctx.DivideByZero(left);
                return Default();
            }

            return new ElaValue(left.DirectGetSingle() / right.DirectGetSingle());
        }

        internal ElaValue Force()
        {
            if (Value.Ref == null)
            {
                var fun = Function;

                while (fun != null)
                {
                    Value = fun.CallWithThrow(
                        fun.LastParameter.Ref != null ? fun.LastParameter :
                        new ElaValue(ElaUnit.Instance));

                    if (Value.Ref is ElaLazy)
                    {
                        var la = (ElaLazy)Value.Ref;

                        if (la.Value.Ref == null && la.Function != null)
                            fun = la.Function;
                        else
                        {
                            Value = la.Value;
                            fun = null;
                        }
                    }
                    else
                        fun = null;
                }
            }

            return Value;
        }

        internal override ElaValue Quot(ElaValue left, ElaValue right, ExecutionContext ctx)
        {
            if (right.TypeId != ElaMachine.LNG)
            {
                if (right.TypeId == ElaMachine.INT)
                {
                    if (right.I4 == 0)
                    {
                        ctx.DivideByZero(left);
                        return Default();
                    }

                    return new ElaValue(left.Ref.AsLong() / right.I4);
                }
                else
                {
                    ctx.NoOverload(left.GetTypeName() + "->" + left.GetTypeName() + "->*", left.GetTypeName() + "->" + right.GetTypeName() + "->*", "quot");
                    return Default();
                }
            }

            var r = right.Ref.AsLong();

            if (r == 0)
            {
                ctx.DivideByZero(left);
                return Default();
            }

            return new ElaValue(left.Ref.AsLong() / right.Ref.AsLong());
        }

 internal AvlTree(ElaValue key, ElaValue value, AvlTree left, AvlTree right)
 {
     Key = key;
     Value = value;
     Left = left;
     Right = right;
     TreeHeight = 1 + Math.Max(Height(left), Height(right));
 }

        public ElaVariant GetValue(ElaValue key, ElaMap map)
        {
            if (map.Tree.IsEmpty)
                return ElaVariant.None();

            var res = map.Tree.Search(key);
            return res.IsEmpty ? ElaVariant.None() : ElaVariant.Some(res.Value);
        }

        protected override ElaValue Convert(ElaValue @this, ElaTypeInfo type, ExecutionContext ctx)
        {
            if (type.ReflectedTypeCode == ElaTypeCode.String)
                return new ElaValue(Value.ToString());

            ctx.ConversionFailed(@this, type.ReflectedTypeName);
            return Default();
        }

        internal override bool False(ElaValue @this, ExecutionContext ctx)
        {
            var ret = Force(ctx);

            if (ctx.Failed)
                return false;

            return ret.Ref.False(ret, ctx);
        }

        public ElaVariant Get(ElaValue key, ElaMutableMap map)
        {
            var val = default(ElaValue);

            if (!map.Map.TryGetValue(key, out val))
                return ElaVariant.None();

            return ElaVariant.Some(val);
        }

        internal override bool Lesser(ElaValue left, ElaValue right, ExecutionContext ctx)
        {
            if (right.TypeId != ElaMachine.STR)
            {
                NoOverloadBinary(TCF.STRING, right, "lesser", ctx);
                return false;
            }

            return left.DirectGetString().CompareTo(right.DirectGetString()) > 0;
        }

        internal override bool Equal(ElaValue left, ElaValue right, ExecutionContext ctx)
        {
            if (right.TypeId != ElaMachine.STR)
            {
                NoOverloadBinary(TCF.STRING, right, "equal", ctx);
                return false;
            }

            return left.DirectGetString() == right.DirectGetString();
        }

        internal override bool Equal(ElaValue left, ElaValue right, ExecutionContext ctx)
        {
            if (right.TypeId != ElaMachine.UNI)
            {
                NoOverloadBinary(TCF.UNIT, right, "equal", ctx);
                return false;
            }

            return left.Ref == right.Ref;
        }

        internal override bool LesserEqual(ElaValue left, ElaValue right, ExecutionContext ctx)
        {
            if (right.TypeId != ElaMachine.CHR)
            {
                NoOverloadBinary(TCF.CHAR, right, "lesserequal", ctx);
                return false;
            }

            return left.I4 <= right.I4;
        }

        internal override bool Greater(ElaValue left, ElaValue right, ExecutionContext ctx)
        {
            if (right.TypeId != ElaMachine.CHR)
            {
                NoOverloadBinary(TCF.CHAR, right, "greater", ctx);
                return false;
            }

            return left.I4 > right.I4;
        }

        internal override bool NotEqual(ElaValue left, ElaValue right, ExecutionContext ctx)
        {
            if (right.TypeId != ElaMachine.MOD)
            {
                NoOverloadBinary(TCF.MOD, right, "notequal", ctx);
                return false;
            }

            return ((ElaModule)left.Ref).Handle != ((ElaModule)right.Ref).Handle;
        }

        internal override bool NotEqual(ElaValue left, ElaValue right, ExecutionContext ctx)
        {
            if (right.TypeId != ElaMachine.BYT)
            {
                NoOverloadBinary(TCF.BOOL, right, "notequal", ctx);
                return false;
            }

            return left.I4 != right.I4;
        }

        internal virtual AvlTree Add(ElaValue key, ElaValue value)
        {
            var result = default(AvlTree);

            if (key.CompareTo(Key) > 0)
                result = new AvlTree(Key, Value, Left, Right.Add(key, value));
            else
                result = new AvlTree(Key, Value, Left.Add(key, value), Right);

            return MakeBalanced(result);
        }

        protected override bool NotEqual(ElaValue left, ElaValue right, ExecutionContext ctx)
        {
            var lg = left.As<ElaGuid>();
            var rg = right.As<ElaGuid>();

            if (lg != null && rg != null)
                return lg.Value != rg.Value;
            else if (lg != null)
                return right.NotEqual(left, right, ctx);

            return true;
        }

        public ElaRecord ChangeField(string field, ElaValue value, ElaRecord rec)
        {
            var fieldList = new List<ElaRecordField>();

            foreach (var f in rec)
                if (f.Field == field)
                    fieldList.Add(new ElaRecordField(f.Field, value));
                else
                    fieldList.Add(f);

            return new ElaRecord(fieldList.ToArray());
        }