如何在 Haskell 中实现非引用透明数据结构？

Question

我想实现一个数据结构，当我注册它时会给我一个“签名”，因此我可以：

1. 查询签名是否存在
2. 合并两个这样的 DS，同时保持正确的行为
3. 删除给定的签名

可能有点模糊，但很容易实现，比如用 Java 实现，如下所示：

class Sig {}

class DesiredDS<A> {
    HashMap<Sig, A> map = new HashMap<>();

    public Sig insertWithNewSig(A a) {
        Sig s = new Sig();
        map.put(s, a);
        return s;
    }
    // ...
    // merge will be only to merge to map and delete will be only to delete the key
}

但我摸不着头脑，不知道如何在 Haskell 中使用参考透明度的属性来做到这一点。

有什么好主意吗？可能对此的等效答案是：如何在 Haskell 中生成一个可以比较相等的数据结构，而我不需要费心决定它的值？

Answer 1

可能最简单的方法是使用类似的东西

type Signature a = IORef (Maybe a)

您对其进行操作：

1. 查询签名是否存在

   live :: Signature a -> IO Bool
   live ref = isJust <$> readIORef ref
   

2. 合并两个这样的 DS，同时保持正确的行为

   (...什么是“正确的行为”？)

3. 删除给定的签名

   delete :: Signature a -> IO ()
   delete ref = writeIORef ref Nothing
   

4. 创建新签名

   insertNewSignature :: a -> IO (Signature a)
   insertNewSignature a = newIORef (Just a)
   

5. 比较等于

   (==) :: Signature a -> Signature a -> Bool
   

而且，虽然您没有要求它，但大概您实际上不仅希望能够检查签名是否存在，而且还希望能够从签名中恢复值，您可以对其进行操作

readIORef :: Signature a -> IO (Maybe a)

Answer 2

你有很多选择！如果您希望随机签名以获得唯一性，我建议使用randomness monad 来处理您的随机种子，并使用StateT 来管理您的HashMap。大致是这样的：

type Sig = -- Something big enough that's an instance of `Random`
newtype DS a = DS (HashMap Sig a)
insert :: (MonadRandom m, MonadState (DS a) m) => a -> m Sig
insert a = do
  ds <- get
  ds' <- HM.insert <$> getRandom <*> pure a
  put ds'

Answer 3

使用不安全的 I/O 算作弊吗？

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module Lib where

import           Data.Map (Map)
import qualified Data.Map as Map
import           Data.Monoid
import           Data.Unique (Unique)
import qualified Data.Unique as Unique
import           System.IO.Unsafe

newtype Registrar a =
  Registrar (Map Unique a)
  deriving (Eq, Monoid)

insert :: a -> Registrar a -> (Unique, Registrar a)
insert value (Registrar amap) =
  (u, Registrar (Map.insert u value amap))
  where
    u = unsafePerformIO Unique.newUnique

merge :: Registrar a -> Registrar a -> Registrar a
merge = (<>)

delete :: Unique -> Registrar a -> Registrar a
delete signature (Registrar amap) =
  Registrar (Map.delete signature amap)