Scala: Devnology - Learn A Language Scala

  • 2,361 views
Uploaded on

 

More in: Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
2,361
On Slideshare
0
From Embeds
0
Number of Embeds
5

Actions

Shares
Downloads
84
Comments
0
Likes
7

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. packagenl.devnology.workshop
    importjava.util._
    classLearnALanguage(today: Calendar) extendsDevnology{
    defwelcome(participants: List[Participant]) {
    participants.foreach(p => println("welcome" + p))
    }
    def facilitators() = {
    Facilitator("SoemirnoKartosoewito") ::
    Facilitator("Jan Willem Tulp") :: Nil
    }
    }
  • 2. What’s the plan?
    Setup development environment (Eclipse + Scalaplugin)
    Form pair-programming pairs
    Explanation of basic concepts and syntax
    Labs, labs, labs...
    ... and of course: share knowledge!
  • 3. Euh...Scala?
    Scala runs on JVM and .Net VM
    integrates 100% with existing libraries
    hybrid language: both functional and OO
    statically typed
    “everything is an object”
    ...Immutability, Currying, Tuples, Closures, Higher Order Functions, etc....
  • 4. Scala in the enterprise
  • 5. Run Scala as...
    Interactive / REPL (Read Eval Print Loop): the scala command starts an interactive shell
    As script
    Compiled: scalac command compiles Scala code
    See: http://www.scala-lang.org/node/166
  • 6. Variables, Values & Type Inference
    varmsg = "welcome to ..." // msg is mutable
    msg += " Devnology"
    msg = 3 // compiler error
  • 7. Variables, Values & Type Inference
    valmsg = "welcome to ..." // msg is immutable
    msg += " Devnology" // compiler error
    val n : Int = 3 // explicit type declaration
    valname : String = "John"
  • 8. Functions
    def min(x: Int, y: Int) = if (x < y) x else y
    // equivalent:
    def invert(x: Int) = -x // last statement is return value
    def invert(x: Int) : Int = { return –x }
    Unit can be considered as java’s void
    Watch out!
    def invert(x: Int) { // will return Unit, = is absent
    -x
    }
  • 9. Every operation is a function call
    1 + 2 is the same as1.+(2)
    “to” is not a keyword: for (i <- 0 to 10) print(i)
    map containsKey ‘a’ is the same as map.containsKey(‘a’)
  • 10. Lists
    valscores = List(1, 2, 3) // immutable
    valextraScores: List[Int] = 4 :: 5 :: 6 :: Nil
    // allScores = List(1, 2, 3, 4, 5, 6)
    // scores = List(1, 2, 3)
    // extraScores = List(4, 5, 6)
    valallScores = scores ::: extraScores
    valevenMoreScores = 7 :: allScores
    Nil is synonym for empty list
  • 11. Foreach
    valscores = List(1, 2, 3)
    // equivalent
    scores.foreach((n: Int) => println(n))
    scores.foreach(n => println(n))
    scores.foreach(println)
  • 12. For comprehensions
    valscores = List(1, 2, 3)
    for (s <- scores)
    println(s)
    for (s <- scores if s > 1)
    println(s)
  • 13. Arrays
    valnames = Array("John", "Jane")
    names(0) = "Richard" // Arrays are mutable
    val cities = new Array[String](2)
    cities(0) = "Amsterdam"
    cities(1) = "Rotterdam"
    for (i <- 0 to 1)
    println(cities(i))
  • 14. Maps
    valtowns = Map("John" -> "Amsterdam", "Jane" -> "Rotterdam") // default immutable Map
    var a = towns("John") // returns "Amsterdam"
    a = towns get "John”// returns Some(Amsterdam)
    a = towns get "John"get // returns "Amsterdam"
    var r = towns("Bill") // throws NoSuchElementException
    r = towns get "Bill”// returns None
    towns.update("John", "Delft") // returns a new Map
  • 15. Classes & Constructors
    class Person(name: String, age: Int) {
    if (age < 0) thrownewIllegalArgumentException
    defsayHello() { println("Hello, " + name) }
    }
    class Person(name: String, age: Int) {
    require (age >= 0)
    defsayHello() { println("Hello, " + name) }
    }
  • 16. Classes & Constructors
    class Person(name: String, age: Int) {
    def this(name: String) = this(name, 21) // auxiliary
    def this(age: Int) = this(“John”, age) // auxiliary
    def this() = this(“John”, 21) // auxiliary
    }
  • 17. Classes & Constructors
    class Person(name: String, age: Int)
    ...
    val p = new Person("John", 33)
    val a = p.age// compiler error
    p.name = "Richard" // compiler error
    class Person(var name: String, val age: Int)
  • 18. Companion Objects
    // must be declared in same file as Person class
    object Person {
    defprintName = println("John")
    }
    valp = Person // Singleton is also an object
    Person.printName// similar to static methods in Java/C#
  • 19. Traits
    trait Student {
    varage = 10;
    def greet() = {
    "Hello teacher!"
    }
    def study(): String // abstract method
    }
  • 20. Extending Traits
    class FirstGrader extends Student {
    override def greet() = {
    "Hello amazing teacher!"
    }
    override def study(): String = {
    “I am studying really hard!"
    }
    }
  • 21. Trait Mixin
    // compiler error: abstract function study from trait Student is not implemented
    valjohn = new Person with Student
    traitSimpleStudent {
    def greet() = "Hello amazing teacher!"
    }
    // this is ok
    val john = new Person withSimpleStudent
    println(john.greet())
  • 22. Scala Application
    object Person
    def main(args: Array[String]) { // define a main method
    for (arg <- args)
    println("Hello " + arg)
    }
    }
    // or extend Application trait
    object Person extends Application {
    for (name <- List("John", "Jane"))
    println("Hello " + name)
    }
  • 23. Pattern Matching
    valcolor = if (args.length > 0) args(0) else ""
    valfruit match {
    case"red"=>"apple"
    case"orange" =>"orange"
    case"yellow" =>"banana"
    case_ => "yuk!"
    }
  • 24. Case Classes
    case class Var(name: String) extendsExpr
    val v = Var("sum")
    adds a Factory method with the name of the class
    all parameters implicitly get a val prefix, so they are maintained as fields
    “natural” implementation of toString, hashCode and equals
    big advantage: support pattern matching
  • 25. Exceptions
    try {
    args(0).toFloat
    } catch {
    case ex: NumberFormatException => println("Oops!")
    }
  • 26. Tuples
    valpair = ("John", 28) // Tuple2[String, Int]
    println(pair._1)
    println(pair._2)
    def divProd(x: Int, y:Int) = (x / y, x * y)
    valdp = divProd(10, 2)
    println(pair._1) // 5
    println(pair._2) // 20
  • 27. LABS!!
    Resources:
    http://www.scala-lang.org/api
    http://scala-tools.org/scaladocs/scala-library/2.7.1/
    http://www.codecommit.com/blog/scala/roundup-scala-for-java-refugees
    http://blogs.sun.com/sundararajan/entry/scala_for_java_programmers
  • 28. THANK YOU!