別のMonadガイド（パート1：基本）

マイク・ヴァニエ



Haskellのファンコミュニティでは、すべてのHaskellプログラマーがトレーニング中に1つ以上のモナドガイドを作成する必要があるという冗談でした。 そして私も例外ではありません。 しかし、私はこのトピックに関するガイドがたくさんあることを知っています、それらの多くは良いです-なぜ別のガイドを書くべきですか？ 2つの理由：

1. 私が見た他の多くのマニュアルよりも、モナドのいくつかの側面を説明できると思います。
2. 私はモナドを今よりもずっとよく理解し始めました、そして可能な限り共有したいと思います。

前提条件

Haskellで例を書くので、読者の皆さんは、ポリモーフィズムや型クラスなどのトピックを含めて、それを知ることが役立つでしょう。 この知識がなければ、資料を理解するのは困難です。 何十ものHaskell入門ガイドがすでに書かれています。これらは準備のできていない読者に読む価値があり、これらの記事のシリーズに戻ります。



しかし、モナドの理論を（この記事の観点から）記述しているにもかかわらず、数学の非常に抽象的な分岐であるカテゴリーの理論を知る必要はありません。 もちろん、カテゴリー理論の知識は害にはなりませんが、提示された資料を理解する必要はありません。 私は、プログラミング言語に適用されるモナドを学習する前にカテゴリー理論が必要だと言う人を信じていません-これはそうではありません。 あなたがそれを研究した場合、それは良いことですが、そこから用語を使用することの利点がわかりません。

の拒否...

次の2つの理由で、モナドの世界にあるすべてを教えようとは思いません。 1つ目は非常に長い時間であり、2つ目はすべてがわからないため、おそらく決してわかりません。 純粋な概念レベルでのモナドの理解、それらが有用である理由、それらの操作方法、および最も一般的に使用される一般的なモナドを提供したいと思います。 この一連の記事の最後にあるリンクから、モナドをより深く学ぶことができます。



毎日の仕事ですぐに使用できる大量のコードを期待しないでください。 これは「レシピブック」ではありません！ モナドを使用してプログラムを作成するとどうなるかを理解する必要があると本当に信じています。このガイドはモナドを詳細に説明するために書かれています。 それに加えて、他のマニュアル（リンクを参照）を読んで実用的な問題に対する最良のモナドの解決策を見つけることができます。私の目標は、全体像を概説し、モナドとその作業を本当に理解できるようにすることです。



最後に、私はあなたが私に言いたいことを完全に理解してほしいので、彼らがあなたに向かって叫ぶまで主な考えを繰り返して繰り返すことをあなたに通知しています。 モナドはいくつかの文章で説明できないので、これは退屈ではないことを願っています。 自分でコーヒーを飲み、椅子が快適であることを確認してください-理解には時間がかかります。

動機：モナドについて考える必要があるのはなぜですか？

私の知る限り、最初のモナドはHaskellで使用され、Eugenio MoggiとPhilip Wadler（私は比較できない2つの巨人）の仕事に基づいています。 それ以来、それらは他の言語、特に機能的な言語で登場しました。 しかし、なぜ読者（おそらく関数型プログラミングの薬を試したことのないプログラマー）がモナドを心配する必要があるのでしょうか？



関数型プログラミングの主な考え方は、 純粋な関数をできるだけ広く使用することです。 純粋な関数はブラックボックスです。 彼女がしていることは、1つ以上の引数を取り、何かを計算し、結果を返すことだけです。 彼女は副作用がありません 。 ファイルとソケットへの読み取り/書き込み、コンソールへの出力、グローバル変数への変更、例外処理などはありません。 ここでの利点は、純粋な関数の動作が厳密に定義されていることです。 常に同じ引数に同じ値を返します。 純粋な関数は、より予測可能で、テストが簡単で、エラーが発生しにくいものです。 （{1}）比較のために、unclean関数（副作用があります）は、いくつかの同一の呼び出しに対して必ずしも同じ結果を計算しません。 たとえば、関連するグローバル変数の値が変更された場合、または読み取られたファイルの内容が異なる場合、回答が異なる場合があります。 不純な関数はテストが難しく、多くのエラーが発生しやすく、関数が失敗する多くの状況があります。 これらの理由から、関数型プログラミング言語では、可能な限り純粋な関数を作成することをお勧めします。



ただし、純粋な関数のプログラムは制限が多すぎます。 副作用を使用してプログラムを簡単に作成できる場合がありますが、純粋な関数でのみ（苦痛を伴う）作成できます。 また、他のいくつかのケースでは、副作用なしで行うことは不可能です。 たとえば、あるフォルダーから別のフォルダーにファイルをコピーするプログラムは、ファイルシステムとやり取りして変更します。 純粋な関数がファイルの読み取りと書き込みを許可されていない場合（そしてこれらは副作用です）、この問題を解決することはできません。 したがって、関数型言語であっても副作用に対処する方法が必要です。



関数型言語には、純粋と不浄の2つのタイプがあります。 不純なFS（Scheme、OCaml）はこの問題を気にしません：副作用のある関数を書くことができますが、ダーティFSのプログラマーは通常、特別な必要なしにこれを避けます。 純粋なFY（Haskellなど）はよりハードコアです。通常、副作用を伴う関数の直接的な書き込みを禁止します（「直接」と書いた理由がすぐにわかります）。 したがって、ご想像のとおり、純粋なプログラミング言語の副作用のトピックは、長い間研究の主な分野の1つでした。



モナドはこの問題を解決する鍵であることが判明しました。 （より正確には、キーの1つ。他のアプローチは他のFYで発明されています。オプションとして「Cleanの一意性タイプ」。）モナドを使用すると、言語の純度に違反することなく副作用のある計算を使用できます。 モナドと型システムを使用すると、副作用のある計算を他の計算から分離することができ、相互に干渉しません。 副作用なしにコードのすべての利点が得られ、これにより型システムが保証されます。 同時に、必要に応じて副作用を実行できます。 そして、これは非常に強力な概念です。



そして、これで十分ではないかのように、モナドには副作用を抑えるだけでなく、他にも多くの用途があることがわかりました。 モナドは非常に用途の広いツールであり、これを使用すると、透過的な動作でさまざまなタイプの計算を整理できます。 一部のプログラムは大幅に簡素化されています。 多くの場合、モナドコードは、非モナドコードよりも短く、理解しやすいです。 この現象の例を分析します。 一般に、モナドは関数型言語の副作用以外でも有用です。



モナドは、プログラミング言語の理論における素晴らしいアイデアの1つであり、探索する価値があります。

定義：モナドとは何ですか？

モナドは、関数、関数の適用、および関数の構成に対する一般化であり、標準の関数と比較して計算の概念が抽象化されています。

その過程で、私はあなたにモナド自体とそれらがどのように機能するかだけでなく、なぜ彼らが以前に会ったことのないプログラマを落胆させるのかを説明したいと思っています。 （ヒント：これは、プログラマーが十分に賢くないか、カテゴリー理論を知らないためではありません。）

コンピューティングの概念

さて、「コンピューティングの概念」という表現から定義の分析を始めましょう。



最も単純で最も予測可能な計算は、通常の（純粋な）関数（つまり、関数の数学的な定義）です。 簡単にするために、1つの入力引数を1つの出力にマップする関数を考えます。 （ カリー化手順を使用して、複数の引数を持つ関数を1つの引数を持つ関数に減らすことができます。これについては後で詳しく説明する必要があります。 ： 常に同じ結果を同じ入力パラメーターに返す必要があります。 Haskellのような強く型付けされた言語では、関数には型定義があります。つまり、型aとbの場合、関数は型aの値を型bの値にマップします。 Haskellでは次のように表示されます。

f :: a- > b

ここで、二重コロン「::」は「次のタイプを持つ」ことを意味します。 したがって、関数fの機能タイプはa-> bです。これは、関数がタイプaの値を取り、タイプbの値を返すことを意味します。 実際には、aとbは通常、具体的な型（Int、Float、String ...）を持っていますが、Haskellでは、関数は引数の型に関係なく機能します。 （{3}）



したがって、純粋な関数は最も単純な「計算の概念」です。 そして、どのような計算がまだ存在しますか？ それらの多くがあり、あなたは多くに精通しています。 これには次の計算が含まれます。

• 入力/出力（ファイル、コンソール）を操作します。
• 例外を引き起こす;
• 一般的な状態（グローバル、ローカル）を変更します。
• 時々それらは失敗するかもしれません。
• 一度に多くの結果を返します。
• その他多数。

通知：ファイルまたはコンソールを操作するときの入力/出力を意味するために、「入力/出力」または略してI / Oというフレーズを使用しました。 I / O操作は副作用をもたらすことが知られています。 I / O操作を関数の入出力値と混同しないでください。



これらの計算を通常のプログラミング言語（CまたはJava）でどのように使用するかについてもう1つ考えてください。 入出力操作の計算？ 問題ありません！ CおよびJavaの任意の機能。 例外の呼び出しはどうですか？ Cでは、例外の言語サポートがないため、これは少し複雑ですが、障害が発生した場合にエラーコードを返すことができます。 （または、経験豊富な低レベルのプログラマーであれば、一般にsetjmp / longjmpでエラーを処理できます。）Javaでは、どこかで処理されることを期待して、単に例外をスローします。 例外に加えて、まだ条件があります-それをどのように扱うか？ はい、一般的には簡単です。CおよびJavaでは、グローバルおよびローカルの変数をさまざまな方法で読み書きできます。 そして、失敗するかもしれない計算？ それらは例外の退化したケースと見なすことができるので、やはり問題はありません。 最後に、多くの値を返す計算についてはどうでしょうか？ ここで、多数の値とは、多数の結果を含む1つのオブジェクトではなく、C構造体やJavaオブジェクトではなく、複数の別個の結果を「並列に」返すことができる関数のことです。 CまたはJavaでこれを行う方法は完全には明らかではありません。 （{4}）



次の点に注意することが重要です。すべての場合において、従来のコンピューティングの概念についてはもう話していません。入力パラメータから出力への通常のマッピングに加えて、「どこか」、「何か」が発生するからです。 さらに、コンピューティングの独自のコンセプトを持つ他のタイプの「他の何か」があります。 通常、プログラムを作成するときにこれについて心配することはありません。 「関数」は数学的な意味での関数とまったく同じではないことを理解しています。 結局のところ、入力/出力、例外、グローバル変数の変更などの副作用があります。 ほとんどのプログラマーにとって、これは重要ではありません。グローバル変数の変更による不快なエラーをキャッチするまで、プログラムが例外で突然停止するまで、またはこれらすべての非機能的性質によって引き起こされる他の問題が発生するまで「機能」。 したがって、できるだけ純粋な関数を使用したいと思います。 したいと思いますが、これが不可能な場合があり、「何か他のこと」、つまり副作用を伴う計算を行う必要があります。



結論は1つだけです。2つの椅子に座りたいです。 （{5}）可能な限り純粋な関数でコードを記述し、これのすべての利点を得ます：デバッグ、検証を容易にします...しかし、この「何か」を制御された方法で処理したいと思います。特定の状況では、出口かそこらがより良いです。 そして、これがモナドが私たちに許していることです。



しかし！ 最後の段落のキーフレーズは「制御された方法で」です。 このメカニズムがCまたはJavaの場合と同じように機能する場合、もちろん、これらの非関数型計算の多くを使用して問題を解決しますが、関数型プログラミングの利点も失います。 結局のところ、関数がクリーンであることを保証するものではなく、ここでは型チェックも役に立たないでしょう。 コンピューティングの他の概念と連携するためのある種の体系的なアプローチが必要です。これは、コードの純度に違反しません。



次に、（純粋な）関数、（純粋な）関数の適用、および（純粋な）関数の合成の有用な概念を検討し、同じ目標を実装するモナド法と比較します。

機能、機能の適用（アプリケーション）および機能の構成

以前、Haskellは関数の入力および出力パラメーターのタイプを決定するために特別なエントリを使用することを述べました。 入力タイプがaで出力タイプがbの関数fの場合、エントリは次のようになります。

f :: a- > b

したがって、fのタイプはa-> bです（「from a to b」と読みます）。 入力値を2倍にする関数のより具体的な例を次に示します。

f :: Int- > Int

f x = 2 * x

fは整数型を取り、整数を2倍して別の整数を返すため、Int-> Int型です。



関数の実行は簡単です。そのため、引数に適用します（引数が1つあると仮定します）。 これは通常、関数に引数を割り当てることで行われます。

f 2- 関数「f 2」値= 4。

Haskellでは、他の多くのプログラミング言語のように、引数が括弧で囲まれていないことに注意してください。

カレー



実際には、単一の引数関数では多くのタスクに十分ではありません。 2つの引数の関数をどのように定義しますか？ たとえば、2つの整数引数を取り、それらの2乗の合計を返す関数qを作成するにはどうすればよいですか？ 関数の本体は簡単に記述できます。

q x y = x * x + y * y

関数タイプの署名が省略されました。 おそらく、あなたはある種のオプションを期待しています：

q :: Int Int- > Int

またはおそらくこれ：

q : :（Int 、 Int ） -> Int

実際、この関数のタイプは次のようになります。

q :: Int- > Int- > Int

矢印「->」は右結合なので、エントリは次のことを意味します。

q :: Int -> （ Int- > Int ）

今では面白そうです。 Haskellでは1つの引数の関数（この場合はx）になる2つの引数の関数は、1つの引数の別の関数を返し、次の引数（y）を受け取って結果を返します。 Haskellでは、他のFYと同様に、関数は他の関数の値として返される可能性があるため、これは正しいです。 （言い換えると、関数はUFでは単に異なるデータ型です。）このように、複数引数関数を単一引数として表現する方法はカリー化と呼ばれます（Haskell Curryの名前はHaskellとも呼ばれます。手順など、必要に応じて）。 明確にするために、整数を返す4つの整数引数w、x、y、およびzを持つ関数rを使用します。

r :: Int- > Int- > Int- > Int- > Int

r w x y z = ... は、w、x、y、およびzの関数です

右矢印は次を提供します。

r :: Int -> （ Int -> （ Int -> （ Int- > Int ） ） ））

r w x y z = ... は、w、x、y、およびzの関数です

ここで、rは1つの整数引数wの関数であり、タイプ（Int->（Int->（Int-> Int）））の関数を返します。 その関数は、整数（この例ではx）に適用されると、タイプ（Int->（Int-> Int））の関数を返します。 次の関数は、整数（例ではy）に適用され、型（Int-> Int）の関数を返します。これは、別の整数（z）に適用されると、整数-呼び出しの結果（rwxyz）を返します。 、実際には、（（（（rw）x）y）z）。 そして、これはカレーと呼ばれます。 Haskellは自動的に関数をカリー化します。 カリー化は非常に便利です。引数を一度に1つずつ渡すことができ、一度にすべてを渡すことはできません。また、これらの部分的に適用された関数は、単独で非常に役立つことがよくあります。 また、カレーは概念的にはこれからは1つの引数の関数について考えるだけで十分であり、それ以上のことはありません。 いいね！

Haskellには特別な$演算子があります。これは関数演算子です。 次のタイプがあります。

（ $ ） ::（a- > b ） -> a- > b

（Haskellでは、記号中置演算子は括弧で囲まれた同じ名前の関数と同等です。したがって、表記f $ 2は表記（$）f 2.と同等です。演算子は通常、便宜上関数形式で定義されます。言語の入門資料を参照してください。詳細を知りたい場合は、ここで演算子を使用することがよくあります。）



表記法は、任意のタイプaおよびbに対して、この演算子がaからbまでの関数を最初の引数として受け取り、それをタイプaの2番目の引数に適用し、タイプbの結果を返すことを意味します。 関数型言語では、関数を引数として他の関数に渡すことは一般的であると考えられているため、問題はありません。 次の結論を出すことができます。

f 2- >は4を返します

f $ 2- >も4を返します

（ $ ） f 2- >ここでは4が返されます

同じことを書くための3つの異なる方法があります。



ここでは、関数を実行するために引数を関数に置き換える方が技術的に簡単なので、$演算子は実際には必要ありません。 しかし、興味を引くために、「逆アプリケーション」演算子を指定し、それを>>呼び出し、同じ引数を逆の順序で受け取ることができます。

（ > $> ） :: a -> （ a- > b ） -> b

x > $> f = f x- = f $ xと同じ

これを「演算子は値xを取り、それに関数を適用して結果を返す」と読むことができます。 UNIXシステムに精通している場合は、Unixパイプライン（パイプ、|）が同様に機能することに気付いているかもしれません。 あなたは彼にいくつかのデータを与え、彼は彼に続くプログラムを適用します。 便利な場合は関数演算子を使用できますが、通常はまったく使用せず、関数の引数を単純に置き換えます。



関数の使用について説明したので、次の重要なトピックは関数の構成です。 そして、これは本当に重要なトピックです。 2つの関数fとg、および次の形式のx値があるとします。

x :: a

f :: a- > b

g :: b- > c

ここで、a、b、cはいくつかのタイプです。 これらのx、f、およびgを使用して以下を実行できます。xを取得し、それに関数fを適用し（タイプbの値を取得）、関数gを結果に適用します。 タイプxの値はタイプbの値に変換され、その後、発生したことはタイプcの値に変換されます。 Haskellで書くことは言うより簡単です：

g （ f x ）

しかし、これは、型fとgに互換性がある場合、つまり、関数fの結果が関数gの引数と同じ型である場合にのみ機能します（この場合、型bです）。 ある関数の別の関数への適用は別の方法で解釈できます。それぞれ、タイプの2つの関数fおよびg、a-> bおよびb-> cを取り、タイプa-> cの3番目の関数を作成します。 引数xに適用すると、タイプcの結果が得られます。 2つの関数を3番目の関数に結合するこの考え方は、関数の合成と呼ばれます。 Haskellは単純な関数合成演算子も定義しています：

（ 。 ） ::（ b- > c ） -> （ a- > b ） -> （ a- > c ）

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

ここでは、表記「\ x-> ...」を使用します。これは、1つの引数xを持つラムダ式（または、同じこと、匿名関数）を示します。 これは、合成演算子が引数として2つの関数を取り、3番目の関数を返す方法です。 繰り返しになりますが、FYでは、引数としての関数と戻り値としての関数は、すべてのステップで発生する非常に一般的な現象です。



関数が間違った順序で続くと、合成演算子で迷惑が発生することがあります。 しかし、「逆構成演算子」を書くことができます。>：

（ >。> ） ::（a- > b ） -> （ b- > c ） -> （ a- > c ）

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

function> $>の逆演算子でも表現できます。

（ >。> ） ::（a- > b ） -> （ b- > c ） -> （ a- > c ）

f >。> g = \ x- > x > $> f > $> g

またはさらにシンプル-合成演算子を使用：

（ >。> ） ::（a- > b ） -> （ b- > c ） -> （ a- > c ）

f >。> g = g f

the>。>演算子のシグネチャは少し明確で、関数が構成されたときに何が起こるかを示しています。 関数fとgを取り、新しい関数を計算します。 彼女をhと呼びましょう。 値にhを適用すると、最初に値にfを適用し、次に結果にgを適用すると同じ結果になります。 これが関数合成とは何か-いくつかの関数から他の関数​​を作成する方法です。



例を分析しましょう：

f :: Int- > Int

f x = 2 * x



g :: Int- > Int

g y = 3 + y



h :: Int- > Int

h = g f- または同じ：f>。> g

ここで関数hは何をしていますか？ 整数を取得し、2で乗算し、3を加算します。つまり、次のオプションと同等です。

h :: Int- > Int

h x = 3 + 2 * x

関数の構成はそれほど大したことではないように思えるかもしれません-実際には、これは関数型プログラミングの主要なポイントの1つです。 合成により、既存の関数をより複雑な関数にリンクし、引数を使用した手作業を省略できます。 そして、「hは、関数y = f（x）を計算することによって最初に取得され、次に関数h = g（y）を計算することによって取得される関数」と言う代わりに、「hは最初に適用される関数ですf、g。」 中間エンティティがなければ、コードはより簡潔で高レベルになります。 10個の関数を次々に呼び出さなければならないと想像してください。 中間結果を作成すると、次のような結果になります。

f11 x =

させる

x2 = f1 x

x3 = f2 x2

x4 = f3 x3

x5 = f4 x4

x6 = f5 x5

x7 = f6 x6

x8 = f7 x7

x9 = f8 x8

x10 = f9 x9

x11 = f10 x10

で

x11

とても疲れますよね？ 次に、関数の構成を見てください。

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

または、同じこと：

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

短いだけでなく、より直感的です。 （「f1、f2、f3などを使用すると、f11が得られます」）。 ところで、合成を使用して引数なしで関数を記述するこの方法は、「無意味なスタイル」と呼ばれます。 皮肉なことに、「ドット」演算子（。）は「無意味なスタイル」で非常によく使用されます-通常のコードよりも強力です。 関数の引数を省略しているため、「無意味」ではなく「引数のないスタイル」と言う方が正しいでしょう。



反射のテーマ、素材の強化：

• 関数、関数のアプリケーション（アプリケーション）、関数型プログラミングの基本概念としての関数の合成。
• 任意の順序で引数を取る関数を作成するための、関数を適用するための演算子。

モナド関数、モナド値

これまでのところ、私が語ったことはすべて、非常に簡単でした。 次に、より複雑なものに進みます。



前に、モナドの本質は、純粋な関数の計算とは異なる計算の形で、関数の構成と適用の概念を一般化することであると述べ、「不純物」のいくつかの例を検討しました。 モナドの定義から、単純に入力値を計算することに加えて、何か他のことを行う「高度な関数」が得られることがわかります。 スケマティック擬似Haskell言語では、次のようにこれらの「高度な関数」を書くことができます。

f :: a- [その他]-> b

ここで、fは拡張関数、aは引数のタイプ、bは結果のタイプ、「何か他のもの」はコンピューティングのさまざまな概念に固有のものです。 Haskellでは、「計算の概念」という言葉は、特にモナドにあります。 （私たちはまだそれが何であるかを知らないので、今のところ、私の言葉を使ってください。）「高度な関数」は「単項関数」として理解できます。 これは標準的な用語ではなく、通常の純粋な関数と区別するために呼び出します。



もちろん、 "-[something other]->"という表記はHaskellでは無効です。 少し後で、それが実際にどのように見えるかを確認し、それが明確になることを願っています。 上記の計算の概念を比較するために、これらの表記法に固執します。 Haskellのモナドに対応する計算名の各概念を示します。

1. コンソールまたはファイルへの入出力操作を実行する関数。 I / O操作はIOモナドに対応するため、次のように記述します。
   
   

   f :: a- [IO]-> b

   （ところで、後で説明するように、IOモナドには他の用途があります。）
2. 例外をスローできる関数。 いくつかのタイプのモナドがそれらに対応します：
   
   

   f :: a- [エラー]-> b

3. グローバルまたはローカル状態と相互作用する関数。 これは、Stateモナドです：
   
   

   f :: a- [状態s]-> b

4. 失敗する可能性のある機能。 多分モナドについて話している：
   
   

   f :: a- [多分]-> b

5. 同時に複数の値を返す関数。 モナドリスト（リスト）：
   
   

   f :: a- [リスト]-> b

Haskellのリストは構文糖のために少し異なって見えるため、「リスト」という単語を小さな文字で書きました。したがって、別個の単語は必要ありません。



後でこれらのすべてのモナドの例を示します。次に、入出力操作を実行する関数、つまりIOモナドに関連する関数を検討します。 疑似レコードがあります：

f :: a- [IO]-> b

fは、モナドIOで機能するaからbまでの関数であると言えます。 上で述べたように、これは無効な構文です。 Haskellでは、入力または出力パラメーターでそれを囲むことにより、モナド関数の単進性を型でラップする必要があります。 原則として、次のようなモナド関数を作成するための2つのオプションがあります。

f :: IO a- > b

または

f :: a- > IO b

Haskellはモナド関数に2番目の形式の表記法を使用していることがわかります。

f :: a- > m b

任意のモナドm; IOの場合など。 （筋金入りの労働者にとって、各関数がf :: ca-> bという形式のcomonadの概念があることに注意してください。一部のcomonad cについては、この質問を今後の記事のために残しましょう。）



さて、エントリ「f :: a-> mb」の背後にあるものは本当に何ですか？ レコードとは、タイプaの値を取り、タイプmbの値を返す通常の（純粋な）関数fがあることを意味します（それらが何であれ）。 そのため、Haskellでは、モナド関数は、モナドの戻り値型を持つ純粋な関数です。 つまり、純粋な関数は通常の値を取り、モナドを返します。 それはどういう意味ですか？



エントリ「mb」には説明が必要です。 b-これは何らかのタイプです。 mは何らかのモナドを表します。 しかし、Haskellのmの正確な意味は何ですか？ Haskellでは、「m」は型コンストラクターである必要があります。これは型に関する特別な関数です。引数を取り、型を返します。 これは見た目ほど奇妙ではありません。 Haskellのタイプが[Int]のように見える「整数のリスト」の概念を考えてみましょう。 「何かのリスト」部分は、特定のタイプ（Int）を受け取り、別のタイプ（整数のリスト、[Int]）を返すタイプコンストラクターとして理解できます。 Haskellの角括弧はリストを示すために固定されていますが、独自の型コンストラクタを定義できます。 また、あらゆる多相型には独自のコンストラクタがあります。 最も単純な多相型の1つは、多分、

データ 多分 a = Nothing | ただ

ここでは、多分は型（aと呼ばれる）を取り、出力値として新しい型を生成する型コンストラクターであると述べています。 タイプIntをaに置き換えると、新しいタイプMaybe Intが得られます。これは次のように記述されます。

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

したがって、多分、1つの型を別の型にマップする型関数です。



モナドは、Haskellにあるように、古い型をラップして新しい型を生成する型コンストラクタです。そして実際、IOモナドは、IO Bool、IO Int、IO Float、IO Char、IO Stringなどの型が生成される型コンストラクタです。これらはすべてHaskellで有効なタイプです。同様に、Maybeモナドの場合、有効なタイプMaybe Bool、Maybe Intなどが構築されます。モナドコンストラクターによって作成された型を「モナド型」と呼びます。IO Bool、Maybe Intなど-これらはすべてモナド型です。

注意事項：Haskellのすべてのモナドは型コンストラクターでなければなりませんが、すべての型コンストラクターがモナドではありません。後で見るように、モナドは型コンストラクタでなければなりません。モナドに対して特別な操作を定義する必要があり、それらはいくつかの「モナドの法則」を満たさなければなりません。

私たちは非常に重要な質問に来ます：モナド型を表す値は何をしますか？私はそれらを「単項の意味」と呼びます。たとえば、Maybe Int値とは何ですか？IO Float-それは何ですか？



モナドを「理解するのが難しい」ように見えるものに出会ったところです。



要約しましょう。

1. 「純粋な関数」というおなじみの概念があります。つまり、何もせずに、あるタイプの入力値を別のタイプの出力値（または同じもの）に変換する関数です。
2. , - . «- » / , , , , . , « ». , , .
3. Haskell — , - . «».

ここで、「モナドの意味」の本質について私たちは何を言うことができるかという質問を再定式化しますか？



答えは：彼らは本当に直感的ではありません！ 。直感的には、モナド関数（一部のデータを他のデータに変換する以外のことを行うもの）の概念。 「単項の意味」の概念はまったく直感的ではありません。 Haskellでは、モナド関数の出力値を示すのが慣習であるだけです。これらのモナドの意味が実際に何であるかを通してモナドを理解しようとすると、無駄に時間を費やします。気にしないでください！それだけの価値はありません！



しかし、Haskellの文献には、モナドの意味を説明する2つの一般的な方法があります（多くのマニュアルが罪を犯す愚かな方法がたくさんあります）。



1. ma型のモナド値（一部のモナドmの場合）は、何かを実行してa型の値を返す特別な種類の「アクション」です。アクションの本質は特定のモナドに依存します。



2.タイプmaのモナド値（一部のモナドm）は、タイプaの値が格納されるコンテナです。



モナドの意味のリフレクションを通してモナドを研究することは間違ったアプローチであり、モナド関数のリフレクションを通して正しいです。定義にはある程度の意味があることを納得させたいと思います（1）。しかし、後で見るように、定義（2）はモナドを研究する間違った方法です。ほとんどのモナドはコンテナではありませんが、コンテナのように動作するものもあります。



私たちの機能を見てみましょう、それが出発点として、かなり明確であることを願っています：

F :: - >メガバイト

次に、関数fx（xはa型）はmb型になります。

x :: a

fx :: mb

fxは現在、「単項の意味」であり、完全に直感的ではありません。別の機能を検討してください：

g :: a -> （ ） -> a

gx （ ） = x

gは文字通り次のことを行います。任意の型aの値を取り、関数にラップするため、空の値をgに渡すことで結果を取得できます。（{6}）空の型と値は、括弧（）で同じようにHaskellで記述されます。これは、私たちにとって重要ではない型/値です。（「空」という言葉は、この値が私たちにとって関心を表していないことを意味します。）次に例を示します。

h = g 10

h （ ） -数値10が計算されます

さて、g（fx）関数を発明することで何が得られますか？タイプを見てみましょう。

fx :: mb- 上記を参照

g :: a -> （ ） -> a

g （ fx ） :: （ ） -> mb

したがって、関数g（fx）はタイプ（）-> m bです。つまり、空の値を取り、単項の値を返します。一方、これを見ると、これは空の値（何があっても）を型bの値に変換すると同時に、「何か他のこと」を実行する単項関数です。（「他の何か」は、どのモナドが使用されるかに依存します。）それはある程度理にかなっています。



これが私の考えです。 （mb型の）モナド値が何であるかを理解する必要があると思う場合、（）-> mb型のモナド関数、つまり、空の値をb型の値にマッピングするだけでなく、何かを実行する関数として考えるのが最善です他の何か。タイプmbの値がタイプ（）-> mbの関数であるかのように、異なる方法でのみ記述されます。つまり、モナドの意味は「秘密の機能」です。したがって、それらは「アクション」と呼ばれることが多く、機能に関連付けられていますが、完全な機能ではありません。 （「アクションを実行する」と言うこともありますが、これは関数を使用するのに似ています。）



いくつかの例は今のところ問題ありません。 Haskellで2つのI / O関数を使用します。

getlineの :: IO 文字列

putStrLn :: 文字列 - > IO （ ）

getLineは、コンソールからテキストの行を読み取り、何らかの方法でそれを返す「関数」（実際には「単項アクション」としても知られる単項値）です。putStrLnは、文字列を引数として取り、コンソールに出力し、行終了記号を追加する関数（今回は実際に関数）です。



これらの関数のタイプが従来の言語でどのように見えるかについて少し考えてみてください。次のようなものを想定できます。

getLine :: （ ） -> String -Haskellにはない

putStrLn :: String -> （ ） -Haskellにはない

getLine関数は簡単に理解できます。空の値（何があっても）を受け取り、何らかの方法でコンソールと対話し、そこから文字列をフェッチして、この文字列を返します。putStrLnは引数として文字列を取り、何らかの方法でコンソールと対話し（文字列を出力）、空の値を返します（何があっても）。空の値の意味は、関数が実際に関数であること、つまり入力値と出力値を持っていることを保証するために減らされていることに注意してください。（）を取り除くと、次のようになります。

getLine :: String

putStrLn :: String

これは事実ではありません。getLineは単なる文字列ではありません。文字列を返すには引数を付けて呼び出す必要があります。同様に、putStrLnは単なる文字列ではありません。彼女は文字列引数を必要としますが、それは何に関係なく戻ります いずれの場合も、入力値または出力値を適切な場所に置き換えるためだけに空の値が必要です。



しかし、Haskellに戻ります。私たちが持っています：

getlineの :: IO 文字列

putStrLn :: 文字列 - > IO （ ）

putStrLn関数のタイプは簡単に理解できます。これは、モナドIO内の単なるモナド関数です。文字列を印刷に取り、空の値（何があっても）を返し、「他の何か」を行うことが理解されています。 （この場合、コンソールと対話して行を出力することが、IOモナドでできることです。）



getLine関数のタイプは理解するのがより困難です。 getLineは単項値です。しかし、（）-> IO String型の単項関数と考える方が簡単です。それは理にかなっています：これは、どの値に関係なく、コンソールとの対話中に文字列を返す関数です（つまり、コンソールに入力するのを待ちます）。



ただし、Haskellには、この関数には（）-> IO Stringなどのタイプはありませんが、IO Stringタイプがあります。モナド値は、タイプ（）の暗黙的な入力引数を持つモナド関数であることがわかります。多くのHaskellの専門家は、それを「アクション」として認識しています。getLineがI / O操作を実行する「アクション」であると言うとき、それらは単項関数を意味します。将来の記事で状態モナドについて議論するとき、値のように見えるものが関数としてどのように機能するかについて、あなたはもっと気付くでしょう。



次の記事では、2つの基本的なモナド演算について説明します。それらはどこから来たのか、そしてその背後にあるものです。

内容

パート1：基本

パート2：関数>> =およびreturn

パート3：モナド則

パート4：モナドとリストモナド

注釈

{1}オリジナルでは、「エラーが発生しやすい」-「バグが発生しやすい」が、これは多少異なって翻訳される可能性があります。 ;）

{3}これは「パラメトリック多型」と呼ばれます。

{4}著者は、関数の結果として同じタイプのオブジェクトのセットを意味します。問題は、彼の意見では、関数は異なる数のオブジェクトを返すことができるということです：0からnまで、つまり、オブジェクトの数は事前にわかりません。CとJavaの両方で、この問題は動的データ型によって効果的に解決されます。

{5}オリジナルでは-永続的な表現：「私たちのケーキを持って食べてください。」

{6}オリジナル-「単一」の値、単位。

翻訳者から

私はこれまで著者の他の資料へのリンクを見つけていません。持ってきます

1. HaskellチュートリアルHaskellのチュートリアルと記事の最も包括的なコレクションは英語です。

2. xgu.ruのHaskell-多くの便利なリンク。

3. ロシアのラムダ惑星 -ロシア語のAFに関する優れた情報源。

4. Haskell Planet -HaskellおよびFPに関するさらに優れた英語の情報源。