SCALA - Functional domain

SCALA
Functional domain
#cododajnia
Bartosz Kosarzycki
@bkosarzyckiMar 26, 2018

Outline
- SCALA introduction
- SCALA compared to other JVM languages / Kotlin vs SCALA
- Basic SCALA syntax
- Build tools - gradle/SBT
- Lambda calculus
- Functional programming
- Currying
- Pattern matching
- Lazy evaluation
- Scalaz

SCALA runs on:
Recommended IDEs:
Interactive playground:
https://scastie.scala-lang.org

TIOBE index (march 2018):
Language index
Java 1
C++ 3
JavaScript 8
Swift 12
Go 17
Dart 22
Scala 30
Kotlin 38
Bash 43

Companies using SCALA
Company Purpose
Twitter throughout the company, own utils
LinkedIn Scalatra microframework
Airbnb Aerosolve - open source machine learning software
Zalando Entire technology stack
Walmart Canada Backend platform
SoundCloud Finagle (micro services), Scalding and Spark (data
processing)
Google Firebase (parts), Nest
Verizon Quiver (multi-graphs), utils, whole tech. stack
Others: Siemens, Sony Pictures, Imageworks, Duolingo...

History of SCALA
- Designed by Martin Odersky (who worked on Java generics in
J2SE 5.0, and Pizza - Java with Generics, function pointers,
case-classes, pattern-matching)
- Released in 2003
- In May Odersky launches Typesafe Inc. (now - Lightbend Inc.)
which provides commercial support for Scala
- Scala is one of the few languages developed in close collaboration
with university society (technically “in the Academia”)
- As of now - Scala 2.12.4, increased performance
- SCALA = Java (OO) + Pizza + functional programming focus
* OO - Object Oriented Language

Road to functional programming - SCALA
- Seamless integration of functional programming features into an
otherwise object-oriented language
- “scala” - name comes from the ability to scale along with the
growing complexity of the project
- concurrent - ready for multi-core, micro-service world

Road to functional programming - SCALA
Non-functional Functional

Kotlin vs SCALA
SCALA Kotlin
Java interoperability Java code from Scala (100%)
Scala code from Java (edge
cases not supported)
bidirectional, 100%
Pattern matching yes, better yes
Design designed in the Academia designed by a leading
software/IDE company
Operator overloading yes, better
+ operator looking functions
yes
Compilation slower faster
Community bigger smaller (still relatively new)
Backward compatibility no yes (up to this point)

Kotlin vs SCALA
Scala has the right features, but its most obvious
deficiency is very slow compilation," said Dmitry Jemerov,
JetBrains development lead

Kotlin vs SCALA
Kotlin is a Better Java
- excellent tools
- syntactic sugar
- performance
- compatibility
- simple rather than formal
SCALA is more powerful than Java
- designed to do things Java cannot
- pattern matching
- monads
- traits
- full-blown closures
etc.

Classes and Objects
class Car {
def startEngine(): Unit = {
engine.invokeIgnition()
}
def openDoor(): Unit = {
}
}
object Car {
def build(color: Color): Car = {
new Car().withColor(color)
}
val RED = Color.fromHex(“#FF0000”)
}

Methods
class Car {
val engine = new Engine()
def startEngine(): Unit = {
engine.invokeIgnition();
}
def stopEngine = engine.stop
}
- {} are optional
- ; are optional
- () are optional
- return value is optional
- ‘return’ keyword is optional
- whole class body is a ‘constructor’
(functional domain/everything is a func)
- multiple parameter lists [this will exaplained later]
def multiply(x:Int)(y:Int): Int = x * y

Method arguments
add({
val res = 33 + 66
println(res)
res
}, 2)
def multiply (elems: Int*): Int = {
elems.foldLeft( 0)((accum, element) =>
accum * element)
}

Multiple classes in a file + inner classes
class Graph {
class Node {
var connectedNodes: List[Node] = Nil
}
}
class Tree

Postfix operator notation
List(1,2,3) head
2 + 2
2.+(2)

Build systems for SCALA
SBT
- performance
- SBT shell
- “Scala build tool”
GRADLE
- possible
- more configuration needed
- gradle 4.6 Scala Plugin - link

Build tools: Gradle
- Install gradle
(brew on macos/apt-get ubuntu)
- Run initialization script
- Import build.gradle into
IntelliJ IDEA
- Add “.idea” & “.gradle” to
.gitignore
Repository: link
Branch: feature/gradle-build-tool
$> gradle init --type scala-library
$> ./gradlew clean build
$> brew install gradle

Build tools: Gradle
Repository: link
class Application {
def run(args: Array[String]): Unit = {
println("Hello world!" )
}
}
object Application extends App {
override def main(args: Array[String]): Unit = {
new Application().run(args)
}
}
Entry point

Build tools: Gradle
Repository: link
Build.gradle:
plugins {
// Apply the scala plugin to add support for Scala
id 'scala'
}
dependencies {
// Use Scala 2.11 in our library project
compile 'org.scala-lang:scala-library:2.11.8'
}
repositories {
jcenter()
}

EXERCISE 1
Create gradle project
$> gradle init --type scala-library
$> ./gradlew clean build$> brew install gradle

Build tools: SBT
- Install sbt
(brew install sbt / Linux: link)
- Check version: sbt sbtVersion
[1.1.1]
- run ‘scala new’ and name the project
‘cododajnia’
- Import build.sbt into
IntelliJ IDEA
- Add “.idea” to
gitignore
Repository: link
Branch: feature/sbt-build-tool
$> sbt new scala/hello-world.g8
$> cd cododajnia; sbt clean compile
$> brew install sbt
$> sbt sbtVersion

Build tools: SBT
Add “target/” & “project/target/” to .gitignore
Repository: link
Branch: feature/sbt-build-tool
object Main extends App {
println("Hello, World!")
}
Main object is added automatically:
scalaVersion := "2.12.4"
name := "hello-world"
organization := "ch.epfl.scala"
version := "1.0"
libraryDependencies += "org.typelevel" %% "cats-core" % "1.0.1"

EXERCISE 2
Create sbt project
$> brew install sbt
$> sbt new scala/hello-world.g8
$> cd cododajnia; sbt clean compile

Functional programming
- computation as the evaluation of mathematical functions
- avoids mutable data, stateless
- expressions/declarations instead of statements
- originates from λ-calculus (lambda calculus)
- concept of "pure function" - always the same result for a
given set of parameters
- methods should have no "side effects"
- everything is a function

Lambda calculus
- mathematical formalism
- invented in 1932 by Alonzo Church
- turing complete - universal model of computation
- untyped and typed variety of the calculus
- making one "abstraction" == "declaring" a function λx.x
- everything is a function

Lambda calculus
Anjana Vakil, EuroPython Conference, July 2017

Currying in SCALA
def add(x:Int): Int=>Int = (y) => x + y
Add function:
def add(x:Int): Int=>Int = (y) => x + y
Curried function (full syntax):
def add(x:Int)(y:Int):Int = x + y
Curried function (short syntax):
add(6)(5)
val add6 = add(6)
add6(5)
val add6 = add(6)_
add6(5)

Currying in SCALA
def calculateMean(businessCustomersBasketVal: Int*)
(homeCustomersBasketVal: Int*): Float
Common usages:
or for error handling:
calculateMean(1,2,7,6,5)(1,2)
def registerCustomer (successAction: User => Unit)
(homeCustomersBasketVal:() => Unit): Float

EXERCISE 2
Create a curried func
$> brew install scala
Create a curried function which adds two arguments to each other

Tail recursion
- Function contains ONLY A SINGLE
recursive call and it is the last statement
to be executed
- Tail recursion can be replaced
by iteration to remove recursion
from the solution

Tail recursion
def factorial(x:Long):Long = if (x <= 1) 1
else x * factorial(x - 1)
factorial(100000L) //100 000
Exception in thread "main" java.lang.StackOverflowError
Recursion:
6 * 5 * 4 * 3 * 2 * 1

Tail recursion
def factorialTail(number:Long):Long = {
def factorialWithAcc (acc:Long, x:Long):Long =
if (x <= 1) acc
else factorialWithAcc(acc * number , number -1)
factorialWithAcc( 1, number)
}
factorialTail(100000L) //100 000
Recursion:
1 * 2 * 3 * 4 * 5 * 6

Tail recursion
Automatically transformed into iteration:

CHURCH NUMERALS
Representing numerals, operators & data in the lambda calculus

object ChurchNumerals {
type Succ[Z] = Z => Z
type ChNum[Z] = Succ[Z] => Z => Z
def zero[Z]: ChNum[Z] =
(_: Succ[Z]) => (z: Z) => z
def succ[Z] (num: ChNum[Z]): ChNum[Z] =
(s: Succ[Z]) => (z: Z) => s( num(s)(z) )
// a couple of church constants
def one[Z] : ChNum[Z] = succ(zero)
def two[Z] : ChNum[Z] = succ(one)
// the addition function
def add[Z] (a: ChNum[Z]) (b: ChNum[Z]) =
(s: Succ[Z]) => (z: Z) => a(s)( b(s)(z) )
def four[Z] : ChNum[Z] = add(two)(two)
// test
def church_to_int (num: ChNum[Int]): Int =
num((x: Int) => x + 1)(0)
def fourInt: Int = church_to_int(four)
def main(args: Array[String]): Unit = {
println(s"2 + 2 = ${fourInt}")
}
}

Lists
SCALA
systematically
distinguishes between
mutable and immutable
collections
MUTABLE ≠ IMMUTABLE

Lists
Array Buffers
List Buffers
StringBuilders
Linked Lists
Double Linked Lists
Mutable Lists
Queues
Array Sequences
Stacks
Array Stacks
Hash Tables
Weak Hash Maps
Concurrent Maps
Mutable Bitsets

Lists
// Create a Scala List in the Lisp style
val list = 1 :: 2 :: 3 :: Nil
// Create a Scala List in the Java style
val list2 = List(1,2,3)
val list3 = List[Number](1,2,3)
// Create a Scala List with the ‘range’ method
val list4 = List.range(1, 10) // List(1, 2, 3, 4, 5, 6, 7, 8, 9)
val list5 = List.range(0, 10, 2) // List(0, 2, 4, 6, 8)
// Create a Scala List with the List class ‘fill’ method
val x = List.fill(3)("foo") // List(foo, foo, foo)

Conversion from Java to SCALA collections
import collection.JavaConverters._
List(1,2,3).asJava // Java List
List(1,2,3).asJavaCollection // Java collection

Traits
- like Java 8 interfaces (Java 7 could not have interface implementation)
- abstract classes vs traits
- traits cannot have constructor parameters

Traits
class Ball {
def props(): List[String] = List()
override def toString() = "It's a" + props.mkString(" ", ", ", " ") + "ball"
}
trait Red extends Ball {
override def props() = super.props ::: List("red")
}
trait Shiny extends Ball {
override def props() = super.props ::: List("shiny")
}
// hint: traits are called from right to left
// that is Red and then Shiny
val myBall = new Ball with Shiny with Red
println(myBall) // It's a shiny, red ball

EXERCISE 3
Trait for pretty print
Create a trait which changes behaviour of List’s toString() method

EXERCISE 3
Solution
trait ListPrettyPrint[ T] extends mutable.MutableList[ T] {
override def toString() : String = {
this.mkString("[", ", elem: ", "]")
}
}
val stringList = (new mutable.MutableList[ String] with
ListPrettyPrint[ String]
+= "cat" += "dog" += "tiger")
println(stringList)

Apply and unapply functions
Apply - when you treat your object like a function, apply is the method
that is called
obj(a, b, c) is equivalent to obj.apply(a, b, c)
- one apply()’s args need to match constructor
object User {
def apply(name: String): User = new User(name)
}

Apply and unapply functions
Unapply - is used in Scala's pattern matching mechanism and its most
common use I've seen is in Extractor Objects
object User() {
def unapply(arg: User): Option[( String, String)] = {
Option.apply(("a", "b"))
}
}

Case classes
// Has properties id & msg
class Message(p_id:String, p_msg:String) {
val id = p_id
val msg = p_msg
}
class Message2(val id:String,val msg:String)
case class Message3(id:String, msg:String)
// Getter and setter methods (java) - getId(), setId() etc.
class Message4(@BeanProperty val id:String, @BeanProperty val
msg:String)

Case classes
// custom constructors
case class Message5(@BeanProperty val id:String,
@BeanProperty val msg:String) {
def this() = this(null, null)
def this(msg:String) = this(null, msg)
}

Pattern matching
checking value against a pattern
procedural/functional - result can be returned
val random: Int = Random.nextInt(10)
val numberString = random match {
case 0 => "zero"
case 1 => "one"
case 2 => "two"
case _ => "many"
}

Pattern matching on type/case classes
abstract class Notification
case class Email(sender: String, title: String, body: String)
extends Notification
case class SMS(message: String) extends Notification
notification match {
case Email(sender, title, body_) =>
print(s"You got an email from $sender with title: $title")
case SMS(message) =>
print(s"You got an SMS! Message: $message")
}

Pattern matching on multiple types
abstract class Notification
case class Email(sender: String, title: String, body: String)
extends Notification
case class SMS(message: String) extends Notification
notification match {
case (Email(sender, title, body_) | SMS(message)) =>
print(s"You got a message” )
}

Safe pattern matching
object Foo {
def unapply(x : Int) : Option[String] =
if(x == 0) Some("This value is zero") else None
}
val myInt = 1
myInt match {
case Foo(str) => println(str)
}

Safe pattern matching
val myInt = 1
myInt match {
case Foo(str) => println(str)
case _ => println("other: _")
}
results in:

Pattern matching
STRING comparison
regex pattern search
Object vs Object comparison
- performance
- conciseness
(brevity of code)

DATA STREAM
Analyze data and look
for patterns
Pattern matching

Pattern matching
Recently languages are borrowing concepts from newer breed of
functional languages. Type inference and pattern matching I am
guessing goes back to ML. Eventually people will come to expect these
features too. Given that Lisp came out in 1958 and ML in 1973, it seems
to take decades for good ideas to catch on. For those cold decades,
these languages were probably considered heretical or worse “not
serious.”

EXERCISE 4
Pattern match emails
From a given messages list (mobile + email), select sucessive email
messages from the same person [i.e. ignoring domain names]
val messageList = List(
Message("tom@gmail.com" ,"Message text 1" ),
Message("7742394590","Message text 2" ),
Message("8326192398","Message text 3" ),
Message("lisa@gmail.com" ,"Message text 4" ),
Message("lisa@yahoo.com" ,"Message text 5" ),
Message("harry@gmail.com" ,"Message text 6" )
)

EXERCISE 4
Pattern match emailscase class Message(id:String, msg:String)
object Message{
def apply(id:String, msg:String) = new Message(id,msg)
def unapply(m:Message) :Option[(String,String)] = {
if (m == null) None
else Some(m.id, m.msg)
}
}
object EmailAddress {
def apply(uname: String, dname: String) = uname + "@" + dname
def unapply(str: String): Option[(String, String)] = {
val parts = str split "@"
if (parts.length == 2) Some(parts(0), parts(1)) else None
}
}

EXERCISE 4
Pattern match emails
def testMessagePattern (msgList:List[Message]):String = {
msgList match {
case Nil => "Not found"
case Message(EmailAddress(u1,d1),_) :: Message(EmailAddress(u2,d2),_) :: _
if u1 == u2 => u1 + " got two successive emails"
case h::t => testMessagePattern(t)
}
}

Pattern matching
By default, pattern matching does not work with regular
classes.
Use case classes or implement:
apply()/unapply() methods

Higher order functions
- Functional languages treat functions as first-class values
- Function can be passed as a parameter and returned as a result
- Function type :
type A => B is the type of a function that takes an argument of type
A and returns a result of type B (i.e. lambda/closure)
-

Lazy evaluation
- Scala uses strict evaluation by default, but allows lazy evaluation
- Some languages use lazy evaluation as default - Haskell
- Lazy == “non strict”, “deferred execution”
Definition of lazy value:
lazy val x = 2 + 2

Lazy evaluation
1 less than 30?
1 more than 20?
25 less than 30?
25 more than 20?
25
40 less than 30?
5 less than 30?
5 more than 20?
23 less than 30?
23 more than 20?
23
// (20, 30)
def lessThan30(i: Int): Boolean = {
println(s"n$i less than 30?" )
i < 30
}
def moreThan20(i: Int): Boolean = {
println(s"$i more than 20?" )
i > 20
}
val a = List(1, 25, 40, 5, 23)
val q0 = a.withFilter(lessThan30)
val q1 = q0.withFilter(moreThan20)
for (r <- q1) println(s"$r")
withFilter() - non strict

Lazy evaluation
1 less than 30?
25 less than 30?
40 less than 30?
5 less than 30?
23 less than 30?
1 more than 20?
25 more than 20?
5 more than 20?
23 more than 20?
25
23
// (20, 30)
def lessThan30(i: Int): Boolean = {
println(s"n$i less than 30?" )
i < 30
}
def moreThan20(i: Int): Boolean = {
println(s"$i more than 20?" )
i > 20
}
val a = List(1, 25, 40, 5, 23)
val q0 = a.filter(lessThan30)
val q1 = q0.filter(moreThan20)
for (r <- q1) println(s"$r")
filter() - strict eval

Cache using lazy evaluation
- If you don’t use cache - the cost is 0 - value will never get evalueted
- If you use cache one or multiple times, the cost is always 1
- You can make a function lazy by assigning it to a lazy val !
- You can use lazy for network calls etc.
def foo(x: Int => Expensive) = {
lazy val cache = x
/* do lots of stuff with cache */
}

Unified type system
- Java makes a sharp distinction between primitive types (e.g. int
and boolean) and reference types (any class).
- In Scala, all types inherit from a top-level class Any, whose
immediate children are AnyVal (value types, such as Int and
Boolean) and AnyRef (reference types, as in Java)
- distinction between primitive types and boxed types (e.g. int vs.
Integer) is not present in Scala
- Scala 2.10 allows for new value types to be defined by the user

Value classes
class Foo(val name: String) extends AnyVal {
def print = println(name)
}
Value class
- Scala allows user-defined value classes that extend AnyVal
- Value classes in Scala do not allocate runtime objects
- Performance optimization
- Single, public val parameter that is the underlying runtime
representation
- A value class can define defs, but no vals, vars, or nested traits
classes or objects.

Value classes
val foo = new Foo("sample value" )
foo.print
- Now one can use newly defined methods

Nullability
- SCALA has no built-in support for null-safe types (Int?, Double? etc.)
- Option[T]
val numberOption = List(1,2,3,4).headOption
if (numberOption.isDefined) {
println(numberOption.get)
}
val number = numberOption.getOrElse(-1)

Nullability
- NOT SUPPORTED
val connSocketOption = List(connSocket).headOption
connSocketOption?.removeDevice() // NOT SUPPORTED :(

Dependencies definition
libraryDependencies ++=
{
val slickVersion = "3.2.1"
val postgresVersion = "42.2.1"
Seq(
"javax.inject" % "javax.inject" % "1",
"com.typesafe" % "config" % "1.3.1",
"org.postgresql" % "postgresql" % postgresVersion,
"com.typesafe.slick" %% "slick" % slickVersion,
//--- Testing
"org.springframework.boot" % "spring-boot-starter-test" % springBootVersion % Test,
"org.scalatest" %% "scalatest" % "3.0.1" % Test
)
}

Dependencies definition
- + usual maven/gradle syntax
"com.typesafe" % "config" % "1.3.1"
compile “com.typesafe:config:1.3.1”
- ++ adds scala version to the dependency
"com.typesafe.slick" %% "slick" % “3.2.1”

Companion objects
- Accompany classes
- Store constant values
- can access methods and fields that are private in the class/trait
-
class Foo() {
def getVersion = "1.2.1"
object c {
val TAG = "[PROCESSING]"
}
}
class ExtString(var str: String) {
var extraData: String = ""
override def toString: String = str + extraData
}
object ExtString {
def apply(base:String) : ExtString = new ExtString(base)
def apply(base:String, extras: String) : ExtString = {
new ExtString(base)
}
}

Infinite data structures
- lazy by default, like Haskell, laziness makes it easy to support
infinite data structures
- Scala is not lazy by default. If it was, we could define Fibonacci as:
fibonacci_sequence = for (i <- 0 to infinity) yield fib(i)
fibonacci_sequence.take(10)

Infinite data structures
- odd numbers:
def from(n: Int): Stream[Int] = Stream.cons(n, from(n+1))
lazy val ints = from(0)
lazy val odds = ints.filter(_ % 2 == 1)
odds.take(10).print

Type classes
- a type system construct that supports ad hoc polymorphism
object Math {
trait NumberLike[T] {
def plus(x: T, y: T): T
def divide(x: T, y: Int): T
def minus(x: T, y: T): T
}
object NumberLike {
implicit object NumberLikeDouble extends NumberLike[Double] {
def plus(x: Double, y: Double): Double = x + y
def divide(x: Double, y: Int): Double = x / y
def minus(x: Double, y: Double): Double = x - y
}
implicit object NumberLikeInt extends NumberLike[Int] {
def plus(x: Int, y: Int): Int = x + y
def divide(x: Int, y: Int): Int = x / y
def minus(x: Int, y: Int): Int = x - y
}
}
}
More info

Futures & Promises
- Define execution context
import ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.concurrent.blocking
Future {
blocking {
myLock.lock()
// so sth
}
}

SCALAZ
Scalaz is a Scala library for functional programming.
It provides purely functional data structures to complement those from
the Scala standard library. It defines a set of foundational type classes
(e.g. Functor, Monad) and corresponding instances for a large number of
data structures.

Spark
- Source
- open-source cluster-computing framework. Originally developed at
the University of California
- mainframe computing
- written in SCALA

SCALA - AKKA agents
- Implement the REACTIVE MANIFESTO
- Binary/fast communication as default
- Easy to implement

SCALA - AKKA agents
val helloGreeter: ActorRef =
system.actorOf(Greeter.props( "Hello", printer), "helloGreeter" )
printerActor ! Greeting(greeting) //send a message

Twitter & SCALA
- Scala twitter util
- bunch of idiomatic, small, general purpose tools.
- Time, collections,
- source

Links / References
- Scala & Scala JS;
- Oracle developers - Scala course - link
- Twitter Scala School - link
- Scala lang overview - link, Scala cheatsheet - link
- Why SCALA - link - interview with Odersky
- Steps in Scala - link (Loverdo, Christos 2010)
- Lightbend - introduction to Scala course - link
- Beyond Java - link
- Kotlin vs Scala - link, link, link
- Java criticism - link
- Can Java be used for functional programming? - link
- Europython - Lambda functions - link
- Functional programming - link
- Functional programming in JavaScript - link
- Mostly Adequate Guide to functional programming - link
- Programming and Problem Solving Using Scala - link
- Tail recursion in scala - link

Links / References
- Alexander Alvina,Funtions are variables too, link
- Kotlin & Funtional programming - link
- Scala basics video - link
- Functional programming principles in Scala - link, link, link, link
- Understanding tail recursion - link, link
- Composing traits LEGO style - link
- List creation in SCALA - link
- SCALA collections overview - link
- apply/unapply function - link
- Scala exercises - link
- Differences between lazy and strict evaluation: link
- Guide to Type classes - link
- Scala from a functional perspective - link
- Scala tour - value classes - link, link
- Scala method scope visibility - link
- Functors in SCALA - link
- Functor & Monad - link
- Functor, applicative, monads - link

Additional
- Why SCALA & Kotlin? Is Java 8 a truly functional language?
READ
- Learning SCALAZ - READ

SCALA - Functional domain

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a SCALA - Functional domain

Similar a SCALA - Functional domain (20)

Más de Bartosz Kosarzycki

Más de Bartosz Kosarzycki (17)

Último

Último (20)

SCALA - Functional domain