/// <summary>
/// Determine whether a Grace object is truthy or not.
/// </summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="val">Grace object to test for truthiness</param>
/// <remarks>
/// If the value is the true or false boolean literal, this
/// method returns the appropriate value immediately. If it is
/// an object conforming to the boolean type, this method requests
/// ifTrue ifFalse on the object with suitable blocks and returns
/// the result. If it is neither, an error will be reported.
/// </remarks>
public static bool IsTrue(EvaluationContext ctx, GraceObject val)
{
if (val == True)
{
return(true);
}
if (val == False)
{
return(false);
}
var req = new MethodRequest();
req.AddPart(new RequestPart("ifTrue",
new List <GraceObject> {
_trueBlock
},
RequestPart.EmptyList
)
);
req.AddPart(new RequestPart("ifFalse",
new List <GraceObject> {
_falseBlock
},
RequestPart.EmptyList
)
);
return(val.Request(ctx, req) == True);
}
private GraceObject mIfFalse(EvaluationContext ctx, GraceObject b)
{
if (!Success)
{
return(b.Request(ctx, MethodRequest.Nullary("apply")));
}
return(GraceObject.Done);
}
/// <summary>Native method for Grace do</summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="block">Block to apply for each element</param>
public GraceObject Do(EvaluationContext ctx, GraceObject block)
{
var req = MethodRequest.Single("do", block);
left.Request(ctx, req);
right.Request(ctx, req);
return(GraceObject.Done);
}
/// <summary>Create a failed match</summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="obj">Result value</param>
public static GraceObject FailedMatch(EvaluationContext ctx,
GraceObject obj)
{
var successfulMatchReq = MethodRequest.Single("_FailedMatch",
obj);
GraceObject smRec = ctx.FindReceiver(successfulMatchReq);
return(smRec.Request(ctx, successfulMatchReq));
}
/// <summary>
/// Execute a block of native code for each element
/// of an iterable.
/// </summary>
/// <param name="ctx">Interpreter to use</param>
/// <param name="iterable">Iterable to loop over</param>
/// <param name="block">
/// Block of code to execute.
/// </param>
public static void ForEach(
EvaluationContext ctx,
GraceObject iterable,
GraceObject block
)
{
var req = MethodRequest.Single("do", block);
iterable.Request(ctx, req);
}
/// <summary>Native method for Grace refine</summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="name">Name of the sub-exception</param>
public GraceObject Refine(EvaluationContext ctx, GraceObject name)
{
var asGraceString = name.Request(ctx,
MethodRequest.Nullary("asString"))
.FindNativeParent <GraceString>();
var nameStr = asGraceString.Value;
AddDescendant(nameStr);
return(new GraceExceptionKind(this, nameStr));
}
/// <summary>Native method for Grace do</summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="block">Block to apply for each element</param>
public GraceObject Do(EvaluationContext ctx, GraceObject block)
{
var req = MethodRequest.Single("apply", null);
foreach (var o in elements)
{
req[0].Arguments[0] = o;
block.Request(ctx, req);
}
return(GraceObject.Done);
}
/// <summary>Native method for Grace raise</summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="message">Message string</param>
public GraceObject Raise(EvaluationContext ctx, GraceObject message)
{
var msg = "<<No message>>";
var asGraceString = message.Request(ctx,
MethodRequest.Nullary("asString"))
.FindNativeParent <GraceString>();
if (asGraceString != null)
{
msg = asGraceString.Value;
}
GraceExceptionPacket.Throw(this, msg, ctx.GetStackTrace());
return(GraceObject.Done);
}
/// <summary>Match a pattern against a target</summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="pattern">Pattern to match</param>
/// <param name="target">Target of the match</param>
public static GraceObject Match(EvaluationContext ctx,
GraceObject pattern,
GraceObject target)
{
var matchReq = new MethodRequest();
var rp = new RequestPart("match", new List <GraceObject>(),
new List <GraceObject>()
{
target
});
matchReq.AddPart(rp);
return(pattern.Request(ctx, matchReq));
}
private GraceObject mDo(EvaluationContext ctx, GraceObject block)
{
var apply = MethodRequest.Single("apply", null);
Rational v = _low;
if (_step < 0)
{
while (v >= _high)
{
apply[0].Arguments[0] = GraceNumber.Create(v);
block.Request(ctx, apply);
v += _step;
}
return(GraceObject.Done);
}
while (v <= _high)
{
apply[0].Arguments[0] = GraceNumber.Create(v);
block.Request(ctx, apply);
v += _step;
}
return(GraceObject.Done);
}
/// <summary>Native method for the | combinator</summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="self">Left-hand side</param>
/// <param name="other">Right-hand side</param>
public static GraceObject OrCombinator(EvaluationContext ctx,
GraceObject self, GraceObject other)
{
var patReq = new MethodRequest();
patReq.AddPart(new RequestPart("_OrPattern",
RequestPart.EmptyList,
new List <GraceObject> {
self, other
}));
GraceObject patRec = ctx.FindReceiver(patReq);
return(patRec.Request(ctx, patReq));
}
private static GraceObject mDo(
EvaluationContext ctx,
GraceString self,
GraceObject blk
)
{
var req = MethodRequest.Single("apply", null);
for (var i = 0; i < self.graphemeIndices.Length; i++)
{
int start = self.graphemeIndices[i];
string c = StringInfo.GetNextTextElement(self.Value, start);
req[0].Arguments[0] = GraceString.Create(c);
blk.Request(ctx, req);
}
return(GraceObject.Done);
}
/// <summary>
/// Convert any GraceObject into a CLI string.
/// </summary>
/// <param name="ctx">Interpreter to call asString under</param>
/// <param name="o">Object to convert</param>
public static string AsNativeString(EvaluationContext ctx,
GraceObject o)
{
var s = o as GraceString;
if (s != null)
{
return(s.Value);
}
s = o.Request(ctx, MethodRequest.Nullary("asString"))
as GraceString;
if (s != null)
{
return(s.Value);
}
return("not a string, nor stringifiable");
}
private static GraceObject mConcatenate(EvaluationContext ctx,
GraceString self,
GraceObject other)
{
var oth = other.FindNativeParent <GraceString>();
if (oth != null)
{
return(GraceString.Create(self.Value + oth.Value));
}
var op = other as GraceObjectProxy;
if (op != null)
{
return(GraceString.Create(self.Value + op.Object));
}
other = other.Request(ctx, MethodRequest.Nullary("asString"));
oth = other.FindNativeParent <GraceString>();
return(GraceString.Create(self.Value + oth.Value));
}
private GraceObject apply(EvaluationContext ctx,
GraceObject arg)
{
if (index >= _elements.Count)
{
return(GraceObject.Done);
}
var el = _elements[index++];
var req = new MethodRequest();
var rpn = new RequestPart("apply",
new List <GraceObject>(),
new List <GraceObject>()
{
el, arg
}
);
req.AddPart(rpn);
_block.Request(ctx, req);
return(GraceObject.Done);
}
/// <summary>Native method for Grace orElse</summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="other">Block to apply if false</param>
public GraceObject OrElse(EvaluationContext ctx, GraceObject other)
{
var oth = other as GraceBlock;
if (oth == null)
{
ErrorReporting.RaiseError(ctx, "R2001",
new Dictionary <string, string>()
{
{ "method", "orElse" },
{ "index", "1" },
{ "part", "ifFalse" },
{ "required", "Block" }
},
"ArgumentTypeError: orElse requires a block argument"
);
}
if (!Boolean)
{
var req = MethodRequest.Nullary("apply");
return(other.Request(ctx, req));
}
return(True);
}
/// <summary>Native method for the Grace apply method</summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="req">Request that reached this method</param>
public GraceObject Apply(EvaluationContext ctx, MethodRequest req)
{
return(receiver.Request(ctx, request));
}
/// <summary>Determine whether MatchResult failed</summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="matchResult">MatchResult to examine</param>
public static bool Failed(EvaluationContext ctx,
GraceObject matchResult)
{
return(GraceBoolean.False == matchResult.Request(ctx, MethodRequest.Nullary("succeeded")));
}
/// <summary>Get the result of a MatchResult</summary>
/// <param name="ctx">Current interpreter</param>
/// <param name="matchResult">MatchResult to examine</param>
public static GraceObject GetResult(EvaluationContext ctx,
GraceObject matchResult)
{
return(matchResult.Request(ctx, MethodRequest.Nullary("result")));
}
/// <inheritdoc/>
public override GraceObject Request(EvaluationContext ctx,
MethodRequest req,
GraceObject receiver)
{
return(target.Request(ctx, req, target));
}