Выражения вычисления F#: Как использовать `for` для возврата`seq`?

Question

Я пишу вычислительное выражение, которое по существу реализует монаду State, и я пытаюсь использовать for выражение.

Я могу использовать шаблонную функцию forLoop или даже MBuilder.For()и все они возвращают хороший M<seq<'U>, _> которые могут быть обработаны в дальнейшем let! выражение. Но когда я пытаюсь сделать то же самое с for выражение, он не может скомпилировать, говоря мне, что выражение внутри for должен вернуться unit,

Я прошу прощения за большой блок кода, который я не могу сделать меньше.

type M<'T, 'E> = 'T * 'E                 // Monadic type is a simple tuple
type MFunc<'T, 'U, 'E> = 'T -> M<'U, 'E> // A function producing monadic value

// typical boilerplate functions
let bind (x: M<'T, 'E>) (f: MFunc<'T, 'U, 'E>) : M<'U, 'E> =
    let a, s = x
    let b, s1 = f a
    b, s1 + s
let combine (e1: M<'T, 'E>) (e2: M<'U, 'E>) : M<'U, 'E> = bind e1 (fun _ -> e2)
let delay f = (fun () -> f())()

// These two are explained below
let combineList (e1: M<'T, 'E>) (e2: M<'T seq, 'E>) : M<'T seq, 'E> =
    bind
        e1
        (fun x1 ->
            let e2body, e2state = e2
            seq{yield! e2body; yield x1}, e2state
        )
let forLoop (xs: seq<'T>) (f: MFunc<'T, 'U, 'E>) : M<seq<'U>, 'E> =
    Seq.fold
        (fun s x -> combineList (f x) s)
        (Seq.empty<'U>, 0)
        xs

// Builder class
type MBuilder() =
    member this.Bind (x: M<'T, 'E>, f: MFunc<'T, 'U, 'E>) : M<'U, 'E> = bind x f
    member this.Return(a) = a, 0
    member this.Combine(e1,e2) = combine e1 e2
    member this.Delay(f) = delay f
    member this.Zero() = (), 0
    member this.For (xs: seq<'T>, f: MFunc<'T, 'U, 'E> ) : M<seq<'U>, 'E> = forLoop xs f
let stateful = new MBuilder()

let mTest = stateful {
    // below is the typical use, just for example
    let! var1 = "q", 3
    let! var2 = true, 4
    // so far so good, the monad returns ("test", 7)
    return "test"
    }

Теперь я пытаюсь использовать петли. Следующие три вызова работают как положено, увеличивая состояние столько раз, сколько есть элементов в myList, Они также возвращают красивый string seqОчевидно, кроме последнего звонка:

    let myList = ["one"; "two"; "three"] // define test data

    let! var3 = stateful.For(myList, (fun x -> x, 1))
    let! var4 = forLoop myList (fun x -> x, 1)

    // No return value, as expected
    for str in myList do
        let! _ = str, 1
        return ""

Но следующее не компилируется: error FS0001: This expression was expected to have type M<'a,int> but here has type unit

    let! var5 =
        for str in myList do
            let! _ = str, 1
            return ""

Поэтому мой вопрос - что я делаю не так?

Я также немного запутался с двумя перегрузками For описано здесь и как использовать оба.

Answer 1

Код, который вы пытаетесь написать, не является синтаксически допустимым выражением вычисления. Синтаксис не допускает конструкции выражения вычисления в выражении e в let! v = e,

Если вы хотите использовать вложенное выражение для вычисления, вы должны написать:

let mtest = stateful {
  let! var5 = 
    stateful { for str in myList do 
                 let! _ = str, 1 
                 return "" }
  return "something here" }

Это должно ответить на ваш немедленный вопрос, но есть ряд вещей, которые я нахожу довольно запутанными в ваших определениях:

• Тип вашего For сбивает с толку. Должно быть либо seq<'T> -> ('T -> M<'R>) -> M<'R> (если ваша монада может объединять несколько результатов) или seq<'T> -> ('T -> M<unit>) -> M<unit> (если ваши вычисления возвращают только одно значение)

• Вы иногда используете seq<'T> внутри M<_> в результате (в For), но иногда ваша монада возвращает только одно значение. Вы должны использовать один и тот же монадический тип везде.

• For конструкция может быть определена с точки зрения Zero а также Combine, Если вы не делаете что-то особенное, это лучший способ. Смотрите пример в спецификации F#.

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