Rationale for order of arguments to `get` function

Question

Why are the arguments ordered the way they are in Array.get and Dict.get? The order in most map/filter functions makes sense: the function comes before the collection (or monad, more generally).

MyCollection.map : (a -> b) -> MyCollection a -> MyCollection b

This makes it easier to compose higher functions out of smaller ones before passing in a collection.

Why, however, does the index/key come before the collection in get functions?

Dict.get : comparable -> Dict comparable v -> Maybe v

It seems to make it harder to compose higher functions. If the arguments were reversed, one could write:

ids : List Int
myObjects : Dict Int a

selectObjects = List.map (Dict.get myObjects) ids

But instead, the best way I can come up with to write this is:

ids : List Int
myObjects : Dict Int a

selectObjects = List.map (\id -> (Dict.get id myObjects)) ids

Am I missing something? What is the reason for the argument order in Array.get, Dict.get, and similar?

Answer 1

List.map (Dict.get myObjects) ids isn't function composition.

Composition is when you have
f : X -> Y and
g : Y -> Z then you compose them
h = f >> g so that
h : X -> Z

Now, when composing functions as above, we need them to require ONLY one more parameter.

So when defining an API, the question is:
"When someone partially evaluates this function so that it can be composed, what is the last parameter they'll likely want to pass it?"

In other words, are we more likely to see code like:
getStuff >> mungeIntoDict >> (Dict.get id)
or
getStuff >> getImportantId >> (Dict.get myDict) ?

The answer to that is "it depends". The API designers took their best guess and we have flip for when it doesn't suit us.