Free Монада в F # с общими выходными типа

Question

Я пытаюсь применить свободный образец монады, как описан в F# for fun and profit для осуществления доступа к данным (для Microsoft Azure Table Storage)

Примера

Давайте предположим, что мы имеем три таблицы базы данных и три Dao в Foo, Bar, баз:

Foo   Bar   Baz 

key | col key | col key | col 
--------- --------- --------- 
foo | 1  bar | 2   | 

Я хочу, чтобы выбрать Foo с ключом = «Foo» и бар с ключом = «бар», чтобы вставить баз с ключом = «бАЗ» и цв = 3

Select<Foo> ("foo", fun foo -> Done foo) 
    >>= (fun foo -> Select<Bar> ("bar", fun bar -> Done bar) 
    >>= (fun bar -> Insert<Baz> ((Baz ("baz", foo.col + bar.col), fun() -> Done())))) 

В функции интерпретатора

• Select приводит к вызову функции, которая принимает key : string и возвращает obj
• Insert приводит к вызову функции, которая принимает obj и возвращает unit

Pro я проблема

Я определил две операции Select и Insert в дополнение к Done прекратить вычисления:

type StoreOp<'T> = 
    | Select of string * ('T -> StoreOp<'T>) 
    | Insert of 'T * (unit -> StoreOp<'T>) 
    | Done of 'T 

Для того, чтобы цепь StoreOp-х я пытаюсь реализовать правильную функцию связывания:

let rec bindOp (f : 'T1 -> StoreOp<'T2>) (op : StoreOp<'T1>) : StoreOp<'T2> = 
    match op with 
    | Select (k, next) -> 
     Select (k, fun v -> bindOp f (next v)) 
    | Insert (v, next) -> 
     Insert (v, fun() -> bindOp f (next())) 
    | Done t -> 
     f t 

    let (>>=) = bindOp 

Однако компилятор f # правильно предупреждает меня, что:

The type variable 'T1 has been constrained to be type 'T2 

Для данной реализации bindOp типа фиксируется на протяжении вычислений, поэтому вместо того, чтобы:

Foo > Bar > unit 

все, что я могу выразить это:

Foo > Foo > Foo 

Как следует изменить определение StoreOp и/или bindOp для работы с разными типами вычислений?

Answer 1

Как отметил Федор в комментариях, проблема связана с объявлением типа. Если вы хотите, чтобы сделать его компилировать по цене жертвуя типобезопасность, вы могли бы использовать obj в двух местах - это по крайней мере показывает, где проблема:

type StoreOp<'T> = 
    | Select of string * (obj -> StoreOp<'T>) 
    | Insert of obj * (unit -> StoreOp<'T>) 
    | Done of 'T 

Я не совсем уверен, что эти две операции Предположим, что модель - но я думаю, что Select означает, что вы что-то читаете (с помощью клавиши string?) и Insert означает, что вы сохраняете некоторое значение (а затем продолжаете unit). Итак, здесь данные, которые вы храните/читаете, будут obj.

Есть способы сделать этот тип безопасным, но я думаю, что вы получите лучший ответ, если объясните, чего вы пытаетесь достичь, используя монадическую структуру.

Не зная больше, я думаю, что использование свободных монадов сделает ваш код очень грязным и трудным для понимания. F # - это функционально-первый язык, что означает, что вы можете записывать преобразования данных в приятном функциональном стиле с использованием неизменяемых типов данных и использовать императивное программирование для загрузки ваших данных и хранения ваших результатов. Если вы работаете с хранилищем таблиц, почему бы просто не написать нормальный императивный код для чтения данных из хранилища таблиц, передать результаты в чисто функциональное преобразование и затем сохранить результаты?