Agreed. Some functional languages (like F#) have a pipelining operator |> that gives the same syntactic impression:

    list |> map (1+) |> filter odd |> sum

I have found myself using pipes many times in Elm, because they make the code so much more readable. Now I understand why!

I haven't seen an autocomplete that works on pipes. But with a good type system, it is technically possible to list all compatible functions that take "noun" as first parameter.

Sometimes you supply partially applied functions (also with pipes in noun->verb order) and that's not so easy to match:

noun |> verb1 |> (otherNoun >> verb2) |> etc

But perhaps even functions that take "noun" as nth parameter could be suggested.

And other languages, such as Forth; don't need one.

    list map filter odd sum

Huh. I would've expected it to be `odd filter`, not `filter odd`.

Interestingly enough, the now standard data manipulation package in R, dplyr, uses pipelines.

Good to learn me some F#, looks like Elixir.

If verbs from the object flowing you want, "That style to me is preferable" you should say. (Style is the object, preferring it is the verb)

English reads left to right overall, but writing instructions in English does not flow smoothly either way. e.g. "shuffle a deck of playing cards then deal four" reads more naturally than either "a deck of playing cards shuffle then four cards deal" or "deal four cards after shuffling a deck of playing cards".

shuffle(cards).deal(4) is a mix of both approaches.

Yes yes, english doesn't follow this noun-verb order but that's not what I'm actually talking about.

Usually the languages either encourage cards.shuffle().deal(4) or deal(shuffle(cards),4).

In the 'noun-verb'/OOP version the sequence of modifications follows the english reading order where basically I only have to keep information about the last result in my head. The functional verb-noun version I have to pop in and out of layers: 'ok we're dealing what?, something shuffled, what are we shuffling?, the cards object/variable, ok we're dealing shuffled cards how many are we dealing? 4.'

In general the noun-verb follows the sequence of operations applied by the computer so it's easier to read.

That's where I was going as well, LISP style and APL style claims "reads left to right" but having to build up a stack of buffered work which you can only unwind once you get to the end, is annoying and unhelpful and limiting.

But simply turning it around to cards.shuffle().deal(4) isn't a good answer, it's still the case that you can only put a small number of things together in a chain because it stops making sense. If the next move was to start the game, "cards.shuffle().deal(4).startgame('some-card-game')" does not make sense because starting the game is not something the cards do, but "start(deal(shuffle(cards), 4), 'some-card-game')" can make sense because start is a function which takes a board state and a game to start. It describes the world state, not the cards and their abilities.

That is, neither style is right, but a mixed style where both approaches are available and you can mix and match to be more expressive, works much better, IMO. Chunking a small number of things with prefix into one operation, or with postfix into one operation, but combining those chunks flexibly at a larger scale.

the main point was about auto-completion and usability and discoverability. fluent api for the win.

English is worse as it is SVO. So a more English like language would be all infix operators. I thunk part of ambiguity is that English can be used in both modes.

“Say that” “He said”

I was really just talking about the left to right order of modification not the actual order of English sentences. Apparently I was very unclear because that's all the responses I'm getting.