[Haskell-cafe] Key-Parametrized Lookup Table

[James Cook]

Another option which allows you to define your own key type is the dependent-map[1] package.  It requires implementing some classes for your key type that encode a proof that key equality entails equality of the type indices. If the documentation is insufficient feel free to ask me for more details or examples.

[1] http://hackage.haskell.org/package/dependent-map

On Jul 31, 2012, at 6:56 AM, Alexander Foremny <alexanderforemny at gmail.com> wrote:

> At first glance I noticed some problems with the vault library for my
> particular approach.
> 
> Despite from being unique, Key values don't appear to carry any
> information like the Label I need. However, it might be possible to
> work around that.
> 
> The more grave problem seems to be that a Key cannot be
> (de-)serialized. This might be impossible due to the type parameter a
> in Key a.
> However, it is no problem to fix the types of values to some finite collection.
> 
> Because of this some solution built around Dynamic seems to be more
> and more appropriate. But I'll try to investigate vault further.
> 
> Regards,
> Alexander Foremny
> 
> 2012/7/31 Alexander Foremny <alexanderforemny at gmail.com>:
>> Dear Michael,
>> 
>> thank you very much for your quick and interesting response. This
>> looks very much like what I want!
>> 
>> Regards,
>> Alexander Foremny
>> 
>> 2012/7/31 Michael Snoyman <michael at snoyman.com>:
>>> On Tue, Jul 31, 2012 at 1:13 PM, Alexander Foremny
>>> <alexanderforemny at gmail.com> wrote:
>>>> 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 at haskell.org
>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>> 
>>> I think you might be looking for something like vault[1].
>>> 
>>> HTH,
>>> Michael
>>> 
>>> [1] http://hackage.haskell.org/package/vault
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>