Is there any abstract container that permits the addition of new types of data? I know how to simulate the extension of Algebraic datatypes, but this does not permit the addition of data with new types in the same container and recover them in a type-safe way. Did I reinvent the Weel? I found something, that permits this for any Typeable datatype. For example x=5 list= [put x, put "hello"] [t1,t2 ]= list x' = get t1 :: Int s = get t2 :: String print (x' +1) -- 2 print s -- "hello" x''= get t2 :: Int --"get: casting from String to type Int" The code: data Abstract= forall a. Typeable a => T !String a class FromToAbstract x where put :: x -> Abstract get :: Abstract -> x unsafeGet :: Abstract -> x -- get(put x)== x instance Typeable x => FromToAbstract x where put x= T (typeString x) x get (Abstract type1 a)= if type2 == type1 then v else error ("get: casting "++ "from type "++type1++" to type "++type2) where v= unsafeCoerce a :: x type2= typeString v unsafeGet (Abstract type1 a)= unsafeCoerce a typeString !x= tyConString $ typeRepTyCon $ typeOf x instance Typeable T where typeOf _= mkTyConApp (mkTyCon "Abstract") []