If this is accurate, it's pretty remarkable. It comes from a blog post detailing an implementation of Lisp written in Haskell:
Traditional object oriented languages let us abstract ourselves from writing [if-then-else] switches and take the task upon themselves freeing us up to do more important work. Haskell does the same thing, however, it doesn't limit the abstraction to types - we can get the compiler to write such switches based on any component we're interested in abstracting! We can, for example, get the compiler to write code for us that will cause the runtime to only execute a particular function if the first argument is equal to five, or if the second element in a list is equal to three. We could do that in traditional languages with if statements and switches but Haskell does this for us in a much more elegant and expressive way. After all, why are we only allowed to create virtual functions based on the type of the object they belong to? Why can't we define "virtuality" based on the type (or value) of the function's third argument, for example? Interestingly, this is one of the reasons why Haskell isn't object oriented - it's functions don't need to belong to objects because the compiler and the runtime system allow us to abstract over any argument's type and structure (contrast that to being able to abstract only over an implicit this)!
The implication is that from a Haskell perspective, an object-oriented language is one which comes with one (and only one) simple mechanism for abstraction that consists entirely of an embedded this flag variable which every piece of data is guaranteed to have by default. If I understand correctly, Haskell's abstraction mechanism operates as a superset of this paradigm, because it can abstract over other things as well as the implicit flag variable.
Pretty interesting. If I've understood, then I totally understand the appeal of Haskell as well, because that's pretty powerful. The only thing I don't get is why Haskell would be preferred over Scheme or Common Lisp; surely, if Language A wins because Language A's functionality is a superset of Language B's, then absurdly powerful languages are the best. I'm assuming there's something which Haskell is best for, which Lisp cannot do, or can't do as eloquently, and that this is why Haskell exists in the first place. But I'm not sure.