I really like the current trend in `Base`

of functions that take a function as their first argument, and have been adopting it for my own code. My question is: If I define the no-op function

```
f(x) = x
```

can I happily pass this into other functions of the form:

```
function f1(f::Function, x1, x2, ...)
... #some stuff
z1 = f(x)
... #some other stuff
end
```

and get *zero* efficiency loss versus the case where I don’t include a function as an argument?

My understanding is that in the above pseudo-code, the `z1 = f(x)`

is compiled down to `z1 = x`

, and so this is indeed the case, but I wanted to double-check before adopting this style wholesale. (yes I did try looking at `code_lowered`

type output, but managed to quickly confuse myself, and also wasn’t certain if what I was seeing would hold up in more complex cases).

Bonus question: does julia have a standard no-op function for use in cases like this, eg say if I wanted to define the shortcut method:

```
f1(x1, x2, ...) = f1(Base.f_noop, x1, x2, ...)
```

Thanks to all responders,

Colin