# Why do you use `(flip andThen)`?

TLDR; To use it with the pipe (`|>`) operator.

## The actual `andThen` problem

Here is the signature for `Task.andThen`:

```elm
import Task exposing (andThen)
andThen : Task x a -> (a -> Task x b) -> Task x b
```

Now, imagine two (or more) tasks, where the second needs the result of the first one to proceed:

```elm
taskOfA : Task x a
taskOfB : a -> Task x b

```

The official way to compose them is using `andThen` as an operator (using backticks `):

```elm
doAthenB : Task x b
doAthenB =
 taskOfA `andThen` (\a ->
    taskOfB a
    )

-- Equivalent to:
doAthenB =
  taskOfA `andThen` taskOfB

-- Equivalent to:
doAthenB =
  andThen taskOfA taskOfB
```

But, **we prefer to use the pipe operator** because:

- Most elm functions take a function to call, then the data (`List.map : (a -> b) -> List a -> List b`)
- The pipe operator works great those functions 
- It's arguably more readable and saves you some parentheses

For context, the signatures for the pipe operator, and flip:

```elm
-- Imported from Basics by default
(|>) : a -> (a -> b) -> b
flip : (a -> b -> c) -> b -> a -> c
```


And when we want to use pipe, there is a problem in the order of the andThen function:

```elm
doAthenB =
  taskOfA |> (\a -> andThen taskOfB a)
```

So we use flip, which flips the first and second parameters of the given function:

```elm
doAthenB =
  taskOfA |> (flip andThen) taskOfB
```