Removes redundant parser grammar equality rule (#31)

This is a breaking change that consolidates equality operations into the comparison rule,
eliminating grammar redundancy and simplifying the AST structure.

- Remove separate `equality` rule that handled `==` and `!=` operators
- Consolidate all equality operators into the `comparison` rule
- Update grammar: `comparison → addition ( ( ">" | "<" | ">=" | "<=" | "=" | "==" | "!=" | "in" | "contains" ) addition )?`

- Remove `{:equality, ...}` AST node type entirely
- Both `=` and `==` now create `{:comparison, :eq, ...}` nodes
- `!=` creates `{:comparison, :ne, ...}` nodes
- Remove `equality_op` type definition

- Remove 50+ lines of redundant equality parsing functions
- Remove equality visitor functions in both string and instructions visitors
- Update type annotations throughout codebase
- Simplify operator mapping functions

- Both `=` and `==` operators now parse to identical AST nodes
- Decompilation: both `=` and `==` now format as `=` for consistency
- Evaluation behavior unchanged (both operators work identically)

- Update all test expectations from `{:equality, ...}` to `{:comparison, ...}`
- Update string formatting tests to expect `=` output instead of `==`
- All 970 tests pass with consolidated grammar

- AST pattern matching on `{:equality, ...}` nodes will break
- `==` operator now decompiles as `=` instead of `==`
- Grammar rule `equality` no longer exists

- Eliminates parser grammar redundancy identified in previous analysis
- Reduces AST complexity and parsing code paths
- Maintains full functional compatibility for end users
- Simplifies future grammar maintenance

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-authored-by: Claude <noreply@anthropic.com>

Author: johnnyt

CLAUDE.md

@@ -20,9 +20,8 @@ Expression String → Lexer → Parser → Compiler → Instructions → Evaluat
 expression   → logical_or
 logical_or   → logical_and ( ("OR" | "or") logical_and )*
 logical_and  → logical_not ( ("AND" | "and") logical_not )*
-logical_not  → ("NOT" | "not") logical_not | equality
-equality     → comparison ( ("==" | "!=") comparison )*
-comparison   → addition ( ( ">" | "<" | ">=" | "<=" | "=" | "!=" | "in" | "contains" ) addition )?
+logical_not  → ("NOT" | "not") logical_not | comparison
+comparison   → addition ( ( ">" | "<" | ">=" | "<=" | "=" | "==" | "!=" | "in" | "contains" ) addition )?
 addition     → multiplication ( ( "+" | "-" ) multiplication )*
 multiplication → unary ( ( "*" | "/" | "%" ) unary )*
 unary        → ( "-" | "!" ) unary | postfix

README.md

@@ -354,9 +354,8 @@ Predicator uses a multi-stage compilation pipeline:
 expression   → logical_or
 logical_or   → logical_and ( ("OR" | "or") logical_and )*
 logical_and  → logical_not ( ("AND" | "and") logical_not )*
-logical_not  → ("NOT" | "not") logical_not | equality
-equality     → comparison ( ("==" | "!=") comparison )*
-comparison   → addition ( ( ">" | "<" | ">=" | "<=" | "=" | "!=" | "in" | "contains" ) addition )?
+logical_not  → ("NOT" | "not") logical_not | comparison
+comparison   → addition ( ( ">" | "<" | ">=" | "<=" | "=" | "==" | "!=" | "in" | "contains" ) addition )?
 addition     → multiplication ( ( "+" | "-" ) multiplication )*
 multiplication → unary ( ( "*" | "/" | "%" ) unary )*
 unary        → ( "-" | "!" ) unary | postfix

lib/predicator/parser.ex

@@ -16,9 +16,8 @@ defmodule Predicator.Parser do
       expression   → logical_or
       logical_or   → logical_and ( "OR" | "||" logical_and )*
       logical_and  → logical_not ( "AND" | "&&" logical_not )*
-      logical_not  → "NOT" | "!" logical_not | equality
-      equality     → comparison ( ( "==" | "!=" ) comparison )*
-      comparison   → addition ( ( ">" | "<" | ">=" | "<=" | "=" | "in" | "contains" ) addition )?
+      logical_not  → "NOT" | "!" logical_not | comparison
+      comparison   → addition ( ( ">" | "<" | ">=" | "<=" | "=" | "==" | "!=" | "in" | "contains" ) addition )?
       addition     → multiplication ( ( "+" | "-" ) multiplication )*
       multiplication → unary ( ( "*" | "/" | "%" ) unary )*
       unary        → ( "-" | "!" ) unary | postfix
@@ -58,8 +57,7 @@ defmodule Predicator.Parser do
   - `{:literal, value}` - A literal value (number, boolean, list, date, datetime)
   - `{:string_literal, value, quote_type}` - A string literal with quote type information
   - `{:identifier, name}` - A variable reference
-  - `{:comparison, operator, left, right}` - A comparison expression
-  - `{:equality, operator, left, right}` - An equality expression (== !=)
+  - `{:comparison, operator, left, right}` - A comparison expression (including equality)
   - `{:arithmetic, operator, left, right}` - An arithmetic expression (+, -, *, /, %)
   - `{:unary, operator, operand}` - A unary expression (-, !)
   - `{:logical_and, left, right}` - A logical AND expression
@@ -76,7 +74,6 @@ defmodule Predicator.Parser do
           | {:string_literal, binary(), :double | :single}
           | {:identifier, binary()}
           | {:comparison, comparison_op(), ast(), ast()}
-          | {:equality, equality_op(), ast(), ast()}
           | {:arithmetic, arithmetic_op(), ast(), ast()}
           | {:unary, unary_op(), ast()}
           | {:membership, membership_op(), ast(), ast()}
@@ -103,12 +100,7 @@ defmodule Predicator.Parser do
   @typedoc """
   Comparison operators in the AST.
   """
-  @type comparison_op :: :gt | :lt | :gte | :lte | :eq
-
-  @typedoc """
-  Equality operators in the AST.
-  """
-  @type equality_op :: :equal_equal | :ne
+  @type comparison_op :: :gt | :lt | :gte | :lte | :eq | :ne
 
   @typedoc """
   Arithmetic operators in the AST.
@@ -321,62 +313,9 @@ defmodule Predicator.Parser do
     end
   end
 
-  # No NOT operator, parse equality
+  # No NOT operator, parse comparison
   defp parse_logical_not_token(state, _token) do
-    parse_equality(state)
-  end
-
-  # Parse equality expressions (== !=)
-  @spec parse_equality(parser_state()) ::
-          {:ok, ast(), parser_state()} | {:error, binary(), pos_integer(), pos_integer()}
-  defp parse_equality(state) do
-    case parse_comparison(state) do
-      {:ok, left, new_state} ->
-        parse_equality_rest(left, new_state)
-
-      {:error, message, line, col} ->
-        {:error, message, line, col}
-    end
-  end
-
-  @spec parse_equality_rest(ast(), parser_state()) ::
-          {:ok, ast(), parser_state()} | {:error, binary(), pos_integer(), pos_integer()}
-  defp parse_equality_rest(left, state) do
-    token = peek_token(state)
-    parse_equality_rest_token(left, state, token)
-  end
-
-  # Parse == operator
-  defp parse_equality_rest_token(left, state, {:equal_equal, _line, _col, _len, _value}) do
-    eq_state = advance(state)
-
-    case parse_comparison(eq_state) do
-      {:ok, right, final_state} ->
-        ast = {:equality, :equal_equal, left, right}
-        parse_equality_rest(ast, final_state)
-
-      {:error, message, line, col} ->
-        {:error, message, line, col}
-    end
-  end
-
-  # Parse != operator
-  defp parse_equality_rest_token(left, state, {:ne, _line, _col, _len, _value}) do
-    ne_state = advance(state)
-
-    case parse_comparison(ne_state) do
-      {:ok, right, final_state} ->
-        ast = {:equality, :ne, left, right}
-        parse_equality_rest(ast, final_state)
-
-      {:error, message, line, col} ->
-        {:error, message, line, col}
-    end
-  end
-
-  # No equality operator, return left operand
-  defp parse_equality_rest_token(left, state, _token) do
-    {:ok, left, state}
+    parse_comparison(state)
   end
 
   # Parse comparison expressions
@@ -389,14 +328,16 @@ defmodule Predicator.Parser do
     case parse_addition(state) do
       {:ok, left, new_state} ->
         case peek_token(new_state) do
-          # Comparison operators
+          # Comparison operators (including equality)
           {op_type, _line, _col, _len, _value}
-          when op_type in [:gt, :lt, :gte, :lte, :eq] ->
+          when op_type in [:gt, :lt, :gte, :lte, :eq, :equal_equal, :ne] ->
             op_state = advance(new_state)
 
             case parse_addition(op_state) do
               {:ok, right, final_state} ->
-                ast = {:comparison, op_type, left, right}
+                # Map == to :eq for consistency, != stays as :ne
+                normalized_op = if op_type == :equal_equal, do: :eq, else: op_type
+                ast = {:comparison, normalized_op, left, right}
                 {:ok, ast, final_state}
 
               {:error, message, line, col} ->

lib/predicator/visitors/instructions_visitor.ex

@@ -80,15 +80,6 @@ defmodule Predicator.Visitors.InstructionsVisitor do
     left_instructions ++ right_instructions ++ op_instruction
   end
 
-  def visit({:equality, op, left, right}, opts) do
-    # Post-order traversal: left operand, right operand, then operator
-    left_instructions = visit(left, opts)
-    right_instructions = visit(right, opts)
-    op_instruction = [["compare", map_equality_op(op)]]
-
-    left_instructions ++ right_instructions ++ op_instruction
-  end
-
   def visit({:arithmetic, op, left, right}, opts) do
     # Post-order traversal: left operand, right operand, then operator
     left_instructions = visit(left, opts)
@@ -202,11 +193,7 @@ defmodule Predicator.Visitors.InstructionsVisitor do
   defp map_comparison_op(:gte), do: "GTE"
   defp map_comparison_op(:lte), do: "LTE"
   defp map_comparison_op(:eq), do: "EQ"
-
-  # Helper function to map AST equality operators to instruction format
-  @spec map_equality_op(Parser.equality_op()) :: binary()
-  defp map_equality_op(:equal_equal), do: "EQ"
-  defp map_equality_op(:ne), do: "NE"
+  defp map_comparison_op(:ne), do: "NE"
 
   # Helper function to map AST arithmetic operators to instruction format
   @spec map_arithmetic_op(Parser.arithmetic_op()) :: binary()

lib/predicator/visitors/string_visitor.ex

@@ -168,10 +168,6 @@ defmodule Predicator.Visitors.StringVisitor do
     end
   end
 
-  def visit({:equality, op, left, right}, opts) do
-    format_binary_operator(op, left, right, opts)
-  end
-
   def visit({:arithmetic, op, left, right}, opts) do
     format_binary_operator(op, left, right, opts)
   end
@@ -237,7 +233,6 @@ defmodule Predicator.Visitors.StringVisitor do
 
   @spec format_operator(
           Parser.comparison_op()
-          | Parser.equality_op()
           | Parser.arithmetic_op()
           | Parser.unary_op()
         ) :: binary()
@@ -247,7 +242,6 @@ defmodule Predicator.Visitors.StringVisitor do
   defp format_operator(:lte), do: "<="
   defp format_operator(:eq), do: "="
   defp format_operator(:ne), do: "!="
-  defp format_operator(:equal_equal), do: "=="
   defp format_operator(:add), do: "+"
   defp format_operator(:subtract), do: "-"
   defp format_operator(:multiply), do: "*"
@@ -263,7 +257,6 @@ defmodule Predicator.Visitors.StringVisitor do
   # Helper function to format binary operators (comparison, equality, arithmetic)
   @spec format_binary_operator(
           Parser.comparison_op()
-          | Parser.equality_op()
           | Parser.arithmetic_op(),
           Parser.ast(),
           Parser.ast(),

test/predicator/compiler_test.exs

@@ -54,12 +54,12 @@ defmodule Predicator.CompilerTest do
 
     test "works with equality operators" do
       equality_operators = %{
-        :equal_equal => "EQ",
+        :eq => "EQ",
         :ne => "NE"
       }
 
       for {ast_op, instruction_op} <- equality_operators do
-        ast = {:equality, ast_op, {:identifier, "x"}, {:literal, 1}}
+        ast = {:comparison, ast_op, {:identifier, "x"}, {:literal, 1}}
         result = Compiler.to_instructions(ast)
 
         assert result == [

test/predicator/parser_test.exs

@@ -94,7 +94,7 @@ defmodule Predicator.ParserTest do
       {:ok, tokens} = Lexer.tokenize("status != \"inactive\"")
 
       expected =
-        {:equality, :ne, {:identifier, "status"}, {:string_literal, "inactive", :double}}
+        {:comparison, :ne, {:identifier, "status"}, {:string_literal, "inactive", :double}}
 
       assert Parser.parse(tokens) == {:ok, expected}
     end
@@ -1065,7 +1065,7 @@ defmodule Predicator.ParserTest do
       result = Parser.parse(tokens)
 
       expected_ast =
-        {:equality, :equal_equal, {:arithmetic, :add, {:identifier, "a"}, {:identifier, "b"}},
+        {:comparison, :eq, {:arithmetic, :add, {:identifier, "a"}, {:identifier, "b"}},
          {:arithmetic, :multiply, {:identifier, "c"}, {:identifier, "d"}}}
 
       assert {:ok, ^expected_ast} = result

test/predicator/visitors/instructions_visitor_test.exs

@@ -101,7 +101,7 @@ defmodule Predicator.Visitors.InstructionsVisitorTest do
     end
 
     test "generates instructions for not equal comparison" do
-      ast = {:equality, :ne, {:identifier, "status"}, {:literal, "inactive"}}
+      ast = {:comparison, :ne, {:identifier, "status"}, {:literal, "inactive"}}
       result = InstructionsVisitor.visit(ast, [])
 
       assert result == [
@@ -510,7 +510,7 @@ defmodule Predicator.Visitors.InstructionsVisitorTest do
 
   describe "visit/2 - equality operators" do
     test "generates instructions for equality (==)" do
-      ast = {:equality, :equal_equal, {:identifier, "x"}, {:identifier, "y"}}
+      ast = {:comparison, :eq, {:identifier, "x"}, {:identifier, "y"}}
       result = InstructionsVisitor.visit(ast, [])
 
       assert result == [
@@ -521,7 +521,7 @@ defmodule Predicator.Visitors.InstructionsVisitorTest do
     end
 
     test "generates instructions for inequality (!=) with equality syntax" do
-      ast = {:equality, :ne, {:identifier, "status"}, {:literal, "active"}}
+      ast = {:comparison, :ne, {:identifier, "status"}, {:literal, "active"}}
       result = InstructionsVisitor.visit(ast, [])
 
       assert result == [
@@ -534,7 +534,7 @@ defmodule Predicator.Visitors.InstructionsVisitorTest do
     test "generates instructions for complex equality expression" do
       # x + y == 10
       arithmetic = {:arithmetic, :add, {:identifier, "x"}, {:identifier, "y"}}
-      ast = {:equality, :equal_equal, arithmetic, {:literal, 10}}
+      ast = {:comparison, :eq, arithmetic, {:literal, 10}}
       result = InstructionsVisitor.visit(ast, [])
 
       assert result == [
@@ -582,7 +582,7 @@ defmodule Predicator.Visitors.InstructionsVisitorTest do
     test "generates instructions for complex nested expression" do
       # !(x + y == 10)
       arithmetic = {:arithmetic, :add, {:identifier, "x"}, {:identifier, "y"}}
-      equality = {:equality, :equal_equal, arithmetic, {:literal, 10}}
+      equality = {:comparison, :eq, arithmetic, {:literal, 10}}
       ast = {:unary, :bang, equality}
       result = InstructionsVisitor.visit(ast, [])
 

test/predicator/visitors/string_visitor_test.exs

@@ -679,31 +679,31 @@ defmodule Predicator.Visitors.StringVisitorTest do
 
   describe "visit/2 - equality operators" do
     test "converts equality (==) expression" do
-      ast = {:equality, :equal_equal, {:identifier, "x"}, {:identifier, "y"}}
+      ast = {:comparison, :eq, {:identifier, "x"}, {:identifier, "y"}}
       result = StringVisitor.visit(ast, [])
 
-      assert result == "x == y"
+      assert result == "x = y"
     end
 
     test "converts inequality (!=) with equality syntax" do
-      ast = {:equality, :ne, {:identifier, "status"}, {:literal, "active"}}
+      ast = {:comparison, :ne, {:identifier, "status"}, {:literal, "active"}}
       result = StringVisitor.visit(ast, [])
 
       assert result == ~s(status != "active")
     end
 
     test "converts equality with explicit parentheses" do
-      ast = {:equality, :equal_equal, {:literal, 1}, {:literal, 1}}
+      ast = {:comparison, :eq, {:literal, 1}, {:literal, 1}}
       result = StringVisitor.visit(ast, parentheses: :explicit)
 
-      assert result == "(1 == 1)"
+      assert result == "(1 = 1)"
     end
 
     test "converts equality with compact spacing" do
-      ast = {:equality, :equal_equal, {:identifier, "a"}, {:identifier, "b"}}
+      ast = {:comparison, :eq, {:identifier, "a"}, {:identifier, "b"}}
       result = StringVisitor.visit(ast, spacing: :compact)
 
-      assert result == "a==b"
+      assert result == "a=b"
     end
   end
 
@@ -730,11 +730,11 @@ defmodule Predicator.Visitors.StringVisitorTest do
     test "converts complex nested expression" do
       # !(x + y == 10)
       arithmetic = {:arithmetic, :add, {:identifier, "x"}, {:identifier, "y"}}
-      equality = {:equality, :equal_equal, arithmetic, {:literal, 10}}
+      equality = {:comparison, :eq, arithmetic, {:literal, 10}}
       ast = {:unary, :bang, equality}
       result = StringVisitor.visit(ast, [])
 
-      assert result == "!x + y == 10"
+      assert result == "!x + y = 10"
     end
   end
 end