Haskell Questチュートリアル-キャニオンビュー

キャニオンビュー
グレートキャニオンの西の壁にあります。 ここから、渓谷とフリージ川の上流の素晴らしい景色が見えます。 キャニオンを横切ると、ホワイトクリフの壁が東のフラットヘッドマウンテンの強大な城壁に合流します。 北のキャニオンの上流に続いて、虹のあるアラゲイン滝が見られることがあります。 強大なフリギド川は、大きな暗い洞窟から流れ出ています。 西と南には広大な森があり、何マイルも伸びています。 北西に続く小道。 ここから渓谷に降りることができます。

内容：
あいさつ
パート1-先
パート2-フォレスト
パート3-ポリアナ
パート4-キャニオンのビュー
パート5-ホール

パート4
ここでは、リファクタリングを行い、いくつかのアクションを実装し、パターンマッチングと再帰について学び、クエストから実際のプログラムを作成します。


そして、現在の場所を入力しましょうか？ そして言う-それは時間です。 最も重要なことがすべて実行されるrun関数が既にあります。つまり、現在の場所がその中にある必要があります。 run関数で、場所の説明が最初に表示され、次に他のすべてが表示されるとします。 したがって、run関数は現在の場所を認識しています。 この場所をパラメーターとして彼女に渡します。

curLoc = doを実行します
putStrLn （ describe curLocを記述）
putStr 「コマンドを入力：」
x < -getLine
putStrLn （ evalAction （ convertStringToAction x ） ）

いいね 私達は試みます：

*メイン>実行ホーム
ホーム
あなたは木製のテーブルの真ん中の部屋に立っています。
コマンドを入力：見て
アクション：見て！
*メイン>

しかし、なんという短いプログラムでしょう！ 期待どおりに動作しますが、すぐに終了します。 まあ、これはゲームではありません。 ゲームでは、通常、イベントハンドラーは、[終了]ボタンによって明確に中断されるまでループでスピンします。 このようなものが欲しいのです。「Quit」と言うまでゲームは動作するはずです。 どうやってやるの？ まず、ユーザーからのコマンドの継続的な処理を整理する必要があります。 最も簡単な方法は、自分自身からrunを呼び出すことです。 パラメータがあります-現在の場所-古い現在の場所を転送する際に、後で何かを考えます。

curLoc = doを実行します
putStrLn （ describe curLocを記述）
putStr 「コマンドを入力：」
x < -getLine
putStrLn （ evalAction （ convertStringToAction x ） ）
putStrLn 「ターン終了。 \ n " -新しい移動-新しい行から。
curLocを実行します

-テスト：

*メイン>実行ホーム
ホーム
あなたは木製のテーブルの真ん中の部屋に立っています。
コマンドを入力：見て
アクション：見て！
ターン終了。

ホーム
あなたは木製のテーブルの真ん中の部屋に立っています。
コマンドを入力します： < Ctrl + C > Interrupted 。

このプログラムは、バレルオルガンを最初から素直に開始しました。 まだ適切なイベント処理が行われていないため、プログラムを中断する唯一の方法は<Ctrl + C>を押すことです。 また、Quitコマンドに彼女を反応させるには、少しのリファクタリングが必要です。 run関数を次のように書き直します。

curLoc = doを実行します
putStrLn （ describe curLocを記述）
putStr 「コマンドを入力：」
x < -getLine
のケース （ convertStringToAction x ）
終了-> putStrLn 「 会い ましょう...」
そうでなければ -> する
putStrLn （ evalAction （ convertStringToAction x ） ）
putStrLn 「ターン終了。 \ n "
curLocを実行します

ええ、ここで何かが汚れています！..それを把握しましょう。 実行機能の開始はおなじみです。 最初のdoキーワードは、チェーン内のアクションをリンクします。 このチェーンにはどのようなアクションが含まれていますか？ 4つのみ：（場所の説明を印刷）-（「Enterコマンド：„行」を表示）-（ユーザーから文字列を受け取り、変数xに関連付けます）-（case-construction内の式を実行します）。 実行がケースに達すると、目的の代替にジャンプして、そこで継続します。 ユーザーが「Quit」と入力し、関数（convertStringToAction x）がQuitコンストラクターを返すとします。これは、最初の選択肢が機能することを意味します。 この代替方法には、「Be See You ...」という行を印刷するだけのアクションがあります。 どこにもアクションはありません。Quitオルタナティブ内でも、case-constructionの後でもありません。したがって、run関数はそれ以上何もすることがなく、終了します。 ユーザーが「Quit」ではなく「Look」と入力しなかった場合、どうなりますか？ Quitの代替手段が機能しないことは明らかですが、 それ以外の場合は常に警戒されます-そこで実行が続行されます。 そして、何がありますか？ もう1つのキーワードがあります！ そのため、ここで新しい一連のアクションが開始され、まったく同じ方法で段階的に実行されます。 このチェーンにはどのようなアクションが含まれていますか？ 3つのみ：（処理されたコマンドを印刷する）-（「End of turn。\ N」行を印刷する）-（run関数を実行する）。

一見したところ、この関数は理解できません。これらすべてのケース、do、left、rightの矢印！ ただし、実装を注意深く監視すると、すべてが適切に配置されます。 考えているとおりにプログラムが実際に機能するかどうかを確認するだけです。

*メイン>実行ホーム
ホーム
あなたは木製のテーブルの真ん中の部屋に立っています。
コマンドを入力：見て
アクション：見て！
ターン終了。

ホーム
あなたは木製のテーブルの真ん中の部屋に立っています。
コマンドを入力：終了
あなたに会えて...
*メイン>

やった！ よくできました！ しかし、実行関数はまだ理想からはほど遠いものです。 呼び出し（convertStringToAction x）が2回含まれていることに注意してください。これは悪いことです。 幸いなことに、関数convertStringToActionは単純で、リソースを必要としません。そうしないと、オーバーランになります。 Haskellおよび他の言語では、繰り返しを避ける必要があります。 この呼び出しはcase-constructionであるため、その結果を変数に入れることができます。 実行関数を少し変更します。

curLoc = doを実行します
putStrLn （ describe curLocを記述）
putStr 「コマンドを入力：」
x < -getLine
のケース （ convertStringToAction x ）
終了-> putStrLn 「 会い ましょう...」
convertResult- > do
putStrLn （ evalAction convertResult ）
putStrLn 「ターン終了。 \ n " -新しい移動-新しい行から。
curLocを実行します

はい、そうではなく、 convertResult変数が今です。 ある値に対する以前の選択肢が機能しなかった場合、一度計算されたこの値は変数に配置されて使用されます。 そして、これは優れた実践であり、明白な理由から、 それは他の場合よりもさらに一般的です。

まあ、それは非常に難しかったので、今日はそれだけです。

インデントを忘れないでください;ここで重要です; 最初と2番目の「do」では、すべてのアクションは最初のアクションが開始された場所に正確に配置されます。 たとえば、次のように、異なる位置に配置することができます。

curLoc = doを実行します
putStrLn （ describe curLocを記述）
putStr 「コマンドを入力：」
x < -getLine
のケース （ convertStringToAction x ）
終了-> putStrLn 「 会い ましょう...」
そうでなければ -> する
putStrLn （ evalAction （ convertStringToAction x ） ）
putStrLn "ターンの終わり。 \ n " -新しい移動-新しい行から。
curLocを実行します

各ブロックには独自のインデントがあり、それらを混在させる必要はありません。

誰があなたが発散できると言った？ 続けます！ もちろん、あなたはすでにプログラムを改善する計画を立てています。 そして当然！ Lookコマンドの実際の（架空ではない）処理をいつか自分で追加しますが、Goコマンドについて考えてみましょう。 Zorkではどのように実装されていますか？

清算
...

>西に行く
森
...

「Go West」と書くと、コマンドパーサーはこの行を解析する方法が明確ではないため不満になります。

*メイン>実行ホーム
ホーム
あなたは木製のテーブルの真ん中の部屋に立っています。
コマンドを入力：Go West
***例外： プレリュード 。 読み取り ：解析なし

GoとWestのコンストラクタがあるため、「Go West」の行を2つに分けて別々に解析することもできますか？ もちろん、アイデアは正しいですし、確かに機能しますが、Go Westをさらに簡単に解析できなければ、Haskellは魔法の言語にはなりません。 遠くから行こう。 覚えているように、3番目の部分には、ADT型のコンストラクターが特別な関数であるというインセットがありました。 たとえば、HomeはLocationタイプの関数、GoはTypeアクションの関数、WestはDirectionタイプの関数です。

* Main > ： タイプ Home
ホーム::ロケーション

* Main > ： タイプ West
西::方向

* Main > ：Goと入力
Go ::アクション

関数について何を知っていますか？ そうだね。 彼らは議論があるかもしれないこと。 そして、どのような質問をする必要がありますか？ そうだね。 「コンストラクタが関数である場合、これは引数も持つことができるということですか？」ご想像のとおり、そうです！ ADTタイプを定義するとき、このコンストラクターまたはそのコンストラクターに渡す引数のタイプを指定できます。 GoコンストラクタにDirection引数を追加します。

データアクション=
見て
| 行き方
| 在庫
| 取る
| 落とす
| 調査する
| やめる
| 保存する
| 負荷
| 新しい
導出 （ Eq 、 Show 、 Read ）

この場合、Directionを取得してActionを返す関数を作成したため、コンストラクターのタイプはわずかに変更されます。 コンストラクターの文字列への変換、およびその逆の動作を確認しましょう。

*メイン> ショー （ Go West ）
西へ行く

*メイン> 「Go North」を 読む ::アクション
北へ行く

*メイン> ：t Go
移動::方向->アクション

こっち そして何よりも、私たちの側にはほとんど努力がありません。 複合コンストラクターは他のコンストラクターほど複雑ではなく、直感的にデータを設定するため、さらに優れています。 そして彼との仕事はとても簡単です！ 実行ケースを更新します。

curLoc = doを実行します
putStrLn （ describe curLocを記述）
putStr 「コマンドを入力：」
x < -getLine
のケース （ convertStringToAction x ）
終了-> putStrLn 「 会い ましょう...」
Go dir- > putStrLn （ "You going to" ++ show dir ++ "！" ）
convertResult- > do
putStrLn （ evalAction convertResult ）
putStrLn 「ターン終了。 \ n " -新しい移動-新しい行から。
curLocを実行します

-チェック：

*メイン>実行ホーム
ホーム
あなたは木製のテーブルの真ん中の部屋に立っています。
コマンドを入力：Go West
あなたは西に行く！

パーサーが行の「Go Something」を認識すると、代替の「Go dir」が機能し、同じ「Something」がdir変数に分類されます。 それでは、dir変数を使用します。 魔法！

Haskellの代数データ型はさらに優れています。 おそらく、引数付きのコンストラクターを使用して、第3部の「ダム計算機」タスクを書き換える方法を既に理解しているかもしれません。 次のようなものを取得できます。

データ IntegerArithmOperation =
プラス整数 整数
| マイナス整数 整数
| 製品整数 整数
| 整数の否定

evalOp :: IntegerArithmOperation- > 整数
evalOp op = case op
Plus x y- > x + y- 「op」パラメーターは各オプションに順番にマッピングされます。
マイナスx y- > x - y- どのサンプルが表示されたか、そのような代替が選択されます。
Prod x y- > x * y -xとyの代わりに、コンストラクターと一緒に渡された数値が置き換えられます。
否定x -> - x- 計算結果を返します。 たとえば、2 * 3 = 6。

* Main > evalOp （ Plus 2 3 ） -（Plus 2 3）は2つの引数を持つコンストラクターです。
5
*メイン> evalOp （マイナス2 3 ）
-1
* Main > evalOp （ Prod 2 3 ）
6
* Main > evalOp （ Negate 5 ）
-5

同じ場所を踏みつけたら、どんな冒険家でしょうか？ 拳で力を集め、場所を切り替える必要があります！ 現在の位置と動きの方向を取得し、新しい位置を返すwalk関数（2番目の部分からのタスク）があるとします。 以下がその1つです。

歩く::場所->方向->場所
walk curLoc toDir = case curLoc of
Home- > ケース toDir
北->庭
南->フレンドの庭
それ以外の場合 ->ホーム
庭-> ケース toDir
北->フレンドの庭
南->ホーム
それ以外の場合 ->庭
-...ここに残りのオプションを追加します。

実際、ひどいアプローチです。 そんなに余分な仕事！ ネストされたケースが非常に多い！ 十分な知識があれば、間違いなく他の何かを思い付くでしょう。そして今では、ケースがないようにウォーク関数を改善することができるだけです。

歩く::場所->方向->場所

歩いてホームノース=ガーデン
徒歩ホーム南= Friend'sYard
ガーデンノース= Friend'sYardを歩く
庭南を歩く=ホーム
Friend'sYard North = Homeを歩く
Friend'sYard South = Gardenを歩く
歩くcurLoc _ = curLoc

うわー、いくつのウォーク機能があります！ そしてすべて同じですが、前の例よりも行が少なく、機能が多くなっています。 どのように機能しますか？ とても簡単です。 引数を指定してwalk関数を呼び出すと、適切なオプションが選択されます。 たとえば、「walk Garden South」-4番目が選択され、Homeに戻ります。

*メイン>サウスガーデンを歩く
ホーム

興味は最後の散歩です。 彼女は私たちを現在の場所に置いてきました。 他の全員が機能しない場合でも機能すると推測できます。 その中で、最初のパラメーターはcurLoc変数に適合し、2番目のパラメーターはどこにも適合しません。 一般に、2番目のパラメーターの内容は重要ではないため、使用しないため、アンダースコア記号を使用します。 もちろん、ある種の変数をスリップすることはできますが、下線はより明白です。 引数を指定しないでください。 あなたがそうすると、ghciはscる、彼らは言う、なぜあなたはそんなに気まぐれですか？..

......
Friend'sYard North = Homeを歩く
Friend'sYard South = Gardenを歩く
walk curLoc = curLoc


*メイン> ：r
[ 1 of 1 ] Mainのコンパイル（ H：\ Haskell \ QuestTutorial \ Quest \ QuestMain。Hs 、解釈済み）

H：\ Haskell \ QuestTutorial \ Quest \ QuestMain hs： 50 ： 1 ：
「ウォーク」の方程式の引数の数は異なります
H：\ Haskell \ QuestTutorial \ Quest \ QuestMain hs： 50 ：1-24
H：\ Haskell \ QuestTutorial \ Quest \ QuestMain hs： 56 ：1-22
失敗し、モジュールがロードされました：なし。

ここで使用されているパターンマッチングは便利なツールであり、コードがより明確、安全、短くなります。 パターンマッチングには他にも便利な機能があります。 定数だけでなく変数も「パームオフ」でき、用語をコンポーネントパーツに分解することもできます。 特別なエントリを使用すると、リストの最初の要素と残りの要素を簡単に分離できます。 文字列では次のようになります。

headLetter :: 文字列 -> Char
headLetter （ ch：chs ） = ch

tailLetters :: 文字列 -> 文字列
tailLetters （ ch：chs ） = chs

*メイン> headLetter "Abduction"
「A」
*メイン> tailLetters "Abduction"
「B致」

最後のステップは、実行機能を変更することです。 すべてが簡単です：一連のアクションをGo dir代替に追加し、「\ nYou walking to」行を表示します++ show dir ++ "。\ N"、run関数を再度実行しますが、今回はwalkを使用して新しい現在位置を取得します。

curLoc = doを実行します
putStrLn （ describe curLocを記述）
putStr 「コマンドを入力：」
x < -getLine
のケース （ convertStringToAction x ）
終了-> putStrLn 「 会い ましょう...」
Go dir- > do
putStrLn （ " \ n You walking to" ++ show dir ++ "。 \ n " ）
実行（ walk curLoc dir ）
convertResult- > do
putStrLn （ evalAction convertResult ）
putStrLn 「ターン終了。 \ n "
curLocを実行します

-チェック

*メイン>実行ホーム
ホーム
あなたは立っています...
コマンドを入力：Go North

北へ歩いています。

庭
あなたは庭にいます。 ...

実際、それがすべてです。 Goアクションが機能します。

再帰は再帰です。 それ自体からの関数呼び出しです。 私たちはHaskellで再帰を積極的に使用しています-それには何の問題もありません。 C ++などの命令型言語とは異なり、関数型言語では、他のメソッドで行うことが困難な場所で再帰を使用することをお勧めします。 この場合、再帰は受け入れられます。 大量のデータを生成することはなく、再帰を1,000回もスピンしないので、同じC ++で発生する可能性のあるリソースリークを恐れてはいけません。 Haskellには、再帰を安全なツールにするメカニズムがあります。 そのため、ここで現在必要な式のみが計算されます。つまり、リソースは他のコードの巨大なレイヤーに費やされません。 コンパイラは、一度計算されたものを再利用できます。 Haskellにはそのようなスタックはありません-メモリがいっぱいになりません。 最後に、末尾呼び出しへの再帰を最適化することにより、コンパイラは通常の意味で再帰がまったくないことを保証できます。

簡単なプログラムをコンパイルして、リソース使用のダイナミクスを確認できます。 プログラムは、再帰の各ステップでフィボナッチ数を計算し、それらの最後を表示します。

-test.hs：

モジュールメイン

fibs = 0 ： 1 ： zipWith （ + ） fibs （ tail fibs ）

cnt = doを実行します
putStrLn （ " \ n 回転 数：" ++ show cnt ）
putStrLn $ show $ last $ take cnt fibs
実行（ cnt + 1 ）

メイン= 行う
実行1

最適化を伴うコンパイル：

ghc - Oテスト。 hs

コードの順序は好きですか？ クエストのコードは、一般的には悪くはありませんが、1つの重要なものが欠けています。プログラムへのエントリポイントです。 実行可能ファイルにコンパイルすることさえできません。 GHCiインタープリターを使用している間、それについては考えませんでしたが、友人がゲームをプレイしたい場合はどうでしょうか？ 彼に与えられるのはHaskellのコードではありません。一般的には友人であり、プログラマではないかもしれません。 しかし、実行可能ファイルは簡単です。 プログラムを実際にコンパイルするには、コマンドプロンプトでghcコマンドを実行し、QuestMain.hsへのパスを指定します。

H：\ Haskell \ QuestTutorial \ Quest > ghc QuestMain 。 hs
[ 1 of 1 ]コンパイルメイン（ QuestMain。Hs 、 QuestMain.o ）

QuestMain hs： 1 ： 1
関数 'main'はモジュール 'Main'で定義されて いません

GHCコンパイラーは、main関数がmainモジュールで見つからなかったと言います。 これが、Haskellプログラムへのエントリポイントの形成方法です。 何らかの形で主な機能がある他の言語のように見えます。 QuestMain.hsファイルの最後に追加します。

メイン= 行う
putStrLn "Haskellでのクエストアドベンチャー。 \ n "
家に帰る

そして、ファイルの最初の部分で、Mainモジュールを定義します。Mainモジュールには、すべての機能が含まれます。

モジュールメイン

これで、コンパイラーはソースを安全に食べ、実行可能ファイルが表示されます。 このQuestMain.exeがあります。 とりわけ、拡張子が.oおよび.hiのファイルが表示されます-これらは一時ファイルです（オブジェクトとインターフェイスを持つファイル）。 気になる場合は削除できます。 プロジェクトは小さいですが、特別な役割は果たしません。 その後、他の言語と同様に、部分コンパイルに使用できます。これは、最初からコンパイルするよりもはるかに高速です。 たとえば、モジュールが一度コンパイルされて変更されなくなった場合、依存するモジュールが変更されなかったのと同じように、古い.oファイルと.hiファイルを取得するだけで、再コンパイルする必要はありません。 したがって、コードをモジュールに分割することをお勧めします。 さらに良い-モジュールとフォルダによって; そしてさらに良い-モジュール、フォルダ、ライブラリによって。

クエストをTypesモジュールとMainモジュールの2つのモジュールに分けましょう。 これを行うには、Types.hsファイルを作成し、最上部で「module Types where」行を使用してモジュールとして定義し、QuestMain.hsファイルからすべてのADTタイプを転送します。

-Types.hs：

モジュールの種類

データの場所=
ホーム
| ...
導出 （ Eq 、 Show 、 Read ）

データの方向=
北
| ...
導出 （ Eq 、 Show 、 Read ）

データアクション=
見て
| 行き方
| ...
導出 （ Eq 、 Show 、 Read ）

ghciがコマンドrを実行すると、インタープリターはパニックします。これらのタイプを認識しません！

*メイン> ：r
[ 1 of 1 ] Mainのコンパイル（ H：\ Haskell \ QuestTutorial \ Quest \ QuestMain。Hs 、解釈済み）

H：\ Haskell \ QuestTutorial \ Quest \ QuestMain hs： 4 ： 21 ：
範囲外： 型コンストラクタまたは クラス 'Location'

H：\ Haskell \ QuestTutorial \ Quest \ QuestMain hs： 7 ： 13 ：
スコープ外： データコンストラクター「ホーム」

H：\ Haskell \ QuestTutorial \ Quest \ QuestMain hs： 8 ： 13 ：
スコープ外： データコンストラクター「Friend'sYard」

...そして、このような行がさらに20行あります。

プレリュード>

関係ありません！ モジュールを型に接続する必要があります-それらはMainに表示されます。 Mainモジュールの最上部のどこか、「module Main where」の下に、簡単な行を追加します。

-QuestMain.hs：
モジュールメイン

インポートタイプ
-...残りのコード...

これでコンパイルが成功しました。 気づく時間はあります。すでに2つのコンパイル済みファイルがあり、それは論理的です。

プレリュード> ：r
[ 1/2 ]タイプのコンパイル（ H：\ Haskell \ QuestTutorial \ Quest \ Types。Hs 、解釈済み）
[ 2 of 2 ] Mainのコンパイル（ H：\ Haskell \ QuestTutorial \ Quest \ QuestMain。Hs 、解釈済み）
OK 、ロードされたモジュール：Main 、 Types 。
*メイン>

コードをモジュールに分割しました-それは良いことです。 エントリポイントを追加し、コードは実際のプログラムになりました。 これもいいです。 最後に、再帰とパターンマッチングに精通し、Action型の1つの複合コンストラクターも考案しました。 いいね！ これで、十分な休息と知識の統合が必要になります。

修正のための割り当て。

1. GameAction.hsファイルにGameActionモジュールを作成し、main以外のすべての関数をMainから抽出して実行します。
2. Quit、Go dirの処理の横にLookコマンドの処理を追加します（まだない場合）。 重複コード "（describeLocation curLoc）"を2回呼び出さないように改善する方法を検討してください。
3.ユーザーが新しいゲームを開始することを確信しているかどうかを確認するために、Newコマンドの処理を追加します。

この部分のソース 。

目次、参照、および追加情報はGreetingsにあります。