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 ElaValue GetField(ElaValue index, ExecutionContext ctx)
{
if (vm != null)
{
if (index.TypeId != ElaMachine.STR)
{
ctx.InvalidType(TCF.GetShortForm(ElaTypeCode.String), index);
return(Default());
}
var field = index.DirectGetString();
var frame = vm.Assembly.GetModule(Handle);
ScopeVar sc;
if (!frame.GlobalScope.Locals.TryGetValue(field, out sc))
{
ctx.UnknownField(index.DirectGetString(), new ElaValue(this));
return(Default());
}
if ((sc.Flags & ElaVariableFlags.Private) == ElaVariableFlags.Private)
{
ctx.Fail(new ElaError(ElaRuntimeError.PrivateVariable, field));
return(Default());
}
return(vm.modules[Handle][sc.Address]);
}
ctx.Fail(ElaRuntimeError.Unknown, "VM is non present");
return(Default());
}
internal override ElaValue Quot(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.INT)
{
if (right.TypeId == ElaMachine.LNG)
{
var r = right.Ref.AsLong();
if (r == 0)
{
ctx.DivideByZero(left);
return(Default());
}
return(new ElaValue(left.I4 / r));
}
else
{
ctx.NoOverload(left.GetTypeName() + "->" + left.GetTypeName() + "->*", left.GetTypeName() + "->" + right.GetTypeName() + "->*", "quot");
return(Default());
}
}
if (right.I4 == 0)
{
ctx.DivideByZero(left);
return(Default());
}
return(new ElaValue(left.I4 / right.I4));
}
internal override bool Greater(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.REA)
{
if (right.TypeId == ElaMachine.DBL)
{
return(left.DirectGetSingle() > right.Ref.AsDouble());
}
else if (right.TypeId == ElaMachine.INT)
{
return(left.DirectGetSingle() > right.I4);
}
else if (right.TypeId == ElaMachine.LNG)
{
return(left.DirectGetSingle() > right.Ref.AsLong());
}
else
{
NoOverloadBinary(TCF.SINGLE, right, "greater", ctx);
return(false);
}
}
return(left.DirectGetSingle() > right.DirectGetSingle());
}
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 override ElaValue Divide(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.INT)
{
if (right.TypeId == ElaMachine.LNG)
{
var r = right.Ref.AsLong();
return(new ElaValue((Double)left.I4 / r));
}
else if (right.TypeId == ElaMachine.REA)
{
return(new ElaValue(left.I4 / right.DirectGetSingle()));
}
else if (right.TypeId == ElaMachine.DBL)
{
return(new ElaValue(left.I4 / right.Ref.AsDouble()));
}
else
{
NoOverloadBinary(TCF.INT, right, "divide", ctx);
return(Default());
}
}
return(new ElaValue((Single)left.I4 / right.I4));
}
internal override bool LesserEqual(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.INT)
{
if (right.TypeId == ElaMachine.LNG)
{
return(left.I4 <= right.Ref.AsLong());
}
else if (right.TypeId == ElaMachine.REA)
{
return(left.I4 <= right.DirectGetSingle());
}
else if (right.TypeId == ElaMachine.DBL)
{
return(left.I4 <= right.Ref.AsDouble());
}
else
{
NoOverloadBinary(TCF.INT, right, "lesserequal", ctx);
return(false);
}
}
return(left.I4 <= right.I4);
}
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 override ElaValue Multiply(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.LNG)
{
if (right.TypeId == ElaMachine.INT)
{
return(new ElaValue(left.Ref.AsLong() + right.I4));
}
else if (right.TypeId == ElaMachine.REA)
{
return(new ElaValue(left.Ref.AsLong() + right.DirectGetSingle()));
}
else if (right.TypeId == ElaMachine.DBL)
{
return(new ElaValue(left.Ref.AsLong() + right.Ref.AsDouble()));
}
else
{
NoOverloadBinary(TCF.LONG, right, "multiply", ctx);
return(Default());
}
}
return(new ElaValue(left.Ref.AsLong() * right.Ref.AsLong()));
}
internal CallPoint(int modHandle, EvalStack stack, ElaValue[] locals, FastList<ElaValue[]> captures)
{
ModuleHandle = modHandle;
Locals = locals;
Captures = captures;
Stack = stack;
}
internal override ElaValue Remainder(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, "remainder", ctx);
return(Default());
}
}
if (right.DirectGetSingle() == 0)
{
ctx.DivideByZero(left);
return(Default());
}
return(new ElaValue(left.DirectGetSingle() % right.DirectGetSingle()));
}
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());
}
public ElaValue AsString(ElaValue val)
{
if (val.TypeId > SysConst.MAX_TYP)
{
var tid = val.TypeId;
var sb = new StringBuilder();
var usb = val.Ref as ElaUserType2;
var xs = new List <String>();
while (usb != null)
{
xs.Add(usb.Value2.DirectGetString());
var td = usb.Value1.Ref;
if (td.TypeId == tid)
{
usb = td as ElaUserType2;
}
else
{
usb = null;
xs.Add(td.ToString());
}
}
for (var i = xs.Count - 1; i > -1; i--)
{
sb.Append(xs[i]);
}
return(new ElaValue(sb.ToString()));
}
return(new ElaValue(val.AsString()));
}
internal override ElaValue Subtract(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.DBL)
{
if (right.TypeId == ElaMachine.REA)
{
return(new ElaValue(left.Ref.AsDouble() - right.DirectGetSingle()));
}
else if (right.TypeId == ElaMachine.INT)
{
return(new ElaValue(left.Ref.AsDouble() - right.I4));
}
else if (right.TypeId == ElaMachine.LNG)
{
return(new ElaValue(left.Ref.AsDouble() - right.Ref.AsLong()));
}
else
{
NoOverloadBinary(TCF.DOUBLE, right, "subtract", ctx);
return(Default());
}
}
return(new ElaValue(left.Ref.AsDouble() - right.Ref.AsDouble()));
}
internal override ElaValue Modulus(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.REA)
{
if (right.TypeId == ElaMachine.DBL)
{
return(DoubleInstance.Modulus(left.DirectGetSingle(), right.Ref.AsDouble(), ctx));
}
else if (right.TypeId == ElaMachine.INT)
{
return(Modulus(left.DirectGetSingle(), right.I4, ctx));
}
else if (right.TypeId == ElaMachine.LNG)
{
return(Modulus(left.DirectGetSingle(), right.Ref.AsLong(), ctx));
}
else
{
NoOverloadBinary(TCF.SINGLE, right, "modulus", ctx);
return(Default());
}
}
return(Modulus(left.DirectGetSingle(), right.DirectGetSingle(), ctx));
}
internal override ElaValue Power(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.REA)
{
if (right.TypeId == ElaMachine.DBL)
{
return(new ElaValue(Math.Pow(left.DirectGetSingle(), right.Ref.AsDouble())));
}
else if (right.TypeId == ElaMachine.INT)
{
return(new ElaValue((Single)Math.Pow(left.DirectGetSingle(), right.I4)));
}
else if (right.TypeId == ElaMachine.LNG)
{
return(new ElaValue((Single)Math.Pow(left.DirectGetSingle(), right.Ref.AsLong())));
}
else
{
NoOverloadBinary(TCF.SINGLE, right, "power", ctx);
return(Default());
}
}
return(new ElaValue(Math.Pow(left.DirectGetSingle(), right.DirectGetSingle())));
}
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();
}
public ElaFun <T1, T2, T3, T4, R> ToDelegate <T1, T2, T3, T4, R>()
{
return((t1, t2, t3, t4) =>
{
var ret = Call(ElaValue.FromObject(t1), ElaValue.FromObject(t2), ElaValue.FromObject(t3), ElaValue.FromObject(t4));
return ret.Convert <R>();
});
}
public ElaFun <T, R> ToDelegate <T, R>()
{
return(t =>
{
var ret = Call(ElaValue.FromObject(t));
return ret.Convert <R>();
});
}
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 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 override bool False(ElaValue @this, ExecutionContext ctx)
{
var ret = Force(ctx);
if (ctx.Failed)
return false;
return ret.Ref.False(ret, ctx);
}
internal override ElaValue Force(ElaValue @this, ExecutionContext ctx)
{
if (ctx == ElaObject.DummyContext)
{
return(Force());
}
return(Force(ctx));
}
public ElaFun <T1, T2, T3, T4, T5, T6, T7, T8, R> ToDelegate <T1, T2, T3, T4, T5, T6, T7, T8, R>()
{
return((t1, t2, t3, t4, t5, t6, t7, t8) =>
{
var ret = Call(ElaValue.FromObject(t1), ElaValue.FromObject(t2), ElaValue.FromObject(t3), ElaValue.FromObject(t4),
ElaValue.FromObject(t5), ElaValue.FromObject(t6), ElaValue.FromObject(t7), ElaValue.FromObject(t8));
return ret.Convert <R>();
});
}
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 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 ElaValue ShiftLeft(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.INT)
{
NoOverloadBinary(TCF.LONG, right, "shiftleft", ctx);
return(Default());
}
return(new ElaValue(left.Ref.AsLong() << right.I4));
}
internal override bool Equal(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.BYT)
{
NoOverloadBinary(TCF.BOOL, right, "equal", 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 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.STR)
{
NoOverloadBinary(TCF.STRING, right, "notequal", ctx);
return(false);
}
return(left.DirectGetString() != right.DirectGetString());
}
internal override ElaValue ShiftRight(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.INT)
{
NoOverloadBinary(TCF.INT, right, "shiftright", ctx);
return(Default());
}
return(new ElaValue(left.I4 >> right.I4));
}
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 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 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 LesserEqual(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.STR)
{
NoOverloadBinary(TCF.STRING, right, "lesserequal", ctx);
return(false);
}
return(left.DirectGetString().CompareTo(right.DirectGetString()) >= 0);
}
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 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.UNI)
{
NoOverloadBinary(TCF.UNIT, right, "notequal", ctx);
return(false);
}
return(left.Ref == right.Ref);
}
internal override bool False(ElaValue @this, ExecutionContext ctx)
{
var ret = Force(ctx);
if (ctx.Failed)
{
return(false);
}
return(ret.Ref.False(ret, ctx));
}
internal virtual string Show(ElaValue value, ExecutionContext ctx)
{
if (show != null)
{
ctx.SetDeffered(show, 1);
return(String.Empty);
}
ctx.NoOverload(value.GetTypeName(), "show");
return(String.Empty);
}
internal virtual bool IsNil(ElaValue left, ExecutionContext ctx)
{
if (isnil != null)
{
ctx.SetDeffered(isnil, 1);
return(false);
}
ctx.NoOverload(left.GetTypeName(), "isnil");
return(false);
}
internal virtual ElaValue Tail(ElaValue left, ExecutionContext ctx)
{
if (tail != null)
{
ctx.SetDeffered(tail, 1);
return(Default());
}
ctx.NoOverload(left.GetTypeName(), "tail");
return(Default());
}
internal virtual ElaValue Head(ElaValue left, ExecutionContext ctx)
{
if (head != null)
{
ctx.SetDeffered(head, 1);
return(Default());
}
ctx.NoOverload(left.GetTypeName(), "head");
return(Default());
}
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());
}
internal override ElaValue Concatenate(ElaValue left, ElaValue right, ExecutionContext ctx)
{
left = left.Ref.Force(left, ctx);
right = right.Ref.Force(right, ctx);
if (right.TypeId != ElaMachine.REC)
{
NoOverloadBinary(TCF.RECORD, right, "concatenate", ctx);
return Default();
}
return new ElaValue(ElaRecord.Concat((ElaRecord)left.Ref, (ElaRecord)right.Ref));
}
internal override bool NotEqual(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.FUN)
{
NoOverloadBinary(TCF.FUN, right, "notequal", ctx);
return false;
}
var f1 = (ElaFunction)left.Ref;
var f2 = (ElaFunction)left.Ref;
return f1.Handle != f2.Handle || f1.ModuleHandle != f2.ModuleHandle ||
f1.AppliedParameters != f2.AppliedParameters || f1.AppliedParameters != 0;
}
internal override ElaValue BitwiseXor(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.LNG)
{
if (right.TypeId == ElaMachine.INT)
return new ElaValue(left.Ref.AsLong() ^ right.I4);
else
{
NoOverloadBinary(TCF.LONG, right, "bitwisexor", ctx);
return Default();
}
}
return new ElaValue(left.Ref.AsLong() ^ right.Ref.AsLong());
}
internal override ElaValue Concatenate(ElaValue left, ElaValue right, ExecutionContext ctx)
{
right = right.Ref.Force(right, ctx);
if (right.TypeId != ElaMachine.STR)
{
if (right.TypeId == ElaMachine.CHR)
return new ElaValue(left.DirectGetString() + right.ToString());
NoOverloadBinary(TCF.STRING, right, "concatenate", ctx);
return Default();
}
return new ElaValue(left.DirectGetString() + right.DirectGetString());
}
internal override ElaValue GetValue(ElaValue value, ElaValue key, ExecutionContext ctx)
{
if (key.TypeId != ElaMachine.INT)
{
ctx.InvalidIndexType(key);
return Default();
}
var tup = (ElaTuple)value.Ref;
if (key.I4 < tup.Length && key.I4 > -1)
return tup.Values[key.I4];
ctx.IndexOutOfRange(key, value);
return Default();
}
internal override ElaValue BitwiseOr(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.LNG)
{
if (right.TypeId == ElaMachine.INT)
{
var lo = (Int64)right.I4;
return new ElaValue(left.Ref.AsLong() | lo);
}
else
{
NoOverloadBinary(TCF.LONG, right, "bitwiseor", ctx);
return Default();
}
}
return new ElaValue(left.Ref.AsLong() | right.Ref.AsLong());
}
internal override bool Greater(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.REA)
{
if (right.TypeId == ElaMachine.DBL)
return left.DirectGetSingle() > right.Ref.AsDouble();
else if (right.TypeId == ElaMachine.INT)
return left.DirectGetSingle() > right.I4;
else if (right.TypeId == ElaMachine.LNG)
return left.DirectGetSingle() > right.Ref.AsLong();
else
{
NoOverloadBinary(TCF.SINGLE, right, "greater", ctx);
return false;
}
}
return left.DirectGetSingle() > right.DirectGetSingle();
}
internal override ElaValue Add(ElaValue left, ElaValue right, ExecutionContext ctx)
{
if (right.TypeId != ElaMachine.LNG)
{
if (right.TypeId == ElaMachine.INT)
return new ElaValue(left.Ref.AsLong() + right.I4);
else if (right.TypeId == ElaMachine.REA)
return new ElaValue(left.Ref.AsLong() + right.DirectGetSingle());
else if (right.TypeId == ElaMachine.DBL)
return new ElaValue(left.Ref.AsLong() + right.Ref.AsDouble());
else
{
NoOverloadBinary(TCF.LONG, right, "add", ctx);
return Default();
}
}
return new ElaValue(left.Ref.AsLong() + right.Ref.AsLong());
}
public bool Contains(ElaValue key, ElaMutableMap map)
{
return map.Map.ContainsKey(key);
}
public ElaMap Remove(ElaValue key, ElaMap map)
{
return map.Remove(key);
}
