[Haskell-cafe] How to fulfill the "code-reuse" destiny of OOP?

Peter Verswyvelen bugfact at gmail.com
Wed Jan 13 05:21:02 EST 2010

Yes that is true, but often in Haskell I had to use type annotations
when the dispatch is based on the return type, so it also has some

Don't get me wrong, I see the advantages of Haskell's type classes and
closures, and I love these. But in Java - if you stay close to OO, and
don't try to do FP - you can accomplish a lot, albeit with a lot of
boilerplate. IMO, it's not because you have less lines of code in
Haskell, that the code becomes more readable per se. I'm not a Java
expert, but I have no troubles at all reading Java code, even though
that code is typically twice as long as similar C# code, and maybe ten
times as long as Haskell or ML code (at least if the side effects are
kept local enough, which is good practice in OO anyway). But after
many years of playing with Haskell, I still fail to read and
understand a lot of Haskell code (maybe because it is written by
people with a much higher IQ than mine I guess)

On Wed, Jan 13, 2010 at 11:00 AM, Sittampalam, Ganesh
<ganesh.sittampalam at credit-suisse.com> wrote:
> The problem with interfaces as a replacement for type classes is that they
> only provide dispatch based on the specific type of the first argument (i.e.
> the receiver).
> Type classes allow you to dispatch based on return type, and on the
> instantiations of generic parameters. Neither of these things is reasonably
> possible with interfaces.
> For example you can't directly implement the Read type class with
> interfaces. Neither can you implement a function of type [a] -> ... where
> the dispatch is based on the instantiation of a - even if you can add an
> interface to the [] generic type, you might not have a concrete object of
> type a to dispatch from if the empty list is passed as an argument.
> ________________________________
> From: haskell-cafe-bounces at haskell.org
> [mailto:haskell-cafe-bounces at haskell.org] On Behalf Of Peter Verswyvelen
> Sent: 13 January 2010 09:52
> To: Gregory Collins
> Cc: haskell-cafe at haskell.org
> Subject: Re: [Haskell-cafe] How to fulfill the "code-reuse" destiny of OOP?
> On Sun, Nov 1, 2009 at 2:57 AM, Gregory Collins <greg at gregorycollins.net>
> wrote:
>> Doing OO-style programming in Haskell is difficult and unnatural, it's
>> true (although technically speaking it is possible). That said, nobody's
>> yet to present a convincing argument to me why Java gets a free pass for
>> lacking closures and typeclasses.
> I might be wrong, but doesn't Java's concepts of inner classes and
> interfaces together with adapter classes can be used to replace closures and
> typeclasses in a way?
> An inner class allows you to implicitly capture the parent object
> ("environment"), just like a closure does in a sense.
> Interfaces group together methods, like type classes do.
> Although I'm actually a C# fanboy for doing "industrial" programming, I
> think the Java designers did an excellent job, finding a good balance in
> language features, ease of use and readability, and although C# does offer
> closures and many more FP constructs, I really miss the above Java
> constructs.
> ==============================================================================
> Please access the attached hyperlink for an important electronic
> communications disclaimer:
> http://www.credit-suisse.com/legal/en/disclaimer_email_ib.html
> ==============================================================================

More information about the Haskell-Cafe mailing list