With the newest trunk, using the JVM 1.6 or newer, use the: collection.parallel.ForkJoinTasks.defaultForkJoinPool.setParallelism(parlevel: Int) This may be a subject to changes in the future, though. A more unified approach to configuring all Scala task parallel APIs is planned for the next releases. Note, however, that while this will determine the number of processors the query … Read more
I found a solution. Scala reference says in section 6.12.3 Infix Operations: The associativity of an operator is determined by the operator’s last character. Operators ending in a colon ‘:’ are right-associative. All other operators are left-associative. Therefore it was enough to rename >> to >>:. It took me some time to realize that while … Read more
This behavior is underspecified but intended, though it might appear confusing. We plan to elaborate on the role of return type in macro signatures, but at the moment I feel like the flexibility is a good thing to have. Also at times the behavior is inconsistent, e.g. when the macro is caught in the middle … Read more
This is exactly why I wrote these functions, which are apparently impressively obscure since nobody has mentioned them. scala> import PartialFunction._ import PartialFunction._ scala> cond(“abc”) { case “def” => true } res0: Boolean = false scala> condOpt(“abc”) { case x if x.length == 3 => x + x } res1: Option[java.lang.String] = Some(abcabc) scala> condOpt(“abc”) … Read more
Consider the following interaction with the REPL. First we define a class with a factorial method: scala> class C { def fact(n: Int, result: Int): Int = if(n == 0) result else fact(n – 1, n * result) } defined class C scala> (new C).fact(5, 1) res11: Int = 120 Now let’s override it in … Read more
This works as written as of the most recent shapeless 2.1.0-SNAPSHOT.
This isn’t simply “multiple variable assignment”, it’s fully-featured pattern matching! So the following are all valid: val (a, b) = (1, 2) val Array(a, b) = Array(1, 2) val h :: t = List(1, 2) val List(a, Some(b)) = List(1, Option(2)) This is the way that pattern matching works, it’ll de-construct something into smaller parts, … Read more
def foo(msf: String, o: AnyRef, os: AnyRef*) = println( String.format(msf, (o :: os.toList).toArray : _* ))
You can do this pretty straightforwardly with an implicit class and a for-comprehension in Scala 2.10: implicit class Crossable[X](xs: Traversable[X]) { def cross[Y](ys: Traversable[Y]) = for { x <- xs; y <- ys } yield (x, y) } val xs = Seq(1, 2) val ys = List(“hello”, “world”, “bye”) And now: scala> xs cross ys … Read more
Stream memoises and Iterator does not. You can traverse the same Stream multiple times and get the same result each time. Iterator, on the other hand, can only be traversed once.