主页 / coding / 问题 / 78320292
Accepted
Materia Gravis
Asked: 2024-04-13 18:33:49 +0800 CST

在 Haskell 中根据状态过滤列表

  • 772

我一直在研究 ListT 的实现，以找到一种好方法来做这样的事情：

func list = do
  set <- get -- Data.Set
  el <- list
  guard $ Set.notMember el set
  return el

我知道我可以使用 ListT.fromFoldable，但我希望能够使用此流作为更大处理管道的一部分，而无需在每一步从列表转换为流并返回。也许是这样的：

func' list = (ListT.toReverseList . ListT.take 5 . func . ListT.fromFoldable) list

据我了解，这里应该使用流式传输方法。但我不明白如何使用例如list-t package来做到这一点。遍历能否以某种方式过滤掉流中的结果？我没有看到人们问这个问题，所以也许这种方法本身就有缺陷？

list

2 个回答

  1. Best Answer

    回答编辑前的原始问题：

    据我了解，这里应该使用流式传输方法。但我不明白如何使用例如list-t包来做到这一点。

    如果你的 monad 足够懒，你可以使用常规列表：

    import Control.Monad (filterM)
import Control.Monad.Trans.State.Lazy (State, get)
import Data.Set (Set, member)

filterStateLazy :: Ord a => [a] -> State (Set a) [a]
filterStateLazy = filterM $ \x -> do
    s <- get
    pure $ x `member` s

-- >>> import Control.Monad.Trans.State.Lazy (evalState)
-- >>> import qualified Data.Set as Set
-- >>> take 5 . evalState (filterStateLazy [1..]) $ Set.fromList [1, 6, 22, 39, 54]
-- [1,6,22,39,54]

    如果你真的想要ListT，你也可以使用它，并且不需要惰性 monad：

    {-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE LambdaCase #-}

import ListT
import Control.Monad.State.Strict
import Data.Set (Set, member)

filterStateLazy :: (MonadState (Set a) m, Ord a) => ListT m a -> ListT m a
filterStateLazy (ListT run) = ListT $ run >>= \case
    Nothing -> return Nothing
    Just (x, rest) -> do
        s <- get
        if x `member` s
            then pure $ Just (x, filterStateLazy rest)
            else uncons $ filterStateLazy rest

-- >>> import Control.Monad.Trans.State.Lazy (evalState)
-- >>> import qualified ListT as ListT
-- >>> import qualified Data.Set as Set
-- >>> evalState (ListT.toList . ListT.take 5 . filterStateLazy $ ListT.fromFoldable [1..]) $ Set.fromList [1, 6, 22, 39, 54]
-- [1,6,22,39,54]
    • 3

  2. 虽然 @effectously 的答案效果很好，但您可能正在mfilter寻找Control.Monad：

    func act = do
  st <- get
  mfilter (`Set.notMember` st) act

    在上下文中，借用 @effectively 的例子：

    import ListT
import Control.Monad
import Control.Monad.State
import Data.Set (Set)
import qualified Data.Set as Set

func :: (MonadState (Set a) m, Ord a) => ListT m a -> ListT m a
func act = do
  st <- get
  mfilter (`Set.notMember` st) act

runM :: ListT (State (Set a)) a -> Set a -> [a]
runM act state0 = evalState (ListT.toList act) state0

main :: IO ()
main = print $ runM (ListT.take 5 . func . ListT.fromFoldable $ [1..]) (Set.fromList [1,6,22,39,54])
    • 1

相关问题