Scala 的产量是多少？

Question

我了解 Ruby 和 Python 的产量。 Scala的yield有什么作用？

Answer 1

我认为公认的答案很好，但似乎很多人都未能抓住一些基本点。

首先，Scala 的 for 推导式相当于 Haskell 的 do 表示法，它只不过是多个一元运算组合的语法糖。 由于这个语句很可能不会帮助任何需要帮助的人，所以让我们再试一次......:-)

Scala 的 for 推导式是使用 map、flatMap 和 组合多个操作的语法糖。过滤器。 或者foreach。 Scala 实际上将 for 表达式转换为对这些方法的调用，因此提供它们的任何类或其子集都可以与 for 推导式一起使用。

首先，我们来谈谈翻译。 有非常简单的规则：

1. 这个

   for(x <- c1; y <- c2; z <-c3) {...} 
     

   翻译成

   c1.foreach(x => c2.foreach(y => c3.foreach(z => {...}))) 
     

2. This

   for(x <- c1; y <- c2; z <- c3) 产量 {...} 
     

   翻译成

   c1.flatMap(x => c2.flatMap(y => c3.map(z => {...}))) 
     

3. This

   for(x <- c; if cond) 产量 {...} 
     

   在 Scala 2.7 上被翻译成

   c.filter(x => cond).map(x => {...}) 
     

   或者，在 Scala 2.8 上，进入

   c.withFilter(x => cond).map(x => {...}) 
     

   如果 withFilter 方法不可用，但 filter 可用，则回退到前者。 有关详细信息，请参阅下面的部分。

4. 这个

   for(x <- c; y = ...) 产量 {...} 
     

   翻译成

   c.map(x => (x, ...)).map((x,y) => {...}) 
     

当你查看非常简单的 for 推导式时，map/foreach 替代方案看起来确实如此， 更好的。 然而，一旦开始编写它们，您很容易迷失在括号和嵌套级别中。 当这种情况发生时，for 理解通常会更加清晰。

我将展示一个简单的例子，并故意省略任何解释。 您可以决定哪种语法更容易理解。

l.flatMap(sl => sl.filter(el => el > 0).map(el => el.toString.length))

或者

for {
  sl <- l
  el <- sl
  if el > 0
} yield el.toString.length

---

withFilter

Scala 2.8 引入了一种名为 withFilter 的方法，其主要区别在于，它不是返回一个新的、经过过滤的集合，而是按需进行过滤。 filter 方法的行为是根据集合的严格性定义的。 为了更好地理解这一点，让我们看一下带有 List（严格）和 Stream（非严格）的 Scala 2.7：

scala> var found = false
found: Boolean = false

scala> List.range(1,10).filter(_ % 2 == 1 && !found).foreach(x => if (x == 5) found = true else println(x))
1
3
7
9

scala> found = false
found: Boolean = false

scala> Stream.range(1,10).filter(_ % 2 == 1 && !found).foreach(x => if (x == 5) found = true else println(x))
1
3

之所以会出现差异，是因为 filter 立即与 List 一起应用，返回赔率列表 - 因为 found 为 false。 只有这样 foreach 才会执行，但是此时，更改 found 已经没有意义了，因为 filter 已经执行了。

对于Stream，条件不会立即应用。 相反，当 foreach 请求每个元素时，filter 会测试条件，这使得 foreach 能够通过 found 影响它>。 澄清一下，这里是等效的 for 理解代码：

for (x <- List.range(1, 10); if x % 2 == 1 && !found) 
  if (x == 5) found = true else println(x)

for (x <- Stream.range(1, 10); if x % 2 == 1 && !found) 
  if (x == 5) found = true else println(x)

这导致了很多问题，因为人们期望 if 被视为按需，而不是预先应用于整个集合。

Scala 2.8 引入了 withFilter，它始终是非严格的，无论集合的严格性如何。 以下示例显示了 Scala 2.8 上使用两种方法的 List：

scala> var found = false
found: Boolean = false

scala> List.range(1,10).filter(_ % 2 == 1 && !found).foreach(x => if (x == 5) found = true else println(x))
1
3
7
9

scala> found = false
found: Boolean = false

scala> List.range(1,10).withFilter(_ % 2 == 1 && !found).foreach(x => if (x == 5) found = true else println(x))
1
3

这会产生大多数人期望的结果，而无需更改 filter 的行为方式。 附带说明一下，在 Scala 2.7 和 Scala 2.8 之间，Range 从非严格更改为严格。

Answer 2

它用于 序列推导式（如 Python 的列表推导式和生成器，您可以在其中使用产量）。

它与 for 结合应用，并将新元素写入结果序列中。

简单示例（来自 scala-lang）

/** Turn command line arguments to uppercase */
object Main {
  def main(args: Array[String]) {
    val res = for (a <- args) yield a.toUpperCase
    println("Arguments: " + res.toString)
  }
}

F# 中相应的表达式将是

[ for a in args -> a.toUpperCase ]

Linq 中的or

from a in args select a.toUpperCase 

。

Ruby 的 yield 有不同的效果。

Answer 3

是的，正如 Earwicker 所说，它几乎相当于 LINQ 的 select，并且与 Ruby 和 Python 的 yield 关系不大。 基本上，在 C# 中，您可以

from ... select ??? 

用 Scala

for ... yield ???

编写。同样重要的是要了解 for 推导式不仅适用于序列，还适用于定义某些方法的任何类型，就像 LINQ 一样：

• 如果您的类型仅定义 map，则它允许包含 for 表达式
  单发电机。
• 如果它定义了 flatMap 以及 map，则它允许 for 表达式组成
  几个发电机。
• 如果它定义了foreach，则它允许不带yield的for循环（无论是单个生成器还是多个生成器）。
• 如果它定义了 filter，则允许以 if 开头的 for 过滤表达式
  在 for 表达式中。

Answer 4

除非您从 Scala 用户那里得到更好的答案（我不是），否则这是我的理解。

它仅作为以 for 开头的表达式的一部分出现，该表达式说明如何从现有列表生成新列表。

就像这样：

var doubled = for (n <- original) yield n * 2

所以每个输入都有一个输出项（尽管我相信有一种删除重复项的方法）。

这与其他语言中由yield启用的“命令式延续”有很大不同，它提供了一种从具有几乎任何结构的命令式代码生成任何长度的列表的方法。

（如果您熟悉 C#，它更接近 LINQ 的 select运算符而不是yield return）。

Answer 5

考虑以下内容进行理解

val A = for (i <- Int.MinValue to Int.MaxValue; if i > 3) yield i

如下所示大声朗读可能会有所帮助

” 对于每个整数i，如果它大于3，则产量 (产生）i并将其添加到列表A。”

在数学方面set-builder 表示法，上面的 for 理解类似于

可以读作

"For每个整数 ，如果它大于，那么它是集合 ." 的成员

或

"< img src="https://latex.codecogs.com/gif.latex?A" alt="A"> 是所有整数的集合 ，使得每个 大于 。"

Answer 6

Scala 中的关键字 yield 只是语法糖，可以轻松地用 map 替换，如 Daniel Sobral 已经详细解释了。

另一方面，如果您正在寻找类似于 yield 绝对具有误导性。 moin/Generators" rel="noreferrer">Python 中的。 请参阅此SO线程以获取更多信息： 什么是首选方法在 Scala 中实现“yield”？

Answer 7

Yield 类似于 for 循环，它有一个我们看不到的缓冲区，并且对于每个增量，它都会不断地将下一个项目添加到缓冲区中。 当 for 循环运行结束时，它将返回所有生成值的集合。 Yield 可以用作简单的算术运算符，甚至可以与数组结合使用。
这里有两个简单的例子，可以帮助您更好地理解

scala>for (i <- 1 to 5) yield i * 3

res: scala.collection.immutable.IndexedSeq[Int] = Vector(3, 6, 9, 12, 15)

scala> val nums = Seq(1,2,3)
nums: Seq[Int] = List(1, 2, 3)

scala> val letters = Seq('a', 'b', 'c')
letters: Seq[Char] = List(a, b, c)

scala> val res = for {
     |     n <- nums
     |     c <- letters
     | } yield (n, c)

res: Seq[(Int, Char)] = List((1, a)、(1,b)、(1,c)、(2,a)、(2,b)、(2,c)、(3,a)、(3,b)、(3,c) ）

希望这可以帮助！！

Answer 8

val aList = List( 1,2,3,4,5 )

val res3 = for ( al <- aList if al > 3 ) yield al + 1
val res4 = aList.filter(_ > 3).map(_ + 1)

println( res3 )
println( res4 )

这两段代码是等价的。

val res3 = for (al <- aList) yield al + 1 > 3
val res4 = aList.map( _+ 1 > 3 )

println( res3 ) 
println( res4 )

这两段代码也是等价的。

Map 与产量一样灵活，反之亦然。

Answer 9

val doubledNums = for (n <- nums) yield n * 2
val ucNames = for (name <- names) yield name.capitalize

请注意，这两个 for 表达式都使用 yield 关键字：

在 for 之后使用 yield 是“秘密武器”，它表示“我想要使用所示的算法，从我在 for 表达式中迭代的现有集合中生成一个新集合。”

取自此处

Answer 10

根据Scala 文档，它明确表示“从现有集合中产生一个新集合”。

另一个 Scala 文档说：“Scala 提供了一种轻量级符号来表达序列推导式。推导式的形式为 for（枚举） yield e，其中 enums 指的是以分号分隔的枚举器列表。枚举器要么是引入新变量的生成器，要么是过滤器。

Answer 11

yield 比 map() 更灵活，请参见下面的示例，

val aList = List( 1,2,3,4,5 )

val res3 = for ( al <- aList if al > 3 ) yield al + 1 
val res4 = aList.map( _+ 1 > 3 ) 

println( res3 )
println( res4 )

yield 将打印结果，如：List(5, 6)，这很好，

而 map() 将返回结果，如：List(false, false, true, true, true)，这可能不是你想要的。