Why doesn't this Haskell typeclass code work?

Question

Trying to figure out Haskell typeclasses. Why doesn't the following work?

{-# LANGUAGE FlexibleInstances #-}
class IntClass t
instance IntClass Int

intToIntClass  :: (IntClass r) => Int -> r
intToIntClass  x = x

Clearly "instance" doesn't mean what I think it should mean. Instead, it gives the error message, which I do not understand.

Could not deduce (r ~ Int)
from the context (IntClass r)
  bound by the type signature for intToIntClass  :: IntClass r => Int -> r
  at f.hs:10:1-16
  `r' is a rigid type variable bound by
      the type signature for intToIntClass  :: IntClass r => Int -> r
      at f.hs:10:1
In the expression: x
In an equation for `intToIntClass t': intToIntClass  x = x

The (r ~ Int) part of the top line in the error message means "Could not deduce type r is the same type as Int". ~ (tilde) means type equality which once you are used to it is fine, but if this is the first time you've seen it then it's a bit bizarre. Using the more natural = for type equality would make Haskell's syntax ambiguous when it is used in programs rather than error messages. — stephen tetley
– stephen tetley, Commented Apr 30, 2012 at 7:05

Daniel Fischer · Accepted Answer · 2012-04-29 23:46:43Z

14

The signature

intToIntClass  :: (IntClass r) => Int -> r

means that intToIntClass can produce a value of whichever type the caller wants, as long as that type belongs to IntClass. But the implementation can only produce Int values.

It doesn't help that Int is - so far - the only instance, as far as the compiler is concerned, there may be more instances defined in other modules, so the compiler can't accept a method that produces only Ints.

answered Apr 29, 2012 at 23:46

Daniel Fischer

184k19 gold badges319 silver badges436 bronze badges

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

Comments

Anthony · Accepted Answer · 2012-04-29 23:50:10Z

The function you wrote says, "Give me something, and I will give it back to you." The type you wrote says, "I can convert an Int into any type you the caller would like, as long as that type is an instance of the IntClass typeclass."

When we put those together, we have a function that will take an Int from the caller, and give it straight back. Except that when that very same Int is returned, it will be a value of any type the caller would like as long as that type is a member of the IntClass typeclass. How can the input go from being an Int to any (constrained) type the caller would like? It can't. Since the input is given straight back, the return type must be the same as the argument type. The type checker infers this from your code, but then can't reconcile that inference with you naming the output type r. The type checker wants to work with you on this, but can't be sure that r is the same thing as Int given the sole hypothesis that r is an instance of the IntClass typeclass.

A function rather like the one you wrote is fromInteger, found in the Num typeclass. If you want to talk about all types that you can construct based on an Int, then this should be a method of your typeclass. Something like:

class IntClass a where
  intToIntClass :: Int -> a

You would define this method for every type that you want to be an instance of IntClass, and would have your desired type of intToIntClass :: IntClass r => Int -> r. This return type polymorphism depends critically on each participating type having an appropriate definition of intToIntClass.

bdonlan · Accepted Answer · 2012-04-29 23:48:26Z

4

Your typeclass is fine. For example, this works:

intId :: IntClass r => r -> r
intId = id

The problem is, intToIntClass's type signature says it maps from Int to any member of IntClass. The compiler can't prove that Int is the only member of IntClass, and so since the body of intToIntClass rigidly returns Int, it's not polymorphic enough.

answered Apr 29, 2012 at 23:48

bdonlan

233k31 gold badges275 silver badges326 bronze badges

1 Comment

drwowe Over a year ago

Ah that makes sense. My mistake was in thinking that the function signature was doing something like an interface cast in other languages.

Chris Kuklewicz · Accepted Answer · 2012-04-30 07:06:58Z

To further clarify, let's say I use your module alongside a new instance:

instance IntClass Integer

Then your implementation of of intToIntClass also promises to have type (IntClass Integer => Int -> Integer). But your implementation conflicts with this. The compiler assumes type classes are "open", meaning that

new instances might appear in the future, and
today's code must not change behaviour in such a future

Thus the compiler sees that today the only instance is for Int but it cannot assume that this will stay true in the future.

The combination of (1.) and (2.) makes thinking and reasoning about Haskell code much easier. There are far fewer caveats when you know today's new instance cannot screw up yesterday's code and that today's code is safe from tomorrow's new instance.

Collectives™ on Stack Overflow

Why doesn't this Haskell typeclass code work?

4 Answers 4

Comments

Comments

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related