var func = "x + sin(y) + 2ch(0)".Compile<Complex, double, Complex>("x", "y");
Console.WriteLine(func(new(3, 4), 1.2d));
>>> (5.932039085967226, 4)
var func = "x > 3 and (a implies b)".Compile<int, bool, bool, bool>("x", "a", "b");
Console.WriteLine(func(4, false, true));
>>> True

Entity
|
+--Operators
  |
  +--Sumf
  |
  +--Minusf
  |
  ...
+--Trigonometry
  |
  +--Sinf
  |
  +--Cosf
  |
  ...
+--Discrete
  |
  +--Andf
  |
  +--Lessf
  |

public sealed record CompilationProtocol
{
  public Func<Entity, Expression> ConstantConverter { get; init; }
  public Func<Expression, Expression, Entity, Expression> BinaryNodeConverter { get; init; }
  public Func<Expression, Entity, Expression> UnaryNodeConverter { get; init; }
  public Func<IEnumerable<Expression>, Entity, Expression> AnyArgumentConverter { get; init; }
}

internal static TDelegate Compile<TDelegate>(
            Entity expr,
            Type? returnType,
            CompilationProtocol protocol,
            IEnumerable<(Type type, Variable variable)> typesAndNames
            ) where TDelegate : Delegate

internal static TDelegate Compile<TDelegate>(Entity expr, Type? returnType, CompilationProtocol protocol, IEnumerable<(Type type, Variable variable)> typesAndNames) where TDelegate : Delegate
{
  // для каждого поддерева есть локальная переменная, которую мы держим здесь
  var subexpressionsCache = typesAndNames.ToDictionary(c => (Entity)c.variable, c => Expression.Parameter(c.type));
  // это параметры функции: те переменные, которые будут передаваться в нее, а не создаваться локально
  var functionArguments = subexpressionsCache.Select(c => c.Value).ToArray(); // copying
  // а это локальные переменные, мы их сохраняем в этом списке
  var localVars = new List<ParameterExpression>();
  // это список инструкций-присваиваний (о нем позже)
  var variableAssignments = new List<Expression>();
  // по всем данным строим дерево
  var tree = BuildTree(expr, subexpressionsCache, variableAssignments, localVars, protocol);
  // построив, создаем блок, в котором объявляем локальные переменные, используемые в дереве
  var treeWithLocals = Expression.Block(localVars, variableAssignments.Append(tree));
  // если пользователь передал returnType, то попытаемся явно скастить в него
  Expression entireExpresion = returnType is not null ? Expression.Convert(treeWithLocals, returnType) : treeWithLocals;
  // создаем лямбду с аргументами функции
  var finalLambda = Expression.Lambda<TDelegate>(entireExpresion, functionArguments);
  // компилируем
  return finalLambda.Compile();
}

internal static Expression BuildTree(
  Entity expr,
  Dictionary<Entity, ParameterExpression> cachedSubexpressions,
  List<Expression> variableAssignments,
  List<ParameterExpression> newLocalVars,
  CompilationProtocol protocol)

internal static Expression BuildTree(Entity expr, ...)
{
  // если поддерево встречалось, возвращаем переменную, в которую оно присвоено
  if (cachedSubexpressions.TryGetValue(expr, out var readyVar))
    return readyVar;
  Expression subTree = expr switch
  {
    ...
    // если константа - прогоняем через ConstantConverter
    // нашего протокола
    Entity.Boolean or Number => protocol.ConstantConverter(expr),
    // аналогичная логика с унарной, бинарной, и n-арными нодами
    IUnaryNode oneArg
      => protocol.UnaryNodeConverter(BuildTree(oneArg.NodeChild, ...), expr),
    IBinaryNode twoArg
      => protocol.BinaryNodeConverter(
        BuildTree(twoArg.NodeFirstChild, ...),
        BuildTree(twoArg.NodeSecondChild, ...),
        expr),
    var other => protocol.AnyArgumentConverter(
        other.DirectChildren.Select(c => BuildTree(c, ...)),
      expr)
  };
  // для этого поддерева создадим локальную переменную
  var newVar = Expression.Variable(subTree.Type);
  // добавим запись вида var5 = subTree
  variableAssignments.Add(Expression.Assign(newVar, subTree));
  // запомним, что для этого поддерева используется эта переменная
  cachedSubexpressions[expr] = newVar;
  // запомним, что мы вообще такую создали
  newLocalVars.Add(newVar);
  return newVar;
}

public static Expression ConverterConstant(Entity e)
  => e switch
  {
    Number n => Expression.Constant(DownCast(n)),
    Entity.Boolean b => Expression.Constant((bool)b),
    _ => throw new AngouriBugException("Undefined constant type")
  };

private static object DownCast(Number num)
{
  if (num is Integer)
    return (long)num;
  if (num is Real)
    return (double)num;
  if (num is Number.Complex)
    return (System.Numerics.Complex)num;
  throw new InvalidProtocolProvided("Undefined type, provide valid compilation protocol");
}

public static Expression OneArgumentEntity(Expression e, Entity typeHolder)
  => typeHolder switch
  {
    Sinf =>         Expression.Call(GetDef("Sin", 1, e.Type), e),
    ...
    Cosecantf =>    Expression.Call(GetDef("Csc", 1, e.Type), e),
    Arcsinf =>      Expression.Call(GetDef("Asin", 1, e.Type), e),
    ...
    Arccosecantf => Expression.Call(GetDef("Acsc", 1, e.Type), e),
    Absf =>         Expression.Call(GetDef("Abs", 1, e.Type), e),
    Signumf =>      Expression.Call(GetDef("Sgn", 1, e.Type), e),
    Notf =>         Expression.Not(e),
    _ => throw new AngouriBugException("A node seems to be not added")
  };

public static Expression TwoArgumentEntity(Expression left, Expression right, Entity typeHolder)
{
  var typeToCastTo = MaxType(left.Type, right.Type);
  if (left.Type != typeToCastTo)
    left = Expression.Convert(left, typeToCastTo);
  if (right.Type != typeToCastTo)
    right = Expression.Convert(right, typeToCastTo);
  return typeHolder switch
  {
    Sumf => Expression.Add(left, right),
    ...
    Andf => Expression.And(left, right),
    ...
    Lessf => Expression.LessThan(left, right),
    ...
    _ => throw new AngouriBugException("A node seems to be not added")
  };
}

Complex:   10
double:     9
float:      8
long:       8
BigInteger: 8
int:        7

public TDelegate Compile<TDelegate>(CompilationProtocol protocol, Type returnType, IEnumerable<(Type type, Variable variable)> typesAndNames) where TDelegate : Delegate

// указываем типы аргументов и выходной                             а здесь указываем соответствующие переменные из самого выражения
public Func<TIn1, TIn2, TIn3, TOut> Compile<TIn1, TIn2, TIn3, TOut>(Variable var1, Variable var2, Variable var3)
                                       // делегат генерируем сами        выходной тип известен   new() так как создаем правила по умолчанию
            => IntoLinqCompiler.Compile<Func<TIn1, TIn2, TIn3, TOut>>(this, typeof(TOut),         new(),
                new[] { (typeof(TIn1), var1), (typeof(TIn2), var2) , (typeof(TIn3), var3)  });

<# for (var i = 1; i <= 8; i++) { #>
        public Func<<# for(var t=1;t<=i;t++){ #>TIn<#= t #>, <# } #>TOut> Compile<<# for(var t=1;t<=i;t++){ #>TIn<#= t #>, <# } #>TOut>(Variable var1<# for(var t=2; t<=i; t++){ #>, Variable var<#= t #><# } #>)
            => IntoLinqCompiler.Compile<Func<<# for(var t=1;t<=i;t++){ #>TIn<#= t #>, <# } #>TOut>>(this, typeof(TOut), new(),
                new[] { (typeof(TIn1), var1)<# for(var t=2;t<=i;t++){ #>, (typeof(TIn<#= t #>), var<#= t #>) <# } #> });
<# } #>

public static Func<TIn1, TIn2, TOut> Compile<TIn1, TIn2, TOut>(this string @this, Variable var1, Variable var2)
  => IntoLinqCompiler.Compile<Func<TIn1, TIn2, TOut>>(@this, typeof(TOut), new(),
    new[] { (typeof(TIn1), var1), (typeof(TIn2), var2)  });

|                 Method |       Mean |    Error |   StdDev |
|----------------------- |-----------:|---------:|---------:|
|      BenchNormalSimple |   189.1 ns |  3.75 ns |  5.83 ns |
|          BenchMySimple |   195.7 ns |  3.92 ns |  5.50 ns |
| BenchNormalComplicated | 1,383.0 ns | 26.82 ns | 35.80 ns |
|     BenchMyComplicated |   293.6 ns |  5.74 ns |  8.77 ns |

var func = "sin(x)".Compile<double, double>("x");
Console.WriteLine(func(Math.PI / 2));
>>> 1
var func1 = "a > b".Compile<float, int, bool>("a", "b");
Console.WriteLine(func1(5.4f, 4));
Console.WriteLine(func1(4f, 4));
>>> True
>>> False
var cr = new CompilationProtocol()
{
    ConstantConverter = ent => Expression.Constant(ent.ToString()),
    BinaryNodeConverter = (a, b, t) => t switch
    {
        Sumf => Expression.Call(typeof(string)
            .GetMethod("Concat", new[] { typeof(string), typeof(string) }) ?? throw new Exception(), a, b),
        _ => throw new Exception()
    }
};
var func2 = "a + b + c + 1234"
    .Compile<Func<string, string, string, string>>(
        cr, typeof(string),
        new[] {
            (typeof(string), Var("a")),
            (typeof(string), Var("b")),
            (typeof(string), Var("c")) }
        );
Console.WriteLine(func2("White", "Black", "Goose"));
>>> WhiteBlackGoose1234