インタラクティブ環境での簡単なテスト

コマンドラインプロンプトの設定:set prompt "ghci>"

しじえんざん

ghci> 2 + 15
17

ghci> 49 * 100
4900

ghci> 1892 - 1472
420

ghci> 5 / 2
2.5

ghci>

かっこの優先度の変更

ghci> (50 * 100) - 4999
1  

ghci> 50 * 100 - 4999
1  

ghci> 50 * (100 - 4999)
-244950

ブール演算

ghci> True && False
False

ghci> True && True
True

ghci> False || True
True

ghci> not False
True

ghci> not (True && True)
False

そうとうせいけってい

ghci> 5 == 5
True

ghci> 1 == 0
False

ghci> 5 /= 5
False

ghci> 5 /= 4
True

ghci> "hello" == "hello"
True

タイプエラー

関数に渡されるパラメータのタイプは、要求に合致する必要があります.そうしないと、エラーが発生します.

ghci> 5+"llama"

No instance for (Num [Char])
arising from a use of `+' at :1:0-9
Possible fix: add an instance declaration for (Num [Char])
In the expression: 5 + "llama"
In the definition of `it': it = 5 + "llama"

呼び出し関数

関数呼び出しにはカッコは必要ありません.パラメータ間はスペースで区切られます.

ghci> succ 8
9

ghci> min 9 10
9

ghci> min 3.4 3.2
3.2

ghci> max 100 101
101

関数の優先度が高い

関数は右結合です

ghci> succ 9 + max 5 4 + 1
16

ghci> (succ 9) + (max 5 4) + 1
16

カスタム関数

Haskellのカスタム関数は、数学の関数と非常に似ています.たとえば、f(x) = x + xなどです.
次の関数では、1つの数に2を乗算します.

doubleMe x = x + x

保存してロード

baby.hsファイルとして保存し、:l命令でロードします.

ghci> :l baby  
[1 of 1] Compiling Main             ( baby.hs, interpreted )
Ok, modules loaded: Main.

ghci> doubleMe 9
18

ghci> doubleMe 8.3
16.6

分岐式if...then ... else ...

*Haskell**で

if文は式であるため、戻り値のある

である.

にはeles文

が必要です.

の2つのブランチが返すデータ型は同じでなければなりません.そうしないと、

とエラーが発生します.

doubleSmallNumber x = if x > 100
                      then x
                      else  x*2

if文は式であるため、最終的には値に簡略化できるため、どこでも使用できます.

doubleSmallNumber' x = (if x > 100 then x else x*2) + 1

関数の命名規則

関数名には、単一引用符

を使用できます.

関数名の頭文字は

と小文字でなければなりません.

はパラメータ(変数)の関数がなく、定数を定義することに相当し、彼の値は

を変更できない.

List入門

Listは本質的にシーケンスであり、他の動的言語とは異なり、シーケンス内の項目は同じタイプである
注意:インタラクティブな環境では、letで変数を定義する必要があります.

ghci> let lostNumbers = [4,8,15,16,23,48]  
ghci> lostNumbers  
[4,8,15,16,23,48]

++連結演算

[1,2,3,4] ++ [9,10,11,12]  ==  [1,2,3,4,9,10,11,12]

:リストヘッダに要素を追加します。高速です。

'A' : " SMALL CAT"  ==  "A SMALL CAT" 
5:[1,2,3,4,5]  ==  [5,1,2,3,4,5]

[]空のリスト

空のリストはリストの最内層要素であり、リストは実際には一連の列接続演算の構文糖である.

[1,2,3] ==  1:2:3:[]

!!インデックスリストの要素は、境界

を超えないように注意してください.

"Steve Buscemi" !! 6  ==  'B' 
[9.4,33.2,96.2,11.2,23.25]!! 1  ==  33.2

リスト内のリスト

リストはネストできますが、サブリストのタイプは同じでなければなりません.

ghci> let b = [[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]
ghci> b
[[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]

ghci> b ++ [[1,1,1,1]]
[[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3],[1,1,1,1]]

ghci> [6,6,6]:b
[[6,6,6],[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]

ghci> b !! 2
[1,2,2,3,4]

リスト比較サイズ

リストはサイズを比較できますが、比較するときに要素を順番に比較します.

ghci> [3,2,1] > [2,1,0]  
True  

ghci> [3,2,1] > [2,10,100]  
True  

ghci> [3,4,2] > [3,4]  
True  

ghci> [3,4,2] > [2,4]  
True  

ghci> [3,4,2] == [3,4,2]  
True

headリストのヘッダを取り出す

head [5,4,3,2,1]  ==  5 

テイル頭以外の部分を取り出す

tail [5,4,3,2,1]   ==  [4,3,2,1] 

リストの末尾を取り出す

last [5,4,3,2,1]   ==  1 

Init尾以外の部分を取り出す

init [5,4,3,2,1]  ==  [5,4,3,2]

注:上の4つの関数が空のリストを処理するとエラーが発生します.

ghci> head []  
*** Exception: Prelude.head: empty list

lengthはリストの長さを返す

ghci> length [5,4,3,2,1]  
5

nullリストが空かどうかをチェック

ghci> null [1,2,3]  
False  

ghci> null []  
True

reverseリストを反転

ghci> reverse [5,4,3,2,1]  
[1,2,3,4,5]

takeはリストの最初の要素を返します

リスト長を超える要素の個数をとると、元のリスト

しか得られない.

take 0エレメントであれば、空のLisが得られます!

ghci> take 3 [5,4,3,2,1]  
[5,4,3]  

ghci> take 1 [3,9,3]  
[3]  

ghci> take 5 [1,2]  
[1,2]  

ghci> take 0 [6,6,6] 
[]

dropリストの最初の要素を削除

ghci> drop 3 [8,4,2,1,5,6]  
[1,5,6]  

ghci> drop 0 [1,2,3,4]  
[1,2,3,4]  

ghci> drop 100 [1,2,3,4]  
[]

maximumはリスト内の最大要素を返します

minimunはリストの最小要素を返します

ghci> minimum [8,4,2,1,5,6]  
1  
ghci> maximum [1,9,2,3,4]  
9

sumはリスト内のすべての要素の和を返します。

productはリスト内のすべての要素の積を返します。

ghci> sum [5,2,1,6,3,2,5,7]  
31  

ghci> product [6,2,1,2]  
24  

ghci> product [1,2,5,6,7,9,2,0]  
0

Elemは、要素がリストにあるかどうかを判断します。

ghci> 4 `elem` [3,4,5,6]  
True  
ghci> 10 `elem` [3,4,5,6]  
False

Rangeの使用

Rangeは、順序付けされたシーケンスを定義することができる
シーケンスとは数学上の数列に類似しており、増加または減少することができる.

[1..20]  ==  [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] 
['a'..'z']  ==  "abcdefghijklmnopqrstuvwxyz" 
['K'..'Z']  ==  "KLMNOPQRSTUVWXYZ" 

シーケンスの間隔を指定できます

[2,4..20]  ==  [2,4,6,8,10,12,14,16,18,20] 
[3,6..20]  ==  [3,6,9,12,15,18] 

浮動小数点数を使用してシーケンスを作成しないでください.正確ではありません.

[0.1, 0.3 .. 1]   ==  [0.1,0.3,0.5,0.7,0.8999999999999999,1.0999999999999999] 

ふかっせい

cycle無限ループのシーケンスを作成する

take 10 (cycle [1,2,3])  ==  [1,2,3,1,2,3,1,2,3,1] 
take 12 (cycle"LOL ")  ==  "LOL LOL LOL " 

repeat無限長のシーケンスを作成する

take 10 (repeat 5)  ==  [5,5,5,5,5,5,5,5,5,5]

リスト解析

リスト解析は本質的に代数上の集合変換である.次に、シーケンス内の要素を2倍にします.

[x*2 | x 

じょうけんろか

集合にフィルタ条件を設定できます.条件に一致する項目は新しいリストに入ります.
次の条件は、シーケンス内の2倍化後に12より大きい要素のみを2倍化して新しいシーケンスに入ることです.

[x*2 | x = 12]  == [12,14,16,18,20]

50から100の間に7を除いた3の要素をすべて取ります.

[ x | x 

注:条件はカンマで区切られています

たじょうけんろか

複数のフィルタ条件を設定できます

[ x | x 

複数リストの解析

複数のシーケンスを1つのシーケンスに変換し、各

注意:フィルタ条件は、複数の解析変数を用いて

を演算することができる.

は、2つの変数の演算結果を新しいシーケンス

に入力する.

[ x*y | x  50]  == [55,80,100,110]

ぜんはいち

複数のシーケンスを解析するときは全配列の組み合わせです

ghci> let nouns = ["hobo","frog","pope"]
ghci> let adjectives = ["lazy","grouchy","scheming"]

ghci> [adjective ++ " " ++ noun | adjective 

リスト解析でlength関数を実現する

リストの要素が何であるかにかかわらず、下線で代用できます.

length' xs = sum [1 | _ 

大文字のフィルタ

条件付きフィルタで大文字をフィルタリングします
注意:ここでは\ elem`関数を使用しています.

removeNonUppercase st = [ c | c  removeNonUppercase "Hahaha! Ahahaha!"
"HA"

ghci> removeNonUppercase "IdontLIKEFROGS"
"ILIKEFROGS"

ネストされたリストの解析

解析されたアイテムがリストであれば、再度解析できます.

ghci> let xxs = [[1,3,5,2,3,1,2,4,5],[1,2,3,4,5,6,7,8,9],[1,2,4,2,1,6,3,1,3,2,3,6]]

ghci> [ [ x | x 

メタグループ

リストは配列のようで、メタグループはベクトルのようで、各要素は1つの成分です.
メタグループには独自のデータ型があり、成分の数とタイプがメタグループのタイプを決定します.メタグループのタイプが異なるため、次のようなリストは間違っています.

[(1,2),(8,11,5),(4,5)]

Couldn't match expected type `(t, t1)'
against inferred type `(t2, t3, t4)'
In the expression: (8, 11, 5)
In the expression: [(1, 2), (8, 11, 5), (4, 5)]
In the definition of `it': it = [(1, 2), (8, 11, 5), (4, 5)]

タプル比較サイズ

Prelude> (1,2,3)>(2,3,4)
False

一元グループなし

最も短いメタグループにも2つの成分があるべきで、二メタグループまたはシーケンスペアと呼ばれます.
一元グループは意味がなく、データ自体です.

Prelude> (2)
2

Prelude> (1,2)
(1,2)

二元グループの成分をとる

fstの取り出しシーケンスのうちの第1の成分

.

snd取り出しシーケンスのうちの第2の成分

.
注意:fst sndこの2つの関数は2元グループしか処理できず、多重グループを処理できません.

ghci> fst (8,11)
8

ghci> fst ("Wow", False)
"Wow"

ghci> snd (8,11)
11

ghci> snd ("Wow", False)
False

zip関数

zip関数は、2つのリストの要素を組み合わせて、2元グループのリストにすることができます.
注意:リスト解析処理では全配列になりますが、mapでよろしいでしょうか.

ghci> zip [1,2,3,4,5] [5,5,5,5,5]
[(1,5),(2,5),(3,5),(4,5),(5,5)]

ghci> zip [1 .. 5] ["one", "two", "three", "four", "five"]
[(1,"one"),(2,"two"),(3,"three"),(4,"four"),(5,"five")]

長さの異なるリストも組み合わせられ、短いものを基準としています

ghci> zip [1..] ["apple", "orange", "cherry", "mango"]
[(1,"apple"),(2,"orange"),(3,"cherry"),(4,"mango")]

リスト解析によるメタグループのリストの構築

質問:すべての辺の長さが10以下で、周長が24に等しい直角三角形を見つけます.
注意:ここの解析条件は3つの解析変数を用いて演算されます.

ghci> let rightTriangles' = 
        [(a,b,c) |  c  rightTriangles'
[(6,8,10)]