Deciding between use of foldleft() or Seq.newBuilder in Scala

Question

I have some code where I need to add elements to a sequence while iterating over another one. Which way is the 'preferred' or rather the better way of doing that in scala and why?:

Way 1:

val builder = Seq.newBuilder[String]    
for(i <- iterator){
builder += i  //Everytime I want to add a new element    
}

Way 2:

val stringSeq = iterator.foldLeft(Seq[String]()){
case (acc, i) => i +: acc
}

In your `Way 1` you want the builder to be outside the loop. Also you should add `i` to the builder (not `"Element"`) to match your `Way 2` code. — Kigyo, May 19 '14 at 08:23
2 more annoying things. There is a `-` missing: `for(i <- iterator)` and `foldLeft` (capital L). — Kigyo, May 19 '14 at 08:37
Why not map/flatMap on the iterator to get a new sequence that has what you want (Maybe I don't understand what you are trying to do... ) — mericano1, May 19 '14 at 08:47
Can you explain your use case? I would do neither of these, but use yield to get the sequence directly. — The Archetypal Paul, May 19 '14 at 09:32

Nicolas Rinaudo · Answer 1 · 2014-05-20T10:23:12.127

Why not use both, and be both functional and efficient?

iterator.foldLeft(Seq.newBuilder[String])(_ += _).result

Note that this code's behaviour is slightly different than that of your second solution: your solution reverse the iterator's order, mine preserves it. I don't know which is desired.

Also, just in case it didn't occur to you (sorry if I'm being obvious), any particular reason you're not using iterator.toSeq?

score 1 · Accepted Answer · answered May 19 '14 at 08:39

I would say Way 2 is more idiomatic and feels more functional, as you do not create mutable state.

The Way 1 seems to be a bit more imperative, as it resembles for as it is used in the object oriented programming.

However Scala has both OOP elements and FP elements. I guess you should use a construct, which works better for you, due to for example performance reasons (however I don't think your example is the case, as appending to the head of Seq should be fast).

PS. your generator should be <- not < and it is foldLeft (capital L)

score 1 · Answer 3 · answered May 19 '14 at 09:15

1

There is a ++: method in Seq, so you can just do seq ++: iterator

And don't worry about performance, it's a basic API scala provide us and we should trust it.

Actually the current implementation is similar to your way 1.

answered May 19 '14 at 09:15

cloud

1,057
7
12

Deciding between use of foldleft() or Seq.newBuilder in Scala

3 Answers3