Example code: map.erl, filter.erl

Anonymous Functions

Many languages, including Clojure, Scala, and Ruby, have the ability to define “anonymous” blocks of code. An important use of such code blocks is to transform a series of values from a collection (e.g., passing an anonymous function to the Clojure map function.)

Erlang supports anonymous functions. Because Erlang is dynamically-typed, an anonymous function can be assigned to a variable (Clojure allows this as well). You can think of an anonymous function as being a value, in much the same way that numbers, lists, and tuples are values in Erlang. Like all other values, they can be passed to functions and returned from functions.

Example:

1> Add1 = fun(N) -> N+1 end.
#Fun<erl_eval.6.80247286>
2> Add1(3).
4

Here, we defined a function of one parameter N that adds 1 to its parameter and returns the result.

More interesting example:

3> AddN = fun(N) -> fun(X) -> N+X end end.
#Fun<erl_eval.6.80247286>
4> Add12 = AddN(12).
#Fun<erl_eval.6.80247286>
5> Add12(11).
23

In this example, the AddN function takes a parameter N and returns a function that adds N to its parameter X. By calling AddN with the argument value 12, we create a function that adds 12 to its parameter.

The concept of returning a function from a function is called currying.

Transforming Lists

Anonymous functions can be applied to lists to select or transform the values in the list.

One way to transform a list is to map a function onto each element of the list, producing a list of transformed values as a result.

Here is a possible implementation of a map function:

-module(map).
-export([map/2]).

map(_, []) -> [];
map(F, [First|Rest]) -> [F(First) | map(F, Rest)].

The implementation is quite simple. The base case is an empty list, where the result is simply the empty list. In the recursive case, the function F is applied to the first element of the list, and prepended onto the list that results from recursively applying F to the rest of the list.

Testing it on a list:

8> map:map(fun(N) -> N*2 end, [1, 2, 3]).
[2,4,6]

Note that the implementation of map above is not tail-recursive. Here is a tail-recursive version:

-module(map).
-export([map/2]).

mapwork(_, [], Accum) -> lists:reverse(Accum);
mapwork(F, [First|Rest], Accum) -> mapwork(F, Rest, [F(First)|Accum]).

map(F, L) -> mapwork(F, L, []).

Because the accumulator builds the result list with the transformed elements in reverse order, we apply the built-in lists:reverse function before returning the final result.

Another useful list-transformation technique is filtering a list to retain or discard elements matching a specified predicate:

-module(filter).
-export([retain/2, discard/2]).

filterwork(_, [], _, Accum) -> lists:reverse(Accum);
filterwork(F, [First|Rest], Keep, Accum) ->
  Test = F(First),
  if
    (Test and Keep) or (not Test and not Keep) ->
       filterwork(F, Rest, Keep, [First | Accum]);
    true -> filterwork(F, Rest, Keep, Accum)
  end.

retain(F, List) -> filterwork(F, List, true, []).

discard(F, List) -> filterwork(F, List, false, []).

Examples of using these functions:

18> filter:retain(fun(N) -> N > 4 end, [1, 2, 3, 4, 5, 6, 7, 8]).
[5,6,7,8]
19> filter:discard(fun(N) -> N > 4 end, [1, 2, 3, 4, 5, 6, 7, 8]).
[1,2,3,4]

Built-in versions

It’s interesting to build our own list-transformation functions, but in practice it’s better to use the built-in implementations, which are list::map, lists:takewhile, and lists:dropwhile.

List Comprehensions

List comprehensions are a concise syntax for describing transformations of one or more lists.

In the following examples, the variable List is defined as:

List = [1, 2, 3, 4, 5, 6, 7, 8].

Example: double each element in a list:

26> [N * 2 || N <- List].
[2,4,6,8,10,12,14,16]

Read this as “select elements N from List, and generate a new list by adding elements of the form N*2”.

Example: get all elements greater than 4:

27> [N || N <- List, N > 4].
[5,6,7,8]

Here, we’ve specified an additional clause N>4 to restrict which elements of List are used to generate the result list.

Example: double all elements greater than 4:

28> [N*2 || N <- List, N > 4].
[10,12,14,16]

In this example, we both selected and transformed the input list.