scala-2.8

For example, there is a Scala array val A = Array("please", "help", "me") . How to choose a random element from this array? topless import java.util.Random // ... val rand = new Random(System.currentTimeMillis()) val random_index = rand.nextInt(A.length) val result = A(random_index) import scala.util.Random val A = Array("please", "help", "me") Random.shuffle(A.toList).head import scala.util.Random val A = List(1, 2, 3, 4, 5, 6) A(Random.nextInt(A.size)) We can also add some safety with the Option monad (using the lift function, and a condition) Actually, if you use this function on Arrays

Or does it just clutter up the code for something the JIT would take care of automatically anyway? I have yet to find a case where it improves performance, and I've tried in quite a few different spots. The JVM seems to be quite good at inlining when it's possible, and even if you ask for @inline in Scala, it can't always do it (and sometimes I've noticed that it doesn't even when I think it ought to be able to). The place where you expect to see a bytecode difference is in something like this: object InlineExample { final class C(val i: Int) { @inline def t2 = i*2 @inline def t4 = t2*2 }

I just found out that there are such iterators in Java. Does Scala have iterators with 'set' and 'remove' methods for iterating (and modifying) mutable collections like array? If there is no such iterator then is there a good reason for that? Scala does not currently have such an iterator. I suspect that it does not because Such iterators are not general (i.e they are only usable with mutable collections) but consume namespace. Because they can rapidly become confusing to think about in conjunction with lazy operations like takeWhile (Is it always obvious what x.takeWhile(_<5).add(5) should do

Language FAQ says import scala.collection.mutable.{_, Map => _, Set => _} should import all classes from package scala.collection.mutable , except Map and Set . But it gives me this error: error: '}' expected but ',' found. import scala.collection.mutable.{_, Map => _, Set => _} Is there still a way to do this? Patrick The _ has to be put at the end - not at the beginning: Exclude Map and Set from the import import scala.collection.mutable.{Map => _, Set => _, _} Exclude Set and rename Map to ScalaMutableMap import scala.collection.mutable.{Map=>ScalaMutableMap, Set => _, _} See the detailed

Just wondering if this is possible. What I would actually like to do is check and possibly modify one of the arguments before it is stored as a val. Alternatively, I could use an overload and make the default constructor private. In which case I would also like to make private the default factory constructor in the companion object, how would I do that? Many thanks. Adam edit: well i figured out that making the default constructor private also makes the default factory constructor private, so i have a solution, i'm still interested to know if the default constructor is overridable though The

In Scala 2.7, I could write: package com.acme.bar class Bar . package com.acme.foo class Foo { new bar.Bar } This doesn't compile in Scala 2.8 -- however this does: package com.acme package bar class Bar . package com.acme package foo class Foo { new bar.Bar } What was the motivation for this? What is the precise meaning, with regards to scope and visibility? When should I use one form over the other? There were several long discussions on the mailing lists about this. See this thread for the problem and this thread for the solution . As to meaning, only the package A package B form will open