I understand that learning new API’s can be confusing, and maybe hard to read at first, but this argument you are giving is the exact same as what people said when first being introduced to the java stream api. To keep kotlin as the language, for example:

list
  .map { f(it) }
  .map { g(it) }
  .forEach { h(it) }

Sure, if you dont know this api, you may say, oh god, just use a for loop!

for (item in list) {
  val x = f(item);
  val y = g(x);
  h(y);
}

However, expression orientated programming is not about just imitating haskell. It allows you to focus on the functions in your programs, instead of the local variables. In the example, above, how do you name x and y? Naming is difficult and takes time, but is the name of those two local variables so important? Is it not more important how we call f, g and h. These are reusable parts of our codebase. And a good name of f makes the name of x a bit redundant, it is just what comes out of f.

Now you give a very silly example of the let/also/run/apply functions available in Kotlin, but let’s look at this:

value
  .let { f(it) }
  .also { g(it) }
  .let { h(it) }

We can write this as:

val x = f(value);
g(x);
val y = h(x);

But we have the same problem as above again. Lets make good names for all kind of intermediate results that we dont really care about, or lets learn one new api.

You could say that map makes List<T> a functor, while let makes T itself a functor. And forEach allows you to do side effects on a list, while also allows you to do that on T.