# Scala

## Notes

### function

to define a function:

def square(x:Double):Double = x * x

function literals

(x:Double) => x * x

when writing a function results Unit type, can use a short syntax:

def foo (x:Double) { // type and '=' sign can be ignored
/** do something and return Unit type, like print */
}

to declare a new type

type Vect = (Double, Double, Double)

### recursion

factorial

def fact(n:Int):Int = if (n < 2) 1 else n*fact(n-1)

### matching

expr match {
case pattern1 => expr1
...
}

val num = try {
} catch {
case 1 => ...
case e => ...
}

### array and list

making array

Array(1, 2, 3, 4)
Array("one", "two", "three", "four")
Array[Double](1, 2, 3, 4) // 1.0, 2.0, 3.0, 4.0

using array

var a = Array(1, 2, 3, 4)
a(0) // 1
a.length // 4
a.size // 4

list

List(1, 2, 3, 4)
List[Int](1, 2, 3, 4)

cons operator ::

val a = List(2, 3, 4)
1::a // List (1, 2, 3, 4)

basic methods

return part of collection

• drop (n:Int)
• init
• last
• slice (from:Int, until:Int) // until: before the given index
• splitAt (n:Int)
• take (n:Int)
• takeRight (n:Int)

boolean test

• contains (elem:Any)
• endsWith (that: Seq[B])
• isEmpty
• nonEmpty
• startsWith

search

• indexOf (elem:A)
• lastIndexOf (elem:A)

others

• diff (that: Seq[A])
• mkString // like implode of php
• reverse
• toArray, toList
• zip (that: Interable[B])
• zipWithIndex

higher order methods

• count (P:(A) => Boolean)
• dropWhile (P:(A) => Boolean)
• exists (P:(A) => Boolean)
• filter (P:(A) => Boolean)
• filterNot (P:(A) => Boolean)
• filterMap (f:(A) => Seq[B])
• forall (P:(A) => Boolean)
• foreach (f:(A) => Unit)
• indexWhere (P:(A) => Boolean)
• lastIndexWhere (P:(A) => Boolean)
• map (f:(A) => B)
• partition (P:(A) => Boolean)
• takeWhile (P:(A) => Boolean)

combinatorial/iterator methods

• combinations (n: Int)
• grouped (size: Int)
• inits
• permutations
• sliding (size: Int)
• tails

### loop

while(condition) statement
do { statement } while(condition)

range type:

1 to 10
1 until 10

if guards

for(...; if ...)

multiple generators

for (i <- 0 to 10; k <- 'a' to 'c') println(i + " " _+ k)

import scala.io.Source
val fileSource = Source.fromFile("input.txt") // fileSource is a BufferedSource object
fileSource.close
fileSource.mkString // this gives a string
fileSource.mkString // this gives nothing, after 1st mkString, fileSource becomes an empty iterator
fileSource.reset // reset to iterable

Source.fromURL(s:string)

other options of Souce object

• hasNext():Boolean
• hasNextDouble():Boolean
• hasNextInt():Boolean
• hasNextLine():Boolean
• next():String
• nextDouble()
• nextInt()
• nextLine()

write to file

import java.io.PrintWriter
val pw = new PrintWriter("output.txt")
for (i <- 1 to 100) {
pw.println(i)
// pw.flush
}
pw.close()

append to file

import java.io.{PrintWriter, FileWriter}
val pw = new PrintWriter(new FileWriter("output.txt", true)) // true for append

### oop

class

class TypeName (arg1:Type1, arg2:Type2, ...) {
// methods and members
}

visibility

public var count = 0
private var balance = 0
protected def foo { ... }

the apply method

arr(3) // => arr.apply(3)

the update method

obj(args) = e // => obj.update(args, e)

property assignment method

def balance_ = {...} // write a method with the name prop_ where prop is the property name
obj.balance = 100

inheritance

class TypeName extends SuperTypeName {
override def {...}
}

calling parent methods

super.method

anonymous class

val panel = new Panel {
// methods and members
}

which is equal to

class AnonymousPanel extends Panel {
// methods and members
}
val panel = new AnonymousPanel

abstract class

abstract className (...) {
...
}

traits, just like abstract class except:

1. traits ca not take arguments
2. more than one traits can be inherited
trait A { ... }
trait B extends A { ... }
trait B2 extends A { ... }
class C extends B with B2 with ... { ... }

final

final class { ... }
final def { ... }

### other collections

import scala.collection.immutable
import scala.collection.mutable
Set(1, 2, 3) // immutable
Map("one" -> 1, "two" -> 2) // immutable
Buffer(1, 2, 3, 4) // mutable

val c = new Thread {
...
sys.exit(0)
}
• synchronized
• wait/notify
• Atomic
• Locks

### parallel collections

import scala.collection.parallel