Приведение существующих типов для внутреннего DSL в F#

Здесь есть несколько тонких проблем.

Во-первых, SRTP работают только с inline функциями. Это связано с тем, что они не могут быть скомпилированы в IL (поскольку IL не поддерживает такого рода ограничения), поэтому их необходимо разрешать во время компиляции. Статически. Вот почему они «статически разрешены». Ключевое слово inline позволяет компилятору сделать это.

let inline (+) a b = ...

Во-вторых, что это за универсальный тип ^t, на который вы ссылаетесь? Это тип чего? Я думаю, вы хотели, чтобы это был тип a и b, но вы не объявили его как таковой, так что это просто какой-то случайный общий тип, плавающий вокруг. Его нужно привязать к параметрам:

let inline (+) (a: ^t) (b: ^t) = ...

В-третьих, из ваших примеров похоже, что вы действительно имели в виду, что a и b должны быть разных типов, не так ли?

let inline (+) (a: ^a) (b: ^b) = ...

В-четвертых, методы расширения не учитываются для статически разрешенных типов, поэтому вы не можете определить ToExpression на String и float и ожидать, что это сработает. Обычный трюк состоит в том, чтобы вместо этого объявить все ваши методы в специальном классе, который существует только для хранения этих методов:

type ToExpressionStub() =
    static member ToExpression s = Var s
    static member ToExpression f = Val f

И тогда можно было бы ожидать, что это сработает:

let inline (+) (a: ^a) (b: ^b) =
  let a = (ToExpression : (static member ToExpression: ^a -> Expression) a)
  let b = (ToExpression : (static member ToExpression: ^b -> Expression) b)
  Add [a; b]

Но нет, не будет. Это связано с тем, что статически разрешенные ограничения не могут применяться к конкретным типам, а только к переменным типа, таким как ^a или ^b. Так что делать?

Ну, мы можем просто дать нашей функции дополнительный параметр, например:

let inline (+) (dummy: ^c) (a: ^a) (b: ^b) =
  let a = (^c : (static member ToExpression: ^a -> Expression) a)
  let b = (^c : (static member ToExpression: ^b -> Expression) b)
  Add [a; b]

И тогда нам пришлось бы передавать значение ToExpressionStub() при каждом вызове:

let x = (+) (ToExpressionStub()) "foo" 2.0

Это, конечно, очень неудобно, поэтому вместо этого мы добавим еще одну промежуточную функцию с тремя параметрами и вызовем ее из оператора (+):

let inline doAdd (dummy: ^c) (a: ^a) (b: ^b) =
  let a = (^c : (static member ToExpression: ^a -> Expression) a)
  let b = (^c : (static member ToExpression: ^b -> Expression) b)
  Add [a; b]

let inline (+) (a: ^a) (b: ^b) = doAdd (ToExpressionStub()) a b

Почти готово! Но это тоже не совсем работает: на строке let b = ... получаем предупреждение, что «Эта конструкция делает код менее универсальным...», а потом на сайтах использования получаем ошибку, что нельзя использовать ни string, ни float , в зависимости от того, что было раньше.

Происходит это по очень-очень непонятным причинам. Компилятор видит, что два ограничения имеют одинаковую форму и применяются к одному и тому же типу, и решает, что они должны быть одним и тем же ограничением, и, следовательно, ^a = ^b. Чтобы выйти из этого тупика, мы можем просто изменить форму ограничений, чтобы сделать их другими:

let inline doAdd (dummy: ^c) (a: ^a) (b: ^b) =
  let a = ((^a or ^c) : (static member ToExpression: ^a -> Expression) a)
  let b = ((^b or ^c) : (static member ToExpression: ^b -> Expression) b)
  Add [a; b]

Обратите внимание, что теперь они применяются к ^a or ^c и ^b or ^c соответственно, а не только к ^c. Это также имеет бонусный эффект: мы больше не ограничены только типами, которые мы перечислили в ToExpressionStub. Мы можем использовать любой тип, для которого определен собственный нерасширяющий метод ToExpression. Например, сам Expression:

type Expression =
  | Add of list<Expression>
  | Var of string
  | Val of float
  with
    static member ToExpression (e: Expression) = e

Вот и все! Теперь это работает:

> let x = 2.0 + "foo"
Add [Val 2.0; Var "foo"]

> let y = x + "bar"
Add [Add [Val 2.0; Var "foo"]; Var "bar"]

Наконец, чтобы уменьшить затраты на выделение памяти во время выполнения, я обычно использую одиночный экземпляр ToExpressionStub, а не создаю новый при каждом вызове:

type ToExpressionStub() = 
    static member val Value = ToExpressionStub()
    ...

let inline (+) (a: ^a) (b: ^b) = doAdd ToExpressionStub.Value a b

Суть в том, что да, вы можете это сделать, но, пожалуйста, хорошенько подумайте, стоит ли вам это делать.

На практике такого рода уловки скорее мешают развитию, чем помогают ему. Конечно, поначалу это может выглядеть очень аккуратно и умно, но через несколько месяцев вы будете смотреть на свой собственный код и не сможете понять, что происходит. Пожалуйста, поверьте моему опыту: необходимость заключать значения в Val и Var — это функция, а не ошибка. Программный код читается гораздо больше, чем пишется. Не стреляй себе в ногу.