I wonder why the function expected by fold left has type signature `a -> b -> a` instead of `b -> a -> a`. Is there a design decision behind this?

In Haskell, for example, I have to write `foldl (\xs x -> x:xs) [] xs` to reverse a list instead of the shorter `foldl (:) [] xs` (which would be possible with `b -> a -> a`). On the other hand, there are use cases which require the standard `a -> b -> a`. In Scala, this could be appending: `xs.foldLeft(List.empty[Int]) ((xs, x) => xs:+x)` which can be written as `xs.foldLeft(List.empty[Int]) (_:+_)`.

Do proportionately more use cases occur requiring the given type signature instead of the alternative one, or are there other decisions which led to the design that fold left has in Haskell and Scala (and probably lots of other languages)?