<https://en.wikipedia.org/wiki/Continuation-passing_style> says

> 
> A function written in **continuation-passing style** takes an extra
>  argument: an explicit "continuation", i.e. a function of one argument.
>  When the CPS function has computed its result value, it "returns" it
>  by calling the continuation function with this value as the argument.
>  That means that when invoking a CPS function, the calling function is
>  required to supply a procedure to be invoked with the subroutine's
>  "return" value. Expressing code in this form **makes a number of things
>  explicit** which are implicit in direct style. These include: **procedure
>  returns**, which become apparent as calls to a continuation;
>  **intermediate values**, which are all given names; **order of argument
>  evaluation**, which is made explicit; and **tail calls**, which simply call
>  a procedure with the same continuation, unmodified, that was passed to
>  the caller.
> 
> 
> 

How shall I understand that a function written in CPS "**makes a number of things explicit**", which include "**procedure returns**", "**intermediate values**", "**order of argument evaluation**", and "**tail calls**"?

For example, it seems to me that a function written in CPS makes the return value of the function implicit instead of explicit to the caller of the function.

For example in Haskell, a function not in CPS is

```hs
add :: Float -> Float -> Float
add a b = a + b

```

while it is written in CPS as:

```hs
add' :: Float -> Float -> (Float -> a) -> a
add' a b cont = cont (a + b)

```

Examples in Scheme are similar.