在 Haskell 中以应用风格组合验证器

Question

我对命令式编程有很好的掌握，但现在我自学了一个 Haskell。

我认为，我对 Monads、Functors 和 Applicatives 有很好的理论理解，但我需要一些练习。为了练习，我有时会从我目前的工作任务中得到一些东西。

我对以应用方式组合东西有点卡住了

第一个问题

我有两个验证函数：

import Prelude hiding (even)

even :: Integer -> Maybe Integer
even x = if rem x 2 == 0 then Just x else Nothing

isSmall :: Integer -> Maybe Integer
isSmall x = if x < 10 then Just x else Nothing

现在我想要由even 和isSmall 构建的validate :: Integer -> Maybe Integer

我最好的解决方案是

validate a = isSmall a *> even a *> Just a

这不是无意义的

我可以使用单子

validate x = do
  even x
  isSmall x
  return x

但是，如果（我想）我所需要的只是一个 Applicative，为什么还要使用 Monad？ （而且它仍然不是免费的）

这样做是否更好（并且更实用）？

第二个问题

现在我有两个具有不同签名的验证器：

even = ...

greater :: (Integer, Integer) -> Maybe (Integer, Integer)
-- tuple's second element should be greater than the first
greater (a, b) = if a >= b then Nothing else Just (a, b)

我需要validate :: (Integer, Integer) -> Maybe (Integer, Integer)，它在输入元组上尝试greater，然后在元组的第二个元素上尝试even。

和validate' :: (Integer, Integer) -> Maybe Integer 的逻辑相同，但返回元组的第二个元素。

validate  (a, b) = greater (a, b) *> even b *> Just (a, b)
validate' (a, b) = greater (a, b) *> even b *> Just  b

但我想输入元组 "flows" 进入 greater，然后 "flows" 进入 snd 和 even 的某种组合和那么只有单个元素会出现在最终的 Just 中。

haskeller 会做什么？

Answer 1

当您编写a -> Maybe b 形式的验证器时，您对整个类型比对Maybe 应用程序更感兴趣。 a -> Maybe b 类型是 Maybe monad 的 Kleisli 箭头。您可以制作一些工具来帮助处理这种类型。

对于你可以定义的第一个问题

(>*>) :: Applicative f => (t -> f a) -> (t -> f b) -> t -> f b
(f >*> g) x = f x *> g x

infixr 3 >*>

然后写

validate = isSmall >*> even

你的第二个例子是

validate = even . snd >*> greater
validate' = even . snd >*> fmap snd . greater

它们以不同的顺序检查条件。如果您关心评估顺序，您可以定义另一个函数<*<。

阅读器T

如果您经常使用 a -> Maybe b 类型，则可能值得为它创建一个 newtype，以便您可以添加自己的实例来执行您希望它执行的操作。 newtype 已经存在；它是ReaderT，它的实例已经做了你想做的事情。

newtype ReaderT r m a = ReaderT { runReaderT :: r -> m a }

当您使用r -> Maybe a 类型作为验证器来验证和转换单个输入r 时，它与ReaderT r Maybe 相同。 Applicative instance for ReaderT 通过将它们的两个函数应用于同一输入，然后将它们与 <*> 组合在一起，将它们组合在一起：

instance (Applicative m) => Applicative (ReaderT r m) where
    f <*> v = ReaderT $ \ r -> runReaderT f r <*> runReaderT v r
    ...

ReaderT 的<*> 与第一部分中的>*> 几乎完全相同，但它不会丢弃第一个结果。 ReaderT 的 *> 与第一部分中的 >*> 完全相同。

就ReaderT而言，您的示例变为

import Control.Monad.Trans.ReaderT

checkEven :: ReaderT Integer Maybe Integer
checkEven = ReaderT $ \x -> if rem x 2 == 0 then Just x else Nothing

checkSmall = ReaderT Integer Maybe Integer
checkSmall = ReaderT $ \x -> if x < 10 then Just x else Nothing

validate = checkSmall *> checkEven

和

checkGreater = ReaderT (Integer, Integer) Maybe (Integer, Integer)
checkGreater = ReaderT $ \(a, b) = if a >= b then Nothing else Just (a, b)

validate = checkGreater <* withReaderT snd checkEven
validate' = snd <$> validate

您对 x 的值 runReaderT validate x 使用这些 ReaderT 验证器之一

Answer 2

如果你只需要 Applicative，你问为什么要使用 Monad？我可以问——如果你只需要 Monoid，为什么还要使用 Applicative？

您所做的一切本质上是在尝试利用 Monoidal 行为/Monoid，但尝试通过 Applicative 接口来实现。有点像使用Int's 通过他们的字符串表示（实现+ 为字符串"1" 和"12" 并使用字符串而不是仅仅1 和12 并使用整数）

请注意，您可以从任何 Monoid 实例中获取 Applicative 实例，因此找到可以解决您的问题的 Monoid 与找到可以解决问题的 Applicative 相同。

even :: Integer -> All
even x = All (rem x 2 == 0)

isSmall :: Integer -> All
isSmall x = All (x < 10)

greater :: (Integer, Integer) -> All
greater (a, b) = All (b > a)

为了证明它们是一样的，我们可以来回写转换函数：

convertToMaybeFunc :: (a -> All) -> (a -> Maybe a)
convertToMaybeFunc f x = guard (getAll (f x)) $> x

-- assuming the resulting Just contains no new information
convertFromMaybeFunc :: (a -> Maybe b) -> (a -> All)
convertFromMaybeFunc f x = maybe (All False) (\_ -> All True) (f x)

你可以直接写你的validate:

validate :: Int -> All
validate a = isSmall a <> even a

但你也可以用你想要的提升风格来写它：

validate :: Int -> All
validate = isSmall <> even

想要做符号吗？

validate :: Int -> All
validate = execWriter $ do
    tell isSmall
    tell even
    tell (other validator)

validate' :: (Int, Int) -> All
validate' = execWriter $ do
    tell (isSmall . fst)
    tell (isSmall . snd)
    tell greater

如您所见，每个Monoid 实例都会产生一个Applicative/Monad 实例（通过Writer 和tell），这使得这有点方便。您可以将这里的Writer/tell 视为将Monoid 实例“提升”为免费的Applicative/Monad 实例。

最后，您会注意到一个有用的设计模式/抽象，但您真正注意到的是 monoid。您正专注于通过 Applicative 接口处理该 monoid，不知何故……但直接使用 monoid 可能更简单。

还有，

validate :: Int -> All
validate = mconcat
  [ isSmall
  , even
  , other validator
  ]

可以说在清晰度上与带有 Writer 的 do 表示法版本相当:)