F# 的 monad 实现在可用关键字数量方面是否独特？

Question

我只知道F#。我还没有学过其他的函数式编程语言。我见过的所有关于 monad 的例子都只描述了 bind 和 unit 方法。 F# 有很多关键字（例如 let!、do! 等），允许您在同一计算表达式中执行不同的操作。这似乎为您提供了比基本绑定和单位方法更多的功能。这是 F# 独有的还是在函数式编程语言中很常见？

Answer 1

Monad 是根据 bind 和 unit 操作（仅）来定义的。还有其他由其他操作定义的结构（例如，在 Haskell 中，MonadPlus 类型类具有 zero 和 plus 操作 - 这些对应于 Zero 和F# 计算表达式中的Combine）。据我所知，F# 的计算构建器在为它们支持的各种操作提供良好的语法方面是独一无二的，但大多数操作与 monad 无关。

Answer 2

以 ! 结尾的 F# 绑定形式表示计算表达式，包括 let!使用！做！屈服！返回！。

let! pat = expr in comp-expr         -- binding computation

do!  expr in comp-expr               -- sequential computation

use! pat = expr in comp-expr         -- auto cleanup computation

yield! expr                          -- yield computation

return! expr                         -- return computation

计算表达式用于“F# 表达式语法的序列和其他非标准解释”。这些语法形式提供了重载该语法的方法，例如，对一元计算或幺半群计算进行编码，并且看起来类似于 Haskell 的 do-notation 以及相应的（非魔法）该语言的绑定形式。

所以我想说，它们支持某种语法重载，以支持该语言的表达式语法的其他解释，这与许多语言（包括 Haskell 和 OCaml）都有共同点。这无疑是一个强大且有用的语言功能。

---

参考文献：F# 2.0 语言规范。

Answer 3

（凭记忆回忆一下，我可能跑题了。）

虽然我认为 unit 和 bind 是 monad 的典型基础，但我认为也许 map 和join 以获得我在学术论文中看到的不同基础。这有点像 LINQ 在 C# 和 VB 中的工作方式，其中各种 from 语法脱糖为 Select 或 SelectMany ，类似于 地图和加入。 LINQ 还有一些“额外”关键字，有点像 F#，但更临时（并且最适合查询枚举/数据库）。

我暂时不知道像 F# 这样的其他函数式语言可以有效地将大部分控制流和其他语法“提升”到 monad 中（好吧，“计算表达式”，可能是也可能不是 monad）。

Answer 4

是的，我认为计算表达式的 F# 语法是独特的，因为它为不同类型的计算提供直接语法支持。它可用于处理 monoids、常见的 monad 以及来自 Haskell 的 MonadPlus 计算。

我在我的硕士论文的简介中写了这些内容。我认为这是一个很好读的部分，所以你可以到第27页来阅读。无论如何，我将在这里复制示例：

Monoid 仅用于使用某些“+”操作（Combine）连接值。例如，您可以使用它来构建字符串（这是低效的，但它演示了这个想法）：

type StringMonoid() =
  member x.Combine(s1, s2) = String.Concat(s1, s2)
  member x.Zero() = ""
  member x.Yield(s) = s

let str = new StringMonoid()

let hello = str { yield "Hello "
                  yield "world!" };;

Monad 是使用 bind 和 return 的熟悉示例em> 计算表达式的运算。例如，也许 monad 表示在任何时候都可能失败的计算：

type MaybeMonad() =
  member x.Bind(m, f) =
    match m with Some(v) -> f v | None -> None
  member x.Return(v) = Some(v)

let maybe = new MaybeMonad()

let rec productNameByID() = maybe {
  let! id = tryReadNumber()
  let! prod = db.TryFindProduct(id)
  return prod.Name }

Additive monads（在 Haskell 中又名 MonadPlus）是两者的组合。它有点像可以产生多个值的一元计算。一个常见的例子是列表（或序列），它可以实现绑定和组合：

type ListMonadPlus() =
  member x.Zero() = []
  member x.Yield(v) = [v]
  member x.Combine(a, b) = a @ b
  member x.Bind(l, f) = l |> List.map f |> List.concat

let list = new ListMonadPlus()

let cities = list {
  yield "York"
  yield "Orleans" }
let moreCities = list {
  let! n = cities
  yield n
  yield "New " + n }

// Creates: [ "York"; "New York"; "Orleans"; "New Orleans" ]

还有一些额外的功能不直接对应于任何理论思想的关键词。 use 关键字处理资源，for 和 while 可用于实现循环。序列/列表理解实际上使用 for 而不是 let!，因为从语法的角度来看，这更有意义（并且 for 通常需要一些顺序 - 尽管它可能是异步的）。