Невозможно правильно определить преобразование из универсального типа, определенного с помощью GADT.

Сначала отказ от ответственности: я не знаю всего контекста проблемы, которую вы пытаетесь решить, но первое впечатление, которое у меня возникает, заключается в том, что такое использование экзистенциалов является неправильным инструментом для работы, и вы, возможно, пытаетесь реализовать некоторые шаблон кода, который распространен в объектно-ориентированном языке, но плохо подходит для Haskell.

Тем не менее, экзистенциальные типы, такие как тот, который у вас есть здесь, обычно похожи на черные дыры, в которые, как только вы что-то вставляете, информация о типе теряется навсегда, и вы не можете вернуть значение к исходному типу. Однако вы можете работать с экзистенциальными значениями через классы типов (как вы сделали с Show и Read), поэтому вы можете использовать класс типов Typeable для сохранения исходной информации о типе:

import Data.Typeable

data AnyT where
    Any :: (Show a, Read a, Typeable a) => a -> AnyT

Теперь вы можете реализовать все имеющиеся у вас функции, если вы также добавите к ним новое ограничение:

readAnyT :: (Read a, Show a, Typeable a) => (String -> a) -> String -> AnyT
readAnyT readFun str = Any $ readFun str

showAnyT :: AnyT -> String
showAnyT (Any thing) = show thing

toAnyT :: (Show a, Read a, Typeable a) => a -> AnyT -- Rather useless
toAnyT a = Any a

fromAny может быть реализован как возврат Maybe a (поскольку вы не можете быть уверены, что получаемое вами значение имеет тот тип, который вы ожидаете).

fromAny :: Typeable a => AnyT -> Maybe a
fromAny (Any thing) = cast thing

Вы используете GADT для создания экзистенциального типа данных. Тип a в конструкторе существовал, но восстановить его невозможно. Единственная доступная вам информация состоит в том, что у него есть Show и Read экземпляры. Точный тип забывается, потому что это то, что тип вашего конструктора инструктирует делать система типов. «Убедитесь, что у этого типа есть правильные экземпляры, а затем забудьте, что это такое».

Кстати, есть одна функция, которую вы пропустили:

readLike :: String -> AnyT -> AnyT
readLike s (Any a) = Any $ read s `asTypeOf` a

В контексте сопоставления с шаблоном компилятор знает, что какой бы тип ни был у a, существует экземпляр Read, и он может применить этот экземпляр. Хотя не уверен, что это за тип a. Но все, что он может с ним сделать, это либо показать его, либо прочитать строки того же типа, что и он.

То, что у вас есть, называется экзистенциальным типом. Если вы перейдете по этой ссылке, то обнаружите, что в этом шаблоне единственный способ работать с «данными» внутри типа контейнера — использовать классы типов.

В вашем текущем примере вы упомянули, что a должен иметь экземпляры Read и Show, и это означает, что только функции в этих классах типов могут использоваться в a и ничего больше, и если вы хотите поддерживать еще несколько операций в a, тогда он должен быть ограничен с помощью требуемый класс типа.

Подумайте об этом так: вы можете положить что угодно в коробку. Теперь, когда вы извлекаете что-то из этой коробки, у вас нет возможности указать, что вы получите из нее, поскольку вы можете положить в нее что угодно. Теперь, если вы говорите, что можете положить в эту коробку любую съедобную вещь, то вы уверены, что когда вы выберете что-то из этой коробки, она будет съедобной.