Re: [Haskell] What is the best way to write adapters?

11 Mar 2004

      Thanks! Oleg.

This works and it looks nice!

And now, my code can be like:

class FwdSig d where
  (forall a. Sig a => a -> w) -> d -> w

All the types that supports such forwarding are instances of FwdSig.

My Def type is:

instance FwdSig Def where
  fwd f (ClassDef c) = f c
  fwd f (ProtDef p) = f p

instance Sig Def where
  getName = fwd getName
  getMethods = fwd getMethods
  ...

My Native type is:

instance FwdSig Native where
  fwd f (NativeSignature s) = f s
  fwd f (NativeProtocol p) = f p

instance Sig Native where
  getName = fwd getName
  getMethods = fwd getMethods
  ...

Many annoying forwarding functions are gone.

The only thing that I hope to be better is this "getXXX = fwd getXXX" piece
of code. Is it possible to reuse the same piece of code for both Native and
Def and any other possible types?

Inspired by your generic code, I wrote such thing:

instance FwdSig d => Sig d where
  getName = fwd getName
  getMethods = fwd getMethods
  ...

However, my ghc complains about the use of "Sig d".

I followed its recommendation and put -fallow-undecidable-instances flag
with the surprise that the "FwdSig d=>Sig d" instance declaration conflicts
with my other "instance Sig XXX" declarations.

Surely this is not a serious problem, I can live with repeating the
"getXXX=fwd getXXX" several times. Just curious about how further this can
go.

Ben.

oleg@pobox.com@haskell.org on 03/11/2004 01:36:30 PM

Please respond to oleg@pobox.com

Sent by:    haskell-bounces@haskell.org

To:    haskell@haskell.org
cc:    Ben_Yu@asc.aon.com

Subject:    [Haskell] What is the best way to write adapters?
...
The code is currently like this:
...
instance Sig Def where
  getName (DefClass c) = getName c
  getName(DefProtocol p) getName p
  getName(DefSignature s) = getName s
  getParents(DefClass c) = getParents c
  getParents(DefProtocol p) = getParents p
blah blah blah...
But this seems very annoying.
If I have 4 different constructors in Def, and 5 methods of class Sig,
(Please bear with me if I'm using some OO terminology because I'm still a
new FP programmer), I'll have to write 4*5=20 forwarding functions.
Adapters seem by necessity higher-ranked functions. The following is
a stubefied code that uses generic adaptors (the function fwd).
...
{-# OPTIONS -fglasgow-exts #-}
module Foo where
class Sig a where
  getName :: a -> Int
  getParents :: a -> String
  getMethods :: a -> String
data ClassDef = ClassDef
data ProtocolDef = ProtocolDef
instance Sig ClassDef where
    getName _ = 0
    getParents _ = "ClassDef Parents"
    getMethods _ = "ClassDef Methods"
instance Sig ProtocolDef where
    getName _ = 1
    getParents _ = "ProtocolDef Parents"
    getMethods _ = "ProtocolDef Methods"
data Def = DefClass ClassDef | DefProtocol ProtocolDef
fwd::(forall a. Sig a => a -> w) -> Def -> w
fwd f (DefClass c) = f c
fwd f (DefProtocol p) = f p
instance Sig Def where
    getName = fwd getName
    getParents = fwd getParents
    getMethods = fwd getMethods
Tests:

*Foo> getParents ClassDef
"ClassDef Parents"
*Foo> getParents ProtocolDef
"ProtocolDef Parents"
*Foo> getParents (DefClass ClassDef)
"ClassDef Parents"
*Foo> getParents (DefProtocol ProtocolDef)
"ProtocolDef Parents"
_______________________________________________
Haskell mailing list
Haskell@haskell.org
http://www.haskell.org/mailman/listinfo/haskell

This message is intended only for the addressee and may contain information
that is confidential or privileged. Unauthorized use is strictly prohibited
and may be unlawful. If you are not the intended recipient, or the person
responsible for delivering to the intended recipient, you should not read,
copy, disclose or otherwise use this message, except for the purpose of
delivery to the addressee. If you have received this email in error, please
delete and advise us immediately.

Re: [Haskell] What is the best way to write adapters?

Ben_Yu＠asc.aon.com