Haskell — помогите упростить функцию с расширенными функциями типов

Да, на самом деле вы можете сделать это с помощью классов типов. Разумно это или нет — спорный вопрос (для вашего простого типа Value сопоставление с образцом, вероятно, является лучшим решением), но все равно интересно :)

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeSynonymInstances #-}
module Main where

data Value = VStr String | VInt Int | VBool Bool

class FromValue a where
    fromValue :: Value -> Maybe a
instance FromValue String where
    fromValue (VStr s) = Just s
    fromValue _ = Nothing

ensureType :: (Monad m, FromValue a) => Value -> m a
ensureType = maybe (fail "type error!") return . fromValue

interpreterFunction :: Value -> IO ()
interpreterFunction val = 
    do s <- ensureType val
       putStrLn s

main =
    do interpreterFunction (VStr "asd")
       interpreterFunction (VInt 1)

Отпечатки:

asd
*** Exception: user error (type error!)

Вы также можете использовать расширение ScopedTypeVariables, чтобы указать определенный тип, когда его невозможно вывести:

{-# LANGUAGE ScopedTypeVariables #-}
interpreterFunction2 :: Value -> IO ()
interpreterFunction2 val = 
    do (s :: String) <- ensureType val
       print s

Кстати, ваш первоначальный подход кажется мне немного "неправильным":

VStr s <- ensureType p TString

Хотя вы можете быть уверены (самоанализом), что ensureType x TString никогда не возвращает ничего, кроме строки, это не обеспечивается системой типов, и соответствие шаблону не является исчерпывающим. Это не большая проблема, но вы можете легко исключить возможность сбоя во время выполнения этой функции, используя вместо этого специальную функцию "извлечение строки":

ensureString :: (Monad m) => Value -> m String
{- ... -}
s <- ensureString val

1. Чистый, понятный простой способ:

Я думаю, что тип союза с тегами, который вы определяете

data Value = VStr String | VInt Int | VBool Bool

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

interpreterFunction :: Value -> SomeMonadicContext ReturnType
interpreterFunction (Vstr s) = do
    some code that uses s
interpreterFunction _ = do
    some error handling code

Тебе понравилось:

interpreterFunction p = do
    s <- ensureType p
    ..
    same code that uses s

говоря

«Здесь из кода после s ‹- можно сделать вывод, что s имеет тип String, и статически известно, что единственным конструктором Value, который имеет часть String, является VStr, поэтому sureType возвращает String после динамической проверки, является ли p VStr.

Моя версия также динамически проверяет, является ли p VStr. Статически известно, что единственным конструктором Value, который имеет часть String, является VStr, но на самом деле это довольно сложно использовать.

2. Менее чистый способ, основанный на классе типов

Нам нужно создать экземпляр String, поэтому нам нужно

{-# LANGUAGE TypeSynonymInstances, FlexibleInstances #-}

class FromValue a where 
   ensureType :: Value -> SomeMonadicContext a

Примеры:

instance FromValue String where
   ensureType (VStr s) = return s
   ensureType  _       = fail $ unlines 
                          ["Yikes, I'd rather have thrown a Nothing than a fail,"
                          ,"but then I'd have to have detagged the Just later"
                          ,"and then I may as well have used solution 1 anyway!"]

instance FromValue Int where
   ensureType (VInt i) = return i
   ensureType  _       = fail "Oh no, do I really have to use catch?"

Что дало бы

interpreterFunction :: Value -> IO String
interpreterFunction p = do
    s <- ensureType p
    return $ s ++ ", yay!" -- example String-specific code.

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

2b. Может быть?

Использование типа данных Maybe в ensureType позволит избежать досадного сбоя/улова, но тогда вам придется выполнить Just s <- ensureType p или использовать функцию maybe, и все это по крайней мере столько же работы, сколько и обычное совпадение с шаблоном.

3. Что-то умное и новое, но неуместное

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