For loop in scala without sequence?

So, while working my way through "Scala for the Impatient" I found myself wondering: Can you use a Scala for loop without a sequence?

For example, there is an exercise in the book that asks you to build a counter object that cannot be incremented past Integer.MAX_VALUE. In order to test my solution, I wrote the following code:

var c = new Counter
for( i <- 0 to Integer.MAX_VALUE ) c.increment()

This throws an error: sequences cannot contain more than Int.MaxValue elements. It seems to me that means that Scala is first allocating and po开发者_C百科pulating a sequence object, with the values 0 through Integer.MaxValue, and then doing a foreach loop on that sequence object.

I realize that I could do this instead:

var c = new Counter
while(c.value < Integer.MAX_VALUE ) c.increment()

But is there any way to do a traditional C-style for loop with the for statement?

In fact, 0 to N does not actually populate anything with integers from 0 to N. It instead creates an instance of scala.collection.immutable.Range, which applies its methods to all the integers generated on the fly.

The error you ran into is only because you have to be able to fit the number of elements (whether they actually exist or not) into the positive part of an Int in order to maintain the contract for the length method. 1 to Int.MaxValue works fine, as does 0 until Int.MaxValue. And the latter is what your while loop is doing anyway (to includes the right endpoint, until omits it).

Anyway, since the Scala for is a very different (much more generic) creature than the C for, the short answer is no, you can't do exactly the same thing. But you can probably do what you want with for (though maybe not as fast as you want, since there is some performance penalty).

Wow, some nice technical answers for a simple question (which is good!) But in case anyone is just looking for a simple answer:

//start from 0, stop at 9 inclusive
for (i <- 0 until 10){
    println("Hi " + i)
}

//or start from 0, stop at 9 inclusive
for (i <- 0 to 9){
    println("Hi " + i)
}

As Rex pointed out, "to" includes the right endpoint, "until" omits it.

Yes and no, it depends what you are asking for. If you're asking whether you can iterate over a sequence of integers without having to build that sequence first, then yes you can, for instance using streams:

def fromTo(from : Int, to : Int) : Stream[Int] = 
  if(from > to) {
    Stream.empty
  } else {
    // println("one more.") // uncomment to see when it is called
    Stream.cons(from, fromTo(from + 1, to))
  }

Then:

for(i <- fromTo(0, 5)) println(i)

Writing your own iterator by defining hasNext and next is another option.

If you're asking whether you can use the 'for' syntax to write a "native" loop, i.e. a loop that works by incrementing some native integer rather than iterating over values produced by an instance of an object, then the answer is, as far as I know, no. As you may know, 'for' comprehensions are syntactic sugar for a combination of calls to flatMap, filter, map and/or foreach (all defined in the FilterMonadic trait), depending on the nesting of generators and their types. You can try to compile some loop and print its compiler intermediate representation with

scalac -Xprint:refchecks

to see how they are expanded.

There's a bunch of these out there, but I can't be bothered googling them at the moment. The following is pretty canonical:

@scala.annotation.tailrec
def loop(from: Int, until: Int)(f: Int => Unit): Unit = {
  if (from < until) {
    f(from)
    loop(from + 1, until)(f)
  }
}

loop(0, 10) { i =>
  println("Hi " + i)
}