public static IAtomNode Simplify(this IAtomNode n, TAction <Exception> handler) { IAtomNode ret = n; n.TryEvaluate(handler).IfJust((int i) => { ret = FromInt(n.MyLocation, i); }); return(ret); }
public OperatorNode(IAtomNode l, Token op, IAtomNode r, int prec) { left = l; right = r; this.op = op; Precedence = prec; }
public override Maybe <int> TryEvaluate(TAction <Exception> handler) { Maybe <int> l = left.TryEvaluate(handler); l.IfJust((int i) => { this.left = new NumberNode(left.MyLocation, i); }); Maybe <int> r = right.TryEvaluate(handler); r.IfJust((int i) => { this.right = new NumberNode(right.MyLocation, i); }); return(l.Bind((int newL) => r.Fmap((int newR) => Operators[op.Type](newL, newR)))); }
/*** * Precondition: grammarSymbols alternates between IAtomNodes, operator Tokens, .Count is odd * the precedences of the IAtomNodes is increasing. * Postcondition: Either grammarSymbols.Count == 1, or everything in grammarSymbols will have precedence <= targetPrecedence. * */ private void Reduce(Stack <Either <IAtomNode, Token> > grammarSymbols, int targetPrecedence) { while (grammarSymbols.Count > 1)// && grammarSymbols.Peek().GetLeft.Precedence > targetPrecedence) { //These shouldn't error... IAtomNode r = grammarSymbols.Pop().GetLeft; if (precedences[grammarSymbols.Peek().GetRight.Type] > targetPrecedence) { grammarSymbols.Push(new Left <IAtomNode, Token>(r)); break; } else { Token op = grammarSymbols.Pop().GetRight; IAtomNode l = grammarSymbols.Pop().GetLeft; grammarSymbols.Push(new Left <IAtomNode, Token>(new OperatorNode(l, op, r, l.Precedence))); } } }
public static int CoerceInt(this IAtomNode n) { return(n.TryEvaluate((Exception e) => { throw e; }).FromJust); }
public NegationNode(Token token, IAtomNode inside) { myToken = token; interior = inside; }