haskell - 'unsafeCoerce' 的使用

Question

在 Haskell 中，有一个名为 unsafeCoerce 的函数。 ，这会将任何东西变成任何其他类型的东西。这究竟是用来做什么的？比如，为什么我们要以这种“不安全”的方式将事物相互转化？

提供一个方式的例子 unsafeCoerce实际使用。 Hackage 的链接会有所帮助。有人问题中的示例代码不会。

Answer 1

unsafeCoerce 可让您说服类型系统您喜欢的任何属性。因此，只有当您可以完全确定您声明的属性为真时，它才是“安全的”。因此，例如:

unsafeCoerce True :: Int

是一种违规行为，可能会导致不稳定的、不良的运行时行为。

unsafeCoerce (3 :: Int) :: Int

(显然)很好，不会导致运行时不当行为。

那么 unsafeCoerce 的重要用途是什么？假设我们有一个类型类绑定(bind)的存在类型

module MyClass ( SomethingMyClass (..), intSomething ) where

class MyClass x where {}

instance MyClass Int where {}

data SomethingMyClass = forall a. MyClass a => SomethingMyClass a

我们还要说，正如这里所指出的，类型类 MyClass 没有被导出，因此没有人可以创建它的实例。实际上， Int 是唯一实例化它的东西，也是唯一实例化它的东西。

现在，当我们使用模式匹配来破坏 SomethingMyClass 的值时，我们将能够从内部取出一个“东西”

foo :: SomethingMyClass -> ...
foo (SomethingMyClass a) =
  -- here we have a value `a` with type `exists a . MyClass a => a`
  --
  -- this is totally useless since `MyClass` doesn't even have any
  -- methods for us to use!
  ...

现在，在这一点上，正如评论所暗示的那样，我们提取的值没有类型信息——它被存在上下文“遗忘”了。它绝对可以是任何实例化 MyClass 的东西。

当然，在这种非常特殊的情况下，我们知道唯一实现 MyClass 的是 Int 。所以我们的值 a 实际上必须具有类型 Int 。我们永远无法说服类型检查员这是真的，但由于外部证据，我们知道这是真的。

因此，我们可以(非常小心地)

intSomething :: SomethingMyClass -> Int
intSomething (SomethingMyClass a) = unsafeCoerce a    -- shudder!

现在，希望我已经提出这是一个可怕的、危险的想法，但它也可以让我们体验一下我们可以利用什么样的信息来了解类型检查器无法知道的事情。

在非病理情况下，这种情况很少见。更罕见的是，使用我们知道的东西而类型检查器本身并不是病态的。在上面的例子中，我们必须完全确定没有人会扩展我们的 MyClass 模块来将更多类型实例化到 MyClass 否则我们对 unsafeCoerce 的使用立即变得不安全。

> instance MyClass Bool where {}
> intSomething (SomethingMyClass True)
6917529027658597398

看起来我们的编译器内部正在泄漏!

此类行为可能有值(value)的更常见示例是使用 newtype 包装器时。我们可能将类型包装在 newtype 包装器中以便专门化其 instance 定义，这是一个相当普遍的想法。

例如， Int 没有 Monoid 定义，因为在 Int s 上有两个自然幺半群:和和乘积。相反，我们使用 newtype 包装器来更加明确。

newtype Sum a = Sum { getSum :: a }

instance Num a => Monoid (Sum a) where
  mempty = Sum 0
  mappend (Sum a) (Sum b) = Sum (a+b)

现在，通常编译器非常聪明，并且认识到它可以消除所有那些 Sum 构造函数以生成更高效的代码。可悲的是，有时它不能，尤其是在高度多态的情况下。

如果您 (a) 知道某种类型 a 实际上只是一个 newtype-wrapped b 并且 (b) 知道编译器无法自行推断，那么您可能想要这样做

unsafeCoerce (x :: a) :: b

以获得轻微的效率增益。例如，这经常发生在 lens 中，并在 Data.Profunctor.Unsafe 的 profunctors 模块中表示，这是 lens 的依赖项。

但是让我再次建议您在使用 unsafeCoerce 之前确实需要知道发生了什么，因为这绝不是非常不安全的。

要比较的最后一件事是 cast 中可用的“类型安全 Data.Typeable”。这个函数看起来有点像 unsafeCoerce ，但有更多的仪式感。

unsafeCoerce ::                             a ->       b
cast         :: (Typeable a, Typeable b) => a -> Maybe b

其中，您可能认为是使用 unsafeCoerce 和函数 typeOf :: Typeable a => a -> TypeRep 实现的，其中 TypeRep 是不可伪造的运行时 token ，它们反射(reflect)了值的类型。然后我们有

cast :: (Typeable a, Typeable b) => a -> Maybe b
cast a = if (typeOf a == typeOf b) then Just b else Nothing 
  where b = unsafeCoerce a

因此， cast 能够确保 a 和 b 的类型在运行时确实相同，如果不同，它可以决定返回 Nothing。举个例子:

{-# LANGUAGE DeriveDataTypeable        #-}
{-# LANGUAGE ExistentialQuantification #-}

data A = A deriving (Show, Typeable)
data B = B deriving (Show, Typeable)

data Forget = forall a . Typeable a => Forget a

getAnA :: Forget -> Maybe A
getAnA (Forget something) = cast something

我们可以按如下方式运行

> getAnA (Forget A)
Just A
> getAnA (Forget B)
Nothing

因此，如果我们将 cast 的这种用法与 unsafeCoerce 进行比较，我们会发现它可以实现一些相同的功能。特别是，它允许我们重新发现可能被 ExistentialQuantification 遗忘的信息。但是， cast 在运行时手动检查类型以确保它们确实相同，因此不能不安全地使用。为此，它要求源类型和目标类型都允许通过 Typeable 类对其类型进行运行时反射。