views:

267

answers:

2

I am new to Scala, just started learning, so this is basic beginner question.

I try to implement Sieve of Eratosthenes algorithm. Here is what I got so far:

def sieve_core(cross: Int, lst: Seq[Int]): List[Int] = {
    val crossed = lst.filter(_ % cross != 0)
    crossed match {
            case a :: rest => cross :: sieve_core(a, crossed)
            case _ => cross :: Nil
    }
}

def sieve(max: Int): List[Int] = {
    sieve_core(2, (2 to max))
}

println(sieve(100))

The result is:

List(2)

As far as I understand, case _ => cross :: Nil is matched in first iteration of sieve_core, which means that crossed is not an instance of a List.

I changed lst parameters type to List[Int] and now the code won't compile with an error:

(fragment of Problem3.scala):24: error: type mismatch;
 found   : Range.Inclusive
 required: List[Int]
    sieve_core(2, (2 to max))
                      ^

Apparently Range is not a List.

Question: how can I turn Range into a List? Or is it some bigger problem with my code, I have made some bad assumption somewhere along the way?

Any help appreciated.

+4  A: 

Scalalaland

Updated: The Scala way:

$ scala
Welcome to Scala version 2.7.3final (Java HotSpot(TM) Client VM, Java 1.6.0_14).

scala> val max = 10
max: Int = 10

scala> val example = 2 to max toList
example: List[Int] = List(2, 3, 4, 5, 6, 7, 8, 9, 10)

scala>
DigitalRoss
I checked List class apidocs, haven't checked List object docs. Now I know better. Thanks.
Ula Krukar
You know, it's super annoying how they aren't prominently linked to each other, or even combined into a single page :)
wrang-wrang
This is supposed to be deprecated, I'm told. `2 to max toList` will work.
Daniel
Thanks, I revised the answer. 2.7.3 docs released in January 2009 gave no hint...
DigitalRoss
caution: the very nice option of dropping the "." may still require you to add parens later for methods with no arguments: 2 to 4 toList reverse parses as `.toList(reverse)`, so you need `(2 to 4 toList) reverse` or `(2 to 4).toList reverse` or more conventionally, `2.to(4).toList.reverse` - but I still drop the ".()" if I can.
wrang-wrang
+3  A: 

To turn any sequence s into a list, use s.toList

I'm sure digitalross' is more efficient in this case, though.

wrang-wrang
Actually, this seems to be The Scala Way +1
DigitalRoss