Polymorphic lists...

[MR K P SCHUPKE]

I did not know about Oleg's posting, as I originally said, I based my implementation on
a paper by Conor McBride. Oleg is addressing the question of type safe casting, rather
than generic storage, so his code is a bit different. Infact his class:

> class TypeSeq t s where
>     type_index:: t -> s -> Int
>     fetch:: t -> s -> t
>     alter:: t -> s -> s
>    
> instance (PList Cons t r) => TypeSeq t (Cons t r) where
>     type_index _ _ = 0
>     fetch _ (Cons v _) = v
>     alter newv (Cons v r)  = Cons newv r
>    
> instance (PList Cons t' r', TypeSeq t r') => TypeSeq t (Cons t' r') where
>     type_index v s = 1 + (type_index v $ cdr s)
>     fetch v s = fetch v $ cdr s
>     alter newv (Cons v' r') = Cons v' $ alter newv r'

This stores unique types in a list that can be indexed by their types. Actually last 
night (before I read this code) I came up with something similar:

data MNil = MNil deriving (Show,Data,Typeable)
data MCons l a r = MCons l a r deriving (Show,Data,Typeable)

class MLookup l r a | l r -> a where
   mLookup :: r -> l -> a
instance MLookup l (MCons l a r) a where
   mLookup (MCons _ x _) _ = x
instance MLookup l r b => MLookup l (MCons m a r) b where
   mLookup (MCons _ _ xs) l = mLookup xs l


This is indexed by a unique type, but stores a second independant
type. The allows a kind of static finite map, which is pretty cool!
Here's an example:

data TmId = TmId
data TmVal = TmVal
data TmFloat = TmFloat
data TmName = TmName

testMap :: MCons TmId Int
	(MCons TmVal String
	(MCons TmFloat Float
	(MCons TmName String
	MNil)))

testMap = MCons TmId 1
	$ MCons TmVal "Hello"
	$ MCons TmFloat 1.2
	$ MCons TmName "World"
	MNil

main :: IO ()
main = do
	putStrLn $ show $ testMap `mLookup` TmId
	putStrLn $ show $ testMap `mLookup` TmVal
	putStrLn $ show $ testMap `mLookup` TmFloat
	putStrLn $ show $ testMap `mLookup` TmName

Index types don't need to be unique, the first match from the
head of the list will be returned. No match will result in a 
compile time error.

Regards,
	Keean Schupke.