10

I'm learning how to use typeclasses in Haskell.

Consider the following implementation of a typeclass T with a type constrained class function f.

class T t where
    f :: (Eq u) => t -> u 

data T_Impl = T_Impl_Bool Bool | T_Impl_Int Int | T_Impl_Float Float 
instance T T_Impl where
    f (T_Impl_Bool x) = x
    f (T_Impl_Int x) = x
    f (T_Impl_Float x) = x

When I load this into GHCI 7.10.2, I get the following error:

Couldn't match expected type ‘u’ with actual type ‘Float’
      ‘u’ is a rigid type variable bound by
          the type signature for f :: Eq u => T_Impl -> u 
          at generics.hs:6:5

Relevant bindings include
  f :: T_Impl -> u (bound at generics.hs:6:5)
In the expression: x
In an equation for ‘f’: f (T_Impl_Float x) = x

What am I doing/understanding wrong? It seems reasonable to me that one would want to specialize a typeclass in an instance by providing an accompaning data constructor and function implementation. The part

Couldn't match expected type 'u' with actual type 'Float'

is especially confusing. Why does u not match Float if u only has the constraint that it must qualify as an Eq type (Floats do that afaik)?

Improve this question
5
  • 3
    the constraint is not your problem - the problem is that you are saying: no matter what Eq type you want from me as a result - I can provide it Commented Jun 2, 2016 at 10:37
  • Where do I say that? Commented Jun 2, 2016 at 11:28
  • 2
    in f :: Eq u => t -> u - t is know from the context - the u is there with an implicit forall Commented Jun 2, 2016 at 12:07
  • @Carsten Can you link me to a reference for your claim. From what I understand a type constraint only limits potential definitions. Commented Jun 2, 2016 at 16:02
  • it's not about the constraint - it's about the u - it's really just what Chi pointed out in his answer and comments Commented Jun 2, 2016 at 16:11

3 Answers 3

Reset to default
19

The signature

f :: (Eq u) => t -> u

means that the caller can pick t and u as wanted, with the only burden of ensuring that u is of class Eq (and t of class T -- in class methods there's an implicit T t constraint).

It does not mean that the implementation can choose any u.

So, the caller can use f in any of these ways: (with t in class T)

f :: t -> Bool 
f :: t -> Char
f :: t -> Int
...

The compiler is complaining that your implementation is not general enough to cover all these cases.

Couldn't match expected type ‘u’ with actual type ‘Float’

means "You gave me a Float, but you must provide a value of the general type u (where u will be chosen by the caller)"

Improve this answer
Sign up to request clarification or add additional context in comments.

17 Comments

This. 1,000 times this. In a typical OO language, the method can choose to return anything it wants, so long as it matches the requirements. In Haskell the caller gets to choose, not the method.
@FK82 It's impossible to work with that class, it's promising the impossible, so it can't be implemented. You need to rework your approach. Your question looks like a case of the XY problem. meta.stackexchange.com/questions/66377/what-is-the-xy-problem
Your Java example would be similar to f :: Eq u => u -> Bool, where the input type, not the return type, has an Eq instance.
@FK82 OOP translations are necessarily imprecise, but it is roughly like interface T { <U extends Comparable> U f(); } This is promising to be able to produce any U, caller's choice.
@FK82 What are you ultimately trying to accomplish? Knowing that might help us help you more.
|
10

Chi has already pointed out why your code doesn't compile. But it's not even that typeclasses are the problem; indeed, your example has only one instance, so it might just as well be a normal function rather than a class.

Fundamentally, the problem is that you're trying to do something like

foobar :: Show x => Either Int Bool -> x
foobar (Left  x) = x
foobar (Right x) = x

This won't work. It tries to make foobar return a different type depending on the value you feed it at run-time. But in Haskell, all types must be 100% determined at compile-time. So this cannot work.

There are several things you can do, however.

First of all, you can do this:

foo :: Either Int Bool -> String
foo (Left  x) = show x
foo (Right x) = show x

In other words, rather than return something showable, actually show it. That means the result type is always String. It means that which version of show gets called will vary at run-time, but that's fine. Code paths can vary at run-time, it's types which cannot.

Another thing you can do is this:

toInt :: Either Int Bool -> Maybe Int
toInt (Left  x) = Just x
toInt (Right x) = Nothing

toBool :: Either Int Bool -> Maybe Bool
toBool (Left  x) = Nothing
toBool (Right x) = Just x

Again, that works perfectly fine.

There are other things you can do; without knowing why you want this, it's difficult to suggest others.

As a side note, you want to stop thinking about this like it's object oriented programming. It isn't. It requires a new way of thinking. In particular, don't reach for a typeclass unless you really need one. (I realise this particular example may just be a learning exercise to learn about typeclasses of course...)

Improve this answer

1 Comment

I think I understand the problem now: the type declaration of the class function must either specify a certain data type (this is the most simple case); or, if the type may be parameterized — and hence constrained by a type class — the compiler must be able to safely infer it. Anything else will not pass compilation.
0

It's possible to do this:

class Eq u => T t u | t -> u where
    f :: t -> u

You need FlexibleContextx+FunctionalDepencencies and MultiParamTypeClasses+FlexibleInstances on call-site. Or to eliminate class and to use data types instead like Gabriel shows here

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.