mamonbo @ ウィキ

Haskell/真偽値

2014-09-24T20:41:37+09:00

==等しいかとその他の比較== (前回の復習) 前回の章で、Haskellで等号を変数や関数を定義するのに使う方法を見てきた。例えば、以下のコード

r = 5

で定義のスコープに沿って置き換わって意味の通じるところ全てで5に置き換わる rが現れる。また、

f x = x + 3

で数字が1つ後に続き(fの引数として取る)、その数に3を足すのに置き換わる fが現れる。 (復習おわり) しかし、数学では、等号は微妙に違っていて、同様に重要な意味でも使われる。例えば、この問題について考える: {| |valign="top" style="border-right: 1px dashed SlateBlue"| 例題:次の方程式を解きなさい:

x+3=5

|} このような問題を見たとき、

5

が

x+3

の代わりになるとか、その逆にすぐに関心を持つわけでない。代わりに、方程式

x+3=5

を ''命題''、と理解し、ある数

x

が3足すと結果として5となるという意味となる。「方程式を解く」とは命題が真となるような

x

の値を、存在するのならば、見つけ出すということである。この例題では、初等代数学を用いれば、等式を

x=5-3

x=2

と変形し、目的の解を求めることが出来る。また、解が等式を成立させることは元の等式に

x=2

を代入することで確認できる。例題では

2+3=5

という明らかに真である結果になる。 (注:最新版が壊れていたのでここの部分に関しては旧版から持ってきた) 等しいかどうかを見るために値を比較することはプログラミングにおいても便利である。 Haskellではそのような比較をちょうど方程式のように見える自然な方法で書くことが出来る。等号は既にものを定義するのに使われているので、代わりに''等号２つ'' (==)を使う。実際の動きを見るには、GHCiを起動し上で書いた命題を以下のように入力すれば良い: Prelude> 2 + 3 == 5 True

2 + 3

は5に等しいためGHCiは"True"(真)と返す。では、真でない等式を用いたらどうなるだろうか: Prelude> 7 + 3 == 5 False 快適で繋がりのある結果になった。次にこのような比較の中に自分で定義した関数を使ってみる。復習の部分で取り上げた関数fを使ってみる: Prelude> let f x = x + 3 Prelude> f 2 == 5 True f 2はちょうど2 + 3なので、予想通りの結果である。等しいかを確かめるのに加えて、同じほど容易に2つの数値のどちらが大きいかを見るために比較することもできる。Haskellでは<(小なり)、>(大なり)、<=(以下)、>=(以上)といった多くの比較が利用でき、==(等しい)とちょうど同様に機能する。簡単な応用例として、前回の章の円の面積を求める関数areaのそばに<を使って、ある半径の円の面積がある値より小さいかを調べることが出来る。 Prelude> let area r = pi * r^2 Prelude> area 5 < 50 False ==ブール値== 今までの説明でGHCiである算術的命題が真か偽かを知ることができることを学んだ。そのことはそれでよいのだが、これがどのようにプログラムを書くときに便利なのだろうか？そして、GHCiがそのような"質問"に対して"答える"とき実際は何が起こっているのだうか？何が起こっているのかを理解するために、一旦別の関連することについて考える。 GHCiに計算式を入力した時、式は''評価''され、結果となる数値が画面上に表示される: Prelude> 2 + 2 4 ここで計算式を等しいかの比較に変えると、似たようなことが起こる: Prelude> 2 == 2 True 表示される''True''が''何''なのか？確実に数のようには見えない。命題2 == 2 が正しいかを示す何かと思うことが出来る。この視点から、''True''を''値''―総計や数量等の類を表すものではないが―としてみなすのは意味が通っている。ある命題が正しいかどうかを表している。このような値のことを'''真偽値'''や'''ブール値'''という。当然なことだが、ブール値は2つしか存在し得ない。それは、Trueと Falseである。(Haskellでは先頭は大文字) ちなみにブール値という用語は数学者、哲学者である[http://ja.wikipedia.org/wiki/%E3%82%B8%E3%83%A7%E3%83%BC%E3%82%B8%E3%83%BB%E3%83%96%E3%83%BC%E3%83%AB ジョージ・ブール]にちなんで名付けられた。 ===型の導入=== TrueやFalseが値であるという時、ただ単に類似をしているわけではない。Haskellではブール値は数値と同じ状態を持っていて、実際、数字とちょうど同じように操作することができる。些細な例を挙げるとしたら、真偽値が等しいかの比較であろう: Prelude> True == True True Prelude> True == False False 確かにTrueはTrueに等しく、TrueはFalseに等しくない。では、2がTrueに等しいかすぐに答えられるか？ Prelude> 2 == True :1:0: No instance for (Num Bool) arising from the literal `2' at :1:0 Possible fix: add an instance declaration for (Num Bool) In the first argument of `(==)', namely `2' In the expression: 2 == True In the definition of `it': it = 2 == True 正しい答えは''比較できない''である、なぜならこの質問は単に意味を成さないからである。数字を数字でないものを比較することは出来ないし、ブール値とブール値でないものを比較することは出来ない。Haskellは上の式を取り入れ、出てきた醜いエラーメッセージは本質的に、ちょうどこのことを言っている。分かりづらいごちゃごちゃをすべて無視すれば(最終的には理解できるようになる)、上のメッセージは==の左辺に数(Num)があり、それ故、数の類が右辺にあると思われた。しかし、ブール値(Bool)は数でなく、それ故、等しいかの比較は吹き飛んだのである。故に、一般的な概念は値は'''型'''を持つということであり、これらの型がその値で何が出来て、何が出来ないのかを定義する。例えば今回の場合、TrueはBool型の値であり、 The correct answer is you ''can't'', because the question just does not make sense. It is impossible to compare a number with something that is not a number, or a boolean with something that is not a boolean. Haskell incorporates that notion, and the ugly error message we got is, in essence, stating exactly that. Ignoring all of the obfuscating clutter (which we will get to understand eventually), that message says that there was a number (Num) on the left side of the ==, and so some kind of number was expected on the right side; however, a boolean value (Bool) is not a number, and so the equality test exploded into flames. Thus, the general concept is that values have '''types''', and these types define what we can or cannot do with the values. In this case, for instance, True is a value of type Bool, as is False (as for the 2, while there is a well-defined concept of number in Haskell the situation is slightly more complicated, so we will defer the explanation for a little while). Types are a very powerful tool because they provide a way to regulate the behaviour of values with rules which ''make sense'', making it easier to write programs that work correctly. We will come back to the topic of types many times as they are very important to Haskell. == Infix operators == What we have seen so far leads us to the conclusion that an equality test like 2 == 2 is an expression just like 2 + 2, and that it also evaluates to a value in pretty much the same way. That fact is actually given a passing mention on the ugly error message we got on the previous example: {{HaskellGHCi|1= In the expression: 2 == True }} Therefore, when we type 2 == 2 in the prompt and GHCi "answers" True it is just evaluating an expression. But there is a deeper truth involved in this process. A hint is provided by the very same error message: {{HaskellGHCi|1= In the first argument of `(==)', namely `2' }} GHCi called 2 the first ''argument'' of (==). In the previous module, we used ''argument'' to describe the values we feed a function with so that it evaluates to a result. It turns out that == is just a function, which takes two arguments, namely the left side and the right side of the equality test. The only special thing about it is the syntax: Haskell allows two-argument functions with names composed only of non-alphanumeric characters to be used as ''infix operators'', that is, placed between their arguments. The only caveat is that if you wish to use such a function in the "standard" way (writing the function name before the arguments, as a ''prefix operator'') the function name must be enclosed in parentheses. So the following expressions are completely equivalent: {{HaskellGHCi|1= Prelude> 4 + 9 == 13 True Prelude> (==) (4 + 9) 13 True }} This makes it clear how (==) is a function with two arguments just like areaRect from the previous module. What's more, the same considerations apply to the other ''relational operators'' we mentioned (<, >, <=, >=) and to the arithmetical operators (+, *, etc.) – all of them are just functions. This generality is an illustration of one of the strengths of Haskell: it is a language with very few "special cases", which helps to keep things simple. In general, we can say that all tangible things in Haskell are either values or functions.In case you found this statement bold, know that we will go even further in due course. == Boolean operations == To see both truth values and infix operators in action, let's consider the boolean operations which manipulate truth values as in logic propositions. Haskell provides us three basic functions for that purpose: * (&&) performs the ''and'' operation. Given two boolean values, it evaluates to True if both the first and the second are True, and to False otherwise. {{HaskellGHCi|1= Prelude> (3 < 8) && (False == False) True Prelude> (&&) (6 <= 5) (1 == 1) False }} * (||) performs the ''or'' operation. Given two boolean values, it evaluates to True if either the first or the second are True (or if both are true), and to False otherwise. {{HaskellGHCi|1= Prelude> (2 + 2 == 5) {{!!}} (2 > 0) True Prelude> ({{!!}}) (18 == 17) (9 >= 11) False }} * not performs the negation of a boolean value; that is, it converts True to False and vice-versa. {{HaskellGHCi|1= Prelude> not (5 * 2 == 10) False }} Another relational operator is ''not equal to''. It is already provided by Haskell as the (/=) function, but if we were to implement it ourselves, a natural way would be: x /= y = not (x == y) Note that it is perfectly legal syntax to write operators infix, even when defining them. Completely new operators can also be created out of ASCII symbols (which means mostly the common symbols used on a keyboard). == Guards == Now we have explored what is really happening with boolean operators, but we've done little more than testing one-line expressions here. We still don't know how this can be used to make real programs. We will tackle this issue by introducing ''guards'', a feature that relies on boolean values and allows us to write more interesting functions. Let us implement the absolute value function. The absolute value of a number is the number with its sign discardedTechnically, that just covers how to get the absolute value of a ''real'' number, but let's ignore this detail for now.; so if the number is negative (that is, smaller than zero) the sign is inverted; otherwise it remains unchanged. We could write the definition as:

|x| = \begin{cases} x, & \mbox{if }  x \ge 0  \\ -x,  & \mbox{if } x < 0. \end{cases}

Here, the actual expression to be used for calculating

|x|

depends on a set of propositions made about

x

. If

x \ge 0

is true, then we use the first expression, but if

x < 0

is the case, then we use the second expression instead. We need a way to express this decision process in Haskell. Using guards, the implementation could look like this:abs is also provided by Haskell, so in a real-world situation you don't need to worry about providing an implementation yourself. {{HaskellExample|1=The abs function.|2= abs x | x < 0 = 0 - x | otherwise = x }} Remarkably, the above code is about as readable as the corresponding mathematical definition. Let us dissect the components of the definition: * We start just like a normal function definition, providing a name for the function, abs, and saying it will take a single parameter, which we will name x. * Instead of just following with the = and the right-hand side of the definition, we entered a line break, and, following it, the two alternatives, placed in separate lines.We ''could'' have joined the lines and written everything in a single line, but in this case it would be a lot less readable. These alternatives are the ''guards'' proper. Note that the whitespace is not just for aesthetic reasons; it is necessary for the code to be parsed correctly. * Each of the guards begins with a pipe character, |. After the pipe, we put an expression which evaluates to a boolean (also called a boolean condition or a ''predicate''), which is followed by the rest of the definition – the equals sign and the right-hand side which should be used if the predicate evaluates to True. * The otherwise case is used when none of the preceding predicates evaluate to True. In this case, if x is not smaller than zero, it must be greater than or equal to zero, so the final predicate could have just as easily been x >= 0; but otherwise works just as well. {{body note |There is no syntactical magic behind otherwise. It is defined alongside the default variables and functions of Haskell as simply otherwise = True This definition makes ''otherwise'' a catch-all guard. As evaluation of the guard predicates is sequential, the otherwise predicate will only be reached if none of the other ones evaluates to True (so make sure you always place ''otherwise'' as the last guard!). In general, it is a good idea to always provide an otherwise guard, because a rather ugly runtime error will be produced if none of the predicates is true for some input. }} {{body note |You might be wondering why we wrote 0 - x and not simply -x to denote the sign inversion. Truth is, we could have written the first guard as | x < 0 = -x and it would have worked just as well. The only issue is that this way of expressing sign inversion is actually one of the few "special cases" in Haskell, in that in this case the - is ''not'' a function that takes one argument and evaluates to 0 - x, but just a syntactical abbreviation. While very handy, this shortcut occasionally conflicts with the usage of (-) as an actual function (the subtraction operator), which is a potential source of annoyance (for example, try writing three minus negative-four without using any parentheses for grouping). Here, we wrote 0 - x explicitly so that we could take the opportunity to point out this issue. }} === where and Guards === where clauses are particularly handy when used with guards. For instance, consider a function which computes the number of (real) solutions for a [[w:Quadratic equation|quadratic equation]],

ax^2 + bx + c = 0

: numOfSolutions a b c | disc > 0 = 2 | disc == 0 = 1 | otherwise = 0 where disc = b^2 - 4*a*c The where definition is within the scope of all of the guards, sparing us from repeating the expression for disc. {{Haskell/NotesSection}} {{Haskell navigation|chapter=Haskell Basics|noexercises=1}} {{Auto category}}

Wikibooks:Haskell勝手に日本語訳

2014-09-18T13:54:14+09:00

[[Haskell-logo.png]] このページは[http://en.wikibooks.org/wiki/Haskell WikibooksのHaskellのページ(英語版)]の日本語訳である。なぜ日本語版に上げないのかというと、書き言葉で訳せる気がしないということと、私自身がHaskell初心者でこれを書きながら学ぼうと思っているからである。元がクリエイティブ・コモンズ表示 - 継承 3.0(CC BY-SA 3.0)なので、これもCC BY-SA 3.0 となります。 '''Haskell'''は[http://ja.wikipedia.org/wiki/%E9%96%A2%E6%95%B0%E5%9E%8B%E8%A8%80%E8%AA%9E 関数型言語]である。もしプログラミングの経験があるのなら、 [[Haskell/概要|概要]]を見て、Haskellがどのように動くのかをいくらか見、他の言語とどう違うかを見てみよう。 Haskellは幾らかの点に置いて他と異なっている: *Haskellは''純粋''関数型言語である。もし同じ関数を同じ引数で2回違うところで呼び出すと、2回とも全く同じ値を返す。([http://ja.wikipedia.org/wiki/%E5%8F%82%E7%85%A7%E9%80%8F%E9%81%8E%E6%80%A7 参照透過性]という) *Haskellはtypeclassやgeneralized algebraic data typesと言った(それぞれ型クラス、一般代数データ型といったところか)洗練された特徴を持つモダンな型付けシステムを提供する。(このような用語はすぐに滑らかに口から出るようになる) *Haskellは''遅延型''つまり最終的な結果を得るために必要なときだけ計算をする言語でもある。 (modernをカタカナで訳すのはコンピュータ界隈ではよくある話。対義語の古いって言ってもだいたい20世紀だったりするからかと) 純粋な関数だけを取り扱ってコードをずっと簡単に理解し、それぞれの関数の正しさを解析し、証明しさえするのが簡単になるからHaskellプログラマはHaskellを享受するのである。その上、先進的な型システムが馬鹿げた間違い、真面目な間違い両方を見つけるのを助けてくれる。この本では、Haskellのとても初歩的なところから先の特徴までと、コンピュータプログラミング一般両方について紹介することを目標にしている。経験のあるプログラマにはこの工程に大いに辛抱強くいてもらいたい。絶対に、最も慣れ親しんだ言語はHaskellを大いに異なっていて、君たちの言語からの習慣がHaskellの仕組みを理解するのの障壁になるかもしれない。仕組みは単純なのだが異なるのだ。離れていて数学的な関数型プログラマの頭を通して世界を見るための学習を重要なことを理解していかなる言語の境界を遥かに超えたところへもたらしてくれる、素晴らしい新しい世界での冒険として捉えてほしい。 ==概要== この本は初級編、中級編、より最近の問題を取り扱う実践編に分かれている。実践編ではほとんど初心者編で習ったことのみ使う。 (ここにページ作成に貢献するように説得する文章が書いてある) {| |valign="top" style="border-right: 1px dashed SlateBlue"| 本家ではプロンプトの場合は実線の枠、ソースファイルの場合は点線枠の囲いがあったが、@wikiでは点線枠が出せそうにないのでそれぞれ赤枠(行頭スペース)、青枠(blockquoteタグ)で代用している。 |} ==初級編== [[Haskell/変数と関数]] Haskellの基本といくつかのよく使われるライブラリで単純なプログラムが作れるようになる。ほとんどの章には理解度を調べるために役立つ演習問題がある。それぞれの章の最後に解答のリンクが貼ってあるので、知識の正確さを確かめたり、行き詰まった時に答えを知ることができるようになっている。 {|width="100%" cellspacing="0" cellpadding="15" valign="top" style="margin:0.8em 0;border:1px solid MediumAquamarine;background:honeydew" |valign="top" style="border-right: 1px dashed MediumAquamarine"| ===Haskellの基本=== *[[Haskell/環境の構築|環境の構築]] *[[Haskell/変数と関数|変数と関数]] *[[Haskell/真偽値|真偽値]] *[[Haskell/型の基本その1|型の基本その1]] *[[Haskell/リストとタプル|リストとタプル]] *[[Haskell/型の基本その2|型の基本その2]] *Next steps *Building vocabulary *[[Haskell/簡単な入出力|簡単な入出力]] |valign="top" style="border-right: 1px dashed MediumAquamarine"| ===Haskell初級第一=== *{{Haskell chapter/Elementary Haskell|sep= *}} |valign="top" style="border-right: 1px dashed MediumAquamarine"| ===Haskell初級第二=== *{{Haskell chapter/Intermediate Haskell|sep= *}} |valign="top"| ===モナド=== *{{Haskell chapter/Monads|sep=*|subsep= - |breaksep= **|firstsep= *}} |} ==中級編== This section introduces wider functional programming concepts such as different data structures and type theory. It will also cover more practical topics like concurrency. {|width="100%" cellspacing="0" cellpadding="15" valign="top" style="margin:0.8em 0; border: 1px solid SlateBlue; background:#F7F7FF" |valign="top" style="border-right: 1px dashed SlateBlue"| ===Haskell中級=== *{{Haskell chapter/Advanced Haskell|sep= *}} |valign="top" style="border-right:1px dashed SlateBlue"| ===型で遊ぶ=== *{{Haskell chapter/Fun with Types|sep= *}} |valign="top" style="border-right:1px dashed SlateBlue"| === Wider Theory === *{{Haskell chapter/Wider Theory|sep= *}} |valign="top"| === Haskell Performance === *{{Haskell chapter/Haskell Performance|sep= *}} |} == Haskell in Practice == Day-to-day issues of working with Haskell include items such as knowing the standard libraries, building graphical interfaces, and working with databases. You should be able to jump directly to this section from the beginner's track. {|width="100%" cellspacing="0" cellpadding="15" style="margin-top:0.8em;margin-bottom:0.8em;border:1px solid gold;background:cornsilk" |valign="top" style="border-right: 1px dashed gold"| === Libraries Reference === *{{Haskell chapter/Libraries Reference|sep=*|subsep= - |breaksep= **|firstsep= *}} |valign="top" style="border-right: 1px dashed gold"| === General Practices === *{{Haskell chapter/General Practices|sep= *}} |valign="top"| === Specialised Tasks === *{{Haskell chapter/Specialised Tasks|sep= *}} |} == Appendices == :[[/Syntactic sugar/]] :[[/Solutions|Answers to exercises]] :[[/Authors/|Authors and Acknowledgements]] == About the book == :[[/Notes for contributors/]] :[[/Style conventions/]] :[[/To do/]] :[[:Category:Haskell/Templates|Templates for the Haskell wikibook]] :[[/Experimental Modules/|Experimental Modules]] :[[/List of topics/|List of topics]] == Other Haskell tutorials == * [http://www.haskell.org/haskellwiki/Meta-tutorial Haskell Meta-tutorial] - the tutorial to find other tutorials * [http://www.learnyouahaskell.com/Chapters Learn You a Haskell for Great Good] - Tutorial aimed at beginners who may have experience in imperative programming languages but haven't programmed in a functional language before. Freely available online under a CC-BY-NC-SA license; also released as a conventional book. * [http://book.realworldhaskell.org/ Real World Haskell] - an O'Reilly book, available online at no charge (CC-BY-NC license). Built around case studies of practical applications. * [[Write Yourself a Scheme in 48 Hours]] - (imported here) An alternate approach to teaching Haskell (and perhaps Scheme), aimed at a more advanced audience (though not necessarily one that knows how to program!) * [[/YAHT|Yet Another Haskell Tutorial]] - (imported here) is aimed at beginners and takes a practical approach to things. == Additional resources == * [http://www.haskell.org/haskellwiki/Learning_Haskell haskell.org - Resources for learning Haskell]. * [http://dev.stephendiehl.com/hask/ What I Wish I Knew When Learning Haskell] - A wide-ranging collection of concise summaries of many intermediate and advanced Haskell topics. Released in the public domain. * [http://www.cs.kent.ac.uk/people/staff/sjt/craft2e/ The resource page] for the ''Haskell: the craft of functional programming'' book. {{status|75%}}

初回購入特典

2014-09-05T11:45:03+09:00

初回購入特典は 2007で00の部分がメガネになっているやつプチプチした後のプチプチ偽造1円玉 HDDVDプレイヤー嘘です。

Haskell/変数と関数

2014-08-21T15:54:43+09:00

''この章に出てくるすべての例はHaskellのソースファイルに入力しGHCないしHugsに読み込ませることで評価することができる。入力の頭の"Prelude>"のプロンプトは含めないこと。プロンプトが出ているときは、GHCiといった環境にコードを入力してよい。そうでない時は、コードをファイルに入れて実行すること。'' (斜体にするのは英字だけみたい。そしてEnter入ると切れるみたい。) ==変数== GHCiを電卓として使う方法はもう見た。もちろん、この方法は短い計算に取ってのみ実用的である。より長い計算やHaskellのプログラムを書くのには中間結果を追跡したい。中間結果は''変数''に格納でき、名前で呼び出すことができる。1つの変数には1つの''値''が入っていて、変数が使われた時に変数名が値に代わる。例えば、以下に示すような計算である。 ghci> 3.1416 * 5^2 78.53999999999999 これは円の面積公式

A = \pi r^2

による半径5の円のおよその面積である。

\pi (\approx 3.1416)

の数桁打つのも、この数桁をきっかり覚えるのさえも面倒臭い。実際、プログラミングの重要な気の持ちようの1つは我々の頭が思う存分より面白い考えを扱うようにするために、非思考的な繰り返しや丸暗記を機械に任せることだ。今回の場合なら、Haskellはすでに10桁以上の

\pi

を格納しているpiという変数が入っている。 ghci> pi 3.141592653589793 ghci> pi * 5^2 78.53981633974483 注意:変数piとそれが持っている値3.141592653589793は計算上では相互交換可能に使われうる。 (後ろに9が続くのは10進数で有限小数でも2進数では無限小数なために精度落ちするため。ちなみに私は3.14159265358979323846264338327950288419716939937510まで覚えている) ==Haskellのソースファイル== 一瞬だけ使うわけでないコードを書くときはいつでも、コードを拡張子が.hsのHaskellのソースファイルに保存する。基本的に、.hsファイルはプレーンテキストである。テキストエディタにコーディングに合った予測機能が必要なら[http://ja.wikipedia.org/wiki/%E3%83%86%E3%82%AD%E3%82%B9%E3%83%88%E3%82%A8%E3%83%87%E3%82%A3%E3%82%BF Wikipediaのテキストエディタの記事]から始めてみるのが良いだろう。Vimや'''Emacs'''がHaskellプログラマの間でよく採用されている。(小生Emacsユーザーなのです、スミマセン) しっかりとしたソースコードエディタには読解を楽にするために適切にでコードに色を付ける''構文ハイライト''が付いている。きちんと管理するためにこの本での演習で作ることになるHaskellファイルを保存するためのディレクトリ(Windowsで言うところのフォルダ)を作っておくこと。このディレクトリをHaskellWikibookなりと呼ぶことにする。そしてそのディレクトリ内にVarfun.hsという名前のファイルを作り以下のコードを書く:

r = 5.0

このコードは変数rを5.0と定義している。自分で変数を設定すると後の計算をするのが容易になる。注意:行頭にスペースが入っていないことを確かめること、というのもHaskellはスペースに厳格なのである。次に、ターミナルをHaskellWikibooksディレクトリに持って行き、GHCiを起動し :loadコマンドを使ってVarfun.hsファイルを読みこむ: Prelude> :load Varfun.hs [1 of 1] Compiling Main ( Varfun.hs, interpreted ) Ok, modules loaded: Main. :loadは:lと略せる。(今回なら:l Varfun.hsのように略せる) もしGHCiがCould not find module 'Varfun.hs'('Varfun.hs'モジュールを見つけられませんでした)といったエラーを出した場合、違うディレクトリにいる可能性がある。 :cdコマンドでGHCiの中でディレクトリを変えることが出来る。(例えば、 :cd HaskellWikibook) ファイルがロードされたのなら、新しく定義した変数rを計算に使うことが出来る。 *Main> r 5.0 *Main> pi * r^2 78.53981633974483 なので、半径5の円の面積を計算するために、単にr = 5.0と定義して、よく知られている円の面積公式

\pi r^2

を入力する。これにより毎回数を書く必要が無くなり、とても便利である。この機能はとても便利だったので、更に定義を加えよう:ソースファイルの内容以下のように変更する。

r = 5.0
area = pi * r ^ 2

ファイルを保存し、新たな内容を読みこませるために:reload(省略形は:r)コマンドをGHCiに入力する。(このことはこのページの最後まで続く) *Main> :reload Compiling Main ( Varfun.hs, interpreted ) Ok, modules loaded: Main. *Main> 今、rとareaの2つの変数が利用可能である。 *Main> area 78.53981633974483 *Main> area / r 15.707963267948966 {| |valign="top" style="border-right: 1px dashed SlateBlue"| 注意 GHCiプロンプトからソースファイルを使わずに直接変数を定義することも可能である。詳しいことを省略すると、これをするための構文はletという''キーワード''(特別な意味を持つ語、変数名や関数名として使うことが出来ない)を使う。 (小生は''予約語''と習ったがキーワードというのが最近の流行りなのだろうか) 例えば以下の通り: Prelude> let area = pi * 5 ^ 2 便宜上このように''let''を時々使うが、このやり方は一旦少しでも複雑な仕事に移ると不便である。そのため、最初からソースファイルを使うことを強調している。 (letは数学な世界で仮定の意味だと思われ、BASICにもだいたい省略可能でLETはある) |} {| |valign="top" style="border-right: 1px dashed SlateBlue"| 注意 GHCはコンパイラとしても利用可能である。(つまり、自分の書いたHaskellファイルをインタプリタに頼らずに実行できるスタンドアロンプログラムに変換するためにGHCを使うことが出来る。)やり方については[[Haskell/Standalone programs|スタンドアロンプログラム]]の章で後々説明する。(Glasgow Haskell ''Compiler''ですから出来なきゃ詐欺) |} ==コメント== 続きに行く前に、プログラム内に文章をコードとして扱われずに入れることが可能であることを理解するのが良い。これは''コメント''を使うことによって出来る。Haskellではコメントは-- で始め、行の最後まで続く:

x = 5 -- 変数xは5
y = 6 -- 変数yは6
-- z = 7

この場合、xとyは定義されているが、zは定義されていない。さらに、コメントは代わりの構文{-(コメント)-}を使うことでどこにでも入れることも出来る。(日本語も可能)

x = {-可能だからというだけの理由でやっている-} 5

一般にコメントは読者が混乱するかもしれないプログラムの部分を説明するのにその場所に使われる。しかしながら使いすぎには注意すること。コメントが多すぎるとプログラムが読みにくくなる。また、対応するコードを変更した時はコメントが古いのになったり、不正確であったり、間違いを引き起こしがちにならないようにいつもコメントを注意深く更新すること。 ==命令型言語での変数== もしCのような命令型プログラミング言語に既に慣れているのなら、Haskellの変数があなたの知っている変数というものととても異なっていることに気付くことになる。では今からその理由と違いについて説明してゆく。もしプログラミング経験がないのなら、この部分を読み飛ばして[[#関数|関数]](うまく動作しせん)から読むのが良いかもしれない。命令型言語の場合と異なり、Haskellでの変数は''不変である''。(←重要斜体が出ないので) つまり、一度定義すると、中の値は決して変化しない、イミュータブルなのである。例えば、以下のコードは動かない:

r = 5
r = 2

関数型プログラミング言語での変数は計算機のメモリの位置というよりも数学的な変数の方がより関連している。数学の授業では一つの問題の中で絶対に決して変数の中の値が変わることは無かっただろう。それ同様に、Haskellではコンパイラは上のコードに対し"multiple declarations of r"(rの多重宣言)とエラーを返すのだ。計算機に何をするかを明示的に伝えることがある''命令型プログラミング''に慣れている人々にとってはこれを「最初r = 5と設定して、次にr = 2と変える」と読むのに慣れているかもしれない。しかしながら、関数型プログラミングでプログラムは計算機のメモリで何をするのかを明らかにする責任がある。これは命令型言語との大きな違いの別の例である:

r = r + 1

これは(命令型言語で考えがちな)"変数rのインクリメント"ではなく、実際はそれ自身の観点では、rの再帰的定義である。(詳しくは[[Haskell/再帰|再帰]]を後々説明する。命令型言語で起こるようなことと大きな違いがあることだけを覚えておけば良い)もしrが前に何かしらの値で定義されていたのなら、 r = r + 1はHaskellではエラーメッセージを出す。これは数学的文脈で明白に間違いである

5 = 5 + 1

と言うのに同類である。 (逆に技術の教科書には、命令型プログラミングのa = a + 1に慣れろと書いてあった) 変数の値がプログラム中変わらないので、変数はいかなる順序でも定義できる。例えば、以下のコードの断片は全く同じことをする: {|border="0" |- ||

y = x * 2
x = 3

x = 3
y = x * 2

|} 物事を好きな順番で書いても良い、つまり、「xがyの前に宣言された」かその逆かを気にする必要はない。また、このことは一回しかものを宣言できないことの理由でもある。もし2回以上宣言できたとすると、上のコードが曖昧になってしまう。もちろんのことだが、それでもyを使うにはxの値が必要であるが、これは具体的な数値が必要になるまで重要でない。今までの説明で、もしかしたら変数が変化しないHaskellで実際一体何が出来るのかと思っているかもしれない。しかし、見捨てないでくれ、この本の残りの部分で説明しようと思っていることだが、変数を一つも変更すること無くこの世のどんなプログラムも書けるようになる。実際変数が変わらないお陰で''かなり''楽になる、というのもそれのお陰でプログラムの挙動がずっと一層予測しやすくなるからだ。これは純粋関数型プログラミングの重要な特徴である。そして、そのことで命令型プログラミングのやり方や考え方とかなり違ったそれらが必要なのである。 ==関数== では、異なる半径の円の面積を計算したいとする。例えば、半径3の別の円の面積を計算してみよう。書いたばかりのプログラムから作るとすれば、rは既に5と定義されている。プログラム全体をr = 3と変更することが出来る。しかしすると、最初の円が計算できなくなる。代替策は新たな変数r2とr2で計算される面積のための変数area2を定義することだ。この例が示すように、変数名には英字の他に数字含んで良い。(日本語はファイルからだとダメ、プロンプトからは可能)ただし、変数は小文字から始め''なければならない''が残りの部分については文字、数字、アンダースコア(_)、シングルクォート(')(と日本語がギリギリ)からなる任意の文字列を使うことが出来る(日本語には名前の1文字目の制約はない)。 2つの円を対象とした新しいソースファイルは以下のとおり:

r = 5
area = pi*r^2
r2 = 3
area2 = pi*r2^2

明らかなことだが、このやり方は円の面積公式を言葉通りに繰り返しているから不満足である。この頭使っていない繰り返しを無くすために一回だけ書いて異なる半径を適用させるのが好ましい。これがこそまさに''関数''のが出来ることである。 ''関数''は''引数''値(''パラメータ''ともいう)を取り結果の値を与える(これは本質的に数学の関数と同じである)。Haskellでの関数の定義は単純である:変数を定義するように、ただし左辺に付ける関数の引数に気を払うこと。例えば、以下のコードはrと名前を付けた1引数に依る関数areaの定義である。

area r = pi * r^2

構文を注意深く見てみよう:関数名が最初に来て(上の例ではarea) 続いてスペースが一個そして引数(上の例ではr)とがある。そして=の次に、関数の定義が既に定義した物々とともに筋通りに引数を使う公式がとしてある。そして、関数の''呼び出し''ごとに引数へ異なる値を入れることが出来る。コードをファイルに保存しGHCiに読み込ませて以下を試す: *Main> area 5 78.53981633974483 *Main> area 3 28.274333882308138 *Main> area 17 907.9202768874502 ゆえに、この関数を異なる半径で呼び出して、いかなる半径の円の面積も計算できる。ここでの関数は数学的に以下のように定義される :

A(r) = \pi \cdot r^2

A(5) = 78.54

や

A(3) = 28.27

のように数学では、パラメータは括弧によって囲まれる。しかし、Haskellのコードは括弧を付けても機能するが普通は省略される。Haskellは''関数型''言語なので、常に関数を使うことになる、なので可能である場合ならいつも余分な記号を最小にしたいのである。また、括弧は''式''(値を与えるコード全てのこと)をともに評価させるためにまとめるのに使われる。以下の2つの式がいかに違う解釈をされるかに注意:

5 * 3 + 2 -- 15 + 2 = 17 (乗算は加算の前になされる)
5 * (3 + 2) -- 5 * 5 = 25 (括弧のおかげ)
area 5 * 3 -- (area 5) * 3
area (5 * 3) -- area 15

Haskellがどのように+や*と言った他のどの演算子よりも''優先順序が先''であるかに注意。これは例えば、数学で乗算が加算よりも先になされることと同じ流れである。 ==評価== GHCiに式を入力したときに厳密に何が起こるのかを理解してみよう。Enterキーを押した後、 GHCiは渡された式を''評価''をする。これはそれぞれの関数を定義に置き換え、一つの値になるまで計算をするということだ。例えば、area 5の評価は以下のように進行する。 area 5 => {左辺area rを右辺pi * r^2に変える} pi * 5^2 => {変数piを数値に変える} 3.141592653589793 * 5^2 => {べき乗(^)を適用} 3.141592653589793 * 25 => {乗算(*)を適用} 78.53981633974483 ここに示す通り、関数の''適用''や''呼び出し''というのは関数の定義の左辺を右辺に変えるということである。最後の工程として、GHCiは最終結果を画面に表示する。関数を更に挙げてゆく:

double x = 2*x
quadruple x = double (double x)
square x = x*x
half x = x / 2

(quadrupleは定義を見れば分かる通り4倍のこと) {|style="margin:0 auto" |valign="top" style="border-right: 1px dashed SlateBlue"|

演習問題

*GHCiによってquadruple 5がどのように評価されるかを説明しなさい *引数の半分から12を引く(引いた結果を返す)関数を定義しなさい |} ==複数のパラメータ== もちろん、関数は2つ以上の引数を持つことも出来る。例えば、以下は幅と高さ(lengthとなっている)が与えられた長方形の面積を計算する関数である:

areaRect l w = l * w

*Main> areaRect 5 10 50 三角形の面積を計算する別の例:

\left(A = \frac{bh}{2}\right)

(底辺×高さ÷2で求める)

areaTriangle b h = (b * h) / 2

*Main> areaTriangle 3 9 13.5 例から分かる通り、複数の引数はスペース(全角半角は問わない)で分ける。これも式をまとめるのに括弧を使わなければならないことがある理由である。例えば、値 xを4倍するのに以下のようには書けない

quadruple x = double double x

理由はこの書き方はdoubleという名前の関数を2つの引数doubleとxに適用する意図となるからである、というのも''関数は他の関数の引数になりうる''(後々理由を説明する)。代わりの、引数の周りに括弧を付けなければならない: quadruple x = double (double x) 引数は常に与えられた順番通りに渡される。例えば:

subtract x y = x - y

*Main> subtract 10 5 5 *Main> subtract 5 10 -5 ここの例ではsubtract 10 5は10 - 5に評価するが、 subtract 5 10は順番が違うので5 - 10に評価する。 {|style="margin:0 auto" |valign="top" style="border-right: 1px dashed SlateBlue"|

演習問題

*直方体の体積を求める関数を書きなさい *有名なギザのピラミッドに用いられた石の数をおおよそで求めなさいヒント:ピラミッドの体積と1ブロックの体積を見積もる必要がある。(Wikipediaに大きさが載っているが答えの石の数も書いてあるのが難点。また中に穴が開いているということ気にしなくて良い) |} ==関数を組み合わせることについての意見== 言わずもがな、加算(+)や乗算(*)といった予め定義された関数がが使えるのと同様に、新しい関数を定義するのに既に定義した関数を使うことができる。(Haskellでは演算子は関数として定義されている)例えば、正方形の面積を計算するために、長方形の面積を計算する関数を再利用することが出来る:

areaRect l w = l * w
areaSquare s = areaRect s s

*Main> areaSquare 5 25 そもそも、正方形は辺の長さが等しい長方形なだけである。この原則はかなり単純に思えるかもしれないが、とても強力である。特に、数字の代わりに他のオブジェクトで計算し始めるときはそうである。 {|style="margin:0 auto" |valign="top" style="border-right: 1px dashed SlateBlue"|

演習問題

*円柱の体積を計算する関数を書きなさい。円柱の体積は円形である底面積(この章で既にこの関数は作った)に高さを掛けて求める。 |} ==ローカル定義== ===where節=== 関数を定義する際、関数に''ローカルな''中間の結果を定義することはよくある。例えば、 3辺の長さa、b、cが与えられている三角形の面積を計算する[http://ja.wikipedia.org/wiki/%E3%83%98%E3%83%AD%E3%83%B3%E3%81%AE%E5%85%AC%E5%BC%8F ヘロンの公式]

A = \sqrt{s(s-a)(s-b)(s-c)}

を考える:

heron a b c = sqrt (s*(s-a)*(s-b)*(s-c))
□・・where
□・・s = (a+b+c) / 2

変数sは三角形の周の長さの半分で平方根を求める関数sqrt の引数の中に4回書き出すのはただ長いだけで退屈である。実は単に定義を順に書き連ねるだけではうまくいかない――

heron a b c = sqrt (s*(s-a)*(s-b)*(s-c)) -- sはここでは定義されていない
s = (a+b+c) / 2 -- a,b,cはここで定義されていない

――なぜなら変数a、b、cは関数heronの右辺の中のみで利用可能であるが、ここに書かれているsの定義はheronの右辺の外であるからだ。この式を右辺の一部にするために、 whereキーワードを使う必要がある。下に続く定義と区別するためにwhereとローカル定義がスペース4つで''インデント''されていることに注意。(スペースがうまく出力されないので"□・・"と書いた。入力の際にはスペースに変えること)以下はローカルとトップレベルの定義を併用した例である。([[Haskell/変数と関数/fig1.png|fig.1]])

areaTriangleTrig a b c = c * height / 2 --三角法を用いた方法
□・・where
□・・cosa = (b^2 + c^2 - a^2) / (2*b*c) --余弦定理
□・・sina = sqrt (1 - cosa^2) --cos x ^2+sin x ^ 2 =1
□・・height = b*sina
areaTriangleHeron a b c = result --ヘロンの公式を用いた方法
□・・where
□・・result = sqrt (s*(s-a)*(s-b)*(s-c))
□・・s = (a+b+c)/2

==スコープ== さっきの例を注意深く見ると、変数名a、b、cを 2つの面積を計算する関数のそれぞれ1回ずつ、計2回ずつ使っていることに気づくだろう。これが正しく動作する仕組みについて説明してゆく。幸運にも、以下のコードの断片はは嬉しくない驚きは無い: Prelude> let r = 0 Prelude> let area r = pi * r ^ 2 Prelude> area 5 78.53981633974483 ここでの"嬉しくない驚き"とはlet r = 0の定義が入り込んで、areaの結果 0を返すことである。これはrを2回目に定義したとき、1回目の rと''違う''rについて話題にしているからだ。これは実生活でも起こることだ。あなたは、Johnという名前の人を何人知っているか？Johnという名前の人に関して興味のあることは、殆どの場合、友達と"John"について話ができることであり、文脈により、どのJohnを指しているのかが友達がわかることで、このことを''[http://ja.wikipedia.org/wiki/%E3%82%B9%E3%82%B3%E3%83%BC%E3%83%97 スコープ]''と呼ぶ。スコープの専門的な裏側については説明しないつもりである(少なくとも今回は)。なので、パラメータの値は関数の定義でどの変数を呼び出したかによらず厳格に関数を呼び出す時に渡した通りであるということを覚えておくだけでよい。 {| |valign="top" style="border-right: 1px dashed SlateBlue"| 補足上の例ではrは一番最後の定義に則るようにも見える。しかしこれは Prelude>r を試すことで間違いであると判る。(0と帰ってくる)よって、この2つのr は別物である。 |} ==まとめ== #変数は値を格納する。実際はHaskellの任意の式を格納する。 #変数は変化しない。 #関数は再利用するコードを書くのに役立つ。 #関数は複数個パラメータを持つことも出来る。そしてコメントはソースファイルの中のコードでない文章であることも学んだ [[Haskell/解答/変数と関数|演習問題の解答]] [[Haskell]] [[Haskell/真偽値型|次:真偽値型]]

Haskell/変数と関数/fig1.png

2014-08-21T15:45:51+09:00

#ref(tri.png) 製作者:Mamonbo ライセンス:パブリックドメイン(頭使わなくてもこんなもの作れるため)

Haskell-logo.png

2014-08-21T15:21:36+09:00

@wikiでのwikipedia like modeでは画像の挿入は検討中とのことちなみにこのページは@wiki mode #ref(Haskell-logo.png) ライセンス:パブリックドメイン

Haskell/環境の構築

2014-08-19T21:09:03+09:00

この章ではHaskellでコードを書くときに必要となるプログラムのインストール方法について説明する。 ==Haskellのインストール== Haskellは''プログラミング言語''、人が計算機がどう振る舞うべきかをを表せる言語である。料理のレシピを書くような感じで、あなたがレシピを書いて計算機がレシピを実行してくれる。 Haskellのプログラムを使うためには、Haskell''コンパイラ''と呼ばれる特別なプログラムが必要である。コンパイラはHaskellで書かれたコードを受け取って計算機が理解出来るより原始的な言語である''機械語''に翻訳する。 (機械が理解出来るのが機械語で、(設計さえやれば)バイナリである必要は無くBrainf*ckでも機械語になりうる　という話も) 上の料理の例えを使えば、あなたがレシピなるHaskellプログラムを書いて、料理人にあたるコンパイラプログラムが実際の材料を合わせて食べられる料理にあたる実行可能ファイルを作る作業をするのである。もちろん、完成した料理から簡単にはレシピを知ることは出来ない、つまりコンパイル後は実行可能ファイルからHaskellのコードを知ることが出来ない。 Haskell学習を始めるために'''[http://hackage.haskell.org/platform/ Haskellプラットフォーム]をダウンロードしインストールする'''。中には"Glasgow Haskell Compiler"略してGHCと他の必要なものすべてが入っているだろう。もしただHaskellを試してみたいとか完全なコンパイラをダウンロード、インストールするのが嫌なら[http://www.haskell.org/hugs/ Hugs]が使える。もしくはオンライン管理のインタプリタである[http://www.tryhaskell.org/ TryHaskell]で遊んでみるのもいいかもしれない。なお、この本での説明ではすべてGHC用になる。 ([http://ideone.com/ Ideone]でもオンラインで実行できる) {| |valign="top" style="border-right: 1px dashed SlateBlue"| 補足 UNIXユーザーへ(他の人は飛ばして良い): GHCについてはソースからコンパイルするのはお薦めしない。特に初回のインストールにはお薦めしない。GHCはそれ自身がほとんどHaskellで書かれているのでソースから人力でブートストラップを試みるのはとても技が混む。その上、ビルド作業は''実に''時間が掛かり大量の記憶領域を消費する。それでも本当にGHCをソースからビルドしたいのなら[http://hackage.haskell.org/trac/ghc/wiki/Building Building and Porting GHC at the GHC homepage(GHCのホームページにあるGHCのビルドと移植)]を参照のこと。(もちろんのことだが、それらに加えて英文読解という壁がある) 短くまとめるとソースからコンパイルする代わりにHaskell Platformをダウンロードすることを強く薦める。 |} ==第一歩== [http://hackage.haskell.org/platform/ Haskell Platform]をインストールした後は、初めてのHaskellのコードを書く時である。そのために、'''GHCi'''(iは'interactive'の略)と呼ばれるプログラムを使う。やり方はOSによって以下の通り: *Windows:'''スタート'''をクリック、'''ファイル名を指定して実行'''、'cmd'と入力しEnterキーを押し、そしてghciと入力しもう一度Enterキーを押す (Windows 8ではスタートメニューからアプリ一覧を出し右上のボックスに'cmd'と入力) (cmdのところにghciでも可) *MacOS:"Applications/Utilities"("アプリケーション/ユーティリティ"とかになっているかも)フォルダにある"ターミナル"(端末? Mac持ってないからわからない)を開きghciと入力しEnterキーを押す *ターミナル(端末)を開きghciプログラムを実行すると以下の様なのが出力されるはずである: GHCi, version 7.6.3: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. Prelude> 最初の部分はGHCiのバージョンである。そして次に基本パッケージを読み込んでいること伝えている。なのでGHCに付属する組み込み関数やモジュールのほとんどがつかえる。最後に、Prelude>の部分はいわゆる''プロンプト''である。ここの部分にコマンドを入力して、GHCiが結果を返す。 (Preludeは前置きといったところ) これで初めてのHaskellのコードを書く準備は整った。特に今回は基本的な計算をやってみよう: Prelude> 2 + 2 4 Prelude> 5 + 4 * 3 17 Prelude> 2 ^ 5 32 Haskellの演算子は他の言語のそれと似ている、具体的には+は加算、*は乗算、^べき乗(

a ^ b

)である。注目すべき点として2番目の例でHaskellは標準的な演算順序にの則って計算している。(掛け算は足し算より先　ということ) これで、Haskellを電卓として使うことが出来る。実のところ、Haskellはいつも基本的には電卓なのである、しかしながらとても強力で数字以外のオブジェクトー文字やリストや関数や木や他のプログラムまでも―も扱える。(ここで出てきた用語に慣れていなくても心配しなくてよい) GHCiはとても強力な開発環境である。この本が進むに連れ、ソースコードの入ったファイルをGHCiに読み込ませ、ファイルの別々の部分を評価する方法を学ぶ。 {| |valign="top" style="border-right: 1px dashed SlateBlue"| 補足ここで「評価」という言葉が出てきたので説明を入れておくと、Lisp界隈では実行のことをよく「評価」という。そして''Haskell共和国''は''Lisp国''と陸続きである。(Conrad Barski, M.D.談) |} 今のところ全部理解しているのなら次の章へ準備ができている。次章では初めての関数に沿ってHaskellの基本的な概念をいくらか紹介していく。(理解していない人はトークのページを使ってこのWikibookを改善するのに力を貸して)(といっても小生には質問しないで) [[Haskell]] [[Haskell/変数と関数|次:変数と関数]]

Haskell

2014-08-15T13:16:19+09:00

[[Wikibooks:Haskell勝手に日本語訳]]へ

プログラム

2014-08-13T18:20:56+09:00

//haskell ghci> 3.1416 * 5^2 78.53999999999999

チルノ

2014-08-13T18:14:11+09:00

==サンドボックス!== {|width="100%" |valign="top"| ひょう |}