In the beginning…
There were the forces of light…There were the forces of darkness…
Actually, there were two very early higher level languages, Fortran and Lisp Fortran was an imperative language, and became mainstream Lisp was a functional language, with fewer followers
Both languages had many descendants Fortran: C, Algol, Pascal, Python, etc., plus modern versions
of Fortran Lisp: Erlang, Haskell, OCaml, etc., plus modern versions of
Lisp (such as Clojure)
2
Why did Fortran pull ahead?
Fortran was slightly earlier in time A great deal of work was put into optimizing Fortran, so
that it could compete with assembly language Fortran was (and is) better for heavy number crunching,
which made it more suitable for military uses
3
The Lisp influence
“All languages converge to Lisp.” -- Anonymous Modern languages all contain many features that originated in Lisp
What did Lisp have that Fortran didn’t? Recursion Automatic garbage collection Data structures other than arrays
What does Lisp have that Java 7 still doesn’t? Functions (not the same as methods!) Ability to treat functions as values Immutable (persistent) data structures Macros
C has “macros”, but they are difficult and badly integrated into the language Homoiconicity
4
Functions as values
All modern languages have recursion, automatic garbage collection (except C++), and a variety of data structures
Many languages now have the ability to treat a function as an ordinary value (like an integer or a string) There is a way to write a “literal” (anonymous) function Functions can be stored in variables and in collections Functions can be passed as parameters to functions Functions can be returned as the result of a function There are operators to combine functions into new functions
5
Functions in FP languages
Given a set of input values, a function produces an output value Given the same input values, a function always produces the same output
value Functions can use only the information provided by their parameters This excludes “functions” that return the date, the time, or a random number
Functions have no side effects Functions don’t do input or output Functions don’t change the values of any variables or data Functions only return a value
Consequently, functions are easier to reason about To understand a function, you need examine only the function itself A function can use other functions, and of course you need to know what
those functions are supposed to compute (but nothing about how they do it) In addition, functions can be called in any order, including in parallel
6
Immutable and persistent data structures
An immutable data structure is one that, once created, cannot be modified Immutable data structures can (usually) be copied, with modifications, to create a
new version The modified version takes up as much memory as the original version If all data is immutable, we may need infeasible amounts of memory
A persistent data structure is one that, when modified, retains both the old and the new values Persistent data structures are effectively immutable, in that prior references to it do
not see any change Modifying a persistent data structure may copy part of the original, but the new
version shares memory with the original
We generally talk about functional programming as having immutable data, but really it’s persistent
7
Lists
Lists are the original persistent data structures, and are very heavily used in functional programming
x zy
[x, y, z]
w
[w, x, y, z] [y, z]
The tail of [x, y, z] is [y, z].
Adding an element w to [x, y, z] doesn’t change [x, y, z] itself.
Immutable values
Fundamental to functional programming is that all data is immutable or persistent You can only compute new data from it Structure sharing makes this feasible
Consequences: Lists, not arrays, are the fundamental data structure
Arrays are designed for random access; lists are designed for working from one end
Complex data structures can be built more easily from lists thanfrom arrays
Recursion replaces loops as a fundamental “control structure” You never need to protect data with mutexes (locks)
9
“No silver bullet”
There are language zealots that will try to convince you that some particular language (usually Lisp) will solve all the worlds problems.
If Lisp is so great, why isn’t everybody using it?
In a sense, both Lisp and Prolog are “perfect,” or nearly so Both are direct computer implementations of beautiful mathematical
structures Both are extremely powerful in certain domains
“In theory, there is no difference between theory and practice. But in practice, there is.” -- Jan L. A. van de Snepscheut
Functional programming will not solve all the world’s problems, but… It solves an awful lot of problems when doing concurrent programming It provides some really nice tools even when you aren’t doing concurrent
programming
10
Working with lists
Arrays:Loop over the array, doing something with each element in turn
Lists:Do something with the head, and recur with the tail
Head: The first element in the list Tail: The list that remains when you step past the head.
Occasionally you may need to work at the “wrong end” of a list General solution: Reverse the list, work at the head, and reverse the result
11
Basic list operations
There aren’t very many Get the head of the list (hd in Erlang) Get the tail of the list (tl in Erlang) Add a new element E to the list L ([E|L] in Erlang) Test if a list is empty (L==[] in Erlang)
12
Recursion on lists
Basic strategy:1. Return some value if the list is empty
2. Do something with the head
3. Recur with the tail
Finding the length of a list (Do It Yourself version): myLength([]) -> 0;
myLength([_|T]) -> 1 + myLength(T).
Again, but with tail recursion: myLengthTR(List) -> myLengthHelper(0, List).
myLengthHelper(Acc, []) -> Acc;myLengthHelper(Acc, [_|T]) -> myLengthHelper(Acc + 1, T).
13
Standard higher-order functions
A higher-order function is a function that (1) takes a function as a parameter, or (2) returns a function as its value, or both
map(Fun, List) Applies Fun to each element of List, returning a list of the results. The result may contain values of a type different that those in List .
filter(Pred, List) Returns a list of the elements of List that satisfy the predicate Pred. The result will be a sublist of List .
The following standard function comes in a variety of flavors—whether it works left to right or right to left, and whether it needs an explicit accumulator
foldl(Fun, Acc, List) Calls Fun on successive pairs of elements of List , starting with Acc The type returned is the type of Acc
14
More higher-order functions
all(Pred, List) any(Pred, List) takewhile(Pred, List) dropwhile(Pred, List) flatten(DeepList) flatmap(Fun, List) foreach(Fun, List) partition(Pred, List) zip(List1, List2) unzip(List)
15
takewhile in Java Suppose you have a list of numbers, and you want a new list consisting of
only the positive numbers at the beginning of the given list List newList<Integer> = new LinkedList<>();
for (int e : oldList) { if (e <= 0) break; newList.append(e);}
That’s not as easy as takewhile(fun(X) -> X > 0 end, List)but you can work through it without too much difficulty
Suppose you also want to get only the even numbers at the beginning, or only the prime numbers, or only ones less than 100
You cannot reuse the above Java code; you have to do it all over again!
16
Loop elimination
Good code is clear and easy to understand takewhile(fun(X) -> X > 0 end, List)
is clear and easy to understand (once you know the syntax) Loops always need to be worked through in order to understand them
(well, almost always) for (int i; i < array.length; i++) array[i] = 0;
is pretty clear
Functional programming languages typically provide quite a few very useful higher-order functions
In a lot of cases, these functions can replace loops FP languages may also provide list comprehensions, which again are
clearer than loops, and can often replace them When all else fails, loops can be replaced by recursion, which is
(arguably) no harder to understand than loops
17
Functions that return functions
Erlang has a built-in version of quicksort, but you could write your own:
quicksort([]) -> [];quicksort([H | T]) -> quicksort( [ X || X <- T, X < H ]) ++ [H] ++ quicksort([ X || X <- T, X >= H ]).
But what if you wanted to sort something other than numbers, say, student records?
The key point to notice is that X < H (and X >= H, which is really just not(X < H)) is just a binary predicate
You could rewrite this function to pass in some binary predicate You could also write a function that takes in just a binary
predicate, and returns a sort function18
Summary
In a functional language, especially a “pure” one, you lose: Global variables The ability to change the values of variables The ability to write loops
You gain: The ability to treat functions just like any other values A useful set of higher-order functions More ways to avoid code duplication (DRY) Far better ways to deal with concurrency
19