这是我到目前为止所做的:
type Maybe<'a> = option<'a>
let succeed x = Some(x)
let fail = None
let bind rest p =
match p with
| None -> fail
| Some r -> rest r
let rec whileLoop cond body =
if cond() then
match body() with
| Some() ->
whileLoop cond body
| None ->
fail
else
succeed()
let forLoop (xs : 'T seq) f =
using (xs.GetEnumerator()) (fun it ->
whileLoop
(fun () -> it.MoveNext())
(fun () -> it.Current |> f)
)
whileLoop
可以很好地支持for
循环,但我不知道如何获得while循环。部分问题是while循环的转换使用delay
,在这种情况下我无法弄清楚。下面明显的实现可能是错误的,因为它不会延迟计算,而是运行它!
let delay f = f()
没有延迟也会妨碍try...with
和try...finally
。
答案 0 :(得分:12)
在F#中实际上有两种不同的方法来实现延续构建器。一种是使用monadic类型表示延迟计算(如果它支持某种表示延迟计算的方式,如Async<'T>
或unit -> option<'T>
类型,如kkm所示。
但是,您也可以使用F#计算表达式的灵活性,并使用不同的类型作为Delay
的返回值。然后你需要相应地修改Combine
操作并实现Run
成员,但这一切都很顺利:
type OptionBuilder() =
member x.Bind(v, f) = Option.bind f v
member x.Return(v) = Some v
member x.Zero() = Some ()
member x.Combine(v, f:unit -> _) = Option.bind f v
member x.Delay(f : unit -> 'T) = f
member x.Run(f) = f()
member x.While(cond, f) =
if cond() then x.Bind(f(), fun _ -> x.While(cond, f))
else x.Zero()
let maybe = OptionBuilder()
诀窍是当你有一个需要延迟的计算时F#编译器使用Delay
- 即:1)包装整个计算,2)当你顺序组合计算时,例如在计算中使用if
和3)延迟while
或for
的正文。
在上面的定义中,Delay
成员返回unit -> M<'a>
而不是M<'a>
,但这完全正常,因为Combine
和While
取unit -> M<'a>
作为他们的第二个论点。此外,通过添加评估函数的Run
,评估maybe { .. }
块(延迟函数)的结果,因为整个块传递给Run
:
// As usual, the type of 'res' is 'Option<int>'
let res = maybe {
// The whole body is passed to `Delay` and then to `Run`
let! a = Some 3
let b = ref 0
while !b < 10 do
let! n = Some () // This body will be delayed & passed to While
incr b
if a = 3 then printfn "got 3"
else printfn "got something else"
// Code following `if` is delayed and passed to Combine
return a }
这是一种为非延迟类型定义计算构建器的方法,它最有可能比函数内的包装类型更有效(如在kkm的解决方案中),并且它不需要定义该类型的特殊延迟版本。
请注意,此问题不会发生在例如Haskell,因为它是一种惰性语言,所以它不需要显式延迟计算。我认为F#转换非常优雅,因为它允许处理延迟的两种类型(使用返回Delay
的{{1}})和仅代表直接结果的类型(使用M<'a>
返回一个函数&amp; Delay
)。
答案 1 :(得分:5)
根据monadic身份,您的delay
应始终等同于
let delay f = bind (return ()) f
自
val bind : M<'T> -> ('T -> M<'R>) -> M<'R>
val return : 'T -> M<'T>
delay
的签名为
val delay : (unit -> M<'R>) -> M<'R>
'T
与unit
绑定类型。请注意,您的bind
函数的参数与惯用订单bind p rest
相反。这在技术上是相同的,但会使阅读代码变得复杂。
由于您将monadic类型定义为type Maybe<'a> = option<'a>
,因此不会延迟计算,因为类型根本不包含任何计算,只包含一个值。所以你定义延迟let delay f = f()
在理论上是正确的。但它对于while循环是不够的:循环的“body”将在其“test condition”之前计算,实际上在bind
绑定之前。为了避免这种情况,你需要额外的一层延迟来重新定义你的monad:不是包装一个值,而是包装一个带有单位的计算并计算该值。
type Maybe<'a> = unit -> option<'a>
let return x = fun () -> Some(x)
let fail = fun() -> None
let bind p rest =
match p() with
| None -> fail
| Some r -> rest r
请注意,包装计算直到bind
函数内部才会运行,i。即<{1}}的参数绑定后才会运行。
通过上面的表达式,bind
被正确简化为
delay