# A useful function that does nothing

ReturnTrue series:

1. A useful function that does nothing
2. What is NaN in JavaScript?

The goal is not to show the answers but to dive deep into the elaborate internals of JavaScript and browsers. Yet, we recommend you try to find solutions yourself. It would be more interesting this way, be sure.

Alright, the disclaimer is over. Let’s continue with an introduction explaining what ReturnTrue is.

## Introduction

ReturnTrue is a set of puzzles. Each of them is a tricky function. You should pass arguments to such a function, and the result of its evaluation should be `true`. Not “truthy value”, but exactly `true`.

Erling Ellingsen, a programmer from Norway, created the game more than six years ago. Kudos to him and all the contributors!

Finally, let’s start.

## ID

``````function id(x) {
return x;
}``````

Easy. The main goal of this task is to explain the rules.

The solution is obvious:

``id(true)``

The game assumes that the shorter solution the better. What is shorter than `true`? Not-zero!

``id(!0)``

## But wait, why is it called “id”?

The title “id” here is not by accident. There is a mathematical term called identity function. It is a function that returns its argument without changing it.

To explain when we may use it, let’s assume we want to go through an array of numbers and increase each odd value by 1. Here is how it may look in JavaScript:

``arr.map(x => x % 2 ? x + 1 : x)``

But even though we use `map` here, the code is not “functional” enough. In functional programming, it is more common to use functions, not statements. In other words, programmers say what to do, not how. They are trying to be declarative, not to be imperative.

So, if our code was truly functional, it would look like this:

``map(arr, when(isOdd, inc, id))``

Here you can see a typical functional way to process data. We pass data to a pipeline, which transforms it, and returns the result. No more of those nasty statements, my precious!

Usually, a functional programming language has the functions like those we used. For instance, Clojure has identity, F# has id, Elixir has identity/1, and so on.

But, JavaScript was not designed as a pure functional language. So, their implementation may look like this:

``````const isOdd = x => x % 2 === 1;
const inc = x => x + 1;
const id = x => x;
const when = (cond, thenFn, elseFn) => x => cond(x) ? thenFn(x) : elseFn(x);
const map = (xs, fn) => xs.map(fn);``````

And now you see when the function returning its argument may be handy.

## Do we need such a function?

Yeah, it may look weird in the context of front-end development. One may even say that `id` function is a kludge from FP world.

Sure, it may sound like a joke or a “bug” of programming language design. First, you define functions that can not be evaluated without passed arguments (e.g. `when` function we defined above). Then, you define more functions to use them as a sticky patch for the previously defined.

However, the functional programming paradigm is trying to be as close as possible to math. `id` function is a normal thing in this field of science.

It may not be obvious why exactly we need such a function. But, when we work with numbers, we use some special ones like 0 or 1. When we work with arrays, the special one is an empty array. When we work with functions, we need a “special” one too. It is `id`.

It may look like overhead sometimes, and you may think: "Why not define `when` function another way, where `elseFn` will not be required?". Sure, it’s possible. But explicit is better than implicit. 