reveal.js

Pythonic FP with Coconut

Anthony Khong

09 August 2018

Functional Programming
Declarative Programming by Example
Other Cool Features

Functional Programming

Immutability

Once assigned, a variable cannot change its value.

Immutability = Predictability

Declarative Programming

Declarative vs. Imperative

Say what things are rather than how things are done.

Sieve of Eratosthenes

<h4>Concise Lambdas</h4>
 ```python
 from itertools import count, takewhile

def primes():
                def sieve(numbers):
                    head = next(numbers)
                    yield head
                    yield from sieve(n for n in numbers if n % head)
                return sieve(count(2))

>>> list(takewhile(x -> x < 60, primes()))
 [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59]
 ```
 <aside class="notes">
 In Coconut, we can simply write an arrow for a lambda.
 It may seem minor, but if you're writing functional code, you often pass functions as arguments.
 In fact, this is how you should pass behaviours around instead of objects with methods.
 In that case, you'd like your building blocks to be as concise as possible.
 It may seem small, but this is very very nice to write functional codes with.
 Next up is functional composition...
 </aside>

<h4>Forward Piping</h4>
 ```python
 from itertools import count, takewhile

>>> primes() |> ns -> takewhile(x -> x < 60, ns) |> list
 [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59]
 ```
 <aside class="notes">
 Instead of clumsy brackets, Coconut gives us a forward pipe operator that allows to do F# style code.
 There is another type of composition: the dot composition.
 It's right to left instead of left to right, which is similar to Haskell.
 Whatever you choose Haskell-style or F#-style it's more readable than the original.
 I've softened up on this after doing some Clojure, but I'd still prefer the F#-style code.
 Next up is currying...
 </aside>

<h4>Currying</h4>
 ```python
 from itertools import count, takewhile

>>> primes() |> takewhile$(x -> x < 60) |> list
 [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59]
 ```
 <aside class="notes">
 Currying is a fancy name for partial application of a function.
 In Python, you have the partial module.
 The main idea is to start with a function of many arguments, and go down to a
 function with fewer arguments (usually one).
 This makes the syntax more concise, because instead of writing a lambda in
 takewhile, you write a curried takewhile.
 Note that in pure Python, you'd have to apply partial.
 It's hard, it's not readable. Nobody would ever do it.
 Next is iterator chaining...
 </aside>

<h4>Iterator Chaining</h4>
 ```python
 from itertools import count, takewhile

def primes():
                def sieve(numbers):
                    head = next(numbers)
                    return [head] :: sieve(n for n in numbers if n % head)
                return sieve(count(2))

>>> primes() |> takewhile$(x -> x < 60) |> list
 [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59]
 ```
 <aside class="notes">
 When you write functional code, you often work with lazy lists.
 The closest thing you have to this in Python is generators.
 In Coconut, there's a specialised syntax to deal with generators.
 In particular, you can append to the head.
 Here there's still an ugly side effect: the next function.
 We instead do pattern matching.
 </aside>

<h4>Function Assignments</h4>
 ```python
 from itertools import count, takewhile

def primes() =
                def sieve([x] :: xs) = [x] :: sieve(n for n in xs if n % x)
                sieve(count(2))

>>> primes() |> takewhile$(x -> x < 60) |> list
 [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59]
 ```
 <aside class="notes">
 In many functional programming languages, you work with expressions instead of statements.
 Functions are just any other values. Its return value is simply the last value.
 These are called function assignments and we can skip the return statement.
 Note that sieve now looks very much like a lambda.
 In fact it is, you can write that as an argument of a function.
 Finally, we have builtin higher order functions...
 </aside>

<h4>Coconut</h4>
 ```python
 def primes() =
 def sieve([x] :: xs) = [x] :: sieve(n for n in xs if n % x)
 sieve(count(2))

>>> primes() |> takewhile$(x -> x < 60) |> list
 ```

<h4>Python</h4>
 ```python
 from itertools import count, takewhile

>>> list(takewhile(x -> x < 60, primes()))
 ```
 <aside class="notes">
 There are many changes to be made from Python.
 There's no right or wrong and better or worse. It's a matter of preference.
 As someone who likes FP, I know I prefer the top version.
 </aside>