関数合成

Haskellは、純粋関数型プログラミング言語のひとつです。Haskellでのプログラミングでは関数が中心となります。関数型プログラミング言語では「関数合成」について十分に理解しておくことが大切になります。

関数合成とは、複数の関数を組み合わせて新しい関数を作成する強力な手法です。Haskellでは、この関数合成をする際の便利な演算子として関数合成演算子「.」が用意されています。

この記事では、Haskellの関数合成演算子.の使い方を紹介します。

関数合成演算子.とは

関数合成演算子.の基本的な概念と型シグネチャについて説明していきます。関数合成演算子.の型シグネチャは以下のようになります。

ghci> :t (.)
(.) :: (b -> c) -> (a -> b) -> a -> c

これは、関数合成演算子である.が関数(b->c)と関数(a->b)と引数aを取り、結果cを返すことを示しています。文章にすると少しわかりにくいかもしれませんが、絵にすると以下のようになります。

入力となる引数の型aを型シグネチャが(a->b)である関数Aが受け取り型bに変換します。その後に型シグネチャが(b->c)である関数Bが型bの入力を受け取り、型cの結果に変換するという流れです。この関数を順番に適用していく流れを関数と関数合成演算子を用いることで(B . A)と表現することが可能になります。

基本的な使い方

関数合成演算子.の使い方の例を見てみましょう。例として、文字を大文字に変換して、ASCIIコードに変換するような関数を考えてみます。

import Data.Char

-- 文字列の各文字を大文字に変換後、ASCIIコードに変換する
toUpperAscii :: Char -> Int
toUpperAscii = ord . toUpper

ghci> toUpperAscii 'a'
65

この例では、toUpper関数とord関数を関数合成で合成することで新しくtoUpperAsciiという関数を作成しています。

この例は、概要説明における図で説明した内容に当てはめてみると、関数A=toUpper、関数B=ord、引数a='a'、結果c=65に該当します。絵に当てはめてみると関数合成がどういった動きをしているかをつかんでもらえるのではないかなと思います。

このように既存の関数を組み合わせて新しい関数を簡単に合成して作成できる機能は非常に強力です。

関数合成の利点と注意点

関数合成を利用することの最大の利点は、コードの簡潔性と可読性を高めることができることです。複数の処理を1つの流れで表現できるため、処理の流れが直感的に理解しやすくなります。

例えば、以下の関数はリストの各要素に複数の関数を適用するような場合です。

-- 文字列の各文字を各文字を大文字に変換して、ASCIIコードのリスト変換
stringToUpperAscii :: [Char] -> [Int]
stringToUpperAscii = map (ord . toUpper)

ghci> stringToUpperAscii "haskell"
[72,65,83,75,69,76,76]

関数合成とmap関数をうまく使うことで非常にスマートにコーディングを行うことが可能となります。なお、map関数については「map関数の基本的な使い方」で紹介しているので参考にしてください。

上記のように関数合成は、非常に強力な機能です。ただし、過度に使用すると逆にコードが読みにくくなってしまうことがあります。特に合成する関数が多くなるほど、どの関数が何をしているのかが一見して分かりにくいということもあります。このため、適切なコメントや適切な関数の命名が重要になってきます。

まとめ

Haskellの関数合成演算子.の使い方を解説しました。

関数合成は、複数の関数を組み合わせて新しい関数を作成する強力な手法です。Haskellでは、この関数合成をする際の便利な演算子として関数合成演算子「.」が用意されています。

この記事では、Haskellの関数合成演算子.の使い方を簡単な例を用いて説明しました。関数合成演算子.を使用することで、コードの簡潔性を保ちつつ、複数の関数を効率的に組み合わせることができるようになります。

この記事で紹介した技術を活用し、よりクリーンで効率的なコードを書けるようになってもらえたらと思います。

Haskell入門純粋関数型言語であるHaskellの入門編となる記事についてまとめます。Haskellで基本となる項目を中心に解説しているページへのリンク集です。...

関数適用

Haskellは、純粋関数型プログラミング言語のひとつです。Haskellでのプログラミングでは関数が中心となるため、関数を適用するのに便利な機能が用意されています。

関数適用とは、簡単に言うと関数に引数を渡して実行することです。Haskellでは、この関数適用をする際の便利な演算子として関数適用演算子「$」が用意されています。

この記事では、Haskellの関数適用演算子$の使い方を紹介します。

関数適用演算子$とは

ここでは、Haskellにおける関数適用演算子$の基本的な概念とその型シグネチャについて詳しく説明します。Haskellでは、通常の関数適用（つまりは関数に引数を適用すること）は空白を使って表されます。例えば、以下のような形です。

result = f a

上記は、関数fに引数aを適用して結果をresultに取得します。しかし、この方法では、複数の関数を適用する場合に、括弧を多用する必要があります。ここで、関数適用演算子$が役に立ちます。

$は、右結合の関数適用演算子で、括弧を使わずに関数適用を表現できます。$の型シグネチャは以下の通りです。

ghci> :t ($)
($) :: (a -> b) -> a -> b

これは、$が関数(a -> b)とその引数aを取り、結果bを返すことを示しています。実際の動きとしては、$はただの関数適用を行いますが、最も低い優先順位を持つため、通常のスペースによる関数適用よりも後に評価されます。

例を挙げてみると以下の2つの式は等価となります。

-- 括弧を使って表現
f (g (h x))

-- 関数適用演算子$を使って表現
f $ g $ h x

上記のように複数の関数を順次適用していくような場合に、関数適用演算子$を使うことによって括弧を削減することができ、コードを読みやすく、書きやすくすることができます。

基本的な使い方

関数適用演算子$の使い方の例を見てみましょう。以下の2つの式は同じ結果6.0となります。

-- 括弧を使って表現
result1 :: Double
result1 = (+) 1 (sqrt (3^2 + 4^2))

-- 関数適用演算子$を使って表現
result2 :: Double
result2 = (+) 1 $ sqrt $ 3^2 + 4^2

まず、括弧を使用したresult1の例では、sqrt (3^2 + 4^2) を先に計算し、その結果に1 を加えるために括弧を使っています。括弧は、sqrt関数に3^2 + 4^2の計算結果を適用し、その結果を(+)関数の第2引数として使用するために必要です。

一方で、関数適用演算子を使用したresult2の例では、関数適用演算子$を使用しています。$はその右側の式を最初に評価し（この場合は sqrt $ 3^2 + 4^2）、その結果を左側の関数に適用します。

ここでの$の利点は、括弧を排除してコードをより読みやすくできる点です。$の使用により「3^2 + 4^2」が最初に計算され、その結果が「sqrt」に適用され、最後に「1を加える (+)関数」にその結果が適用されます。右から順に式を読んでいくと関数の適用の流れを簡単に理解することができます。

どちらもHaskellでは有効な式であるため、異なるスタイルを示しているにすぎませんが、Haskellのコミュニティでは、コードの可読性と簡潔性を高めるために、不必要な括弧の使用を避けるスタイルが好まれます。

しかし、可読性を維持することが最優先されるべきであり、場合によってはコードの意図を明確にするために括弧を使った方がよいという場合もあります。例えば、複雑な式の一部を明示的にグループ化する場合や演算子の優先順位に混乱が生じるような場合には、括弧を使用して明確にすることが推奨されます。

結局のところ、これらのスタイルの適用には適切なバランスが必要です。コードの明瞭さ、維持管理の容易さ、そしてチーム内での一貫性を保つことを意識して使用してください。

まとめ

Haskellの関数適用演算子$の使い方を解説しました。

Haskellでは、関数適用をする際の便利な演算子として関数適用演算子「$」が用意されています。$を使用することで不必要な括弧を用いないで簡潔に関数の適用を行うことができます。

Haskellでは、簡潔なコードが好まれるため$を使用した関数適用したスタイルは好まれますが、場合によっては括弧による関数適用の方がコードの可読性が高くなる可能性があります。

コードの明瞭さ、維持管理の容易さ、そしてチーム内での一貫性を保つことを意識して使用するように注意してみてください。

Haskell入門純粋関数型言語であるHaskellの入門編となる記事についてまとめます。Haskellで基本となる項目を中心に解説しているページへのリンク集です。...

カリー化と部分適用

高階関数とは、引数に関数を受けとったり、返り値として関数を返却できる関数のことを言います。高階関数は、Haskellのような関数型プログラミング言語では必要不可欠なものとなっています。

高階関数について、理解するために覚えておくべき内容として「カリー化(Currying)」と「部分適用 (Partial Application)」という考え方があります。

この記事では、カリー化と部分適用について説明します。

カリー化 (currying)

Haskellは、純粋関数型のプログラミング言語であるため、実装の中心は関数となります。Haskellの関数の基本は「関数の基本」でまとめているので参考にしてください。

この記事で、伝えたいHaskellの関数における重要なポイントの1つは以下になります。

しかし、皆さんが関数を作成する際には、複数の引数をとる関数を作成してきたと思います。これはどういうことでしょうか。実際にはHaskellの関数は「カリー化 (Currying)」された関数だったのです。カリー化について理解できると上記の引数を1つだけとるの意味を理解することができます。

簡単な例を使って理解していきましょう。例として以下のような2つの整数を加算するような簡単な関数を考えてみましょう。

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

次の2つの呼び出し方は、結果としては同じになります。

ghci> add 1 2
3
ghci> (add 1) 2
3

addの型シグネチャは、「Int -> Int -> Int」ですが、これは「Int -> (Int -> Int)」と書くことができます。後者の記載では「Int」を1つ引数にとって、「(Int -> Int)」つまりは Intを受け取ってIntを返す関数を返却すると読むことができます。

つまり、「add 1 2」というのは、実際には2つのステップを踏みます。

1. add 1が評価されて1を加算するような関数が返却されます。この関数は引数を1つ受け取る関数です。
2. ステップ1で返却された関数の引数に2を適用して、結果の3を返却する。

これは引数が3つ、4つ、…と増えていっても同じです。1つ引数が適用されて関数が返却され、次の引数が適用されてまた関数が返却されるというのが繰り返されます。このような関数をカリー化された関数といいます。

「Haskellのすべての関数は、引数を1つだけ取る」の意味はご理解いただけたでしょうか。では、これは何がうれしいのでしょうか。それが以降で説明する部分適用になります。

部分適用 (Partial Application)

部分適用 (Partial Application)は、関数にその関数がとる引数の一部だけを提供し、残りの引数を受け取るような新しい関数を生成することを言います。

先ほども見てきたadd関数を使って、部分適用の例を見てみましょう。

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

-- 2を足し算する関数
add2 = add 2

-- 3を足し算する関数
add3 = add 3

【実行結果例】
ghci> add2 3
5
ghci> add3 3
6

上記の例では、add関数の引数xのみ値を渡して新しい関数を作成しています。先ほどカリー化でも見てきたように1つの引数だけ与えた場合には、返却値は関数となっているので、その関数に新しく名前(add2やadd3)を付けて使うことができます。

部分適用の利点は、既存の関数の再利用性とモジュール性を高めることができる点にあります。

カリー化と部分適用の違い

上記で「カリー化」と「部分適用」について説明してきましたが、これらはよく混同されがちです。しかし、これらは明確に異なる概念です。

カリー化は、複数の引数をとる関数を引数を1つだけ取る関数の連鎖に変換するプロセスのこと自体を指します。一方で、部分適用は、複数の引数をとる関数の一部に引数を渡して新しい関数を生成することです。

これらは、明確に異なった概念ですので区別して理解してください。

まとめ

Haskellにおいて高階関数を理解するために重要となる「カリー化(Currying)」と「部分適用 (Partial Application)」について解説しました。

カリー化は、複数の引数をとる関数を、引数を1つだけ取る関数の連鎖に変換するプロセスのことです。部分適用は、複数の引数をとる関数の一部に引数を渡して新しい関数を生成することでカリー化と関連しています。

この記事では、カリー化と部分適用について、簡単な例を使いながら紹介しました。これらの概念は、理解していなくてもプログラムすることはできるのですが、純粋関数型プログラミング言語であるHaskellの理解を深めるのに非常に重要なので、ぜひ理解していただきたいと思います。

Haskell入門純粋関数型言語であるHaskellの入門編となる記事についてまとめます。Haskellで基本となる項目を中心に解説しているページへのリンク集です。...

畳み込み関数 (foldl, foldr)

畳み込みとは、適用する関数、初期値、畳み込み可能な型のデータ(例えばリスト)を受け取って単一の値にする計算のことを言います。Haskellでは、畳み込み関数の代表的なものとしてfoldl関数とfoldr関数があります。

これらの関数において、lは「left」、rは「right」を表しており、foldlは左畳み込み、foldrは右畳み込みと言います。これらは左から値を畳み込んでいくのか、右から値を畳み込んでいくのかの違いがあります。

foldl関数やfoldr関数のように引数に関数を受け取る関数は、高階関数と言います。高階関数の概要については「高階関数の基本」でまとめているので参考にしてください。畳み込み関数(foldl, foldr)は、高階関数の中でも代表的な関数であり、関数型プログラミングにおいて中心的な関数の一つです。他のプログラミング言語では、reduceという関数名の場合もあります。

この記事では、畳み込み計算をするためのfoldl関数とfoldr関数の使い方を解説します。

foldl関数の基本的な使い方

foldl関数は、Haskellにおいてリスト等のFoldableな型を畳み込むために使用します。「l」は「left」を表しており、左畳み込みとも言われます。

foldl関数の型シグネチャは以下のようになっています。

foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

foldl関数は、以下の3つの引数を取ります。

1. 関数 (b -> a -> b)：リストの各要素と累積値に適用され、新しい累積値を生成します。例えば、(+)は2つの数を受け取り、その和を返す2項関数です。
2. 初期値 b：畳み込みを開始するための値です。例えば、数値リストを畳み込む場合の初期値として0がよく使用されます。
3. 畳み込まれるリスト t a：Foldable型クラスのインスタンスであり、畳み込み対象となるデータです。例えば、Intのリスト([Int])等が該当します。

ここで、Foldableというのは型クラスを表しています。tはFoldable型クラスのインスタンスである必要があります。今回は簡単のためFoldableのインスタンスであるリストを使った例を紹介しますが、他の型でもfoldl関数は使用できます。他のFoldable型クラスのインスタンスである型としてはTree型やMaybe型などが該当します。

foldl関数の使用例

数値の畳み込み

foldl関数を使用して、数値のリストを畳み込む場合には以下のようにします。

-- 数値の畳み込み
plusFoldl :: [Int] -> Int
plusFoldl xs = foldl (+) 0 xs

【実行結果例】
ghci> plusFoldl [1, 2, 3, 4, 5]
15

上記で定義したplusFoldl関数は、foldlを使用してリストxsの中の全ての数値を左から順に加算(+)し、その合計値を返します。左から順に足しこんでいく基準の初期値は0となります。実行結果例をわかる通り[1, 2, 3, 4, 5]を引数に渡すと結果は15となります。

foldl関数の動作を理解する

上記の例を見てfoldl関数がどのような結果となるかは分かったかと思いますが、より関数の動作を理解するには自分で実装するとどうなるかを考えてみることが非常に役に立ちます。

foldl関数は、型シグネチャを見るとわかる通りリスト限定のものではありませんが、リストを前提として左畳み込みを自分で実装してみる場合のmyFoldl関数は以下のように実装することができます。

-- foldlを自分で実装する
myFoldl :: (b -> a -> b) -> b -> [a] -> b
myFoldl f z [] = z
myFoldl f z (x:xs) = myFoldl f (f z x) xs

上記の関数においてfを(+)、zを0、xsを[1, 2, 3, 4, 5]と考えてどのような動きをしているか考えてみましょう。具体的にどのように処理が流れていくかを記載してみると以下のようになります。

myFoldl関数は、再帰的に定義されています。「myFoldl f z (x:xs) = myFoldl f (f z x) xs」の部分に注目してみると、初期値0とリストの先頭要素1に対して引数で与えられた関数(+)を適用し、その結果が次の初期値となっています。このように順に計算をしていくと計算結果の15が得られます。具体的には(((((0 + 1) + 2) + 3) + 4) + 5) = 15のように計算されていることが分かるかと思います。

foldr関数の基本的な使い方

foldr関数も、foldl関数と同様にリスト等のFoldableな型を畳み込むために使用します。「r」は「right」を表しており、右畳み込みとも言われます。

foldr関数の型シグネチャは以下のようになっています。

foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b

foldl関数と非常に似た型シグネチャであることが分かるかと思いますが、違いとしては第1引数で受け取る関数の型が(a -> b -> b)となっていて、aとbが逆転しています。これは、foldr関数がリストの要素を右から畳み込んでいくことを意味しています。

foldr関数の使用例

数値の畳み込み

foldl関数と同じようにfoldr関数を用いて数値の畳み込みをする例を見てみましょう。

-- 数値の畳み込み
plusFoldr :: [Int] -> Int
plusFoldr xs = foldr (+) 0 xs

【実行結果例】
ghci> plusFoldr [1, 2, 3, 4, 5]
15

上記で定義したplusFoldr関数は、foldrを使用してリストxsの中の全ての数値を右から順に加算(+)し、その合計値を返します。右から順に足しこんでいく基準となる初期値は0となります。実行結果例をわかる通り、[1, 2, 3, 4, 5]を引数に渡すと結果は15となります。

foldr関数の動作を理解する

数値を畳み込む例を見てきましたが結果としてはfoldl関数とfoldr関数では同じ結果になりました。しかし、内部的には全く異なる動作をしています。

foldl関数でも見てきたようにfoldr関数についても、自分で実装してみることにしてみましょう。foldr関数をリストに対して実装したmyFoldr関数は以下のようになります。

-- foldrを自分で実装する
myFoldr :: (a -> b -> b) -> b -> [a] -> b
myFoldr _ z [] = z
myFoldr f z (x:xs) = f x (myFoldr f z xs)

上記の関数においてfを(+)、zを0、xsを[1, 2, 3, 4, 5]と考えてどのような動きをしているか考えてみましょう。具体的にどのように処理が流れていくかを記載してみると以下のようになります。

myFoldr関数についても再帰的に定義されています。「myFoldr f z (x:xs) = f x (myFoldr f z xs)」の部分について着目してみると、リストの先頭要素が前に来て、初期値が後ろにスライドし、残りのリストを使って再度myFoldrが適用されていることが分かるかと思います。

このように書き下していくと最終的には「myfoldr (+) 0 []」という形となり、これは「myFoldr _ z [] = z」の定義より初期値z、今回の例では0になります。最終的には、(1 + (2 + (3 + (4 + (5+0)))))のように右から(+)で畳み込まれている計算となっていることが分かるかと思います。

上記で見てきた通りfoldl関数とfoldr関数は、左から畳み込むのか、右から畳み込むのかという点で具体的な動作が異なっています。

foldl関数とfoldr関数の違い

適用する関数による結果の違い

上記まででfoldl関数とfoldr関数を見てきました。足し算(+)を例に見る限りでは、結果は同じでした。しかし、各関数の動作を理解するために動作をステップごとに書いてみましたが「左から畳み込むのか」「右から畳み込むのか」という違いがありました。

例えば、適用する関数として引き算(-)を指定した場合には、以下のように結果が大きく変わります。

-- foldlの場合
minusFoldl :: [Int] -> Int
minusFoldl xs = foldl (-) 0 xs

-- foldrの場合
minusFoldr :: [Int] -> Int
minusFoldr xs = foldr (-) 0 xs

【実行結果例】
ghci> minusFoldl [1, 2, 3, 4, 5]
-15
ghci> minusFoldr [1, 2, 3, 4, 5]
3

上記の例についても具体的に書き下してみると以下のような計算になっていることが分かります。

• minusFoldlの場合：(((((0 - 1) - 2) - 3) - 4) - 5) = -15
• minusFoldrの場合：(1 - (2 - (3 - (4 - (5 - 0))))) = 3

上記のように畳み込む方向が左からから、右からかという違いがあるため、適用する関数によって大きな違いが出ることに注意が必要です。

無限リストに対する挙動の違い

Haskellは遅延評価言語であるため、foldrは無限リストに対しても使用することが可能な場合があります。これは、結果を得るためにリスト全体を評価する必要がないケースで利点となります。

一方で、foldlは基本的にリストの全体を評価しようとするため、無限リストには適していません。無限リストに対してfoldlを適用すると無限ループとなってしまいます。

まとめ

Haskellで畳み込み計算をするためのfoldl関数とfoldr関数の使い方を解説しました。

畳み込みとは、適用する関数、初期値、畳み込み可能な型のデータ(例えばリスト)を受け取って単一の値にする計算のことを言います。foldl関数は左畳み込み、foldr関数は右畳み込みといい、値を畳み込む順序が異なっています。

この記事では、foldl関数とfoldr関数の各関数の概要と基本的な使い方、そして違いについて説明しました。

畳み込み関数(foldl, foldr)は、map関数やfilter関数と同様に関数型プログラミングのHaskellにとっては代表的で重要な関数です。しっかりと動作を理解して使いこなせるようにしていただきたいと思います。

Haskell入門純粋関数型言語であるHaskellの入門編となる記事についてまとめます。Haskellで基本となる項目を中心に解説しているページへのリンク集です。...

filter関数によるデータ抽出

filter関数は、関数とリストを受け取って、リストから特定の条件を満たす要素のみ抽出する関数です。

このように引数に関数を受け取る関数は、高階関数と言います。高階関数の概要については「高階関数の基本」でまとめているので参考にしてください。filter関数は高階関数の中でも代表的な関数であり、関数型プログラミングにおいて中心的な関数の一つです。

本記事では、filter関数を使用してリストから特定の条件を満たす要素のみ抽出する方法を紹介します。

filter関数の基本的な使い方

filter関数の型シグネチャとしては、以下のようになっています。

filter :: (a -> Bool) -> [a] -> [a]

上記の型シグネチャの意味は「(a -> Bool)：a型を引数として受け取り、Boolを返却する関数」と「[a]：a型のリスト」の2つの引数を受け取って、「[a]：a型のリスト」を返却する関数ということを意味しています。

簡単に言うと、filter関数は第1引数で受け取った判定の関数を使用し、第2引数のリストから関数の判定でTrueになる要素のみ抽出したリストを返却します。第1引数で指定する関数は、Boolを返却するような関数である必要があります。

具体的な使用例を見ていただくとイメージがつかめると思いますので、以降でいくつかの使用例を使いながらfilter関数の使い方を説明します。

filter関数の使用例

ここではfilter関数の簡単な使用例を使ってイメージをつかんでもらいたいと思います。以下は説明のための簡単な例です。引数に渡す関数を変更することで様々な抽出ができますので、色々と試してみてください。

特定の数値条件を満たす要素の抽出

特定の数値条件を満たすような抽出の例を見てみましょう。5よりも大きい数値のみ抽出する場合には、filter関数を使用して以下のようにします。

-- 5よりも大きい数値のみ抽出する
valuesOver5 :: [Int]
valuesOver5 = filter (> 5) [1, 4, 7, 2, 8, 9, 3, 10, 5, 6]

【実行結果】
ghci> valuesOver5 
[7,8,9,10,6]

上記では、5より大きいことを判定する関数(> 5)を、受け取ったリストに対して適用して条件に一致(True)する要素を含むリストを返却します。結果としては、5より大きい値のみ含むリストになっていることが分かります。

偶数のみ抽出する

リストから偶数のみ抽出する例を見てみましょう。偶数を抽出する際には、even関数を使用します。

-- 偶数のみ抽出する
valuesEven :: [Int]
valuesEven = filter even [1, 4, 7, 2, 8, 9, 3, 10, 5, 6]

【実行結果】
ghci> valuesEven 
[4,2,8,10,6]

上記のように、Haskellに標準で用意されているeven関数を使っても要素の抽出をすることが可能です。結果を見ると偶数のみ抽出されたリストになっていることが分かります。

文字列のリストから特定の文字を含む要素だけを抽出する

上記では数値の例を見てきましたが、もちろん文字列のリストに対してもフィルタが可能です。例えば、リスト内の文字列から特定の文字を含むものだけを抽出する例を考えます。リスト内に文字を含むかどうかは、elem関数を使用して以下のように指定します。

-- 文字列のリストから特定の文字を含む要素だけを抽出する
strsElemA :: [String]
strsElemA = filter (elem 'a') ["apple", "banana", "cherry", "pine", "orange"]

【実行結果】
ghci> strsElemA 
["apple","banana","orange"]

上記結果では、文字列(String)を含むリストから指定した要素'a'を含むような要素のみを抽出しています。

上記で見てきたようにfilter関数を使用すると、様々なリストから特定の条件に一致した要素を抽出することが可能になります。

まとめ

Haskellでfilter関数を使用してリストから特定の条件を満たす要素のみ抽出する方法を解説しました。

filter関数は、関数とリストを受け取って、リストから特定の条件を満たす要素のみ抽出する関数で、関数型プログラミングにおいて中心的な高階関数の一つです。簡単な例を用いてfilter関数の使用方法を紹介しています。

filter関数は非常に基本的で中心的な高階関数なので、ぜひ使い方をしっかりと覚えてもらいたいと思います。

Haskell入門純粋関数型言語であるHaskellの入門編となる記事についてまとめます。Haskellで基本となる項目を中心に解説しているページへのリンク集です。...

map関数による関数適用

map関数は、関数とリストを受け取って、リストの各要素に関数を適用した結果を返す関数です。

このように引数に関数を受け取る関数は、高階関数と言います。高階関数の概要については「高階関数の基本」でまとめているので参考にしてください。map関数は高階関数の中でも代表的な関数であり、関数型プログラミングにおいて中心的な関数の一つです。

本記事では、map関数を使用してリストの各要素に関数を適用する方法を紹介します。

map関数の基本的な使い方

map関数の型シグネチャとしては、以下のようになっています。

map :: (a -> b) -> [a] -> [b]

上記の型シグネチャの意味は「(a -> b)：a型を引数として受け取り、b型を返却する関数」と「[a]：a型のリスト」の2つの引数を受け取って、「[b]：b型のリスト」を返却する関数ということを意味しています。

簡単に言うと、map関数は第1引数で受け取った関数を第2引数のリストの各要素に適用した結果リストを返却するということになります。具体的な使用例を見ていただくとイメージがつかめると思いますので、以降でいくつかの使用例を使いながらmap関数の使い方を説明します。

map関数の使用例

ここではmap関数の簡単な使用例を使ってイメージをつかんでもらいたいと思います。以下は説明のための簡単な例です。引数に渡す関数を変更することでリストに対して様々な変換をかけることができますので、色々と試してみてください。

すべての要素を2倍にする

リストのすべての要素を2倍にする場合には、map関数を使用して以下のようにします。

-- 全ての要素を2倍にする
doubles :: [Int] -> [Int]
doubles xs = map (*2) xs

【実行結果】
ghci> doubles [1,2,3,4,5]
[2,4,6,8,10]

上記では、2倍する関数(*2)を受け取ったリストの各要素に対して適用します。結果を見ても分かるようにリストの全ての要素が2倍にできていることが分かります。

文字列のリストを大文字にする

リストの文字列を大文字にする場合には、map関数を使用して以下のようにします。ここでは文字(Char)を大文字にするために、Data.CharのtoUpper関数をインポートして使用します。

import Data.Char (toUpper)

-- 文字列のリストを大文字にする
toUpperCase :: [String] -> [String]
toUpperCase strs = map (map toUpper) strs

【実行結果】
ghci> toUpperCase ["hello","world"]
["HELLO","WORLD"]

上記例では、map関数を2回適用していることに注意してください。Stringは、Char型のリストのことで[Char]と同じ意味です。(map toUpper)の部分は「Stringの各文字Charに対してtoUpperを適用する関数」で、外側のmapは受け取ったStringリストの各Stringに対して、(map toUpper)関数を適用するということを意味しています。

リスト内の数値を文字列に変換する

リスト内の数値を文字列に変換する場合には、map関数を使用して以下のようにします。文字列にする場合には、show関数を使用します。

-- リスト内の数値を文字列に変換する
toStrings :: [Int] -> [String]
toStrings nums = map show nums

【実行結果】
ghci> toStrings [1,2,3,4,5]  
["1","2","3","4","5"]

上記では、受け取ったリストの各要素のInt型の数値に対して、show関数をかけることで文字列に変換しています。結果を見ると数値が文字列に変換されていることが分かるかと思います。

まとめ

Haskellでmap関数を使用してリストの各要素に関数を適用する方法を解説しました。

map関数は、関数とリストを受け取って、リストの各要素に関数を適用した結果を返す関数で、関数型プログラミングにおいて中心的な高階関数の一つです。簡単な例を用いてmap関数の使用方法を紹介しています。

map関数は非常に基本的で中心的な高階関数なのでぜひ使い方をしっかりと覚えてもらいたいと思います。

Haskell入門純粋関数型言語であるHaskellの入門編となる記事についてまとめます。Haskellで基本となる項目を中心に解説しているページへのリンク集です。...

型シグネチャと型変数

Haskellは、純粋関数型プログラミング言語のひとつで、強力な型システムを持つ静的型付け言語です。Haskellの強力な型システムでは、プログラムの正確性と安全性を高めており、型についてしっかりと理解してプログラミングに取り組むことが非常に重要です。

Haskellのプログラムにおいて「型シグネチャ」と「型変数」というものは非常に重要な役割を持っており、これらによりコンパイラはプログラム内の一貫性をチェックし、型に関するエラーを早期に発見します。

本記事では、型シグネチャと型変数についての基本を解説します。

変数の型シグネチャ

Haskellでは、変数に対して型シグネチャ(type signatures)を付与することができます。型シグネチャとは変数や関数の型を宣言するためのものです。

例えば、整数値を持つ変数を宣言する場合は、以下のように型シグネチャを使用します。

myNumber :: Int
myNumber = 42

この例では、myNumberという変数は、Int型であることを宣言しています。型シグネチャの宣言では、「::」の後に型を記述します。これにより、myNumberは整数を意味するようになるため、それ以外の値を割り当てるとコンパイルエラーとなります。

関数の型シグネチャ

1引数の関数の型シグネチャ

関数に対しても同様に型シグネチャを定義することが可能です。関数の型シグネチャでは、引数の型と返却値の型を指定します。

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

上記例のdouble関数は、Int型の引数をとり、2をかけたInt型の返却値を返却します。関数の型シグネチャでは、引数の型と返却値の型を「->」でつなぎます。

複数の引数を持つ関数の型シグネチャ

複数の引数を持つ関数の型シグネチャは、慣れるのに少し時間がかかるかもしれません。例で見てみましょう。

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

上記例のadd関数はxとyの二つの引数を取ります。「->」で順番に型が列挙されているのですが、どれが引数の型でどれが戻り値の型かを明確に区別する方法がないのが少し厄介な点です。

一番簡単な覚え方としては「最後の型が常に戻り値の型である」ということです。上記例では、1番目のIntは引数xの型、2番目のIntは引数yの型、そして最後のIntが返却値x+yの型ということになります。

型変数

これまで型シグネチャについてみてきましたが、Haskellで定義されている一般的な型(Int)を用いた例で見てきました。ここで受け取った引数をそのまま返却するようなidentity関数を考えてみましょう。（Haskellには、同じ動作のid関数がありますが、ここではあえて自分で定義します）

identity x = x

このidentity関数の型シグネチャはどう書くと良いでしょうか。引数として与えることができる型は、Int、Double、Charなど様々考えられます。それぞれの型のために「identityInt」「identityDouble」「identityChar」といった関数を個別に定義するのは、非常に大変にも関わらず無意味な作業です。

このような問題を解決するために、Haskellでは型変数(type variables)があります。型変数を使用するとidentity関数の型シグネチャは以下のように記載できます。

identity :: a -> a
identity x = x

ここで「a」が型変数を表します。このaは、IntやDouble、Charなどに置き換えても問題ないことを意味しており、型変数を使うことで任意の型を表すことができます。型変数は、一般的にアルファベットの小文字1文字で表現されます。例えば、a、b、cといったものがよく使用されます。これは型変数を簡潔にし、コードの可読性を高めるためです。

なお、Haskellの文法上は型変数にmyVarのような小文字から始まる文字列を使用することも可能ですが、任意の型を示す変数に名前を付けることに意味はあまりなくコードの可読性が悪くなる可能性があるため、アルファベット1文字を使うのが良いでしょう。

また、型変数は複数使用することも可能です。例えば「func :: a -> b -> a」というような型シグネチャの関数があった場合には、1番目の引数と2番目の引数は異なる型でよいですが、返却値は1番目の引数と同じ型である必要があります。なお、1番目の引数と2番目の引数が同じ型であることは問題ありません。この型シグネチャで求めているのは、1番目の引数と返却値の型が同じであるということです。

上記のように型変数を用いることで、任意の型を表現することができます。ただし、任意の型を許容するため関数内の処理が問題なく動作するかは慎重にプログラミングする必要があります。明確に型を絞って提供したい関数は、型を明示した型シグネチャとして実装するべきでしょう。

型推論

上記で、変数や関数の型の情報を明示する型シグネチャや型変数の記述方法を説明しました。ただし、Haskellは強力な型推論(type inference)の機能を持っています。型推論とは、プログラムの文脈からコンパイラが自動的に変数や関数の型を推論する機能です。

このため、型シグネチャを記載することは実は必須ではありません。しかし、型シグネチャを明示的に記述することには利点があります。特に、複雑な関数や型推論による曖昧さを排除したい場合には、意図した型が使用されることを保証するために、明確に型シグネチャを使用する方が適切です。

また、型シグネチャはそれを見るだけで変数や関数の意図をある程度解釈できるため、プログラムのドキュメントとしても機能します。これによりコードの可読性を高める効果があります。

関数型プログラミングであるHaskellでは、型を基準にプログラミングを行います。そのため、実装する前に必然的に関数の型について考えることになります。型シグネチャを書くことは、Haskellの開発においてとても自然なことです。

まとめ

Haskellの強力な型システムにおいて重要な役割を果たす「型シグネチャ」と「型変数」について基本を解説しました。

Haskellの型シグネチャと型変数は、プログラムの型の安全性と柔軟性を高めるための強力なツールとなっています。型シグネチャにより関数や変数の期待する型を明示的に宣言することでコンパイラは型のミスマッチを効率的に検出できます。

また、型推論についても簡単に触れ、型シグネチャは必須ではないことを説明しました。しかし、型シグネチャはプログラムの品質を高めるために効果があるため、基本的に書くように意識することを推奨します。

型シグネチャや型変数が読めるようになるとHaskellのプログラムがとても理解しやすくなってきます。ぜひ、型シグネチャの基本的なところを理解してほしいと思います。

Haskell入門純粋関数型言語であるHaskellの入門編となる記事についてまとめます。Haskellで基本となる項目を中心に解説しているページへのリンク集です。...

高階関数の基本概念

高階関数（Higher-order functions）は、関数型プログラミング言語における中心的な概念で、プログラミングにおける表現力を大きく高めることができます。

高階関数は、他の関数を引数として受け取るか、または結果として関数を返すことができます。この特徴により、コードの再利用性が向上し、より柔軟なプログラミングが可能になります。

本記事では、高階関数の特徴やHaskellにおける実装例を紹介します。

高階関数の特徴

高階関数は、以下のような特徴を持つ関数です。

高階関数は、上記のような非常に有用な特性を持っているため、Haskellのような関数型プログラミング言語に限らず様々な言語でも取り込まれていっています。例えば、Pythonはマルチパラダイム言語であり、高階関数を使用することが可能です。Pythonのデコレータは、高階関数を用いた仕組みを簡単に利用できるようにする仕組みとして機能しています。

ただし、高階関数は良い側面ばかりとも言えません。高階関数を過度に使用することでコードの読みにくさを引き起こす可能性があったり、デバッグがしにくくなる可能性もある点は理解しておいてください。

高階関数のHaskell実装例

ここでは、Haskellでの実装例を使って高階関数のイメージをつかんでもらおうかと思います。高階関数を実装する際には、関数を受け取るか、または関数を返すようにします。例として、二つの関数を合成する高階関数composeをHaskellで実装してみます。

-- 2つの関数を合成する関数
compose :: (b -> c) -> (a -> b) -> a -> c
compose f g x = f (g x)

上記関数は、関数f、関数gと入力xを受け取って、xにgを適用し、その結果にfを適用するという関数になっています。つまり、数学的に書いてみるとf(g(x))を返す関数です。

では、この関数をうまく使って、5を加算する関数(add5)と2を乗算をする関数(multiply2)を順番に適用するような関数を作ることを考えてみましょう。

-- 5を加算する関数
add5 :: Int -> Int
add5 x = x + 5

-- 2を乗算する関数
multiply2 :: Int -> Int
multiply2 x = x * 2

上記の二つの関数を順番に適用する関数は、composeを使って以下のように定義できます。

-- add5を適用してから、multiply2を適用する関数
add5AndMultiply2 :: Int -> Int
add5AndMultiply2 = compose multiply2 add5

ここで、compose関数は、関数自体を引数に渡すことができるため、引数の部分に「add5」や「multiply2」といった関数を指定することができます。この式は「add5AndMultiply2 x = compose multiply2 add5 x」とも書けますが、Haskellでは、η簡約（eta reduction）でxを省略することができます。

上記の定義は、compose関数が「Int型のxを受け取ってIntの結果を返却するような関数」を返却し、その関数がadd5AndMultiply2に割り当てられていることを意味します。

具体的に使用例を見てもらえるとイメージがつかみやすいかもしれません。ghciというHaskellのインタプリタを使ってadd5AndMultiply2実行した結果は以下の通りです。

ghci> add5AndMultiply2 5
20
ghci> add5AndMultiply2 10
30

上記の結果から、add5AndMultiply2が、5を加算する関数(add5)と2を乗算をする関数(multiply2)を順番に適用するような関数となっていることが分かるかと思います。

このように関数の組み合わせが簡単に実現できてしまいました。これは、関数を引数に取ったり、関数を返却したりできる高階関数のおかげです。

まとめ

関数型プログラミング言語における中心的な概念である高階関数の基本について解説しました。

高階関数は、他の関数を引数として受け取るか、または結果として関数を返すことができ、コードの再利用性や柔軟性を向上させます。今回は、Haskellの簡単な高階関数の実装を通して、高階関数のイメージをつかんでもらいました。

高階関数は、関数型プログラミング言語における中心的な概念で、プログラミングにおける表現力を大きく高めるものです。是非考え方をしっかり理解して使いこなしてもらいたいと思います。

Haskell入門純粋関数型言語であるHaskellの入門編となる記事についてまとめます。Haskellで基本となる項目を中心に解説しているページへのリンク集です。...

ラムダ関数（無名関数）

ラムダ関数とは、関数名がなくても使用できる関数のことです。関数名が不要なことから無名関数とも呼ばれます。

Haskellは、純粋関数型プログラミング言語であり、関数を主体にプログラミングを行っていきます。関数型プログラミングのパラダイムでは、ラムダ関数は中心的な役割を果たします。これは、関数を第一級オブジェクトとして扱い、関数を他の関数に引数として渡したり、返却値として関数を返したりできるためです。Haskellを含む多くの関数型言語では、ラムダ関数を使ってより表現力豊かで柔軟なコードを記述することが可能です。

ラムダ関数を使うことのメリットについては、後述する使い方を見ていただけると分かると思いますが、以下のような点が挙げられます。

• 小さな関数をすべて関数名をつけて定義する必要がない。
• 関数名の衝突を考慮する必要がない。
• 高階関数の引数としても使用できる。
• コードがシンプルになる。

本記事では、Haskellでラムダ関数を実装する方法を例を使いながら説明します。

ラムダ関数の基本

Haskellにおけるラムダ関数は以下のように定義します。

\引数1 引数2 ... -> 式

ラムダ関数は「\ (バックスラッシュ)」で始まり、関数が受け取る引数を列挙します。なお、「\ (バックスラッシュ)」であるのはギリシャ文字のλ (ラムダ)が視覚的に類似していることに由来しています。

受け取った引数を使った式は「->」の右側に記載します。ラムダ関数の例としては、具体的には以下のような例になります。

\x -> 2 * x

ラムダ関数は、通常は高階関数への引数として使用されることが多くなります。ラムダ関数について確認するために、ghci上でその場でラムダ関数を使って使用してみましょう。

ghci> (\x -> 2 * x) 5
10

上記の例では()内で記載した部分がラムダ関数となっています。通常の関数の名称を指定するときと同じで、5をxに受け取り2倍した値を出力しています。

以降でラムダ関数の代表的な使用例を紹介します。

ラムダ関数の使用例

Haskellでは、ラムダ関数を多様な場面で使用できます。よく使用される例について紹介します。

filterとの組み合わせ

Haskellでは、ラムダ関数を使用する際に高階関数と組み合わせることが一般的です。その中でも代表的なものとして、filterという高階関数と組み合わせる例があります。filter関数は、条件に合致するリストの要素を選択します。この関数の型シグネチャは次のようになります。

ghci> :t filter
filter :: (a -> Bool) -> [a] -> [a]

これは、「ある型aの要素を受け取りBoolを返す関数」と「a型のリスト」を受け取り、その条件に合致する「a型のリスト」を返す関数であることを意味しています。

例えば、偶数のみをフィルタリングする場合は以下のように書きます。

ghci> evenNumbers = filter (\x -> x `mod` 2 == 0) [1..10]
ghci> evenNumbers
[2,4,6,8,10]

ここで(\x -> x mod 2 == 0)はラムダ関数で、偶数を判定する関数です。このラムダ関数をfilter関数に適用することで、指定した1~10のリストから偶数のみを抽出できます。

フィルタ条件は、利用場面でよく変わると思いますが、その都度フィルタ関数を名前付きで定義することは非常に負担がかかります。ラムダ関数を用いると、小規模な関数をその場で簡潔に定義でき、コードの柔軟性が高まります。

上記はfilterという代表的な高階関数の例として紹介していますが、もちろん、その他の高階関数に対しても同様に使用できます。

ラムダ関数の適切な利用

ラムダ関数は、Haskellのような関数型プログラミング言語でコードの柔軟性と表現力を高める重要な機能です。ラムダ関数は、一時的な用途や小さな関数を即座に簡潔に記述するのに適しています。ラムダ関数を活用することで、プログラム構造をシンプルに保ちつつ、必要な処理を直接的に表現可能です。

しかし、ラムダ関数の使用は、コードの読みやすさや保守性とのバランスを考慮することが重要です。例えば、複数の場所で再利用される可能性がある関数や、その機能が明確に定義されるべき関数の場合は、名前を付けて関数を定義する方が適切です。名前を付けることで関数の目的が明確になり、プロジェクト内での可読性が向上します。

大規模なプロジェクトでは、特に可読性と保守性は重要です。多くの開発者がコードを読むため、明確な命名と関数の適切な使用がプロジェクトの成功につながります。ラムダ関数は、利用のバランスを適切にすることで、Haskellプログラムの効率性、可読性、及び保守性を向上させることが可能です。

まとめ

Haskellにおけるラムダ関数（無名関数）の実装方法を解説しました。ラムダ関数は、関数名がなくても使用できる関数のことで、関数名が不要なことから無名関数とも呼ばれます。

基本的な記載方法とよく使用される高階関数との組み合わせて使用する方法について例を使って紹介しました。また、関数名をつけて定義するか、ラムダ関数を使うかという点においては、コードの読みやすさや保守性といったバランスを考慮して使用することが重要であることについても説明しました。

ラムダ関数は、一時的な用途や小さな関数を即座に記述できるため、関数型プログラミング言語であるHaskellではコードの柔軟性と表現力を高める重要で中心的な機能です。しっかりと理解し、使いこなせるようになってもらえたらと思います。

Haskell入門純粋関数型言語であるHaskellの入門編となる記事についてまとめます。Haskellで基本となる項目を中心に解説しているページへのリンク集です。...

Haskellにおける再帰関数

再帰関数とは、自分自身を呼び出す関数のことを言います。純粋関数型のプログラミング言語であり、関数を主体にプログラミングを行っていくHaskellにとって再帰関数は非常に重要なものになっています。

本記事では、Haskellを使って再帰関数を実装する方法を紹介します。

Haskellにおける再帰関数の重要性

C/C++、Java、Pythonといった手続き型、オブジェクト指向型のプログラミング言語を学んできた人にとってHaskellを勉強した時に戸惑うことがあります。多くのプログラミング言語では、繰り返しの制御を行うためにforやwhileといった制御構文がありますが、Haskellにはないことです。

では、Haskellではどのように繰り返し処理を行うかというと、そこで登場するのが再帰関数です。再帰関数で表現することについては理解しにくい部分かと思いますが、Haskellを学んで慣れていくことで非常に美しい直感的なコードを書くことができるようになります。

本記事では、Haskellで再帰関数を実装する方法について紹介していきます。

再帰関数の基本

再帰関数とは、どういったものでしょうか。例えば再帰関数の代表的な例として$n!=n\cdot(n-1)\cdot…\cdot2\cdot1$といった階乗を求める関数があります。なお、$0!=1$です。

Haskellで階乗を求める関数を実装する場合は以下のようになります。

-- 階乗関数
factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * factorial (n-1)

【実行例】
ghci> factorial 1
1
ghci> factorial 2
2
ghci> factorial 3
6
ghci> factorial 4
24
ghci> factorial 5
120

Haskellの再帰関数を記述するときに非常に重要になってくるのは、パターンマッチという機能です。パターンマッチについては「関数におけるパターンマッチ」でまとめていますので参考にしてください。

階乗関数では、$0!=1$です。このパターンを示しているのがfactorial 0 = 1の部分です。$n$番目の値を処理する場合には、$n$と$n-1!$をかけることになるのでfactorial n = n * factorial (n-1)となります。nに値を入れてみて自分で展開してみると分かりやすいでしょう。

factorial' :: Integer -> Either String Integer
factorial' n
    | n < 0     = Left "Error: Negative numbers are not allowed."
    | n == 0    = Right 1
    | otherwise = case factorial' (n - 1) of
        Left err -> Left err
        Right res -> Right (n * res)

【実行例】
ghci> factorial' 5
Right 120
ghci> factorial' (-1)
Left "Error: Negative numbers are not allowed."

階乗関数は他の言語でも再帰で実装されることがあるので、もう少し違う例を見てみましょう。非常に簡単ですが、リストの要素を順番に取り出して値を2倍する関数を考えます。この時、他の言語ではfor文で要素を一つずつ取り出して2倍していくという方法をとるかもしれません。しかし、Haskellではfor文などの繰り返し制御構文がないため、こういった対応ができません。Haskellでは以下のように関数を定義します。

-- リストを2倍する関数
doubleList :: [Integer] -> [Integer]
doubleList [] = []
doubleList (x:xs) = (2 * x) : doubleList xs

【実行例】
ghci> doubleList [1, 2, 3, 4, 5] 
[2,4,6,8,10]

リストを2倍するには「先頭から1要素取り出して2倍し、残りのリストの各要素を2倍したリストと結合する」と考えてみます。この処理の終了条件を考えていくと、要素を取り出していった場合には最後には空リスト[]が残ります。この空リスト[]に対する結果は、空リスト[]でよいでしょう。この部分がdoubleList [] = []となります。

では、繰り返しプロセス「先頭から1要素取り出して2倍し、残りのリストの各要素を2倍したリストと結合する」の定義を考えてみます。Haskellでは(x:xs)というパターンマッチで先頭要素xと残りのリストxsを取得することができます。取り出した先頭要素を2倍し、残りのリストを2倍したリストと結合します。この部分が「doubleList (x:xs) = (2 * x) : doubleList xs」になります。リストの結合は「:」で実行でき、コンスと呼ばれます。

実行例を見ても分かるようにこのように実装することでリストを2倍したリストを取得できていることが分かります。

上記の例を参考にして再帰のプログラミングをする際の考え方を整理してみると以下のようになります。

１の手順は、factorialの場合は「factorial 0 = 1」、doubleListの場合は「doubleList [] = []」に該当します。そして、２の手順がそれぞれ「factorial n = n * factorial (n-1)」や「doubleList (x:xs) = (2 * x) : doubleList xs」になります。

Haskellは宣言的に関数を定義するというのが特徴的で、処理の内容を捉えやすい理由です。「先頭から1要素取り出して2倍し、残りのリストの各要素を2倍したリストと結合する」ということが、まさに「doubleList (x:xs) = (2 * x) : doubleList xs」に表現されています。

多くの場合は便利な高階関数を利用する

上記では、再帰関数の定義の考え方について紹介してきました。しかし、Haskellでのプログラミングをする場合は、多くの場合は便利な高階関数を使用します。高階関数とは、関数を引数として受け取ったり、関数自体を返却したりする関数のことを言い、関数型プログラミングのパラダイムでよく登場します。

例えば、上記で紹介したdoubleList関数は、map関数という高階関数を使って以下のdoubleList'関数のように書き換えることができます。

-- リストを2倍する関数
doubleList' :: [Integer] -> [Integer]
doubleList' xs = map (*2) xs

ghci> doubleList' [1, 2, 3, 4, 5]
[2,4,6,8,10]

再帰関数での実装例と比べるとシンプルになっていることが分かるかと思います。map関数は、関数とリストを受け取ってリスト要素のそれぞれに受け取った関数を適用した結果リストを返してくれます。Haskellでは(*2)は2倍するという関数を意味します。この関数とリストxsを引数に渡すとすべての要素に適用した結果リストを返してくれます。

他にも代表的な高階関数として要素を抽出するfilterや畳み込みのためのfoldl、foldrといった関数等がありますので、そういった関数をまずは使うことを考えるのが一般的です。これらの高階関数については、また別途まとめてみようかと思います。

なお、より複雑な処理などを検討する場合には自分で再帰関数を書くべき時もあるため、考え方をよく理解しておいてもらうと良いかと思います。

まとめ

Haskellを使って再帰関数を実装する方法を解説しました。forやwhileといった制御構文がないHaskellにとっては再帰関数は非常に重要な関数となっています。

階乗関数やリストを2倍するといった簡単な例を使って再帰関数の定義方法について紹介しました。また、実際には繰り返し処理に該当するような再帰処理についても、map等のHaskellで既に定義されている便利な高階関数を使うことができることも説明しました。

Haskellでは、再帰関数は非常に重要な関数であるので、是非考え方や実装方法について理解してもらえたらと思います。

Haskell入門純粋関数型言語であるHaskellの入門編となる記事についてまとめます。Haskellで基本となる項目を中心に解説しているページへのリンク集です。...