哈斯克爾：運行兩個單子，不停的第一個

Question

結果哈斯克爾玩，現在我試圖創建一個像

keepValue :: (Monad m) => m a -> (a -> m b) -> m a 

功能具有以下語義：它應該單子值適用於一個功能，它的回報第二個單子，並保持結果第一個單子，但第二個

的效果我Maybe單子的情況下，有一個工作功能：

keepValueMaybe :: Maybe a -> (a -> Maybe b) -> Maybe a 

keepValue ma f = case ma >>= f of 
    Nothing -> Nothing 
    Just _ -> ma 

因此，如果第一個值是Nothing，功能不運行（所以沒有第二副作用），但如果第一個值是Just，然後，運行該功能（與副作用）。我保持效果的第二次計算（例如，Nothing使整個表達式Nothing），但原始值。

現在我想知道。它可以用於任何單子嗎？

它看起來有點內置>>，但我在標準庫中找不到任何東西。

Answer 1

讓我們通過這個！

keepValue :: Monad m => m a -> (a -> m b) -> m a 
keepValue ma f = _ 

那麼我們想要keepValue做什麼？那麼，我們應該做的第一件事是使用ma，所以我們可以將它連接到f。

keepValue :: Monad m => m a -> (a -> m b) -> m a 
keepValue ma f = do 
    a <- ma 
    _ 

現在我們有a類型的值va，所以我們可以把它傳遞給f。

keepValue :: Monad m => m a -> (a -> m b) -> m a 
keepValue ma f = do 
    va <- ma 
    vb <- f va 
    _ 

最後，我們要生產va，這樣我們就可以做到這一點：

keepValue :: Monad m => m a -> (a -> m b) -> m a 
keepValue ma f = do 
    va <- ma 
    vb <- f va 
    return va 

這是我如何完成編寫任何像這樣的一元函數的第一個草案行走。然後，我會清理它。首先，一些小事情：因爲Applicative是Monad的超類，所以我更喜歡pure到return;我們沒有使用vb;我會放下v這個名字。因此，對於這個功能的do -notation基礎版本，我認爲最好的辦法是

keepValue :: Monad m => m a -> (a -> m b) -> m a 
keepValue ma f = do 
    a <- ma 
    _ <- f a 
    pure a 

然而，現在，我們就可以開始讓實現更好的。首先，我們可以顯式調用替換_ <- f va到(>>)：

keepValue :: Monad m => m a -> (a -> m b) -> m a 
keepValue ma f = do 
    a <- ma 
    f a >> pure a 

而現在，我們可以應用的簡化。你可能知道，我們總是可以fmap/(<$>)更換(>>=)加pure/return：任何pure . f =<< ma，ma >>= pure . f，或者do a <- ma ; pure $ f a（所有這些都是等價物）可以通過f <$> ma更換。然而，Functor型類有另一個，-公知的方法少，(<$)：

(<$) :: a -> f b -> f a
替換輸入的所有位置具有相同值。默認定義是fmap . const，但這可能會被更高效的版本覆蓋。

因此，我們必須對(<$)類似的替換規則：我們可以隨時更換b <$ ma或ma >> pure bdo ma ; pure b。這給了我們

keepValue :: Monad m => m a -> (a -> m b) -> m a 
keepValue ma f = do 
    a <- ma 
    a <$ f a 

而且我認爲這是這個功能的最短合理版本！沒有任何不錯的免費技巧可以使這個更清潔。其中一個指標是在do區塊的第二行上多次使用a。

---

順便說一句，一個術語記：你在運行兩個單子行動，或兩個單子值;你沒有運行*「兩個monad」。單子就像Maybe - 一種類型的構造函數，它支持(>>=)和return。不要將這些值與類型混合在一起 - 這種術語區分有助於保持更清晰的事物！

Answer 2

該結構看起來很像>>=/>>的定義Monad Maybe。

case foo of 
    Nothing -> Nothing 
    Just _ -> bar 

foo >>= \_ -> bar 
foo >> bar 

所以你的原始表達式可以簡化爲

ma >>= f >> ma 

，這適用於其他的單子。

但是，我不認爲這實際上是你想要的，因爲你可以看到ma發生兩次。取而代之，從第一個ma >>=綁定中取值，並將其貫穿到計算結束。

keepValue ma f = 
    ma >>= \a -> 
    f a >> 
    return a 

或do -notation

keepValue ma f = do 
    a <- ma 
    f a 
    return a