|> It seems you might benefit from local functional dependencies, which |> are asserted per instance rather than for the whole class. They are |> explained in |> |> http://pobox.com/~oleg/ftp/Haskell/typecast.html Unfortunately I come crawling back with a failure. Either my fu was not strong enough to fully tame the power of the TypeCast, or there's something here that's trickier than I realize. This message is a literate haskell source file, and I'll set the scene more carefully this time. Note that many of my definitions here are not really definitions but part of the literate comments.

{-# OPTIONS_GHC -fglasgow-exts #-} {-# OPTIONS_GHC -fallow-overlapping-instances #-} {-# OPTIONS_GHC -fallow-undecidable-instances #-} module GenXML where

We start out with a (very simplified) datatype for XML:

data XML = Element String [XML] | CDATA String

We want to be able to generate XML values of this type using a function (not that this is still a comment) build :: String -> [XML] -> XML build = Element The intended use of build is as the unsugared counterpart of HSP-style XML-like syntax, for instance p c = <p><% c %></p> =desugar=> p c = build "p" [embed c] However, we also want to use this syntax to generate values of other possible representations of XML, so we put the function definition in a type class:

class Build xml child | xml -> child where build :: String -> [child] -> xml asChild :: xml -> child

Read out, we can build values of type xml holding children of type child. The use of asChild will be evident below. Clearly XML should fit for this, so we define the instance

instance Build XML XML where build = Element asChild = id

The next step is to allow values of different types to be embedded inside XML elements using the embed function:

class Build xml child => Embed a xml child where embed :: xml -> a -> child

In English, we can embed values of type a into a tree of type xml, by turning it into something of type child. (The first argument to 'embed' is only there to guide type inference, instantiations of the class are not allowed to look at it.) As an example, now we can embed String values into a tree of type XML:

instance Embed String XML XML where embed _ = CDATA

Clearly we also want to be able to embed XML values as children of some element, so we could define (comment) instance Embed XML XML XML where embed _ = id Now we can define p as

p c = let x = build "p" [embed x c] in x

and define a test function (comment) test :: XML test1 = p (p "foo") and if we do we get the following error from GHCi: ---------------------------------------------------------------- GenXML.hs:25:8: No instance for (Embed a xml XML) arising from use of `p' at GenXML.hs:25:8 Probable fix: add an instance declaration for (Embed a xml XML) In the definition of `test1': test1 = p (p "foo") GenXML.hs:25:11: No instance for (Embed [Char] xml child) arising from use of `p' at GenXML.hs:25:11 Probable fix: add an instance declaration for (Embed [Char] xml child) In the first argument of `p', namely `(p "foo")' In the definition of `test1': test1 = p (p "foo") ---------------------------------------------------------------- The problem is that the type of the intermediate value (p "foo") cannot be determined. Looking at the type of p we see p :: (Build a1 child, Embed a xml child) => a -> a1 This is pretty obvious, we have no way of knowing what the result of p should be just by its use, it is polymorphic in its result type, and we get no help with inference from the usage site either since it then occurs in a polymorphic position too. But my intention here, which is really the core of my problem, is that I want to disambiguate this problem, by stating (somehow) that if the result of a build is embedded inside another build, the result types of the two should be identical. That is, if we want to generate subtrees of some tree, we should generate them as having the correct type immediately. My first attempt was to define the instance instance (Build xml child) => Embed xml xml child where embed _ x = asChild x but it didn't quite work out, the instance selection still couldn't know what the result of the generation should be, so I still get the same error as above. When I saw TypeCast I thought I had the answer to my problems, and tried to define

class TypeCast a b | a -> b, b->a where typeCast :: a -> b class TypeCast' t a b | t a -> b, t b -> a where typeCast' :: t->a->b class TypeCast'' t a b | t a -> b, t b -> a where typeCast'' :: t->a->b instance TypeCast' () a b => TypeCast a b where typeCast x = typeCast' () x instance TypeCast'' t a b => TypeCast' t a b where typeCast' = typeCast'' instance TypeCast'' () a a where typeCast'' _ x = x

instance (Build xml child, TypeCast x xml) => Embed x xml child where embed _ x = asChild (typeCast x :: xml)

(Btw, why is the type signature needed for typeCast? Shouldn't it be given by the FD from the TypeCast class?) The point here is the very general instance head, containing only type variables, so it will match the result of any call to build. TypeCast is then used to ensure that what I really get is the same type as that which I'm trying to embed in. This works, and I can write for instance

test2 :: XML test2 = p (p (CDATA "foo"))

From my use of CDATA here I'm sure you can see where I'm headed, if you didn't already. The above test2 definition type checks and works as expected, but I still run into a problem if I try to define test1 from above:

From the type signature for test1 we know a1 to be XML, and thus by

test1 :: XML test1 = p (p "foo") When I try to define this I get the following error from GHCi: ---------------------------------------------------------------- GenXML.hs:29:8: Overlapping instances for Embed a XML XML arising from use of `p' at GenXML.hs:29:8 Matching instances: GenXML.hs:31:0: instance (Build xml child, TypeCast x xml) => Embed x xml child GenXML.hs:20:0: instance Embed String XML XML (The choice depends on the instantiation of `a' Use -fallow-incoherent-instances to use the first choice above) In the definition of `test1': test1 = p (p "foo") GenXML.hs:29:11: Overlapping instances for Embed [Char] a child arising from use of `p' at GenXML.hs:29:11 Matching instances: GenXML.hs:31:0: instance (Build xml child, TypeCast x xml) => Embed x xml child GenXML.hs:20:0: instance Embed String XML XML (The choice depends on the instantiation of `a, child' Use -fallow-incoherent-instances to use the first choice above) In the first argument of `p', namely `(p "foo")' In the definition of `test1': test1 = p (p "foo") ---------------------------------------------------------------- For the first one, if we turn on incoherent instances we get what we want. But we would then get the wrong instance for the second one. Looking at the type signature of the expression p (p "foo") we see that p (p "foo") :: (Embed a a1 child, Embed [Char] a child1) => a1 the FD that child should be XML, so we can simplify this to p (p "foo") :: (Embed a XML XML, Embed [Char] a child) => XML If we look at the first constraint, we would get two possible instances matching as per the error message above, and similarly for the second. So, the error message seems right on the spot, but that doesn't make me any happier, since I have no idea how to get around this problem. It seems that the TypeCast trick only works when you have no more instances than that most general one, but that won't work in my case. So I come crawling back, hoping to pick up some more wisdom to help me solve this problematic case. If you read this long, then thanks a lot for your interest! :-) /Niklas

Hi Oleg, Thanks a lot for your reply. I see now where my attempt went wrong and why it couldn't work in the first place, the instances will indeed overlap. I'm not completely satisfied with your solution though, but seeing how you did it has lead me to the solution I want. Details below. :-) ] Fortunately, there is a solution that does not involve proxies or ] type annotations. We use a `syntactic hint' to tell the typechecker ] which intermediate type we want. To be more precise, we assert local ] functional dependencies. Thus we can write: ] ] p c = build "p" [embed c] ] ] test1 :: XML ] test1 = p [[p [[p "foo"]]]] ] ] Our syntactic crutch is the list notation: [[x]]. We could have used a ] single pair of brackets, but we'd like to avoid overlapping ] instances (as is done in the following self-contained code). While I appreciate the ingenuity of the solution, unfortunately I cannot use it. First of all I don't want to require my users to write double brackets everywhere, it makes the code a lot uglier IMO. Another problem is that in my real library (as opposed to the simplified example I gave here) I allow the embedding of lists, which means that the [[x]] is not safe from overlap as it is in your example. But I still see the general pattern here, the point is just to get something that won't clash with other instances. I could define data X a = X a instance (TypeCast a XML) => Embed (X a) XML where embed (X a) = typeCast a and write test1 = p (X $ p (X $ p "foo")) Not quite so pretty, even worse than with the [[ ]] syntax. However, I have an ace up my sleeve, that allows me to get exactly what I want using your trick. Let's start the .lhs file first:

{-# OPTIONS_GHC -fglasgow-exts #-} {-# OPTIONS_GHC -fallow-overlapping-instances #-} {-# OPTIONS_GHC -fallow-undecidable-instances #-} module HSP where

import Control.Monad.State import Control.Monad.Writer import TypeCast -- putting your six lines in a different module

Now, the thing I haven't told you in my simplified version is that all the XML generation I have in mind takes place in monadic code. In other words, all instances of Build will be monadic. My whole point of wanting more than one instance is that I want to use one monad, with an XML representation, in server-side code and another in client-side code, as worked on by Joel Björnson. Since everything is monadic, I can define what it means to be an XML-generating monad in terms of a monad transformer:

newtype XMLGen m a = XMLGen (m a) deriving (Monad, Functor, MonadIO)

and define the Build and Embed classes as

class Build m xml child | m -> xml child where build :: String -> [child] -> XMLGen m xml

class Embed a child where embed :: a -> child

Now for the server-side stuff:

data XML = CDATA String | Element String [XML] deriving Show

newtype HSPState = HSPState Int -- just to have something type HSP' = StateT HSPState IO type HSP = XMLGen HSP'

Note that by including XMLGen we define HSP to be an XML-generation monad. Now we can declare our instances. First we can generate XML values in the HSP monad (we use HSP [XML] as the child type to enable embedding of lists):

instance GenXML HSP' XML (HSP [XML]) where genElement s chs = do xmls <- fmap concat $ sequence chs return (Element s xmls)

Second we do the TypeCast trick, with XMLGen as the marker type:

instance TypeCast (m x) (HSP' XML) => Embed (XMLGen m x) (HSP [XML]) where embed (XMLGen x) = XMLGen $ fmap return $ typeCast x

And now we can safely declare other instances that will not clash with the above because of XMLGen, e.g.:

instance Embed String (HSP [XML]) where embed s = return [CDATA s]

instance Embed a (HSP [XML]) => Embed [a] (HSP [XML]) where embed = fmap concat . mapM embed -- (why is there no concatMapM??)

This last instance is why I cannot use lists as disambiguation, and also why I need overlapping instances. Now for some testing functions:

p c = build "p" [embed c]

test0 :: HSP XML test0 = p "foo"

test1 :: HSP XML test1 = p (p "foo")

test2 :: HSP XML test2 = p [p "foo", p "bar"]

All of these now work just fine. We could end here, but just to show that it works we do the same stuff all over again for the clientside stuff (mostly dummy code, the clientside stuff doesn't work like this at all, this is just for show):

data ElementNode = ElementNode String [ElementNode] | TextNode String deriving Show

type HJScript' = WriterT [String] (State Int) type HJScript = XMLGen HJScript'

instance Build HJScript' ElementNode (HJScript ElementNode) where build s chs = do xs <- sequence chs return $ ElementNode s xs

instance TypeCast (m x) (HJScript' ElementNode) => Embed (XMLGen m x) (HJScript ElementNode) where embed (XMLGen x) = XMLGen $ typeCast x

instance Embed String (HJScript ElementNode) where embed s = return $ TextNode s

Testing the new stuff, using the same p as above:

test3 :: HJScript ElementNode test3 = p "foo"

test4 :: HJScript ElementNode test4 = p (p "foo")

And these also work just as expected! :-) Thanks a lot for teaching my the zen of TypeCast, it works like a charm once you learn to use it properly. Really cool stuff! :-) /Niklas