Added implication (=>), removed support for using <> as brackets

Author: tomc128

BooleanExpressionParser/Nodes/ImplicationOperatorNode.cs

@@ -0,0 +1,6 @@
+class ImplicationOperatorNode : OperatorNode
+{
+    public ImplicationOperatorNode(Node left, Node right) : base(left, right) { }
+
+    public override bool Evaluate(Dictionary<string, bool> variables) => Left.Evaluate(variables) || !Right!.Evaluate(variables);
+}

BooleanExpressionParser/Parser.cs

@@ -26,6 +26,7 @@ public IEnumerable<Token> ParseTokens(IEnumerable<Token> tokens)
                 case NandOperatorToken:
                 case NorOperatorToken:
                 case XnorOperatorToken:
+                case ImplicationOperatorToken:
                     while ((stack.Count > 0 && stack.Peek() is OperatorToken && stack.Peek() is not OpenParenToken) && ((stack.Peek() as OperatorToken)!.Precedence >= (token as OperatorToken)!.Precedence))
                     {
                         output.Enqueue(stack.Pop());
@@ -88,6 +89,7 @@ public Ast GrowAst(IEnumerable<Token> tokens)
                 case NandOperatorToken:
                 case NorOperatorToken:
                 case XnorOperatorToken:
+                case ImplicationOperatorToken:
                     if (stack.Count < 2) throw new Exception($"2 parameters needed for operator ${token}");
 
                     if (token is AndOperatorToken)
@@ -102,6 +104,8 @@ public Ast GrowAst(IEnumerable<Token> tokens)
                         stack.Push(new XorOperatorNode(stack.Pop(), stack.Pop()));
                     else if (token is XnorOperatorToken)
                         stack.Push(new XnorOperatorNode(stack.Pop(), stack.Pop()));
+                    else if (token is ImplicationOperatorToken)
+                        stack.Push(new ImplicationOperatorNode(stack.Pop(), stack.Pop()));
                     break;
 
                 case NotOperatorToken:

BooleanExpressionParser/Tokeniser.cs

@@ -4,7 +4,7 @@ namespace BooleanExpressionParser;
 
 class Tokeniser
 {
-    private readonly Regex regex = new Regex(@"([([{<]|[)\]}>]|\w+|[.&+!¬|])\s*");
+    private readonly Regex regex = new Regex(@"([([{]|[)\]}]|[\w]+|[.&+!¬|]|=>)\s*");
     private readonly string input;
 
     public Tokeniser(string input)
@@ -27,15 +27,16 @@ public IEnumerable<Token> Tokenise()
 
             yield return token switch
             {
-                "(" or "[" or "{" or "<" => new OpenParenToken(),
-                ")" or "]" or "}" or ">" => new CloseParenToken(),
+                "(" or "[" or "{" => new OpenParenToken(),
+                ")" or "]" or "}"  => new CloseParenToken(),
                 "AND" or "." or "&" => new AndOperatorToken(),
                 "OR" or "+" or "|" => new OrOperatorToken(),
                 "NOT" or "!" or "¬" => new NotOperatorToken(),
                 "XOR" => new XorOperatorToken(),
                 "NAND" => new NandOperatorToken(),
                 "NOR" => new NorOperatorToken(),
                 "XNOR" => new XnorOperatorToken(),
+                "=>" or "IMPLIES" => new ImplicationOperatorToken(),
                 _ => new VariableToken(token)
             };
         }

BooleanExpressionParser/Tokens/ImplicationOperatorToken.cs

@@ -0,0 +1,5 @@
+class ImplicationOperatorToken : OperatorToken
+{
+    public ImplicationOperatorToken() : base(0) { }
+    public override string ToString() => "=>";
+}

BooleanExpressionParser/Tokens/XnorOperatorToken.cs

@@ -1,5 +1,5 @@
 class XnorOperatorToken : OperatorToken
 {
-    public XnorOperatorToken() : base(3) { }
+    public XnorOperatorToken() : base(1) { }
     public override string ToString() => "XNOR";
 }