基礎
Hello World
main がエントリポイント、putStrLn は改行付きで出力します
-- GHCi interactive environment
-- launch: ghci (quit with :q)
-- simple arithmetic
> 2 + 3
5
-- function application (no parentheses needed)
> succ 5
6
-- define a function
> double x = x * 2
> double 10
20
-- lists
> [1,2,3,4]
[1,2,3,4]
-- strings are lists of chars
> "hello"
"hello"コメント
{- -} で複数行コメント
-- single line comment
{- multi-line comment
spanning multiple lines -}
{- nested {- comments -} are allowed -}
-- comments are ignored by the compilerGHCi インタラクティブ
:t は型を表示、:q で終了
-- hello.hs
main :: IO ()
main = putStrLn "Hello, World!"
-- run interpreted
-- runhaskell hello.hs
-- or compile to an executable
-- ghc hello.hs && ./hellolet 束縛
let は do ブロック内でローカル変数を定義します
-- in GHCi, 'let' defines a binding (no 'in' needed)
> let x = 5
> let double n = n * 2
> x + double x
15
-- in a source file, top-level bindings need no 'let'
y = 10
-- 'let' inside an expression needs 'in'
z = let a = 2 in a * a -- 4インデントルール
Haskell は中括弧の代わりにインデントを使用します
-- :t shows the type of an expression
> :t 'a'
'a' :: Char
> :t True
True :: Bool
> :t "hi"
"hi" :: [Char]
> :t (+)
(+) :: Num a => a -> a -> a
-- :info shows typeclass info
> :info Numファイルのロード
:load はモジュールを GHCi にロードし、:reload は編集後に再ロードします。:browse はモジュールがエクスポートするすべてを一覧し、:main はコマンドライン引数付きでプログラムを実行します。REPL の作業がスムーズになります。
-- GHCi commands
> :load MyModule.hs -- or :l
> :reload -- or :r, reload after edits
> :type main -- check a type
> :browse Data.List -- list a module's exports
> :main arg1 arg2 -- run main with args
-- :set +t auto-prints types of results型
基本型
:: で型を明示的に注釈します
-- Int: bounded integer (platform-dependent)
x :: Int
x = 9
-- Integer: arbitrary-precision (unbounded)
big :: Integer
big = 2 ^ 100
-- Float / Double (prefer Double)
piVal :: Double
piVal = 3.14159
-- Bool
flag :: Bool
flag = True
-- Char (single Unicode character)
c :: Char
c = 'a'関数の型
-> は右結合、最後が戻り値の型です
-- explicit type signature above a binding
age :: Int
age = 30
-- annotate an expression inline with ::
result = (5 :: Int) + 3
-- function signature
add :: Int -> Int -> Int
add x y = x + y
-- annotate a list
nums :: [Double]
nums = [1.0, 2.0, 3.0]型変数
小文字は型変数です
-- 'a' is a type variable (polymorphic)
id' :: a -> a
id' x = x
-- works for any type
> id' 5
5
> id' "hello"
"hello"
-- length works on any list
length :: [a] -> IntMaybe 型
Maybe は失敗する可能性のある計算を表します
-- '->' is right-associative
add :: Int -> Int -> Int
-- equivalent to: Int -> (Int -> Int)
-- takes a function as an argument
apply :: (a -> b) -> a -> b
apply f x = f x
-- returns a function
const' :: a -> b -> a
const' x y = xEither 型
Either はエラーハンドリングに使われます
-- Maybe: optional values
data Maybe a = Nothing | Just a
safeDiv :: Double -> Double -> Maybe Double
safeDiv _ 0 = Nothing
safeDiv x y = Just (x / y)
-- Either: a value or an error
data Either a b = Left a | Right b
-- convention: Left = error, Right = success
parse :: String -> Either String Int
parse s = Right (read s)タプルとリストの型
タプル (a, b) は型が違ってもいい固定個の値を持ちます。リスト [a] は同じ型の値をいくつでも持ちます。タプルの型は要素数を符号化しますが、リストの型はしません。
-- tuple: (a, b)
pair :: (Int, String)
pair = (1, "one")
-- list: [a]
nums :: [Int]
nums = [1, 2, 3]
-- list of tuples
pairs :: [(Int, String)]
pairs = [(1, "a"), (2, "b")]
-- empty list keeps the polymorphic type
empty :: [a]
empty = []型クラス
Eq 型クラス
Eq は等値比較を定義します
-- name, parameters, '=', body
double :: Int -> Int
double x = x * 2
-- application: just a space, no parentheses
> double 5
10
-- multiple parameters (curried)
add :: Int -> Int -> Int
add x y = x + y
> add 3 4
7Show と Read
Show/Read 型クラス
-- application is left-associative
> max 3 5
5
> max (max 3 5) 7
7
-- '$' has the lowest precedence, right-associative
> sum (map (*2) [1..5])
30
> sum $ map (*2) [1..5] -- same, fewer parens
-- chain reads left to right
> putStrLn $ show $ sum [1..10]
55Num と Ord
Num は数値演算、Ord は順序比較
-- wrap an operator in () to use as a function
> (+) 2 3
5
> (*) 4 5
20
-- sections: partial application of operators
> (+10) 5
15
> (3/) 12
0.25
> (/3) 12
4.0
-- backticks make a function infix
> 10 `div` 3
3
> 10 `mod` 3
1Functor 型クラス
Functor はマップ可能です
-- (.) composes functions right to left
(.) :: (b -> c) -> (a -> b) -> a -> c
(f . g) x = f (g x)
> negate . sum $ [1,2,3]
-6
-- chaining
fn = ceiling . negate . tan
> fn (pi/4)
-1
-- point-free style
odd' = not . even型制約
=> の左側が型制約です
-- functions are first-class values
applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)
> applyTwice (+3) 10
16
> applyTwice (\x -> x*x) 2
16
-- pass functions to higher-order functions
> map (*2) [1..5]
[2,4,6,8,10]
> filter even [1..6]
[2,4,6]中置と前置
任意の二項関数はバッククォートで中置に書け(3 `elem` xs)、任意の演算子は括弧で前置に書けます(mod 10 3)。文脈でより自然に読める方を選びましょう。
-- infix operators can be written prefix with ()
> mod 10 3
1
> div 10 3
3
-- functions can be written infix with backticks
> 10 `mod` 3
1
> 10 `div` 3
3
-- elem: membership test, often infix
> 3 `elem` [1,2,3]
True関数
関数の定義
関数呼び出しに括弧は不要です
-- lists are homogeneous linked lists
nums :: [Int]
nums = [1, 2, 3, 4, 5]
-- strings are [Char]
chars = ['h','e','l','l','o']
str = "hello" -- same as chars
-- empty list
empty = []
-- cons (prepend) is O(1)
> 0 : [1,2,3]
[0,1,2,3]複数パラメータ関数
すべての関数は1 引数(カリー化)です
-- ranges
> [1..5]
[1,2,3,4,5]
-- with a step (first two elements)
> [2,4..10]
[2,4,6,8,10]
-- decreasing needs the step
> [5,4..1]
[5,4,3,2,1]
-- infinite lists (lazy)
> take 5 [1..]
[1,2,3,4,5]
> take 3 (cycle [1,2])
[1,2,1]演算子の関数化
() で演算子を関数として扱います
-- basic access (partial: crash on empty)
> head [1,2,3]
1
> tail [1,2,3]
[2,3]
> last [1,2,3]
3
> init [1,2,3]
[1,2]
-- safe helpers
> length [1,2,3]
3
> null []
True
> reverse [1,2,3]
[3,2,1]関数合成
. 演算子で関数を合成します
-- '++' concatenates two lists
> [1,2] ++ [3,4]
[1,2,3,4]
-- ':' prepends a single element (O(1))
> 1 : [2,3]
[1,2,3]
-- concat flattens one level
> concat [[1,2],[3,4],[5]]
[1,2,3,4,5]
-- intercalate joins with a separator
> intercalate ", " ["a","b","c"]
"a, b, c"where 節
where は関数の末尾でヘルパーを定義します
-- like mathematical set-builder notation
> [x*2 | x <- [1..5]]
[2,4,6,8,10]
-- with a predicate (filter)
> [x | x <- [1..10], even x]
[2,4,6,8,10]
-- multiple generators = Cartesian product
> [(x,y) | x <- [1,2], y <- ['a','b']]
[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
-- with a let binding
> [x*y | x <- [1..3], let y = x+1]
[2,6,12]よく使うリスト関数
elem は所属をチェックします(中置でよく使う)。sum と product は数値リストを畳み込みます。take/drop は先頭部分を取り出すか取り除きます。splitAt はインデックスでペアに分割します。リストは不変なので、すべて新しいリストを返します。
-- membership (often written infix)
> elem 3 [1,2,3]
True
> 3 `elem` [1,2,3]
True
-- reductions
> sum [1..10]
55
> product [1..5]
120
-- take / drop a prefix
> take 3 [1..10]
[1,2,3]
> drop 3 [1..10]
[4,5,6,7,8,9,10]
-- split at an index
> splitAt 3 [1..6]
([1,2,3],[4,5,6])パターンマッチ
基本的なパターンマッチ
順にマッチ、_ は何にでもマッチ
-- tuples can hold different types
pair :: (Int, String)
pair = (1, "hello")
triple :: (Int, String, Double)
triple = (1, "x", 3.14)
-- the size is part of the type
-- (1,2) and (1,2,3) are different typesリストのパターンマッチ
: は先頭と末尾を分けます
-- fst/snd only work on pairs
> fst (1, "a")
1
> snd (1, "a")
"a"
-- swap exchanges the components
> swap (1, 2)
(2,1)
-- these do NOT work on triples
> fst (1, 2, 3) -- type error!タプルのパターンマッチ
タプルの各位置にマッチさせます
-- destructure a tuple by position
describe :: (Int, String) -> String
describe (n, s) = show n ++ ": " ++ s
-- ignore components with _
firstOf :: (a, b, c) -> a
firstOf (x, _, _) = x
-- in a list comprehension
> [n | (n, _) <- [(1,'a'),(2,'b')]]
[1,2]as パターン
@ はマッチした値全体を保持します
-- zip pairs elements from two lists
> zip [1,2,3] ['a','b','c']
[(1,'a'),(2,'b'),(3,'c')]
-- stops at the shorter list
> zip [1,2,3] [4,5]
[(1,4),(2,5)]
-- unzip splits a list of pairs
> unzip [(1,'a'),(2,'b')]
([1,2],"ab")case 式
case で関数本体内のパターンマッチを行います
-- list: same type, variable length
ints :: [Int]
ints = [1, 2, 3]
-- tuple: mixed types, fixed length
mixed :: (Int, String, Bool)
mixed = (1, "x", True)
-- list of tuples (tabular data)
people :: [(String, Int)]
people = [("Alice",30),("Bob",25)]
-- cannot mix types in a list
> [1, "two"] -- type errorガード
基本的なガード
otherwise は True のエイリアスです
-- match on literals, top to bottom
lucky :: Int -> String
lucky 7 = "LUCKY SEVEN!"
lucky _ = "Sorry, you're out of luck"
> lucky 7
"LUCKY SEVEN!"
> lucky 13
"Sorry, you're out of luck"複数パラメータのガード
ガードは順にチェックされます
-- empty list
isEmpty [] = True
isEmpty _ = False
-- head and tail (cons pattern)
head' :: [a] -> a
head' (x:_) = x
-- first two elements
firstTwo :: [a] -> [a]
firstTwo (x:y:_) = [x,y]
firstTwo xs = xsガードと where
where はすべてのガードで共有できます
-- match by position
addPair :: (Int, Int) -> Int
addPair (x, y) = x + y
-- nested patterns
getAge :: (String, (Int, Int)) -> Int
getAge (_, (age, _)) = age
-- ignore with _
nameOf :: (String, Int) -> String
nameOf (name, _) = nameas パターン
as パターン(name@pattern)は、値を分解しつつ、マッチした全体に名前を束縛します。元の値とその部分の両方が必要なときに便利で、高コストな再構築を避けられます。
-- '@' keeps the whole value AND its parts
firstLetter :: String -> String
firstLetter "" = "Empty string!"
firstLetter all@(x:_) =
"The first letter of " ++ all ++ " is " ++ [x]
> firstLetter "Haskell"
"The first letter of Haskell is H"case 式
case は式の中でパターンマッチを行います。セットアップの後に計算した値で関数の本体を分岐したいときに有用です。パターンは順番に試されるので、必要なら網羅的な分岐を追加しましょう。
-- pattern match inside any expression
describe :: [a] -> String
describe xs =
case xs of
[] -> "empty"
[_] -> "singleton"
_ -> "longer"
-- case on any value, e.g. an Ordering
classify n = case compare n 0 of
LT -> "negative"
EQ -> "zero"
GT -> "positive"コンストラクタパターン
パターンは Red、Nothing、Just のようなデータコンストラクタにマッチできます。代数的データ型を分解するのがこれです。コンパイラは非網羅的なパターンに警告するので、すべてのコンストラクタをカバーしましょう。
-- match on data constructors
data Color = Red | Green | Blue
toString :: Color -> String
toString Red = "red"
toString Green = "green"
toString Blue = "blue"
-- match on Maybe
fromMaybe :: a -> Maybe a -> a
fromMaybe d Nothing = d
fromMaybe _ (Just x) = xWhere / Let
where 節
where は関数定義の末尾にあります
-- '|' tests boolean conditions in order
bmiTell :: Double -> String
bmiTell bmi
| bmi <= 18.5 = "underweight"
| bmi <= 25.0 = "normal"
| bmi <= 30.0 = "overweight"
| otherwise = "obese"
> bmiTell 22.0
"normal"let-in 式
let-in は式で、どこでも使えます
-- otherwise is just True
otherwise :: Bool
otherwise = True
-- a signum implementation
signum' :: Int -> Int
signum' n
| n < 0 = -1
| n == 0 = 0
| otherwise = 1do ブロック内の let
do ブロック内の let には in が不要です
-- multiple parameters
max' :: Int -> Int -> Int
max' a b
| a > b = a
| otherwise = b
-- shared helpers via where
bmiTell :: Double -> Double -> String
bmiTell w h
| bmi <= 18.5 = "underweight"
| bmi <= 25.0 = "normal"
| otherwise = "overweight"
where bmi = w / h^2リスト内包表記の let
let はリスト内包表記で使えます
-- pattern matching: fixed values/structure
factorial 0 = 1
factorial n = n * factorial (n-1)
-- guards: ranges and conditions
clamp :: Int -> Int -> Int -> Int
clamp lo hi x
| x < lo = lo
| x > hi = hi
| otherwise = xif-then-else
Haskell の 'if' は常に値を返す式で、両方の分岐が必須です。多方向の分岐では、ネストした if-then-else よりガードのほうがきれいです。if-then-else は単純な二択に向いています。
-- 'if' is an expression that returns a value
abs' :: Int -> Int
abs' n = if n < 0 then -n else n
-- nested ifs (prefer guards for readability)
grade :: Int -> Char
grade n =
if n >= 90 then 'A'
else if n >= 80 then 'B'
else if n >= 70 then 'C'
else 'F'リスト
リストの基礎
リストは同じ型の要素の連結リストです
-- where: definitions at the bottom, scoped to a function
area :: Double -> Double -> Double
area w h = w * h_adj
where
h_adj = h * 0.9 -- adjust height
scale = 0.9 -- a helper
-- definitions can refer to each other
f x = a + b
where a = x * 2
b = a + 1 -- refers to a範囲リスト
ステップと無限リストをサポートします
-- let <bindings> in <expr>
cylinder :: Double -> Double -> Double
cylinder r h =
let side = 2 * pi * r * h
top = pi * r^2
in side + 2 * top
-- scoped to the expression only
> let z = 5 in z * z
25
-- z is not in scope hereリスト操作
基本的なリスト操作関数
-- in do, 'let' needs no 'in'
main = do
let x = 5
y = 10
putStrLn $ "sum = " ++ show (x + y)
-- in a list comprehension, no 'in'
> [x*y | x <- [1..3], let y = x+1]
[2, 6, 12]リストの結合
++ は結合、: は先頭に追加します
-- where bindings support pattern matching
describe :: [a] -> String
describe xs = "head is " ++ show first
where (first:_) = xs
-- multiple where bindings
analyze :: [Int] -> String
analyze xs =
"sum=" ++ show s ++ ", len=" ++ show l
where s = sum xs
l = length xsリスト内包表記
数学の集合内包表記に似ています
-- let: an expression, available wherever expressions go
-- (needs 'in', except in do/comprehension)
-- where: a declaration, attached to a function
-- (cannot be nested as an expression)
-- same result, two styles:
-- with let:
f x = let y = x+1 in y*y
-- with where:
f' x = y*y where y = x+1タプル
タプルの基礎
タプルは異なる型を含めます
-- base case + recursive case
factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)
> factorial 5
120タプル関数
fst/snd はペアにのみ使えます
-- match [] then (x:xs)
length' :: [a] -> Int
length' [] = 0
length' (_:xs) = 1 + length' xs
sum' :: Num a => [a] -> a
sum' [] = 0
sum' (x:xs) = x + sum' xsタプルのパターンマッチ
パターンマッチでタプルを分解します
-- carry the running result in an accumulator
factorial :: Int -> Int
factorial n = go n 1
where
go 0 acc = acc
go k acc = go (k-1) (k*acc)
-- sum with an accumulator
sumTo :: Int -> Int
sumTo n = go n 0
where go 0 acc = acc
go k acc = go (k-1) (k+acc)クイックソート
この有名な例は Haskell の表現力を示しています。リスト内包表記でピボットの前後へ分割し、各部分を再帰的にソートします。最も効率的なクイックソートではありませんが、再帰と内包表記の美しいデモです。
-- elegant but not in-place quicksort
qsort :: Ord a => [a] -> [a]
qsort [] = []
qsort (p:xs) =
qsort smaller ++ [p] ++ qsort larger
where
smaller = [x | x <- xs, x < p]
larger = [x | x <- xs, x >= p]
> qsort [3,1,4,1,5,9,2,6]
[1,1,2,3,4,5,6,9]相互再帰
相互再帰とは、2 つ以上の関数が互いに呼び合うことです。ここでは even' と odd' がベースケースの 0 へ向かって減らしていきます。両方を定義する必要があります(モジュール内では順序は問われません)。
-- functions calling each other
even' :: Int -> Bool
even' 0 = True
even' n = odd' (n - 1)
odd' :: Int -> Bool
odd' 0 = False
odd' n = even' (n - 1)
> even' 4
True高階関数
map
map は各要素に関数を適用します
-- map applies a function to every element
> map (*2) [1,2,3]
[2,4,6]
> map (+1) [1..5]
[2,3,4,5,6]
-- with a lambda
> map (\x -> x*x) [1..4]
[1,4,9,16]
-- strings are lists of chars
> map toUpper "hello"
"HELLO"filter
filter は述語を満たす要素を残します
-- keep elements satisfying a predicate
> filter even [1..10]
[2,4,6,8,10]
> filter (>3) [1,2,3,4,5]
[4,5]
-- with a lambda
> filter (\c -> c /= ' ') "hello world"
"helloworld"
-- count matches
> length (filter odd [1..100])
50foldl and foldr
foldl は左畳み込み、foldr は右畳み込み
-- foldl: left fold (function, seed, list)
> foldl (+) 0 [1..5]
15
-- foldr: right fold
> foldr (+) 0 [1..5]
15
-- associativity differs:
-- foldl: ((((0+1)+2)+3)+4)+5
-- foldr: 1+(2+(3+(4+(5+0))))
-- foldl1/foldr1 use the first element as seed
> foldl1 max [3,1,4,1,5]
5zipWith
zipWith は関数で2つのリストを結合します
-- apply a function to paired elements
> zipWith (+) [1,2,3] [10,20,30]
[11,22,33]
> zipWith (*) [1,2,3,4] [2,2,2,2]
[2,4,6,8]
-- combine strings
> zipWith (\a b -> a ++ b) ["a","b"] ["1","2"]
["a1","b2"]
-- stops at the shorter list
> zipWith max [1,5,3] [2,4,6,8]
[2,5,6]関数適用 $
$ 演算子で括弧を減らせます
-- scanl returns all intermediate accumulators
> scanl (+) 0 [1,2,3]
[0,1,3,6]
-- scanr from the right
> scanr (+) 0 [1,2,3]
[6,5,3,0]
-- running maximum
> scanl max 0 [3,1,4,1,5]
[0,3,3,4,4,5]takeWhile と dropWhile
takeWhile は述語を満たさない最初の要素で止まり、dropWhile は満たす接頭部分を取り除きます。span は最初の失敗要素でリストを分割します。接頭部分ベースの処理に最適です。
-- takeWhile: take while the predicate holds
> takeWhile (<5) [1,2,3,4,5,4,3]
[1,2,3,4]
-- dropWhile: drop while the predicate holds
> dropWhile (<5) [1,2,3,4,5,4,3]
[5,4,3]
-- span splits at the first failing element
> span (<3) [1,2,3,4,5]
([1,2],[3,4,5])
-- first word of a string
> takeWhile (/= ' ') "hello world"
"hello"Map / Filter / Fold
チェーン操作
map/filter/fold を組み合わせます
-- '\' defines a lambda (resembles the λ symbol)
> (\x -> x + 1) 5
6
-- used with map
> map (\x -> x * x) [1..4]
[1,4,9,16]
-- used with filter
> filter (\x -> x > 2) [1,2,3,4]
[3,4]scanl/scanr
scan はすべての中間結果を保持します
-- parameters separated by spaces
> (\x y -> x + y) 3 4
7
-- in zipWith
> zipWith (\x y -> x * y + 1) [1,2,3] [10,20,30]
[11,21,31]takeWhile/dropWhile
条件で要素を取得/破棄します
-- lambdas can pattern match their one argument
> map (\(a,b) -> a + b) [(1,2),(3,4)]
[3,7]
-- only ONE pattern, no fallthrough
-- this crashes if it doesn't match:
> (\(x:_) -> x) [] -- runtime error高階関数の中のラムダ
ラムダは fold、filter、map で輝きます。他の関数を返すこともできます(\x -> \y -> ...)。カリー化を示しています。ラムダは短く保ちましょう。長いラムダは名前付き関数にしたほうが明確です。
-- combining with fold
> foldl (\acc x -> acc + x*2) 0 [1,2,3]
12
-- with filter (infix via backticks)
> length . filter (\x -> x `mod` 2 == 0) $ [1..10]
5
-- a lambda returning a function
> (\x -> \y -> x + y) 3 4
7ポイントフリースタイル
ポイントフリースタイルは明示的な引数を省き、合成と適用で関数を表現します。簡潔ですが、やりすぎると可読性が落ちます。流れが自明な短いチェーンに使いましょう。
-- explicit: name every argument
sumSquares xs = sum (map (^2) xs)
-- point-free: omit arguments via composition
sumSquares' = sum . map (^2)
-- more examples
count p = length . filter p
oddNums = filter odd
negateAll = map negateラムダ
無名関数
\ はラムダを定義、λ のようなもの
-- all functions are curried (one arg at a time)
add :: Int -> Int -> Int
add x y = x + y
-- apply fewer args to get a function
add5 :: Int -> Int
add5 = add 5
> add5 10
15
-- with map
> map (add 5) [1,2,3]
[6,7,8]複数パラメータのラムダ
複数のパラメータはスペース区切り
-- left section (fix the left operand)
> map (+3) [1,2,3]
[4,5,6]
-- right section (fix the right operand)
> map (3/) [9, 12, 18]
[0.333..,0.25,0.166..]
-- (-3) is the NUMBER, not a section!
> map (subtract 3) [4,5,6]
[1,2,3]
-- comparison sections
> filter (>3) [1..6]
[4,5,6]パターンマッチ付きラムダ
ラムダ内のパターンマッチ
-- flip swaps the first two arguments
flip :: (a -> b -> c) -> b -> a -> c
flip f x y = f y x
-- fix the second argument instead of the first
> map (flip (-) 1) [3,4,5]
[2,3,4]
-- divide from the other side
> map (flip div 2) [4,6,9]
[2,3,4]カリー化の解説
a -> b -> c は a -> (b -> c) を意味します。'a' を受け取り、関数を返す関数です。適用は左結合で、f x y = (f x) y です。これが部分適用が自然に機能する理由です。
-- this signature:
max :: Int -> Int -> Int
-- is actually: Int -> (Int -> Int)
-- max takes an Int and returns a function
-- step by step
> :t max 5
max 5 :: Int -> Int
> (max 5) 10
10
-- application is left-associative
> max 5 10 == ((max 5) 10)
True関数を返す関数
関数は他の関数を返せます。これはカリー化から自然に生じます。関数ファクトリーが可能になり、multiplyBy 2 は 2 倍する関数を作ります。greet "Hi" のような部分適用は、後で使う関数を設定します。
-- return a function
multiplyBy :: Int -> (Int -> Int)
multiplyBy n = \x -> n * x
-- or equivalently (currying)
multiplyBy' n x = n * x
> let double = multiplyBy 2
> double 21
42
-- configure a function via partial application
greet :: String -> String -> String
greet greeting name = greeting ++ ", " ++ name
sayHi = greet "Hi" -- a configured greeterカリー化
部分適用
すべての関数は自動的にカリー化されます
-- Eq: equality
> 5 == 5
True
> "a" /= "b"
True
-- Ord: ordering
> 3 < 5
True
> compare 3 5
LT
-- Show: convert to a string
> show 5
"5"
> show [1,2,3]
"[1,2,3]"
-- Read: parse from a string
> read "5" + 2
7中置部分適用
演算子の部分適用
-- '=>' constrains the type variables
(==) :: Eq a => a -> a -> Bool
(<) :: Ord a => a -> a -> Bool
show :: Show a => a -> String
-- a function requiring Eq
elem :: Eq a => a -> [a] -> Bool
elem _ [] = False
elem x (y:ys) = x == y || elem x ys
-- multiple constraints
showMax :: (Ord a, Show a) => [a] -> String
showMax xs = show (maximum xs)flip 関数
flip は引数の順序を入れ替えます
-- declare a typeclass with method signatures
class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
-- default implementations
x == y = not (x /= y)
x /= y = not (x == y)
-- minimal: define either (==) or (/=)インスタンス宣言
instance Typeclass Type where は型に対して型クラスを実装します。デフォルトが存在しない限り、各メソッドを定義する必要 があります。これで TrafficLight の値は ==、/=、show を使えます。
data TrafficLight = Red | Yellow | Green
instance Eq TrafficLight where
Red == Red = True
Yellow == Yellow = True
Green == Green = True
_ == _ = False
instance Show TrafficLight where
show Red = "Red light"
show Yellow = "Yellow light"
show Green = "Green light"数値の型クラス
数値の階層には Num(すべての数値)、Fractional(/ をサポート)、Integral(div、mod をサポート)があります。Int と Double は別の型です。fromIntegral で安全に相互変換しましょう。
-- Num: basic numeric operations
(+) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a
negate :: Num a => a -> a
-- Fractional: supports division
(/) :: Fractional a => a -> a -> a
-- Integral: integer division
div, mod :: Integral a => a -> a -> a
-- convert between numeric types
> fromIntegral (length [1,2,3]) + 0.5
3.5deriving
多くの型クラスは自動導出できます: Eq、Ord、Show、Read、Enum、Bounded。ボイラープレートなインスタンスを書かずに済みます。Enum と Bounded により、範囲構文([Red ..])や minBound/maxBound が使えます。
-- automatically derive common typeclasses
data Color = Red | Green | Blue
deriving (Eq, Ord, Show, Read, Enum, Bounded)
> show Red
"Red"
> Red < Green
True
> minBound :: Color
Red
> [Red ..]
[Red,Green,Blue]合成
関数合成
. は右から左へ合成します
-- sum type: alternatives separated by '|'
data Bool' = False' | True'
-- pattern match on constructors
not' :: Bool' -> Bool'
not' True' = False'
not' False' = True'
-- value constructors with no fields
data Weekday = Mon | Tue | Wed | Thu | Fri複数関数の合成
複数の関数を連鎖合成します
-- product type: constructors carry fields
data Point = Point Double Double
data Shape
= Circle Double -- radius
| Rect Double Double -- width, height
-- construct values
p = Point 1.0 2.0
c = Circle 5.0
r = Rect 3.0 4.0ポイントフリースタイル
引数を省略し、より簡潔に
-- a type parameter 'a' (like Maybe)
data Maybe' a = Nothing' | Just' a
-- a boxed value
data Box a = Box a
-- use it with any type
> Just' 5
Just' 5
> Box "hello"
Box "hello"
-- model failure with Maybe
divide :: Double -> Double -> Maybe' Double
divide _ 0 = Nothing'
divide x y = Just' (x/y)再帰的な型
型は自分自身を参照でき、再帰的な構造を作れます。IntList は Int の単方向連結リスト、Tree a は二分木です。パターンマッチはそのような構造の上を自然に再帰します。
-- a custom linked list
data IntList = INil | ICons Int IntList
-- build the list 1,2,3
xs = ICons 1 (ICons 2 (ICons 3 INil))
-- a binary tree
data Tree a = Leaf | Node a (Tree a) (Tree a)
tree = Node 1 (Node 2 Leaf Leaf) (Node 3 Leaf Leaf)関数付きの BST
代数的データ型はパターンマッチ経由の再帰関数と自然に組み合わさります。この BST 実装は順序を保ちながら挿入し、中間順走査はソート済みリストにフラット化します。ADT と再帰が、OOP のクラスを置き換えます。
data Tree a = Leaf | Node a (Tree a) (Tree a)
-- insert into a binary search tree
insert :: Ord a => a -> Tree a -> Tree a
insert x Leaf = Node x Leaf Leaf
insert x (Node y l r)
| x < y = Node y (insert x l) r
| otherwise = Node y l (insert x r)
-- inorder traversal yields a sorted list
inorder :: Tree a -> [a]
inorder Leaf = []
inorder (Node x l r) = inorder l ++ [x] ++ inorder r列挙型
引数なしのコンストラクタの直和型は enum のように振る舞います。deriving Enum で succ/pred と範囲構文([North ..])が使え、deriving Bounded で minBound/maxBound が得られます。Haskell の慣用的な列挙です。
-- enum-like sum type
data Direction = North | East | South | West
deriving (Eq, Ord, Enum, Bounded, Show)
-- enumerate via Enum
> [North .. West]
[North,East,South,West]
-- Bounded: the limits
> minBound :: Direction
North
> maxBound :: Direction
West
-- cycle through directions
next :: Direction -> Direction
next West = North
next d = succ dMonads
Maybe Monad
Maybe は失敗の伝播を自動的に処理します
-- without records (positional, error-prone)
data Person0 = Person0 String Int String
-- with records (named fields)
data Person = Person
{ name :: String
, age :: Int
, city :: String
}
-- construct with field names (any order)
p1 = Person { name = "Alice", age = 30, city = "NYC" }List Monad
List Monad は非決定的計算を表します
-- field names are accessor functions
> name p1
"Alice"
> age p1
30
-- their types
> :t name
name :: Person -> String
> :t age
age :: Person -> Int
-- record patterns also work
greet :: Person -> String
greet (Person { name = n }) = "Hi, " ++ nIO Monad
IO Monad は副作用を分離します
-- functional update: change only some fields
p2 = p1 { age = 31 }
-- the original is unchanged (immutable)
> age p1
30
> age p2
31
-- update multiple fields at once
p3 = p1 { age = 31, city = "LA" }bind 演算子
>>= は Monad の中核操作です
-- match and bind fields by name
birthday :: Person -> Person
birthday p@Person { age = a } = p { age = a + 1 }
-- ignore unneeded fields
getName :: Person -> String
getName Person { name = n } = n
-- as-pattern keeps the whole record
isAdult :: Person -> Bool
isAdult p@Person { age = a } = a >= 18return
return は値を Monad コンテキストに入れます
-- field names share a top-level namespace
data Person = Person { name :: String }
data Company = Company { name :: String }
-- ERROR: 'name' clashes in the same module
-- workaround 1: prefix the fields
data Person' = Person' { personName :: String }
data Company' = Company' { companyName :: String }
-- workaround 2: language extensions
{-# LANGUAGE DuplicateRecordFields #-}Functors
fmap
fmap は Functor 内の値に関数を適用します
-- file Geometry.hs
module Geometry
( sphereVolume -- explicit export list
, cubeVolume
) where
sphereVolume :: Float -> Float
sphereVolume r = (4/3) * pi * r^3
cubeVolume :: Float -> Float
cubeVolume s = s^3
-- a helper not in the export list is private
privateHelper = ...<$> 演算子
<$> は fmap と同等です
-- import everything from Data.List
import Data.List
-- names are now in scope
> sort [3,1,2]
[1,2,3]
> nub [1,1,2,2,3]
[1,2,3]
-- import specific functions
import Data.Maybe (fromMaybe)
-- qualified: use the full module name
import qualified Data.Map as M
> M.empty関数 Functor
関数の fmap は . です
-- import only specific names
import Data.List (sort, nub, group)
-- import everything except some
import Data.List hiding (head, tail)
-- import a type without its constructors
import Data.Tree (Tree, Node)
-- import constructors too
import Data.Tree (Tree(..))修飾付きインポート
修飾付きインポートはモジュールのプレフィックスを強制し、衝突を防ぎます(例: Prelude の filter と Data.Map の filter)。import qualified M as M が慣用です。名前が多く重複するモジュールには qualified を使いましょう。
-- avoid name clashes with qualified
import qualified Data.Map as Map
import qualified Data.Set as Set
m = Map.empty
s = Set.fromList [1,2,3]
-- Prelude's filter vs Data.Map's
> filter even [1..6]
[2,4,6]
> Map.filter (>2) (Map.fromList [(1,'a'),(3,'b')])
fromList [(3,'b')]Prelude
Prelude はデフォルトでインポートされ、一般的な関数と型を提供します。衝突を避けるため、またはより良い代替(例: Data.List の foldl')を使うために、項目を hiding しましょう。カスタムプレリュードを使うプロジェクトも多いです。
-- Prelude is imported by default
-- provides: map, filter, length, (+), etc.
-- hide entries to avoid clashes
import Prelude hiding (head, tail, foldl)
-- use better alternatives
import Data.List (foldl') -- strict fold
-- common standard modules
import Data.List
import Data.Maybe
import Data.Char
import Data.Eitherモジュール階層
モジュール名は階層的で、ディレクトリ構造を反映します。A.B.C は A/B/C.hs にあります。エクスポートリストに 'module M' を入れると、別のモジュールを再エクスポートできます。公開 API をまとめるのに便利です。
-- hierarchical names mirror directories
-- module Data.Geometry.Sphere where
-- lives in: Data/Geometry/Sphere.hs
-- import nested modules
import Data.Geometry.Sphere
import Data.Geometry.Cube
-- re-export a whole module
module MyMod
( module Data.List -- re-export
, myFunc
) where
import Data.List
myFunc = sortApplicatives
<*> 演算子
<*> は Functor 内の関数を適用します
-- IO actions produce effects when run
greet :: IO ()
greet = do
putStrLn "What's your name?"
name <- getLine
putStrLn ("Hello, " ++ name)
-- run in GHCi
> greet
What's your name?
Alice
Hello, Alice純粋関数適用
pure は値を Applicative に入れます
-- every program starts in main
main :: IO ()
main = putStrLn "Hello, World!"
-- combine actions with do
main = do
greet
putStrLn "Done."
-- command-line arguments
import System.Environment
main = do
args <- getArgs
print argsリスト Applicative
リストの <*> は直積です
-- do is sugar for sequential actions
echo = do
s <- getLine
putStrLn s
-- desugars to bind (>>=)
echo' = getLine >>= putStrLn
-- 'let' needs no 'in' inside do
greet = do
let msg = "Hi!"
putStrLn msg入力関数
getLine は 1 行(改行なし)、getChar は 1 文字、getContents は標準入力を遅延で全読みします。結果の束縛には '<-' を使います。getContents は遅延評価なので、ストリーミングパイプラインに最適です。
-- read a line (without the newline)
> line <- getLine
hello world
> line
"hello world"
-- read a single character
> c <- getChar
a> c
'a'
-- read all of stdin lazily
process = do
text <- getContents
putStr (map toUpper text)出力関数
putStrLn と putStr は String を標準出力に書きます(改行あり/なし)。print は putStrLn . show と等価なので、文字列に引用符が付きます。改行の要否と、値が String かどうかで選びましょう。
-- with a trailing newline
putStrLn :: String -> IO ()
-- without a newline
putStr :: String -> IO ()
-- any Show-able value
print :: Show a => a -> IO ()
> putStrLn "hi" -- hi
> putStr "hi" -- hi (no newline)
> print 5 -- 5
> print "hi" -- "hi" (with quotes)ファイル IO
readFile は遅延読み込み、writeFile は上書き、appendFile は末尾に追記します。例外時にもリソースが閉じられるように bracket を使いましょう。ファイルは FilePath(String のエイリアス)で指定します。
-- read a whole file (lazy)
readFile :: FilePath -> IO String
-- write a file (overwrites)
writeFile :: FilePath -> String -> IO ()
-- append to a file
appendFile :: FilePath -> String -> IO ()
main = do
contents <- readFile "input.txt"
writeFile "output.txt" (map toUpper contents)
-- safe resource handling
import Control.Exception (bracket)IO
基本的な IO
IO 操作は IO Monad 内にあります
-- Functor: a context you can map over
class Functor f where
fmap :: (a -> b) -> f a -> f b
-- '<$>' is fmap as an operator
> fmap (+1) (Just 5)
Just 6
> (+1) <$> Just 5
Just 6
> (+1) <$> Nothing
Nothing
> map (+1) [1,2,3] -- map is fmap for lists
[2,3,4]ファイルの読み書き
readFile/writeFile でファイルを扱います
-- Applicative: functions inside a context
class Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
-- apply a wrapped function
> pure (+) <*> Just 3 <*> Just 4
Just 7
> Just (+1) <*> Just 5
Just 6
-- for lists, <*> is the Cartesian product
> [(+1), (*2)] <*> [1,2,3]
[2,3,4,2,4,6]putStr/putChar
異なる出力関数
-- Monad: sequential, dependent computations
class Monad m where
return :: a -> m a
(>>=) :: m a -> (a -> m b) -> m b -- bind
-- bind chains dependent computations
> Just 3 >>= \x -> Just (x+1)
Just 4
> Nothing >>= \x -> Just (x+1)
Nothing
-- '>>' ignores the left result
> putStrLn "a" >> putStrLn "b"
a
bインタラクション
getLine は1行の入力を読み取ります
-- do notation
greet = do
name <- getLine
putStrLn ("Hi " ++ name)
-- desugars to bind
greet' = getLine >>= \name ->
putStrLn ("Hi " ++ name)
-- 'let' becomes a regular binding
compute = do
let x = 5
print (x * x)
-- desugars to:
compute' = let x = 5 in print (x*x)Maybe モナドのチェーン
Maybe の Monad は短絡します。1 ステップでも Nothing を返すと、追加の作業なしに全体が Nothing になります。do が手動の Nothing チェックを隠し、失敗の伝播が自動できれいになります。
-- short-circuit on Nothing
safeDiv :: Double -> Double -> Maybe Double
safeDiv _ 0 = Nothing
safeDiv x y = Just (x / y)
-- chain with do (auto-propagates failure)
calc = do
a <- safeDiv 10 2
b <- safeDiv a 2
return (b + 1)
> calc
Just 3.5
-- any Nothing stops the whole chain
> safeDiv 10 0 >>= \a -> safeDiv a 2
Nothingリストモナド
リストモナドは非決定性をモデル化します。各 bind がすべての可能性を探索し、デカルト積を生成します。リスト上の do はリスト内包表記と等価です。内包表記とモナドのスタイルが統一されます。
-- list bind = non-deterministic computation
> [1,2] >>= \x -> [x, x*10]
[1,10,2,20]
-- do over lists == list comprehension
pairs = do
x <- [1,2]
y <- ['a','b']
return (x, y)
> pairs
[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
-- equivalent comprehension
> [(x,y) | x <- [1,2], y <- ['a','b']]do 記法
基本的な do
do 構文糖衣が Monad 操作を簡素化します
-- 'type' creates a synonym (not a new type)
type String = [Char]
type PhoneNumber = String
type Name = String
-- improves readability of signatures
printEntry :: Name -> PhoneNumber -> IO ()
printEntry name num = putStrLn (name ++ ": " ++ num)do 内の let
do 内の let には in が不要です
-- newtype: one constructor, one field, zero cost
newtype Dollars = Dollars Double
newtype Count = Count Int
-- pattern match or unwrap the field
addDollars :: Dollars -> Dollars -> Dollars
addDollars (Dollars a) (Dollars b) = Dollars (a + b)
-- distinct type: can't mix with raw Double
total :: Dollars
total = addDollars (Dollars 10) (Dollars 20)do の脱糖衣
do は >>= の構文糖衣です
-- type: just a synonym (no new type, no safety)
type Score = Int
-- newtype: distinct type, zero cost, one field
newtype Score' = Score' Int
-- data: full ADT, runtime cost,
-- can have multiple constructors/fields
data Score'' = Score'' Int | Bonus Int
-- newtype is strict: exactly one
-- constructor and one field, but a distinct type新しいインスタンスのための newtype
newtype は、同じ基底型に異なる型クラスのインスタンスを付けられます。Sum と Product は同じ数を包みますが、Monoid インスタンスが違います(加法と乗法)。よくある強力なパターンです。
-- wrap to attach different typeclass instances
newtype Sum a = Sum { getSum :: a }
instance Num a => Monoid (Sum a) where
mempty = Sum 0
Sum a `mappend` Sum b = Sum (a + b)
newtype Product a = Product { getProduct :: a }
-- different Monoid: multiplication
-- same underlying type, different behavior
> getSum (Sum 3 <> Sum 4)
7
> getProduct (Product 3 <> Product 4)
12パラメータ化されたシノニム
型シノニムはパラメータを取れ、軽量な抽象化として働きます。AssocList k v は [(k,v)] で、シグネチャが自己文書化されます。明確さのために使えますが、型安全性のない単なるエイリアスだと覚えておきましょう。
-- type synonyms can take parameters
type AssocList k v = [(k, v)]
-- used in signatures (self-documenting)
lookup :: Eq k => k -> AssocList k v -> Maybe v
lookup _ [] = Nothing
lookup k ((k',v):rest)
| k == k' = Just v
| otherwise = lookup k rest
-- more examples
type Parser a = String -> Maybe (a, String)
type Matrix a = [[a]]