scala(10)A Tour of Scala: Inner Classes

scala(10)A Tour of Scala: Inner Classes
Inner Classes
Just understand we can have inner classes
class Graph {
  class Node {
    var connectedNodes: List[Node] = Nil
    def connectTo(node: Node) {
      if (connectedNodes.find(node.equals).isEmpty) {
        connectedNodes = node :: connectedNodes
      }
    }
  }
  var nodes: List[Node] = Nil
  def newNode: Node = {
    val res = new Node
    nodes = res :: nodes
    res
  }
}

object GraphTest extends App {
  val g = new Graph
  val n1 = g.newNode
  val n2 = g.newNode
  val n3 = g.newNode
  n1.connectTo(n2)
  n3.connectTo(n1)
}

Mixin Class Composition

abstract class AbsIterator {
  type T
  def hasNext: Boolean
  def next: T
}

trait RichIterator extends AbsIterator {
  def foreach(f: T => Unit) { while (hasNext) f(next) }
}

class StringIterator(s: String) extends AbsIterator {
  type T = Char
  privatevari = 0
  def hasNext = i < s.length()
  def next = { val ch = s charAt i; i += 1; ch }
}

object StringIteratorTest extends App {
  class Iter extends StringIterator("1234") with RichIterator
  val iter = new Iter
  iter foreach println
}

No one has the method foreach, but the trait has.

Nested Functions
…snip…

Anonymous Function Syntax
…snip…

Currying
…snip...

Automatic Type-Dependent Closure Construction
…snip...

Operators
Any method which takes a single parameter can be used as an infix operator in Scala.
class MyBool(x: Boolean){
     def or(that: MyBool): MyBool = if(x) this else that
}

def xor(x: MyBool, y: MyBool) = (x or y)

Higher-Order Functions
class Decorator(left: String, right: String) {
  def layout[A](x: A) = left + x.toString() + right
}

object FunTest extends App {
  //defined the function, take other function and values as
  //parameters
  def apply(f: Int => String, v: Int) = f(v)
  val decorator = new Decorator("[", "]")
  println(apply(decorator.layout, 7))  //[7]
}

This function can take other functions and values as parameters and apply first.

Packages
A package is a special object which defines a set of member classes, objects and packages. Unlike other objects, packages are not introduced by a definition.

Import clauses
import p._                 all members of p
import p.x                 the member x of p.
import p.{ x => a}      the member x of p renamed as a.
import p.{x, y}           the members x and y of p.
import p1.p2.z          the member z of p2, itself member of p1.

import p1._, p2._       alternatively import p1._; import p2._

Implicitly imported into every compilation unit
java.lang
scala
scala.Predef

Pattern Matching
object MatchTest1 extends App {
  def matchTest(x: Int): String = x match {
    case 1 => "one"
    case 2 => "two"
    case _ => "many"
  }
  println(matchTest(3)) //many
}

object MatchTest2 extends App {
  def matchTest(x: Any): Any = x match {
    case 1 => "one"
    case "two" => 2
    case y: Int => "scala.Int"
  }
  println(matchTest("two")) //2
  println(matchTest(2))     //scala.Int
  println(matchTest(1))//one
}

Magic match, can be any types and even pattern.


References:
http://www.scala-lang.org/node/115
http://www.scala-lang.org/node/116
http://www.scala-lang.org/node/118
http://www.scala-lang.org/node/134