为什么这篇简单的作文不管用?

最好的写法可能是:

f >>= g . head

或者以更详细的形式:

f >>= (g . head)

所以我们基本上是执行 fmap f (因此,我们采取 head IO 蒙纳德),然后我们传给 g

(head <$> f) >>= g

在语义上是相同的。

但是现在如果我们使用 g <$> head <$> f ? 我们先来分析一下类型:

f :: IO [Int]
g :: Int -> IO ()
(<$>) :: Functor m => (a -> b) -> m a -> m b

(我用过) m 在这里避免与 (功能)

((<$>) ((<$>) g head) f)

第二个 (<$>) g :: Int -> IO () head :: [c] -> c 作为参数,这意味着 a ~ Int b ~ IO () ,和 m ~ (->) [c]

 (<$>) g head :: (->) [c] (IO ())

或更详细:

g <$> head :: [c] -> IO ()

第一个 (<$>) 因此,函数将作为参数 g <$> head :: [c] -> IO () IO [Int] ,也就是说 m ~ IO a ~ [Int] , c ~ Int , ,因此我们得到类型:

(<$>) (g <$> head) f :: IO (IO ())

因此,我们不采取任何实际行动:我们 fmap公司 这个 [Int] 列表到 动作(包装在 木卫一 return (print 1) print 1 return 包裹在一个

你当然可以“吸收”外部 木卫一 在这里,然后使用内部 ,例如:

evalIO :: IO (IO f) -> IO f
evalIO res = do
   f <- res
   f

evalIO :: IO (IO f) -> IO f
evalIO res = res >>= id

Monad s、 但这与此无关)。

这个 evalIO 也被称为 join :: Monad m => m (m a) -> m a

第一个和第二个完全一样,因为 <$> head 是函数,并且 <$> 是 .

    g . head <$> f

    =  fmap (print . head) (return [1..5] :: IO [Int])
    =  do { x <- (return [1..5] :: IO [Int])
          ; return ( print (head x) ) }
    =  do { let x = [1..5] 
          ; return ( print (head x) ) } :: IO _whatever
    =       
            return ( print 1 )   :: IO (IO ())

我们有太多了 return

    =  fmap (print . head) (return [1..5] :: IO [Int])
    =  return (print (head [1..5]))
    =  return (print 1)

第三个是

    (head <$> f) >>= g
  = (fmap head $ return [1..5]) >>= print
  = (return (head [1..5])) >>= print
  = (return 1) >>= print