Scala 是否有相当于 C# 的产量？

Question

我是 Scala 的新手，据我了解，Scala 中的ield 并不像C# 中的yield，它更像是select。

Scala有类似C#的yield的东西吗？ C# 的yield 非常好，因为它使编写迭代器变得非常容易。

更新：这是一个来自 C# 的伪代码示例，我希望能够在 Scala 中实现：

public class Graph<T> {
   public IEnumerable<T> BreadthFirstIterator() {
      List<T> currentLevel = new List<T>();
      currentLevel.add(_root);

      while ( currentLevel.count > 0 ) {
         List<T> nextLevel = new List<T>();
         foreach( var node in currentLevel ) {
            yield return node;
            nextLevel.addRange( node.Children );
         }
         currentLevel = nextLevel;
      }
   }
}

此代码使用yield 实现图的迭代广度优先遍历，它返回一个迭代器，以便调用者可以使用常规的 for 循环遍历图形，例如：

graph.BreadthFirstIterator().foreach( n => Console.WriteLine( n ) );

在 C# 中，yield 只是语法糖，可以轻松编写迭代器（.Net 中的 IEnumerable，类似于 Java 中可迭代）。作为一个迭代器，它的计算是惰性的。

更新 II： 我在这里可能是错的，但我认为 C# 中的yield 的全部意义在于让您不必编写更高阶的函数。例如，您可以编写常规 for 循环或使用诸如 select/map/filter/where 之类的方法而不是传入一个函数，然后该函数将遍历该序列。

例如，graph.iterator().foreach(n => println(n)) 而不是 graph.iterator( n => println(n))。

这样你就可以轻松链接它们，例如 graph.iterator().map(x => x.foo).filter(y => y.bar >= 2).foreach(z => println(z))。

Answer 1

这里对单词“yield”的劫持偏离了它通常的意图：作为 协程。上面示例中的 C# BreadthFirstIterator 似乎在协程意义上使用了 yield；在 yield 返回值后，对活动 BreadthFirstIterator 的 IEnumerable 的下一次调用将继续执行 yield< 之后的下一条语句/代码>。

在 C# 中，yield 与迭代的思想相结合< /a> 不是一个更通用的控制流语句，但在该有限域内，它的行为是协程的行为。 Scala 的分隔延续可以允许定义协程。在那之前，Scala 缺乏这样的功能，特别是考虑到它的 yield 的替代含义。

Answer 2

是的，您可能想看看这个问题的答案：
Scala 的产量是多少？

以下是 Scala 中针对此类构造的文档：
http://www.scala-lang.org/node/111

更新：

此博客讨论了 C# Yield 和 Scala：
http: //hestia.typepad.com/flatlander/2009/01/scala-for-c-programmers-part-1-mixins-and-traits.html

他详细介绍了如何使用扩展来制作与在 Scala 中使用 Traits 相比，IEnumerable 的工作量更大。

所以，你是对的，yield 在 Scala 中的功能与 C# 不同，但那是因为它们非常不同，所以如果你想将 BreadthFirst 作为 Trait 来执行，那么你可以调用 map( ) 和 filter 和 foreach 方法，就像在 C# 中一样，但该特征将有助于解决如何遍历集合的问题。

Answer 3

我认为答案（除非 2.8 中发生变化）答案是否定的，Scala 没有类似于 C# 的yield 的语法糖来编写迭代器（IEumerable 或 Iterable 的实现）。

然而，在 Scala 中，您可以通过向遍历传递一个函数来实现类似的结果，该函数将在遍历中的每个项目上调用该函数。这种方法也可以在 C# 中以相同的方式实现。

以下是我在 C# 中编写 Traverse 的方法，而不使用 Yield：

public class Graph<T> {
   public void BreadthFirstTraversal( Action<T> f) {
      List<T> currentLevel = new List<T>();
      currentLevel.add(_root);

      while ( currentLevel.count > 0 ) {
         List<T> nextLevel = new List<T>();
         foreach( var node in currentLevel ) {
            f(node);
            nextLevel.addRange( node.Children );
         }
         currentLevel = nextLevel;
      }
   }
}

然后您可以像这样使用它：

graph.BreadthFirstTraversal( n => Console.WriteLine( n ) );

或者像这样：

graph.BreadthFirstTraversal( n =>
{
   Console.WriteLine(n);
   DoSomeOtherStuff(n);
});

Answer 4

尽管 Scala 有一个关键字 yield，但它与 C# yield 有很大不同，Ruby 的 yield 也与两者不同。这似乎是一个被过度使用的关键字。乍一看，yield 在 C# 中的使用似乎非常有限。

要在 Scala 中执行相同的操作，您可以定义自己的高阶函数。在英语中，这意味着一个以函数作为参数的函数。

要采用 Microsoft 的示例，这里有一个 Scala 方法：

object Powers {
  def apply(number:Int, exponent:Int) (f:(Double) => Any) = {
    (new Range(1,exponent+1,1)).map{exponent => f(Math.pow(number, exponent))}
  }
}

现在你有了你的“迭代器”：

scala> Powers(2,8){ println(_) }
2.0
4.0
8.0
16.0
32.0
64.0
128.0
256.0

注意：

• Powers(2,8) 与 Powers.apply(2,8) 相同。这只是一个编译器技巧。
• 该方法定义了两个参数列表，这可能会令人困惑。它只是允许您执行以下操作： Powers(2, 8){ println(_) } 而不是 Powers(2, 8, {println(_)})

Scala： 1，C#：0

---

更新：

对于您刚刚添加的示例，编写 traverse 来执行您想要的遍历，而无需考虑如何使用它。然后通过在traverse参数列表后面添加(f(Node) => Any)来添加额外的参数，例如

def traverse(node:Node, maxDepth:Int)(f(Node) => Any)) { ... }

在traverse中的点如果您有一个在 C# 中yield 的值，请调用 f(yieldValue)。

当您想要使用此“迭代器”时，请调用 traverse 并向其传递一个函数，该函数可以为迭代器中的每个元素执行您想要执行的操作。

traverse(node, maxDepth) { (yieldValue) =>
  // this is f(yieldValue) and will be called for each value that you call f with
  println(yieldValue)
}

这是“函数式编程”的基本案例，您应该确保理解它才能成功使用 Scala。

Answer 5

您可以在 Scala >= 2.8 中使用分隔延续的生成器实现来执行此操作。您需要延续插件，然后是类似的东西，

import scala.continuations._
import scala.continuations.ControlContext._

object Test {

  def loopWhile(cond: =>Boolean)(body: =>(Unit @suspendable)): Unit @suspendable = {
    if (cond) {
      body
      loopWhile(cond)(body)
    } else ()
  }

  abstract class Generator[T] {
    var producerCont : (Unit => Unit) = null
    var consumerCont : (T => Unit) = null

    protected def body : Unit @suspendable

    reset {
      body
    }

    def generate(t : T) : Unit @suspendable =
      shift {
        (k : Unit => Unit) => {
          producerCont = k
          if (consumerCont != null)
            consumerCont(t)
        }
      }

    def next : T @suspendable =
      shift {
        (k : T => Unit) => {
          consumerCont = k
          if (producerCont != null)
            producerCont()
        }
      }
  }

  def main(args: Array[String]) {
    val g = new Generator[Int] {
      def body = {
        var i = 0
        loopWhile(i < 10) {
          generate(i)
          i += 1
        }
      }
    }

    reset {
      loopWhile(true) {
        println("Generated: "+g.next)
      }
    }
  }
}

Answer 6

正如已经提到的，您可以使用 continuations-plugin 创建一个生成器来创建一个yield，其行为与 C# 完全相同：

import scala.util.continuations._

object GenTest {

    val gen = new Generator[Int] { def produce = {
        yieldValue(1)
        yieldValue(2)
        yieldValue(3)
        Thread.sleep(1000)
        yieldValue(42)
  }}


    def main(args: Array[String]): Unit = {
        for (v <- gen) {
            println(v)
        }
    }
}

abstract class Generator[E] {

    var loopFn: (E => Unit) = null

    def produce(): Unit @cps[Unit]

  def foreach(f: => (E => Unit)): Unit = {
        loopFn = f
        reset[Unit,Unit]( produce )
  }

  def yieldValue(value: E): Unit @cps[Unit] =
    shift { genK: (Unit => Unit) =>
      loopFn( value )
      genK( () )
      ()
    }

}

Answer 7

来自 C# 背景并从 hotzen 调试了 Scala 代码（适应 Scala 2.11.6），我必须说这种延续用法接近于 C#-yield 的等价物。我不知道如果需要多个生成器，以相同的方法运行所有生成器，或者可能分布在不同的方法中，连续性是否仍然会发挥类似的作用，但我很高兴连续性确实存在，这样我就不必被迫使用多个线程来实现类似的，或者传递回调。