Complete the explanation of <$>, begin explaining <*>

Author: igrep

assets/20.md

@@ -116,52 +116,73 @@ putStrLn <$> getLine :: IO (IO ())
 
 以上の通り、「関数オブジェクト」とよく似たこの`IO`は単なる値として扱えるので、Haskellにおける関数`a -> b`の結果`b`として返したり、`putStrLn <$> getLine`が返す`IO (IO ())`のように、`IO`を実行した結果として返すことができます。
 
-では肝心な点、その結果として返された`IO`はどうやって実行することができるのでしょうか？簡潔に言うと、`main`関数やGHCiの中で評価することで（`>>=`や`>>`でつなげられてその部分を通ったとき）初めて実行できます。ほかのプログラミング言語における「関数オブジェクト」と異なり、実行するための演算子が明確でなく、わかりづらくなっています。
+では肝心な点、その結果として返された`IO`はどうやって実行することができるのでしょうか？簡潔に言うと、`main`関数やGHCiの中で評価することで（`>>=`や`>>`、あるいは`do`でつなげられて、その部分を通ったとき）初めて実行できます。ほかのプログラミング言語における「関数オブジェクト」と異なり、実行する専用の演算子[^execute-operator]はありません。ちょっと分かりづらいですね。
 
-先程の`putStrLn <$> getLine`を、今度こそ全部実行してみましょう:
+[^execute-operator]: JavaScriptやPythonの関数オブジェクトでは`()`、Rubyの`Proc`クラスのインスタンスやJavaの`Callable`を実装したオブジェクトでは`call`メソッドがその「実行する専用の演算子」に該当します。
+
+例として、先程の`putStrLn <$> getLine`を今度こそ全部実行してみましょう:
 
 ```haskell
-ghci> :t putStrLn <$> getLine
-putStrLn <$> getLine :: IO (IO ())
-ghci> returnedAction <- putStrLn <$> getLine
-12345 -- ここはユーザーによる入力
-ghci> :t returnedAction
-returnedAction :: IO ()
-ghci> returnedAction
-12345
+ghci> action1 = putStrLn <$> getLine
+ghci> action1 -- 復習: この時点では putStrLn は実行されない
+aaaaa         -- ここはユーザーによる入力
+ghci>
+ghci> :t action1 --  IO (IO ()) という型なので、内側の IO () が実行されるまで、putStrLn は実行されない
+action1 :: IO (IO ())
+
+-- do の中で<- を使って action1 の中の IO () を取り出して、実行する
+ghci> :{
+ghci| do
+ghci|   action2 <- action1
+ghci|   action2
+ghci| :}
+aaaaa -- ここはユーザーによる入力
+aaaaa -- 入力した文字列が出力された！
 ```
 
-GHCiは、`putStrLn <$> getLine`という式を受け取ったとき、とりあず`IO (IO ())`の外側の`IO (...)`、つまりこの場合`getLine`に当たる「命令」を実行します。  
-そして、その結果として`putStrLn <getLineが返した文字列>`という`IO ()`型の値（命令）を返しているのです。  
-そのため、上記のように`putStrLn <$> getLine`から`<-`で（あるいは、`>>=`で）取り出した`IO ()`（上記で言うところの`returnedAction`）を直接GHCiに入力すれば、`putStrLn <getLineが返した文字列>`の部分も実行することができます。
+GHCiは、`putStrLn <$> getLine`という式を受け取ったとき、とりあず`IO (IO ())`の外側の`IO (...)`、つまりこの場合`getLine`に当たる「命令」を実行します。そして、その結果として`putStrLn <getLineが返した文字列>`という`IO ()`型の値（命令）を返しているのです。
+
+そのため、上記のように`putStrLn <$> getLine`から`<-`で（あるいは、`>>=`で）取り出した`IO ()`（上記で言うところの`action2`）を直接`do`の中に含めてGHCiに入力することで初めて、`putStrLn <getLineが返した文字列>`の部分も実行することができるようになるのです。
 
 `putStrLn <$> getLine`と書いても`putStrLn`の部分が実行されなかったのは、`getLine`が結果として返した`[Char]`を`putStrLn`で`IO ()`に変換した後、実行していなかったからなのです。
 
-この、`putStrLn <$> getLine`と入力しても`putStrLn`が実行されない、という現象は、GHCiだけでなく、`main`関数に`putStrLn <$> getLine`と書いてしまった場合も同様に発生します。
+先程の`action2`を最終的に実行する`do`の型を`:t`を使って見てみると、ちゃんと入れ子じゃない、普通の`IO ()`になっていることが確認できます:
 
+```haskell
+ghci> :{
+ghci| :t do
+ghci|   action2 <- action1
+ghci|   action2
+ghci| :}
+do
+  action2 <- action1
+  action2 :: IO ()
 ```
+
+なお、この`putStrLn <$> getLine`と入力しても`putStrLn`が実行されない、という現象は、GHCiだけでなく、`main`関数に`putStrLn <$> getLine`と書いてしまった場合も同様に発生します。
+
+```haskell
 main = putStrLn <$> getLine
 ```
 
 というファイルを`not-echoed.hs`という名前で保存して実行してみても、やはりGHCiで実行した場合と同様に、`getLine`に当たる部分しか実行されません。
 
-```
+```haskell
 shell> stack exec runhaskell not-echoed.hs
 12345 # ここはユーザーによる入力
 shell>
 ```
 
-しかし、多くのHaskellerが行うように、この問題は`main`関数に型注釈をつけていれば、型エラーとして回避できます。  
-`not-echoed.hs`を次のように書き換えてみましょう。
+しかし、多くのHaskellerが行うように、この問題は`main`関数に型注釈をつけていれば、型エラーとして回避できます。`not-echoed.hs`を次のように書き換えてみましょう。
 
-```
+```haskell
 main :: IO ()
 main = putStrLn <$> getLine
 ```
 
-今度は以下のような型エラーが報告されるので、問題のある`putStrLn <$> getLine`は実行されるまでもありません。
+今度は以下のような型エラーが報告されるので、問題のある`putStrLn <$> getLine`は実行される間でもありません。
 
-```
+```haskell
 shell> stack exec runhaskell not-echoed.hs
 not-echoed.hs:2:8: error:
     ? Couldn't match type ‘IO ()’ with ‘()’
@@ -174,58 +195,56 @@ not-echoed.hs:2:8: error:
   |        ^^^^^^^^^^^^^^^^^^^^
 ```
 
-`main`関数のように、`let`や`where`を伴わないで定義された、同じモジュール内のどの関数からも参照できる関数を、「トップレベルに定義された関数」と言います。  
-`main`関数だけでなく、ほかのトップレベルの`IO`型の値を返す関数（あるいは`IO`型の値そのもの）にも型注釈を付けていれば、この問題は大抵回避できます。  
-一般に、**トップレベルに定義する関数は、型注釈を書く**ことでインターフェースを明確にすることが望ましいとされています。  
-なので、トップレベルの関数に型注釈を書くことは、この問題を回避する以外のメリットもあるので、なるべく書きましょう。  
-当入門ではこれまで`main`の型注釈については省略してきましたが、今後は`main`についても記載します。
+`main`関数のように、`let`や`where`を伴わないで定義された、同じモジュール内のどの関数からも参照できる関数を、「トップレベルに定義された関数」と言います。`main`関数だけでなく、ほかのトップレベルの`IO`型の値を返す関数（あるいは`IO`型の値そのもの）にも型注釈を付けていれば、この問題は大抵回避できます。一般に、**トップレベルに定義する関数は、型注釈を書く**ことでインターフェースを明確にすることが望ましいとされています。なので、トップレベルの関数に型注釈を書くことは、この問題を回避する以外のメリットもあるので、なるべく書きましょう。当入門ではこれまで`main`の型注釈については省略してきましたが、今後は`main`についても記載します。
 
 ### `<*>`を使って2つ目以降の引数を「命令」の結果から渡す
 
-`+`などの二項演算子といった、2つ以上の引数を受け取る関数の引数を、`IO`などの「命令」の結果から渡す場合、`<$>`だけではできません（理由は後述します）。
+`+`などの二項演算子といった、2つ以上の引数を受け取る関数の引数として、`IO`などの「命令」の結果を渡す場合、`<$>`だけではできません（理由は後述します）。
 
-これまで下記のように`do`を使って書いていたものは、`<$>`と`<*>`を使って書き換えることができます。  
+例えばこれまで、下記のように`do`を使って書いていた場合を例としましょう:
 
-```
+```haskell
 -- `getLine`を2回実行して、取得した2つの文字列を ++ で結合する
 do
   line1 <- getLine
   line2 <- getLine
   return $ line1 ++ line2
 ```
 
-```
+このように二つ（以上）の「命令」が返した結果を、命令でない、純粋な関数に渡すコードは、`<$>`と`<*>`を使って次のように書き換えることができます:
+
+```haskell
 (++) <$> getLine <*> getLine
 ```
 
-すっきり！やっぱりワンライナーで書けましたね！  
-（課題18で学習した「演算子を前置関数に変換する」方法を思い出してください！）
+すっきり！やっぱりワンライナーで書けましたね！（課題18で学習した「演算子を前置関数に変換する」方法を思い出してください！）
 
-実行例
+試しに実行すると、確かに`getLine`を2回実行して、その結果を`++`で結合していることがわかります:
 
-```
+```haskell
 ghci> (++) <$> getLine <*> getLine
 first half -- ここはユーザーによる入力
 second half -- ここはユーザーによる入力
 "first halfsecond half"
 ```
 
-例のごとく、新しい関数を見つけたら型を見る、の精神で、`<*>`の型を覗いてみましょう。
+例のごとく、新しい関数を見つけたら型を見る、の精神で、`<*>`の型を覗いてみましょう:
 
-```
+```haskell
 ghci> :t (<*>)
 (<*>) :: Applicative f => f (a -> b) -> f a -> f b
 ```
 
-`Monad`, `Functor`と続いて、`Applicative`というまた見知らぬ型クラスが登場しました。  
-これらの詳細は次の課題で行いますので、今はまた`TypeApplications`で`f`を`IO`に置き換えましょう。
+`Monad`, `Functor`と続いて、`Applicative`というまた見知らぬ型クラスが登場しました。これらの詳細は次の課題で行いますので、今はまた`TypeApplications`で`f`を`IO`に置き換えましょう。
 
-```
+```haskell
 ghci> :set -XTypeApplications
 ghci> :t (<*>) @IO
 (<*>) @IO :: IO (a -> b) -> IO a -> IO b
 ```
 
+`TypeApplications`で`f`を`IO`に絞っても、まだまだ複雑な型ですね。日本語で説明すると、`<*>`は両辺に次のような値を受け取り、次のような値を返す演算子となっています:
+
 - 第1引数（左辺）の`IO (a -> b)`: 「普通の（入出力を行わない）関数 `a -> b`」を返す命令。
 - 第2引数（右辺）の`IO a`: 「第1引数の命令が返す関数」の引数と同じ型`a`を返す命令。
 - 戻り値の`IO b`: 「第1引数の命令が返す関数」の戻り値と同じ型`b`を返す命令。