scala> 1 to 325000
res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3…
scala> res0.foldRight(“”)((x,y)=>”X”)
res1: java.lang.String = X

scala> res0.toList.view
res2: java.lang.Object with scala.collection.SeqView[Int,List[Int]] = SeqView(…)

scala> res2.foldRight(“”)((x,y)=>”X”)
res3: java.lang.String = X

As Knuth said: “We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil”

Thanks for your post; it was a good read.

Firstly, you say that reverse.foldLeft is at least O(n). I don’t see how it can be anything other than O(n). Reverse is clear enough. It builds a second singly linked list out of the first, one item at a time. That’s O(n). And then foldLeft runs, which is implemented as a while loop. That’s O(n). The combination is O(n+n) which is the same as O(n).

Secondly (and this is the one that I’ve been puzzling over) I don’t think foldRight runs in O(1). Let’s take the foldRight call in your example.

scala> var x: Boolean = true
x: Boolean = true

scala> def time = (new java.util.Date).getTime
time: Long

scala> var list = (1 to 10).toList.map(x => x==1)
list: List[Boolean] = List(true, false, false, false, false, false, false, false, false, false)

scala> val t1 = time; for (_  val t1 = time; for (_ <- 1 to 10000) { x=list.foldRight(false)(_||_) }; println (time - t1)
16
t1: Long = 1281477156551

This foldRight applied to a list of 10 booleans 10,000 times takes 16 milliseconds.

scala> list = (1 to 100).toList.map(x => x==1)
list: List[Boolean] = List(true, false, false, false, ...

scala> val t1 = time; for (_  val t1 = time; for (_ <- 1 to 10000) { x=list.foldRight(false)(_||_) }; println (time - t1)
94
t1: Long = 1281477234035

This foldRight applied to a list of 100 booleans 10,000 times takes 94 milliseconds. That’s 10 times as many items and it took about 6 times as long.

scala> list = (1 to 1000).toList.map(x => x==1)
list: List[Boolean] = List(true, false, false, false, ...

scala> val t1 = time; for (_  val t1 = time; for (_ <- 1 to 10000) { x=list.foldRight(false)(_||_) }; println (time - t1)
984
t1: Long = 1281477246817

This foldRight applied to a list of 1000 booleans 10,000 times takes about 984 milliseconds. That’s 10 times as many items and it took about 10 times as long.

scala> list = (1 to 2000).toList.map(x => x==1)
list: List[Boolean] = List(true, false, false, false, ...

scala> val t1 = time; for (_  val t1 = time; for (_ <- 1 to 10000) { x=list.foldRight(false)(_||_) }; println (time - t1)
1797
t1: Long = 1281477309082

This foldRight applied to a list of 2000 booleans 10,000 times takes about 1797 milliseconds. That’s 2 times as many items and it took about 1.8 times as long.

This is all consistent with an O(n) foldRight, and it’s what I would expect from the implementation. When you say that foldRight “can execute in O(1) time”, do you mean that it should theoretically be possible for the compiler to short circuit the logic in certain applications of foldRight? Because I’m not seeing any such optimization in these numbers.

List(true,false,false).foldRight(false)(_||_) = = true

In Haskell, foldr can operate on infinite lists, while foldl cannot