Scala training workshop 02

Nguyen Thanh TuanPlatform Department@Septeni Technology

Agenda- Summary

- Types and Pattern Matching- Lists- Collections- Lazy Evaluation

- Exercise- Share

Types and Pattern Matching- Functions as Objects- Subtyping and Generics- Objectis Everywhere- Variance- Decomposition- Pattern Matching- Lists

Functions as Objects

Source : Safaribooksonline.com

Example- If Expressions

if (10%2 == 0) println(“10 is a multiple of 2”)

- If-Else Expressionsval x = 10;val y = 5if (x > y) println(“Max number is :”+ x)else println(“Max numner is :” + y)

- Match Expressionsval x = 10;val y = 5;val max = x > y match { case true => x case true => y}

- A Pattern Alternative :val day = “MON”val kind = day match {

case “MON”| ”TUE” | “WED” | “THU” | “FRI” =>

“weekday”case “SAT” | “SUN” =>

“weekend”}

- Matching with Wildcard Patternscase _ => {println(s”Couldn’t parse

$message”) -1}- Matching with Pattern Guards

case 3 if 3 > 5=> println(“Something”)

Source : Safaribooksonline.com

Blocksval x = 0 def f(y: Int) = y + 1 val result = {

val x = f(3) x * x

} + x

- A block is delimited by braces { ... }

- It contains a sequence of definitions or expressions

- Blocks are themselves expressions; a block may appear everywhere an expression can

- The definitions inside a block are only visible from within the block.

Tail recursion- Recursion definition : A call B, B call A ..etc- Reasons we don’t see alot of recursion code in Java

- is hard ( is not intuitive : you see one layer and you have to imagine what happens when those layers stack up)

- is not designed to accommodate recursion. It’s designed to accommodate iteration.

- But in Scala, being a function language is very much geared toward recursion rather than iteration ( Scala in the case of tail recursive, can eliminate the creation of a new stack frame and just re-use the current stack frame)

Exampledef pascal(c: Int, r: Int): Int = { if(c == 0) return 1 if(c == 1 && c != r) return r if(c == r) return 1 pascal(c-1,r-1)+pascal(c,r-1) }

Tail&Head recursion in Scaladef listLength2(list: List[_]): Int = { def listLength2Helper(list: List[_], len: Int): Int = { if (list == Nil) len else listLength2Helper(list.tail, len + 1) } listLength2Helper(list, 0)}

var list1 = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)println( listLength2( list1 ) )

def listLength1(list: List[_]): Int = { if (list == Nil) 0 else 1 + listLength1(list.tail)} var list1 = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

println( listLength1( list1 ) )

Higher-order function- Higher Order Functions

- Currying

Higher-order functionScala allows the definition of higher-order functions.- Functions can take other functions as parameters

- Result is a function- Example

Example higherOrderobject higherOrder { def main(args: Array[String]) {

println( apply( layout, 10) )

}

def apply(f: Int => String, v: Int) = f(v)

def layout[A](x: A) = "[" + x.toString() + "] }

Currying FunctionsCurrying transforms a function that takes multiple parameters into a chain of function, each taking a single parameter. Curried functions are defined with multiple parameter lists, as follows :def strcat(s1: String)(s2: String) = s1 + s2

OR

def strcat(s1: String) = (s2: String) => s1 + s2

Example Currying functionsobject Currying { def main(args: Array[String]) { val str1:String = "Hello, " val str2:String = "Scala!" println( "str1 + str2 = " + strcat(str1)(str2) ) }

def strcat(s1: String)(s2: String) = { s1 + s2 }}

Data and Abstraction- Class hierarchy- Trait and Abstractclass

Class hierarchy

Source : meetfp.com

Trait and Abstract class- Scala has traits, and a trait is more flexible than an abstract class, so you

wonder, “When should I use an abstract class?”- Reason is :

- You want to create a base class that requires constructor arguments- The code will be called from Java code

- We can use

abstract class Animal(name: String)- But we can’t use

trait Animal(name: String)

Trait ( The reason we should use trait )

- One big advantage of traits is that you can extend multiple traits but only one abstract class. Traits solve many of the problems with multiple inheritance but allow code reuse.

- Define types by specifying the signatures of supported methods. This is similar to how interfaces work in Java.

But trait can’t- Traits do not have constructor parameters (but this should not be an issue in practice).- Traits impose a slight performance overhead (but this is unlikely to impact the overall performance

of your program)- Traits introduce compilation fragility for classes that mix them in. If a trait changes, a class that

mixes it in has to be recompiled

Exercises - Pascal’s Triangle

The following pattern of numbers is called Pascal’s triangle.

1 1 1 1 2 1 1 3 3 11 4 6 4 1 ...

The numbers at the edge of the triangle are all 1, and each number inside the triangle is the sum of the two numbers above it. Write a function

that computes the elements of Pascal’s triangle by means of a recursive process.

Do this exercise by implementing the pascal function in Main.scala, which takes a column c and a row r, counting from 0 and returns the

number at that spot in the triangle. For example: pascal(0,2)=1, pascal(1,2)=2 and pascal(1,3)=3.

def pascal(c: Int, r: Int): Int

Source : coursera.org

Exercisesobject Main { def main(args: Array[String]) { println("Pascal's Triangle") for (row <- 0 to 10) { for (col <- 0 to row) print(pascal(col, row) + " ") println() } def pascal(c: Int, r: Int): Int = {

c match { case 0 => 1 case 1 if c == 1 && c != r => r case r => 1 case _ => pascal(c-1,r-1)+pascal(c,r-1) } }}

Shares

Thank for comming