モナドを勉強しようとするとモナド則が立ちはだかります。しかしモナド則は意味だけでなく、それがモナドを勉強する上でどういう位置付けなのかも分かりにくいです。とりあえず棚上げしたまま分かる範囲のことから手を付けていましたが、ちょっと分かったような気がしたのでメモしておきます。

モナド則に関する現時点の理解ですが、正確さは保証できません。
これを読めばモナドが理解できるという類の説明（モナドチュートリアル）ではありません。
試験的にモナド則を図示しました。コードを図に転写して、多少の解釈を加えたものです。もし分かりにくければ無視しても構いません。

この記事はHaskell 超入門シリーズの番外編です。

モナド則

モナド則は return と >>= の動きに関するルールです。

return x >>= f == f x
m >>= return == m
(m >>= f) >>= g == m >>= (\x -> f x >>= g)

各モナド則は式を == で区切り、左辺と右辺が等しいかを見ます。等しくなるものがモナドだ、というルールです。等しくならないものは作れますが、それはモナドではありません。

解釈を書いておきます。（詳細は後述）

>>= の左側の return が消せることを要請します。
>>= の右側の return が消せることを要請します。
あらかじめ関数が合成できることを要請します。

※ 余談ですが、いきなりこういうのを見せられたときの感覚が、次のツイートでうまく表現されていると思いました。

最初に骸骨を見せて「これからこれに肉付けをして美女にします」というのがいまの大学の数学科のカリキュラムみたいなもんね。最初から美女のイメージ持ってる人は楽しいのかもしれないけど、そうでない人はいつまでも骸骨と一緒にワルツを踊ってなきゃいけない。
— ゼルプスト殿下 (@tenapyon) 2014年12月1日

何でないか

モナドを勉強するには、まずモナド則を理解しないといけないわけではありません。
モナド則を理解すれば、モナドがすっきり分かるというものではありません。

何であるか

モナド則は、モナドを作るときに守らないといけないルールです。
モナドを使う側の立場からは、コードを整理するのに役立ちそうです。

モナドの勉強

モナドをどう勉強するかについて、現段階で感じていることです。

モナドの勉強にあたって、モナドの作り方から入るのは難しいです。オブジェクト指向を勉強するときに、クラスの作り方から入るようなものです。（それは難しいよね、という意味合いです）
モナドが何かという抽象的な問いかけはしなくても、単なるプログラミングテクニックとして既存のモナドは使えそうです。オブジェクト指向で例えれば、デザインパターンに沿ってきれいな設計のクラスが作れなくても、既存のクラスは使えるようなものです。

※ もちろん最終的にはモナドが作れるに越したことはありませんが、ここで想定しているのは学習の初期段階です。

次のような見解もあります。

モナド則とか、理解しなくてもいいですって。分かれば当たり前のことだし、分からなくてもプログラムは書けるし。教えちゃうから、分からないってなっちゃう。知らないといけないのは、モナドを自分で作るようになってから。
— 山本和彦 (@kazu_yamamoto) 2013, 11月 28

モナド・ミニマム

returnと>>=で操作できてモナド則を満たすものをモナドと呼びます。

モナドはよく箱だと言われます。中に値が入った箱です。

リストの実体もモナドで、まさに値が入った箱です（例：[1]）。そのためモナド代表としてリストで説明します。

return

returnはモナドという箱に値を入れるための関数です。

ghciで確認します。

Prelude> return 1
1

これだけでは単なる1と区別が付かないので、:tで型を調べます。

Prelude> :t 1
1 :: Num a => a
Prelude> :t return 1
return 1 :: (Monad m, Num a) => m a

単なる1と、モナドに入れられた1とは型が異なることが確認できました。

※ 一番下の行の => の右側の m a に注目してください。

型表記を単純にするため、1がIntであることを指定します。

Prelude> :t return (1 :: Int)
return (1 :: Int) :: Monad m => m Int

※ m a が　m Int に変化したことに注目してください。

モナドの型を指定します。リスト型は[]です。

Prelude> return 1 :: [] Int
[1]

※ m Int の m を [] に置き換えて [] Int となります。[Int] とも書けます。

型を指定することで、returnによりリストモナドに1という値を入れることができました。複雑な書き方をしていますが、得られるものは[1]と同じです。

>>=

モナドを関数に渡すための演算子が>>=（バインドと読む）です。

モナド >>= 関数で以下の処理が行われます。（漏斗に例えています）

モナドから値が取り出されます。
取り出された値が関数に引数として渡されます。
関数では戻り値をモナドに入れて返します。

関数はモナドを返す必要があります。一番簡単な対応方法は計算結果をreturnでモナドに入れることです。

Prelude> let f x = return $ x + 1

動作を確認します。

Prelude> [1] >>= f
[2]

モナドから1が取り出されて関数fに渡され、関数の戻り値が表示されました。

連続

わざわざ>>=などというものを用意して、しかもモナドから値の出し入れなどという複雑なことをしているのは、それを連続させたいからのようです。

Prelude> [1] >>= f >>= f >>= f >>= f
[5]

これで何が嬉しいのかは、具体的に意味のあるものを作ってみないと実感しにくいです。しかし簡単なサンプルは思い付かないので、別の言語で似た例を示します。

メソッドチェイン

>>=を連続させる使い方は、オブジェクト指向言語におけるメソッドチェインに似ています。

x >>= f >>= f >>= f >>= f
x.f().f().f().f()

C#での実装例を示します。オブジェクト指向でモナドを模倣すると冗長になります。

using System;

class Test
{
    private readonly int x;

    private Test(int x)
    {
        this.x = x;
    }

    public static Test @return(int x)
    {
        return new Test(x);
    }

    public Test f()
    {
        return @return(x + 1);
    }

    public override string ToString()
    {
        return "[" + x + "]";
    }

    static void Main()
    {
        Console.WriteLine(@return(1).f().f().f().f());
    }
}

実行結果

[5]

C#でメソッドチェインが多用されるのはLinqやRxです。モナドの>>=も同じような目的で使うことができると考えても、当たらずと雖も遠からずではないでしょうか。

※ 実際には>>=は関数呼び出しの前後に処理を挟むことができるため、メソッドチェインよりも強力です。今回の範囲を超えるため詳細は省略しますが、興味があれば次の記事を参照してください。

@7shi: Haskell Maybeモナド超入門 2015.1.22

モナド則を確認

結果の分かりやすさを考慮してリストで確認します。

※ 理解の便宜として一例を示しただけです。証明ではありません。

1. `return x >>= f` == `f x`

>>= の左側の return が消せることを要請します。

returnでモナドに値xを入れてからすぐ>>=でxを取り出して関数fに渡すのは、値xを関数fに直接渡すのと等しいです。左辺は出し入れしているだけです。

Prelude> let x = 1
Prelude> let f x = [x + 1]
Prelude> return x >>= f
[2]
Prelude> f x
[2]

当たり前に思えます。

2. `m >>= return` == `m`

>>= の右側の return が消せることを要請します。

モナドmから>>=で値を取り出してreturnでまたモナドに入れれば、それは元のmと等しいです。左辺は出し入れしているだけです。

Prelude> let m = [1]
Prelude> m >>= return
[1]

これもまた当たり前に思えます。

return

C言語などの感覚でコードを見ると、ブロックの最後にreturnがあるとしっくり来ます。

例

inc x = return $ x + 1

test x = do
    y <- inc $ x * 2
    return y

main = do
    print =<< test 3

モナド則2により、関数testのreturnは省略できます。

test x = inc $ x * 2

コーディングスタイルの是非はともかく、このような変形を保証しているのがモナド則2です。

3. `(m >>= f) >>= g` == `m >>= (\x -> f x >>= g)`

あらかじめ関数が合成できることを要請します。

右辺のラムダ式を関数化して fg x = f x >>= g とおけば fg は f と g の関数合成に相当します。

※ f と g の間にモナドから値を取り出す操作 >>= が必要なため、単純な関数合成 g . f では型エラーとなります。(>>= g) . f とする必要があります。f >=> g とも書けます。（詳細は後述）

fg によって書き換えると (m >>= f) >>= g == m >>= fg となります。両辺とも m が f → g の順に渡されます。処理される順番が同じなので、f や g がどのような関数であっても結果は同じです。

Prelude> let m = [1]
Prelude> let f x = return $ x + 1
Prelude> let g x = return $ x * 2
Prelude> (m >>= f) >>= g
[4]
Prelude> m >>= (\x -> f x >>= g)
[4]

見かけはややこしいですが、理屈は当たり前です。

※ モナド則1と2を満たして3だけを満たさないものは、意図的に作ろうとしてもなかなか難しいです。詳細はコメントを参照してください。

注意

>>= は左結合のため、左辺 (m >>= f) >>= g の括弧は外せます: m >>= f >>= g
- m >>= (f >>= g) は型エラーになります。
右辺 m >>= (\x -> f x >>= g) のラムダ式の範囲を明示すると m >>= (\x -> (f x >>= g)) です。
- m >>= ((\x -> f x) >>= g) ではありません。これは型エラーになります。\x -> f x をポイントフリー化すれば f となるため、前述の型エラーになる m >>= (f >>= g) と一致します。（やはりダメだということです）
モナドに適用する関数同士は専用の演算子 >=> で合成できます: fg = f >=> g
- >=> によって右辺 m >>= (\x -> f x >>= g) を書き換えれば m >>= (f >=> g) となります。これはあらかじめ関数を合成しているのが分かりやすい表記です。
- m >>= (f >>= g) とは書けませんが、m >>= (f >=> g) とは書けるという見方もできます。

まとめ

モナドを実装する人が適切にreturnと>>=を実装すれば、モナド則に沿った「当たり前な動き」が実現されます。そうならないように実装することは可能ですが、それはモナドではありません。それを判定するのがモナド則だということのようです。

モナドを使うだけの人にとっては「コードを整理するためのヒント」になりそうですが、わざわざルールとして勉強しなくても、モナドの動きが分かっていれば同等の変形は自然と気付きそうです。

補足

補足情報です。よく分からなければ無視しても構いません。

モナド則3の書き換え

モナド則3の書き換えを並べます。

(m >>= f) >>= g == m >>= (\x -> f x >>= g)（ラムダ式）
(m >>= f) >>= g == m >>= fg where fg x = f x >>= g（関数化）
(m >>= f) >>= g == m >>= (f >=> g)（専用の演算子）
(m >>= f) >>= g == m >>= ((>>= g) . f)（関数合成）

演算子の使い分けにさえ慣れれば、3で考えるのがお勧めです。特に結合法則が読み取りやすいです。

>=> については次の記事が参考になります。

@CyLomw: (>>=) を (>=>) に書き換える 2014.12.30

関数合成

モナド則3を普通の関数合成で書けば m >>= ((>>= g) . f) となります。パズルみたいな見た目です。意味が取りにくい書き方ですが、参考のため説明します。

考え方としては f x >>= g を f x と (>>= g) に分割して、引数 x を取り除き、f と (>>= g) を関数合成したのが (>>= g) . f です。

※ f と g の間にモナドから値を取り出す操作 >>= が入ることに注意します。(>>= g) は g がモナドを受け取るように変換された関数だと解釈します。（この変換を関数の持ち上げと表現します）

書き換える過程を示します。

f x >>= g を f x とセクション (>>= g) に分割して、前者を後者の引数とします。
- f x >>= g → (>>= g) (f x)
(>>= g) と f を合成して、引数 x を括り出します。
- (>>= g) (f x) → ((>>= g) . f) x
ラムダ式の引数をそのまま適用している形になるため、引数を取り除きます。（ポイントフリースタイル）
- \x -> ((>>= g) . f) x → (>>= g) . f