Todayâ€™s article is about doing some fun with Swift functions, like functions returning functions, currying and operators on functions.

## Functions basics

In this post weâ€™ll use functions that takes a `Int`

and return a `Bool`

telling if it matches a certain criteria. This kind of functions can then be used with `filter`

to filter an array of integers.

So letâ€™s start with a simple one, a function that tells if a number is positive:

```
func isPositive(value: Int) -> Bool {
return value > 0
}
[-4,-2,0,4,7,-8,3].filter(isPositive)
// returns: [4,7,3]
```

## More generic functions

Now what if we want to have a function that returns true if the number is a multiple of N? Sure we could write one function for `isEven`

, one for `isMultipleOf3`

, `isMultipleOf4`

â€¦ but where to end?

Of course, a better solution is to have a function that takes that `N`

as a parameter. But then if we write this, `filter`

wonâ€™t like it:

```
func isMultiple(multiple: Int, value: Int) -> Bool {
return value % multiple == 0
}
[-4,-2,0,4,7,-8,3].filter(isMultiple)
// Error: filter expects Int->Bool and we gave it (Int,Int)->Bool instead
[-4,-2,0,4,7,-8,3].filter(isMultiple(3))
// Error: can't call `isMultiple` with only one parameter, it expects two
```

## Functions returning Functions

So what we really want is a way to generate a new `Int -> Bool`

function (that will fit what `filter`

expects) given a multiplier value. So letâ€™s write exactly that: a function that takes a `(multiplier: Int)`

and returnsâ€¦ another function, of type `Int -> Bool`

.

There is multiple ways to do that, the first being to declare a `Int -> Bool`

function *inside* our `isMultiple`

function, and return that inner function:

```
func isMultiple(multiplier: Int) -> (Int -> Bool) {
func multFunctionToReturn(value: Int) -> Bool {
return value % multiplier == 0
}
return multFunctionToReturn
}
```

Here the inner function â€ścapturesâ€ť the `multiplier`

parameter provided by the outer function to generate a tailored function and return it.

But the more common (and compact) way is to use closures instead. In Swift, functions and closures are interchangeable, so letâ€™s directly return a closure of type `Int -> Bool`

:

```
func isMultiple(multiplier: Int) -> (Int -> Bool) {
return { (value: Int) -> Bool in
value % multiplier == 0
}
}
```

## Currying^{1}

There is actually a third way to achieve that: using *currying*. Currying is the idea of transforming a function that takes multiple parameters into a function that takes one parameter and returns another function (which in turn takes the next parameter and return a functionâ€¦ until all parameters have been consumed and it returns the final value). This technique allows you to do partial application of a function, which can be very powerful and useful in some cases.

In Swift, we can very easily change a method with multiple parameters into a currying method, by replacing commas separating the parameters with a closing parenthesis immediately followed by a reopening one^{1}. So letâ€™s reuse our very first implementation of `isMultiple`

but transform that into a currying function:

```
func isMultiple(multiplier: Int)(value: Int) -> Bool {
return value % multiplier == 0
}
```

This syntax may be a bit disturbing, so I personally prefer explicitly using a function returning a function (like in the previous paragraph), as in the end this currying form is exactly equivalent to this (which I find more explicit):

```
func isMultiple(multiplier: Int) -> (value: Int) -> Bool {
return { value in value % multiplier == 0 }
}
```

But in the end itâ€™s up to you to use the syntax you prefer.

[EDIT on 01 Feb. 2016]

đźš¨A proposition to remove this currying syntax in Swift 3.0 has been accepted since this blog post, so this`(x: T)(y: U)`

syntax will no longer be valid soon. One more reason not to use it and to prefer using`(x: T) -> (y: U)`

instead!

## Combining functions

What could be nice next is to combine those filters, to generate a new filter from it. For example, now that we have `isPositive`

and `isMultiple`

, how could we filter every number that are both positive and even?

Of course we could filter twice, like this:

```
[-4,-2,0,4,7,-8,3].filter(isPositive).filter(isMultiple(2))
```

But thatâ€™s not very efficient since it makes the code loop twice into the array. And moreover, it could also be interesting to have numbers that are *either* positive or even, and we wouldnâ€™t have a nice syntax for that, but only this:

```
[-4,-2,0,4,7,-8,3].filter { value in isPositive(value) || isMultiple(2)(value) }
```

Wouldnâ€™t it be cool instead to generate a new function by combining two `Int -> Bool`

functions? It would indeed feel more natural to write something like this:

```
[-4,-2,0,4,7,-8,3].filter(isPositive || isMultiple(2))
```

Well, letâ€™s make that possible!

The `&&`

and `||`

operators already exist, so we just need to override them so they supports taking `Int -> Bool`

functions as a parameter:

```
func || (lhs: Int->Bool, rhs: Int->Bool) -> (Int->Bool) {
return { (value: Int) -> Bool in
return lhs(value) || rhs(value)
}
}
```

We could also do the same for `&&`

. Letâ€™s use a more compact syntax for this one, using implicit `$0`

parameters, to vary the examples:

```
func && (lhs: Int->Bool, rhs: Int->Bool) -> (Int->Bool) {
return { lhs($0) && rhs($0) }
}
```

What about also having a way to negate a function, by overloading the prefix `!`

operator too?

```
prefix func ! (f: Int->Bool) -> (Int->Bool) {
return { value in !f(value) }
}
```

And now we could even write:

```
[-4,-2,0,4,7,-8,3].filter( !isPositive || isMultiple(3) )
// return [-4,-2,0,-8,3] (non-positive numbers + multiples of 3)
```

Isnâ€™t that beautiful?

One could even declare those shorthand aliases for negative and odd/even filters:

```
let isZero = { value in value == 0 }
let isPositiveOrZero = isPositive || isZero
let isNegative = !isPositive && !isZero
let isNegativeOrZero = !isPositive
let isEven = isMultiple(2)
let isOdd = !isEven
```

And this works like expected, even if those are functions, thanks to our overloading above!

## Conclusion

So with those simple tricks, you learned how having functions returning functions can be useful, how we could imagine some operators to combine functions returning `Bool`

the same way we wouldâ€™ve combined `Bool`

directly, and were introduced to the concept of currying.

There is a lot more fun we could have with function. We could have made those overload of `&&`

,`||`

and `!`

generic, so that it would work with any `T->Bool`

functions whatever the type of `T`

is for example. I could even talk about using currying to its full power, go crazy with Functional Programming and all (but a lot of other blogs do that already, so no need for another one here I guess), but I think thatâ€™ll be enough for today!

Happy Swifting all!