[Haskell-cafe] Question about classes from a Haskell newbie.

[Jeff.Harper at handheld.com]

Hi,

I'm new to Haskell and even newer to this list.   I have over 20 years of 
experience in C or C++.

For fun, I decided to write a Fourier transform in Haskell.  It would be 
convenient if I had a function that converts any real or complex number 
into a complex number.  My attempt at doing this is below.  Hugs produces 
errors when I try to load this code.

Essentially, I'm trying to define a class called ConvertibleToComplex. 
There is a function in this class called toComplex.  toComplex has the 
type:

class ConvertibleToComplex a where
   toComplex :: RealFloat b => a -> Complex b

I'd like some instances of toComplex to return a Complex Double while 
other instances return a Complex Float.  Doing this sort of thing in C++ 
is fairly easy.  However, I get the feeling that I'm pushing the Haskell 
type system to do something it isn't designed to do.  Is there a way to 
define ConvertibleToComplex so that toComplex's return type is generic and 
a particular instance of ConvertibleToComplex decides what the return type 
is?

Here is my attempt at doing this.  If someone can give me some pointers on 
how to make this work, I'd appreciate it.


module Main where

import Complex

--------------------------------------------------------------------------------
-- toComplex should convert a real or complex number to a complex number.
--
-- Here's my goal for the type of toComplex.  Given:
-- f  :: Float
-- d  :: Double
-- cf :: Complex Float
-- cd :: Complex Double
--
-- When toComplex is applied to these, I'd like it to evaluate to the 
-- following types:
--
-- toComplex f  :: Complex Float
-- toComplex d  :: Complex Double
-- toComplex cf :: Complex Float
-- toComplex cd :: Complex Double


class ConvertibleToComplex a where
   toComplex :: RealFloat b => a -> Complex b
 
-- If I uncomment the following code, Hugs produces errors:
-- ERROR "c:\tmp\test2.hs":29 - Inferred type is not general enough
-- *** Expression    : toComplex
-- *** Expected type : (ConvertibleToComplex Float, RealFloat a) => Float 
-> Complex a
-- *** Inferred type : (ConvertibleToComplex Float, RealFloat Float) => 
Float -> Complex Float  
{-
instance ConvertibleToComplex Float where
        toComplex f = f :+ 0

instance ConvertibleToComplex Double where
        toComplex d = d :+ 0

instance ConvertibleToComplex (Complex a) where
        toComplex c = c
-}
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org//pipermail/haskell-cafe/attachments/20050523/9b7bed14/attachment.htm