Introduction of <$>, and its caveat

Author: igrep

assets/20.md

@@ -8,60 +8,59 @@
 
 従来、`IO`（命令）の結果に対して（`a -> IO b`というような型ではなく、`a -> b`という型の）普通の関数を実行するには、次のように`do`の中で左細い矢印`<-`を使って、一旦変数に代入する必要がありました。
 
-```
+```haskell
 do
     line <- getLine
 
     -- line 変数に代入して、length関数を実行してから何かする
     print (length line)
+
     -- あるいは、length関数を実行してから何もせずにそのまま返す
     return (length line)
 ```
 
-課題19で紹介した`>>=`を使うことによって、`do`や代入する変数を用意する必要はなくなりましたが、`return`などの関数を使って、必ず何らかの形で`IO`（命令）に変換する必要がありました。
+課題hoge(19?)で紹介した`>>=`を使うことによって、`do`や代入する変数を用意する必要はなくなりましたが、`return`などの関数を使い、必ず何らかの形で右辺の関数を、`IO`（命令）を返す関数に変換する必要がありました:
 
-```
+```haskell
 getLine >>= return . length
 ```
 
-この変換を不要にするのが`fmap`、あるいはその演算子バージョンである`<$>`の役目です（実際のところ`<$>`の方がよく使われるので、ここからは`<$>`で説明します）。  
-上記の例を書き換えてみると、こう👇なります。
+この変換を不要にするのが`fmap`、あるいはその演算子バージョンである`<$>`の役目です（実際のところ`<$>`の方がよく使われるので、ここからは`<$>`で説明します）。
 
-```
+上記の例を`<$>`を使って書き換えてみると、こう👇なります:
+
+```haskell
 length <$> getLine
 ```
 
-順番が変わってしまっている点には、ご注意ください。  
-`>>= return .`という部分が`<$>`に置き換わって、すっきりしましたね！
+`>==`から両辺に渡す式の型が入れ替わっている点には、ご注意ください。`<$>`では、左辺に「普通の関数」、右辺に「命令」を渡します。`>>= return .`という部分が`<$>`に置き換わって、すっきりしましたね！
 
-このように`<$>`は、**`IO`（命令）を実行した結果に対して、普通の、純粋な関数を実行する**命令を作るための演算子です。
+このように`<$>`は、**`IO`（命令）の結果**に対して、普通の、**純粋な関数**を実行する命令を作るための演算子です。
 
 そのことを裏付けるために、例のごとく`:t`で型定義を覗いてみましょう。
 
-```
+```haskell
 ghci> :t (<$>)
 (<$>) :: Functor f => (a -> b) -> f a -> f b
 ```
 
-おっと、`Monad`でもない、`Functor`という聞き慣れない型クラスの型変数が出てきました。  
-`Functor`の説明は一旦置いておいて、前の課題と同様`TypeApplications`を使って型変数`f`を`IO`に置き換えて解釈しましょう。
+おっと、`Monad`でもない、`Functor`という聞き慣れない型クラスの型変数が出てきました。`Functor`の説明は一旦置いておいて、前の課題と同様`TypeApplications`を使って型変数`f`を`IO`に置き換えて解釈しましょう。
 
-```
+```haskell
 ghci> :set -XTypeApplications
 ghci> :t (<$>) @IO
 (<$>) @IO :: (a -> b) -> IO a -> IO b
 ```
 
-2つの引数と戻り値:
+上記のように`<$>`の型変数`f`を`IO`に絞ったバージョンを作ると、2つの引数と戻り値は次のような型となります:
 
 - 第1引数（左辺）の`a -> b`: 普通の（入出力を行わない）関数 `a -> b`。
 - 第2引数（右辺）の`IO a`: 第1引数の関数の引数と、同じ型の値を返す`IO`（命令）。
 - 戻り値の`IO b`: 第1引数（左辺）の関数と、同じ型の値を返す命令。
 
-`IO a`を`a -> b`で`IO b`に変換する演算子である、というのが伝わるでしょうか？  
-`length <$> getLine`の例に当てはめると、`getLine`で「ユーザーから入力してもらった文字列」に対して、`length`関数を実行して得た文字列の長さを返す`IO`（命令）を作っていますね！
+`IO a`を`a -> b`で`IO b`に変換する演算子である、というのが伝わるでしょうか？`length <$> getLine`の例に当てはめると、`getLine`で「ユーザーから入力してもらった文字列」に対して、`length`関数を実行して得た文字列の長さを返す`IO`（命令）を作っていますね！
 
-```
+```haskell
      length   <$>   getLine
      ^^^^^^         ^^^^^^^
 [Char] -> Int      IO [Char]
@@ -76,25 +75,20 @@ ghci> :t (<$>) @IO
             f   b
 ```
 
-ここで重要なのは、第1引数である関数はあくまでも`a -> b`という型の、「普通の関数」として**扱われる**、という点です。  
-`<$>`を`IO`を返す関数`a -> IO b`に対して使うと、**型エラーにはならず**、妙な動作になってしまう場合があるのでご注意ください。
+ただし厳密に言えば、第1引数である関数はあくまでも`a -> b`という型の、「普通の関数」として**扱われる**、という点にはご注意ください。`<$>`を`IO`を返す関数`a -> IO b`に対して使うと、**型エラーにはならず**、妙な動作になってしまう場合があります。例えば、`putStrLn <$> getLine`とGHCi上で書いた場合...
 
-例えば、`putStrLn <$> getLine`とGHCi上で書いた場合...
-
-```
+```haskell
 ghci> putStrLn <$> getLine
 aaaaa -- ここはユーザーによる入力
 ```
 
-`putStrLn =<< getLine`と書いたときと異なり、入力した文字列が`putStrLn`によって出力されなかったことにお気づきでしょうか？  
-そう、`getLine`が実行されてユーザーから入力を得たものの、なぜかそれを受け取ったはずの`putStrLn`は実行されなかったのです...😱
+`putStrLn =<< getLine`と書いたときと異なり、入力した文字列が`putStrLn`によって出力されなかったことにお気づきでしょうか？そう、`getLine`が実行されてユーザーから入力を得たものの、なぜかそれを受け取ったはずの`putStrLn`は実行されなかったのです...😱
 
 #### なぜ`putStrLn <$> getLine`と書いても`putStrLn`は実行されないのか、あるいは型注釈を付けようという話
 
-この理由については、難しい話になるので節を分けます。  
-今回の課題を解くだけの目的では必要ないばかりか、あなたの今後のHaskeller人生で絶対に必要な知識でもないので、わからなかったら適当に飛ばしてください。
+この理由については難しい話になるので節を分けます。今回の課題を解くだけの目的では必要ないばかりか、あなたの今後のHaskeller人生で絶対に必要な知識でもないので、わからなかったら適当に飛ばしてください。
 
-```
+```haskell
 ghci> :t putStrLn <$> getLine
 putStrLn <$> getLine :: IO (IO ())
 ```
@@ -108,32 +102,25 @@ putStrLn <$> getLine :: IO (IO ())
 - `IO`に対する`<$>`は`(a -> b) -> IO a -> IO b`という型なので、
 - 型変数`a`に`[Char]`、型変数`b`に`IO ()`が代入された。
 
-そう、`IO ()`も、実態は単なる普通の型なので、普通に型推論され、普通に型変数に代入されます。  
-これまで扱ってきた`Integer`や`Bool`、`[a]`などと変わらない、普通の型なのです。
+そう、`IO ()`、実態は単なる普通の型なので、普通に型推論され、普通に型変数に代入されます。これまで扱ってきた`Integer`や`Bool`、`[a]`などと変わらない、普通の型なのです。
 
-型と言うことは何らかの値を表しているはずです。これまではっきりと説明してきませんでしたが、一体`IO`型の値は何を表しているのでしょう？  
-`IO`は「命令」を表すオブジェクトです。
+型と言うことは何らかの値を表しているはずです。これまではっきりと説明してきませんでしたが、一体`IO`型の値は何を表しているのでしょう？
 
-例えるなら、ほかのプログラミング言語で言うところの「関数オブジェクト」に近いです。  
-PythonやJavaScriptにおける関数オブジェクト、Rubyで言えば`Proc`クラスのオブジェクト、Javaにおける`Callable`インターフェースを実装したオブジェクトなどなど
+`IO`は「命令」を表すオブジェクトです。例えるなら、ほかのプログラミング言語で言うところの「関数オブジェクト」に近いです。PythonやJavaScriptにおける関数オブジェクト、Rubyで言えば`Proc`クラスのオブジェクト、Javaにおける`Callable`インターフェースを実装したオブジェクトなどなど。
 
-ただし、ほかのプログラミング言語で言うところの、「関数オブジェクト」と異なり、引数を受け取りません。  
-Haskellでは引数を受け取るのは、あくまでも普通の関数`a -> b`の役目なのです。  
-`putStrLn`も引数に当たる`[Char]`は`[Char] -> IO ()`という型の「普通の関数」の引数として受け取っていますね。
+ただし、ほかのプログラミング言語で言うところの、「関数オブジェクト」と異なり、引数を受け取りません。Haskellでは引数を受け取るのは、あくまでも普通の関数`a -> b`の役目なのです。`putStrLn`も引数に当たる`[Char]`は`[Char] -> IO ()`という型の「普通の関数」の引数として受け取っています。
 
-一方、普通の関数`a -> b`は、`IO`のように入出力処理が出来ません。  
-なので入出力処理の部分は`IO`に任せているのです。
+一方、普通の関数`a -> b`は、`IO`のように入出力処理が出来ません。なので入出力処理の部分は`IO`に任せているのです。
 
-結果、ほかのプログラミング言語における「関数オブジェクト」は、自由に入出力ができる、関数の戻り値（や引数）になることができる、という点で、Haskellの`IO`と似ています。  
-従って、「`IO`は引数を受け取らない関数オブジェクト」というイメージで捉えてください。
+したがって、ほかのプログラミング言語における「関数オブジェクト」は、「自由に入出力ができる」、「関数の戻り値（や引数）になることができる」、という点で、Haskellの`IO`と似ています。「`IO`は引数を受け取らない関数オブジェクト」と捉えてください。
 
 以上の通り、「関数オブジェクト」とよく似たこの`IO`は単なる値として扱えるので、Haskellにおける関数`a -> b`の結果`b`として返したり、`putStrLn <$> getLine`が返す`IO (IO ())`のように、`IO`を実行した結果として返すことができます。
 
-では、その結果として返された`IO`はどうやって実行することができるのでしょうか？  
-`main`関数やGHCiの中で評価されて（`>>=`や`>>`でつなげられてその部分を通ったとき）初めて実行されます。  
-ほかのプログラミング言語の「関数オブジェクト」と異なり、実行するための演算子が明確でなく、わかりづらい
+では肝心な点、その結果として返された`IO`はどうやって実行することができるのでしょうか？簡潔に言うと、`main`関数やGHCiの中で評価することで（`>>=`や`>>`でつなげられてその部分を通ったとき）初めて実行できます。ほかのプログラミング言語における「関数オブジェクト」と異なり、実行するための演算子が明確でなく、わかりづらくなっています。
 
-```
+先程の`putStrLn <$> getLine`を、今度こそ全部実行してみましょう:
+
+```haskell
 ghci> :t putStrLn <$> getLine
 putStrLn <$> getLine :: IO (IO ())
 ghci> returnedAction <- putStrLn <$> getLine