最少两个可能

Question

我想获得两个可能值中的最小值，或者如果一个什么都没有，则获得一个非无，或者如果两个输入都没有，则什么都不返回。我可以编写一个简单的函数来做到这一点，但我怀疑有一种方法可以在不编写自定义函数的情况下做到这一点。抱歉，如果这是一个小问题，但有没有比使用这个自定义函数更简单的方法？

minMaybe :: Ord a => Maybe a -> Maybe a -> Maybe a
minMaybe Nothing b = b
minMaybe a Nothing = a
minMaybe (Just a) (Just b) = Just $ min a b

Answer 1

使用Control.Applicative 中的运算符可以满足规范。

myMin :: Ord x => Maybe x -> Maybe x -> Maybe x
myMin a b = min <$> a <*> b <|> a <|> b

<|> 的 Maybe 在哪里实现“偏好”

Nothing <|> b  = b
a       <|> _  = a

事情是这样的

min <$> Just a <*> Just b = Just (min a b)

但是

min <$> Just a <*> Nothing = Nothing

这导致对这个问题的一些错误答案。使用<|> 可以让您在计算出的min 值可用时更喜欢它，但是当只有一个Just 时，您可以使用任一个人来恢复。

但是你应该问问这样使用Maybe是否合适。除了 Monoid 实例这个不光彩的例外，Maybe 被设置为对容易发生故障的计算进行建模。您在这里拥有的是现有Ord 的扩展，带有“顶部”元素。

data Topped x = Val x | Top deriving (Show, Eq, Ord)

您会发现min for Topped x 正是您所需要的。将类型不仅视为数据的表示，而且将其视为具有结构的数据的设备，这很好。 Nothing 通常代表某种失败，因此最好使用不同的类型。

Answer 2

您不能为此使用Applicative 或Monad 实例，因为这些上下文中的任何Nothing 都会使您的总结果为Nothing。话虽这么说，“更简单”这个词是高度自以为是的，你的功能很好。

Answer 3

您可以使用Maybe 的Alternative 实例编写它：

minMaybe a b = liftA2 min a b <|> a <|> b

或者，您可以使用maxBound 作为默认值，所以它总是会选择另一个：

minMaybe a b = liftA2 min (d a) (d b)
  where d x = x <|> Just maxBound

但我不建议这样做。

Answer 4

问题是关于提升功能 min :: Ord a ⇒ a → a → a 以使用 Maybes 上下文。它具有关联性，因此 Semigroup 实例完全符合您的要求：

min' :: forall a. Ord a => Maybe a -> Maybe a -> Maybe a
min' = coerce ((<>) @(Maybe (Min a)))

这需要ScopedTypeVariables 和TypeApplications。 coerce 来自 Data.Coerce。下面给出了更老式的解决方案。但是上面的版本应该更高效：coerce 在运行时不存在。虽然 GHC 可能会消除 fmaps 但不能保证：

min'' :: Ord a => Maybe a -> Maybe a -> Maybe a
min'' x y = fmap getMin (fmap Min x <> fmap Min y)

附：我会说你的解决方案很好。

Answer 5

我认为 radomaj 有一个 good idea。

import Data.Ord (Down (..))
import Data.Function (on)

minMaybes mx my =
  getDown <$> (max `on` fmap Down) mx my
getDown (Down x) = x

我们使用max 优先于Just 而不是Nothing，然后使用Down，所以如果两者都是Just，我们实际上会得到最小值。

---

这是另一种类似的方法，看起来更简洁。 Maybe 可以看作是一种将额外的最小值 Nothing 附加到任意 Ord 类型的方法。我们可以编写自己的类型来附加最大值：

data AddMax a = TheMax | Plain a deriving Eq
instance Ord a => Ord (AddMax a) where
  TheMax <= Plain _ = False
  _ <= TheMax = True
  Plain a <= Plain b = a <= b

maybeToAddMax :: Maybe a -> AddMax a
maybeToAddMax = maybe TheMax Plain

addMaxToMaybe :: AddMax a -> Maybe a
addMaxToMaybe TheMax = Nothing
addMaxToMaybe (Plain a) = Just a

现在你可以写了

minMaybes mx my = addMaxToMaybe $
  (min `on` maybeToAddMax) mx my

你也可以耍点花招：

{-# LANGUAGE ScopedTypeVariables, TypeApplications #-}
import Data.Ord
import Data.Function
import Data.Coerce

newtype AddMax a = AddMax {unAddMax :: Down (Maybe (Down a))}
  deriving (Eq, Ord)

现在

minMaybes :: forall a. Ord a => Maybe a -> Maybe a -> Maybe a
minMaybes = coerce (min @(AddMax a))