A. Sundararajan's Weblog

public class Hello {
  public static void main(String[] args) {
    System.out.println("hello world");
  }
}

object Hello {
  def main(args: Array[String]) : unit = {
    Console.println("hello world");
  }     
}

object Hello extends Application {
  Console.println("hello world");
}

General form:
for(<generators>; <filter>) yield <expression>


Example:

object Main extends Application {

  val list = List("Fortran", "Java", "Scala", 
                  "JavaScript", "ML");
  val shortList = 
    for (val e <- list; e.length() < 6) 
    yield e.toUpperCase()
  Console.println(shortList);
}

object Main extends Application {

  val list = List("Fortran", "Java", "Scala", 
                  "JavaScript", "ML");
  val shortList = list.filter(e=>e.length() < 6)
                      .map(e=>e.toUpperCase());
    
  Console.println(shortList);
}

object Main {
  def func(s: String) : boolean = {
    return s.startsWith("J");
  }

  def print(s: String): unit = {
    Console.println(s);
  }

  def main(args: Array[String]) : unit = {
    var list = List("hello", "world", "Java");

    // pass method reference as argument
    list = list.filter(func);
    Console.println(list);

    // explicitly mentions "Main" object
    // in the method reference
    list.foreach(Main.print);
  }
}

object Main {
  def main(args: Array[String]) : unit = {
    val list = List(3, 54, -1, -324, 45);
    // print negative numbers only
    Console.println(list.filter(0 >));
  }
}

• Object-oriented decomposition
• Visitor pattern
• Type-Test/Type-Cast (instanceof and cast)

object t {
   def main(args: Array[String]) : unit = {
     args.length match {
         case 1 => Console.println("1 argument");
         case 2 => Console.println("2 arguments");
         case _ => Console.println("more than 2!");
     }
   }
}

  def matchTest(x: Any): Any = x match {
    // matching integer value "1"
    case 1 => "one"
    // matches string "two"
    // x is a string with "two" as value
    case "two" => 2
    // x is any int type but with not equal to 1
    case y:Int => "scala.Int"
  }

• create objects of case classes without "new" operator - use function call-like syntax
• case classes have automatic accessor generators for constructor parameter.
• case classes can be used in pattern matching.

abstract class Expression;
case class Number(n:int) extends Expression;
case class Add(left:Expression, right:Expression) extends Expression;
case class Var(name: String) extends Expression;
case class Multiply(left:Expression, right:Expression) extends Expression;

// sample match expression that uses above case classes

// This expression simplifies a given expression "e"
// We use x + 0 = x and x * 1 = x rules to simplify

def simplify(e: Expression) : Expression = {
  e match {

    // matches if expression is a Multiply object
    // and right operand is Number 1
    case Multiply(x, Number(1)) => x

    // matches if expression is a Add object
    // and right operand is Number 0
    case Add(x, Number(0)) => x

    // matches any other expression - no simplification
    // just return the original expression
    case _ => e
  }
}

• In Defense of Pattern Matching
• Matching Objects with Patterns

throw new RuntimeException();
throw new IOException();

throw new RuntimeException();
throw new IOException();

try {
   // ...
} catch(IOException ieExp) {
   // ...
} catch(RuntimeException re) {
   // ...
} finally {
   // ...
}

try {
     // ...
} catch {
  case ioExp:IOException => {
     // ...
  }
  case re:RuntimeException => {
     // ...
  }
} finally {
  // ...
}

• Pattern matching is used to match a particular exception type within a single catch clause - unlike separate catch clauses in Java.
• finally clause is optional here as well.
• Because catch uses case clauses, it is possible to match values - for example, if your exception class is a case class, then you can match constructor parameters of your exception class as well.

case class MyException(s:String) extends Exception(s) {
}
object Hello extends Application {
  try {
    throw new MyException("hello");
  } catch {
    // MyException with message equal to "hello"
    case MyException("hello") =>
      Console.println("world!");
    // MyException with message not equal to "hello"
    case MyException(_) => 
      Console.println("no way!");  
    // any other exception
    case _ => 
      Console.println("any other exception");
  }
}

package com.acme;

package com.acme;

With the above statement as first line in a compilation unit, everything in the compilation unit goes into the package -- as in Java. But, Scala supports "packaging" statements as well. The following example defines

package com.acme {
  class X {}
  class Y {}
}

package com.sun {
  class X {}
  package P {
    class Y {}
  }
}

Notes:

• Several packages may be declared in the same compilation unit.
• Packages can include other packages.

// import whole package
import java.io.*;

// import a specific (public) class from a package
import java.net.URL;

// import whole package
import java.io._;

// import a specific (public) class from a package
import java.net.URL;

// import all static members of Math class
import static java.lang.Math.*

object t {
  def sayHello() : unit = {
     Console.println("hello");
  }
}

object Main {
  import t._;
  def main(args: Array[String]): unit = {
    sayHello();
  }
}

import java.lang.Math._;

object t {
 def main(a: Array[String]) : unit = {
  Console.println(sin(3.14/2));
 } 
}

Generic pattern is 

type <name> =  <type-expression>

Examples:

type StringList = List[String];
var sl: StringList = List("hello", "world");

type voidFunc = ()=>unit;
var v : voidFunc = ()=>Console.println("hello");
v();

abstract class Cell {
  // an abstract type member
  // subclass can define it
  type T

  // abstract value member
  var element: T
}

abstract class ValueCell extends Cell {
  // define T to be some subtype of AnyVal
  type T <: AnyVal
}

class IntCell extends Cell {
  // define T to be int
  type T = int

  // define (initial) value to be zero
  var element : T = 0
}

object Main {
  def main(args: Array[String]) : unit = {
    def sum(x: int)(y: int) : int = x + y
    // curry sum to specify first value
    val add7 = &sum(7)
  
    // call curried version with one argument
    Console.println(add7(8));
  }
}

def printAges(values: int*)(names: String*) : unit = {
  // code here..
}

// caller calls this as
printAges(34, 24, 45)("X", "Y", "Z");

object Main {
  def func(v: => int) = {
      Console.println("You passed " + v);
      Console.println("You passed " + v);
  }

  def main(args: Array[String]): unit = {
      var i = 0;
      func({i = i + 1; i});
  }
}

You passed 1
You passed 1

You passed 1
You passed 2

Interesting blog entry to simulate Java-style for(<init< <condition> <update>) loop for Scala is here. The author uses call-by-name parameters to implement control abstraction.

object Main {
  def main(args: Array[String]): unit = {
      var s = <html>
              <title>{args(0)}
              </title></html>;
              
      Console.println(s);
  }
}

Possible to mix Scala expressions in XML literals - as shown in above example (within {} args[0] is referred). XML elements may be used inside pattern-matching as well (only elements).