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