作为类型类实例的函数？

Question

{-# LANGUAGE LambdaCase #-}

我有一堆以各种方式编码失败的函数。例如：

• f :: A -> Bool回报False失败
• g :: B -> Maybe B'回报Nothing失败
• h :: C -> Either Error C'回报Left ...失败

我想链以同样的方式，这些操作为Maybe单子，所以链接函数需要知道每个函数是否失败，然后才能继续下一个函数。为此，我写了这个类：

class Fail a where 
    isFail :: a -> Bool 
instance Fail() where 
    isFail() = False 
instance Fail Bool where -- a 
    isFail = not 
instance Fail (Maybe a) where -- b 
    isFail = not . isJust 
instance Fail (Either a b) where -- c 
    isFail (Left _) = True 
    isFail _ = False 

但是，它可能是不符合功能存在：

• f' :: A -> Bool回报True失败
• g' :: B -> Maybe Error回报Just Error失败（Nothing成功）
• h' :: C -> Either C' Error返回Right ...失败

这些可以通过简单地与改造他们，例如功能包它们来补救：

• f'' = not . f'。
• g'' = (\case Nothing -> Right(); Just e -> Left e) . g'
• h'' = (\case Left c -> Right c; Right e -> Left e) . h'

然而，链接功能的用户希望能够结合f，g，h，f'，g'和h'并让他们只是工作。他不会知道函数的返回类型需要被转换，除非他查看了他所组合的每个函数的语义，并检查它们是否与范围内的任何其他实例匹配。对于普通用户来说，这是单调乏味而且太微妙的，尤其是对于绕过用户不得不选择正确实例的类型推断而言。

这些函数不是在知道如何使用它们的情况下创建的。所以我可以创建一个类型data Result a b = Fail a | Success b并在每个函数周围创建包装。例如：

• fR = (\case True -> Sucess(); False -> Fail()) . f
• f'R = (\case False -> Sucess(); True -> Fail()) . f'
• gR = (\case Just a -> Sucess a; Nothing -> Fail()) . g
• g'R = (\case Nothing -> Sucess(); Just e -> Fail e) . g'
• hR = (\case Left e -> Fail e; Right a -> Sucess a) . h
• h'R = (\case Right e -> Fail e; Left a -> Sucess a) . h'

然而，这种感觉很脏。我们正在做的仅仅是证明/解释如何在组合函数的上下文中使用f,g,h,f',g'和h'中的每一个。是否有更直接的方式来做到这一点？我要的到底是一个方式说，应使用其Fail类型类的实例为每个功能，即，（使用提供给上述类型类实例的名称），f→a，g→b，h→c，并f' →a'，g'→b'，h'→c'为“无效”的功能，其中a'，b'和c'被定义为以下情况（重叠于以前的，所以你需要能够通过名称来接他们不知何故）：

instance Fail Bool where -- a' 
    isFail = id 
instance Fail (Maybe a) where -- b' 
    isFail = isJust 
instance Fail (Either a b) where -- c' 
    isFail (Right _) = True 
    isFail _ = False 

虽然不一定要通过类特性来完成。也许有一些方法可以做到这一点，而不是类型类？

Answer 1

不要这样做。 Haskell的静态类型系统和参考透明性为您提供了非常有用的保证：您可以确定某些特定的值意味着相同的事情，而不管它是如何生成的。对于这种干扰既没有可变性，也没有动态风格的表达式的运行时重新解释”，正如你所期望的那样。

如果你那里的那些功能没有相应地遵守这样的规范，那么这很糟糕。更好地摆脱它们（至少，隐藏他们，并只导出重新定义的版本与统一的行为）。或者告诉用户他们将不得不一起查找每个用户的规格。但不要试图绕开这个破碎定义的特定症状。

你可以适用于只是“标志”功能的一个简单变化，其中失败意味着它，否则确实是让他们回归这样的包裹的结果正好相反：

newtype Anti a = Anti { profail :: a } 

instance (Anti a) => Fail (Anti a) where 
    isFail (Anti a) = not $ isFail a 

---

_{注意：“同样的事情”可能非常抽象。有没有必要为Left是普遍一个“失败构造”，这是足够了很明显，这是相关联的第一个类型参数的变型的构造，这是不什么仿/单子实例从它 –工作自动跟随，这将“意味着”在monadic应用程序中失败。
即，当你选择了正确的类型时，东西应该是非常自动的;当你仅仅是tossing around booleans，显然是相反的，所以也许你应该完全摆脱那些...}