With Swift 2.0 the flatMap function on `SequenceType`

has been introduced. It seems to me that a lot of developers are confused about this function and what it does and what are the differences between it and the map function. In this post i will try to confuse you a bit more about the flatMap function.

**Back to the roots**

In the pure functional programming there is a clear definition of flatMap

`flatMap:([A],(A -> [B])) -> [B]`

. It takes a list of elements of type A and a function `A -> [B]`

that produces a list of B for each element of the original list. In the first step flatMap applies the function f on each element of the list (exactly as map) producing a list of lists of type B. In the second step it combines the inner lists producing a flattened list of type B. For example (pseudocode)

let list:[Int] = [1, 2, 3] let f(x: Int) -> [Int] = [x, x+1] list.flatMap(f) //would produce this list [1, 2, 2, 3, 3, 4]

## The Swift implementation

I think the root of the confusion comes because Swift introduces two overloaded implementations of the flatMap function in `SequenceType`

.

The first one looks like (a little bit simplified):

extension SequenceType { public func flatMap(transform: (Self.Generator.Element) -> T?) -> [T] { var result: [T] = [] for element in self { if let newElement = transform(element) { result.append(newElement) } } return result } }

This implementation is very similar to the map function with some small differences. The function used for the transformation returns an optional of T and because of the statement

if let newElement = transform(element)

the transformed elements are unwrapped and just appended to the result list if they are not nil.

The second implementation is defined as following (a little bit simplified):

extension SequenceType { func flatMap<S : SequenceType>(transform: (Self.Generator.Element) -> S) -> [S.Generator.Element] { var result: [S.Generator.Element] = [] for element in self { result.appendContentsOf(transform(element)) } return result } }

This is the Swift implementation of flatMap that fits to the definition in the functional programming i mentioned earlier. In this case, the transformation function returns a sequence. flatMap the combines the resulting sequences to one sequence using `appendContentsOf`

Consider the following Swift example:

let list:[Int?] = [1, nil, 3] let result = list.flatMap{$0} print(result) // would prints [1, 3]

Because the transformation function, in this case `$0`

returns one element and not a sequence, the compiler picks the **first** implementation of flatMap and cuts the nils from the result.

Now consider an another Swift example:

let list:[Int] = [1, 2, 3] let result = list.flatMap{ x in [x, x+1]} print(result) // would prints [1, 2, 2, 3, 3, 4]

Because the transformation function, in this case `x in [x, x+1]`

returns a sequence, the compiler picks the **second** implementation of flatMap and returns a transformed and flattened sequence.

## Still not confused enough?

Then have a look at the flatMap implementation in the ReactiveX programing for example in RxSwift. The definition there is:

transform the items emitted by an Observable into Observables, then flatten the emissions from those into a single Observable