显式导入实例 [英] Explicitly import instances

问题描述

如何显式导入类型实例？此外，如何使用合格的导入来执行此操作？

目前，我在做

  import Control.Monad.Error（）
  

导入monad实例我可以使用（任一字符串）。以前我用过

$ p $ c $ import import Control.Monad.Error
code $

我对任何一个都不满意，因为 Monad 实例被隐式导入。

解决方案

无法控制实例的导入是Haskell类型类系统的一个折衷。这里有一个假设的Haskell方言的例子，你可以：

Foo.hs：

  module Foo where 
 
 data Foo = FooA | FooB派生（Eq，Ord）
  

Bar.hs：

 模块Bar（myMap）其中
 
导入Data.Map（映射）
导入限定数据。 Map as Map 
 
 import Foo 
 
 myMap :: Map Foo Int 
 myMap = Map.singleton FooA 42 
  

Baz.hs：

 模块Baz其中
 
导入Data.Map（映射）
将限定的Data.Map导入为映射
 
导入Foo隐藏（实例Ord Foo）
导入Bar（myMap）
 
实例Ord Foo其中
 FooA> FooB = True 
 FooB> FooA = False 
 
 ouch :: Map Foo Int 
 ouch = Map.insert FooB 42 myMap 
  

哎呀！集合 myMap 是使用正确的实例Ord Foo 创建的，但它与由不同的，矛盾的实例。

能够做到这一点违反了Haskell的开放世界假设。不幸的是，我不知道有一个好的，集中的资源来了解它。这个 RWH部分可能会有帮助（我搜索haskell open world assumption）。

How do I explicitly import typeclass instances? Also, how do I do this with a qualified import?

Currently, I'm doing

import Control.Monad.Error ()

to import the monad instance that I can use for (Either String). Previously, I used

import Control.Monad.Error

I'm not satisfied with either one, because the Monad instance is implicitly imported.

解决方案

The inability to control imports of instances is one of the trade-offs the Haskell typeclass system makes. Here's an example in a hypothetical Haskell dialect where you can:

Foo.hs:

module Foo where

data Foo = FooA | FooB deriving (Eq, Ord)

Bar.hs:

module Bar (myMap) where

import Data.Map (Map)
import qualified Data.Map as Map

import Foo

myMap :: Map Foo Int
myMap = Map.singleton FooA 42

Baz.hs:

module Baz where

import Data.Map (Map)
import qualified Data.Map as Map

import Foo hiding (instance Ord Foo)
import Bar (myMap)

instance Ord Foo where
  FooA > FooB = True
  FooB > FooA = False

ouch :: Map Foo Int
ouch = Map.insert FooB 42 myMap

Yikes! The set myMap was created with the proper instance Ord Foo, but it's being combined with a map created with a different, contradictory instance.

Being able to do this would violate Haskell's open world assumption. Unfortunately, I don't know of a good, centralised resource for learning about it. This section of RWH might be helpful (I searched for "haskell open world assumption").

这篇关于显式导入实例的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！