OperatorSet.cs

using PolishForm.Expressions;
using System;
using System.Collections;
using System.Collections.Generic;

namespace PolishForm
{
    public class OperatorSet : ICollection<Operator>
    {
        private readonly Dictionary<char, Operator> operators;
        public char[] Symbols => [.. operators.Keys];

        static internal UnaryOperator NegationOperator;

        public OperatorSet()
        {
            operators = new();
        }
        public OperatorSet(int capacity)
        {
            operators = new(capacity);
        }
        public OperatorSet(ICollection<Operator> operators)
        {
            this.operators = new(operators.Count);
            foreach (Operator op in operators)
            {
                Add(op);
            }
        }

        public void Add(Operator op) => operators.Add(op.symbol, op);
        public bool TryAdd(Operator op) => operators.TryAdd(op.symbol, op);
        public bool IsOperator(char symbol) => operators.ContainsKey(symbol);
        public bool TryGetOperator(char symbol, out Operator? op) => operators.TryGetValue(symbol, out op);

        /// <summary>
        /// Compares the precedence of two operators represented by their symbols and returns an indication of their
        /// relative precedence.
        /// </summary>
        /// <param name="symbol1">The first operator symbol to compare. Must be a valid operator in the current set.</param>
        /// <param name="symbol2">The second operator symbol to compare. Must be a valid operator in the current set.</param>
        /// <returns><b>Less than zero</b> - first operator has lower precedence.
        /// <b>Zero</b> - equal precedence.
        /// <b>Greater than zero</b> - first operator has higher precedence.</returns>
        /// <exception cref="ArgumentException">Thrown if either <paramref name="symbol1"/> or <paramref name="symbol2"/> is not a valid operator in the current set.</exception>
        public int ComparePrecedence(char symbol1, char symbol2)
        {
            if (!operators.TryGetValue(symbol1, out Operator? op1))
                throw new ArgumentException($"Symbol '{symbol1}' is not an operator in this set.", nameof(symbol1));
            if (!operators.TryGetValue(symbol2, out Operator? op2))
                throw new ArgumentException($"Symbol '{symbol2}' is not an operator in this set.", nameof(symbol2));
            return op1.CompareTo(op2);
        }

        public bool TryGetAssociativity(char symbol, out Operator.Associativity? associativity)
        {
            if (operators.TryGetValue(symbol, out Operator? op))
            {
                associativity = op.associativity;
                return true;
            }
            associativity = null;
            return false;
        }


        public static OperatorSet Default => CreateDefault();

        public int Count => operators.Count;

        public bool IsReadOnly => throw new NotImplementedException();

        static OperatorSet CreateDefault()
        {
            OperatorSet set = new();

            // Equality
            BinaryOperator eq = new BinaryOperator('=', 0, Operator.Associativity.Right, true);
            eq.AddImplementation((Operand left, Operand right) => new LogicLiteral(left.Equals(right)));
            set.Add(eq);

            // Logical OR
            BinaryOperator or = new BinaryOperator('|', 1, Operator.Associativity.Left, true);
            or.AddImplementation((LogicLiteral left, LogicLiteral right) => new LogicLiteral(left.Value || right.Value));
            set.Add(or);

            // Logical AND
            BinaryOperator and = new BinaryOperator('&', 2, Operator.Associativity.Left, true);
            and.AddImplementation((LogicLiteral left, LogicLiteral right) => new LogicLiteral(left.Value && right.Value));
            set.Add(and);

            // Comparison < and >
            BinaryOperator lt = new BinaryOperator('<', 3, Operator.Associativity.Left, false);
            lt.AddImplementation((NumberLiteral left, NumberLiteral right) => new LogicLiteral(left.Value < right.Value));
            set.Add(lt);

            BinaryOperator gt = new BinaryOperator('>', 3, Operator.Associativity.Left, false);
            gt.AddImplementation((NumberLiteral left, NumberLiteral right) => new LogicLiteral(left.Value > right.Value));
            set.Add(gt);

            // Arithmetic + - * / %
            BinaryOperator plus = new BinaryOperator('+', 4, Operator.Associativity.Left, true);
            plus.AddImplementation<Operand,Operand,IOperand>((left, right) =>
            {
                if (left is NumberLiteral ln && ln.Value == 0)
                    return right;
                if (right is NumberLiteral rn && rn.Value == 0)
                    return left;
                if (left is NumberLiteral l && right is NumberLiteral r)
                    return new NumberLiteral(l.Value + r.Value);
                else
                    return new BinaryExpression(plus, left, right);
            });
            set.Add(plus);

            BinaryOperator minus = new BinaryOperator('-', 4, Operator.Associativity.Left, false);
            minus.AddImplementation<Operand, Operand, IOperand>((left, right) =>
            {
                if (left.Equals(right))
                    return new NumberLiteral(0);
                if (left is NumberLiteral ln && ln.Value == 0)
                    return new UnaryExpression(OperatorSet.NegationOperator, right).Evaluate();
                if (right is NumberLiteral rn && rn.Value == 0)
                    return left;
                if (left is NumberLiteral l && right is NumberLiteral r)
                    return new NumberLiteral(l.Value - r.Value);
                else
                    return new BinaryExpression(minus, left, right);
            });
            set.Add(minus);

            BinaryOperator times = new BinaryOperator('*', 5, Operator.Associativity.Left, true);
            times.AddImplementation((NumberLiteral left, NumberLiteral right) => new NumberLiteral(left.Value * right.Value));
            set.Add(times);

            BinaryOperator div = new BinaryOperator('/', 5, Operator.Associativity.Left, false);
            div.AddImplementation((NumberLiteral left, NumberLiteral right) =>
            {
                if (right.Value == 0) throw new DivideByZeroException("Division by zero is not allowed.");
                return new NumberLiteral(left.Value / right.Value);
            });
            set.Add(div);

            BinaryOperator mod = new BinaryOperator('%', 5, Operator.Associativity.Left, false);
            mod.AddImplementation((NumberLiteral left, NumberLiteral right) =>
            {
                if (right.Value == 0) throw new DivideByZeroException("Modulo by zero is not allowed.");
                return new NumberLiteral(left.Value % right.Value);
            });
            set.Add(mod);

            // Exponentiation
            BinaryOperator pow = new BinaryOperator('^', 7, Operator.Associativity.Right, false);
            pow.AddImplementation((NumberLiteral left, NumberLiteral right) => new NumberLiteral((int)Math.Pow(left.Value, right.Value)));
            set.Add(pow);

            // Unary operators
            UnaryOperator u = new UnaryOperator('~', 6, Operator.Associativity.Right);
            u.AddImplementation((NumberLiteral op) => new NumberLiteral(-op.Value));
            set.Add(u);
            NegationOperator ??= u;

            u = new UnaryOperator('!', 8, Operator.Associativity.Right);
            u.AddImplementation((LogicLiteral op) => new LogicLiteral(!op.Value));
            set.Add(u);

            return set;
        }

        public void Clear() => operators.Clear();

        public bool Contains(Operator item) => operators.ContainsValue(item);

        public void CopyTo(Operator[] array, int arrayIndex)
        {
            throw new NotImplementedException();
        }

        public bool Remove(Operator item) => operators.Remove(item.symbol);

        public IEnumerator<Operator> GetEnumerator() => operators.Values.GetEnumerator();

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }
}