Question

让我们说，我有以下类型：

type LinkID = Int

data Link = Link {
  lid :: LinkID,
  llength :: Int
  }

data Snap = Snap {
  slid :: LinkID,
  slength :: Int
  }

现在，我想编写一个基于管道的函数来执行此操作：

getSnaps :: LinkID -> [Link] -> [Snap] -> [(LinkID, [Snap])]
getSnaps l lks snp = map (\x -> (lid x, filter (\y -> lid x == slid y) snp)) a
  where a = filter (\x -> lid x > l) lks

假设我已经拥有Link和Snap的制作人，我怎样才能在这两位制作人的Pipes世界中实现上述getSnaps功能：

psnap :: Producer Snap IO ()
psnap = undefined

plink :: Producer Link IO ()
plink = undefined

psnap和plink的实际类型更复杂（使用attoparsec-pipes创建），但我想知道如何从psnap实现getSnaps的功能和plink。有没有正确的方法来解决这类问题？

Answer 1

我提出的解决方案与您的代码非常相似。我刚刚将map替换为Pipes.Prelude.map，其中一个过滤器替换为Pipes.Prelude.filter：

import Pipes
import qualified Pipes.Prelude as Pipes

type LinkID = Int

data Link = Link
    { lid :: LinkID
    , llength :: Int
    }

data Snap = Snap
    { slid :: LinkID
    , slength :: Int
    }

getSnaps
    :: Monad m
    => LinkID
    -> Producer  Link            m ()
    -> Producer  Snap            m ()
    -> Producer (LinkID, [Snap]) m ()
getSnaps l lks snp = do
    snp' <- lift (Pipes.toListM snp)  -- Cache `snp` into the list `snp'`
    lks >-> Pipes.filter (\x -> lid x > l)
        >-> Pipes.map (\x -> (lid x, filter (\y -> lid x == slid y) snp'))

请注意，有一个非平凡的部分，即上述解决方案严格将snp Producer的内容加载到列表snp'中。原因是我们必须重复使用列表的内容，因此我们需要将整个列表缓存在内存中以供重复使用。

管道简单函数的等效代码

1 个答案: