Hi Dmitri,
I don't have answers for all your questions. But some, at least.
--- Dmitri O.Kondratiev" -- Ok, then I can
derive MyOrd class directly from Ord: class Ord a => MyOrd a where (%<), (%<=), (%>), (%>=) :: a -> a -> Bool
x %< y = x < y
x %<=
y = (x < y || x == y)
x %> y = y < x
x %>= y = (y < x || x == y) instance (MyOrd a, MyOrd b) => MyOrd (a,b) where
(x1, y1) %< (x2, y2) = (x1 %< x2) && (y1 %< y2) (x1, y1) %> (x2, y2) = (x1 %> x2) && (y1
%> y2)
(x1, y1) %<= (x2, y2) = (x1 %<= x2) && (y1 %<= y2)
(x1, y1)
%>= (x2, y2) = (x1 %>= x2) && (y1 %>= y2) greaterMyOrd :: (MyOrd (a,
b)) => (a, b) -> (a, b) -> Bool
greaterMyOrd (x,y) (z,t) = (x,y) %> (z,t) -- This should work, right? Yet I get this error message: Only if
you tell the compiler to allow constraints of the form (C t), where C is a
class and t is not a variable. That's exactly what GHC tells you to try, using
-fglasgow-exts. -- Notwithstanding :) when i comment out declaration: -- greaterMyOrd :: (MyOrd (a, b)) => (a, b) -> (a, b) -> Bool -- program gets compiled and checking type of 'greaterMyOrd' gives: *ClassTest> :t greaterMyOrd
greaterMyOrd :: (MyOrd (a, b)) => (a, b)
-> (a, b) -> Bool -- which is the same as I tried to declare in the program source. What is hapenning here? That is indeed a bit funny.
Using your instance declaration, GHC could have reduced the constraint "MyOrd
(a,b)" to "MyOrd a, MyOrd b". I think there was a discussion on why it does
not do so very recently. Maybe you can find it in the archive. -- Now,
when trying to use function 'greaterMyOrd' I get: *ClassTest> greaterMyOrd
(2, 3) (1, 2) <interactive>:1:0:
Ambiguous type variable `a'
in the constraints:
`MyOrd a' arising from use of `greaterMyOrd'
at <interactive>:1:0-11
`Num a' arising from the literal `2' at <interactive>:1:14 Probable fix: add a type signature that fixes these type variable(s) -- Then I try to declare argument types explicitely and get That is because GHC doesn't know which type your literal 2 comes from.
So it doesn't know whether there is a MyOrd instance for it, or which to choose.
The Num comment comes from GHC only knowing that literal 2 will be of some
type in the Num class. But that doesn't tell it anything about possible MyOrd
instances.
this: *ClassTest> greaterMyOrd (2::MyOrd, 3::MyOrd) (1::MyOrd, 2::MyOrd) <interactive>:1:17:
Class `MyOrd' used as a type
In an expression type signature: MyOrd In the expression: 2 :: MyOrd In the first argument of `greaterMyOrd', namely `(2 :: MyOrd, 3 :: MyOrd)' *ClassTest> Well, just as GHC tells you, you should use a type for the
signature, not a typeclass. Try something like greaterMyOrd (2::Int, 3::Int)
(1::Int,2::Int). Maybe the annotations on the first tuple suffice. --
I am lost. Please enlight me, what am I doing wrong trying to
create my
own class, its instance and then using it. Hope that helped.
BTW, you
might get problems with overlapping instances. Because with your instance
declaration there are two possible ways, for example, to get a MyOrd instance
for (Int,Int). The first is via:
Ord Int => MyOrd Int => MyOrd (Int,Int)
The second is via:
Ord Int => Ord (Int,Int) => MyOrd (Int,Int)
Ciao,
Janis.