Learning FunctionalProgramming without Growing a Neckbeard

by Kelsey Gilmore-Innis / @kelseyinnis

Hi!

I'm Kelsey.

I work at Reverb writing code that something something. I use Scala to do that.

Why are you here?

To learn to write code with drive that don't take no jive.

The Pam Grier Criteria for Code Badassery

Powerful

• Do big things
• Do them easily
• Do them quickly

Tough to mess with

• Secure from outside manipulation
• Hard to unintentionally make mistakes
• Easy to maintain

Beautiful

• Elegant, concise, and--yes--readable
• Able to be easily reused
• Fun to write

Scala!

• don't need parentheses for method calls
• semicolons are optional
• return value is the last line of the method
• static typing with type inference
  • some things you'll notice technically, you can use return, but it's a code smell--with functional code, it's hard to know where you're returning to static typing: variables have types. if a variable is of type string, the value assigned to it needs to be a string, and this is checked at compile time type inference: when it's reasonable, the computer figures out what type you mean it compiles down to java so you can write really javalike code, and many of us do to start

But what does it look like?

val x: String = "a"
val y = 2
val z = 15.3
val myThing = new Thing
val theList = List("this", "is", "a", "list")
val whatIsIt = theList(4)

But what does it look like?

def haggle(price: Int, offer: Int): String = {
  val theResponse: String =
    if (price <= offer + 5) {
      "You've got a deal!"
    } else {
      "I definitely wouldn't pay more than " +
      (offer + (price - offer)/2) + 
      " for it."
    }
  theResponse
} 

Functional Programming

What is functional programming?

Well, what is a program?

Ask A Kid

(or Simple English Wikipedia)

a sequence of commands that the computer carries out in sequence

these instructions, and the data they manipulate, are organized into objects

What things are

val theQueen = "Elizabeth II"
					

def theGovernor(state: State) = {
	val candidates = state.getCandidates
	candidates(getTopVoteGetter)
}
					

What is a function?

Some Functions

• Math.sqrt(x)
• Collections.max(list)
• Arrays.copyOf(original, newLength)
• String.valueOf(anInt)

A function is pure if the impact of a function on the rest of the program [can] be described only in terms of its return type, and...the impact of the rest of the program on the function be described only in terms of its arguments. (Victor Nicollet)

This is our building block.

Functions are deterministic.

You will always get the same result if you run them with the same data.

• correctness is more clear
• unit tests are a breeze
• debugging is more directed

Functions are encapsulated.

• readability
• reuse
• maintainability

Functions are commutative.

val firstThing = doOneThing()
val secondThing = doAnotherThing()

val thirdThing = doTheLastThing(firstThing, secondThing)
						

• parallelization
• concurrency
• lazy evaluation

...how?

functions as first class citizens

First class citizens

val longSkinnyThing: String = "this is a string"
val listOfThem: List[String] = List("yarn","twine","thread")
val freshNewLongSkinnyThing: String = spinFromFiber("wool")
tieInAKnot(longSkinnyThing)

 class Rope(type:String) {
    override def toString(): String = "You've put me on a diet!";
}

val longSkinnyThing: Rope = new Rope("nautical")
val listOfThem: List[String] = 
    List(longSkinnyThing, new Rope("climbing"), 
    new Rope("clothesline"), new Rope("jump")) 
val freshNewLongSkinnyThing: Rope = spinFromFiber("hemp")
tieInAKnot(longSkinnyThing)

val addSpam: (String) => String =
	{ (x:String) => x + " and Spam" }
addSpam("Egg and Bacon") 
	//result: "Egg and Bacon and Spam"
val menuOptions = List(addSpam, withoutSpam)
menuOptions(1)("Egg and Bacon and Spam") 
	//result: "You can't have that"

addSpam's type is (String) => String

(list of parameters' types) => return type

returning functions from functions

def tagText(tag: String, text: String) = "<" + tag +">" + text + "" 
val noReally = tagText("em", "pay attention!!!!")
	//result: <em>pay attention!!!!</em>

def tagText2(tag: String) = { (text:String) =>"<" + tag +">" + text + "" }
val tagWithAndSpam = tagText2("andSpam")
val breakfast = tagWithAndSpam("Spam Bacon and Sausage")
	//result: <andSpam>Spam Bacon and Sausage</andSpam> 

Currying

Higher-order functions

For Loop

public void talkAboutFruit {
	Fruit[] fruits = {
		new Fruit("apple"),
		new Fruit("cherry"),
		new Fruit("strawberry")
	};
	for (int i = 0; i < fruits.length; i++) {
		System.out.println("Hey the other day I ate a " + fruits[i];
	}
}

 def talkAboutFruit = {
	val fruits = List(new Fruit("apple"),
			  new Fruit("cherry"), 
		   	  new Fruit("strawberry"))
	for (i <- 0 until fruits.length) {
		System.out.println("Hey the other day I ate a " + fruits(i);
	}
}

let's get abstract

a function that takes a list and a function

 def foreach(fruitList:List(fruits), theFunction: (Fruit) => Unit) = {
	for (i <- 0 until fruitList.length) {
		theFunction(fruits(i))
	}			
}

 def talkAboutFruit = {
	val fruits = List(new Fruit("apple"),
			  new Fruit("cherry"), 
		   	  new Fruit("strawberry"))
	val tellEm = 
		{ (f:Fruit) => System.out.println(
			"Hey the other day I ate a " + f) }
	foreach(fruits, tellEm)
	}
}

More abstracterer!

abstract class Collection[A] {
	...
	def foreach(theFunction: (A) => Unit): Unit
	...
}

 def talkAboutFruit = {
	val fruits = List(new Fruit("apple"),
			  new Fruit("cherry"), 
		   	  new Fruit("strawberry"))
	val tellEm = 
		{ (f:Fruit) => System.out.println(
			"Hey the other day I ate a " + f) }
	fruits.foreach(tellEm)
	}
}

This:

abstract class Collection[A] {
	...
	def foreach(theFunction: (A) => Unit): Unit = {
	 	for (i <- 0 until this.length) {
			theFunction(this(i))
		}	
	}
	...
}

is NOT how Scala implemented foreach

Something a little juicier

def makePies: List[Pie] = {
	val fruits = List(new Fruit("apple"),
			  new Fruit("cherry"), 
		   	  new Fruit("strawberry"))
	var pies = List()
	for (i <- 0 until fruits.length) {
		new Pie(fruits(i)) :: pies
	}
	pies
}

def makePies: List[Pie] = {
	val fruits = List(new Fruit("apple"),
			  new Fruit("cherry"), 
		   	  new Fruit("strawberry"))
	val makePie = { (f: Fruit) => new Pie(f) }
	fruits.map(makePie)
}

Anonymous Functions

val kindOfFruit: String = "blueberry"
val blueberryFruit = new Fruit(kindOfFruit)
val alsoBlueberry = new Fruit("blueberry")

val makePie = { (f: Fruit) => new Pie(f) }
fruits.map(makePie) 
//equivalent to 
fruits.map( { (f: Fruit) => new Pie(f) } )

def makePies: List[Pie] = {
	val fruits = List(new Fruit("apple"),
			  new Fruit("cherry"), 
		   	  new Fruit("strawberry"))
	fruits.map( { (f: Fruit) => new Pie(f) } )
}

def makePies(fruits: List[Fruit]) : List[Pie]
	 = fruits.map( { (f: Fruit) => new Pie(f) } )

Collection handling

val theList = List(new Fruit("apple"), new Fruit("pear"), new Fruit("cherry"), new Fruit("strawberry"), new Fruit("honeydew"))
					
scala> theList.filter( { (f: Fruit) => f.isDelicious } )
res0: List[Fruit] = List(apple, cherry, strawberry)

scala> theList.fold("The fruits on this list are: ")( { (stringSoFar: String, f: Fruit) => stringSoFar + " " + f.name } )
res1: String = "The fruits on this list are: apple pear cherry strawberry honeydew"

scala> theList.fold(0)( { (count: Int, f: Fruit) => count + " " + f.totalPieces } )
res2: Int = 42300

theList.reduce( { (f: Fruit) => f.totalPieces } )
res3: Int = 42300

Nested For-Loops

 def tryAllPairings(pies: List[Pie], iceCreams: List[IceCream]): List(Serving[Pie, IceCream]) {
	val servings = List[Serving[Pie,IceCream]]()
	for (p <- 0 until pies.length) {
		for (i <- 0 until iceCreams.length) {
			val serving = new Serving(p, i)
			serving :: servings
		}
	}
	servings
}

 def tryAllPairings(pies: List[Pie], iceCreams: List[IceCream]): List(Serving[Pie, IceCream]) {
	pies.map( { (p: Pie) =>
		iceCreams.map( { (i: IceCream) =>
			new Serving(p, i)
		} )
	} )	
}

Is This an Improvement?

def tryAllPairings(pies: List[Pie], iceCreams: List[IceCream]): List(Serving[Pie, IceCream]) {
	val servingsLists = 
		pies.map( { (p: Pie) =>
			iceCreams.map( { (i: IceCream) =>
				new Serving(p, i)
			} )
		} )
	servingsLists.flatten
}

function composition

def bakeAPie(f: Fruit, c: Crust): Pie
def eatAPie(p: Pie): HappyKelsey

def bakeAndEatAPie(f: Fruit, c: Crust): HappyKelsey = eatAPie compose bakeAPie
	//could also be written bakeAPie andThen eatAPie

For-Yield

 def tryAllPairings(pies: List[Pie], iceCreams: List[IceCream]): List(Serving[Pie, IceCream]) {
	for {
		p <- pies
		i <- iceCreams
	} yield {
		new Serving(p,i)
	}
}

Fun With For-Yield

 def goodPairings(pies: List[Pie], iceCreams: List[IceCream]): List(Serving[Pie, IceCream]) {
	for {
		p <- pies
		i <- iceCreams
		val serving = new Serving(p,i)
		if (serving.isGood)
	} yield {
		serving
	}
}

 def pleaseEverybody(audience: List[Person], pies: List[Pie], iceCreams: List[IceCream]): List(ThankYou) {
	for {
		person <- audience
		p <- pies
		i <- iceCreams
		val serving = new Serving(p,i)
		if (serving.isGood)
	} yield {
		person.feed(serving)
	}
}

• partial application
• higher order functions
• function composition
• for-yield

• partial application--andSpam, html tag
• higher order functions--fruit, and eventually pie
• function composition--added ice cream
• for-yield--served it to you

and now for something (not really) completely different

null.

yuck

public Serving<Pie, IceCream> serveBestALaMode(Pie key, Map<Pie, IceCream> pairings) {
    if(pairings != null) {
        IceCream iceCream = pairings.get(key);
        if(iceCream != null) {
            return new Serving(key, iceCream)
        } else {
        	return null;
        }
    }
}

Scala programming doesn't use null. Yippee!

Option

Option[T] is either a Some with a value of type T inside, or None representing nothing.

val someOption: Option[String] = Some("this is a value")
val noneOption: Option[String] = None

val theSomeValue = someOption.get //returns "this is a value"
val someIsDefined = someOption.isDefined //returns true

val theNoneValue = noneOption.get //throws NoSuchElementException
val someIsDefined = someOption.isDefined //returns false

 def serveBestALaMode(key: Pie, pairings: Map[Pie, IceCream]): Option[Serving[Pie,IceCream]] = {
	iceCream: Option[IceCream] = pairings.get(key);
	if (iceCream.isDefined) {
		Some(new Serving(key, iceCream.get))
	} else {
		None
	}
}

Option is kind of like a Collection

someOption.map( {(str:String) => str + " SAN DIMAS HIGH SCHOOL FOOTBALL RULES"} )
	//returns Some("this is a value SAN DIMAS HIGH SCHOOL FOOTBALL RULES")
noneOption.map( {(str:String) => str + " SAN DIMAS HIGH SCHOOL FOOTBALL RULES"} )
	//returns None

val favoritePie: Option[Pie] = Some(rhubarb)
favoritePie.map({ (pie: Pie) => pairings.get(pie) })
	//returns Some(Some(butterPecan))--whoops!
favoritePie.flatMap( { (pie: Pie) => pairings.get(pie) } )
	//returns Some(butterPecan)

val todaysSpecial: Option[Pie]
val myOrder = todaysSpecial.filter( { (pie: Pie) => (pie != butterPecan) }

for-yield over Option

 for {
	pie <- todaysSpecial
	bestIceCream <- pairings.get(pie)
	iceCream <- availableFlavors.get(bestIceCream) } yield {
	myDessert
}

Option is a monad

What is a monad?

"Let’s look at what it is that makes Thing a monad.

The first thing is that I can wrap up a value inside of a new Thing...We have a function of type A => Thing; a function which takes some value and wraps it up inside a new Thing.

We also have this fancy bind function, which digs inside our Thing and allows a function which we supply to use that value to create a new Thing. Scala calls this function “flatMap“....

What’s interesting here is the fact that bind is how you combine two things together in sequence. We start with one thing and use its value to compute a new thing."

flatMap is magic

flatMap hides our boilerplate. For Lists, it abstracts away a for-loop, letting us create a new List from an existing list. For Options, it abstracts away a null check, letting us create a new nullable value from an existing one.

other monads

• accumulating errors
• a cursor position in a database or file
• states in a state machine
• an environment that changes

extra credit whoa

a semicolon is a monad

• partial application
• higher order functions
• function composition
• for-yield
• monads

The Psychology of Functional Programming

readability

DSLs

class HelloWorldSpec extends Specification {

    "The 'Hello world' string" should {
      "contain 11 characters" in {
        "Hello world" must have size(11)
      }
      "start with 'Hello'" in {
        "Hello world" must startWith("Hello")
      }
      "end with 'world'" in {
        "Hello world" must endWith("world")
      }
    }
  }

Purity

Thank you