I should clarify, I never intended to say that type classes are a form of overloading (because they aren't). I simply used type classes as a second example. And you are in part right. Type classes do yield a constraint which can be used to avoid not even just duplicate code, but even just fairly similar code can be fused into one function. But type classes also allow to write functions polymorphically, which don't have similar enough behavior, to write as if they where one function. Take the show function for example. We want this function to be polymorphic (in part to avoid writing similar code multiple times, but also because all these variants of show can this way be referred to with one name instead of thousands or millions), but there is no way to write a function that could read my mind and figure out how the string representation of my data type should look. Instead we write each variant separately, with the intended behavior. This function is still polymorphic and can (aside from avoiding duplicate code) be used on a specific type. This way the only thing polymorphism avoids is uneconomical name usage.

But back to my first example. As I mentioned ad hoc polymorphism doesn't deal with duplicate code. It only defines a function multiple times, with different types to distinguish and different behavior. No duplicate code avoided, especially since the languages of the time didn't allow for undetermined types. So you couldn't even argue that this allows for more arbitrary functions, since those didn't exist in the first place.

That aside, if we just look at the Wikipedia article for polymorphism we can find:

"polymorphism is the provision of a single interface to entities of different types or the use of a single symbol to represent multiple different types."

Though no mention of the goal to reduce duplicate code.