Function 组合（a->；可能是a）和（a->；a）函数

我有两个职能：

f :: a -> Maybe a
g :: a -> a

我想创建这样的函数：

h :: a -> Maybe a

h x
| isJust(f x) = Just (g $ fromJust(f x))
| otherwise   = Nothing

我怎样才能做得更优雅呢？

为什么不简单地说：

h :: a -> Maybe a
h x = fmap g (f x)

或操作员版本：

h :: a -> Maybe a
h x = g <$> f x

h:：a->可能是a
hx=gfx

既然您已将此问题标记为：

有关解释：

f            ::                          a -> Maybe a
g            ::        a ->       a
fmap g       ::  Maybe a -> Maybe a
(.)          :: (Maybe a -> Maybe a) -> (a -> Maybe a) -> (a -> Maybe a)
(.) (fmap g) ::                         (a -> Maybe a) -> (a -> Maybe a)
fmap g . f   ::                                           (a -> Maybe a)
h            ::                                            a -> Maybe a

请注意，

（）

和

fmap g

的类型实际上更通用：

(.) :: (b -> c) -> (a -> b) -> (a -> c)
-- b in this case is Maybe a
-- c in this case is Maybe a

fmap g :: Functor f => f a -> f a
-- f in this case is Maybe

但是，您也可以对

f

的结果进行模式匹配：

h x = 
  case f x of
    Just k -> Just (g k)
    _      -> Nothing

请注意，您的原始示例甚至无法编译，因为

g

的返回类型不正确。

fmap2 :: (Functor g, Functor f) => (a -> b) -> g (f a) -> g (f b)
fmap2 = fmap . fmap

这里有一个有趣的方式：

h :: a -> Maybe a
h = fmap2 g f

fmap2gf~>fmap（fmapg）f~>fmapg。f~>\x->fmap g（f x）

---

这里使用的实例是：

fmap

可以用来代替

（）

下面发布了优雅的方式。不过，我想提醒大家，使用

isJust/fromJust

可以说是最不优雅的方式。实际上，如果忘记了

isJust

检查，

fromJust

会使程序崩溃。更好的方法是使用模式匹配，例如

casefoxofnothing->Nothing；只需y->只需$GY

。有关更多信息，请参见。该类型不正确

g（fromJust（fx））：a

。我认为你可以使用

Just（g（fromJust（fx））

。我认为这是最惯用的方式，并且表达了所有选项中最清晰的想法。考虑到用户（可能）是Haskell的新手，你能补充一些解释吗？不是每个人都熟悉

Functor（（->）r）

。使用

b~a

，

fa~也许a

和

gc~a->c

会让他们看得更清楚。@Zeta，我想让它看起来像一个谜。所以，在

fmap.fmap

中，左边的

fmap

在

（a->）

，因为无论是什么函子，

fmap g

始终是一个函数。这里右边的

fmap

碰巧在

中，可能在
中（在owl combinator中，它也在（r->）中。很好。）
h :: a -> Maybe a
h = fmap2 g f