- foreach(f, xs)
- map(f, xs)
- filter(f, xs)
- reduce(f, v0, xs)
- foldl(f, v0, xs)
- foldr(f, v0, xs)

Functions can be accepted as parameters and can also be produced as return types. Indeed, functions can be created inside the body of other functions. These inner functions are known as closures.

Functions are objects in Julia. Like any other objects, they can be passed as arguments to other functions. Functions that accept functions are known as higher-order functions.

For instance, we can implement an equivalent of the standard library's `foreach`

function by taking a function `f`

as the first parameter.

```
function myforeach(f, xs)
for x in xs
f(x)
end
end
```

We can test that this function indeed works as we expect:

```
julia> myforeach(println, ["a", "b", "c"])
a
b
c
```

By taking a function as the *first* parameter, instead of a later parameter, we can use Julia's do block syntax. The do block syntax is just a convenient way to pass an anonymous function as the first argument to a function.

```
julia> myforeach([1, 2, 3]) do x
println(x^x)
end
1
4
27
```

Our implementation of `myforeach`

above is roughly equivalent to the built-in `foreach`

function. Many other built-in higher order functions also exist.

Higher-order functions are quite powerful. Sometimes, when working with higher-order functions, the exact operations being performed become unimportant and programs can become quite abstract. Combinators are examples of systems of highly abstract higher-order functions.

Two of the most fundamental higher-order functions included in the standard library are `map`

and `filter`

. These functions are generic and can operate on any iterable. In particular, they are well-suited for computations on arrays.

Suppose we have a dataset of schools. Each school teaches a particular subject, has a number of classes, and an average number of students per class. We can model a school with the following immutable type:

```
immutable School
subject::Symbol
nclasses::Int
nstudents::Int # average no. of students per class
end
```

Our dataset of schools will be a `Vector{School}`

:

```
dataset = [School(:math, 3, 30), School(:math, 5, 20), School(:science, 10, 5)]
```

Suppose we wish to find the number of students in total enrolled in a math program. To do this, we require several steps:

- we must narrow the dataset down to only schools that teach math (
`filter`

) - we must compute the number of students at each school (
`map`

) - and we must reduce that list of numbers of students to a single value, the sum (
`reduce`

)

A naïve (not most performant) solution would simply be to use those three higher-order functions directly.

```
function nmath(data)
maths = filter(x -> x.subject === :math, data)
students = map(x -> x.nclasses * x.nstudents, maths)
reduce(+, 0, students)
end
```

and we verify there are 190 math students in our dataset:

```
julia> nmath(dataset)
190
```

Functions exist to combine these functions and thus improve performance. For instance, we could have used the `mapreduce`

function to perform the mapping and reduction in one step, which would save time and memory.

The `reduce`

is only meaningful for associative operations like `+`

, but occasionally it is useful to perform a reduction with a non-associative operation. The higher-order functions `foldl`

and `foldr`

are provided to force a particular reduction order.

This modified text is an extract of the original Stack Overflow Documentation created by following contributors and released under CC BY-SA 3.0

This website is not affiliated with Stack Overflow

Email: [email protected]