• Tweet

🎅この記事は、Haskell Advent Calendar 2020 25日目の記事です。
🎄Happy Christmas!!🎄

今回は先日（といっても元の質問の投稿からもう何ヶ月も経ってしまいましたが…）StackOverflowに上がったこちら👇の質問に対する回答の、続きっぽい話を書こうと思います。長いし、質問の回答からスコープが大きく外れてしまうので記事にしました。

haskell - モナド則を崩してしまう例が知りたい - スタック・オーバーフロー

MonadとMonoidにある重要な繋がりを説明した後、それを応用したWriter MonadがどうMonoidを使ってMonad則を満たしているのか証明します。そして、Writerのそうした性質を用いて簡単にMonad則を破る例を紹介することで、読者のみなさんがMonad則のみならずdo記法やMonadそのものの性質について、よりはっきりとした理解が得られることを目指します。

Link to
hereサンプルコードについて

本記事のサンプルコードは、Haskellの構文に準拠していないものを除いて、すべてreadme-testというツールの2020年12月13日時点の開発版でテストしました。こちらのツールはまだ開発中で、今後も仕様が大きく変わる可能性がありますが、この記事のサンプルコードをテストするのに必要な機能は十分にそろっています。このreadme-test自体についてはいつか改めて共有します。

また、テストの際に用いた環境は以下の通りです:

• Windows 10 Pro 20H2
• GHC 8.10.1
• Stackage nightly-2020-08-15

Link to
hereMonadとMonoidの切っても切り離せない関係

「モナドは単なる自己関手の圏におけるモノイド対象だよ。何か問題でも？」というフレーズ（原文「A monad is a monoid in the category of endofunctors, what’s the problem?」が示すとおり、モナドとモノイド、Haskellの識別子で言うところのMonadとMonoidには密接な関係があります。ぶっちゃけ、このフレーズの正確な意味を私は理解していないのですが、少なくともMonadとMonoidには重要な共通点があることは知っています。それは、どちらも単位元と結合則がある、ということです！

具体的にMonadとMonoidの単位元・結合則を見てみましょう:

Monoidの単位元: 単位元であるmemptyは、どんな値xに<>で足しても結果が変わらない！

x <> mempty = x
mempty <> x = x

Monadの単位元: returnは>>=の前に使っても後ろに使っても、mやk aの結果を変えない！

return a >>= (\a -> k a) = k a
m >>= (\a -> return a) = m

Monoidの結合則: x <> y <> zの結果は、y <> zを先に計算しようとx <> yを先に計算しようと変わらない！

x <> (y <> z) = (x <> y) <> z

Monadの結合則: m >>= \x -> k x >>= h の結果は、\x -> k x >>= hを先に計算しようと、m >>= (\x -> k x)を先に計算しようと変わらない！

m >>= (\x -> k x >>= h) = (m >>= (\x -> k x)) >>= h

※Monadの単位元・結合則の式についてはわかりやすさのために引用元から少し形を変えています。

HaskellにおけるMonad・Monoidとは、値がそれぞれの単位元・結合則をを満たす型です¹。それ以上でも、それ以下でもありません。

それぞれの単位元・結合則を表す式は、一見して異なるものに見えるかも知れませんが、表す性質自体はよく似ています。なので、式を読んでもよく分からないという方は、上記に書いた日本語の説明をざっと眺めて覚えておいてください。特に、結合則における「～を先に計算しようと、～を先に計算しようと変わらない！」の部分がこの後とても重要になります。

Link to
hereMonoidの例

ここまで読んで、Monadはなんか聞いたことがあるけどMonoidは初めて聞くよ、という方向けに補足すると、Monoidとは例えば次のような型の値（と、それに対する処理）です。

Sum型: 数値（Num型クラスのインスタンス）に対する、足し算を表すMonoidのインスタンス

-- これから紹介する処理に必要なモジュールのimport
import Data.Monoid

-- Sum aに対する <> は + と同等なので、
> getSum (Sum 1 <> Sum 2 <> mempty)
-- は、
1 + 2 + 0
-- と同じ。

memptyが各Monoidのインスタンスにおける単位元を返す、という点に注意してください。上記のとおり足し算の場合は0です。

Product型: 数値（Num型クラスのインスタンス）に対する、かけ算を表すMonoidのインスタンス

-- Product aに対する <> は * と同等なので、
> getProduct (Product 1 <> Product 2 <> mempty)
-- は、
1 * 2 * 1
-- と同じ。

リスト型: リスト型の値に対する、結合 (++)を表すMonoidのインスタンス

-- [a] に対する <> は ++ と同等なので、
> [1, 2] <> [3] <> mempty
-- は、
[1, 2] ++ [3] ++ []
-- と同じ

All型: Bool型の値に対する論理積&&を表すMonoidのインスタンス

> getAll (All True <> All False)
-- は、
True && False
-- と同じ

-- これが何を返すかは、想像してみてください！
getAll mempty

Any型: Bool型の値に対する論理和||を表すMonoidのインスタンス

> getAny (Any True <> Any False)
-- は、
True || False
-- と同じ

-- これも何を返すかは、想像してみてください！
getAny mempty

このように、Monoidは他のプログラミング言語でもおなじみの、多くの二項演算を表しています。これらのインスタンスはすべて、先ほど紹介した「単位元」や「結合則」のルールを守っているので、気になった方はぜひチェックしてみてください²。

Link to
hereMonoidとWriterの切っても切り離せない関係

実はそんなMonadとMonoidの固い絆を象徴するようなMonadが、この世にはあります。そう、Writerです！WriterはMonoidの単位元・結合則をそのまま活かすことによってMonadの単位元・結合則を満たしたMonadであり、WriterがどうやってMonad則を満たしているのか知れば、Monad則がどうやって成立するものなのかが、すっきりクリアになることでしょう。

手始めにWriterの定義と、WriterがMonadの各メソッドをどのように実装しているか見てみましょう。「モナドのすべて」におけるWriterの紹介ページから、少しリファクタリングしつつ引用します³。

-- Writer型の定義
newtype Writer w a = Writer { runWriter :: (a, w) }

タプルに対してnewtypeしていることから分かるとおり、Writerの実態はただのタプルです。ただのタプルがどうやってMonadになるのでしょう？その答えがこちら👇:

-- WriterのMonad型クラスの実装
-- 実際のところFunctor, Applicativeのインスタンス定義も必要だけどここでは省略
instance Monoid w => Monad (Writer w) where
  return a = Writer (a, mempty)
  Writer (a, w1) >>= f =
    let Writer (b, w2) = f a
     in Writer (b, w1 <> w2)

returnの定義は比較的シンプルですね。memptyを受け取った値aと一緒にタプルに入れて返すだけです。Monadの単位元であるreturnでは、Monoidの単位元であるmemptyを使うのです。

一方、>>=はどう読めばいいでしょう？let ... in ...の結果にあたるWriter (b, w1 <> w2)に注目してください。

まず、bは>>=の右辺であるfが返した結果です。Writerの>>=が返す、Writerがラップしたタプルの一つ目の要素は、ここでfが返した値の型と一致していなければなりません。Writerにおいて>>=の型はWriter w a -> (a -> Writer w b) -> Writer w bであり、右辺にあたるfは(a -> Writer w b)という型なので、>>=全体の戻り値Writer w bとfの戻り値が一致している必要があることがわかりますよね？

さらに重要なのがw1 <> w2です。ここであのMonoidの演算子<>が出てきました！Writerは>>=の中で<>を使うMonadなんですね！一体何と何を<>しているのでしょう？まず、<>の左辺であるw1は、左辺にあたるWriterがタプルに保持していたMonoid型クラスのインスタンスの値です。そして右辺のw2は、>>=の右辺に渡した関数fがbと一緒に返したw2です。

以上のことをまとめると、Writerの>>=は、

1. 左辺の(a, w1)におけるaをfに渡して、
2. fが返した(b, w2)におけるbを、
3. w1とw2と一緒に<>でくっつけつつ返す、

という処理を行っています。Writerは、「bを返すついでにw1とw2を<>でくっつける」と覚えてください。

Writerは、

• Monadの単位元returnでMonoidの単位元memptyを使って、
• Monadの結合則を満たす>>=で、これまたMonoidの結合則を満たす<>を使っているのです。

やっぱりWriterはMonoidあってのMonadと言えますね。

Link to
heredoと<>

さて、この「bを返すついでにw1とw2を<>でくっつける」というWriterの振る舞いが象徴するように、大抵のMonadのインスタンスにおける>>=は、何かしら値を返すついでに、何らかの処理を行うよう実装されています。この「ついでに行われる処理」はMonadのインスタンスをdo記法の中で扱うと、ますます静かに身を隠すようになります。

こちらもWriterを例に説明しましょう。まず、例示用にWriterを作るアクションを適当に定義します。

addLogging :: Int -> Int -> Writer [String] Int
addLogging x y =
  Writer (x + y, ["Adding " ++ show x ++ " to " ++ show y ++ "."])

multLogging :: Int -> Int -> Writer [String] Int
multLogging x y =
  Writer (x * y, ["Multiplying " ++ show x ++ " with " ++ show y ++ "."])

addLoggingとmultLoggingはそれぞれ、引数として受け取った整数を足し算したりかけ算したりしつつ、「足したよ」「かけたよ」という内容の文字列を一緒に返します。Writer [String] Intにおける[String]にログとして書き込んでいるようなイメージで捉えてください。

これらをdoの中で使ってみると、よりaddLoggingやmultLoggingが「足し算やかけ算をするついでに、ログとして書き込んでいる」っぽいイメージが伝わるでしょう:

testDo :: Writer [String] Int
testDo = do
  result1 <- addLogging 3 4
  result2 <- multLogging 5 2
  addLogging result1 result2

⚠️申し訳なくもdo記法自体の解説、つまり>>=がどのようにdo記法に対応するかはここには書きません。お近くのHaskell入門書をご覧ください。

👆では、3 + 4した結果result1と、5 * 2した結果result2を足す処理を行っています。それに加えて、「足したよ」「かけたよ」というログを表す文字列のリスト[String]も一緒に返しています。do記法が>>=に変換されるのに従い、Writerの>>=が内部で<>を使い、addLogging 3 4・multLogging 5 2・addLogging result1 result2が返した文字列のリスト[String]を結合することによって、あたかもaddLoggingやmultLoggingが「値を返しつつ、ログとして書き込む」かのような処理を実現できるのがWriterにおけるdo記法の特徴です。

能書きはここまでにして、実際にどのような結果になるか見てみましょう:

> runWriter testDo
(17,["Adding 3 to 4.","Multiplying 5 with 2.","Adding 7 to 10."])

はい、3 + 4と5 * 2の結果を足し算した結果17と、addLogging 3 4・multLogging 5 2・addLogging result1 result2が一緒に返していた文字列のリスト[String]が、書いた順番どおりに結合されて返ってきました。Writerはdo記法の中に書いたWriterの値(a, w)のうち、Monoidのインスタンスであるwを<>で都度結合させているということが伝わったでしょうか？

Link to
hereWriter Monadの結合則とMonoidの結合則

ここまでで、Writer Monadがどのように<>を使っているのか、それによって>>=やdo記法がどのように振る舞っているのか、具体例を示して説明いたしました。ここからは、WriterがMonoidの<>の結合則をどう利用することで、Monadとしての>>=の結合則を満たしているのかを示しましょう。長いので「めんどい！」という方はこちらをクリックしてスキップしてください。

そのために、Monadの結合則における>>=を、Writerの>>=として展開してみます。

(0) Monadの結合則:

m >>= (\x -> k x >>= h) = (m >>= (\x -> k x)) >>= h

(1) mは>>=の左辺なのでWriter (a, w1)に置き換える:

※ここからは、比較しやすくするために等式=の左辺と右辺を別々の行に書きます。

let Writer (a, w1) = m in Writer (a, w1) >>= (\x -> k x >>= h)
  =
let Writer (a, w1) = m in Writer (a, w1) >>= (\x -> k x) >>= h

(2) 一つ目の>>=をWriterにおける>>=の定義で置き換える:

let Writer (a, w1) = m
    Writer (b, w2) = (\x -> k x >>= h) a
 in Writer (b, w1 <> w2)
  =
let Writer (a, w1) = m in Writer (a, w1) >>= (\x -> k x) >>= h

(3) 等式=の右辺における一つ目の>>=も同様に変換する:

let Writer (a, w1) = m
    Writer (b, w2) = (\x -> k x >>= h) a
 in Writer (b, w1 <> w2)
  =
let Writer (a, w1) = m
    Writer (b, w2) = (\x -> k x) a
 in Writer (b, w1 <> w2) >>= h

(4) 無名関数である(\x -> k x >>= h)と(\x -> k x)に、aを適用する:

let Writer (a, w1) = m
    Writer (b, w2) = k a >>= h
 in Writer (b, w1 <> w2)
  =
let Writer (a, w1) = m
    Writer (b, w2) = k a
 in Writer (b, w1 <> w2) >>= h

(5) 等式=の左辺における二つ目の>>=をWriterにおける>>=の定義で置き換える:

let Writer (a, w1) = m
    Writer (b, w2) =
      let Writer (c, w3) = k a
          Writer (d, w4) = h c
       in Writer (d, w3 <> w4)
 in Writer (b, w1 <> w2)
  =
let Writer (a, w1) = m
    Writer (b, w2) = k a
 in Writer (b, w1 <> w2)) >>= h

(6) 等式=の右辺における二つ目の>>=も同様に変換する:

let Writer (a, w1) = m
    Writer (b, w2) =
      let Writer (c, w3) = k a
          Writer (d, w4) = h c
       in Writer (d, w3 <> w4)
 in Writer (b, w1 <> w2)
  =
let Writer (a, w1) = m
    Writer (b, w2) = k a
 in let Writer (c, w3) = Writer (b, w1 <> w2)
        Writer (d, w4) = h c
     in Writer (d, w3 <> w4)

(7) Writerは、Writerと(a, w)を切り替えるだけで実質何もしていないので削除する:

let (a, w1) = m
    (b, w2) =
      let (c, w3) = k a
          (d, w4) = h c
       in (d, w3 <> w4)
 in (b, w1 <> w2)
  =
let (a, w1) = m
    (b, w2) = k a
 in let (c, w3) = (b, w1 <> w2)
        (d, w4) = h c
     in (d, w3 <> w4)

(7.5) (7)の等式をよく見ると、=の左辺においては(b, w2)と(d, w3 <> w4)が、=の右辺においては(c, w3)と(b, w1 <> w2)が等しい。

let (a, w1) = m
    (b, w2) = --           ここの(b, w2)は、
      let (c, w3) = k a
          (d, w4) = h c
       in (d, w3 <> w4) -- ここの(d, w3 <> w4)を代入したもの！
 in (b, w1 <> w2)
  =
let (a, w1) = m
    (b, w2) = k a
 in let (c, w3) = (b, w1 <> w2) -- ここで代入している！
        (d, w4) = h c
     in (d, w3 <> w4)

(8) (7.5)から、=の左辺ではb = dでw2 = w3 <> w4、=の右辺ではc = dでw3 = w1 <> w2であることがわかる。なのでそれぞれ置き換える:

let (a, w1) = m
    (c, w3) = k a
    (d, w4) = h c
 in (d, w1 <> (w3 <> w4))
  =
let (a, w1) = m
    (b, w2) = k a
    (d, w4) = h b
 in (d, (w1 <> w2) <> w4)

(9) a～d・w1～w4の変数名を、登場した順番に振り直す:

let (a, w1) = m
    (b, w2) = k a
    (c, w3) = h b
 in (c, w1 <> (w2 <> w3))
  =
let (a, w1) = m
    (b, w2) = k a
    (c, w3) = h b
 in (c, (w1 <> w2) <> w3)

等式=の左辺と右辺がそっくりな式になりましたね！

ここで、Monoidの結合則を思い出してみましょう:

x <> (y <> z) = (x <> y) <> z

そう、x <> y <> zなどと書いて3つのMonoid型クラスのインスタンスの値を<>でくっつけるときは、カッコで囲って(y <> z)を先に計算しようと、(x <> y)を先に計算しようと、結果が変わらない、というものでした！

それを踏まえて、(9)の等式=の両辺をよく見比べてみてください。異なっているのはw1 <> (w2 <> w3)と(w1 <> w2) <> w3)の箇所だけですね！つまり、Writer Monadにおける>>=の結合則は、w1 <> (w2 <> w3)と(w1 <> w2) <> w3)が等しいから、すなわちMonoidにおける<>の結合則が成り立つからこそ成立するのです。これがまさしく「MonoidとWriterの切っても切り離せない関係」なのです！

Link to
here関係を壊してみる

それではいよいよ、「MonoidとWriterの切っても切り離せない関係」を利用して、Monad則を破ってみましょう💣

Link to
here<>とMonoidの結合則

前述のとおり、Writerにおける>>=が結合則を満たすのは、WriterがラップしているMonoidな値の<>が結合則を満たしてこそ、なのでした。これは言い換えれば、その、ラップしているMonoidな値の<>が結合則を破れば、自然にWriterの>>=も結合則を破るはずです。この方法は、結合則を満たさない>>=っぽい処理をゼロから探すより遥かに簡単です。>>=のようなm a -> (a -> m b) -> m bというややこしい型の関数よりも、<>のようなa -> a -> aという型の関数の方がずっと身近ですしね！

Monoidの<>のようなa -> a -> aという型の関数で、結合則を満たさない処理 — といえば、引き算-や割り算/を思い浮かべる方が多いのではないでしょうか。と、いうわけでMonoidの例で紹介したSumやProductのように、数値に対する引き算を表すnewtype、Differenceを定義してみましょう:

newtype Difference a = Difference { getDifference :: a }

それから、Differenceを（実際には間違いですが）Monoidのインスタンスにします。最近のGHCでは、Monoidのインスタンスを定義する前にSemigroupのインスタンスにする必要があるのでご注意ください。説明しやすさのために敢えてこれまで触れてきませんでしたが、これまで何度も使った<>は実際のところMonoidの関数ではなくSemigroupの関数なんですね。Monoidは「<>で（結合則を備えた）二項演算ができるだけでなく、memptyという単位元もある」という性質の型クラスなので、「単に『<>で（結合則を備えた）二項演算ができる』だけの型クラスも欲しい！」というニーズから、Monoidの<>はSemigroupの関数となり、MonoidはSemigroupのサブクラスという関係に変わったのでした。

何はともあれ、DifferenceをSemigroupのインスタンスにしましょう:

instance Num a => Semigroup (Difference a) where
  Difference a <> Difference b = Difference (a - b)

はい、単に両辺を-で引き算するだけですね。

今度こそDifferenceをMonoidのインスタンスにします。本記事ではmemptyを直接使うことはないので何でもいいはずですが、とりあえずSumと同様に0ということにしておきます:

instance Num a => Monoid (Difference a) where
  mempty = Difference 0

😈これで<>が結合則を満たさないおかしなMonoidのインスタンス、Differenceができました！早速試して結合則を破っていることを確認してみましょう:

-- こちらは 1 - (2 - 3) と同じ
> getDifference $ Difference 1 <> (Difference 2 <> Difference 3)
2

-- こちらは (1 - 2) - 3 と同じなので...
> getDifference $ (Difference 1 <> Difference 2) <> Difference 3
-4 -- <- 当然 1 - (2 - 3) とは異なる結果に！

バッチリ破れてますね！このように<>における結合則は、引き算などおなじみの演算で、簡単に破ることができます💪

Link to
here>>=とMonadの結合則

<>における結合則を破ることができたと言うことは、Writerの>>=による結合則も、もはや破れたも同然です。先ほど定義したDifference型を使えば、>>=は途端に結合則を満たさなくなるでしょう。

例を示す前に、Writerを使う際しばしば用いられる、ユーティリティー関数を定義しておきます。実践でWriterを使いたくなったときにも大変便利なので、是非覚えておいてください:

tell :: Monoid w => w -> Writer w ()
tell w = Writer ((), w)

このtell関数は、受け取ったMonoidな値をそのまま「ログとして書き込む」関数です。結果として返す値はただのユニット()なので、気にする必要がありません。tellのみを使ってWriterを組み立てれば、「ログとして書き込む」値のみに集中することができます。これから紹介する例でもやはり関心があるのは「ログとして書き込む」値だけなので、ここでtellを定義しました。

それではtellを使って、Writerの>>=における結合則も破ってみましょう:

-- こちらは Difference 1 <> (Difference 2 <> Difference 3) と同じ
> getDifference . snd . runWriter $ tell (Difference 1) >>= (\_ -> tell (Difference 2) >>= (\_ -> tell (Difference 3)))
2

-- こちらは (Difference 1 <> Difference 2) <> Difference 3 と同じなので...
> getDifference . snd . runWriter $ (tell (Difference 1) >>= (\_ -> tell (Difference 2))) >>= (\_ -> tell (Difference 3))
-4 -- <- 当然 1 - (2 - 3) とは異なる結果に！

予想どおり一つ目のWriterと二つ目のWriterとで異なる結果となりました。1 - (2 - 3)と(1 - 2) - 3をWriterを使って遠回しに言い換えているだけなので、当然と言えば当然です。

しかしtell (Difference 1) >>= (\_ -> tell (Difference 2) >>= \_ -> tell (Difference 3))などのWriter型の式がMonadの結合則m >>= (\x -> k x >>= h) = (m >>= (\x -> k x)) >>= hにどう対応するのか、ちょっと分かりづらいですかね？（式も長いし）一つずつ注釈を加えます:

-- こちらは m >>= (\x -> k x >>= h) = (m >>= (\x -> k x)) >>= h の前半、
--   m >>= (\x -> k x >>= h) に相当する
>  tell (Difference 1) >>= (\_ -> tell (Difference 2) >>= (\_ -> tell (Difference 3)))
-- ^^^^^^^^^^^^^^^^^^^       ^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
--          m                x             k                             h
--

-- こちらは m >>= (\x -> k x >>= h) = (m >>= (\x -> k x)) >>= h の後半、
--   (m >>= (\x -> k x)) >>= h に相当する
>  (tell (Difference 1) >>= (\_ -> tell (Difference 2))) >>= (\_ -> tell (Difference 3))
--  ^^^^^^^^^^^^^^^^^^^       ^    ^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
--           m                x             k                             h

ラムダ式の引数xは実際には使われていない点に注意してください。これでもconstを使って\x -> const (tell (Difference 2)) xと書き換えれば、const (tell (Difference 2))がkに厳密に対応するので、上記の二組の式は>>=の結合則を破るペアだと言えます。

Link to
heredo記法とMonadの結合則

前の節では、Monoidの結合則を守っていない値をラップしているWriterを作ることで、>>=の結合則を破る例を簡単に作り出せることを紹介しました。ここでは本記事の最後として、>>=の結合則を破った結果、do記法がいかに直感に反する挙動となるか紹介して、>>=の結合則を守ることが私たちにどのようなメリットをもたらすのか解説します。

例として、先ほど>>=の結合則を破るのに使った1 - 2 - 3を再利用しましょう。DifferenceをラップしたWriterで1 - 2 - 3を計算させると、次のような式になります:

tell (Difference 1) >>= (\_ -> tell (Difference 2)) >>= (\_ -> tell (Difference 3))

これをdo記法に変換すると、次のようになります:

do
  tell (Difference 1)
  tell (Difference 2)
  tell (Difference 3)

do記法における各行の間に>>=が隠れたことで、すっきりしましたね！

この状態から、do記法を使って1 - (2 - 3)と(1 - 2) - 3を表すWriterの式にするには、次のように書き換えます:

-- こちらが 1 - (2 - 3) を表す
do_1minus'2minus3' =
  do
    tell (Difference 1)
    do
      tell (Difference 2)
      tell (Difference 3)

-- こちらが (1 - 2) - 3 を表す
do_'1minus2'minus3 =
  do
    do
      tell (Difference 1)
      tell (Difference 2)
    tell (Difference 3)

コメントに書いたとおり、do_1minus'2minus3'が1 - (2 - 3)、do_'1minus2'minus3が(1 - 2) - 3と同等なWriterです。Haskellはシングルクォートを変数の名前に含めることができるので、シングルクォートでカッコを表すことにしました（まさかこんなところで役に立つとはね！）。

上記の二つの式では、カッコ()で囲う代わりにもう一つのdo記法に収めることで、do記法における各行を実行する順番をいじっています。

本当にこれで1 - (2 - 3)や(1 - 2) - 3と同等な式になっているのでしょうか？試しにrunWriterして結果を確かめてみましょう:

-- こちらが 1 - (2 - 3) を表す
> getDifference . snd $ runWriter do_1minus'2minus3'
2

-- こちらが (1 - 2) - 3 を表す
> getDifference . snd $ runWriter do_'1minus2'minus3
-4

バッチリ👌想定どおり、do_1minus'2minus3'が1 - (2 - 3) = 2を計算し、do_'1minus2'minus3が(1 - 2) - 3 = -4を計算していますね！

さてこれまでで、Writer MonadはMonoidの結合則を利用することで>>=の結合則を満たしていることを示し、ラップしているMonoidな値が結合則を満たしていなければ、必然的にWriterも結合則を破ってしまうことを、>>=やdo記法を使って具体的に示しました。それでは今挙げた、do記法で結合則を破った例は、一体何を示唆しているのでしょうか？普通にHaskellでコードを書いていて、前述のような書き換え、すなわち、

do
  tell (Difference 1)
  do
    tell (Difference 2)
    tell (Difference 3)

から、

do
  do
    tell (Difference 1)
    tell (Difference 2)
  tell (Difference 3)

への書き換え（あるいはその逆）は、一見するとそんな機会ないように思えます。しかしこれが、do記法をカッコ代わりに使うという変な方法ではなく、次のように変数に代入することで切り出していた場合、いかがでしょうか？

someSingleAction = tell (Difference 1)

someSequence = do
  tell (Difference 2)
  tell (Difference 3)

someCompositeAction = do
  someSingleAction
  someSequence

上記👆のような三つのWriterの値を、下記👇の三つの値にリファクタリングする場合です。

refactoredSequence = do
  tell (Difference 1)
  tell (Difference 2)

splitOutSingleAction = tell (Difference 3)

refactoredCompositeAction = do
  refactoredSequence
  splitOutSingleAction

あるいは、たった3行しかありませんし、一つの値に統合する方がいいかも知れません:

flattenedAction = do
  tell (Difference 1)
  tell (Difference 2)
  tell (Difference 3)

これらの書き換えは、いずれもdo記法が内部で使っている>>=の結合則を前提とすれば、可能であってしかるべきです。do記法は、適当にMonadのインスタンスの値（「アクション」などとも呼ばれます）を上から下まで列挙すれば、自動で>>=を使ってつなげてくれる、というものです。なので、適当に並べたアクションがどういう形に結合されるのか気にする必要があるのでは、安心して使えません。一方、上記の3組の式は、Writer Difference、すなわち引き算を表す「偽Monoid」をラップしているが故に、>>=の結合則を満たしておりません。結果、do記法に変えたときに並べたアクションをどこで切り出すかで、結果が変わってしまいます。これでは安心して列挙できません！

Link to
hereまとめ

以上です。これまでで、Monad則のうち結合則がなぜ重要なのか、結合則を実際に破ってみることを通じて説明しました。Monadと同様に結合則を持ったMonoidは、Monad以上にインスタンスを見つけるのが簡単で、なおかつ、例えば引き算のように「二項演算だけど結合則を満たしていない」処理を見つけるのが簡単です。本記事ではMonoidのそうした性質と、Monoidの性質でもってMonad則を満たしているWriter Monadに注目することで、簡単にMonad則を破る例を提示することができました。それから、Monadの結合則を実際に破った例を使って、Monadの結合則がdo記法を自然に書けるようにするために必要であることを示しました。これらの実例から主張したいことを一般化すると、次のとおりです:

• do記法の各行の間で、値を返すついでに何かを行うのがMonadのインスタンス
• do記法の各行の間で、値を返すついでに行っている処理が結合則を満たす型が、Monad則を満たすと言える
• Monad則を守らない型をdo記法で使うと、do記法の結合を気にして書かなければならなくなる

それでは、2021年も🎁Happy Haskell Hacking with Monad🎁!