从一组单子动作中获取第一个“非空”值的标准组合器

Question

我确定我在这里遗漏了一些非常明显的东西。以下是我试图在概念层面实现的目标：

action1 :: (MonadIO m) => m [a]
action1 = pure []

action2 :: (MonadIO m) => m [a]
action2 = pure [1, 2, 3]

action3 :: (MonadIO m) => m [a]
action3 = error "should not get evaluated"

someCombinator [action1, action2, action3] == m [1, 2, 3]

这个假设的someCombinator 存在吗？我尝试过使用<|> 和msum，但无法得到我想要的。

我想，这可以概括为两种方式：

-- Will return the first monadic value that is NOT an mempty 
-- (should NOT blindly execute all monadic actions)
-- This is something like the msum function

someCombinator :: (Monoid a, Monad m, Traversable t, Eq a) => t m a -> m a

-- OR

-- this is something like the <|> operator

someCombinator :: (Monad m, Alternative f) => m f a -> m f a -> m f a

Answer 1

我不知道提供这个的库，但实现起来并不难：

someCombinator :: (Monoid a, Monad m, Foldable t, Eq a) => t (m a) -> m a 
someCombinator = foldr f (pure mempty)
    where
        f item next = do
            a <- item
            if a == mempty then next else pure a

请注意，您甚至不需要Traversable：Foldable 就足够了。

Answer 2

在抽象级别上，第一个非空值是一个名为 First 的 Monoid。然而，事实证明，如果你只是天真地将IO 值提升为First，那么action3、since the default monoidal append operation is strict under IO 就会出现问题。

您可以使用来自this answer 的FirstIO 类型获得惰性幺半群计算。它不会比 Fyodor Soikin 的回答更好，但它强调（我希望）你可以如何从通用抽象中组合行为。

除了上面提到的FirstIO wrapper，你可能会发现这个函数很有用：

guarded :: Alternative f => (a -> Bool) -> a -> f a
guarded p x = if p x then pure x else empty

我基本上只是从Protolude 复制它，因为我在 base 中找不到具有所需功能的一个。您可以使用它将列表包装在Maybe 中，以便它们适合FirstIO：

> guarded (not . null) [] :: Maybe [Int]
Nothing
> guarded (not . null) [1, 2, 3] :: Maybe [Int]
Just [1,2,3]

对您的操作列表中的每个操作执行此操作，并将它们包装在 FirstIO 中。

> :t (firstIO . fmap (guarded (not . null))) <$> [action1, action2, action3]
(firstIO . fmap (guarded (not . null))) <$> [action1, action2, action3]
  :: Num a => [FirstIO [a]]

在上面的 GHCi sn-p 中，我只显示了带有:t 的类型。我无法显示该值，因为 FirstIO 没有 Show 实例。然而，关键是您现在有一个 FirstIO 值列表，mconcat 将从其中选择第一个非空值：

> getFirstIO $ mconcat $ (firstIO . fmap (guarded (not . null))) <$> [action1, action2, action3]
Just [1,2,3]

如果要解压Maybe，可以使用fromMaybe from Data.Maybe:

answer :: IO [Integer]
answer =
  fromMaybe [] <$>
  (getFirstIO $ mconcat $ (firstIO . fmap (guarded (not . null))) <$> [action1, action2, action3])

这显然比 Fyodor Soikin 的回答更复杂，但我对 Haskell 如何让您通过“点击”现有事物（几乎就像乐高积木）来组装所需功能感到着迷。

那么，对于这个组合器是否已经存在的问题？答案是它确实存在，但需要一些组装。