#224 - Introduce simplification rules

Author: sys27

xFunc.Maths/Analyzers2/ChainRuleBuilder.cs

@@ -0,0 +1,64 @@
+namespace xFunc.Maths.Analyzers2;
+
+internal class ChainRuleBuilder<TExpression> :
+    IInitialChainRuleBuilder<TExpression>,
+    IChainRuleBuilder<TExpression>
+    where TExpression : IExpression
+{
+    private ChainRule initialRule;
+    private ChainRule currentRule;
+
+    public IChainRuleBuilder<TExpression> WithRule(IRule<TExpression> rule)
+    {
+        initialRule = currentRule = new ChainRule(rule);
+
+        return this;
+    }
+
+    public IChainRuleBuilder<TExpression> WithNext(IRule<TExpression> next)
+    {
+        var chain = new ChainRule(next);
+        currentRule.SetNext(chain);
+        currentRule = chain;
+
+        return this;
+    }
+
+    public IRule GetRule()
+        => initialRule.UnwrapIfEmpty();
+
+    private sealed class ChainRule : IRule<TExpression>
+    {
+        private readonly IRule<TExpression> current;
+        private IRule<TExpression>? next;
+
+        public ChainRule(IRule<TExpression> rule)
+            => current = rule ?? throw new ArgumentNullException(nameof(rule));
+
+        public void SetNext(IRule<TExpression> rule)
+            => next = rule ?? throw new ArgumentNullException(nameof(rule));
+
+        public IRule UnwrapIfEmpty()
+            => next is null ? current : this;
+
+        public Result Execute(IExpression expression, RuleContext context)
+        {
+            var result = current.Execute(expression, context);
+            if (result.IsHandled() || result.IsReAnalyze())
+                return result;
+
+            if (result.IsContinue())
+                expression = result.Value;
+
+            if (next is not null)
+                return next.Execute(expression, context);
+
+            return Result.NotHandled();
+        }
+
+        public Result Execute(TExpression expression, RuleContext context)
+            => Execute(expression as IExpression, context);
+
+        public string Name => "Chain Rule";
+    }
+}

xFunc.Maths/Analyzers2/ExecutionStep.cs

@@ -0,0 +1,17 @@
+namespace xFunc.Maths.Analyzers2;
+
+public readonly struct ExecutionStep
+{
+    public ExecutionStep(IRule rule, IExpression before, IExpression after)
+    {
+        Name = rule.Name;
+        Before = before;
+        After = after;
+    }
+
+    public string Name { get; }
+
+    public IExpression Before { get; }
+
+    public IExpression After { get; }
+}

xFunc.Maths/Analyzers2/IAnalyzer2.cs

@@ -0,0 +1,8 @@
+namespace xFunc.Maths.Analyzers2;
+
+public interface IAnalyzer2
+{
+    IExpression Analyze(IExpression expression);
+
+    IExpression Analyze(IExpression expression, RuleContext context);
+}

xFunc.Maths/Analyzers2/IChainRuleBuilder.cs

@@ -0,0 +1,7 @@
+namespace xFunc.Maths.Analyzers2;
+
+internal interface IChainRuleBuilder<out TExpression>
+    where TExpression : IExpression
+{
+    IChainRuleBuilder<TExpression> WithNext(IRule<TExpression> next);
+}

xFunc.Maths/Analyzers2/IInitialChainRuleBuilder.cs

@@ -0,0 +1,7 @@
+namespace xFunc.Maths.Analyzers2;
+
+internal interface IInitialChainRuleBuilder<out TExpression>
+    where TExpression : IExpression
+{
+    IChainRuleBuilder<TExpression> WithRule(IRule<TExpression> rule);
+}

xFunc.Maths/Analyzers2/IRule.cs

@@ -0,0 +1,8 @@
+namespace xFunc.Maths.Analyzers2;
+
+public interface IRule
+{
+    Result Execute(IExpression expression, RuleContext context);
+
+    string Name { get; }
+}

xFunc.Maths/Analyzers2/IRule{TExpression}.cs

@@ -0,0 +1,6 @@
+namespace xFunc.Maths.Analyzers2;
+
+public interface IRule<in TExpression> : IRule
+{
+    Result Execute(TExpression expression, RuleContext context);
+}

xFunc.Maths/Analyzers2/Result.cs

@@ -0,0 +1,47 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace xFunc.Maths.Analyzers2;
+
+public readonly struct Result
+{
+    private readonly ResultKind kind;
+
+    private Result(ResultKind kind, IExpression? value)
+    {
+        this.kind = kind;
+        Value = value;
+    }
+
+    public static Result NotHandled()
+        => new Result(ResultKind.NotHandled, default);
+
+    public static Result Handled(IExpression value)
+        => new Result(ResultKind.Handled, value);
+
+    public static Result Continue(IExpression value)
+        => new Result(ResultKind.Continue, value);
+
+    public static Result ReAnalyze(IExpression value)
+        => new Result(ResultKind.ReAnalyze, value);
+
+    private bool IsKind(ResultKind kind)
+        => this.kind == kind;
+
+    [MemberNotNullWhen(false, nameof(Value))]
+    public bool IsNotHandled()
+        => IsKind(ResultKind.NotHandled);
+
+    [MemberNotNullWhen(true, nameof(Value))]
+    public bool IsHandled()
+        => IsKind(ResultKind.Handled);
+
+    [MemberNotNullWhen(true, nameof(Value))]
+    public bool IsContinue()
+        => IsKind(ResultKind.Continue);
+
+    [MemberNotNullWhen(true, nameof(Value))]
+    public bool IsReAnalyze()
+        => IsKind(ResultKind.ReAnalyze);
+
+    public IExpression? Value { get; }
+}

xFunc.Maths/Analyzers2/ResultKind.cs

@@ -0,0 +1,9 @@
+namespace xFunc.Maths.Analyzers2;
+
+public enum ResultKind
+{
+    NotHandled,
+    Handled,
+    Continue,
+    ReAnalyze,
+}

xFunc.Maths/Analyzers2/Rule.cs

@@ -0,0 +1,33 @@
+namespace xFunc.Maths.Analyzers2;
+
+public abstract class Rule<TExpression> : IRule<TExpression>
+    where TExpression : IExpression
+{
+    Result IRule.Execute(IExpression expression, RuleContext context)
+        => Execute((TExpression)expression, context);
+
+    public Result Execute(TExpression expression, RuleContext context)
+    {
+        var result = ExecuteInternal(expression, context);
+        if (result.IsHandled() || result.IsContinue() || result.IsReAnalyze())
+            context.AddStep(this, expression, result.Value);
+
+        return result;
+    }
+
+    protected abstract Result ExecuteInternal(TExpression expression, RuleContext context);
+
+    protected static Result Handled(IExpression value)
+        => Result.Handled(value);
+
+    protected static Result Continue(IExpression value)
+        => Result.Continue(value);
+
+    protected static Result ReAnalyze(IExpression value)
+        => Result.ReAnalyze(value);
+
+    protected static Result NotHandled()
+        => Result.NotHandled();
+
+    public virtual string Name => GetType().Name;
+}