在Haskell monad/left-lifting中使用純函數？

Question

考慮以下功能：

foo = 
    [1,2,3] >>= 
    return . (*2) . (+1) 

爲了更好的可讀性和邏輯，我想(*2)和(+1)移動我的純函數的返回的左側。我可以這樣實現這一點：

infixr 9 <. 
(<.) :: (a -> b) -> (b -> c) -> (a -> c) 
(<.) f g = g . f 

bar = 
    [1,2,3] >>= 
    (+1) <. 
    (*2) <. 
    return 

不過，我不喜歡的(<.)右關聯性。

讓我們介紹一個功能leftLift：

leftLift :: Monad m => (a -> b) -> a -> m b 
leftLift f = return . f 

baz = 
    [1,2,3] >>= 
    leftLift (+1) >>= 
    leftLift (*2) >>= 
    return 

我很喜歡這一點。另一種可能性是定義的bind變體：

infixl 1 >>$ 
(>>$) :: Monad m => m a -> (a -> b) -> m b 
(>>$) m f = m >>= return . f 

qux = 
    [1,2,3] >>$ 
    (+1) >>$ 
    (*2) >>= 
    return 

我不知道這是否是一個好主意，因爲它不會允許我使用do符號我應該希望如此。 leftLift我可以do使用：

bazDo = do 
    x <- [1,2,3] 
    y <- leftLift (+1) x 
    z <- leftLift (*2) y 
    return z 

我沒有找到的leftLift上的簽名Hoogle功能。這樣的功能是否存在？如果它叫什麼？如果不是，我應該怎麼稱呼它？什麼是我正在嘗試做的最習慣的方式？

---

編輯：這是一個被@鄧祿普的回答以下的啓發版本：

infixl 4 <&> 
(<&>) :: Functor f => f a -> (a -> b) -> f b 
(<&>) = flip fmap 

blah = 
    [1,2,3] <&> 
    (+1) <&> 
    (*2) >>= 
    return 

我還要補充一點，我是一個bind後-variant，因爲我想寫我的代碼點免費樣式。對於do -notation，我想我不需要「假裝」我做了任何單調的事情，所以我可以使用let s。

Answer 1

每個Monad是Functor（和Applicative）。你的(>>$)是（翻轉）fmap。

GHCi> :t fmap 
fmap :: Functor f => (a -> b) -> f a -> f b 
GHCi> :t (<$>) -- Infix synonym for 'fmap' 
(<$>) -- Infix synonym for 'fmap' 
    :: Functor f => (a -> b) -> f a -> f b 
GHCi> fmap ((*2) . (+1)) [1,2,3] 
[4,6,8] 
GHCi> (*2) . (+1) <$> ([1,2,3] >>= \x -> [1..x]) 
[4,4,6,4,6,8] 

（順便說一句，翻轉後fmap一個共同的名字是(<&>)。也就是說，例如，什麼鏡頭調用它。）

---

如果您正在使用DO-符號，沒有什麼理由明確地使用fmap的任何變體來進行這種轉換。只需切換您<-單子綁定鬆懈綁定：

bazDo = do 
    x <- [1,2,3] 
    let y = (+1) x 
     z = (*2) y 
    return z 

bazDo = do 
    x <- [1,2,3] 
    let y = (+1) x 
    return ((*2) z) 

Answer 2

爲了更好的可讀性...

這將是主觀的，因爲人們不同意什麼構成的可讀性。

這就是說，我同意有時當從左到右書寫數據時，理解數據變換會更容易。不過，我認爲你的>>$是過度殺傷。該&運營商Data.Function這項工作：

import Data.Function 

foo = [1,2,3] & fmap (+1) & fmap (*2) 

我喜歡這說正是入手，並正是在每一步做到從左至右。不像>>$，你不會被強迫留在單子：

bar = [1,2,3] & fmap (+1) & fmap (*2) & sum & negate 

或者你可以組裝你的改造事前並將其映射在你的單子：

import Control.Category 

f = (+1) >>> (*2) 
quuz = fmap f [1,2,3]