/// <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)); }