Ambiguous type variable using multi-parameter typeclass

Question

I don't understand why Haskell can't figure out the type for line 8 in the following code. Doesn't the type signature of the expressMaybe function establish that the result type is the same as the type of the two input parameters?

{-# LANGUAGE MultiParamTypeClasses #-}

class Gene g n where
  express :: g -> g -> g
  -- there will be other functions that use the "n" type parameter

expressMaybe :: Gene g n => Maybe g -> Maybe g -> Maybe g
expressMaybe (Just a) (Just b) = Just (express a b) -- line 8
expressMaybe (Just a) Nothing  = Just a
expressMaybe Nothing (Just b)  = Just b
expressMaybe Nothing Nothing   = Nothing

The error I get is:

Amy20.hs:8:40:
    Ambiguous type variable `n0' in the constraint:
      (Gene g n0) arising from a use of `express'
    Probable fix: add a type signature that fixes these type variable(s)
    In the first argument of `Just', namely `(express a b)'
    In the expression: Just (express a b)
    In an equation for `expressMaybe':
        expressMaybe (Just a) (Just b) = Just (express a b)
Failed, modules loaded: none.

I tried playing around with RankNTypes and ScopedTypeVariables, but I couldn't figure out how to make the error go away.

Thank you in advance for your help!

Edit: Now that I understand the problem, I used fundeps, because I'm familiar with them, and for my application it doesn't make much sense to have more than one "alphabet" for encoding genes. I've never used type families before, though, so I'll look into that too.

{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}

class Gene g n | g -> n where
  express :: g -> g -> g
  -- there will be other functions that use the "n" type parameter

expressMaybe :: Gene g n => Maybe g -> Maybe g -> Maybe g
expressMaybe (Just a) (Just b) = Just (express a b) -- line 8
expressMaybe (Just a) Nothing  = Just a
expressMaybe Nothing (Just b)  = Just b
expressMaybe Nothing Nothing   = Nothing

Answer 1

Consider this:

instance Gene String Int where
  express _ _ = "INT"

instance Gene String Double where
  express _ _ = "DOUBLE"

expressMaybe (Just "") (Just "")

Should that code produce (Just "INT") or (Just "DOUBLE")? Yes, Haskell knows that the result of expressMaybe will have the same type as the arguments. But that doesn't mean it knows which instance to use here since there can be multiple instances for the same type g with different n.

If in your case there will only ever be one type n for each type g, you might consider using extensions like type families or functional dependencies with which you can express that fact to the type system.

Answer 2

I suggest you avoid functional dependencies and go for type families. They're more fun and more intuitive:

{-# LANGUAGE TypeFamilies, KindSignatures #-}

class Gene g where
  type Nucleotide g :: *  -- each instance has an associated type
  express :: g -> g -> g
  encode :: [Nucleotide g] -> g -- probably doesn't make sense, but need an example
  -- there will be other functions that use the "Nucleotide g" type parameter

Let's say we have

data ACTG = A | C | T | G
data ACTGgene = ACTGgene [ACTG]

Essentially, you define the type function by trivial pattern matching at the type level:

instance Gene ACTGgene where
  type Nucleotide ACTGgene = ACTG
  encode ns = ACTGgene ns
  express = error "I'm out of my depth here because I gave up Biology when I hit 14."

Now our code compiles:

expressMaybe :: Gene g => Maybe g -> Maybe g -> Maybe g
expressMaybe (Just a) (Just b) = Just (express a b) -- compiles fine
expressMaybe (Just a) Nothing  = Just a
expressMaybe Nothing (Just b)  = Just b
expressMaybe Nothing Nothing   = Nothing

---

Now it may be that your Gene types are essentially determined by what Nucleotides you're using, or maybe you can use different nucleotides interchangably, I don't know, but one possible solution to your problems is to use a constructor class instead:

class Gene g where
   express :: g n -> g n -> g n
   encode :: n -> g n
   -- more stuff

This would fit with data declarations like

data ACTG = A | C | T | G
data ListGene n = ListGene [n]

instance Gene ListGene where
  ...

but maybe that's just too parametric for your problem domain, I don't know.

---

Certainly you should try type families. I did. Now I love them. - linked answer includes links at the end for further reading.