F# 什么'；这是在F中执行委托多播之类的操作的最简单方法#

目前我使用这个，效果很好：

let mutable notify = fun x -> x
let wrap f i = f(i); i

let a x = printf "%A" x
notify <- notify >> (wrap a)

notify "ss"

let mutable notify=fun x->x
设f i=f（i）；我
设a x=printf“%a”x
通知>（包装a）
通知“ss”

还有其他更好的方法吗

为什么这不起作用

let mutable notify = fun x -> x
let wrap f i = f(i); i

let a x = printf "%A" x  
let d x =
    (notify >> (wrap a)) x
notify <- d

notify "ss"

let mutable notify=fun x->x
设f i=f（i）；我
设a x=printf“%a”x
让dx=
（通知>>（包装a））x
notify我认为在函数式编程范例中，组成多个处理程序的方法是每个处理程序尾部调用其第一个参数，传递其余参数。然后与另一个处理程序进行比较，形成一个处理程序链或单链接列表。
我认为在函数式编程范例中，组成多个处理程序的方法是每个处理程序尾部调用其第一个参数，传递其余参数。然后将其与另一个处理程序聚合，形成一个处理程序链或单链接列表。
您不想使用
多播委托

type D<'T> = delegate of 'T -> 'T
let mutable notify = D<string>(fun x -> x)
let wrap f i = f(i); i
let a x = printfn "%A" x
notify <- Delegate.Combine(notify, D<string>(wrap a)) :?> _
notify.Invoke "ss"

类型D'T
让可变通知=D（乐趣x->x）
设f i=f（i）；我
设a x=printfn“%a”x
通知_
通知。调用“ss”

您的第二个示例失败，因为
d
调用
notify
，它无限循环。
您不想使用
多播委托吗

type D<'T> = delegate of 'T -> 'T
let mutable notify = D<string>(fun x -> x)
let wrap f i = f(i); i
let a x = printfn "%A" x
notify <- Delegate.Combine(notify, D<string>(wrap a)) :?> _
notify.Invoke "ss"

类型D'T
让可变通知=D（乐趣x->x）
设f i=f（i）；我
设a x=printfn“%a”x
通知_
通知。调用“ss”

您的第二个示例失败，因为
d
调用
notify
，它无限递归。
这里有一个简单的替代方法。如果您想表示一个要调用的函数列表，那么为什么不保留一个（可变）函数列表呢

let handlers = ResizeArray()
let notify x = 
    for f in handlers do
        f x

handlers.Add(fun x -> printf "%A" x)

notify "ss"

这里有一个简单的选择。如果您想表示一个要调用的函数列表，那么为什么不保留一个（可变）函数列表呢

let handlers = ResizeArray()
let notify x = 
    for f in handlers do
        f x

handlers.Add(fun x -> printf "%A" x)

notify "ss"

我认为额外的间接层次是由
d
，而不是
>
引起的。我认为额外的间接层次是由
d
，而不是
引起的。