为什么我无法在Haskell中使用id的Functor实例？

Question

当制作我的自定义Either和Functor，只是为了了解更清晰的类型和类型类，我发现了以下情况：

Functor

module Functor (Functor, fmap) where 

import Prelude hiding(Functor, fmap) 

class Functor f where 
    fmap :: (a -> b) -> f a -> f b 

Either

module Either(Either(..)) where 
import Prelude hiding(Either(..), Functor, fmap) 

data Either a b = Left a | Right b deriving(Show) 

instance Functor (Either a) where 
    fmap f (Right x) = Right (f x) 
    fmap _ (Left x) = Left x 

的上面显示的代码编译得很好但是，如果我改变它使用id，它不会编译：

instance Functor (Either a) where 
    fmap f (Right x) = Right (f x) 
    fmap _ = id 

为什么？我错过了什么？下面的代码也不起作用：

instance Functor (Either a) where 
    fmap f (Right x) = Right (f x) 
    fmap f all@(Left x) = all 

...这似乎对我很奇怪，因为该代码显示如下编译：

data Shape = Circle Point Float | Rectangle Point Point deriving (Show) 

data Point = Point Float Float deriving (Show) 

test :: Shape -> String 
test (Circle _ x) = show x 
test all@(Rectangle _ x) = show all ++ " - "++ show x 

预先感谢您

Answer 1

你想做些什么归结为：

f :: Either a Bool -> Either a() 
f (Right _) = Right() 
f left = left 

错误：

foo.hs:3:7: 
    Couldn't match type ‘Bool’ with ‘()’ 
    Expected type: Either a() 
     Actual type: Either a Bool 
    In the expression: left 
    In an equation for ‘f’: f left = left 
Failed, modules loaded: none. 

left绑定到该函数的参数。所以类型检查器知道它是Either a Bool。然后它被用作返回值。我们从f :: Either a Bool -> Either a()知道返回值必须是Either a()。如果left是有效的返回值，则其类型必须匹配返回类型f。所以Either a()必须等于Either a Bool;它不是，所以类型检查程序拒绝该程序。

反过来，它基本上是相同的问题，因为这样的：

λ let l = Left() :: Either()() 
l :: Either()() 

λ l 
Left() 
it :: Either()() 

λ l :: Either() Bool 

<interactive>:10:1: 
    Couldn't match type ‘()’ with ‘Bool’ 
    Expected type: Either() Bool 
     Actual type: Either()() 
    In the expression: l :: Either() Bool 
    In an equation for ‘it’: it = l :: Either() Bool 

我们给l绑定和类型，然后试图用它为不同的类型。这是无效的（并通过id喂养它也不会改变它的类型）。尽管Left()对于Either() Bool类型的值也是有效的10源代码文本，但这并不意味着可以使用源文本Left()定义的已知类型为Either()()的特定值可以像使用键入Either() Bool。

如果你有一个多态值，你可以这样做：

λ let l = Left() 
l :: Either() b 

λ l :: Either()() 
Left() 
it :: Either()() 

λ l :: Either() Bool 
Left() 
it :: Either() Bool 

而且，原l值b这里是多态的;它可以作为Either() b用于任何 b。

但您的fmap情况是微妙的不同。 函数fmap在b中是多态的，但其参数的值是“在多态性的范围内”;在你有论点的时候，b这个类型被fmap的调用者选为，所以它是“某种未知类型可以被任何东西”，而不是“我喜欢选择的任何类型”。无法以某种方式将Either a b类型的值转换为Either a c类型的值，因此您必须提取a值，然后创建一个包含它的Either a c。

Answer 2

让我们来看看FMAP类型专门为Either函子：

fmap :: (a -> b) -> Either e a -> Either e b 

我们由此可见，在fmap f all@(Left _)中，all的类型为Either e a。这与fmap的签名规定的预期结果类型Either e b不匹配，因此fmap f all@(Left _) = all不是很好的类型。

类似的情况下使用id。

Answer 3

在解释类型错误方面，我没有什么可以添加到前面的两个答案，但是我想提到Left x :: Either t a在内存中的表示方式与Left x :: Either t b相同。这意味着即使类型系统不允许使用Either t a代替Either t b类型的值，但由于其他答案已经完全清楚地解释了原因，您可以使用unsafeCoerce通过类型检查程序“强制”它：

import Unsafe.Coerce (unsafeCoerce) 

instance Functor (Either t) where 
    fmap f (Right a) = Right (f a) 
    fmap f l   = unsafeCoerce l 

而且即使unsafeCoerce通常被视为东西，以避免，如果你知道自己在做什么，和你有一个正当的理由这样做，如性能，unsafeCoerce可以让编译器是有用的知道您确定运行时值将与预期的结构匹配。

在这种情况下，没有unsafeCoerce，并且不考虑任何潜在的GHC优化，fmap f (Left x) = Left x总是构造一个新的，但物理上相同Left值，而unsafeCoerce味道也只是没有额外的内存分配返还原物Left值。