I have had some Rust stuff to do lately and I find myself looking for the functional pipe-able patterns there as well (which they have in e.g. Iterator where you can do .map(...).fold(...) etc.). 
I generally agree with your entire comment minus one exception: OOP usually goes hand-in-hand with imperative programming with shared mutable state which, finally, our profession begins to understand is a cause for countless bugs and weird behaviour and many language ecosystems started actively working against those and are trying to have more immutability.
I, like you, believe that the misrepresentation – and the subsequent abuse of – the idea of OOP has done it disservice but I also think it’s too late to change that now. OOP + imperative code + shared mutable state must mostly be made irrelevant in one form or another – that’s the only way to “kill” the horrifying spaghetti monsters that I had to tackle in Java years ago.
This is not just some hate; Rust for example still gives you polymorphism (so OOP) and is imperative by nature but, unlike most other languages out there, it enforces memory ownership so at least the mutable shared state is gone there (which is the main villain in this trio).
I believe we are currently living in some kind of a programming Renaissance when people finally started wanting their machines working for them and not the other way around. 
I am quite excited for Multlicore OCaml (it’s a very fine language!) and any possible final touches on Rust’s async/await situation – those two languages are extremely good and strong contenders for taking the crown from C++ (as for C, sadly it looks like it’ll be around seemingly forever). And even though I do dislike JS quite a bit I’m also happy seeing they are working towards immutability and multi-threading (workers / worklets) – although I fear JS will be, as usual, the last to arrive. But hey, any improvement is welcome!
Things are, in general, going in a good direction IMO.
