推断类型不明确

Question

I'm trying to build a library to fill in a template based on some context.

The relevant data types are a ContextNode and Context .

data ContextNode m = ContextText Text
                   | ContextSub (Context m)

type Context m = (Text -> m (Maybe (ContextNode m)))

I defined a typeclass ContextGenerator to be able to derive something context like for data types using generics.

class ContextGenerator m a where
    clookup :: a -> Text -> m (Maybe (ContextNode m))

Context should be an instance of ContextGenerator

instance (MonadIO m) => ContextGenerator m (Context m) where
    clookup a s = a s

Some code to make contexts

mkContext :: MonadIO m => Text -> ContextNode m -> Context m
mkContext s n = \s' -> if s' == s then return (Just n) else return Nothing

The thing that isn't working is when I do the following (in repl where I enabled OverloadedStrings and FlexibleContexts)

> let ctx = mkContext "hello" (ContextText "world")

> clookup ctx "hello"

Could not deduce (Control.Monad.IO.Class.MonadIO m0)
from the context (Control.Monad.IO.Class.MonadIO m1,
                  ContextGenerator m (Context m1))
  bound by the inferred type for ‘it’:
             (Control.Monad.IO.Class.MonadIO m1,
              ContextGenerator m (Context m1)) =>
             m (Maybe (ContextNode m))
  at <interactive>:18:1-19
The type variable ‘m0’ is ambiguous
When checking that ‘it’ has the inferred type
  it :: forall (m :: * -> *) (m1 :: * -> *).
        (Control.Monad.IO.Class.MonadIO m1,
         ContextGenerator m (Context m1)) =>
        m (Maybe (ContextNode m))
Probable cause: the inferred type is ambiguous

It seems to me that the GHC infers that the two m 's in the instance definition are different, is that correct? How can I tell GHC that these should be the same?

Answer 1

You can make this work using functional dependencies in GHC - just add the language-extension and rewrite your type-class to:

class ContextGenerator m a | a -> m where ...

this basically says that a should include the choice for m (you could say ContextGenerator is now not a binary relation for the types m and a but a function from a -> m - which is implied by the syntax of the extension too)

working example:

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}

import Data.Text
import Control.Monad.IO.Class

data ContextNode m = ContextText Text
                   | ContextSub (Context m)

type Context m = (Text -> m (Maybe (ContextNode m)))

class ContextGenerator m a | a -> m where
  clookup :: a -> Text -> m (Maybe (ContextNode m))

instance (MonadIO m) => ContextGenerator m (Context m) where
  clookup a s = a s

mkContext :: MonadIO m => Text -> ContextNode m -> Context m
mkContext s n = \s' -> if s' == s then return (Just n) else return Nothing

test-session:

λ> let ctx = mkContext "hello" (ContextText "world")

λ> (Just (ContextText t)) <- clookup ctx "hello"

λ> t
"world"

λ> Just _ <- clookup ctx "???"
*** Exception: user error (Pattern match failure in do expression at <interactive>:41:1-6)

λ> Nothing <- clookup ctx "???"
(...empty of course...)

remark

as those types and classes are dependent of each other I am unsure that you really have a use-case for the type-class here- maybe you would be fine with just the function without all the overhead instead?

{-# LANGUAGE OverloadedStrings #-}

import Data.Text
import Control.Monad.IO.Class

clookup :: Context m -> Text -> m (Maybe (ContextNode m))
clookup a s = a s

data ContextNode m
  = ContextText Text
  | ContextSub (Context m)

type Context m = (Text -> m (Maybe (ContextNode m)))

mkContext :: MonadIO m => Text -> ContextNode m -> Context m
mkContext s n = \s' -> if s' == s then return (Just n) else return Nothing