もう一つのモナドガイド（パート4：多分モナドとリストモナド）

マイク・ヴァニエ

このシリーズの以前の記事では、モナドの概念的基礎を研究しましたが、議論はあまりにも抽象的でした。 モナドとは何か、なぜモナドが必要なのかを理解できたので、特定のモナドを詳細に調べる時が来ました。 これは、前に見た多くの異なる計算概念に対して、 Monad型クラスの正しい化身を定義することを意味します。 知識を使用して、各場合にモナドアプリケーション（演算子>> = ）を介してモナド構成を取得し、モナドの法則を使用してreturnの定義を導出します。

たぶんモナド

通常、Monadは使いやすく、実装し、理解しやすいため、Haskellのマニュアルで最初に紹介されるのが普通です。 最初に、 Maybeデータ型の定義を見てください。

データ 多分 a = Nothing | ただ

Maybeは（特定の）データ型を取得するために特定の型aが配置される型コンストラクターであると述べています。 彼らはまた、 多分 「多態性」データ型であり、意味は同じだと言っています。 したがって、 aがIntの場合、次のようになります。

データ 多分 Int = Nothing | ちょうどint

上記の抽象的な定義はすべてのタイプに適用されるため、今だけこれを直接記述する必要はありません。

タイプaの値は、存在する場合と存在しない場合があります。 値がNothingの場合、「そうでない場合」であり、 xのある値に対してJust xである場合、これはxの 「ちょうど」値です。 これは、0個の要素または1個の要素があるコンテナと考えることができます。 （覚えておいてください：私はかつてモナド値が誤ってコンテナとして提示されることがあると言っていました。これが事実です。）

多分型ポリモーフィック型は、出力値として何かを生成するか、クラッシュして値を返すことができない「拡張関数」のモデルとして使用できるという点で便利です。 （つまり、そのような関数は失敗する可能性があります。）これは次のように書かれています。

f :: a- > たぶん b

関数fは、タイプaの値を取り、 Nothing （失敗の兆候）または値Just xを返します（ xはタイプbを 持ちます）。 fのような関数はMaybeモナドで動作し、そのような2つの関数の構成は次のとおりです。

f :: a- > たぶん b -fがどこかで定義されていると仮定する
g :: b- > たぶん c -gがどこかで定義されていると仮定する

h :: a- > たぶん c -fとgの単項合成
h = f > => g- 覚えておいてください：> =>は単項合成の演算子です

すべてのモナドは型コンストラクタでなければならない、と言いました。 多分型コンストラクタなので、ここではすべてがうまくいきます。 しかし、 たぶんモナドになるためには、 Monad型クラスのインスタンスを作成する必要があります。つまり、次の定義を入力する必要があります。

インスタンス Monad たぶん どこ
（ >> = ） = {-定義>> =たぶん-}
return = {-たぶんリターンの定義-}

Maybeにどのように設定（>> =）して戻ることができますか？

まず、 >> =の定義フレームワークを記述し、 多分a型の左オペランドの2つの可能なケースをカバーします。

なし>> = f = {-追加する必要があります-}
x >> = f = {-追加する必要があります-}

xはタイプaです。 定義の左側は別の方法で書くことができます：

（ >> = ）何もf = {-追加する必要はありません-}
（ >> = ） （ Just x ） f = {-追加が必要-}

しかし、演算子（>> =）が関数としてではなく演算子として指定されていると、Haskellはこれを許可します。

この定義を完了するために、 Maybeモナドのモナド構成から何が欲しいか考えてみましょう。 関数fとgを使用して例をとり、それらを単項結合し、関数hを取得します。

f :: a- > たぶん b
g :: b- > たぶん c
h :: a- > たぶん c
h = f > => g

引数を関数fに渡し、 Nothingを返す（つまり、失敗する）場合、関数hは何を返す必要がありますか？

f x =なし
h x = （ f > => g ） x = ???

fxがNothingを返す場合、式（関数f ）の一部が結果を返すことができなかった場合、式全体（関数h ）が結果を返せないため、 hもNothingを返す必要があることは明らかです。 hが値を返すときの唯一のオプションは、 fが結果を返すとき（ yを呼び出しましょう）、関数gに渡され、 gyも正しい結果になります。 fまたはgが失敗すると、 hも失敗します。つまり、 hxの計算はNothingになります。

これを念頭に置いて、 hの定義から次のようになります。

h = f > => g
h = \ x -> （ f x >> = g ） -同等（定義> =>から）
h x = f x >> = g- 同等
-f x == Nothingと仮定する
h x = （なし>> = g ）
=なし
-このように：
なし>> = g =なし

これで、演算子（>> =）がNothing引数にどのように反応するかがわかりました-単に同じNothingを返すだけです：

なし>> = f =なし
x >> = f = {-追加する必要があります-}

ここでgをfに置き換えたことに注意してください。これは正しいことです。関数の名前は重要ではないからです。 実際には、可能な場合は通常関数名を取り除き、次のように特別な演算子_ （アンダースコア）に置き換えます。

なし>> = _ =なし

これは、定義で関数fを使用するため、2番目の式では実行できません。

それでは、他の方法に行きましょう。 fx が失敗しない場合、結果は一部のyに対してJust yの値になります。 Just yからyの値を「アンパック」する必要があり、それを関数gに渡します。gyは関数h全体の結果です。

h = f > => g
h = \ x -> （ f x >> = g ） -同等（定義> =>から）
h x = f x >> = g- 同等
-f x == Just yと仮定する
h x = （ちょうどy >> = g ）
= g y

これにより、定義の2番目の部分が得られます。

なし>> = f =なし
ちょうどx >> = f = f x

yをxに 、 gをfに置き換えたことに注意してください。 繰り返しますが、変数と関数の名前は一貫している限り重要ではありません。

これで、 Maybeモナドの>> =演算子の定義が終了します。 次に、このモナドのリターンを取得する必要があります。

return x = ???

xの任意の値に対して 。 どのようなオプションがありますか？ 私たちはそれを言うことができます

return x =なし

任意のxに対して 。 ただし、これを行うとモナド法に違反します。

return x >> = f == f x
何もない>> = f == f x
何もない== f x- 間違っています！

少なくとも一部の fxが Nothing でないと仮定すると（たとえば、モナド関数fx = Just xを考慮して）、エラーが発生します。 別のオプションがあります：

return x =ちょうどx

そして、それはモナドの法則を満たします：

return x >> = f
= （ Just x ） >> = f- 定義により、Maybeモナドを返す
= f x- 定義により>> =モナドの場合
-最初のモナド法の実装

ちょうどx >> = return
= return x- 定義により>> =たぶんモナド
=ちょうどx- 定義により、Maybeモナドを返す
-第2モナド法の実装

何もない>> = 戻る
=なし-定義により>> =モナドの場合
-第2モナド法の実装

法律が尊重されたら、このオプションを選択します。 Maybeモナドの完全な定義は次のようになります。

インスタンス Monad たぶん どこ
return x =ちょうどx

なし>> = f =なし
ちょうどx >> = f = f x

わあ！ 最初のモナドを作成しました！

私たち自身を保護するために、それが第3モナド法を満たしていることを検証します。

（ mv >> = f ） >> = g == mv >> = （ \ x -> （ f x >> = g ） ）

まず、mv = Nothingの場合の法則を確認します。

（なし>> = f ） >> = g- 左側
=なし>> = g- 定義により>> =
=なし-定義により>> =

なし>> = （ \ x -> （ f x >> = g ） ） -右側
=なし-定義により>> =

OK、チェックは成功しました。 次に、 mv = Just vで機能するかどうかを見てみましょう。ここで、 vは値です。

（ （ Just v ） >> = f ） >> = g- 左側
= f v >> = g- 定義により>> =

（ちょうどv ） >> = （ \ x -> （ f x >> = g ） ） -右側
= （ \ x -> （ f x >> = g ） ） v- 定義により>> =
= f v >> = g- 関数の通常の使用（ベータ削減）

そしてまた成功。 法律が施行されています！ これは本当にモナドの正しい定義かもしれません！ そして観客は夢中になります！

このすべてのポイントは何ですか？ これは、 Maybeモナドのモナド関数の束を簡単に結合できることを意味します。 なぜこれが重要なのか疑問に思うかもしれません。 Maybeモナドの多くのモナド関数、つまり失敗する可能性のある関数を想像することはまったく難しくありません。 タイプがInt-> Maybe Intであるとしましょう。 同様の3つの機能を次に示します。

f :: Int- > 多分 Int
f x = if x ` mod` 2 == 0 then Nothing else Just （ 2 * x ）

g :: Int- > 多分 Int
g x = if x ` mod` 3 == 0 then else Nothing Just （ 3 * x ）

h :: Int- > 多分 Int
h x = if x ` mod` 5 == 0 then else Nothing Just （ 5 * x ）

それらを1つの関数に結合したいと思います。これは、 f 、 g 、 hの順に適用した結果です。

k :: Int- > 多分 Int

また、3つの関数のいずれかが失敗した場合、関数kはNothingを返す必要があります。 この関数は、2、3、または5で割り切れる整数でない場合、入力数に30を掛けます（割り切れる場合、関数はNothingを返します）。

前の資料から、それをよく理解していれば、モナド合成を介してkを指定できることは明らかです。

k = f > => g > => h

または、 >> =演算子を使用できます。

k x = f x >> = g >> = h

または、 do- abstractが好きかもしれません：

k x = do y < -f x
z < -g y
h z

誰でも言えることは簡単です。 {1：原文では、「任意の方法でスライスする」という永続的な表現で、意味が似ています。 -注 あたり。}

一般に、関数hはモナド構造なしで完全に定義できます;このようになります：

k x = ケース f x
なし->なし
ちょうどy- > ケース g y の
なし->なし
ちょうどz- > h z

なぜモナドが重要なのかは明らかです。 複数のMaybe関数をチェーン化することにより、コードを劇的に簡素化します。 この形式で10個のMaybe関数を構成するための大まかな非モナドコードを想像してください。 右側に非常に大きなインデントがあると、読みやすさがひどく影響を受け、入れ子になったcase式の迷路では計算の一般的な構造が失われます。 しかし、モナドの助けを借りて、10個の関数の構成は簡単に書かれています：

f11 = f1 > => f2 > => f3 > => f4 > => f5 > => f6 > => f7 > => f8 > => f9 > => f10

または（ >> =を使用）：

f11 x = f1 x >> = f2 >> = f3 >> = f4 >> = f5 >> = f6 >> = f7 >> = f8 >> = f9 >> = f10

モナドを使用すると、モナド関数の構成は、通常の（非モナド）関数の構成と同じくらい簡単です。

モナドは基本的な概念を説明するのに非常に役立つかもしれませんが、混乱させる可能性があります：多くの人々は、モナドの唯一の役割は非機能計算、つまり入力/出力（コンソールまたはファイルで）を処理することであると誤って信じています、可変グローバル状態など。 そして、いくつかのモナド計算がモナドなしで同じ成功で実行できることを示しました。 モナドは必須のものではなく、 非常に便利であることがわかります。 そのため、非機能コンピューティング用のモナド（ IOを使用 ）を発明した当初の理由にもかかわらず、はるかに大きな適用性があることがわかりました。 このため、モナドは良いです。

次のモナドに移りましょう。

モナドリスト （リスト）

たぶんあなたがモナドが好きなら、あなたはリスト・モナドさえ愛するでしょう。 ;-)この場合、次の定義を入力します。

インスタンス Monad [ ] ここで
（ >> = ） = {-リストの定義>> =-}
return = {-リストの戻り値の定義-}

空のリスト[]を表すには、リスト型コンストラクターを使用することに注意してください。 これは小さなハックです（Haskellのリストに対して特別な構文サポートが提供されます）。 しかし、やるべきことは何もありません。

すべてのモナドと同様に、最初のタスクはこのモナドのモナド関数が何であるかを理解することです。 リストの場合、単項関数fは次のようになります。

f :: a- > [ b ]

（ [b]は、もちろん、「タイプbの要素のリスト」を意味します）。 モナド関数の一般化された定義は次のように書かれていることを思い出してください：

f :: a- > m b

一部のモナドmについては、型コンストラクタである必要があります。 リストはモナドの明らかな候補です。「リスト」は型コンストラクタであるためです（構文がHaskellに組み込まれている場合でも）。 オプションで、リストを自分で定義できます。

データリストa = Nil | 短所（リストa ）

それに対するモナド関数のタイプはそれに応じて見えるでしょう：

f :: a- >リストb

ただし、標準の構文は引き続き使用します。

この種の機能は何ですか？ 通常、これらは、タイプaの入力値を受け取り、1つの便利なコンテナー（リスト）に収集されたタイプbの値の束を生成する関数として理解されます。 （また、コンテナのように見えるモナドがあります。）それらを多くの値を返す関数と考える別の方法、つまり、そのような関数は「1つの」異なる値の束を返します。 （ここではありませんが、並列処理を意味するため、「並列」という意味ではありません。）複数の出力値は単なるリストアイテムです。 次のような関数を使用すると、便利なパースペクティブが開きます。

f :: Int- > [ Int ]
g :: Int- > [ Int ]

ここでは、 fとgの両方が同じInt値を取り、多くのInt値を返します。 しかし、関数fの各結果を取得して、関数gの各結果に適用し、アプリケーションの結果を収集する場合はどうでしょうか。 関数gおよびfの結果リストから各要素をアンパックせずに、これを直接行うことができれば素晴らしいでしょう。 そして、これはリストモナドを使用して行うことができます。

これらの関数のより具体的な例に移りましょう：

f :: Int- > [ Int ]
f x = [ x - 1 、 x 、 x + 1 ]

g :: Int- > [ Int ]
g x = [ -x 、 x ]

これら2つの関数をどのように「構成」しますか？ fxはリストを返し、各要素にgを適用するには、 map関数が必要です。

f 10- > [ 9、10、11 ]
マップ g （ f 10 ） -> [ [ -9、9 ] 、 [ - 10、10 ] 、 [ - 11、11 ] ]

この新しい結果は興味深いものですが、 fとgの合成にはなりません。異なるタイプ（ Intリストだけでなく、 Intリストのリスト）があるためです。 concat関数を使用して単純なリストに滑らかにすることができます（リストを1つに単純に連結します）。

-連結タイプに特に注意してください：[[a]]-> [a]
concat （ map g （ f 10 ） ） -> [ -9、9、-10、10、-11、11 ]

整数にfを適用し、次にfの後に起こったことにgを適用することによって生成されたすべての結果のセットを得ました。 fとgをここで多くの結果を生成する関数と考える場合、それらの出力値はfを使用してから次にgを使用するすべての可能なセットになります。 これを図で表すことができます。

                   g |  -9
            |  9 ----> |
            |  |  9
            |
        f |  g |  -10
   10 ----> |  10 ----> |
            |  |  10
            |
            |  g |  -11
            |  11 ----> |
                       |  11 

fとgの構成は、 fとgの間のすべてのパスのセットであることが明確にわかります。

奇妙なことに、リストモナドに対して演算子>> =を定義しました！ 次のように設定されます。

-mv :: [a]
-g :: a-> [b]
mv >> = g = concat （ map g mv ）

ここで、 mvはリストモナドのモナド値です（タイプaの値のリストにすぎません）。 前の例では、 mvはf 10の計算結果です。 定義は空のリスト[]に対しても機能します。関数を空のリストにマッピングすると空のリストが得られ、空のリストの連結も常に空のリストになるためです。 結果は、演算子>> =の非常に単純な定義です。

[GHCファンへの注意：GHCコンパイラの>> =演算子は、同じことを行いますが、より効率的かつ異なる方法で実装されると考えています。]

このモナドの戻り値を設定する方法は？ モナドのリストの値を、多くの値を返す「アクション」と考えてみましょう。 他のモナドのように、 returnはユニット関数と同等でなければならないことを思い出してください。 リストモナドの単一の関数に相当するものは何ですか？ 値を取り、「計算」の後、単にその値を返す「アクション」を返す必要があります。 そのため、 returnは単に空のリストを返すことができないことに気付きました。 returnについて次のようなものを想定するのは合理的です。

return :: a- > [ b ]
return x = [ x ]

つまり、 returnは、単一の値からリストを要素的に作成します。 この場合、モナドの法則が順守されているかどうかを確認します。

-f :: a-> [b]
-x :: a
return x >> = f = concat （ map f （ return x ） ） -定義により>> =
= concat （ map f [ x ] ） -定義により
= concat [ f x ] -定義マップにより
= f x- 定義により、連結
-最初のモナド法の実装

-mv :: [a]
mv >> = return = concat （ map return mv ） -定義により>> =
= concat （ map （ \ x- > [ x ] ） mv ） -定義により
-2つのケース：
-ケース1：mv == []
= concat （ map （ \ x- > [ x ] ） [ ] ） -定義により、mv
= concat [ ] -定義によりマップ
= [ ] -定義によりconcat
= mv- 定義によりmv
-ケース2：mv == [v1、v2、...]
= concat （ map （ \ x- > [ x ] ） [ v1 、 v2 、 ... ] ） -定義により、mv
= concat [ [ v1 ] 、 [ v2 ] 、 ... ] -定義によりマップ
= [ v1 、 v2 、 ... ] -定義によりconcat
= mv- 定義によりmv
-第2モナド法の実装

さて、モナドの2つの法則が証明されています。 リターンの他の定義を試してみるとよい場合があります（ リターンが返される場合、たとえば特定のリスト[0、2、3] 、または引数のコピーを無限に返す場合）。これらはすべてモナドの法則に違反していることがわかります。 これは、モナドの法則を実践する良い方法です。

リストを実際のモナドと呼ぶ前に、3番目のモナドの法則を証明することが残っています。 それは言わなければならない、それはより難しいが、とにかくしようとします。 タスクを簡素化するために、3番目のモナド法則（モナド構成で定義）の「快適な」形式を取ります。 まず、リストの単項合成の定義が必要です。

-3番目のモナド法（快適なバージョン）：
（ f > => g ） > => h = f > => （ g > => h ）
-定義により：
f > => g = \ x- > f x >> = g
-リストモナドの定義>> =を使用します。
f > => g = \ x- > concat （ map g （ f x ） ）
-構成演算子（。）を使用して式を書き換えることができます。
f > => g = concat マップ g 。 f

さらに、 concatおよびmap関数のいくつかのプロパティを使用します。 あなたは今のところ彼らを信仰に連れて行かなければならないでしょう。 次に、それらを取得する方法を示します。

-方程式1：
map （ f。g ） = マップ f 。 地図 g
-方程式2：
マップ f 。 concat = concat 。 マップ （ マップ f ）
-方程式3：
concat 。 concat = concat 。 地図 連結

以前、ドット（。）は（純粋な）合成演算子であると言いました。 関数、つまりマップfのような式を適用するよりも優先順位が低くなります。 マップgは平均のみ（マップf）。 （マップg） 。 Haskellプログラマーは通常、可能であれば括弧を取り除きます。 また、たとえば、 map f関数は、実際には2つの引数を持つマップ関数（リストアイテム用の関数とリスト自体）であることを理解することも重要です。 カリー化について話していたことを思い出すと、 マップfは1つのリストを取得して別のリストを返す関数であり、 fは各要素に適用されていると推測できます。 今からカレーをたくさん使います。

したがって、これまでに述べられたことをすべて考慮に入れた証拠の結論：

（ f > => g ） > => h
= （ concat。map g。f ） > => h- 定義により> =>
= concat 。 マップ h 。 （ concat。map g。f ） -定義により> =>
= concat 。 マップ h 。 concat 。 マップ g 。 f- 不要な角かっこを削除する

f > => （ g > => h ）
= f > => （ concat。map h。g ） -定義により> =>
= concat 。 map （ concat。map h.g ） 。 f- 定義により> =>
= concat 。 map （ （ concat。map h ） .g ） 。 f は同等の変換です
= concat 。 （ map （ concat。map h ） ） 。 （ マップ g ） 。 f- 式1による
= concat 。 マップ （ 連結 マップ h ） 。 マップ g 。 f- 不要な角かっこを削除する
= concat 。 地図 連結 地図 （ 地図 h ） 。 マップ g 。 f- 式1による

次のことを示す必要があります。

concat 。 マップ h 。 concat = concat 。 地図 連結 地図 （ 地図 h ）

それを証明しましょう。

-明確にするために括弧を追加します。
concat 。 （ map h。concat ） = concat 。 地図 連結 地図 （ 地図 h ）
-式2によると：
concat 。 concat 。 map （ map h ） = concat 。 地図 連結 地図 （ 地図 h ）
-明確にするために括弧を追加します。
（ concat。concat ） 。 map （ map h ） = concat 。 地図 連結 地図 （ 地図 h ）
-式3に従って：
concat 。 地図 連結 map （ map h ） = concat 。 地図 連結 地図 （ 地図 h ）

そしてこれで終わりです。 ふう！ 実際、Haskellistsがこれを行うことはめったにありませんが、疑わしいモナドが本当にモナドであることを示す証拠が必要です。

限界ノート： マップ/連結によるアイデンティティの導出（式1、2、および3）

準備する

身元の証明を進める前に、他のいくつかの証明をする必要があります（数学は難しい！）。 それらをリストします。

-式4：
concat （ x：xs ） = x ++ concat xs
-式5：
concat （ x ++ y ） = concat x ++ concat y
-式6：
map f （ x ++ y ） = map f x ++ map f y

式4はconcatの定義から得られます。 式5は、式4を使用したxの帰納法によって簡単に証明されます。

-ベースケース：x-空のリスト
concat （ [ ] ++ y ） = concat [ ] ++ concat y
concat y = [ ] ++ concat y- 定義によりconcat []
concat y = concat y- 定義により++
-そうです。

-誘導：リストxは空ではありません。 x1はリストの先頭です。 xsはリストの末尾です。
concat （ （ x1：xs ） ++ y ）
= concat （ x1： （ xs ++ y ） ） -定義により++
= x1 ++ concat （ xs ++ y ） -式4
= x1 ++ concat xs ++ concat y- 帰納的仮説

concat （ x1：xs ） ++ concat y
= x1 ++ concat xs ++ concat y- 式4
-証​​明する必要があったのは事実です。

式6は同じ方法で証明できます。

-ベースケース：x-空のリスト
map f （ [ ] ++ y ） = map f [ ] ++ map f y
map f y = [ ] ++ map f y
map f y = map f y
-そうです。

-誘導：リストxは空ではありません。 x1はリストの先頭です。 xsはリストの末尾です。
マップ f （ x ++ y ）
= マップ f （ （ x1：xs ） ++ y ）
= map f （ x1： （ xs ++ y ） ） -定義により++
= f x1： map f （ xs ++ y ） -mapで定義されている
= f x1： （ map f xs ++ map f y ） -帰納的仮説
= （ f x1： map f xs ） ++ map f y- 定義により++
= map f （ x1：xs ） ++ map f y -mapで定義されている
= map f x ++ map f y- 定義によりx
-証​​明する必要があったのは事実です。

これで、方程式1、2、および3を証明します。

式1：

map （ f。g ） = マップ f 。 地図 g

mapの定義だけでなく、両側の暗黙のリスト引数に帰納法を使用します 。

-基本ケース：空のリスト
map （ f。g ） [ ] = [ ]
（ マップ f 。 マップ g ） [ ] = マップ f （ マップ g [ ] ） = マップ f [ ] = [ ]
-OK

-誘導：空でないリスト：
マップ （ f。g ） （ x：xs ）
= （ （ f。g ） x ） ：（ map （ f。g ） xs ） -定義マップ
= （ f （ g x ） ） ：（ map （ f。g ） xs ） -定義により（。）
（ マップ f 。 マップ g ） （ x：xs ）
= map f （ map g （ x：xs ） ） -定義により（。）
= map f （ （ g x ） ：（ map g xs ） ） -定義によりマップ
= （ f （ g x ） ） ：（ map f （ map g xs ） ） -定義によりmap
= （ f （ g x ） ） ： （ （ map f。map g ） xs ） -定義により（。）
= （ f （ g x ） ） ：（ map （ f。g ） xs ） -帰納的仮説
-証​​明する必要があったのは事実です。

式2：

マップ f 。 concat = concat 。 マップ （ マップ f ）

帰納法で証明する：

-基本ケース：空のリスト
（ map f。concat ） [ ] = map f （ concat [ ] ） = map f [ ] = [ ]
（ concat。map （ map f ） ） [ ] = concat （ map （ map f ） [ ] ） = concat [ ] = [ ]
-OK

-誘導：空でないリスト
（ map f。concat ） （ x：xs ）
= map f （ concat （ x：xs ） ） -定義により（。）
= map f （ x ++ concat xs ） -式4
= map f x ++ （ map f （ concat xs ） ） -式6
= map f x ++ （ （ map f。concat ） xs ） -定義により（。）
= map f x ++ （ （ concat。map （ map f ） ） xs ） -帰納的仮説
= map f x ++ concat （ map （ map f ） xs ） -定義により（。）

（ concat。map （ map f ） ） （ x：xs ）
= concat （ map （ map f ） （ x：xs ） ） -定義により（。）
= concat （ map f x： map （ map f ） xs ） -定義によりmap
= map f x ++ concat （ map （ map f ） xs ） -式4
-証​​明する必要があったのは事実です。

式3：

concat 。 concat = concat 。 地図 連結

いつものように、誘導を使用します。

-基本ケース：空のリスト
（ concat。concat ） [ ] = concat （ concat [ ] ） = concat [ ] = [ ]
（ concat。map concat ） [ ] = concat （ map concat [ ] ） = concat [ ] = [ ]
-そう

-誘導：空でないリスト
（ concat。concat ） （ x：xs ）
= concat （ concat （ x：xs ） ） -定義により（。）
= concat （ x ++ concat xs ） -式4
= concat x ++ concat （ concat xs ） -式5

（ concat。map concat ） （ x：xs ）
= concat （ map concat （ x：xs ） ） -定義により（。）
= concat （ concat x： map concat xs ） -mapで 定義されている
= concat x ++ concat （ map concat xs ） -式4
= concat x ++ （ concat。map concat ） xs- 定義により（。）
= concat x ++ （ concat。concat ） xs- 帰納的仮説
= concat x ++ concat （ concat xs ） -定義により（。）
-証​​明する必要があったのは事実です。

リストモナドが本当にモナドであることを疑う余地がないことを願っています。 ;-)

そしてもちろん、ここで最も興味深い質問はこれです：モナドなしでは難しいリストモナドで何ができるでしょうか？ 簡単な例を次に示します。合計が7である1〜6の数字のペアをすべて見つけます（数字はサイコロなど）。 リストモナドを使用すると、問題を解決するのは簡単です。

-<font color = blue> do </ font>表記を使用します。
do n1 <- [ 1 .. 6 ]
n2 <- [ 1 .. 6 ]
n1 + n2 == 7の 場合、 （ n1 、 n2 ） else [ ]を 返し ます
-結果：[（1,6）、（2,5）、（3,4）、（4,3）、（5,2）、（6,1）]

また、 do表記なしで書き換えることもできますが、明確ではありません。

[ 1 .. 6 ] >> = \ n1- >
[ 1 .. 6 ] >> = \ n2- >
n1 + n2 == 7の 場合、 （ n1 、 n2 ） else [ ]を 返し ます

どのように機能しますか？ 座って>> =に関連するすべての計算をトレースし、リストに戻る必要がありますが、ここでは指の説明を示します。 したがって： [1..6]はリストモナドのモナド値であり、 n1は一度にすべてのモナド値を実行します 。 n2-まったく同じ。 そして、合計が正しいすべてのペア（n1、n2）が返されます。 これは、あたかもそれらが1つの要素であるかのように、すべての要素で関数を計算する方法です。 これがモナドリストの本質です。

Haskellプログラミングの知識が豊富であれば、おそらく頭の中でサイレンが聞こえたでしょう。 「なんてことだ！」私はあなたのdigりを聞いた。 「なぜリスト内包表記を使用しないのですか？」そして本当に：

[ （ n1 、 n2 ） | n1 <- [ 1 .. 6 ] 、 n2 <- [ 1 .. 6 ] 、 n1 + n2 == 7 ]

リストモナドとリストジェネレーターの機能は同じです。 この構文またはその構文の選択は設定に依存し、タスクによって決定することもできます。 彼の記事「Comprehending Monads」では、 Phil Walder （彼の多くの記事のようにタイトルにしゃれがあります）は、リストジェネレーターの構文を任意のモナドに拡張することさえ提案しました。 それにもかかわらず、この提案は現在の記録を支持して拒否されました。

リストモナドは、リストジェネレーターの単なる代替手段ではありません。 一方では、あらゆるモナドの化身と連携する非常に一般的な関数がたくさんあります。 リストモナドでも動作します。 一方、 MonadPlusと呼ばれるMonad型クラスには拡張機能があります。 モナドの機能を補完します（具体的には、モナドの「ゼロ」要素を定義し、2つのモナド値を「追加」する操作を導入します）。 リストはMonadとMonadPlusの両方の化身によって作成されます。つまり、 MonadPlusの共通機能はリストでも機能します。 （たとえば、 concat関数の一般化-リストを含むMonadPlusのすべてのインカネーションで機能するmsum 関数 ）があります。多くのデータ型で機能できるが、各型に個別に指定しない一般化機能を使用するのは素晴らしいことです。 これは明らかな勝利です。

次回

次の記事では、エラーを追跡できるモナドについて説明します。

内容

パート1：基本
パート2：関数>> =およびreturn
パート3：モナドの法則
パート4：多分モナドとリストモナド