Question about classes from a Haskell newbie.
Thank you Pierre and Lemmih for answering my question about how to implement the toComplex function. Both of your answers were insightful. I understood Pierre's solution. Pierre wrote:
I think you misunderstand the meaning of the constraint !
toComplex :: (RealFloat b) => a -> Complex b
means the type of "b" needs to be a "RealFloat" and that it will be inferred from the context where the function "toComplex" is called !
"Inferring the type of a function based on the context where the function is called." is an idea that I'm going to have to wrap my mind around. Lemmih's solution is interesting too. I tried it. It seems to work well under Hugs. I'm under the impression that the return type of toComplex is inferred based on the argument passed to toComplex. However, I didn't understand the syntax of the class declaration. Lemmih wrote:
import Complex
class ConvertibleToComplex a b | a -> b where toComplex :: RealFloat b => a -> Complex b
I've looked at several sources to try to understand this declaration. I can't find any examples where a class declaration takes two type variables or uses the pipe symbol. One of the sources I used was _Haskell 98 Language and Libraries The Revised Report_. I'm not an expert at BNF notation, but the definitions for topdecl, tycls, and tyvar in the grammar seems to exclude Lemmih's declaration. If someone could point me to some sources that explain this notation, I'd be very grateful. Thanks, Jeff
However, I didn't understand the syntax of the class declaration.
Lemmih wrote:
import Complex
class ConvertibleToComplex a b | a -> b where toComplex :: RealFloat b => a -> Complex b
I've looked at several sources to try to understand this declaration. I can't find any examples where a class declaration takes two type variables or uses the pipe symbol. One of the sources I used was _Haskell 98 Language and Libraries The Revised Report_. I'm not an expert at BNF notation, but the definitions for topdecl, tycls, and tyvar in the grammar seems to exclude Lemmih's declaration.
If someone could point me to some sources that explain this notation, I'd be very grateful.
This is a multi-parameter typeclass (with functional dependencies), which is not a part of Haskell 98, so its no surprise that you didn't find it in the Report. The Muli-parameter part is pretty easy to understand: the type class simply introduces more than one type variable. Functional dependencies let you say which types should determine which other types. Here are some pages on these ideas: http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions.html... http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions.html... http://haskell.org/hawiki/FunDeps In this particular instance, what the class definition means is that 'ConvertaibleToComplex' is a class which relates two types 'a' and 'b' AND the type 'a' uniquely determines the type 'b'. Hope that helps, Robert Dockins
Hello,
the web page http://research.microsoft.com/~simonpj/multi.ps.gz mentioned
in
http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions.html...
is not reachable or does not exist anymore.
Any hints how I can get my hands on this paper are welcome
Jan
----- Original Message -----
From: "robert dockins"
However, I didn't understand the syntax of the class declaration.
Lemmih wrote:
import Complex
class ConvertibleToComplex a b | a -> b where toComplex :: RealFloat b => a -> Complex b
I've looked at several sources to try to understand this declaration. I can't find any examples where a class declaration takes two type variables or uses the pipe symbol. One of the sources I used was _Haskell 98 Language and Libraries The Revised Report_. I'm not an expert at BNF notation, but the definitions for topdecl, tycls, and tyvar in the grammar seems to exclude Lemmih's declaration.
If someone could point me to some sources that explain this notation, I'd be very grateful.
This is a multi-parameter typeclass (with functional dependencies), which is not a part of Haskell 98, so its no surprise that you didn't find it in the Report. The Muli-parameter part is pretty easy to understand: the type class simply introduces more than one type variable. Functional dependencies let you say which types should determine which other types. Here are some pages on these ideas:
http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions.html... http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions.html... http://haskell.org/hawiki/FunDeps
In this particular instance, what the class definition means is that 'ConvertaibleToComplex' is a class which relates two types 'a' and 'b' AND the type 'a' uniquely determines the type 'b'.
Hope that helps, Robert Dockins
_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
participants (3)
-
Jeff.Harper＠handheld.com -
robert dockins -
Scott J.