[Haskell-cafe] Hint and Ambiguous Type issue

[Joseph Fredette]

I've been working on a little project, and one of the things I need to 
do is dynamically compile and import a Haskell Source file containing 
filtering definitions. I've written a small monad called Filter which is 
simply:

    type Filter a = Reader (Config, Email) a

To encompass all the email filtering. The method I need to import, 
filterMain, has type:

    filterMain :: Deliverable a => Filter a

where Deliverable is a type class which abstracts over delivery to a 
path in the file system. The notion is that I can write a type like:

    data DEmail = {email :: Email, path :: FilePath}
    newtype Maildir = MD DEmail

    instance Deliverable Maildir where
       {- ... omitted -}

However, Filter a should not be restricted to Deliverable types- it also 
encompasses the results of regular expression matching, etc, which are 
not -- in general -- Deliverable instances.

My question is this, when importing the file containing the definitions 
of  filterMain, I have the following code to grab filterMain and return 
it as a function.

    getFilterMain :: Deliverable a => FilePath -> Interpreter (Filter 
a)                          
    getFilterMain fMainLoc = 
do                                                                         
            loadModules [fMainLoc]; setTopLevelModules [(takeWhile 
(/='.') fMainLoc)]                        
            fMain  <- (interpret "(filterMain)" (as :: Deliverable a => 
Filter a))                           
            return 
(fMain)                                                                            

                                           
However, when I try to compile this, I get the type error:

    Hackmain.hs:70:43:
        Ambiguous type variable `a' in the constraint:
          `Deliverable a'
            arising from a use of `getFilterMainStuff' at 
Hackmain.hs:70:43-60
        Probable fix: add a type signature that fixes these type variable(s)

My understanding is that a type like "Foo a => Bar a" (where Foo is a 
class and Bar is a datatype) would simply restrict
the values of a to only those implementing Foo. But evidently I'm wrong. 
Is there a good (read, easy... :) ) fix to this?

Any help would be greatly appreciated.

/Joe

PS. All the actual code is on patch-tag, here 
http://patch-tag.com/repo/Hackmail/home -- if anyone prefers to look at that
directly, the relevant files are in Src, namely, Hackmain.hs, Filter.hs, 
and Deliverable.hs
-------------- next part --------------
A non-text attachment was scrubbed...
Name: jfredett.vcf
Type: text/x-vcard
Size: 296 bytes
Desc: not available
Url : http://www.haskell.org/pipermail/haskell-cafe/attachments/20090305/d67072c5/jfredett.vcf