関数型プログラミング Ch5 関数

関数

Haskellは関数型言語なので,関数の記述がプログラミングにおける花形です. この章ではHaskellの関数に関する記法を学びましょう.

関数と演算子

関数型言語では関数を組み合わせてプログラムを書きます. 関数の正確な定義は後に譲るとして,ここでは取り敢えず｢特定のデータ型の値を受け取って,特定のデータ型の値を返すもの｣という定義にしましょう.このとき受け取る値を引数,返す値を返り値といいます.

Haskellでは,数学の記法と非常に近い方法で関数を定義します. 例えば,

f : \mathbb{Z} \rightarrow \mathbb{Z} \\ f(x) = x + 1

という,整数xを受け取って整数x + 1を返すだけの関数について考えましょう.

Haskellでは上の関数は以下のように定義されます.

f :: Int -> Int
f x = x + 1

main = do
    print $ f 4 --  5

()の代わりにスペースを使う点以外は全く同じ書き方で, =の左側に関数名と引数,右側に返り値を書きます. 関数名は小文字の英字で始めるというルールがあります.

f :: Int -> Intは型注釈であり,このfという関数が,引数にIntを取り,返り値としてIntを返すということを指定しています. 型注釈は高度な処理をしない限り省略しても自動的にGHCが推論してくれますが,可読性のためにもできるだけ書くようにしましょう.

do以下の記述で, f 4の結果を確認しています. printは,文字列に変換可能な値を受け取り,標準出力する関数です. また (f 4)を省略して$ f 4 としています.

引数は何個でも利用できます. 例えば2引数関数

multiple(x,y) = x * y

は以下のように定義できます.

multiple :: Double -> Double -> Double
multiple x y = x * y

main = do
    print $ multiple 3 4 --  12.0

また,以下の記号を組み合わせて中置演算子名として利用することも可能です.

(.*) :: Double -> Double -> Double
x .* y = x * y

main = do
    print $ 3 .* 4 --  12.0

絵文字などのUnicode記号も利用することができます.

(✖) :: Double -> Double -> Double
x ✖ y = x * y

main = do
    print $ 3 ✖ 4 --  12.0

記号を利用して関数を定義する場合には,定義時に() で囲うことで一般の関数のように定義することができます. 例えば, 乗算を新たに定義するとして,以下のように書くことができます.

(.*) :: Int -> Int -> Int
(.*) x y = x * y
main = do
    print $ 3 .* 4 --  12

前置の2引数関数も`` (バッククオート)で囲むことで中置演算子として定義することができます.

x `multiple` y = x * y

main = do
    print $ 3 `multiple` 4 --  12

-- 実行例
main :: IO ()
main = do
    print $ double 7        -- 14
    print $ f 2 3           -- 11
    print $ 4 .+ 5          -- 10
    print $ 10 `divide` 3   -- 3.3333333333333335

double :: Int -> Int
double x = 2 * x

f :: Int -> Int -> Int
f x y = x * y + x + y

(.+) :: Int -> Int -> Int
x .+ y = x + y + 1

divide :: Double -> Double -> Double
divide x y = x / y

main :: IO ()
main = do
    print $ double 7        -- 14
    print $ f 2 3           -- 11
    print $ 4 .+ 5          -- 10
    print $ 10 `divide` 3   -- 3.3333333333333335

結合性

先に述べたように異なる複数の演算子が連なっている式は, 演算子の優先順位に従って計算される順位が変わります.

例えば,* の優先順位は7で, + の優先順位は6なので,2 * 3 + 3 という式は,

   2 * 3  + 3
= (2 * 3) + 3
= 6 + 3
= 9

と言う風に*が優先して計算されます.

では,同じ演算子が複数回連なっている場合にはどのような順序で計算されるのでしょうか? このルールを決めるのが 結合性(Associativity) です.

ユーザーが作成した演算子の結合性を指定するには,右,左,非の順にinfixr,infixl,infix宣言を利用します. いずれも, infix(r/l/なし) 優先順位 記号 の順に書きます.

例えば先程作成した,.* を右結合の優先順位7で指定するには,以下のように書きます.

x .* y = x * y
infixr 7 .*

(.+) :: Int -> Int -> Int
x .+ y = x + y
infixr 5 .+

main :: IO ()
main = do
    print $ 1 .+ 2 .+ 3   -- 6

-- 4 つの演算子を一つのスクリプトに同居させ, 同じ実行で両方の挙動を確認できる
(.+) :: Int -> Int -> Int
x .+ y = x + y
infixl 6 .+

(.*) :: Int -> Int -> Int
x .* y = x * y + 1
infixl 7 .*

(+.) :: Int -> Int -> Int
x +. y = x + y
infixl 7 +.

(*.) :: Int -> Int -> Int
x *. y = x * y + 1
infixl 6 *.

main :: IO ()
main = do
    print $ 2 .+ 3 .* 4   -- 15 (= 2 .+ (3 .* 4))
    print $ 2 +. 3 *. 4   -- 21 (= (2 +. 3) *. 4)

カリー化,部分適用

Haskellでは多引数関数を実装できることは先程確認しました. しかし,Haskellはすべての関数が,引数を一つだけとるという原則があります. これは,矛盾するようですが,この矛盾を解消する概念が カリー化(Currying) です.

カリー化とは複数引数関数に対して,｢一つの引数を取り,次に残りの引数を取る関数を返すようにする変換｣です.

例として,以下のxとyを受け取りその和を返す関数addは

add :: Int -> Int -> Int
add x y = x + y

実際には

add :: Int -> (Int -> Int)

として機能しています. 関数の呼び出しは左結合なので,

add 5 10 = (add 5) 10 であり, ここで(add 5) :: Int -> Intという新たな関数に10が適用されています(以下は型の確認のためにghciを利用しています.)

ghci> :{
ghci| add :: Int -> Int -> Int
ghci| add x y = x + y
ghci| :}
ghci> :t add
add :: Int -> Int -> Int
ghci> :t (add 5)
(add 5) :: Int -> Int

Haskellでは,標準で全ての関数がカリー化されており,これによって関数の複数の引数のうち一部だけを与えて,残りの引数を持つ関数を生成する部分適用(Partial Application)が可能となっています.

-- add関数を利用した部分適用
add5 :: Int -> Int
add5 = add 5

-- 実際の利用例
result = add5 10

分岐

関数型言語において,手続き型言語におけるIF文に相当するのがパターンマッチと指示関数(特性関数)です.

パターンマッチ

パターンマッチに近い概念は既にフィボナッチ数の漸化式として出てきています.フィボナッチ数の漸化式は,以下のように表されます.

この関数はPythonでは,以下のようにif文による分岐で記述されるのが一般的です.

def fib(x):
    if x == 0:
        return 1
    elif x == 1:
        return 1
    else:
        return fib(x-1) + fib(x-2)

これをHaskellでパターンマッチを利用して以下のように定義することができます.

fib :: Int -> Int
fib 0 = 1
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)

このHaskellのコードは,

• 関数fibの引数が0のときには返り値として1を返し,

• 関数fibの引数が1のときには返り値として1を返し,

• 関数fibの引数がそれ以外のときには返り値としてfib (n - 1) + fib (n - 2)を返します.

この最後のfib n = fib (n - 1) + fib (n - 2)は再帰関数といって後ほど扱いますが,取り敢えず,特定の引数に対して特定の返り値を指定するこのような関数の記述方法をパターンマッチといいます.

パターンマッチは,数値以外の引数に関しても適用可能であり,リストではリストの要素数に応じて使い分けることが多いです.

以下の,strHead関数は,リストの先頭の要素を文字列として表示する関数です.リストが空のときには"Empty",要素が一つのときにはその要素,それ以外のときには先頭の要素を文字列にして返します.

showの詳細は後ほど扱いますが,どの様に標準出力に表示するかを定めてあるデータ型を文字列に変換する関数です.

strHead :: Show a => [a] -> String
strHead []    = "Empty"
strHead [x]   = show x
strHead (x:_) = show x

main = do
    print $ strHead [] --  "Empty"
    print $ strHead [3,4] --  "3"

パターンマッチはこのようにリストx:xsの先頭部分xを指定するなどの利用法が可能です. 値の特定の部分を取得する用法として頻出なのがタプルを引数に取るパターンマッチです.

以下のコードは,3つ組のタプル(x,y,z)から指定した位置の値を取り出す関数getFromTupleです.

getFromTuple (x,y,z) 0 = x
getFromTuple (x,y,z) 1 = y
getFromTuple (x,y,z) 2 = z

このような用法は後に紹介する代数的データ型を扱う際にも頻出します.

ガード

数式における分岐は,指示関数を用いて行うこともできます.

Haskellにおいて指示関数の記法に相当するのがガードです.

fib :: Int -> Int
fib n | n == 0    = 1
      | n == 1    = 1
      | n >= 2    = fib (n-1) + fib (n-2)
      | otherwise = error "fib: negative input"

main = do
    print $ fib 5 --  8

特徴関数におけるifの位置が先に来ている以外は,基本的に対応関係にあるのがわかるかと思います. なお, 上のガードでは負の整数が来た場合に備えて otherwise で error を投げています. これは次節でも扱う通り「どのガードにも該当しない値」が来た場合に Non-exhaustive guards で落ちるのを防ぐためのフォールバックです.

otherwise

ガードの最後の分岐には, 慣例的に otherwise を置きます. otherwise は Prelude で次のように定義されている単なる True の別名であり, 必ず真と評価されるため「それまでのどのガードにも当てはまらなかった場合」のフォールバックとして機能します.

otherwise :: Bool
otherwise = True

簡単な事例として, 整数の符号を文字列で返す関数 sign を考えます.

sign :: Int -> String
sign n | n > 0     = "正"
       | n < 0     = "負"
       | otherwise = "零"

main = do
    print $ sign 5     -- "正"
    print $ sign (-3)  -- "負"
    print $ sign 0     -- "零"

n > 0 も n < 0 も成立しない場合(つまり n == 0 のとき)に otherwise の分岐が選ばれます. もちろん | n == 0 = "零" と書いても等価ですが, otherwise を用いることで「残り全て」を網羅していることが明示されます.

最後の otherwise を書き忘れて, かつどのガードにも該当しない値が渡された場合は Non-exhaustive guards in function ... という実行時エラーが発生するので注意してください.

case式

パターンマッチをインデントブロックで実現する手法としてcase式があります. パターンマッチで判定する変数をcase 変数 of のあとに指定して, それぞれのパターンとその結果を->でつなげる記法です. 指定のパターンに当てはまらないものすべて(これをワイルドカードといいます)を指定するために_を利用します.

fib :: Int -> Int
fib n = case n of
        0 -> 1
        1 -> 1
        _ -> fib (n-1) + fib (n-2)

main = do
    print $ fib 5 --  8

ワイルドカードはどのような値に対しても同じ値を返す関数を実装する場合などにも利用されます.

return10 :: a -> Int
return10 _ = 10

if式

Haskellにはifも存在します. if 条件に当てはまる場合の返り値をthenで指定します. else if で条件を追加し, elseでそれ以外のパターンを指定します. Pythonなどのif文と異なり,式なのでelseの場合の返り値も必ず指定する必要があります.

fib :: Int -> Int
fib n = if n == 0 then 1
        else if n == 1 then 1
        else fib (n-1) + fib (n-2)

main = do
    print $ fib 5 --  8

Haskellではあまりif式は利用されませんが, 1行で書けるため,式の中で部分的に利用する場合に便利です.

fib :: Int -> Int
fib n = if n == 0 then 1 else if n == 1 then 1 else fib (n-1) + fib (n-2)

describe 0   -- "zero"
describe 1   -- "one"
describe 2   -- "two"
describe 3   -- "many"
describe 10  -- "many"

describe :: Int -> String
describe 0 = "zero"
describe 1 = "one"
describe 2 = "two"
describe _ = "many"

describe :: Int -> String
describe n
  | n == 0    = "zero"
  | n == 1    = "one"
  | n == 2    = "two"
  | otherwise = "many"

describe :: Int -> String
describe n = case n of
    0 -> "zero"
    1 -> "one"
    2 -> "two"
    _ -> "many"

describe :: Int -> String
describe n = if n == 0 then "zero"
             else if n == 1 then "one"
             else if n == 2 then "two"
             else "many"

main :: IO ()
main = do
    putStrLn $ describe 0   -- "zero"
    putStrLn $ describe 1   -- "one"
    putStrLn $ describe 2   -- "two"
    putStrLn $ describe 3   -- "many"
    putStrLn $ describe 10  -- "many"

-- 入力を 2 倍した値で分岐したい
-- case式なら, 計算した値 (m) に対してその場で分岐できる
classify :: Int -> String
classify n =
    let m = n * 2
    in case m of
        0 -> "zero"
        2 -> "two"
        _ -> "other"

main = do
    print $ classify 0   -- "zero"
    print $ classify 1   -- "two"   (1 * 2 = 2)
    print $ classify 5   -- "other"

式と文

ここまでで関数定義・演算子・分岐といった基本的な構文を一通り見てきました. ここで Haskell を理解する上で重要な 式(Expression) と 文(Statement) という考え方を整理しておきましょう.

式・文とは

Python や C などの手続き型言語では, プログラムを構成する要素は大きく 文 と 式 の2つに分けられます.

• 文(Statement): ｢実行される｣命令であり, それ自体は値を持ちません. 代入 x = 1, if 文, for 文, return 文などが該当します.

• 式(Expression): ｢評価される｣ことで値になるものです. 1 + 2 や f(x), x > 0 などが該当します.

例えば Python では if は文なので, 以下のように if の結果を直接変数に束縛することはできません.

# これは文法エラー
y = if x > 0: 1 else: 0

値が欲しい場合には, 三項演算子という別の式を使う必要があります.

y = 1 if x > 0 else 0   # こちらは式なので OK

このように手続き型言語では ｢文｣ と ｢式｣ が区別され, 場所によって書けるものが決まっています.

全てが式

一方で Haskell には 文が存在せず, プログラムを構成する要素は全て式です. つまり, あらゆる構文要素が ｢評価されると値になる｣ という性質を持っています.

例えば, 先程の ### if式 で扱った if も Haskell では 式 です. これが ｢else を省略できない｣ と述べた理由です. if が必ず値を返さなければならない以上, 条件が偽のときに返す値も必要だからです. このことを利用すると, if を値が必要な場所にそのまま埋め込むことができます.

-- if は式なので, 値が必要な場所にそのまま書ける
absPlus1 :: Int -> Int
absPlus1 x = (if x >= 0 then x else -x) + 1

main = do
    print $ absPlus1 3    -- 4
    print $ absPlus1 (-5) -- 6

同じく先程扱った case式 も式であり, このあと扱う let式 や次章で扱うラムダ式なども全て値を持つ式です. ｢全てが式である｣ という性質は, 小さな式を組み合わせてより大きな式を作るという関数型プログラミングの基本的な発想につながっています.

関数と式の違い

ここまで ｢関数｣ と ｢式｣ という言葉を使ってきましたが, この2つは対立する概念ではありません. 両者の関係を整理しておきましょう.

• 式 とは, ｢評価すると 値 になるもの｣ でした.
• 関数 とは, ｢引数を受け取って値を返す｣ という 値の一種 です.

つまり関数は式と並ぶ別物ではなく, 式を評価して得られる値のうちの一種 が関数なのです. Haskell では関数も整数や文字列と同じく値として扱える 第一級の値(first-class value) であり, 変数に束縛したり, 他の関数に渡したり (高階関数), 返り値にしたり (カリー化) できます.

このことは, 先程の ## カリー化,部分適用 で見た add を例にすると分かりやすくなります.

add :: Int -> Int -> Int
add x y = x + y

このとき, 次の3つはいずれも 式 であり, 評価するとそれぞれ 値 になります.

• add … 評価すると ｢2引数を待つ関数｣ という 値 (型 Int -> Int -> Int).
• add 5 … 評価すると ｢残り1引数を待つ関数｣ という 値 (型 Int -> Int, 部分適用).
• add 5 10 … 評価すると ｢15｣ という 値 (型 Int).

このように, 関数名そのものを書いた add も式 (値は関数), 関数に引数を与えた add 5 10 も式 (値は整数) です. 違いは 評価した結果の値が ｢関数｣ か ｢関数以外 (整数など)｣ か という点だけで, ｢式である｣ ことに変わりはありません.

整理すると, 関数は ｢式が表しうる値の一種｣ であり, 関数を引数に適用する ｢関数適用｣ もまた一つの式 だ, という入れ子の関係になっています. この視点は, 次章で扱う高階関数やラムダ式を理解する際の土台になります.

式の種類

ここまでに登場した式を整理すると, 主に以下のような種類があります.

• リテラル: 1, 'a', "hello", True, [1,2,3], (1,2) のように値そのものを表す式.

• 変数(値の束縛)の参照: x や pi のように, 束縛された値を指す式 (値の束縛については後述の ## 変数(値の束縛) で扱います).

• 関数適用: f x や add 5 10 のように, 関数に引数を与える式.

• 演算子適用: 1 + 2 や 3 .* 4 のように, 中置演算子で値を組み合わせる式.

• 条件分岐の式: 先程扱った if x > 0 then 1 else 0 のような if式 や case式.

• 局所束縛を伴う式: let x = 1 in x + y のような let式 (後述の ### let式 で扱います).

• ラムダ式: \x -> x + 1 のように, その場で関数を作る式 (次章 Ch6 関数(応用編) の ## 無名関数(ラムダ式) で扱います).

これらの式はいずれも評価されると値になるため, 関数の引数や print の対象, あるいは別の式の一部として自由に組み合わせることができます. まだ扱っていない式の詳細は, このあとの節および次章で順に説明していきます.

再帰

Haskellにおいてもfor文に相当する記法は存在しますが,基本的にループは再帰によって実装されます. 再帰とは関数内で自分自身を呼び出すことです. これまで何度も登場していたfibも再帰を利用していましたが, もう少し細かく見てみましょう.

以下のPythonにおけるfor文を事例に考えてみましょう.

def total(xs):
    result = 0
    for x in xs:
        result += x
    return result

これと同値なプログラムをHaskellで記述すると以下のようになります.

total :: [Int] -> Int
total []     = 0
total (x:xs) = x + total xs

main = print $ total [1..10] --  55

このtotal関数は,与えられたリストが空の場合0を返します. 要素が一つ以上あるリストの場合には,先頭の要素xをそれ以降の要素xsの合計に足すという処理を再帰的に行います.

total [1,2,3]における処理の流れを追っていくと以下のようになります.

total [1,2,3]
= 1 + (total [2,3])
= 1 + (2 + (total [3]))
= 1 + 2 + 3 + (total [])
= 1 + 2 + 3 + 0
= 6

再帰の基本は,ループの終了状態をパターンマッチなどで指定して,そこに至るまでの状態の変化を再帰で記述することです. 処理がどのような状態になったら終わるのかを意識して記述しないと永遠に終了しないプログラムになるので注意しましょう.

total では終了状態が ｢空リスト []｣ の1つだけでしたが, 終了状態は複数あっても構いません. 本章で何度も登場している fib も再帰関数の一例です.

fib :: Int -> Int
fib 0 = 1
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)

main = print $ fib 4 --  5

この fib 関数では, 引数が 0 または 1 のとき 1 を返すという 2つの終了状態 をパターンマッチで指定しています. それ以外のとき (n >= 2) には, fib (n - 1) と fib (n - 2) という 2回の再帰呼び出し の結果を足し合わせます.

total が ｢自分自身を1回だけ呼び出す｣ 単純な再帰だったのに対し, fib は ｢自分自身を2回呼び出す｣ 点が異なります. fib 4 における処理の流れを追うと, 呼び出しが木のように枝分かれしていくのがわかります.

fib 4
= fib 3 + fib 2
= (fib 2 + fib 1) + (fib 1 + fib 0)
= ((fib 1 + fib 0) + fib 1) + (fib 1 + fib 0)
= ((1 + 1) + 1) + (1 + 1)
= 3 + 2
= 5

fib (n - 1), fib (n - 2) のように引数が必ず終了状態 (0 や 1) へ向かって小さくなっていくため, この再帰は有限回で停止します. もし fib n = fib (n - 1) + fib (n + 1) のように引数が小さくならない呼び出しを書いてしまうと, 終了状態に到達できず停止しなくなる点に注意してください.

fizzBuzz [1..15]
-- ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]

-- 1. リストの長さを再帰で求める
length2 :: [a] -> Int
length2 []     = 0
length2 (_:xs) = 1 + length2 xs

-- 2. 各要素を FizzBuzz 文字列へ変換
fizzBuzz :: [Int] -> [String]
fizzBuzz []     = []
fizzBuzz (x:xs) = fb x : fizzBuzz xs
  where
    fb n
      | n `mod` 15 == 0 = "FizzBuzz"
      | n `mod`  3 == 0 = "Fizz"
      | n `mod`  5 == 0 = "Buzz"
      | otherwise       = show n

-- 実行例
main :: IO ()
main = do
  print $ length2 [1,2,3,4,5]           -- 5
  print $ length2 "hello"               -- 5
  print $ fizzBuzz [1..15]
  -- ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]

変数(値の束縛)

Pythonなどの言語では,特定の変数に値を代入することができます.例えば,以下の最大値を求めるプログラムでは,変数mに最初の中身はリストの最初の要素が代入された後,次々とより大きな変数が代入されていきます. 変数は名前の通り,次々とその値を変更していきます.

xs = [3,5,2,4,6,7,1]
m  = xs[0]

for x in xs[1:]:
    if x > m:
        m = x
print('max value:',m)

一方でHaskellでは,変数に一度値を割り当てると,その変数の値を後から変更することができません. 変数に値を再代入するという操作が許されていないのです. この性質を不変性 (immutability) といいます. したがって,Haskellでは代入という言葉を使わず束縛といいます. これは,通常の手続き型言語との大きな違いになります.

例えば,以下のように一度値を束縛した変数に新しく変数を代入しようとするとxという変数に複数の宣言をしているというエラーが出ます(ghciでやる場合には,:{ :}を入れる必要があり余計にややこしいですね.すみません).

ghci> :{
ghci| x = 1
ghci| x = 2
ghci| :}

<interactive>:5:1: error:
    Multiple declarations of ‘x’
    Declared at: <interactive>:4:1
                 <interactive>:5:1

これは一見非常に不便なように感じられますが,これによって関数型プログラムでは,プログラムの安全性を高めています.

例えばPythonにおける以下のプログラムについて考えてみましょう.

counter = 0

def count_plus(x):
    global counter
    counter += x
    return counter

print(count_plus(1))  # 出力: 1
print(count_plus(1))  # 出力: 2

このプログラムでは,count_plus()関数に対して同じ引数1を与えているにもかかわらず,関数を呼び出すたびに,グローバル変数counterが変更されて,結果が変わります. 同じ関数を呼び出しても,結果が変わるために関数のみから,関数の挙動を把握することができません.

一方でHaskellでは,常に同じ関数は,同じ入力に対して,同じ返り値を返します. このような特性を参照透過性(Referential Transparency)と呼び,これによってプログラムの挙動を把握しやすくしています.

また,上記のPythonのプログラムは,関数を実行するたびに,関数の外にある,counterという変数の状態が変化しています. このような,関数が実行されることで単に値を返す以外に何らかの｢外部の状態を変化させる｣ことを関数の副作用(Side Effect)といいます. これは言い換えれば,関数の実行によるプログラム全体への影響が,関数以外の外部の状態に依存していることを意味しており,プログラムの挙動を予測することを難しくします.

参照透過性と副作用は相互に結びついた概念ですが,Haskellでは参照透過性を保ち,副作用を排除するようにプログラムが設計されています. このように, ｢参照透過性｣ と ｢副作用の排除｣ の両方を持った関数型言語を 純粋関数型言語 と呼びHaskellの大きな特徴の一つです.

Haskellにおいて,変数への再代入が禁止されていることのメリットは理解していただけたかと思いますが,Haskellにも変数自体はあります.

Haskellにおける変数は主に,トップレベル変数及びローカル変数に大別されます.

トップレベル変数

先程の x=1のように,独立して宣言される変数をトップレベル変数と呼びます. トップレベル変数は,Pythonなどの言語におけるグローバル変数と同様に,スクリプト内のどの場所からでも利用することができます.

x = 1

someFunc :: Int -> Int
someFunc y = x + y

main = do
    print $ someFunc 1 --  2

ローカル変数

手続き型言語においてスコープが制限された変数のように,特定の関数内でのみ参照可能な局所変数として,ローカル変数が存在します. Haskellにおけるローカル変数は, let式,where節の2つのパターンが用意されています(ラムダ式内の引数も見方によってはローカル変数かもしれません.)

let式

関数内で let 宣言 in 式の形式で局所変数を定義できます.

someFunc :: Int -> Int
someFunc y = let x = 1
           in x + y

main = do
    print $ someFunc 1 --  2

この変数xは別の関数内で参照することはできません.

someFunc :: Int -> Int
someFunc y = let x = 1
           in x + y

someFunc2 :: Int -> Int
someFunc2 y = x + y

main = do
    print $ someFunc2 1 --  Variable not in scope: x :: Int

複数の宣言をひとまとめにすることも可能です.

someFunc :: Int -> Int
someFunc z = let x = 1
                 y = 2
           in x + y + z

main = do
    print $ someFunc 1 --  4

where節

数式の直後にインデントをつけてwhere 宣言と書くことでも局所変数や局所関数を定義できます.

someFunc :: Int -> Int
someFunc z = f z
    where
    x = 1
    y = 2
    f z = x + y + z

main = do
    print $ someFunc 1 --  4

練習問題(関数総合)

本章で学んだ パターンマッチ・ガード・再帰・where を組み合わせて解く総合問題です. ここではまだ次章で扱う高階関数やラムダ式は使わず, 基礎的な道具だけで解くことを意識してください.

-- 実行例
main :: IO ()
main = do
    print $ grade 95              -- "A"
    print $ grade 72              -- "C"
    print $ grade 40              -- "F"
    print $ grades [95,82,71,55]  -- ["A","B","C","F"]

-- ガードで点数をランクへ変換
grade :: Int -> String
grade score
  | score >= 90 = "A"
  | score >= 80 = "B"
  | score >= 70 = "C"
  | score >= 60 = "D"
  | otherwise   = "F"

-- 再帰でリストの各要素を変換 (map を使わない)
grades :: [Int] -> [String]
grades []     = []
grades (x:xs) = grade x : grades xs

-- 実行例
main :: IO ()
main = do
    print $ grade 95              -- "A"
    print $ grade 72              -- "C"
    print $ grade 40              -- "F"
    print $ grades [95,82,71,55]  -- ["A","B","C","F"]

-- 実行例
main :: IO ()
main = do
   print $ perceptronOR False False -- False
   print $ perceptronOR True False  -- True
   print $ perceptronOR False True  -- True
   print $ perceptronOR True True   -- True

perceptronOR :: Bool -> Bool -> Bool
perceptronOR x1 x2
  | threshold >= 0 = True
  | otherwise      = False
  where
    g True  = 1
    g False = 0
    threshold = 0.5 * g x1 + 0.5 * g x2 - 0.2

-- 実行例
main :: IO ()
main = do
   print $ perceptronOR False False -- False
   print $ perceptronOR True False  -- True
   print $ perceptronOR False True  -- True
   print $ perceptronOR True True   -- True

エラー修正演習

ここからは本章で扱った 関数定義 に関わる典型エラーを解決する演習です. 関数を書き始めると, fp4 で学んだエラー以外に 関数特有のエラーパターン も頻出します. 実エラーを読み, 原因を答えて修正してください.

-- ch5-7.hs (誤りあり)
f :: Int -> Int
f x = x ++ "!"

main :: IO ()
main = print (f 1)

app/Main.hs:2:7: error: [GHC-83865]
    • Couldn't match expected type ‘Int’ with actual type ‘[Char]’
    • In the expression: x ++ "!"
      In an equation for ‘f’: f x = x ++ "!"
  |
2 | f x = x ++ "!"
  |       ^^^^^^^^

f :: Int -> String
f x = show x ++ "!"        -- "1!"

main = putStrLn (f 1)

f :: Int -> Int
f x = x + 1                 -- 2

main = print (f 1)

-- ch5-8.hs (誤りあり)
add :: Int -> Int -> Int
add x y = x + y

main :: IO ()
main = print (add 5)

app/Main.hs:5:8: error: [GHC-39999]
    • No instance for ‘Show (Int -> Int)’ arising from a use of ‘print’
        (maybe you haven't applied a function to enough arguments?)
    • In the expression: print (add 5)
      In an equation for ‘main’: main = print (add 5)
  |
5 | main = print (add 5)
  |        ^^^^^

add :: Int -> Int -> Int
add x y = x + y

main :: IO ()
main = print (add 5 10)   -- 15

add5 :: Int -> Int
add5 = add 5

main = print (add5 10)    -- 15

-- ch5-9.hs (誤りあり)
describe :: Int -> String
describe 0 = "zero"
describe 1 = "one"

main :: IO ()
main = do
    putStrLn (describe 0)
    putStrLn (describe 2)

zero
ch5-9: app/Main.hs:(2,1)-(3,18): Non-exhaustive patterns in function describe

describe :: Int -> String
describe 0 = "zero"
describe 1 = "one"
describe _ = "many"

main = do
    putStrLn (describe 0)   -- zero
    putStrLn (describe 2)   -- many

describe :: Int -> String
describe n
  | n == 0    = "zero"
  | n == 1    = "one"
  | otherwise = "many"