hi all, i'm hoping to be able to simulate a sort of dynamic dispatch based on class instances. basically a function which takes a value and depending on what classes it is an instance of, does something. a simple example might be a 'maybeShow' function which sematically looks like:
maybeShow x | typeOf x `instanceOf` Show = show x | otherwise = "?"
I've been trying for a while to simulate something along the lines of:
class Foo a where { foo :: a -> Bool } class Bar a where { bar :: a -> Bool } foo x | typeOf x `instanceOf` Foo = Just (foo x) | typeOf x `instanceOf` Bar = Just (bar x) | otherwise = Nothing
and I tried using dynamics but those require instances of typeable on universally quantified types, which doesn't work out too well in practice. also, we can do class sums using existential types:
data FB = forall a . Foo a => MkFoo a | forall a . Bar a => MkBar a
and i tried something like: class FooBar a where wasFoo :: a -> Maybe FB -- will be MkFoo wasBar :: a -> Maybe FB -- will be MkBar wasFoo _ = Nothing wasBar _ = Nothing instance Foo a => FooBar a where wasFoo a = Just (MkFoo a) instance Bar a => FooBar a where wasBar a = Just (MkBar a) but this complains about duplicate instance declarations (for obvious reasons). i'm hoping one of the type class gurus out there can help me. Thanks in advance! -- Hal Daume III | hdaume@isi.edu "Arrest this man, he talks in maths." | www.isi.edu/~hdaume