Каков предпочтительный способ реализации "yield" в Scala?

'yield' отстой, продолжения лучше

на самом деле, в Python yield is продолжение.

какое продолжение? Продолжение сохраняет текущую точку исполнения со всем ее состоянием, таким, что можно дальше в этот момент позже. Это именно то, что Python yield, а также, как именно это реализуется.

насколько я понимаю, продолжения Python не разделителями однако. Я мало что об этом знаю-я могу ошибаться. И я не знаю, что это может означать.

продолжение Scala не работает во время выполнения-на самом деле, есть библиотека продолжений для Java, которая работает, делая материал для байт-кода во время выполнения, который свободен от ограничений, которые имеют продолжение Scala.

продолжение Scala полностью выполняется во время компиляции, что требует довольно много работы. Он также требуется, чтобы код, который будет "продолжен", был подготовлен компилятором для этого.

и вот почему-генераторы не работают. Такое утверждение:

for { x <- xs } proc(x)

если перевести на

xs.foreach(x => proc(x))

здесь foreach метод 'ы. К сожалению, xs класс был давно скомпилирован, поэтому его нельзя изменить в поддержку продолжения. В качестве примечания, вот почему Scala не имеет continue.

помимо этого, да, это дублирующий вопрос, и, да, вы должны найти другой способ написать свой код.

реализация ниже предоставляет генератор, подобный Python.

обратите внимание, что есть функция, называемая _yield в коде ниже, потому что yield уже является ключевым словом в Scala, которое, кстати, не имеет ничего общего с yield вы знаете из Python.

import scala.annotation.tailrec
import scala.collection.immutable.Stream
import scala.util.continuations._

object Generators {
  sealed trait Trampoline[+T]

  case object Done extends Trampoline[Nothing]
  case class Continue[T](result: T, next: Unit => Trampoline[T]) extends Trampoline[T]

  class Generator[T](var cont: Unit => Trampoline[T]) extends Iterator[T] {
    def next: T = {
      cont() match {
        case Continue(r, nextCont) => cont = nextCont; r
        case _ => sys.error("Generator exhausted")
      }
    }

    def hasNext = cont() != Done
  }

  type Gen[T] = cps[Trampoline[T]]

  def generator[T](body: => Unit @Gen[T]): Generator[T] = {
    new Generator((Unit) => reset { body; Done })
  }

  def _yield[T](t: T): Unit @Gen[T] =
    shift { (cont: Unit => Trampoline[T]) => Continue(t, cont) }
}


object TestCase {
  import Generators._

  def sectors = generator {
    def tailrec(seq: Seq[String]): Unit @Gen[String] = {
      if (!seq.isEmpty) {
        _yield(seq.head)
        tailrec(seq.tail)
      }
    }

    val list: Seq[String] = List("Financials", "Materials", "Technology", "Utilities")
    tailrec(list)
  }

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

он работает довольно хорошо, в том числе для типичного использования для петель.

предостережение: мы должны помнить, что Python и Scala отличаются тем, как продолжения выполненный. Ниже мы видим, как генераторы обычно используются в Python и сравнить с тем, как мы должны использовать их в Scala. Тогда мы увидим, почему это должно быть так в Scala.

если вы привыкли писать код на Python, вы, вероятно, использовали генераторы такой:

// This is Scala code that does not compile :(
// This code naively tries to mimic the way generators are used in Python

def myGenerator = generator {
  val list: Seq[String] = List("Financials", "Materials", "Technology", "Utilities")
  list foreach {s => _yield(s)}
}

этот код выше не компилируется. Пропуская все запутанные теоретические аспекты, объяснение таково: он не компилируется, потому что "тип цикла for" не соответствует тип, участвующий в качестве части продолжения. Боюсь, это объяснение-полный провал. Позвольте мне попробовать еще раз:

если бы вы закодировали что-то, как показано ниже, он будет компилироваться нормально:

def myGenerator = generator {
  _yield("Financials")
  _yield("Materials")
  _yield("Technology")
  _yield("Utilities")
}

этот код компилируется, потому что генератор может быть разложившийся в последовательности yields и, в данном случае, a yield соответствует типу, участвующему в продолжении. Чтобы быть более точным, код можно разложить на цепные блоки, где каждый блок заканчивается на yield. Просто для уточнения, мы можем подумать, что последовательность yields можно выразить так:

{ some code here; _yield("Financials")
    { some other code here; _yield("Materials")
        { eventually even some more code here; _yield("Technology")
            { ok, fine, youve got the idea, right?; _yield("Utilities") }}}}

опять же, не углубляясь в запутанную теорию, дело в том, что после yield вам нужно предоставить другой блок, который заканчивается на yield, или закройте цепочку в противном случае. Это то, что мы делаем в псевдо-коде выше: после yield мы открываем еще один блок, который, в свою очередь, заканчивается yield затем другой yield, который, в свою очередь, заканчивается другим yield и так далее. Очевидно, все это когда-нибудь закончится. Тогда единственное, что нам позволено сделать, это закрыть всю цепочку.

ОК. Но... как мы можем!--8--> несколько фрагментов информации? Ответ немного неясен, но имеет смысл после того, как вы знаете ответ: нам нужно использовать хвостовую рекурсию, и последнее утверждение блока должно быть yield.

  def myGenerator = generator {
    def tailrec(seq: Seq[String]): Unit @Gen[String] = {
      if (!seq.isEmpty) {
        _yield(seq.head)
        tailrec(seq.tail)
      }
    }

    val list = List("Financials", "Materials", "Technology", "Utilities")
    tailrec(list)
  }

давайте проанализируем, что происходит здесь:

1. наша функция генератора myGenerator содержит некоторую логику, которая получает, которая генерирует информацию. В этом примере мы просто используем последовательность строк.

2. наша функция генератора myGenerator вызывает рекурсивную функцию, которая отвечает за yield-ing несколько частей информации, полученной из нашей последовательности строк.

3. рекурсивная функция должно быть объявлено до использовать, в противном случае компилятор аварийно завершает работу.

4. рекурсивная функция tailrec обеспечивает необходимую нам хвостовую рекурсию.

эмпирическое правило здесь просто: замените цикл for рекурсивной функцией, как показано выше.

обратите внимание, что tailrec это просто удобное имя, которое мы нашли, для уточнения. В частности, tailrec не нужно быть последним утверждением нашей функцией генератора; не обязательно. Единственное ограничение заключается в том, что вы должны предоставить последовательность блоков, которые соответствуют типу yield, как показано ниже:

  def myGenerator = generator {

    def tailrec(seq: Seq[String]): Unit @Gen[String] = {
      if (!seq.isEmpty) {
        _yield(seq.head)
        tailrec(seq.tail)
      }
    }

    _yield("Before the first call")
    _yield("OK... not yet...")
    _yield("Ready... steady... go")

    val list = List("Financials", "Materials", "Technology", "Utilities")
    tailrec(list)

    _yield("done")
    _yield("long life and prosperity")
  }

еще один шаг, вы должны представить, как выглядят приложения в реальной жизни, в частности, если вы используете несколько генераторов. Было бы неплохо, если бы вы нашли способ стандартизация ваши генераторы вокруг одного шаблона, который демонстрирует, чтобы быть удобным для большинства обстоятельств.

давайте рассмотрим пример ниже. У нас три генератора:--29-->, industries и companies. Для краткости, только sectors полностью показано. Этот генератор использует tailrec функция, как показано выше. Фокус здесь в том, что то же самое tailrec функция также использована другими генераторами. Все, что нам нужно сделать, это поставить другой