# What the FlatMap?

Understand flatmap in RxJava

The operator flatmap in RxJava is a tough topic if you are not familiar with functional style.

After reading all the articles and tutorials and even worked with RxJava for almost a year, I’m still not quite confident about it. I sure know how to and when to use it, but the understanding seems always shallow.

Until I read the flatmap in the Structure and Interpretation of Computer Programs.

The key is to understand the word flat.

# FlatMap in the SICP book

Let me give the context when the flatmap is introduced in the SICP book.

First let’s define the function accumulate.

(define (accumulate op init seq)
(if (null? seq)
init
(op (car seq) (accumulate op init (cdr seq)))))

This is a very simple procedure that generate one value out of a sequence, by using some operation.

For example:

(accumulate + 0 (list 1 2 3 4))

=> 10

Now we have everything ready to define the flatmap procedure.

(define (flatmap proc seq)
(accumulate append '() (map proc seq)))

proc is a procedure that returns a sequence.

append just concats two lists together like

(append (list 1 2 3) (list 4 5 6))

=> (1 2 3 4 5 6)

We can describe the process of flatmap as follows:

;; the original list
(1 2 3)

;; map to a new list of lists
((1 1 1) (2 2 2) (3 3 3))

;; flatten out
(1 1 1 2 2 2 3 3 3)

# FlatMap in RxJava

You can think of the streams in RxJava as lists in SICP. Just streams feels more dynamic, and lists feels more static. The concept is now much easier to understand.

Since streams and lists are very similar, we can apply the same idea to streams.

;; the original stream
<1, 2, 3, end>

;; map to a new stream of streams
<<1,1,1,end>, <2,2,2,end>, <3,3,3,end>>

;; flatten out
<1, 1, 1, 2, 2, 2, 3, 3, 3, end>

Note that one item in the original stream 1, is mapped to a new stream <1, 1, 1, end>.

Even though this is what flatmap really means, it is not the most common usecase.

The most common usecase is a special case of it, that is to map the item in the original stream to a new stream of one item.

;; the original stream
<1, 2, 3, end>

;; map to a new stream of streams
<<a, end>, <b, end>, <3, end>>

;; flatten out
<a, b, c, end>

This is where people got it confused with map, because from the outside look it seems that we map the <1, 2, 3, end> to <a, b, c, end>, but they are totally different processes.

One thing to be careful is the ordering of the items in the flattened stream, since streams emits items asynchronously, when flattened out, the ordering is not garanteed if we use flatmap in RxJava. So to be techniquely correct, in the above example we should use concatmap.