Lambda Squared 2018: Practical Functional Programming

Transcript

227 slides

Practical Functional Programming Jeremy Fairbank @elpapapollo
@testdouble helps improves how the world build software. testdouble.com/agency
In beta now! bit.ly/programming-elm
Functional programming:
Pure Functional programming:
Pure Total Functional programming:
Pure Total Idempotent Functional programming:
Pure Total Idempotent Monad Functional programming:
Pure Total Idempotent Monad Functor Functional programming:
Easier-to-reason-about- oriented programming
Pure Total Idempotent Monad Functor
None
6 Become a rockstar programmer with these tricks!
Hard to test
async function printOrderDetails(ids) { let url = `/orders?ids=${ids.join(',')}` let orders
= await fetchJson(url) for (let i = 0; i < orders.length; i++) { let { id, date, customer } = orders[i] let details = `Order ${id} on ${date} by ${customer}` console.log(details) } }
const td = require('testdouble') describe('order details', () => { let
originalLog = console.log let printOrderDetails let fetchJson beforeEach(() => { fetchJson = td.replace('./fetchJson') console.log = td.function('console.log') printOrderDetails = require('./printOrderDetails') }) afterEach(() => { td.reset() console.log = originalLog })
it('prints details for multiple orders', async () => { td
.when(fetchJson('/orders?ids=1,2,3')) .thenResolve([ { id: 1, date: '12/1/17', customer: 'Tucker' }, { id: 2, date: '11/25/17', customer: 'Sally' }, { id: 3, date: '3/30/18', customer: 'Joe' }, ]) await printOrderDetails([1, 2, 3]) td.verify(console.log('Order 1 on 12/1/17 by Tucker')) td.verify(console.log('Order 2 on 11/25/17 by Sally')) td.verify(console.log('Order 3 on 3/30/18 by Joe')) }) })
Side Eﬀects
Less Predictable
Harder to Test
Functions
const add = (x, y) => x + y add(2,
3) === 5 add(2, 3) === 5 add(2, 3) === 5
None
const url = ids => `/orders?ids=${ids.join(',')}` const orderDetails = ({
id, date, customer }) => `Order ${id} on ${date} by ${customer}` function detailsForOrders(orders) { let details = [] for (let i = 0; i < orders.length; i++) { details.push(orderDetails(orders[i])) } return details }
it('uses the correct url', () => { expect(url([1, 2, 3])).toEqual('/orders?ids=1,2,3')
})
it('creates details for orders', () => { let orders =
[ { id: 1, date: '12/1/17', customer: 'Tucker' }, { id: 2, date: '11/25/17', customer: 'Sally' }, { id: 3, date: '3/30/18', customer: 'Joe' }, ] expect(detailsForOrders(orders)).toEqual([ 'Order 1 on 12/1/17 by Tucker', 'Order 2 on 11/25/17 by Sally', 'Order 3 on 3/30/18 by Joe', ]) })
async function printOrderDetails(ids) { let orders = await fetchJson(url(ids)) let
details = detailsForOrders(orders) for (let i = 0; i < details.length; i++) { console.log(details[i]) } }
youtu.be/yTkzNHF6rMs
Hard to test Hard to follow
const orderDetails = ({ id, date, customer }) => `Order
${id} on ${date} by ${customer}` function detailsForOrders(orders) { let details = [] for (let i = 0; i < orders.length; i++) { details.push(orderDetails(orders[i])) } return details }
${id} on ${date} by ${customer}` function detailsForOrders(orders) { let details = [] for (let i = 0; i < orders.length; i++) { details.push(orderDetails(orders[i])) } return details }
Imperative
Declarative
${id} on ${date} by ${customer}` const detailsForOrders = orders => orders.map(orderDetails)
${id} on ${date} by ${customer}` const detailsForOrders = orders => orders.map(orderDetails)
{ id: 1, date: '12/1/17', customer: 'Tucker' } { id:
2, date: '11/25/17', customer: 'Sally' } { id: 3, date: '3/30/18', customer: 'Joe' }
{ id: 1, date: '12/1/17', customer: 'Tucker' } { id:
2, date: '11/25/17', customer: 'Sally' } { id: 3, date: '3/30/18', customer: 'Joe' } [ 'Order 1 on 12/1/17 by Tucker', ] map orderDetails
[ 'Order 1 on 12/1/17 by Tucker', 'Order 2 on
11/25/17 by Sally', ] orderDetails { id: 1, date: '12/1/17', customer: 'Tucker' } { id: 2, date: '11/25/17', customer: 'Sally' } { id: 3, date: '3/30/18', customer: 'Joe' } map
orderDetails [ 'Order 1 on 12/1/17 by Tucker', 'Order 2
on 11/25/17 by Sally', 'Order 3 on 3/30/18 by Joe', ] map { id: 1, date: '12/1/17', customer: 'Tucker' } { id: 2, date: '11/25/17', customer: 'Sally' } { id: 3, date: '3/30/18', customer: 'Joe' }
Hard to test Hard to follow Code breaks unexpectedly
class Person { constructor(name, hobbies) { this.name = name this.hobbies
= hobbies } describe() { if (this.hobbies.length === 0) { return `${this.name} doesn't do much` } let hobbies = this.hobbies.splice(0, 2).join(' and ') return `${this.name} likes to do things such as ${hobbies}` } }
let person = new Person('Jeremy', [ 'programming', 'reading', 'playing music',
]) person.describe() // Jeremy likes to do things such as programming and reading person.describe() // Jeremy likes to do things such as playing music
let hobbies = this.hobbies.splice(0, 2).join(' and ')
Mutable Data
Immutable Data Safety and consistency
= Object.freeze(hobbies) } // ... }
class Person { // ... describe() { // ... let
hobbies = this.hobbies.splice(0, 2).join(' and ') // ... } }
hobbies = this.hobbies.splice(0, 2).join(' and ') // ... } } TypeError: Cannot add/remove sealed array elements
hobbies = this.hobbies.slice(0, 2).join(' and ') // ... } }
Create New State
const create = (name, hobbies) => Object.freeze({ name, hobbies: Object.freeze(hobbies)
}) function describe(person) { if (person.hobbies.length === 0) { return `${person.name} doesn't do much` } let hobbies = person.hobbies.slice(0, 2).join(' and ') return `${person.name} likes to do things such as ${hobbies}` }
const addHobby = (hobby, person) => Object.freeze({ ...person, hobbies: Object.freeze([...person.hobbies,
hobby]), })
hobby]), })
hobby]), })
hobby]), })
hobby]), })
let person = create('Jeremy', []) person = addHobby('programming', person) person
= addHobby('reading', person) describe(person) // Jeremy likes to do things such as programming and reading
Hard to test Hard to follow Code breaks unexpectedly Too
much code
const greetInEnglish = name => `Hi, ${name}` const greetInSpanish =
name => `Hola, ${name}`
const greet = (greeting, name) => `${greeting}, ${name}` // ..
const greetInEnglish = name => greet('Hi', name) const greetInSpanish = name => greet('Hola', name)
const greet = greeting => name => `${greeting}, ${name}` const
greetInEnglish = greet('Hi') const greetInSpanish = greet('Hola') greetInEnglish('Lambda Squared') // Hi, Lambda Squared greetInSpanish('Lambda Squared') // Hola, Lambda Squared
greetInEnglish = greet('Hi') const greetInSpanish = greet('Hola') Curried Function Partial Application
greet greeting name = greeting ++ ", " ++ name
greetInEnglish = greet "Hi" greetInSpanish = greet "Hola"
greetInEnglish "Lambda Squared" -- Hi, Lambda Squared greetInSpanish "Lambda Squared"
-- Hola, Lambda Squared
None
function createOrder(shoppingCart, customer) { let total = 0 shoppingCart.items.forEach(item =>
{ total += item.price }) shoppingCart.discounts.forEach(discount => { total *= 1 - discount }) total *= 1 + shoppingCart.tax total += shoppingCart.shippingCost total = Math.round(total * 100) / 100 return { status: 'new', customer, total } }
const excitedGreeting = name => // ...
const toUpper = string => string.toUpperCase() const greet = greeting
=> name => `${greeting}, ${name}` const exclaim = phrase => `${phrase}!` const excitedGreeting = name => exclaim(greet('Hi')(toUpper(name))) excitedGreeting('Lambda Squared') // Hi, LAMBDA SQUARED!
const R = require('ramda') const excitedGreeting = name => R.pipe(
toUpper, greet('Hi'), exclaim, )(name) excitedGreeting('Lambda Squared') // Hi, LAMBDA SQUARED!
toUpper, // LAMBDA SQUARED greet('Hi'), exclaim, )(name) excitedGreeting('Lambda Squared') // Hi, LAMBDA SQUARED!
toUpper, greet('Hi'), // Hi, LAMBDA SQUARED exclaim, )(name) excitedGreeting('Lambda Squared') // Hi, LAMBDA SQUARED!
toUpper, greet('Hi'), exclaim, // Hi, LAMBDA SQUARED! )(name) excitedGreeting('Lambda Squared') // Hi, LAMBDA SQUARED!
Function Composition
exclaim phrase = phrase ++ "!" excitedGreeting name = name |> String.toUpper |> greet "Hi" |> exclaim excitedGreeting "Lambda Squared" -- Hi, LAMBDA SQUARED!
exclaim phrase = phrase ++ "!" excitedGreeting name = name |> String.toUpper -- LAMBDA SQUARED |> greet "Hi" |> exclaim excitedGreeting "Lambda Squared" -- Hi, LAMBDA SQUARED!
exclaim phrase = phrase ++ "!" excitedGreeting name = name |> String.toUpper |> greet "Hi" -- Hi, LAMBDA SQUARED |> exclaim excitedGreeting "Lambda Squared" -- Hi, LAMBDA SQUARED!
exclaim phrase = phrase ++ "!" excitedGreeting name = name |> String.toUpper |> greet "Hi" |> exclaim -- Hi, LAMBDA SQUARED! excitedGreeting "Lambda Squared" -- Hi, LAMBDA SQUARED!
function createOrder(shoppingCart, customer) { let total = R.pipe( addPrices(shoppingCart.items), addDiscounts(shoppingCart.discounts),
addTax(shoppingCart.tax), add(shoppingCart.shippingCost), roundTotal, )(0) return { status: 'new', customer, total } }
much code Scary to refactor
const createOrder = customer => shoppingCart => { let total
= R.pipe( addPrices(shoppingCart.items), addDiscounts(shoppingCart.discounts), addTax(shoppingCart.tax), add(shoppingCart.shippingCost), roundTotal, )(0) return { status: 'new', customer, total } }
createOrder(myShoppingCart, 'Tucker')
Strong Static Types
createOrder shoppingCart customer = let total = addPrices shoppingCart.items 0
|> addDiscounts shoppingCart.discounts |> addTax shoppingCart.tax |> add shoppingCart.shippingCost |> roundTotal in { status = "new" , customer = customer , total = total }
createOrder customer shoppingCart = let total = addPrices shoppingCart.items 0
-- TYPE MISMATCH -------------------------------------- App.elm The 2nd argument to function
`createOrder` is causing a mismatch. 25| createOrder myShoppingCart "Tucker" ^^^^^^^^ Function `createOrder` is expecting the 2nd argument to be: { b | discounts : List Float , items : List { a | price : Float } , shippingCost : Float , tax : Float } But it is: String
conference : String conference = "Lambda Squared" life : Int
life = 42 greet : String -> String greet name = "Hello, " ++ name formatCurrency : Float -> String formatCurrency amount = "$" ++ toString amount
Custom Types
type alias Item = { price : Float }
type alias Item = { price : Float } type
alias ShoppingCart = { items : List Item , discounts : List Float , tax : Float , shippingCost : Float }
alias ShoppingCart = { items : List Item , discounts : List Float , tax : Float , shippingCost : Float }
alias ShoppingCart = { items : List Item , discounts : List Float , tax : Float , shippingCost : Float } type alias Order = { status : String , customer : String , total : Float }
createOrder : ShoppingCart -> String -> Order createOrder shoppingCart customer
= ...
= ...
type alias Order = { status : String , customer
: String , total : Float }
type alias Order = { status : String , customer
: String , total : Float }
type Status = New | Processing | Shipped
type Status = New | Processing | Shipped type alias
Order = { status : Status , customer : String , total : Float }
= let total = addPrices shoppingCart.items 0 |> addDiscounts shoppingCart.discounts |> addTax shoppingCart.tax |> add shoppingCart.shippingCost |> roundTotal in { status = New , customer = customer , total = total }
much code Scary to refactor Oh, null
function getBestFriendLocation(id, users) { let user = users.get(id) let friend
= users.get(user.bestFriendId) return friend.location }
getBestFriendLocation(42, users) Uncaught TypeError: Cannot read property 'bestFriendId' of null
= users.get(user.bestFriendId) return friend.location } null
function getBestFriendLocation(id, users) { let user = users.get(id) if (user)
{ let friend = users.get(user.bestFriendId) return friend.location } }
function getBestFriendLocation(id, users) { let user = users.get(id) if (user)
{ let friend = users.get(user.bestFriendId) return friend.location } } null
function getBestFriendLocation(id, users) { let user = users.get(id) if (user
&& user.bestFriendId) { let friend = users.get(user.bestFriendId) return friend.location } }
&& user.bestFriendId) { let friend = users.get(user.bestFriendId) return friend.location } } null
&& user.bestFriendId) { let friend = users.get(user.bestFriendId) if (friend) { return friend.location } } }
None
if () {} if () {} if () {}
type Maybe a = Nothing | Just a
42 Just 42 "Hi" Just "Hi"
Just 42 [42] Nothing [ ]
getUserName : Id -> Dict Id User -> String getUserName
id users = Dict.get id users
id users = Dict.get id users Maybe User
id users = case Dict.get id users of Just user -> user.name
id users = case Dict.get id users of Just user -> user.name user
-- MISSING PATTERNS ------------------------------ App.elm This `case` does not have
branches for all possibilities. 30|> case Dict.get id users of 31|> Just user -> 32|> user.name You need to account for the following values: Maybe.Nothing Add a branch to cover this pattern!
id users = case Dict.get id users of Just user -> user.name Nothing -> "<anonymous>"
&& user.bestFriendId) { let friend = users.get(user.bestFriendId) if (friend) { return friend.location } } }
getBestFriendLocation : Id -> Dict Id User -> Maybe Location
getBestFriendLocation id users = case Dict.get id users of Just user -> case user.bestFriendId of Just bestFriendId -> case Dict.get bestFriendId users of Just friend -> friend.location Nothing -> Nothing Nothing -> Nothing Nothing -> Nothing
getBestFriendLocation id users = Dict.get id users |> Maybe.andThen (\user
-> user.bestFriendId) |> Maybe.andThen (\id -> Dict.get id users) |> Maybe.andThen (\friend -> friend.location)
P.S. You kinda, sorta just learned monads
much code Scary to refactor Oh, null
Hard to test Pure Functions Hard to follow Code breaks
unexpectedly Too much code Scary to refactor Oh, null
Hard to test Pure Functions Hard to follow Declarative Code
Code breaks unexpectedly Too much code Scary to refactor Oh, null
Code breaks unexpectedly Immutable Data Too much code Scary to
refactor Oh, null Hard to test Pure Functions Hard to follow Declarative Code
Too much code Curried, Composable Functions Scary to refactor Oh,
null Code breaks unexpectedly Immutable Data Hard to test Pure Functions Hard to follow Declarative Code
Scary to refactor Strong, Static Types Oh, null Too much
code Curried, Composable Functions Code breaks unexpectedly Immutable Data Hard to test Pure Functions Hard to follow Declarative Code
Oh, null Maybe and Monads Scary to refactor Strong, Static
Types Too much code Curried, Composable Functions Code breaks unexpectedly Immutable Data Hard to test Pure Functions Hard to follow Declarative Code
Thanks! bit.ly/lambda-squared-practical-fp Jeremy Fairbank @elpapapollo

Lambda Squared 2018: Practical Functional Progr...

Lambda Squared 2018: Practical Functional Programming

Transcript