First of all I'd like to thank everyone who participated in this discussion! Most approaches look very promising, especially the last is what I imagined, but were unable to write. Thanks for that, especially.
I will try to solve my problem using these approaches and report back once I succeed or run into trouble. Regards, Alexander Foremny 2012/8/1 Paolino <paolo.verone...@gmail.com>: > This is without class :-) > > > {-# LANGUAGE TypeFamilies, ExistentialQuantification, FlexibleContexts #-} > import Prelude hiding (lookup) > import Data.Typeable > > type family Value a :: * > > data Assoc = forall a . (Typeable (Value a), Typeable a) => Assoc a (Value > a) > > insert :: (Typeable (Value a), Typeable a) => a -> Value a -> [Assoc] -> > [Assoc] > > insert k v = (Assoc k v :) > > lookup :: (Typeable (Value a), Typeable a, Eq a) => a -> [Assoc] -> Value a > > lookup k [] = error "noassoc" > lookup k ((Assoc k' v):xs) = case cast k' of > Nothing -> lookup k xs > Just k'' -> if k'' == k then case cast v of > Nothing -> error "nocast" > Just v' -> v' > else lookup k xs > > *Main> type instance Value Integer = Char > *Main> type instance Value Int = String > *Main> let u = insert (1::Integer) 'c' $ insert (1::Int) "ciao" [] > *Main> lookup (1 :: Integer) u > 'c' > *Main> lookup (1 :: Int) u > "ciao" > *Main> > > Regards > paolino > > > 2012/8/1 Paolino <paolo.verone...@gmail.com> >> >> >> Hello, I made some trial and error with ghci to make it happy. I'm not >> really sure this has the type safety you asked. >> >> {-# LANGUAGE TypeFamilies, ExistentialQuantification, FlexibleContexts #-} >> >> import Prelude hiding (lookup) >> import Data.Typeable >> >> class Typeable a => Key a where >> type Value a :: * >> >> data Assoc = forall a . (Typeable (Value a),Key a) => Assoc a (Value a) >> >> insert :: (Typeable (Value a), Key a) => a -> Value a -> [Assoc] -> >> [Assoc] >> insert k v = (Assoc k v :) >> >> lookup :: (Typeable (Value a), Eq a, Key a) => a -> [Assoc] -> Value a >> lookup k [] = error "noassoc" >> lookup k ((Assoc k' v):xs) = case cast k' of >> Nothing -> lookup k xs >> Just k'' -> if k'' == k then case cast v of >> Nothing -> error "nocast" >> Just v' -> v' >> else lookup k xs >> >> I've tried without the typeclass with no luck. >> For some reasons >> >> type family Key a :: * >> type family Value a :: * >> >> and adding Typeable (Key a) to the contexts and Key 'a' in place of 'a' >> leads to a lot of type errors. >> Maybe it's possible with more help. >> >> Hope I got it right. >> >> Regards >> paolino >> >> >> 2012/7/31 Alexander Foremny <alexanderfore...@gmail.com> >>> >>> Hello list, >>> >>> I am currently thinking that a problem of mine would best be solved if >>> there was a Map-like data structure in which the value returned is >>> parametrized over the lookup type. >>> >>> I wonder is this makes sense and if such a data structure exists or if >>> it could be created while still being well typed. I essentially want >>> to statically define a scope of Key values and dynamically define a >>> list of keys. >>> >>> > -- Scope of possible keys. >>> > type Label = String >>> > data Key a where >>> > KeyStr :: Label -> Key String >>> > KeyInt :: Label -> Key Int >>> > KeyChoice :: Label -> [a] -> Key a >>> >>> > -- Some key values, to be extended at runtime. >>> > strKey "Some String" >>> > strKey' "Another String" >>> > intKey "Some integer" >>> > choiceKey "Chose one" [ "a", "b", "c" ] :: KeyChoice String >>> >>> Now I need a data structure to possibly associate a value to the key. >>> >>> > data MapG = ... >>> > type Value a = a >>> > insert :: Key a -> Value a -> MapG Key Value -> MapG Key Value >>> > lookup :: Key a -> MapG Key Value -> Maybe (Value a) >>> >>> I tried implementing this with multiple Map k a's. I tried adding a >>> phantom type on some storage type of to implement KeyChoice as of type >>> Key Int, but I ran into troubles with this approach. I wonder if >>> Dynamic or Type Families could achieve this, but I am quite at a loss >>> and would like to hear your opinion. >>> >>> I did try to search for this a bit, but I don't quite know how to >>> phrase my problem. I'd like to apologize in advance if this question >>> has been asked already. >>> >>> Regards, >>> Alexander Foremny >>> >>> _______________________________________________ >>> Haskell-Cafe mailing list >>> Haskell-Cafe@haskell.org >>> http://www.haskell.org/mailman/listinfo/haskell-cafe >> >> > _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe