Scala: повторять последовательность при ее изменении?

Давайте начнем с того, что я считаю самой большой проблемой выше. У вас есть это:

for (i <- mi) { mi = something else }

Это не изменит повторяющийся mi. Это mi останется неизменным. Возможно, вы можете мутировать значение mi, но изменить его не получится. Кстати, его мутация тоже может не сработать.

Итак, как вы это делаете? Вы не используете для понимания - или, по крайней мере, не таким образом. Вы можете посмотреть мою собственную версию здесь, которая перебирает коллекцию, отличную от изменяемой. Или вот однострочный:

(n: Int) => (2 to n) |> (r => r.foldLeft(r.toSet)((ps, x) => if (ps(x)) ps -- (x * x to n by x) else ps))

Теперь вернемся к тому, что вы хотите сделать... когда вы используете for-comprehension, вы на самом деле вызываете для него метод foreach, map или flatMap, поэтому вам понадобится коллекция, которая способен обрабатывать один из этих методов и не иметь проблем с "следующим" элементом, изменяющимся от одной итерации к другой. Как я уже сказал, я не уверен, что какая-либо коллекция Scala отвечает всем требованиям. Вам лучше использовать цикл while и следить за вещами самостоятельно, если вы пойдете по этому пути. Например:

def primes(n: Int) = {
    import scala.collection.mutable.LinkedList
    val primes = LinkedList(3 to n by 2: _*)
    var p = primes
    while (p.nonEmpty) {
        var scanner = p
        while (scanner.next.nonEmpty) {
            if (scanner.next.head % p.head == 0)
                scanner.next = scanner.next.next
            else
                scanner = scanner.next
        }
        p = p.next
    }
    primes
}

Обратите внимание, что я сохраняю указатель на начало LinkedList, перемещаю p по всем известным простым числам и перемещаю scanner по всем оставшимся числам, чтобы отрезать непростые числа.

Пример в документации по scala.collection.immutable.Stream представляет собой сито:

object Main extends Application {

  def from(n: Int): Stream[Int] =
    Stream.cons(n, from(n + 1))

  def sieve(s: Stream[Int]): Stream[Int] =
    Stream.cons(s.head, sieve(s.tail filter { _ % s.head != 0 }))

  def primes = sieve(from(2))

  primes take 10 print
}

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

class ModifyingIterator(var collection: Seq[Long]) extends Iterator[Long] {
  var current = collection.head
  def next = {
    current = collection.find(_ > current).get
    current
  }
  def hasNext = collection.exists(_ > current)
}

val mi = new ModifyingIterator(nums)

for (i <- mi) {
    mi.collection = mi.collection.filter((j : Long) => j == i || j % i != 0)
}
println(mi.collection)

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

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

Есть интересный документ: http://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf

Я попытался перевести код Haskell, приведенный в этой статье, на Scala, но не проверял производительность.

object primes {

    type SI = Stream[Int]

    def sieve:SI = {
        def wheel2357:SI = Stream(4,2,4,6,2,6,4,2,4,6,6,
            2,6,4,2,6,4,6,8,4,2,4,2,4,8,6,4,6,2,4,6,2,6,
            6,4,2,4,6,2,6,4,2,4,2,10,2,10,2) append wheel2357
        def spin(s:SI, n:Int):SI = Stream.cons(n, spin(s.tail, n + s.head))

        case class It(value:Int, step:Int) {
            def next = new It(value + step, step)

            def atLeast(c:Int):It =
            if (value >= c) this
            else new It(value + step, step).atLeast(c)
        }

        implicit object ItOrdering extends Ordering[It] {
            def compare(thiz:It, that:It) = {
                val r = thiz.value - that.value
                if (r == 0) thiz.step - that.step else r
            }

        }

        import scala.collection.immutable.TreeSet

        def sieve(cand:SI, set:Set[It]):SI = {
            val c = cand.head
            val set1 = TreeSet[It]() ++ set.dropWhile(_.value < c) ++
               set.takeWhile(_.value < c).map(_.atLeast(c))
            if (set1.elements.next.value == c) {
                val set2 = TreeSet[It]() ++ set1.dropWhile(_.value == c) ++
                    set1.takeWhile(_.value == c).map(_.next)
                sieve(cand.tail, set2)
            } else {
                Stream.cons(c, sieve(cand.tail, set1 + It(c*c,2*c)))
            }
        }
        Stream(2,3,5,7,11) append sieve(spin(wheel2357,13),
                  new TreeSet[It] + It(121,22))
    }

    def main(args:Array[String]) {
        sieve.takeWhile(_ < 1000).foreach(println)
    }
}