3

各ステップの後に継続のようなものを返す式を作成するビルダーを作成したいと思います。

このようなもの：

module TwoSteps = 
  let x = stepwise {
    let! y = "foo"
    printfn "got: %A" y
    let! z = y + "bar"
    printfn "got: %A" z
    return z
  }

  printfn "two steps"
  let a = x()
  printfn "something inbetween"
  let b = a()

'let a'行は、後で評価される残りの式を含むものを返します。

ステップ数ごとに別々のタイプでこれを行うのは簡単ですが、もちろん特に便利ではありません。

type Stepwise() =
  let bnd (v: 'a) rest = fun () -> rest v
  let rtn v = fun () -> Some v
  member x.Bind(v, rest) = 
    bnd v rest
  member x.Return v = rtn v

let stepwise = Stepwise()

module TwoSteps = 
  let x = stepwise {
    let! y = "foo"
    printfn "got: %A" y
    let! z = y + "bar"
    printfn "got: %A" z
    return z
  }

  printfn "two steps"
  let a = x()
  printfn "something inbetween"
  let b = a()

module ThreeSteps = 
  let x = stepwise {
    let! y = "foo"
    printfn "got: %A" y
    let! z = y + "bar"
    printfn "got: %A" z
    let! z' = z + "third"
    printfn "got: %A" z'
    return z
  }

  printfn "three steps"
  let a = x()
  printfn "something inbetween"
  let b = a()
  printfn "something inbetween"
  let c = b()

そして、結果は私が探しているものです：

two steps
got: "foo"
something inbetween
got: "foobar"
three steps
got: "foo"
something inbetween
got: "foobar"
something inbetween
got: "foobarthird"

しかし、私はこれの一般的なケースがどうなるかを理解することはできません。

私が欲しいのは、このワークフローにイベントをフィードできるようにすることです。そうすれば、次のように書くことができます。

let someHandler = Stepwise<someMergedEventStream>() {
  let! touchLocation = swallowEverythingUntilYouGetATouch()
  startSomeSound()
  let! nextTouchLocation = swallowEverythingUntilYouGetATouch()
  stopSomeSound()
}

そして、イベントがワークフローの次のステップへの移動をトリガーするようにします。（特に、私はこの種のことをMonoTouchで遊んでみたいと思っています-iPhoneのF＃。objcセレクターを回すと私は狂気になります。）

4

2 に答える 2

2

実装の問題は、Bindの呼び出しごとに「unit->'a」を返すことです。そのため、ステップ数が異なれば、異なるタイプの結果が得られます（一般に、これはモナド/計算の疑わしい定義です。表現）。

正しい解決策は、任意のステップ数で計算を表すことができる他のタイプを使用することです。また、2つのタイプのステップを区別する必要があります。一部のステップは計算の次のステップを評価するだけで、一部のステップは（returnキーワードを介して）結果を返します。タイプを使用しますseq<option<'a>>。これは遅延シーケンスであるため、次の要素を読み取ると、計算の次のステップが評価されます。シーケンスには、を使用して返される結果を表すNone最後の値であるを除いて、値が含まれます。Some(value)return

実装におけるもう1つの疑わしい点は、非標準タイプのBindメンバーです。バインドが最初のパラメーターとして値をとるという事実は、コードが少し単純に見えることを意味します（書くことができますlet! a = 1）が、段階的な計算を構成することはできません。あなたは書くことができるようになりたいかもしれません：

let foo() = stepwise { 
  return 1; }
let bar() = stepwise { 
  let! a = foo()
  return a + 10 }

上で説明したタイプを使用すると、これも記述できます。Bind型を取得したら、Return実装内の型シグネチャに従う必要があります。これを取得します。

type Stepwise() = 
  member x.Bind(v:seq<option<_>>, rest:(_ -> seq<option<_>>)) = seq {
    let en = v.GetEnumerator()
    let nextVal() = 
      if en.MoveNext() then en.Current
      else failwith "Unexpected end!" 
    let last = ref (nextVal())
    while Option.isNone !last do
      // yield None for each step of the source 'stepwise' computation
      yield None
      last := next()
    // yield one more None for this step
    yield None      
    // run the rest of the computation
    yield! rest (Option.get !last) }
  member x.Return v = seq { 
    // single-step computation that yields the result
    yield Some(v) }

let stepwise = Stepwise() 
// simple function for creating single-step computations
let one v = stepwise.Return(v)

それでは、次のタイプの使用を見てみましょう。

let oneStep = stepwise {
  // NOTE: we need to explicitly create single-step 
  // computations when we call the let! binder
  let! y = one( "foo" ) 
  printfn "got: %A" y 
  return y + "bar" } 

let threeSteps = stepwise { 
  let! x = oneStep // compose computations :-)
  printfn "got: %A" x 
  let! y = one( x + "third" )
  printfn "got: %A" y
  return "returning " + y }

計算を段階的に実行する場合は、たとえばF＃forキーワードを使用して、返されたシーケンスを単純に繰り返すことができます。以下は、ステップのインデックスも出力します。

for step, idx in Seq.zip threeSteps [ 1 .. 10] do
  printf "STEP %d: " idx
  match step with
  | None _ -> ()
  | Some(v) -> printfn "Final result: %s" v

お役に立てれば！

PS：この問題は非常に興味深いと思いました！自分のブログのブログ投稿（http://tomasp.net/blog）に自分の回答を追加してもよろしいですか？ありがとう！

于 2010-01-08T20:01:27.973 に答える
1

モナドと計算ビルダーは私を混乱させますが、私は以前のSO投稿で作成したものを適応させました。たぶん、いくつかの断片が役立つ可能性があります。

以下のコードには、アクションキューと、Clickイベントがアクションキューで使用可能な次のアクションをリッスンするフォームが含まれています。以下のコードは、4つのアクションが連続している例です。FSIで実行し、フォームのクリックを開始します。

open System.Collections.Generic
open System.Windows.Forms

type ActionQueue(actions: (System.EventArgs -> unit) list) =
    let actions = new Queue<System.EventArgs -> unit>(actions) //'a contains event properties
    with
        member hq.Add(action: System.EventArgs -> unit) = 
           actions.Enqueue(action)
        member hq.NextAction = 
            if actions.Count=0 
                then fun _ -> ()
                else actions.Dequeue()

//test code
let frm = new System.Windows.Forms.Form()

let myActions = [
    fun (e:System.EventArgs) -> printfn "You clicked with %A" (e :?> MouseEventArgs).Button
    fun _ -> printfn "Stop clicking me!!"
    fun _ -> printfn "I mean it!"
    fun _ -> printfn "I'll stop talking to you now."
    ]

let aq = new ActionQueue(myActions)

frm.Click.Add(fun e -> aq.NextAction e)

//frm.Click now executes the 4 actions in myActions in order and then does nothing on further clicks
frm.Show()

フォームを4回クリックすると、それ以上クリックしても何も起こりません。次のコードを実行すると、フォームはさらに2回応答します。

let moreActions = [
    fun _ -> printfn "Ok, I'll talk to you again. Just don't click anymore, ever!"
    fun _ -> printfn "That's it. I'm done with you."
    ]

moreActions |> List.iter (aq.Add)
于 2010-01-08T11:10:16.070 に答える