Scala a-t-il un équivalent de C# yield?

le détournement du mot yield distrait ici de son intention habituelle: comme marqueur d'entrée/sortie dans un coroutine . Le C# BreadthFirstIterator dans l'exemple ci-dessus semble utiliser yield dans son sens de coroutine; après qu'une valeur est retournée par yield , l'appel suivant à actif BreadthFirstIterator 's IEnumerable continuera avec l'énoncé suivant après yield .

In C#, yield est couplé à l'idée d'itération plutôt que d'être un énoncé de flux de contrôle plus général, mais dans ce domaine limité son comportement est celui d'une coroutine. Le de Scala délimité les continuations peut permettre de définir des coroutines. D'ici là, Scala n'a pas cette capacité, d'autant plus que sa signification alternative est yield .

Oui, c'est fait, vous pouvez regarder cette question pour la réponse: Quel est le rendement de Scala?

Voici les docs de Scala pour ce type de construction: http://www.scala-lang.org/node/111

mise à jour:

ce blog parle de C # yield et Scala: http://hestia.typepad.com/flatlander/2009/01/scala-for-c-programmers-part-1-mixins-and-traits.html

il donne quelques détails sur la façon dont les extensions sont utilisées pour rendre le travail IENumerable par rapport à l'utilisation de Traits dans Scala.

donc, vous avez raison que le rendement ne fonctionnera pas de la même manière à Scala que C#, mais c'est parce qu'ils sont très différents, et donc si vous voulez faire ce pain D'abord comme Trait alors vous pouvez appeler le map() et les méthodes filter et foreach , tout comme vous le feriez dans C#, mais le trait aidera à résoudre le problème de la façon de traverser la collection.

même si Scala a un mot-clé yield , il est tout à fait différent du C# yield , et yield de Ruby est différent des deux. Il semble être un mot-clé sauvagement surutilisé. L'utilisation de yield dans C# semble très limitée à première vue.

pour faire la même chose à Scala, vous pourriez définir votre propre fonction de haut ordre. En français, cela signifie une fonction qui prend une fonction comme paramètre.

prendre Exemple de Microsoft , voici une méthode 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))}
  }
}

Maintenant vous avez votre "iterator":

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

Notes:

• Powers(2,8) est le même que Powers.apply(2,8) . C'est juste un compilateur truc.
• cette méthode est définie avec deux listes de paramètres, qui peuvent prêter à confusion. Il vous permet juste de faire: Powers(2, 8){ println(_) } au lieu de Powers(2, 8, {println(_)})

Scala: 1, C#: 0

mise à Jour:

pour votre exemple ajouté, écrivez traverse qui fait la traversée que vous voulez sans penser à la façon dont vous allez l'utiliser. Ajouter ensuite un paramètre supplémentaire en ajoutant (f(Node) => Any) après la liste des paramètres traverse , par exemple

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

Au point traverse , où vous avez une valeur yield avec in C#, appelez f(yieldValue) .

Lorsque vous souhaitez utiliser cette "itérateur" appel traverse et passer à une fonction qui fait tout ce que vous voulez faire pour chaque élément de l'itérateur.

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

il s'agit d'un cas de base pour la" programmation fonctionnelle " et vous devez vous assurer que vous comprenez Qu'il est réussi avec Scala.

vous pouvez le faire dans Scala >= 2.8 en utilisant une implémentation de générateurs en termes de continuations délimitées. Vous aurez besoin du suite plugin et puis quelque chose dans ce sens,

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)
      }
    }
  }
}

comme déjà mentionné vous pourriez créer un générateur en utilisant les continuations-plugin pour créer un rendement qui se comporte exactement comme 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( () )
      ()
    }

}

venant d'un arrière-plan C# et ayant débogué le code Scala de hotzen(adapté à Scala 2.11.6), je dois dire que cette utilisation de continuations se rapproche de L'équivalent C# - yield. Je ne sais pas si les continuations fonctionneraient encore de la même manière si plusieurs générateurs étaient nécessaires, fonctionnant tous selon les mêmes méthodes ou éventuellement répartis sur différentes méthodes, mais je suis heureux que les continuations existent, de sorte que je ne suis pas forcé de travailler avec plusieurs fils pour obtenir similaire, ou passer le long les rappels.