Recommended way to produce collections

[scala]

Recommended way to produce collections

[ivanopagano]

I like the unfolding idea, for its declarative approach.
So every concrete collection should provide an implementation of something similar to the following? (code simplified, no type parameter bounds were hurt for this example)

trait Unfolder[COLL[_]] {
  def unfold[A, B](seed: A)(f: (A) ⇒ Option[(B, A)]): COLL[B]
}

Is there any "traditional" collection type which would not fit with this approach?

[julienrf]

I think an unfold library could be implemented separately.

[odersky]

I usually use a ListBuffer as an accumulator, like this:

def fibonacci(n: Int): List[Int] = {
  def loop(remaining: Int, prev: Int, prevPrev: Int, buf: ListBuffer[Int]): ListBuffer[Int] =
    if (remaining > 0) {
      val value = prev + prevPrev
      loop(remaining - 1, value, prev, buf += value)
    } else buf.toList
  loop(n - 2, 1, 0, ListBuffer(0, 1))
}

It's "purely functional" code, but with a mutable type used linearly.

[julienrf]

Also, just to get a comparison basis, here is what an unfold based version could look like:

def fibonacci(n: Int): List[Int] =
  List(0, 1) ++ List.unfold((n - 2, 0, 1)) {
    case (0, _, _) => None
    case (n, prevPrev, prev) =>
      val value = prevPrev + prev
      Some(value -> (n - 1, prev, value))
  }

The nice thing is that we don’t have to manage the loop and the accumulator by ourselves.