Uncategorized

Scala’s Hierarchy

  • Just as Any is a superclass of every other class, Nothing is a subclass of every other class
  • The root class Any has two subclasses: AnyVal and AnyRef. AnyVal is the parent class of every built-in value class in Scala. There are nine such value classes: Byte, Short, Char, Int, Long, Float, Double, Boolean, and Unit. The first eight of these correspond to Java’s primitive types, and their values are represented at run time as Java’s primitive values. The other value class, Unit, corresponds roughly to Java’s void type; it is used as the result type of a method that does not otherwise return an interesting result
Uncategorized

Composition and Inheritance

Composition means one class holds a reference to another, using the referenced class to help it fulfil its mission. Inheritance is the superclass/subclass relationship.
  • The ++ operation concatenates two arrays
  • The zip method picks corresponding elements in its two arguments and forms an array of pairs. For instance, this expression:
Array(1, 2, 3) zip Array("a", "b")
Will evaluate to:
Array((1, "a"), (2, "b"))
Uncategorized

Options

Options allow us to protect against NullPointerException exceptions.
Option[A] is a container for an optional value of type A. If the value of type A is present, the Option[A] is an instance of Some[A], containing the present value of type A. If the value is absent, the Option[A] is the object None.
For example:
def track(user: Option[User]) = match {
     case Some(u) => Tracker.track(u.id)
     case None => Tracker.track(GUEST)
}
More compact way:
Tracker.track(user map (_.id) getOrElse GUEST)
They can accept filters (conditions) as well:
def track(user: Option[User]) = match {
     case Some(u) if u.canTrack => Tracker.track(u.id)
     case _ => Tracker.track(GUEST)
}
More compact way:
Tracker.track(user filter (_.canTrack) map (_.id) getOrElse GUEST)
More robust:
def track(user: Option[User]) = match {
     case Some(u) if u.canTrack => Tracker.track(u.id)
     case None => Tracker.track(GUEST)
     case _ =>
}
More compact way:
if (user forall (_.canTrack))
     Tracker.track(user map (_.id) getOrElse GUEST)
Uncategorized

Control Abstraction

  • Reducing code duplication
    • higher-order functions are functions which take functions as parameters and are better for simplifying code
  • Currying
    • A curried function is applied to multiple argument lists, instead of just one:
      • eg. normal method: def normalSum(num1: Int, num2: Int) = num1 + num2
      • eg. curried method: def plainOldSum(x: Int, y: Int) = x + y What’s happening here is that when you invoke curriedSum, you actually get two traditional function invocations back to back. The first function invocation takes a single Int parameter named x, and returns a function value for the second function. This second function takes the Int parameter y
  • Writing new control structures
    • In languages with first-class functions, you can effectively make new control structures even though the syntax of the language is fixed. All you need to do is create methods that take functions as arguments
Uncategorized

Functions and Closures

  • Local functions: in Scala, you can define functions inside other functions. They will be inaccessible from outside the containing method. They can access the parameters of their enclosing functions
  • Function literals:
var increase = (x: Int) => x + 1
increase(10) //prints 11
  • foreach method takes a function as an argument and invokes that function on each of its elements:
val myList = List (1, 2, 3)
myList.foreach((x: Int) =>  (x))
  • filter method selects those elements of the collection that pass a test the user supplies:
val myList = List (1, 2, 3)
println(myList.filter((x: Int) => x > 2)) //prints 3
//or mix them with foreach:
myList.filter((x: Int) => x > 2).foreach((x: Int) => println(x)) //prints 3
  • One way to make function literals more brief, is to leave off the parameter types. This is called target typing because the targeted usage of an expression is allowed to influence the typing of that expression:
println(myList.filter((x) => x > 2)) // same as x => x > 2
  • Placeholder syntax: you can use underscores as placeholders for one or more parameters, as long as each parameter appears only one time within the function literal. Multiple underscores mean multiple parameters, not reuse of a single parameter repeatedly:
myList.filter(_ > 2)
  • Partially applied function: is an expression in which you don’t supply all of the arguments needed by the function. Instead, you supply some, or none of the needed arguments. You can replace an entire parameter list with an underscore:
//e.g.1:
myList.foreach((x: Int) => println(x)) //is same as:
myList.foreach(println _) //is same as:
myList.foreach(println)

//e.g.2:
def sum(a: Int, b:Int, c: Int) = a + b + c
val a = sum _
a(1, 2, 3) // 6
val b = sum(1, _ : Int, 3)
b(3) // 7
  • Closures: closures capture variables themselves, not the value to which the variables refer:
val more = 10
val addMore = (x: Int) => x + more //more is called a free variable, x is bounded variable
  • Special function call forms: Scala supports repeated parameters, named arguments, and default arguments:
    • Repeated parameters: Scala allows you to indicate last parameter of a function may be repeated:
def echo(args: String*) = 
    for(arg <- args) println (arg)

echo(“Hello”, “world”)

//you can pass an array of strings to this method this way:
val strArr = Array(“Hello”, “World”)
echo(strArr: _*) //this tells the compiler to pass each element of array as its own argument to echo, rather than all of it as one single argument
    • Named arguments: named arguments allow you to pass arguments to a function in a different order:
def speed(distance: Float, time: Float): Float = distance / time
speed(time = 10, distance = 100)
    • Default parameter values: Scala lets you specify default values for function parameters
def speed(distance: Float, time: Float = 50): Float = distance / time
speed(distance = 100) //2
  • Tail recursion: functions which call themselves as the last action, are called tail recursive. The Scala compiler detects tail recursion and replaces it with a jump back to the beginning of the function, after updating the function parameters with the new values. So, if the method is tail recursive, there won’t be any runtime overhead to be paid:
def approximate(guess: Double): Double = {
    if (isGoodEnough(guess)) guess
    else approximate(improve(guess))
Uncategorized

Built-in Control Structures

  • The only control structors in Scala are if, while, for, try, match, and function calls
  • if: val filename = if (args.nonEmpty) args(0) else “default_filename”
  • while loop: there are two types:
while (a != 0) {
    val temp = a
    a = b % a
    b = temp
}

do {
    line = readLine()
    println("Read: "+ line)
} while (line != "")
  • for loop: the for expression syntax works for any kind of collection, not just arrays. There are many ways to use a for loop:
//simple loop
val filesHere = (new java.io.File(".")).listFiles
for (file <- filesHere)
println(file)

//this adds filtering to the for loop
for (file <- filesHere if file.getName.endsWith(".scala"))
println(file)

//it’s possible to have multiple conditions
for (
    file <- filesHere
    if file.isFile
    if file.getName.endsWith(".scala")
) println(file)

//nested iteration
def fileLines(file: java.io.File) = scala.io.Source.fromFile(file)
    .getLines().toList

def grep(pattern: String) =
    for (
        file <- filesHere
        if file.getName.endsWith(".scala");
        line <- fileLines(file)
        if line.trim.matches(pattern)
) println(file +": "+ line.trim)

grep(".*gcd.*")

//mid-steram variable bindings
def grep(pattern: String) =
    for {
        file <- filesHere
        if file.getName.endsWith(".scala")
        line <- fileLines(file)
        trimmed = line.trim
        if trimmed.matches(pattern)
    } println(file +": "+ trimmed)

grep(".*gcd.*")

//producing a new collection
/*this will assemble a collection of Scala files. The type of the 
resulting collection is based on the kind of collections 
processed in the iteration clauses. In this case the result is an 
Array[File], because filesHere is an array and the type of the yielded 
expression is File.*/

def scalaFiles =
    for (
        file <- filesHere
        if file.getName.endsWith(“.scala”)
    ) yield file
  • throwing exceptions: e.g. throw new RuntimeException(“n must be even”). In this example, one branch of an if computes a value, while the other throws an exception and computes Nothing. The type of the whole if expression is then the type of that branch which does compute something.
  • try/catch expressions: example:
try {
    val f = new FileReader(“filename.txt”)
} catch {
    catch ex: FileNotFoundException =>
    catch ex: IOException =>
}
  • finally clause: you can wrap an expression in a finally clause if you want to cause some code to execute no matter how the expression terminates. e.g.:
val f = new FileReader(“input.txt)
    try {
        //something
    } finally {
        f.close()
}
  • match expression: is like switch statement. The default is specified using an underscore (_). There’s no break keyword, as there is no fall through from one alternative to the next. Big difference to Java/PHP, is that match results in a value e.g.:
val input = args(0)
    input match {
        case “salt” => println(“pepper”)
        case _ => println(“type salt!”)
    }

//Same as:

val result = input match {
    case “salt” => “pepper"
    case _ => println(“type salt!”)
}

println (result)