[I've asked this question on lambda-the-ultimate, but it remained unanswered, and it's probably more appropriate here in any case]
The papers referenced here: http://lambda-the-ultimate.org/node/view/552 describe a means of projecting values in an implementation language to and from values in an embedded interpreted language. The papers use ML, but Derek Elkin gives a straightforward translation to haskell, via a typeclass. An excerpt is here: > data U = UF !(U -> U) | UP !U !U | UU | UB !Bool | UI !Int | US !String > deriving Show > > class EmbedProject a where > embed :: a -> U > project :: U -> a > > instance EmbedProject Int where > embed = UI > project (UI i) = i > > instance (EmbedProject a, EmbedProject b) => EmbedProject (a -> b) where > embed f = UF (embed . f . project) > project (UF f) = project . f . embed This is nice and tidy. However, the project function can fail in practise - in the above, this results in pattern matching failures. I'd like have more control of this, which suggests the following: > class EmbedProject a where > embed :: a -> U > project :: U -> Maybe a > > instance EmbedProject Int where > embed = UI > project (UI i) = Just i > project _ = Nothing ...etc, until it comes to to defining the instance of EmbedProject for functions. embed is ok - incorrect parameters map to return values of the UU type. But I'm lost as to what needs to happen with the project function. The definition belows doesn't compile because (project.f.embed) has type a->Maybe b, but I need something of type Maybe (a->b): > instance (EmbedProject a, EmbedProject b) => EmbedProject (a -> b) where > embed f = UF (\a -> maybe UU (embed.f) (project a) ) > project (UF f) = project.f.embed > project _ = Nothing Any suggestions? Is there something obvious (or non-obvious!) that I am missing? Thanks, Tim _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe