[Haskell-cafe] Wondering if this could be done.

[Ling Yang]

Haskell does not play as well with overloading as one would do it in C++;
every
name used must be fully qualified.  Indeed, if we try something like

Indeed, if we try something like

data A = A Int deriving (Show, Eq)

test = A 3 unA (A i) = i

class Group a where (+) :: a -> a -> a

instance Group A where (+) x y = A $ unA x + unA y

we will get

Ambiguous occurrence `+'

It could refer to either `Main.+', defined at ****.hs:7:1
or `Prelude.+', imported from Prelude

Failed, modules loaded: none.

Haskell has its own brand of 'overloading': type classes. Every (+) sign
used
assumes that the operands are of the Num typeclass in particular. In order
to
define (+) on something else you will need to instance the Num typeclass
over
your A type.

I am not sure what you mean by "the stuff defined in class Num is meanless
to
A." Strictly speaking nothing needs to be defined in a typeclass declaration
other than the required type signatures.

To instance the Num typeclass with A, though, assuming that A constructors
take
something that works with Num, you would do something similar to what Miguel
posted:

data A = A Int deriving (Show, Eq)

test = A 3 unA (A i) = i

instance Num A where (+) x y = A $ (unA x) + (unA y) (-) x y = A $ (unA x) -
(unA y) (*) x y = A $ (unA x) * (unA y) abs x = A $ (unA $ abs x) signum y =
A
$ (unA $ signum y) fromInteger i = A (fromInteger i)

Look at fromInteger, which must take Integer as as argument. That may be
inconvenient for you. The Awesome Prelude, referenced in Chris's post, is a
way
of defining less specific version of basic types like Bool so that you have
more choices in defining things like fromInteger in the Num typeclass (which
must take an Integer; it is 'sad' if that Integer refers to a grounded,
specific type).

Still, if not every one of the Num operations make sense for your A type,
you
can leave them blank and get a warning.

On Sun, Nov 21, 2010 at 10:48 PM, Magicloud Magiclouds <
magicloud.magiclouds at gmail.com> wrote:

> Hi,
>  For example, I have a data A defined. Then I want to add (+) and (-)
> operators to it, as a sugar (compared to addA/minusA). But * or other
> stuff defined in class Num is meanless to A. So I just do:
> (+) :: A -> A -> A
> (+) a b =
>  A (elem1 a + elem1 b) (elem2 a + elem2 b) -- I got errors here, for
> the (+) is ambiguous.
>
>  So, just wondering, does this way work in Haskell?
> --
> 竹密岂妨流水过
> 山高哪阻野云飞
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/haskell-cafe/attachments/20101122/8234a3b0/attachment.html