Practically Functional

Practically Functional
Daniel Spiewak

whoami
 Author of Scala for Java Refugees
and other articles on Scala and FP
 Former editor Javalobby / EclipseZone
 Engaged in academic research
involving Scala DSLs and text parsing
(ScalaBison, GLL
Combinators, ScalaQL)

Agenda
 Define “functional programming” (sort
of)
 See some common elements of FP
 Motivate why this stuff is useful in the
real world (hopefully)
 Show practical functional techniques
and design patterns
 Explain monads!
 Hopefully pique your interest in
learning and applying more of this

Definitions
 Q: What is “functional programming”?

Definitions
 Q: What is “functional programming”?
◦ A: Nobody knows!

Definitions
 Q: What is “purely-functional”?

Definitions
◦ Everything is immutable (no variables)

Definitions
◦ Absolutely no side-effects

println(quot;Hello, World!quot;)

Definitions
◦ Referential transparency

Definitions
◦ Referential transparency
◦ Bondage discipline?

Definitions
 Scala is not purely-functional
◦ vars
◦ Mutable collections
◦ Uncontrolled side-effects (println)

Definitions
 Scala is not purely-functional
◦ vars
◦ Mutable collections
◦ Uncontrolled side-effects (println)
 Is Scala a “functional language”?

Functional Trademarks
 Higher-order functions

def foreach(f: String=>Unit) {
f(quot;Whatquot;)
f(quot;isquot;)
f(quot;goingquot;)
f(quot;on?quot;)
}


foreach { s => println(s) }

 Closures are anonymous functions
◦ Ruby, Groovy, Python; none of these
count!

foreach(println)

count!
 Singly-linked immutable lists (cons
cells)

val names = quot;Chrisquot; :: quot;Joequot; :: Nil
val names2 = quot;Danielquot; :: names

count!
cells)
 Usually some form of type-inference

val me = quot;Danielquot;
// equivalent to...
val me: String = quot;Danielquot;

count!
cells)

foreach { s => println(s) }

count!
cells)
 Immutable by default (or encouraged)

val me = quot;Danielquot;
var me = quot;Danielquot;

What does this buy you?
 Modularity (separation of concerns)
 Understandability
 No more “spooky action at a distance”
…

public class Company {
private List<Person> employees;

public List<Person> getEmployees() {
return employees;
}

public void addEmployee(Person p) {
if (p.isAlive()) {
employees.add(p);
}
}
}

 Modularity (separation of concerns)
 Understandability
 No more “spooky action at a distance”
 Flexible libraries (more on this later)
 Syntactic power (internal DSLs)

quot;vectorquot; should {
quot;store a single elementquot; in {
val prop = forAll { (i: Int, e: Int) =>
i >= 0 ==> { (vector(0) = e)(0) mustEqual e }
}

prop must pass
}

quot;implement lengthquot; in {
val prop = forAll { list: List[Int] =>
val vec = Vector(list:_*)
vec.length mustEqual list.length
}

prop must pass
}
}

Functional Idioms
 Recursion instead of loops
◦ Scala helps with this by allowing methods
within methods

Functional Idioms
within methods
def factorial(n: Int) = {
var back = 1
for (i <- 1 to n) {
back *= i
}
back
}

Functional Idioms
within methods
def factorial(n: Int): Int = {
if (n == 1)
1
else
n * factorial(n - 1)
}

Functional Idioms
within methods
def factorial(n: Int) = {
def loop(n: Int, acc: Int): Int = {
if (n == 1)
acc
else
loop(n - 1, acc * n)
}

loop(n, 1)
}

Functional Idioms
within methods
 Higher-order functions instead of
recursion

Functional Idioms
within methods
recursion
 Combinators instead of higher-order
functions

Functional Idioms
within methods
recursion
 Combinators instead of higher-order
functions
 Monads!

Example #1
Retrieve structured, formatted data from
across multiple .properties files
and multiple keys within those files.

# daniel.properties # tim.properties

name.first = Daniel name.first = Timothy
name.last = Spiewak name.last = Olmsted
age = 21 age = 22

def toInt(s: String) = try {
s.toInt
} catch {
case _ => null
}

// uninteresting and ugly
def readFile(file: String): Map[String, String] = {
import collection.jcl.Hashtable

try {
val is = new BufferedInputStream(new FileInputStream(file))

val p = new Properties
p.load(is)

is.close()

new Hashtable(p).asInstanceOf[Hashtable[String, String]]
} catch {
case _ => null
}
}

import collection.mutable.ListBuffer

def readPeople(files: List[String]): List[Person] = {
val back = new ListBuffer[Person]

for (file <- files) {
val props = readFile(file)

if (props != null) {
if (props.contains(quot;name.firstquot;) &&
props.contains(quot;name.lastquot;) &&
props.contains(quot;agequot;)) {
val age = toInt(props(quot;agequot;))

if (age != null)
back += new Person(props(quot;name.firstquot;),
props(quot;name.lastquot;), age)
}
}
}

back.toList
}

Example #1
 Using loops
 Recursive

def readPeople(files: List[String]): List[Person] = files match {
case file :: tail => {

val back = if (props != null) {

if (age != null)
new Person(props(quot;name.firstquot;), props(quot;name.lastquot;), age)
else
null
} else null
} else null

if (back != null)
back :: readPeople(tail)
else
readPeople(tail)
}

case Nil => Nil
}

Example #1
 Loops
 Recursion

files.foldRight(List[String]()) { (file, people) =>

val back = if (props != null) {

if (age != null)
new Person(props(quot;name.firstquot;), props(quot;name.lastquot;), age)
else
null
} else null
} else null

if (back != null)
back :: people
else
people
}
}

Example #1
 Loops
 Recursion
…
 Monads!

def toInt(s: String) = try {
Some(s.toInt)
} catch {
case _ => None
}

// uninteresting and ugly
def readFile(file: String): Option[Map[String, String]] = {
import collection.jcl.Hashtable

try {
val is = new BufferedInputStream(new FileInputStream(file))

val p = new Properties
p.load(is)

is.close()

Some(new Hashtable(p).asInstanceOf[Hashtable[String, String]])
} catch {
case _ => None
}
}

for {
file <- files
props <- readFile(file)

firstName <- props get quot;name.firstquot;
lastName <- props get quot;name.lastquot;

ageString <- props get quot;agequot;
age <- toInt(ageString)
} yield new Person(firstName, lastName, age)
}

Example #1
 Loops
 Recursion
 Combinators
 Monads!

def readPeople(files: List[String]) = {
import Function._

files flatMap readFile flatMap { props =>
val fNames = props get quot;name.firstquot;
val names = fNames flatMap {
(_, props get quot;name.lastquot;)
}

val data = names flatMap {
case (fn, ln) =>
(fn, ln, props get quot;agequot; map toInt)
}

data map tupled(new Person _)
}
}

What did we just see?
 foldLeft / foldRight
◦ Catamorphisms
◦ Use when you want to reduce all of the
elements of a collection into a single
result
◦ Capable of almost anything!


def sum(nums: List[Int]) = {
nums.foldLeft(0) { (x, y) =>
x + y
}
}


nums.foldLeft(0) { _ + _ }
}


(0 /: nums) { _ + _ }
}

 map
◦ Use when you want to transform every
element of a collection, leaving the results
in the corresponding location within a new
collection

 map

val nums = List(quot;1quot;, quot;2quot;, quot;3quot;, quot;4quot;, quot;5quot;)
nums map { str => str.toInt }

 map

val nums = List(quot;1quot;, quot;2quot;, quot;3quot;, quot;4quot;, quot;5quot;)
nums map { _.toInt }

 map
 flatMap (has two meanings)
◦ Collections: Use when you want to
transform every element optionally
◦ Monads: Should have really been called
“bind” (or >>=). More later…

 map
 flatMap (has two meanings)

def toCharArray(arr: Array[String]) = {
arr flatMap { _.toCharArray }
}

toCharArray(Array(quot;Danielquot;, quot;Spiewakquot;))
// =>
Array('D', 'a', 'n', 'i', 'e', 'l',
'S', 'p', 'i', 'e', 'w', 'a', 'k')

Other Common Util Methods
 filter (used in for-comprehensions)

val nums = List(1, 2, 3, 4, 5)
nums filter { _ % 2 == 0 }


val nums = List(1, 2, 3, 4, 5)
nums filter (0 == 2 %)

 zip / zipWithIndex
◦ zipWith (not available pre-2.8.0)

val evens = List(2, 4, 6)
val odds = List(1, 3, 5)

evens zip odds
// =>
List((1, 2), (3, 4), (5, 6))

 forall and exists

val nums = List(1, 2, 3, 4, 5)
nums forall { _ % 2 == 0 } // => false


val nums = List(1, 2, 3, 4, 5)
nums exists { _ % 2 == 0 } // => true

 take and drop

val nums = List(5, 4, 3, 2, 1)
nums take 2
// =>
List(5, 4)

 take and drop

val nums = List(5, 4, 3, 2, 1)
nums drop 2
// =>
List(3, 2, 1)

 take and drop
 foreach

val names = List(quot;Danielquot;, quot;Chrisquot;)
names foreach println

Example #2
Comparing the prefix of a List[Char]
to a given string.

List[Char] String Result
List('d', 'a', 'n', 'i', 'e', 'l') quot;danquot; true
List('d', 'a', 'n', 'i', 'e', 'l') quot;ielquot; false
List('t', 'e', 's', 't') quot;testingquot; false
List('t', 'e', 's', 't') quot;testquot; true

def isPrefix(chars: List[Char], str: String) = {
if (chars.lengthCompare(str.length) < 0) {
false
} else {
val trunc = chars take str.length

trunc.zipWithIndex forall {
case (c, i) => c == str(i)
}
}
}

More About Combinators
 The “Essence of Functional
Programming”
 Combine simple things to solve
complex problems
 Very high level
 Think about Lego™ bricks

 The best example: Parser
Combinators
def expr: Parser[Int] = (
num ~ quot;+quot; ~ expr ^^ { case (x, _, y) => x + y }
| num ~ quot;-quot; ~ expr ^^ { case (x, _, y) => x - y }
| num
)

def num = quot;quot;quot;d+quot;quot;quot;.r ^^ { _.toInt }

 The best example: Parser
Combinators
def expr: Parser[Int] = (
num ~ quot;+quot; ~ expr ^^ { case (x, _, y) => x + y }
| num ~ quot;-quot; ~ expr ^^ { case (x, _, y) => x - y }
| num
)

def num = quot;quot;quot;d+quot;quot;quot;.r ^^ { _.toInt }

expr(quot;12 + 7 - 4quot;) // => Success(15)
expr(quot;42quot;) // => Success(42)

 Three Types of Combinators
◦ Sequential (first a, then b)

a ~ b

◦ Disjunctive (either a, or b)

a | b

◦ Literal (exactly foo)

quot;fooquot;

◦ Literal (exactly foo)
 Note: Our example uses a regular
expression parser, but that is only a
generalization of the literal parser

 Seldom created, often used
 Good for problems which split into
smaller sub-problems

March of the Monads
 Monads are not scary

March of the Monads
 Monads are not scary
 Monad explanations are scary

March of the Monads
 Monads are little containers for
encapsulating something
◦ What the “something” is depends on the
monad
 An instance of a monad can be
“bound” together with another instance
of that monad
 Most combinators are monads

March of the Monads
 All monads have
◦ A type constructor
class Option[A] { … }

◦ A single-argument constructor
new Some(quot;one to watch over mequot;)

◦ A flatMap method which behaves
properly
a flatMap { v => v.next }

March of the Monads
 Option
◦ This is what the Groovy folks really wanted
when they designed the “Elvis Operator”
 Parser
◦ Sequential parser is really two bound
parsers
◦ Disjunctive parser uses an optional
monadic function: orElse
◦ Literal parser is the one-argument
constructor
 Function1 (sort of)
◦ We could say that function composition is

Learn More
 Read my blog! :-)
◦ http://www.codecommit.com/blog
 Some better sources…
◦ http://apocalisp.wordpress.com/
◦ http://michid.wordpress.com/
◦ http://joelneely.wordpress.com/
◦ http://scala-blogs.org
 A really good paper…
◦ Monadic Parser Combinators
(1996; Hutton, Meijer)

Practically Functional

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Practically Functional

Similar to Practically Functional (20)

Recently uploaded

Recently uploaded (20)

Practically Functional