你可以写

maxMaybe : Ord a => Maybe a -> Maybe a -> Maybe a
maxMaybe mx my = [| max mx my |] <|> mx <|> my

但是在运行时它的开销可能会更大，因为你需要重做大量的案例分析，除非有足够的编译器优化来给予与原始解决方案基本等价的东西。

您已经在Haskell和OCaml中询问了两个答案，到目前为止只提供了Haskell中的答案。因此，我将给予OCaml的等价物，而不重复Haskell代码。
由于这个问题是关于合并match语句的对称分支，下面是你的版本如何用OCaml编写的：

let max_option x y = match x, y with
  | None, y -> y
  | x, None -> x
  | None, None -> None
  | Some x, Some y -> Some (max x y)

这是折叠后的版本

let max_option x y = match x, y with
  | None, v | v, None -> v (* two branches are merged *)
  | Some x, Some y -> Some (max x y)
  (* the `None, None` branch has been deleted as it was redundant *)

但是，对于这个特定的情况，由于'a option（Haskell中的Maybe a）是一个monad，使用monadic let绑定会更习惯：

let max_option x y =
  let (let>) = Option.bind in
  let> x = x in
  let> y = y in
  Some (max x y)

因为这个例子有点做作，所以你会得到一些奇怪的let> x = x语句。你可能会使用更多的高级函数，但我不认为这会产生更符合OCaml语言习惯的代码，这与Haskell相反。

在Haskell中，一个想法可能是使用Min半群并使用以下内容进行 Package ：

import Data.Function (on)
import Data.Semigroup (Max (Max, getMax))

maxMaybe :: Ord a => Maybe a -> Maybe a -> Maybe a
maxMaybe = on ((fmap getMax .) . (<>)) (fmap Max)

你可以很容易地将其推广到任何类似Semigroup的结构：

semiFunc :: (Functor f, Semigroup (f b)) => (a -> b) -> (b -> c) -> f a -> f a -> f c
semiFunc f g = on ((fmap g .) . (<>)) (fmap f)

则maxMaybe是semiFunc的特殊情况，其中maxMaybe = semiFunc Max getMax。