Return to chapter index

1 A Scalable Language

1.1 A language that grows on you

  var capital = Map("US" -> "Washington", "France" -> "Paris")

  capital += ("Japan" -> "Tokyo")

  println(capital("France")) 


  def factorial(x: BigInt): BigInt = 
    if (x == 0) 1 else x * factorial(x - 1)


  265252859812191058636308480000000


  import java.math.BigInteger

  def factorial(x: BigInteger): BigInteger =
    if (x == BigInteger.ZERO)
      BigInteger.ONE
    else
      x.multiply(factorial(x.subtract(BigInteger.ONE)))


  recipient ! msg


  receive {
    case Msg1 => ... // handle Msg1
    case Msg2 => ... // handle Msg2
    // ...
  }


  actor { 
    var sum = 0
    loop {
      receive {
        case Data(bytes)       => sum += hash(bytes)
        case GetSum(requester) => requester ! sum
      }
    }
  }


  

1.2 What makes Scala scalable?

1.3 Why Scala?

  // this is Java
  class MyClass {

      private int index;
      private String name;

      public MyClass(int index, String name) {
          this.index = index;
          this.name = name;
      }
  }


  class MyClass(index: Int, name: String)


  // this is Java
  boolean nameHasUpperCase = false;
  for (int i = 0; i < name.length(); ++i) {
      if (Character.isUpperCase(name.charAt(i))) {
          nameHasUpperCase = true;
          break;
      }
  }


  val nameHasUpperCase = name.exists(_.isUpperCase) 


  // this is Java
  interface CharacterProperty {
    boolean hasProperty(char ch);
  }


  // this is Java
  exists(name, new CharacterProperty() {
      public boolean hasProperty(char ch) {
          return Character.isUpperCase(ch);
      }
  });


  s.exists(p) || s.exists(q) == s.exists(x => p(x) || q(x)) 


  def f(x: String) = ...  


  val x: HashMap[Int, String] = new HashMap[Int, String]()


  val x = new HashMap[Int, String]()
  val x: Map[Int, String] = new HashMap() 


  

1.4 Scala's roots

1.5 Conclusion