Functional Programming in Scala

CAIRO TECH CLUB SESSION 5: Functional Programming in Scala
Functional Programming in
Bassam Abd El-Hamid
@MrBassam

Von Neumann architecture

Von Neumann bottleneck
“Can Programming be Liberated from the von Neumann
Style?”
John Backus 1977

History of FP languages

A formal system in mathematical logic and
computer science for expressing computation by
way of variable binding and substitution
λ-calculus
http://en.wikipedia.org/wiki/Lambda_calculus

* Referential transparency
* No side effect
* Remove unused expression safely
Pure functions

Scalable Language
Martin Odersky
2003
www.scala-lang.org

Why Scala?

Object-Oriented
Functional
Statically Typed
Runs on the JVM
Can Execute Java Code

All types are objects
Type inference.
Nested Functions.
Functions are objects.
Domain specific language (DSL) support
Traits.
Closures.
Concurrency support inspired by Erlang.
vs Java

Who is using Scala?

Who is using Scala?
And more ...

Links:
Who's using Scala? (March, 2013)
http://alvinalexander.com/scala/whos-using-scala-akka-play-framework
Scala Adoption by Enterprises
http://www.slideshare.net/mslinn/scala-adoption-by-enterprises
Scala in the Enterprise
http://www.scala-lang.org/node/1658

Syntax

// This is a valid comment
/* This is a multiline
comment */
Comments:

object HelloWorld {
def main(args: Array[String]) {
println("Hello, world!")
}
}
Hello, world!

val s = "hello" // ; not requierd
println(s)
val s = "hello"; println(s) // ; is REQUIRED
Newline Characters

Keywords

package com.bassam.stuff
// Import one class
import scala.collection.mutable.HashMap
// Import more than one
import scala.collection.immutable.{TreeMap, TreeSet}
// Import all
import scala.xml._
Scala Packages

var or val VariableName : DataType [= Initial Value]
var myVar : String = "mutable variable"
val myVal : String = "immutable variable"
//Multiple assignments:
val (myVar1: Int, myVar2: String) = Pair(5, "Foo")
Variable Declaration

Data Types (the same data types as Java)

class Point(xc: Int, yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
Classes, Objects and Traits

class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
}}
class Location(override val xc: Int, override val yc: Int,
val zc :Int) extends Point(xc, yc){
var z: Int = zc
def move(dx: Int, dy: Int, dz: Int) {
x = x + dx
y = y + dy
z = z + dz
println ("Point z location : " + z);
}}

trait someTrait {
var somevar: Int=0
def someFun(x: Int): Int = (x*2)/5
}
trait anotherTrait {
var anothervar: Int=0
def anotherFun(x: Int): Int = (x*7)/100
}
class class1(){}
class class2() extends class1 with someTrait with
anotherTrait
{}

private visible only inside the class or object
protected only accessible from subclasses
public accessed from anywhere (Default)
protected[UpToScope]
private[UpToScpoe]
Access Modifiers

if(Boolean_expression 1){
//Executes when the Boolean expression 1 is true
}else if(Boolean_expression 2){
}else if(Boolean_expression 3){
}else {
//Executes when the none of the above condition is
true.
}
IF...ELSE

while(condition){
statement(s);
}
do{
statement(s);
}while( condition );
for( x <- Range ){
statement(s);
}
Loop Types

import scala.util.control.Breaks
...
var x:Int=1
val brk=new Breaks
brk.breakable{
while( x>0 ){
if (x==10) brk.break
print(x)
x=x+1
}}
break a loop

def functionName ([list of parameters]) : [return type] = {
function body
return [expr]
}
def sum(x:Int,z:Int):Int=z+x
def pi=3.14
Sum(5,6) //11
Functions

def v:Int=5*6
def sum(x: => Int,z:Int):Int=z+x
sum(v,5) //35
Functions Call-by-Name

def sum(x: Int,z: Int):Int=z+x
sum(z=5,x=6)
Functions with Named Arguments

def sum( nums : Int* ) :Int ={
var buf:Int=0
for( i <- nums) buf=buf+i
}
sum(5,2,74,....)
Function with Variable Arguments

def sum( a:Int=5, b:Int=7 ) : Int = {
var s:Int = 0
s = a + b
return s
}
Default Parameter Values for a Function

def factorial(i: Int): Int = {
def fact(i: Int, accumulator: Int): Int = {
if (i <= 1)
accumulator
else
fact(i - 1, i * accumulator)
}
fact(i, 1)
}
Nested Functions - local functions

def factorial(n: BigInt): BigInt = {
if (n <= 1)
1
else
n * factorial(n - 1)
}
Recursion Functions

object Test {
val date = new Date
log(date, "message1" )
}
def log(date: Date, message: String) = {
println(date + "----" + message)
}
}
Partially Applied Functions

object Test {
val logWithDateBound = log(new Date, _ : String)
logWithDateBound("message1" )
}
def log(date: Date, message: String) = {
println(date + "----" + message)
}
}
Partially Applied Functions

([list of parameters]) => function body
object Test {
var sum=(x:Int,z:Int) => x+z
println(sum(5,6))
}
}
Anonymous Functions

object Test {
println( apply( layout, 10) )
}
def apply(f: Int => String, v: Int) = f(v)
def layout[A](x: A) = "[" + x.toString() + "]"
}
Higher-Order Functions

val multiplier = (i:Int) => i * 10
val multiplier = (i:Int) => i * factor
var factor = 3
val multiplier = (i:Int) => i * factor
Closures

Currying transforms a function that takes multiple
parameters into a chain of functions, each taking
a single parameter
Currying Functions schönfinkeling

def strcat(s1: String,s2: String) = s1 + s2
def strcat(s1: String) = (s2: String) => s1 + s2
def main(args: Array[String]){
print (strcat ("Hello ")("World"))
}

def sum(x: Int,z: Int) = x + z
def main(args: Array[String]){
val sumCurried = Function.curried(sum _)
print (sumCurried(5)(6))
}

object Test {
println(matchTest(3))
}
def matchTest(x: Int): String = x match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
}
Pattern Matching

object Test {
println(matchTest("two"))
println(matchTest("test"))
println(matchTest(1))
}
def matchTest(x: Any): Any = x match {
case 1 => "one"
case "two" => 2
case y: Int => "scala.Int"
case _ => "many"
}
}
Pattern Matching

object Test {
val alice = new Person("Alice", 25)
val bob = new Person("Bob", 32)
val charlie = new Person("Charlie", 32)
for (person <- List(alice, bob, charlie)) {
person match {
case Person("Alice", 25) => println("Hi
Alice!")
case Person("Bob", 32) => println("Hi Bob!")
case Person(name, age) =>
println("Age: " + age + " year, name: " +
name + "?")
}}}
// case class, empty one.
case class Person(name: String, age: Int)
}
Pattern Matching

var x:Array[String] = new Array[String](3)
//or
var z = new Array[String](3)
Arrays

var x:Array[String] = new Array[String](3)
//or
var x = new Array[String](3)
//or
var x = Array("One", "Two", "Three")
x(0)="One" ; x(1)="Two" ; x(2)="Three"
Arrays

var myMatrix = Array.ofDim[Int](3,3)
myMatrix(0)(1)=10
Multi-Dimensional Arrays

var myArr1 = Array(1.9, 2.9, 3.4, 3.5)
var myArr2 = Array(8.9, 7.9, 0.4, 1.5)
var myArr3 = Array.concat( myArr1, myArr2)
Arrays

var a=(0 to 10) //from 0 to 10
var b=(0 until 10) //from 0 to 9
var c=(0 to 10 by 2) // step 2
ranges

// List of Strings
val fruit: List[String] = List("apples", "oranges",
"pears")
// List of Integers
val nums: List[Int] = List(1, 2, 3, 4)
// Empty List.
val empty: List[Nothing] = List()
// Two dimensional list
val dim: List[List[Int]] =
List(
List(1, 0, 0),
List(0, 1, 0),
List(0, 0, 1)
)
Lists

// List of Integers
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))
// Empty List.
val empty = Nil
// Two dimensional list
val dim = (1 :: (0 :: (0 :: Nil))) ::
(0 :: (1 :: (0 :: Nil))) ::
(0 :: (0 :: (1 :: Nil))) :: Nil
}
}
Lists

// Empty set of integer type
var s : Set[Int] = Set()
// Set of integer type
var s : Set[Int] = Set(1,3,5,7)
//or
var s = Set(1,3,5,7)
Sets

/*Empty hash table whose keys are strings and
values are integers:*/
var A:Map[Char,Int] = Map()
// A map with keys and values.
val colors = Map("red" -> "#FF0000", "azure" ->
"#F0FFFF")
Maps / Hash tables

val tup = (1, "hello", Console)
//Which is syntactic sugar for:
val t = new Tuple3(1, "hello", Console)
val sum = t._1 + t._2 + t._3
t.productIterator.foreach{ i =>println("Value = " +
i )}
Tuples

object Test {
val it = Iterator("a", "number", "of", "words")
while (it.hasNext){
println(it.next())
}
}
}
Iterators

object Test {
def findPerson(key: Int): Option[Person]
val capitals = Map("France" -> "Paris", "Japan"
-> "Tokyo")
println("capitals.get( "France" ) : " +
capitals.get( "France" ))
println("capitals.get( "India" ) : " +
capitals.get( "India" ))
}
}
Options

import scala.util.matching.Regex
object Test {
val pattern = "Scala".r
val str = "Scala is Scalable and cool"
println(pattern findFirstIn str)
}
}
Regular Expressions

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
object Test {
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException =>>{
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}}}}
Exception Handling

Questions

Thank you :)

Functional Programming in Scala

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (19)

En vedette

En vedette (20)

Similaire à Functional Programming in Scala

Similaire à Functional Programming in Scala (20)

Dernier

Dernier (20)

Functional Programming in Scala