scala(9)A Tour of Scala: Compound Types

scala(9)A Tour of Scala: Compound Types
Compound Types
trait Cloneable extends java.lang.Cloneable {
override def clone(): Cloneable = { super.clone(); this }
}

trait Resetable {
def reset: Unit
}

def cloneAndReset(obj: Cloneable with Resetable): Cloneable = {
//...
}

Sequence Comprehensions
object ComprehensionTest1 extends App {
def even(from: Int, to: Int): List[Int] =
for (i <- List.range(from, to) if i % 2 == 0) yieldi
Console.println(even(0, 20)) // List(0, 2, 4, 6, 8, 10, 12, 14, 16, 18)
}

object ComprehensionTest2 extends App {
def foo(n: Int, v: Int) =
for (i <- 0 until n;
j <- i + 1 until n if i + j == v) yield
Pair(i, j);
foo(20, 32) foreach {
case (i, j) =>
println("(" + i + ", " + j + ")")
}
}

Another easy way to implement this.

object ComprehensionTest3 extends App {
for (i <- Iterator.range(0, 20);
j <- Iterator.range(i + 1, 20) if i + j == 32)
println("(" + i + ", " + j + ")")
}

Extractor Objects

object Twice{
def apply(x:Int): Int = x * 2
def unapply(z: Int): Option[Int] = if (z%2 == 0) Some(z/2) else None
}

object TwiceTest extends App{
valx = Twice(21)
println("apply value: " + x) //apply value: 42
xmatch { case Twice(n) => Console.println("unapply value: " + n) } //unapply value: 21
}

There are 2 syntactic conventions at work here:
1. case Twice(n) will cause an invocation of Twice.unapplly
2. val x = Twice(21) expands to val x = Twice.apply(21).

Generic Classes
class Stack[T] {
var elems: List[T] = Nil
def push(x: T) { elems = x::elems }
def top: T = elems.head
def pop() { elems = elems.tail }
}

Here is the parameterized with types classes, like in Java 5.

object GenericsTest extends App {
val stack = new Stack[Int]
stack.push(1)
stack.push('a')
println(stack.top) // 97
stack.pop()
println(stack.top) // 1
}

Implicit Parameters(Implicit in Scala)
There are 2 implicit in Scala, implicit transfer and implicit parameters.

implicit transfer
scala> def foo(msg: String) = println(msg)
foo: (msg: String)Unit

scala> foo(5)
<console>:9: error: type mismatch;
found : Int(5)
required: String
foo(5)
^

scala> implicit def intToString(x: Int) = x.toString
warning: there were 1 feature warnings; re-run with -feature for details
intToString: (x: Int)String

scala> foo(5)
5

But if we have 2 implicit transfer, it will give us some error messages:
Note that implicit conversions are not applicable because they are ambiguous:
both method int2String of type (x: Int)String
and method int2String2 of type (x: Int)String
are possible conversion functions from Int(5) to String
foo(5)

implicit Parameters
cala> def findAnInt(implicit x : Int) = x
findAnInt: (implicit x: Int)Int

scala> findAnInt
<console>:9: error: could not find implicit value for parameter x: Int
findAnInt
^

scala> implicit val test = 100
test: Int = 100

scala> findAnInt
res1: Int = 100

References:
http://www.scala-lang.org/node/110
http://www.scala-lang.org/node/112
http://www.scala-lang.org/node/114

http://www.zhangyf.net/2012/11/implicit-in-scala/