haskell - 为涉及向量的递归数据结构定义可存储

Question

我有以下形式的数据结构(V 是 Data.Storable.Vector):

data Elems = I {-# UNPACK #-} !GHC.Int.Int32
             | S {-# UNPACK #-} !GHC.Int.Int32 {-# UNPACK #-} !(Ptr CChar)
             | T {-# UNPACK #-} !(V.Vector Elems)
                deriving (Show)

我首先为非递归形式编写了一个自定义可存储定义(即没有 T 构造函数)。然后，我尝试使用 ForeignPtr 和 Vector 中的 length 信息为 T 添加自定义 peek 和 poke 定义(代码在下面)。 GHC 编译器提示没有为 ForeignPtr Elems 类型定义 Storable 实例。我的问题是是否可以将 ptr 存储到 Storable 定义中的 Vector，而不必被迫为ForeignPtr 编写 Storable 实例定义。

来自Haddocs文档中，ForeignPtr 似乎只是一个分配有 Finalizer 的 Ptr:

The essential difference between ForeignPtrs and vanilla memory references of type Ptr a is that the former may be associated with finalizers.

我不想通过使用 Ptr 而不是 ForeignPtr 来解决该问题，因为最终确定它存在问题。因此，我更喜欢存储ForeignPtr的位置(通过Ptr (ForeignPtr a))，以便GHC垃圾收集器知道对它的引用。但是，这种方法将迫使我定义一个 Storable 实例(因为约束 (Storable a) => Ptr a 这是有意义的)。

是否有一种方法可以在 Storable 中将 ptr 存储和检索到 Vector，而无需为ForeignPtr 定义 Storable 实例？如果没有，那么必须编写ForeignPtr的Storable定义。那样的话，会是什么样子呢？我的猜测是它只会将 Ptr 存储到ForeignPtr。

完整代码如下:

{-# LANGUAGE MagicHash #-}
import qualified Data.Vector.Storable as V
import Foreign
import Foreign.C.Types (CChar)
import Foreign.Marshal.Array (lengthArray0)
import GHC.Int

data Elems = I {-# UNPACK #-} !GHC.Int.Int32
             | S {-# UNPACK #-} !GHC.Int.Int32 {-# UNPACK #-} !(Ptr CChar)
             | T {-# UNPACK #-} !(V.Vector Elems)
                deriving (Show)

instance Storable Elems where
  sizeOf _ = sizeOf (undefined :: Word8) + sizeOf (undefined :: Int32) + sizeOf (undefined :: Ptr CChar)
  alignment _ = 4

  {-# INLINE peek #-}
  peek p = do
      let p1 = (castPtr p::Ptr Word8) `plusPtr` 1 -- get pointer to start of the element. First byte is type of element
      t <- peek (castPtr p::Ptr Word8)
      case t of
        1 -> do 
          x <- peek (castPtr p1 :: Ptr GHC.Int.Int32) 
          return (I x)
        2 -> do 
          x <- peek (castPtr p1 :: Ptr GHC.Int.Int32) 
          y <- peek (castPtr (p1 `plusPtr` 4) :: Ptr (Ptr CChar)) -- increment pointer by 4 bytes first
          return (S x y)
        _ -> do
          x <- peek (castPtr p1 :: Ptr Int)
          y <- peek (castPtr (p1 `plusPtr` 8) :: Ptr (ForeignPtr Elems)) 
          return (T (V.unsafeFromForeignPtr y 0 x)) -- return vector

  {-# INLINE poke #-}
  poke p x = case x of
      I a -> do
        poke (castPtr p :: Ptr Word8) 1  
        poke (castPtr p1) a
      S a b -> do
        poke (castPtr p :: Ptr Word8) 2
        poke (castPtr p1) a
        poke (castPtr (p1 `plusPtr` 4)) b -- increment pointer by 4 bytes first
      T x -> do
        poke (castPtr p :: Ptr Word8) 3
        let (fp,_,n) = V.unsafeToForeignPtr x
        poke (castPtr p1) n
        poke (castPtr (p1 `plusPtr` 8)) fp

      where  p1 = (castPtr p :: Ptr Word8) `plusPtr` 1 -- get pointer to start of the element. First byte is type of element

Answer 1

ForeignPtr 无法成为Storable，因为它们的实现需要一种将一个或多个终结器指针关联到原始指针的方法，并且这种关联是依赖于运行时的。要使 ForeignPtr 可存储，您需要存储关联的 Ptr (这很容易)和关联的终结器数组(这是不可能的，因为终结器是运行时内部的，并且可能绑定(bind)到 GHC 运行时的 GC)。

但这不是这里需要解决的问题。

问题在于，没有合理的方法可以将包含 Vector 的东西变成 Storable 的东西。 Vector 需要为其内容提供托管内存(Storable.Vector 的定义是 data Vector a = Vector Int (ForeignPtr a) 加上一些严格注释)，但是 Storable 的全部目的是将一些值存储到非托管内存中。此外，Vector 根据其长度使用不同数量的内存，但Storable 数据结构必须使用常量内存量。

您需要重新考虑您的数据结构试图建模的内容。你真的需要像这样存储一个Vector吗？请记住，您正在存储 Elems 的 Vector，这意味着您可以拥有一个包含 Vector 的值 T包含一个T，其中包含一个Vector，其中包含一个T，等等。

我认为您可能会尝试对以下数据结构进行建模，但我可能是错的:

data Elems = OneElem Elem | ManyElems (Vector Elem)

data Elem
    = I !GHC.Int.Int32
    | S !GHC.Int.Int32 !(Ptr CChar)

如果您确实需要您所描述的递归数据结构，请尝试实现它:

data Elems
    = I !GHC.Int.Int32
    | S !GHC.Int.Int32 !(Ptr CChar)
    | T !GHC.Int.Int32 !(Ptr Elems)

指向某些Elems的指针使用常量内存，并且可以指向非托管内存，因此您可以为其创建可存储实例。