Your intuition is correct, these are just cases of Partial application with Binary operators! In Haskell binary operators are just a special case of a regular binary function where the function happens to be in the middle of two arguments. In fact if you want you can treat any binary operator like a regular function by wrapping it in parentheses.

For example

2 + 4

can also be written as

(+) 2 4

To demonstrate this better we can use a function where the order of the arguments matters.

For this bit of code

map (/ 2) [1,2,4]

we're missing the left-most argument, ie this translates to:

[(1 / 2),(2 / 2), (4 / 2)]

So we get the following result:

[0.5,1.0,2.0]

But if we wrap / in parentheses, changing it from an operator to a function like this:

map ((/) 2) [1,2,4]

Then we're missing the right-most argument which translates to:

[((/) 2 1),((/) 2 2),((/) 2 4)]

Giving us the opposite result as the previous example!

[2.0,1.0,0.5]

The ++ operator has a similar property:

Prelude> map (++ "s") ["car","pot","ack"]
["cars","pots","acks"]
Prelude> map ((++) "s") ["car","pot","ack"]
["scar","spot","sack"]

An alternate way of indicating that the right-most argument is missing would be to use the regular binary operator syntax and supply only the left argument:

Prelude> map ("s" ++) ["car","pot","ack"]
["scar","spot","sack"]

To summarize, for partial application with a binary operator we have three ways we can indicate a missing argument. Below ++ is our operator, 'x' will be our argument and '?' will indicate the missing argument that partial application is waiting for

(++ x) means (? ++ x)

(x ++) means (x ++ ?)

((++) x) means ((++) x ?)

Hope that helps clarify things! If you have a good sense of how partial application works with binary operators, then I would say you've got partial application down!