Есть ли у Scala эквивалент C# yield?
Я новичок в Scala, и, насколько я понимаю, yield в Scala не похож на yield в C#, он больше похож на select.
Есть ли у Scala что-то похожее на выход C#? Выход C# велик, потому что он делает написание итераторов очень простым.
Обновление: вот пример псевдокода из 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 является просто синтаксическим сахаром, облегчающим написание итератора (IEnumerable<T> в.Net, аналогично Iterable на Яве). Как итератор, его оценивают лениво.
Обновление II: я могу ошибаться, но я думаю, что весь смысл yield в C# заключается в том, что вам не нужно писать функцию более высокого порядка. Например, вы можете написать регулярный цикл или использовать такой метод, как 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)),
7 ответов
Я думаю, что ответ (за исключением изменений в 2.8) заключается в том, что ответ - нет, Scala не имеет синтаксического сахара, похожего на выход C# для написания итераторов (реализации IEumerable или Iterable).
Однако в Scala вы могли бы достичь аналогичного результата, передав функцию обходу, которую она будет вызывать для каждого элемента в обходе. Этот подход также может быть реализован таким же образом в C#.
Вот как я бы написал Traverse в C# без использования 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);
});
Угон слова " выход" здесь отвлекает от его обычного намерения: в качестве маркера входа / выхода в сопрограмме. C# BreadthFirstIterator в приведенном выше примере, кажется, использовать yield в его сопрограммном смысле; после того, как значение возвращается yield, следующий звонок на активный BreadthFirstIterator"s IEnumerable продолжит со следующим заявлением после yield,
В C# yield связан с идеей итерации, а не является более общим оператором потока управления, но в пределах этой ограниченной области его поведение соответствует поведению сопрограммы. Разграниченные в Scala продолжения могут позволять определять сопрограммы. До этого у Scala нет такой возможности, особенно учитывая ее альтернативное значение для yield,
Да, возможно, вы можете посмотреть на этот вопрос, чтобы получить ответ: какова доходность 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
Он подробно расскажет о том, как расширения используются для работы IENumerable по сравнению с использованием черт в Scala.
Итак, вы правы, что yield не будет работать в Scala так же, как в C#, но это потому, что они очень разные, и поэтому, если вы хотите сделать BreadthFirst как Trait, вы можете вызвать map() а также filter а также foreach методы, как в C#, но эта особенность поможет решить проблему обхода коллекции.
Вы можете сделать это в 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)
}
}
}
}
Хотя у Scala есть ключевое слово yieldэто сильно отличается от C# yieldи Руби 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 это делает обход, который вы хотите, не думая о том, как вы собираетесь его использовать. Затем добавьте дополнительный параметр, добавив (f(Node) => Any) после traverse список параметров, например
def traverse(node:Node, maxDepth:Int)(f(Node) => Any)) { ... }
В точке traverse где у вас есть значение, которое вы бы yield с в C#, позвоните 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.
Как уже упоминалось, вы можете создать Генератор, используя плагин продолжений, чтобы создать выход, который точно ведет себя как 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( () )
()
}
}
Исходя из фона C# и отладки кода Scala из hotzen(адаптированного к Scala 2.11.6), я должен сказать, что использование этого продолжения близко к эквиваленту C#-производности. Я не знаю, будут ли продолжения функционировать аналогично, если бы потребовалось несколько Генераторов, работающих все в одних и тех же методах или, возможно, распределенных по разным методам, но я рад, что продолжения существуют, так что я не вынужден работать с несколькими потоками для достижения похожи или передают обратные вызовы.