Quiero crear una estructura de datos para almacenar elementos etiquetados a nivel de tipo usando Symbol. Esta:

data Store e (ss :: [Symbol]) where
  Nil :: Store e '[]
  Cons :: e s -> Store e ss -> Store e (s ': ss)

data HasElem (a :: k) (as :: [k]) where
  AtHead :: HasElem a (a ': as)
  InTail :: HasElem a as -> HasElem a (b ': as)

class HasElemC (a :: k) (as :: [k]) where hasElem :: HasElem a as
instance HasElemC {OVERLAPPING} a (a ': as) where hasElem = AtHead
instance HasElemC a as => HasElemC a (b ': as) where hasElem = InTail hasElem

from :: HasElemC s ss => Store e ss -> e s
from = from' hasElem

from' :: HasElem s ss -> Store e ss -> e s
-- from' _ Nil = undefined
from' h (Cons element store) = case h of
  AtHead -> element
  InTail h' -> from' h' store

funciona un poco, si descuidas el hecho de que el compilador me advierte por no suministrarfrom' _ Nil definición (¿por qué, por cierto? ¿hay alguna manera de hacer que se detenga?) Pero lo que realmente quería hacer al principio era usar la biblioteca de singletons de forma idiomática, en lugar de escribir mi propio código de nivel de tipo. Algo como esto:

import Data.Singletons.Prelude.List

data Store e (ss :: [Symbol]) where
  Nil :: Store e '[]
  Cons :: Sing s -> e s -> Store e ss -> Store e (s ': ss)

from :: Elem s ss ~ True => Store e ss -> e s
from (Cons evidence element nested) = ???

Lamentablemente, no pude encontrar la manera de convertir el contexto en una igualdad proposicional. ¿Cómo puedes usar bloques de construcción de la biblioteca de singletons para hacer lo que estoy tratando de hacer?

[email protected], [email protected]