An Invitation to Functional Programming

An Invitation to Functional Programming
Sonat S¨uer
Picus Security
February 14 2018
Sonat S¨uer (Picus Security) An Invitation to Functional Programming February 14 2018 1 / 25

Overview
1 Shameless Promotion
2 Functional programming
3 A Toy Example in Detail
4 Sketch of a Vast Generalization
5 Another Example
6 Final Remarks

Shameless Promotion
Let us cut to the chase...

Shameless Promotion
Let us cut to the chase...
My company, Picus Security, is on a hunt for talent and I am here to lure
you into software engineering and functional programming.
If you decide you are interested after the talk, contact me:
sonat@picussecurity.com.

What is functional programming?
Here is the deﬁnition on Wikipedia:
In computer science, functional programming is a programming
paradigm that treats computation as the evaluation of
mathematical functions and avoids changing-state and mutable
data.

data.
This should be familiar to programmers. . .

data.
This should be familiar to programmers. . .
. . . and very appealing to mathematicians.

Why should it be appealing to mathematicians?
Because choosing pure –i.e. mathematical– functions as a foundation
means that programs are algebraic objects. Computation is literally
simpliﬁcation of algebraic expressions.

This is very intuitive from the point of view of a mathematician. For
instance, we can use substituition of equals for equals principle as a way to
reason about programs.

This is also very useful from the point of view of a programmer. It even
has a name in computer science. It is called referential transparency.

This is also very useful from the point of view of a programmer. It even
has a name in computer science. It is called referential transparency.
Note that in imperative languages referential transparency fails.

Enter Haskell
We will work out an example of the programs are algebraic objects
approach in detail. For that we will use Haskell, an industrial strength pure
functional language, named after the mathematician and logician Haskell
Curry.

Enter Haskell
We will work out an example of the programs are algebraic objects
approach in detail. For that we will use Haskell, an industrial strength pure
functional language, named after the mathematician and logician Haskell
Curry.
This will not be a crash course in Haskell. Instead, I will explain the syntax
as we go. If you have any diﬃculty in reading a code snippet, please ask!

Lists in Haskell
Like the vast majority of programming languages, Haskell has data
structures. One of the most common data structures in Haskell is the list
structure.
Here is the definition: given a type a, (like integers, floating point
numbers, strings, etc.) we define [a] by structural recursion as follows:
1 [] is a list, it is called the empty list;
2 if x is an element of type a and xs is a list of elements of type a then
x : xs is also list.

Lists in Haskell
Like the vast majority of programming languages, Haskell has data
structures. One of the most common data structures in Haskell is the list
structure.
Here is the definition: given a type a, (like integers, floating point
numbers, strings, etc.) we define [a] by structural recursion as follows:
1 [] is a list, it is called the empty list;
2 if x is an element of type a and xs is a list of elements of type a then
x : xs is also list.
For instance
1 : (2 : (3 : [])) = 1 : 2 : 3 : []
is a list of integers. Haskell allows us to express this list as [1, 2, 3].
Note that here : is a actually binary operation and a list actually a term.

Concatenation
Now let us deﬁne a simple function on lists.
Let xs and ys be two lists (over the same type). We deﬁne the
concatenation xs + +ys of xs and ys by recursion on the structure of xs as
follows:
[] + +ys = ys and (x : xs ) + +ys = x : (xs + +ys).

Concatenation
follows:
Let us compute an example:
[1, 2] + +[3, 4] =

Concatenation
follows:
[1, 2] + +[3, 4] =(1 : (2 : [])) + +(3 : (4 : []))

Concatenation
follows:
[1, 2] + +[3, 4] =(1 : (2 : [])) + +(3 : (4 : []))
=1 : ((2 : []) + +(3 : (4 : []))

Concatenation
follows:
[1, 2] + +[3, 4] =(1 : (2 : [])) + +(3 : (4 : []))
=1 : ((2 : []) + +(3 : (4 : []))
=1 : (2 : ([] + +(3 : (4 : [])))

Concatenation
follows:
[1, 2] + +[3, 4] =(1 : (2 : [])) + +(3 : (4 : []))
=1 : ((2 : []) + +(3 : (4 : []))
=1 : (2 : ([] + +(3 : (4 : [])))
=1 : (2 : (3 : (4 : [])))

Concatenation
follows:
[1, 2] + +[3, 4] =(1 : (2 : [])) + +(3 : (4 : []))
=1 : ((2 : []) + +(3 : (4 : []))
=1 : (2 : ([] + +(3 : (4 : [])))
=1 : (2 : (3 : (4 : [])))
=[1, 2, 3, 4]

Naive reverse function
Suppose that we want to devise a function –that is to say, write a
program– which produces the reverse of a list.

Here is the obvious solution. Given a list xs let us deﬁne naiveReverse as
follows:
naiveReverse [] = [] and naiveReverse (x : xs) = naiveReverse xs++[x].

Here is the obvious solution. Given a list xs let us deﬁne naiveReverse as
follows:
naiveReverse [] = [] and naiveReverse (x : xs) = naiveReverse xs++[x].
As an exercise show that naiveReverse [1, 2, 3] = [3, 2, 1].

Complexity of the naive reverse function
First, note that the computation of xs + +ys requires length of xs many
applications of : operation.

Claim: Computation of naiveReverse xs requires 1
2n(n − 1) applications of
the operation : where n is the length of xs.

Proof. By induction on n. Base case is trivial. Suppose the statement
holds for n. Let xs be of length n. Then for any x we have
naiveReverse (x : xs) = naiveReverse xs + +[x].
As naiveReverse xs and xs has the same length, namely n, computation of
++ takes n applications of the : operation. On the other hand, by
induction hypothesis, naiveReverse xs requires 1
2n(n − 1) applications.
Adding these two yields 1
2n(n + 1), which is what we want. QED

Proof. By induction on n. Base case is trivial. Suppose the statement
holds for n. Let xs be of length n. Then for any x we have
naiveReverse (x : xs) = naiveReverse xs + +[x].
As naiveReverse xs and xs has the same length, namely n, computation of
++ takes n applications of the : operation. On the other hand, by
induction hypothesis, naiveReverse xs requires 1
2n(n − 1) applications.
Adding these two yields 1
2n(n + 1), which is what we want. QED
So the complexity is quadratic as a function of the input length.

The Basic Idea
The naive implementation of the reverse function is quadratic because ++
is expensive.

The Basic Idea
is expensive.
There is a very similar situation in mathematics with an elegant solution:
multiplication is expensive, however one can use logarithms to turn
multiplication into addition, do the additon and come back with
exponentiaiton.

The Basic Idea
is expensive.
There is a very similar situation in mathematics with an elegant solution:
multiplication is expensive, however one can use logarithms to turn
multiplication into addition, do the additon and come back with
exponentiaiton.
We will use the same trick, namely we will change the algebraic structure
we work in by using homomorphisms.

A Small Remark Before We Continue
It is about to get technical. Without a certain background in mathematics
some of the things I will talk about may not make much sense.

However, you should not leave the room because

I will give an example for programmers, which will probably be
opaque for most mathematicians,

I will give an example for programmers, which will probably be
opaque for most mathematicians,
You do not need to understand any of the mathematics here to be
productive in Haskell, or any other functional programming language.

Algebra refresher: Cayley representation theorem
Recall that a monoid is a triple (M, ∗, e) where ∗ is a binary associative
operation on M and e is the identity element of ∗.

Here are two important examples:
1 For any set S, the set of self maps of S, denoted by End(S) is a
monoid under composition. The identity is the identity function.

Here are two important examples:
1 For any set S, the set of self maps of S, denoted by End(S) is a
monoid under composition. The identity is the identity function.
2 For any set S, the set of ﬁnite sequences with elements from S form a
monoid under concatenation. The identity is the empty list. (Actually
this is called the free monoid generated by S.)

Theorem
Cayley A monoid with underlying set S can be embedded in End(S).

Theorem
Proof.
One can easily check that C(s) = λs where λs(x) = s ∗ x is such an
embedding.

Theorem
Proof.
One can easily check that C(s) = λs where λs(x) = s ∗ x is such an
embedding.
Note that if a function f is in the image of C then one can recover the
element it came from by applying f to the identity of the monoid.

Pushing the problem to End([a])
In End([a]), the monoidal operation, namely function composition, is very
cheap. To be more precise, it requires constant time because the
composition of two functions is left untouched untill someone tries to
apply it to a value.

However, the notion of reverting only makes sense in [a] and not in
End([a]). So we need to embed only the concatenation part of the
problem into End([a]).

However, the notion of reverting only makes sense in [a] and not in
End([a]). So we need to embed only the concatenation part of the
problem into End([a]).
The inverse of xs is given by f xs [] where f is deﬁned by
f [] = id and f (x : xs) = f xs ◦ C([x]).

Haskell Implementation
type End s = s -> s
singleton :: a -> End [a]
singleton x = f where f y = x : y
cayleyReverse :: [a] -> End [a]
cayleyReverse [] = id
cayleyReverse (x : xs) = cayleyReverse xs . singleton x
naiveReverse :: [a] -> [a]
naiveReverse [] = []
naiveReverse (x : xs) = naiveReverse xs ++ [x]
betterReverse :: [a] -> [a]
betterReverse xs = cayleyReverse xs []

Monoid Objects in a Category
We will port our method to diﬀerent domains using category theory.

First, we need to translate our notions to category theory. Eﬀectively, this
means expressing everything in terms of functions and their compositions.
We need

We need
Elements (using terminal objects)

We need
Products (expressing Cartesian product as a categorical limit)

We need
Monoids (using the “associativity” of Cartesian products)

We need
Now a monoid is a set M together with two functions ∗: M × M → M
and e : 1 → M satisfying the associativity and identitiy rules.

We need
The associativity rule of a monoid M can be expressed by saying that the
two functions
∗ ◦ (id × ∗) and ∗ ◦ (∗ × id) ◦ α
from M × (M × M) to M are equal. (Here α(x, (y, z)) = ((x, y), z)).)

We need
The associativity rule of a monoid M can be expressed by saying that the
two functions
∗ ◦ (id × ∗) and ∗ ◦ (∗ × id) ◦ α
from M × (M × M) to M are equal. (Here α(x, (y, z)) = ((x, y), z)).)
Exercise: Express the identity rule.

Monoid Objects in a Monoidal Category
This is where the hand-waving starts. For actual deﬁnition you may use
Wikipedia.

Wikipedia.
First, let us forget about sets and functions and work with an arbitrary
category. This means that we work with abstract objects and abstract
“maps” between them. The composition f ◦ g is deﬁned only when the
codomain of g coincides with the domain of f . The only assumption
about this abstract composition is associativty.

Wikipedia.
Let us also forget about Cartesians product and work with an arbitrary
monoidal structure. This means that we have a binary construction on our
objects with a function like α –and a little bit more.

Wikipedia.
Let us also forget about Cartesians product and work with an arbitrary
monoidal structure. This means that we have a binary construction on our
objects with a function like α –and a little bit more.
It turns out that the notion of a monoid can be expressed in any category
with a monoidal structure. If your category is the category of sets and
functions between them and the monoidal structure is the Cartesian
product then you recover the original notion.

Examples: Applicatives, Monads and Arrows
But is this generalization useful?

But is this generalization useful? You bet! Here are some examples.
Let Hask be the category of types in Haskell with functions deﬁnable
in Haskell and pairing (or product) as the monoidal structure. (From
a strict point of view, this is not true but good enough to snatch ideas
from category theory.) Then for any a, [a] and End a are monoids.

Consider endofunctors of Hask with composition as the monoidal
structure. Then the monoids are called the monads. The Cayley
representation in this context is acalled the codensity monad
transformation for historical reasons.

In the category of endofunctors of Hask with Day convolution as the
monoidal structure the monoids are called the applicatives.

In the category of endofunctors of Hask with Day convolution as the
monoidal structure the monoids are called the applicatives.
In the category of profunctors with profunctor tensor as the monoidal
structure the monoids are called the weak arrows.
. . .

Tip of the iceberg
This was just one idea and its generalizations. Here is an incomplete list of
other relevant pure mathematical notions, each of which could be the
topic of a diﬀerent talk:
Free constructions (free monads, free applicatives, etc.)

Tip of the iceberg
Categorical duality (comonds, cofree constructions etc.)

Tip of the iceberg
Functors (adjointness and representability)

Tip of the iceberg
Categories as databases (AQL and functorial migration)

Tip of the iceberg
Categories as databases (AQL and functorial migration)
Curry-Howard correspondence
. . .
A lot of exciting things are happenning here!

The Example I Promised to Programmers
At this point, most programmers in the audience should be thinking “I’ve
been coding without knowing/understanding any of these abstract
mathematical concepts. Do I have to know/understand them?”

The answer is no. This was mostly meant for mathematicians. One can
use these tools without understanding the theoretical background.

However a certain shift in mentality seems to be unavoidable.

However a certain shift in mentality seems to be unavoidable.
For that reason, I will give an example of what you can do with Haskell
from our own code base.

Asynchronous Actions
Here is the problem: Suppose that we have some asynchronous actions
each of which can either return a value or fail with an error message. We
want to capture the ﬁrst value returned by these actions. However, if they
all fail, we want to have a list of all the error messages returned. Optional:
The error messages should be ordered chronologically.

Please take a moment and try to solve this problem in your head using
your favourite language.

Please take a moment and try to solve this problem in your head using
your favourite language.
Our solution will depend on Async, a library developed by Simon Marlow.

Haskell Implementation
pickFirstElligible
:: [Async (Either a b)]
-> IO (Either [a] b)
pickFirstElligible allActions =
run [] allActions ‘finally‘ mapM_ cancel allActions
where
run errs actions =
if null actions
then return $ Left $ reverse errs
else do (action, res) <- waitAny actions
case res of
Left err ->
run (err : errs) (delete action actions)
Right val ->
return $ Right val

Two mottos

Two mottos
There is nothing more practical than a good theory.

Two mottos
There is nothing more practical than a good theory.
In theory, there is no diﬀerence between theory and practise. In
practise, there is.

Thank you for listening!

An Invitation to Functional Programming

More Related Content

What's hot

Similar to An Invitation to Functional Programming

Recently uploaded

An Invitation to Functional Programming