Overview

We want our programs to be

Correct programs

• Do what we mean
• Do what we expect
• ...always.

Comprehensible programs

• We can easily comprehend,
  what will happen when they run
   
• We can easily comprehend,
  what the program means

Composable programs

• Are made up of smaller parts
   
• Each part is Correct, Comprehensible, Composable
   
• Parts are swappable,
  click into each other

Immutable, wat?

Mutate

• Make change in-place
   
• ...to data
• ...to data structure (tree, array)

Mutable data

• Data or data structure
  that can be mutated
  (changed in-place)
   
• Example:
  • int variable
  • array
  • object with set-methods
    
    (in many languages)

Mutate

let a = 1      // a == 1
let a = a + 1  // a == 2

Mutate

class Person {
    int age = 0

    function haveBirthday() {
        this.age++
    }
}

Person newBorn = new Person()
newBorn.age  // 0

newBorn.haveBirthday()
newBorn.age  // 1

Mutate

string[] words = ["Good", "morning", "all"]

function changeTime(string newTime) {
    words[1] = newTime
}

function addWord(string word) {
    words[words.length + 1] = word
}

// ---
changeTime("afternoon") // words == ["Good", "afternoon", "all"]
addWord("the")          // words == ["Good", "afternoon", "all", "the"]
addWord("time")         // words == ["Good", "afternoon", "all", "the", "time"]

Immutable data

• Data or data structure
  that cannot be mutated
   
• Example: String
  (in many languages)
   
• Change:
  • copy with some
    parts replaced
    ​

Immutable data

string hello = "HELLO WORLD!"
string hellow = hello.toLower()

hello   //"HELLO WORLD!"
hellow  //"hello world!"

Immutable data structure

Immutable data

class Person {
    int age = 0

    function haveBirthday() {
        cloneOfMe = this.cloneAndSet({ age: this.age+1 });
        return cloneOfMe
    }
}

Person newBorn = new Person()
Person toddler = newBorn.haveBirthday()

newBorn.age  // 0
toddler.age  // 1

Immutable data

string[] words = ["Good", "morning", "all"]

function changeTime(string newTime) {
    words[1] = newTime
}

function addWord(string word) {
    words[words.length + 1] = word
}

// ---
changeTime("afternoon") // words == ["Good", "afternoon", "all"]
addWord("the")          // words == ["Good", "afternoon", "all", "the"]
addWord("time")         // words == ["Good", "afternoon", "all", "the", "time"]

input container

mapper

const numbers = [1, 2, 3, 4]
const doubledNumbers = []

for (let i = 0; i < numbers.length; i++) {   // imperative
    doubledNumbers[i] = numbers[i] * 2       // style
}

doubledNumbers //[2, 4, 6, 8]

const numbers = [1, 2, 3, 4]
const doubledAndIncrementedNumbers = []

for (let i = 0; i < numbers.length; i++) {
    doubledAndIncrementedNumbers[i] = numbers[i] * 2 + 1
}

doubledAndIncrementedNumbers //[3, 5, 7, 9]

Syntax Examples

map

map in Java

String[] input = new String[]{"alice", "bob", "paul", "ellie"};

String[] output = Arrays.stream(input)
                        .map(s -> s.toUpperCase())
                        .toArray(String[]::new);

output // {"ALICE", "BOB", "PAUL", "ELLIE"}

map in Swift

let values = [2.0, 4.0, 5.0, 7.0]

let squares = values.map {$0 * $0}

squares // [4.0, 16.0, 25.0, 49.0]

map in JavaScript

const values = [2, 4, 5, 7]

const squares = values.map(n => n * n)     // ES2015

squares // [4, 16, 25, 49]

var values = [2, 4, 5, 7]

var squares = values.map(function (n) {    // ES5
    return n * n
})

squares // [4, 16, 25, 49]

map in Ruby

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map{|e| e*3 }

# returns [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]

map in C#

List<string> words = new List<string>() {
    "an", "apple", "a", "day"
};

var query = from word in words
            select word.Substring(0, 1);

foreach (string s in query)
    Console.WriteLine(s);

/* This code produces the following output:

    a
    a
    a
    d
*/

map in F#

let helloGood = 
    let list = ["a";"b";"c"]
    list |> List.map (fun element -> "hello " + element)

// val helloGood : string list = ["hello a"; "hello b"; "hello c"]

map in Scala

val numbers = List(1, 2, 3, 4)
numbers.map((i: Int) => i * 2)

// List(2, 4, 6, 8)

map in Python

items = [1, 2, 3, 4, 5]
squared = list( map(lambda x: x**2, items) )

// [1, 4, 9, 16, 25]

map in Elm

map sqrt [1, 4, 9] == [1, 2, 3]

map not [True, False, True] == [False, True, False]

plusOne = (+) 1
map plusOne [1, 4, 9] == [2, 5, 10]

input container

must be at least this big:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

Syntax Examples

filter

filter in Java

String[] input = new String[]{"alice", "bob", "paul", "ellie"};

String[] output = Arrays.stream(input)
                        .filter(s -> s.length() > 4)
                        .toArray(String[]::new);

output // {"alice", "ellie"}

filter in Swift

let digits = [1, 4, 10, 15]
let even = digits.filter { $0 % 2 == 0 }
// [4, 10]

filter in JavaScript

const values = [1, 4, 10, 15]

const even = values.filter(n => n%2 === 0) // ES2015

even // [4, 10]

var values = [1, 4, 10, 15]

var even = values.filter(function (n) {    // ES5
    return n%2 === 0
})

even // [4, 10]

filter in Ruby

[1,2,3,4,5,6,7,8,9,10].select{|el| el%2 == 0 }
# returns [2,4,6,8,10]

filter in C#

string[] words = { "the", "quick", "brown", "fox", "jumps" };

IEnumerable<string> query = from word in words
                            where word.Length == 3
                            select word;

foreach (string str in query)
    Console.WriteLine(str);

/* This code produces the following output:

    the
    fox
*/

filter in F#

[1..10] |> List.filter (fun i -> i%2 = 0) // even

// [2; 4; 6; 8; 10]

filter in Scala

val numbers = List(1, 2, 3, 4)
numbers.filter((i: Int) => i % 2 == 0)

// List(2, 4, 6, 8)

filter in Python

number_list = range(-5, 5)
less_than_zero = list( filter(lambda x: x < 0, number_list) )
print(less_than_zero)

# Output: [-5, -4, -3, -2, -1]

filter in Elm

filter isEven [1..6] == [2,4,6]

input container

+

3

2

3

input container

return the largest of two planets

const numbers = [3, 3, 2]
const sum = numbers.reduce(
    (sumSoFar, number) => sumSoFar+number,  // <-- reducer fn
    0                                       // <-- init value
)

sum // 8

const numbers = [3, 3, 2]
const sum = numbers.reduce(
    (sumSoFar, number) => sumSoFar+number,  // <-- reducer fn
    0                                       // <-- init value
)

sum // 8

Syntax Examples

reduce

reduce in Java

String[] input = { "this", "is", "a", "sentence" };

String output = Arrays.stream(myArray)
                .reduce("", (a,b) -> a + " " + b);

// "this is a sentence"

reduce in Swift

let items = [2.0, 4.0, 5.0, 7.0]

let total = items.reduce(10.0, combine: +)

// 28.0

reduce in JavaScript

const values = [1, 4, 10, 15]

const sum = values.reduce((sumSoFar, n) => sumSoFar + n, 0) // ES2015

sum // 30

var values = [1, 4, 10, 15]

var sum = values.reduce(function (sumSoFar, n) {            // ES5
    return sumSoFar + n
}, 0)

sum // 30

reduce in Ruby

[1,2,3,4,5,6,7,8,9,10].inject{|sum,e| sum += e }
# returns 55

reduce in C#

string sentence = "the quick brown fox jumps over the lazy dog";

// Split the string into individual words.
string[] words = sentence.Split(' ');

// Prepend each word to the beginning of the 
// new sentence to reverse the word order.
string reversed = words.Aggregate((workingSentence, next) =>
                                      next + " " + workingSentence);

Console.WriteLine(reversed);

// This code produces the following output:
//
// dog lazy the over jumps fox brown quick the 

fold in F#

["a";"b";"c"] |> List.fold (+) "hello: "    
// "hello: abc"
// "hello: " + "a" + "b" + "c"

[1;2;3] |> List.fold (+) 10    
// 16
// 10 + 1 + 2 + 3

fold in Scala

val numbers = List(1, 2, 3, 4)
numbers.foldLeft(0)((m: Int, n: Int) => m + n)
// 55

reduce in Python

from functools import reduce
product = reduce( (lambda x, y: x * y), [1, 2, 3, 4] )

# Output: 24

fold in Elm

foldr (+) 0 [1,2,3] == 6

Higher-order functions

• Takes a function as argument

map :: fn -> List -> List

user = {
    name: String,
    age: Int,
    birthday: Date
}

users = [
    {
        name: "Fjodor", 
        age: 31, 
        birthday: "2009-04-21 14:25:29.5585588 UTC"
    }, 
    {
        name: "Hugo", 
        age: 40, 
        birthday: "2010-04-21 14:25:29.5585588 UTC" 
    }
]


map :: (a -> b) -> List a -> List b
map (\a -> a.birthday) users

filter :: fn -> List -> List

user = {
    name: String,
    age: Int,
    birthday: Date
}

users = [
    {
        name: "Fjodor", 
        age: 31, 
        birthday: "2009-04-21 14:25:29.5585588 UTC"
    }, 
    {
        name: "Hugo", 
        age: 40,
        birthday: "2010-04-21 14:25:29.5585588 UTC"
    }
]

filter :: (a -> Bool) -> List a -> List a
filter (\ x -> x.age `mod` 2 == 0) users

Currying

• A function is applied to its arguments one at a time

• Each application returns a new function that accepts the next argument

add

function add(a, b) {
    return a + b;
};


//Normal add function takes two arguments
node> const age = add(1, 3);
4

Curried

//What is Albins age?
//Albin is half the age of Hugo which is three years older than me

//Curried add
const add = a => b => a + b;

//Curried div
const div = b => a => a / b;

const myAge = 32;

const threeYearsOlder = add(3);

const halfTheAge = div(2);

const albinsAge = halfTheAge(threeYearsOlder(myAge))
17.5


//OR by using function composition
node> const R = require('ramda');

node> const findOutAlbinsAgeBasedOnMine = R.compose(halfTheAge, threeYearsOlder);
node> const albinsAge = findoutAlbinsAgeBasedOnMine(myAge)
17.5

Recursion

Head and Tail

node> const listOfNumbers = [ 1, 2, 3, 4, 5, 6, 7, 8 ];

node> [ head, ...tail ] = listOfNumbers;

node> head
1

node> tail
[ 2, 3, 4, 5, 6, 7, 8 ]

Recursive dinner

const dinnerName = (acc, ingredientList) => {
    if (!ingredientList.length) {               // Exit condition
      return acc;                                
    }
    const [head, ...tail] = ingredientList;     // Destructuring
    return dinnerName(head + acc, tail);        // Recursion 
};

node> const ingredients = [ 'soup', 'mushroom', 'forest' ];

node> const dinner = dinnerName('', ingredients);

node> dinner;
'forestmushroomsoup'

Exercise

create a recursive function that takes a list of numbers

and returns only even numbers

(hint find the modulo operator)

Pure functions

• Idempotent
• Does not cause side-effects

Idempotency

Always evaluates the same result value

given the same argument values

// Idempotency requires your function to always return the same result 
// given the same argument no matter how many times you invoke it

node> const R = require('ramda');

node> const composedIdentity = R.compose(R.identity, R.identity);

// OR

node> composedIdentity(32) === R.identity(32)
true

non-idempotent example

// NON-IDEMPOTENT
const nonIdempotentFn = arg => {
    return arg.length;
};

node> nonIdempotentFn('hello');
5

node> nonIdempotentFn(nonIdempotentFn('hello'));
undefined

node> nonIdempotentFn(5)
undefined

Side-effects

• modifies state.
• interacts with functions.
• interacts with the outside world.