Scala or functional programming from a python developer's perspective

Scala
or: functional programming
from a python developer’s perspective
Gabriele Alese
http://gabale.se

Hello.
object HelloWorld extends App {
println("Hello World!")
}

apropos Scala
• «Scala is a pure-bred object-oriented language. Conceptually,
every value is an object and every operation is a method-call. The
language supports advanced component architectures through
classes and traits.»
• «Scala is also a full-blown functional language. It has everything
you would expect, including ﬁrst-class functions, a library with
efﬁcient immutable data structures, and a general preference of
immutability over mutation.»

• A sane approach to the JVM
• Flexibility
• Interoperability
• Excellent community
• Better documentation (mostly)
Why Scala?

• Static types
• Rich type system
• Functions are ﬁrst-class citizens
• Stress on immutability
• Case classes (traits, objects, …)
• Pattern matching
• Rich collections (List, HashMap, Seq, Vector)
• Operator overloading
• Interoperability with Java libraries
• REPL and worksheets (Eclipse, IntelliJ)
Why I like Scala so much?

Static types
class Phrase(value: String) {
def wordCount: Map[String, Int] = {
val wordsMap = words map (_ -> 1)
wordsMap.foldLeft(Map.empty[String, Int]) {
case (acc, (key, _)) => acc + (key -> (acc.getOrElse(key, 0) + 1))
}
}
def words: Seq[String] = {
value.toLowerCase.split("[^a-zA-Z0-9']+")
}
}

Static types
• Compile time checking
• Your IDE will be much more helpful
• Encourages encapsulation
• Limits your ‘ability’ to write code before thinking
• Inferred types greatly reduce boilerplate
• … no more “‘NoneType’ object has no attribute…”

Rich type system
• Monads [Option, Try, Either, …] 
«A monad is a container type together with map and flatMap methods deﬁned on it.»
• Functions [Function1, Function2, …]
• Generic types [+T, -T]
• Higher kinded types 
trait Functor[F[_]] {
def map[A, B](fa: F[A])(f: A => B): F[B]
}
• Structural types 
def setElementText(element : {def setText(text : String)}, text : String)

Functions as ﬁrst-class citizens
sealed trait List[A] {
def map[A](f: A => A): List[A]

Functions as ﬁrst-class citizens
• Higher-order functions (i.e. sum in terms of fold)
• Anonymous functions 
(x: Int, y: Int) => x + y
• Easily transform collections with map

Stress on immutability
«[…] there can never be surprises in logic.»
– L. Wittgenstein
Hopefully, there should never be surprises in code.

Stress on immutability
object LongestIncreasingSubsequence {
def apply(sequence: Seq[Int]): Seq[Int] = {
val validSubsequences = iterateAndDropHead(Seq(sequence), sequence)
validSubsequences
.map(findIncreasingSubsequence)
.sortBy(_.length)(Ordering[Int].reverse)
.head
}
@tailrec
def iterateAndDropHead(folded: Seq[Seq[Int]], remaining: Seq[Int]): Seq[Seq[Int]] = {
remaining match {
case head :: Nil => folded
case head :: tail => iterateAndDropHead(folded :+ tail, tail)
}
}
def findIncreasingSubsequence(sequence: Seq[Int]): Seq[Int] = {
sequence.foldLeft(Seq(sequence.head)) {
(acc, el) => if(acc.last < el) acc :+ el else acc
}
}
}

Case classes
case class Person(firstName: String, lastName: String)
val randomGuy = Person("Gabriele", "Alese")
randomGuy match {
case Person("Gabriele", _) => println("Hello Gabriele!")
case Person("Vincent", _) => println("Hello, Vincent!")
case _ => println("I've never seen you before")
}

Case classes
• Free accessors (and mutators, if you must)
• Free equals() and hashCode()
• Free toString()
• Free copy()
• No need to use new
• Free apply and unapply methods  
on the companion object (see pattern matching)

Pattern matching
sealed abstract class Expression
case class X() extends Expression
case class Const(value : Int) extends Expression
case class Add(left : Expression, right : Expression) extends Expression
case class Mult(left : Expression, right : Expression) extends Expression
case class Neg(expr : Expression) extends Expression
def eval(expression : Expression, xValue : Int) : Int = expression match {
case X() => xValue
case Const(cst) => cst
case Add(left, right) => eval(left, xValue) + eval(right, xValue)
case Mult(left, right) => eval(left, xValue) * eval(right, xValue)
case Neg(expr) => - eval(expr, xValue)
}

Rich collections
def sort(xs: Array[Int]): Array[Int] = {
if (xs.length <= 1) xs
else {
val pivot = xs(xs.length / 2)
Array.concat(
sort(xs filter (pivot >)),
xs filter (pivot ==),
sort(xs filter (pivot <))
)
}
}

Rich collections
• map
• foreach
• filter (and filterNot)
• zip
• find
• drop (and dropWhile)
• foldLeft (and foldRight)

Rich collections
def dropWhile[A](l: List[A])(f: A => Boolean): List[A] =
l match {
case Cons(head, tail) if f(head) => dropWhile(tail)(f)
case _ => l
}
def foldRight[A, B](list: List[A], initial: B)(f: (A, B) => B): B = {
list match {
case Nil => initial
case Cons(head, tail) => f(head, foldRight(tail, initial)(f))
}
}
def foldLeft[A, B](as: List[A], initial: B)(f: (B, A) => B): B = {
as match {
case Nil => initial
case Cons(head, tail) => foldLeft(tail, f(initial, head))(f)
}
}
def map[A, B](list: List[A])(f: A => B): List[B] = {
foldRight(list, Nil: List[B])((a, b) => Cons(f(a), b))
}
def filter[A](list: List[A])(f: A => Boolean): List[A] = {
foldRight(list, Nil: List[A])((a, b) => if (f(a)) Cons(a, b) else b)
}
def flatMap[A, B](list: List[A])(f: A => List[B]): List[B] = {
concat(map(list)(f))
}
}

Operator overloading
package it.alese.scacchirossi.scacchirossi
import it.alese.scacchirossi.scacchirossi.board.{Column, Row}
case class Position(column: Column, row: Row) {
val x: Int = column.toInt
val y: Int = row.toInt
def to(toPosition: Position): List[Position] = {
Move(this, toPosition).intermediatePositions
}
def +(x: Int, y: Int) = {
val col = if (this.x + x != 0) Column(this.x + x) else this.column
val row = if (this.y + y != 0) Row(this.y + y) else this.row
new Position(col, row)
}
…
}
object Position {
def apply(position: String): Position = {
require(position.length == 2, "Illegal coordinate string")
new Position(Column(position(0)), Row(position(1).asDigit))
}
…
}
package it.alese.scacchirossi.scacchirossi
class PositionTest extends WordSpec with Matchers {
"A position" should {
…
"return a new position if summed to an offset" in {
Position("A1") + (1,1) shouldEqual Position("B2")
Position("A1") + (0,1) shouldEqual Position("A2")
}
"return a range of contiguous vertical positions" in {
Position("A1") to Position("A4")
shouldEqual
List(Position("A1"), Position("A2"), Position("A3"), Position("A4"))
}
}

Operator overloading
• Expressivity  
(especially combined with inﬁx notation)
• Deﬁne intuitive operations between types
• Pretty powerful DSLs 
(Like ScalaTest)

Interoperability with Java libraries
package it.alese.emailchecker
import java.io.{InputStreamReader, BufferedReader, PrintWriter}
import java.net.Socket
case class TelnetSession(socket: Socket, input: PrintWriter, output: BufferedReader) {
def allowsConnections: Boolean = {
Reply(output.readLine).code match {
case "220" => true
case _ => false
}
}
def send(command: String): String = {
input.println(command)
output.readLine
}
def close(): Unit = {
send("quit")
socket.close()
}
}
object TelnetSession {
def apply(host: String): TelnetSession = {
val socket = new Socket(host, 25)
new TelnetSession(
socket,
new PrintWriter(socket.getOutputStream, true),
new BufferedReader(
new InputStreamReader(socket.getInputStream)
)
)
}
}

Interoperability with Java libraries
• If you can’t ﬁnd a Scala library for that, chances are
that you’ll ﬁnd a Java equivalent 
(Good luck with the documentation!)
• Appealing for Java programmers 
(or young professionals fresh out of “university Java”)
• Stronger community 
(IMHO: many Scala enthusiasts are Java seniors)

Thank you.
Gabriele Alese
http://gabale.se

Scala or functional programming from a python developer's perspective

Recommended

More Related Content

What's hot (19)

Similar to Scala or functional programming from a python developer's perspective (20)

Recently uploaded (20)

Scala or functional programming from a python developer's perspective