[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