Value evaluate(Value x, Value y)
{
if (y.Type == Value.ValueType.Complex && x.Type != Value.ValueType.Complex)
{
x = new Complex(x.Number);
}
if (y.Type == Value.ValueType.Big && x.Type != Value.ValueType.Big)
{
x = new Big(x.Number);
}
if (x.Type == Value.ValueType.Case && y.Type != Value.ValueType.Case)
{
var _case = (Case)x;
y = new Case(_case.Value, y, false, _case.Required, _case.Condition);
}
switch (x.Type)
{
case Value.ValueType.Date:
case Value.ValueType.Rational:
case Value.ValueType.Complex:
case Value.ValueType.Big:
case Value.ValueType.Case:
case Value.ValueType.Object:
case Value.ValueType.Set:
return(MessagingState.SendMessage(x, Message, new Arguments(y)));
default:
return((x.IsArray || y.IsArray) && UseArrayVersion?evaluateArray(x, y) : Evaluate(x, y));
}
}
public override Value Evaluate()
{
var stack = State.Stack;
var target = stack.Pop(true, LOCATION, false);
var subject = stack.Pop(false, LOCATION);
switch (target.Type)
{
case ValueType.Object:
case ValueType.Class:
case ValueType.Tuple:
case ValueType.MessagePath:
return(SendMessage(target, "apply", subject));
}
var arguments = new Arguments();
if (subject.IsVariable)
{
var variable = (Variable)subject;
arguments.ApplyVariable = variable;
arguments.ApplyValue = variable.Value;
}
else
{
arguments.ApplyVariable = null;
arguments.ApplyValue = subject;
}
return(MessagingState.SendMessage(target, "apply", arguments));
}
protected Value evaluate(Value x, Value y)
{
x = y.Type switch
{
Value.ValueType.Complex when x.Type != Value.ValueType.Complex => new Complex(x.Number),
Value.ValueType.Big when x.Type != Value.ValueType.Big => new Big(x.Number),
_ => x
};
if (x.Type == Value.ValueType.Case && y.Type != Value.ValueType.Case)
{
var _case = (Case)x;
y = new Case(_case.Value, y, false, _case.Required, _case.Condition);
}
return(x.Type switch
{
Value.ValueType.Date => MessagingState.SendMessage(x, Message, new Arguments(y)),
Value.ValueType.Rational => MessagingState.SendMessage(x, Message, new Arguments(y)),
Value.ValueType.Complex => MessagingState.SendMessage(x, Message, new Arguments(y)),
Value.ValueType.Big => MessagingState.SendMessage(x, Message, new Arguments(y)),
Value.ValueType.Case => MessagingState.SendMessage(x, Message, new Arguments(y)),
Value.ValueType.Object => MessagingState.SendMessage(x, Message, new Arguments(y)),
Value.ValueType.Set => MessagingState.SendMessage(x, Message, new Arguments(y)),
_ => (x.IsArray || y.IsArray) && UseArrayVersion?evaluateArray(x, y) : Evaluate(x, y)
});
public override Value Evaluate()
{
var cls = Regions["class"];
Reject(cls.IsEmpty, LOCATION, $"{message} message called out of class");
arguments.FromSelf = true;
return(MessagingState.Send(cls, message, arguments));
}
public override Value Evaluate()
{
var self = RegionManager.Regions["self"];
RejectNull(self, LOCATION, "Self not set");
arguments.FromSelf = true;
return(MessagingState.Send(self, message, arguments));
}
public override Value Evaluate()
{
var cls = Regions["class"];
cls.IsEmpty.Must().Not.BeTrue().OrThrow(LOCATION, () => $"{message} message called out of class");
arguments.FromSelf = true;
return(MessagingState.Send(cls, message, arguments));
}
public override Value Evaluate()
{
var stack = State.Stack;
var source = stack.Pop(true, LOCATION, false);
var target = stack.Pop(false, LOCATION);
var arguments = GuaranteedExecutable(source);
return(MessagingState.SendMessage(target, "map", arguments));
}
public override Value Evaluate()
{
var stack = State.Stack;
var executable = stack.Pop(true, LOCATION);
var target = stack.Pop(true, LOCATION);
var arguments = GuaranteedExecutable(executable);
return(MessagingState.SendMessage(target, "group", arguments));
}
public override Value Evaluate()
{
var self = RegionManager.Regions["self"];
self.Must().Not.BeNull().OrThrow(LOCATION, () => "Self not set");
arguments.FromSelf = true;
return(MessagingState.Send(self, message, arguments));
}
public override Value Evaluate()
{
var stack = State.Stack;
var value = stack.Pop(true, LOCATION);
var target = stack.Pop(true, LOCATION);
var arguments = FromValue(value, false);
return(MessagingState.SendMessage(target, "skip", arguments));
}
public override Value Evaluate()
{
var stack = State.Stack;
var value = stack.Pop(true, LOCATION);
var target = stack.Pop(true, LOCATION);
var arguments = PipelineSource(value);
return(MessagingState.SendMessage(target, Message, arguments));
}
public override Value Evaluate()
{
var stack = State.Stack;
var y = stack.Pop(true, LOCATION, false);
var x = stack.Pop(true, LOCATION);
var arguments = PipelineSource(y);
return(MessagingState.SendMessage(x, "if", arguments));
}
static bool can(Value value, Value message)
{
switch (message.Type)
{
case Value.ValueType.Array:
return(((Array)message).All(i => can(value, i.Value)));
default:
return(MessagingState.RespondsTo(value, message.Text));
}
}
public override Value Evaluate(Value x, Value y)
{
var generator = x.PossibleIndexGenerator();
var arguments = new Arguments(y);
return(generator.FlatMap(g =>
{
var list = new GeneratorList();
list.Add(g);
return MessagingState.SendMessage(list, "concat", arguments);
}, () => MessagingState.SendMessage(x, "concat", arguments)));
}
Value evaluate(Variable variable, Value value)
{
switch (variable.Type)
{
case Value.ValueType.Big:
case Value.ValueType.Object:
return(MessagingState.SendMessage(variable.Value, Message, new Arguments(value)));
default:
return(Execute(variable, value));
}
}
public override Value Evaluate()
{
var stack = State.Stack;
var operatorValue = stack.Pop(true, LOCATION);
var value = stack.Pop(true, LOCATION).Self;
if (operatorValue is Lambda lambda)
{
return(MessagingState.SendMessage(value, "foldr", FromValue(lambda)));
}
throw LOCATION.ThrowsWithLocation(() => "Expected lambda");
}
public override Verb CreateVerb(string[] tokens)
{
var message = tokens[2];
Color(position, tokens[1].Length, Structures);
Color(message.Length, Messaging);
Block actualArguments;
Block executable = null;
Parameters parameters = null;
var index = position + length;
var bracket = tokens[3];
Lambda lambda = null;
if (bracket == "(")
{
Color(1, Structures);
if (GetExpression(source, index, CloseParenthesis()).If(out actualArguments, out var newIndex))
{
index = newIndex;
}
else
{
actualArguments = new Block();
}
}
else
{
actualArguments = new Block();
}
if (blockOrLambdaParser.Scan(source, index))
{
overridePosition = blockOrLambdaParser.Result.Position;
if (blockOrLambdaParser.Result.Verb is IExecutable e)
{
parameters = e.Parameters;
executable = e.Action;
MessagingState.RegisterMessageCall(message);
var arguments = new Arguments(actualArguments, executable, parameters);
if (lambda != null)
{
arguments.AddArgument(lambda);
}
result.Value = new Message(message, arguments);
}
}
return(new NullOp());
}
public override Value Evaluate()
{
var stack = State.Stack;
var operatorValue = stack.Pop(true, LOCATION);
var value = stack.Pop(true, LOCATION).Self;
if (operatorValue is Lambda lambda)
{
return(MessagingState.SendMessage(value, "foldr", FromValue(lambda)));
}
Throw(LOCATION, "Expected lambda");
return(null);
}
public override Value Evaluate()
{
var stack = State.Stack;
var code = stack.Pop(true, LOCATION, false);
var arrayValue = stack.Pop(true, LOCATION);
if (arrayValue.IsArray)
{
var array = (Array)arrayValue.SourceArray;
Arguments arguments;
switch (code)
{
case Lambda lambda:
arguments = new Arguments(new NullBlock(), lambda.Block, lambda.Parameters);
return(MessagingState.SendMessage(array, MESSAGE_NAME, arguments));
case Block block:
arguments = new Arguments(new NullBlock(), block, new NullParameters());
return(MessagingState.SendMessage(array, MESSAGE_NAME, arguments));
case IStringify _:
var stringifyBlock = new Block {
new Push(code)
};
arguments = new Arguments(new NullBlock(), stringifyBlock, new NullParameters());
return(MessagingState.SendMessage(array, MESSAGE_NAME, arguments));
case Values.Format format:
var formatBlock = new Block {
new Push(format.Stringify.String)
};
arguments = new Arguments(new NullBlock(), formatBlock, format.Parameters);
return(MessagingState.SendMessage(array, MESSAGE_NAME, arguments));
default:
return(arrayValue);
}
}
return(arrayValue);
}
public override Value Evaluate()
{
var stack = State.Stack;
var format = stack.Pop(true, LOCATION);
var value = stack.Pop(true, LOCATION, false);
switch (value.Type)
{
case ValueType.Object:
case ValueType.Rational:
return(SendMessage(value, "fmt", format));
}
if (format.IsArray)
{
return(MessagingState.SendMessage(value, "format", new Arguments(format.SourceArray)));
}
var matcher = new Matcher();
var input = format.Text;
if (matcher.IsMatch(input, REGEX_FORMAT))
{
var formatter = new Formatter(matcher.FirstGroup, matcher.SecondGroup, matcher.ThirdGroup);
return(formatter.Format(value.Text));
}
switch (value.Type)
{
case ValueType.Number:
return(value.Number.ToString(input));
case ValueType.Date:
return(((Date)value).DateTime.ToString(input));
}
var formatString = "{0:\"" + input + "\"}";
return(string.Format(formatString, ConvertToObject(value.Text, input.EndsWith("x}"))));
}
public override Value Evaluate()
{
var stack = State.Stack;
var value = stack.Pop(false, LOCATION);
arguments.FromSelf = arguments.FromSelf;
if (value is Variable variable && variable.Name == "super" && variable.Value is Class super)
{
return(SendSuperMessage(super, message, arguments));
}
if (registerCall)
{
MessagingState.RegisterMessageCall(message);
}
value = value.Resolve();
var responds = MessagingState.RespondsTo(value, message);
if (optional && !responds)
{
return(new Nil());
}
if (!optional && !responds)
{
message = GetterName(message);
responds = MessagingState.RespondsTo(value, message);
if (optional && !responds)
{
return(new Nil());
}
}
Assert(optional || responds, LOCATION, () => $"{value} doesn't understand {Unmangle(message)} message");
var result = MessagingState.SendMessage(value, message, arguments);
if (result is ObjectVariable objectVariable && objectVariable.Value is Class cls)
{
return(SendMessage(cls, "invoke", arguments));
}
if (optional)
{
if (result is ObjectVariable innerValue)
{
if (innerValue.Value is Some some)
{
return(some.Value());
}
if (innerValue.Value is None)
{
return(None.NoneValue);
}
return(innerValue.Value);
}
}
if (value is Variable variable1 && inPlace)
{
Reject(variable1.Name.StartsWith(VAR_ANONYMOUS), LOCATION, "Can't reassign to an anonymous variable");
variable1.Value = result;
}
return(result);
}
public static Value GetSuccessor(Value value) => MessagingState.SendMessage(value, "succ", new Arguments());
public override Value Evaluate()
{
var value = State.Stack.Pop(true, "Sequence");
return(value is Object obj ? new ObjectSequence(obj) : MessagingState.SendMessage(value, "seq", new Arguments()));
}
public override Verb CreateVerb(string[] tokens)
{
var whitespace = tokens[1];
Color(position, whitespace.Length, Whitespaces);
var type = tokens[2];
Color(type.Length, Structures);
var message = tokens[3];
var star = tokens[4];
if (star == "*")
{
message += "-" + CompilerState.ObjectID();
}
Color(message.Length, Messaging);
Color(star.Length, Operators);
Color(1, Structures);
Block actualArguments;
Block executable = null;
Parameters parameters = null;
var index = NextPosition;
var bracket = tokens[5];
Lambda lambda = null;
int newIndex;
if (bracket == "(")
{
Color(1, Structures);
if (GetExpression(source, index, CloseParenthesis()).If(out actualArguments, out newIndex))
{
index = newIndex;
}
else
{
actualArguments = new Block();
}
}
else
{
actualArguments = new Block();
}
var splatting = false;
if (useBlockOrLambda && getBlock(blockOrLambdaParser, index).If(out parameters, out executable, out splatting, out newIndex))
{
index = newIndex;
}
if (executable != null)
{
lambda = new Lambda(new Region(), executable, new Parameters(), false);
}
if (extraMessageWordParser.Parse(source, index).If(out newIndex, out var word, out var wordLambda))
{
message += word;
executable = wordLambda.Block;
parameters = wordLambda.Parameters;
index = newIndex;
}
overridePosition = index;
MessagingState.RegisterMessageCall(message);
var arguments = new Arguments(actualArguments, executable, parameters)
{
Splatting = splatting
};
result.Value = lambda;
return(getVerb(type, message, arguments, index));
}
public Value Random()
{
var array = AlternateValue("rand");
return(MessagingState.SendMessage(array, "sample", new Arguments()));
}
public static Value DefaultSendMessage(Value value, string messageName, Arguments arguments, out bool handled)
{
handled = true;
InterpolatedString interpolated;
double number;
switch (messageName)
{
case "print":
print(value.Text, arguments);
return(null);
case "put":
put(value.Text, arguments);
return(null);
case "date":
return(new Date(value));
case "but":
return(elseMessage(value, arguments));
case "kind":
return(new TypeName(value.Type.ToString()));
case "match":
var match = new Match(value);
return(match.Evaluate(arguments.Executable));
case "str":
{
return(value is Object obj && obj.RespondsNoDefault("str") ? Runtime.SendMessage(obj, "str", arguments) : value.Text);
}
case "num":
return(value.Number);
case "id":
return(value.ID);
case "dup":
return(value.Clone());
case "write":
write(value.Text, arguments);
return(null);
case "newMessage":
value.RegisterMessages();
if (arguments[0] is Values.Message message)
{
value.RegisterUserMessage(message);
return(value);
}
return(new Nil());
case "cmp":
{
return(value is Object obj && obj.RespondsNoDefault("cmp") ? Runtime.SendMessage(obj, "cmp", arguments) :
value.Compare(arguments[0]));
}
case "isResp":
return(MessagingState.RespondsTo(value, arguments[0].Text));
case "isEmpty":
return(value.IsEmpty);
case "fmt":
var source = arguments[0].Text;
var formatter = Formatter.Parse(source);
return(formatter.Format(value.Text));
case "return":
value = value.Resolve();
interpolated = value as InterpolatedString;
if (interpolated != null)
{
value = interpolated.String;
}
State.ReturnValue = value;
State.ReturnSignal = true;
return(State.ReturnValue);
case "result":
value = value.Resolve();
interpolated = value as InterpolatedString;
if (interpolated != null)
{
value = interpolated.String;
}
State.ResultValue = value;
return(value);
case "squote":
return(value.Text.SingleQuotify("`'"));
case "dquote":
return(value.Text.Quotify("`\""));
case "rep":
return(value.Resolve().ToString());
case "isNum":
return(value.IsNumeric() ? value.Number : value);
case "exit":
if (value.IsTrue)
{
State.ExitSignal = true;
}
return(null);
case "after":
State.LateBlock = arguments.Executable;
return(value);
case "give":
State.Give(value);
return(value);
case "with":
return(with(value, arguments));
case "alt":
return(value.AlternateValue("alt"));
case "for":
handled = false;
return(forLoop(value, arguments, out handled));
case "json":
return(value.Text);
case "send":
var argClone = arguments.Clone();
messageName = argClone.Shift().Text;
return(MessagingState.SendMessage(value, messageName, argClone));
case "assert":
if (!value.IsTrue)
{
var errorMessage = arguments[0].Text;
if (errorMessage.IsEmpty())
{
errorMessage = "Assertion failed";
}
throw new ApplicationException(errorMessage);
}
return(null);
case "freeze":
freeze(value, arguments);
return(value);
case "thaw":
return(thaw(value));
case "isVal":
return(arguments.IsArray() ? arguments.AsArray().ContainsValue(value) : arguments[0].Text.Has(value.Text,
true));
case "isKey":
return(arguments.IsArray() && arguments.AsArray().ContainsKey(value.Text));
case "can":
return(can(value, arguments));
case "isInt":
number = value.Number;
return(number == Math.Truncate(number));
case "isFloat":
number = value.Number;
return(number != Math.Truncate(number));
case "isArr":
return(value.IsArray);
case "isInv":
return(invokeable(value));
case "isTrue":
return(value.IsTrue);
case "isIter":
return(value.ProvidesGenerator);
case "tap":
return(tap(value, arguments));
case "isFailure":
return(value.Type == Value.ValueType.Failure);
}
handled = false;
return(null);
}
public override Verb CreateVerb(string[] tokens)
{
var whitespace = tokens[1];
Color(position, whitespace.Length, Whitespaces);
var type = tokens[2];
Color(type.Length, Structures);
var message = tokens[3];
Color(message.Length, Messaging);
Block actualArguments;
Block executable = null;
Parameters parameters = null;
var index = position + length;
var bracket = tokens[4];
Lambda lambda = null;
if (bracket == "(")
{
Color(1, Structures);
int newIndex;
if (GetExpression(source, index, "").Assign(out actualArguments, out newIndex))
{
index = newIndex;
}
else
{
actualArguments = new Block();
}
}
else
{
actualArguments = new Block();
}
if (lambdaParser.Scan(source, index))
{
var messageClosure = (Lambda)lambdaParser.Result.Value;
parameters = messageClosure.Parameters;
executable = messageClosure.Block;
index = lambdaParser.Result.Position;
}
else if (blockParser.Scan(source, index))
{
executable = (Block)blockParser.Result.Value;
index = blockParser.Result.Position;
}
if (attachedLambdaParser.Scan(source, index))
{
lambda = (Lambda)attachedLambdaParser.Result.Value;
index = attachedLambdaParser.Result.Position;
}
overridePosition = index;
MessagingState.RegisterMessageCall(message);
var arguments = new Arguments(actualArguments, executable, parameters);
if (lambda != null)
{
arguments.AddArgument(lambda);
}
return(new ApplyMessageToDefaultVariable(new Message(message, arguments)));
}
