# Transforming the Future

A few weeks ago we talked about the type Future and its use to create asynchronous calls.

We saw how to work with blocking calls to obtain the value of the future. We also used callbacks in order to obtain the result of the future asynchronously. However, there are some issues that were left unsaid. And by that I’m referring to transforming the Future without blocking the execution.

### Future transformations

In order to transform futures, as with other Scala basic types, mainly two methods are used: map and flatmap.

#### Map method

Map method allows us to change the content of a future by applying a function. For instance, if we have a method to get the first million prime numbers but we want to transform it to return just the first hundred ones, we can apply the map method in the following way:

```def getFirstMillionOfPrimes(): Future[List[Int]] = ???

getFirstMillionOfPrimes().map(
(list: List[Int]) => list.take(100)
)
```

This way we will be transforming the inside of the future without breaking the asynchrony.

#### FlatMap method

On the other hand, the flatMap method allows us to apply a function to the content of the future and returning a future in turn. After that, a flatten operation is applied to convert the Future[Future[A]] into a simple Future[A]. What the f…? Better explained with an example.

Imagine we want to concatenate the first million prime numbers in a string. To do so, we’ll use a new method:

```def concatenate(l: List[Int]): Future[String] = ???
```

and now we perform a  flatMap

```getFirstMillionOfPrimes().flatMap(
(list: List[Int]) => concatenate(list)
) //Future[String]
```

### And how can we do all this in a more simple way?

Easy question. For comprehension to the rescue! With a spoonful of syntactic sugar we can write a much more readable code.

```for {
primes <- getFirstMillionOfPrimes()
primesString <- concatenate(primes)
} yield primesString
```

This way, the concatenation operation won’t be applied until the prime numbers are obtained with the method getFirstMillionPrimes.

This allows us to keep an order when composing asynchronous calls. Besides, if the first asynchronous call fails, the second won’t be conducted.

And that’s all for today. Now you know how to change the future. What a shame not to be able to change the past 😦

See you soon!

Anuncios