Как определить Yield и For для пользовательской операции вычисления в F#

Question

Я работаю над DSL для своего приложения, и вот как я определил тип вычисления и конструктор:

// expression type
type Action<'a,'b> = Action of ('a -> Async<'b>)

let runAction (Action r) ctx = r ctx
let returnF a = Action (fun _ -> async {return a})
let bind m f = Action (fun r -> async {
    let! a = runAction m r in return! runAction (f a) r
    })

let bindA ac f = Action (fun r -> async {
    let! a = ac in return! runAction (f a) r
    })

type ActionBuilder<'x>() =
  member this.Return(c) = returnF c
  member this.Zero()    = returnF ()
  member this.Delay(f)  = bind (returnF ()) f

  // binds both monadic and for async computations
  member this.Bind(m, f) = bind m f
  member this.Bind(m, f) = bindA m f

  member this.Combine(r1, r2) = bind r1 (fun () -> r2)
  member this.For(s:seq<_>, f)  = Action (fun x -> async {
    for i in s do runAction (f i) x |> ignore
    })

  // here's the attempt to implement 'need' operations

  [<CustomOperation("need")>]
  member this.Need(Action a,  targets: string list) =
    Action (fun x ->
      let r = a x
      printfn "need(%A, [%A])" a targets
      r)

   member this.For(a, f)  = bindA a f
   member this.Yield(()) =
    returnF ()

let action = ActionBuilder<string>()

/////////////////////////////////////////////////////////////
// other functions for Action

/// Gets action context
let getCtx = Action (fun ctx -> async {return ctx})


let needFn res = action {
    let! ctx = getCtx
    printfn "need([%A]) in %A" res ctx
  }

Результирующий код должен быть:

let program1 = fun filename -> action {
  let! a = async {return 123}
  let f = a+1

  // need ["def"; "dd"]
  do! needFn ["def"; "dd"]
  printfn "after need"

  for i in [0..10] do
    do! Async.Sleep (1)
    printfn "i: %A" i

  let! d = async {return f}
  let! ctx = getCtx
  printfn "ctx: %A, %A" ctx f
}

Async.RunSynchronously(runAction (program1 "m.c") "abc")

Теперь я хотел бы изменить do! needFn ["def"; "dd"] Синтаксис лучше, определяя пользовательскую операцию "потребность", но получая различные жалобы от компилятора. Это правильный подход или я неправильно использую выражения вычислений?

Другая проблема заключается в том, что для не работает, если сделать! используется внутри тела цикла

Answer 1

После прочтения статей методом проб и ошибок я пришел к следующему for реализация (Yield метод построения не обязателен):

    let forF (e: seq<_>) prog =
    usingF (e.GetEnumerator()) (fun e ->
        whileF
            (fun () -> e.MoveNext())
            ((fun () -> prog e.Current) |> delayF)
    )

Полный исходный код для построителя выражений вычислений можно найти в целевом проекте. Весь проект представляет собой разновидность системы сборки Fake.

Примечание: действие было переименовано в рецепт. need оператор не может быть реализован вообще.