scalaz折叠式组合

我有下一个密码

val listOption: List[Option[Int]] = List(1.some, none, 2.some)

val result = listx.fold(0.some)((acc, el) => {
  (acc, el) match {
    case (Some(a), Some(b)) => Some(a + b)
    case (Some(a), _) => Some(a)
    case (_, Some(b)) => Some(b)
    case _ => el
  }
})
println(result.getOrElse(0)) // => 3 

我想折叠元素，我写下一段代码

val listOption: List[Option[Int]] = List(1.some, none, 2.some)

val result = listx.fold(0.some)((acc, el) => {
  (acc, el) match {
    case (Some(a), Some(b)) => Some(a + b)
    case (Some(a), _) => Some(a)
    case (_, Some(b)) => Some(b)
    case _ => el
  }
})
println(result.getOrElse(0)) // => 3 

这很好，但我在scalaz源代码中看到了下一个例子

val composeFold = Foldable[List] compose Foldable[Option]
composeFold.fold(listOption) // => 3

---

但我不明白它是如何正确工作的，为什么scalaz不将此方法混合到

listOption

实例中，以及scala

fold

和scalaz

fold
之间的区别scalaz
fold
函数使用元素的
Monoid
实例，因此，您不必提供起始值和函数来组合元素

Monoid
有两个函数
zero
/
empty
和
append
/
合并
。对于
Int
这可能是：

val intMonoid = new Monoid[Int] {
  def zero = 0
  def append(a: Int, b: => Int) = a + b
}

使用这个
Monoid[Int]
我们可以将Scalaz
fold
写成Scala
fold
：

import scalaz.Foldable
import scalaz.std.list._
import scalaz.std.anyVal._

val numbers = List(1,2,3)
Foldable[List].fold(numbers)                          // 6
// analogous to the following Scala fold
numbers.fold(intMonoid.zero)(intMonoid.append(_,_))   // 6

import scalaz.syntax.foldable._
List(1,2,3).concatenate  // 6
1.some.concatenate       // 1

List(1.some, none, 2.some).concatenate.concatenate  // 3

我们可以将
可折叠[列表]
和
可折叠[选项]
组合在一起，如您所示：

import scalaz.std.option._
Foldable[List].fold(List(1,2))    // 3

Foldable[Option].fold(1.some)     // 1
Foldable[Option].fold(none[Int])  // 0

val foldListO = Foldable[List] compose Foldable[Option]
foldListO.fold(List(1.some, none, 2.some))  // 3

您可以使用
foldable
语法导入并使用
concatenate
或
suml
/
sumr
（也有
fold
，但它与
List.fold
和
选项冲突。fold
）：


除了像
scalaz.std.list.\u
和
scalaz.syntax.foldable.\u
这样的特定导入之外，您还可以将uber导入与
import scalaz.\u
结合使用元素的
Monoid
实例，因此，您不必提供起始值和函数来组合元素

Monoid
有两个函数
zero
/
empty
和
append
/
合并
。对于
Int
这可能是：

val intMonoid = new Monoid[Int] {
  def zero = 0
  def append(a: Int, b: => Int) = a + b
}

使用这个
Monoid[Int]
我们可以将Scalaz
fold
写成Scala
fold
：

import scalaz.Foldable
import scalaz.std.list._
import scalaz.std.anyVal._

val numbers = List(1,2,3)
Foldable[List].fold(numbers)                          // 6
// analogous to the following Scala fold
numbers.fold(intMonoid.zero)(intMonoid.append(_,_))   // 6

import scalaz.syntax.foldable._
List(1,2,3).concatenate  // 6
1.some.concatenate       // 1

List(1.some, none, 2.some).concatenate.concatenate  // 3

我们可以将
可折叠[列表]
和
可折叠[选项]
组合在一起，如您所示：

import scalaz.std.option._
Foldable[List].fold(List(1,2))    // 3

Foldable[Option].fold(1.some)     // 1
Foldable[Option].fold(none[Int])  // 0

val foldListO = Foldable[List] compose Foldable[Option]
foldListO.fold(List(1.some, none, 2.some))  // 3

您可以使用
foldable
语法导入并使用
concatenate
或
suml
/
sumr
（也有
fold
，但它与
List.fold
和
选项冲突。fold
）：


除了像
scalaz.std.list.\u
和
scalaz.syntax.foldable.\u
这样的特定导入之外，您还可以将uber导入与
import scalaz.\uu，scalaz.\u
从FoldableSyntax连接起来，但在源代码中我看到FoldableSyntax有fold方法：
final def fold（隐式A:Monoid[A]）：A=F.fold（self）（A）
如何在可折叠语法中调用fold而不是从scala中调用fold？
从可折叠语法中连接
，但在源代码中我看到可折叠语法中有fold方法：
最终定义fold（隐式A:Monoid[A]）：A=F.fold（self）（A）
如何在可折叠语法中调用fold而不是从scala中调用fold？