Lisps are not in this camp by default, but in Clojure it's idiomatic to use the threading function to achieve a similar effect. For example,

  (inc (inc (inc 1)))

can be written

  (-> 1 inc inc inc)

(`inc` increments a number by one)

There are also several languages that allow method chaining. I.e.,

  thing.inc().inc().inc()

This is called Reverse Polish Notation. Forth uses it, as do a few other interesting languages.

Sure - they are called stack-based or concatenative languages (although they don't actually have to use stacks for implementation):

https://en.wikipedia.org/wiki/Stack-oriented_programming

The historically interesting/successful ones are mainly Forth and PostScript, but there are some successors of interest such as Joy.

Shell pipes are like this. Elixir took inspiration from it for its |> operator, although it works only for the first argument. You should check it out!

Factor works like that. It's dynamically typed and meta-programmable like Lisp and uses a global stack like Forth to pass data. By writing everything "backwards" (x) you get a syntax that is much more regular than what is possible in languages with Algol-like or even Lisp-like syntax. The language website is here https://factorcode.org/ It has a lot more code samples.

x - Of course, what is "backwards" and what is "forwards" is up to the reader. I'd argue that foo(arg) is backwards because we think of the expression as "arg processed by foo" Since arg comes before foo, it should be placed to the left of foo in the syntax.

Elixir has the pipe notation, which is somewhat similar