1. 関数型プログラミングとは

関数型プログラミング は、関数を中心に据えたプログラミングスタイルである。従来の「命令を順番に実行する」手続き型とは、考え方が異なる。

特徴	説明
関数は第一級オブジェクト	関数を変数に入れたり、引数として渡せる
副作用を避ける	データを変更せず、新しいデータを返す
宣言的	「何を得たいか」を記述する

1-1. 手続き型と関数型の違い

手続き型では「どうやって処理するか」を細かく指示する。一方、関数型では「何を得たいか」を宣言する。

例えば「リストの各要素を2倍する」場合：

;; 手続き型：ループで1つずつ処理
(let ((result nil))
  (dolist (x '(1 2 3))
    (push (* x 2) result))
  (nreverse result))

;; 関数型：変換を宣言
(mapcar (lambda (x) (* x 2)) '(1 2 3))

関数型の方が「何をしたいか」が明確で、コードも短い。

2. Map → Filter → Reduce パイプライン

2-1. データ処理の3ステップ

実務のデータ処理の多くは、以下の3ステップの組み合わせで表現できる。これを パイプライン と呼ぶ。

Filter（絞り込み）：必要なデータだけ選ぶ
Map（変換）：各データを加工する
Reduce（集約）：全体を1つの値にまとめる

この順序は固定ではなく、処理の目的に応じて入れ替えてよい。重要なのは「小さな処理を組み合わせて複雑な処理を作る」という考え方である。

2-2. 具体例：成績処理

学生の点数リストから、合格者の平均点を求める例を見てみよう。

;; 学生の点数リスト
(defparameter *scores* '(45 78 92 38 85 67 91 55))

;; 目標：合格者（60点以上）の平均点を求める

ステップごとに分解

まず、何をすべきか整理する。

60点以上の点数だけを取り出す（Filter）
点数はそのまま使う（Map は不要）
合計を求めて人数で割る（Reduce + 計算）

;; ステップ1：Filter（合格者だけ抽出）
(defparameter *passing*
  (remove-if-not (lambda (s) (>= s 60)) *scores*))
;; → (78 92 85 67 91)

;; ステップ2：Map（この例では不要、点数をそのまま使う）

;; ステップ3：Reduce（平均を計算）
(/ (reduce #'+ *passing*)
   (float (length *passing*)))
;; → 82.6

1つの式で書く

慣れてくると、これらを1つの式にまとめられる。let で中間結果を束縛すると読みやすい。

(let ((passing (remove-if-not (lambda (s) (>= s 60)) *scores*)))
  (if passing
      (/ (reduce #'+ passing)
         (float (length passing)))
      0))
;; → 82.6

空のリストで割り算するとエラーになるため、if でチェックしている。

2-3. 具体例：テキスト分析

単語リストから、5文字以上の単語の総文字数を求める。

;; 単語リスト
(defparameter *words* 
  '("the" "quick" "brown" "fox" "jumps" "over" "lazy" "dog"))

;; 目標：5文字以上の単語の総文字数を求める

処理の流れ

5文字以上の単語を抽出（Filter）
各単語を文字数に変換（Map）
文字数を合計（Reduce）

(reduce #'+                                    ; 3. 合計
        (mapcar #'length                       ; 2. 文字数に変換
                (remove-if-not                 ; 1. 5文字以上を抽出
                  (lambda (w) (>= (length w) 5))
                  *words*)))
;; → 15（"quick" + "brown" + "jumps" = 5 + 5 + 5）

コードは内側から外側に向かって読む。最初に remove-if-not が実行され、その結果に mapcar が適用され、最後に reduce で集約される。

2-4. 具体例：商品在庫管理

より実践的な例として、商品データの処理を見てみよう。

;; 商品リスト（名前 価格 在庫数）
(defparameter *products*
  '(("Apple" 100 50)
    ("Banana" 80 0)
    ("Orange" 120 30)
    ("Grape" 200 0)
    ("Melon" 500 15)))

;; 目標：在庫がある商品の総在庫金額を計算

処理の流れ：

在庫がある商品だけ抽出（Filter）
各商品の在庫金額（価格×在庫数）を計算（Map）
合計（Reduce）

(reduce #'+
        ;; 各商品の「価格 × 在庫数」を計算
        (mapcar (lambda (p) (* (second p) (third p)))
                ;; 在庫数が 0 より大きい商品だけ残す
                (remove-if-not (lambda (p) (> (third p) 0))
                               *products*)))
;; → 16100

second と third でリストの2番目（価格）と3番目（在庫数）を取り出している。

3. 関数合成（Function Composition）

3-1. 関数合成とは

関数合成 は、複数の関数をつなげて新しい関数を作ることである。数学では $(f \circ g)(x) = f(g(x))$ と書く。

なぜ関数合成が必要か？毎回 (f (g x)) と書くのは冗長である。「f の後に g を適用する」という処理自体を関数として名前をつけておけば、再利用できる。

;; 例：「絶対値を取ってから2倍する」
;; 手順1: x → (abs x)
;; 手順2: (abs x) → (* 2 (abs x))

;; 直接書くと
(* 2 (abs -5))
;; → 10

この処理を何度も使うなら、関数として定義しておきたい。

3-2. compose 関数の実装

2つの関数を合成する compose を自作してみよう。

;; 2つの関数を合成する
(defun compose (f g)
  (lambda (x)
    (funcall f (funcall g x))))

この関数は「関数を受け取って、関数を返す」高階関数である。返される関数は、引数 x に対して「まず g を適用し、その結果に f を適用する」。

使用例：

;; 「絶対値を取ってから2倍する」関数を作成
(defparameter *abs-then-double*
  (compose (lambda (x) (* x 2))  ; 後に適用（2倍）
           #'abs))               ; 先に適用（絶対値）

(funcall *abs-then-double* -5)
;; → 10（-5 → 5 → 10）

(funcall *abs-then-double* 3)
;; → 6（3 → 3 → 6）

注意：compose の引数の順序は「後に適用する関数が先」である。これは数学の表記 f ∘ g に合わせている。

3-3. 実用例

;; 文字列を大文字にして長さを返す関数
(defparameter *uppercase-length*
  (compose #'length #'string-upcase))

(funcall *uppercase-length* "hello")
;; → 5

;; 1を足してから2乗する関数
(defparameter *inc-then-square*
  (compose (lambda (x) (* x x)) #'1+))

(funcall *inc-then-square* 4)
;; → 25（4 → 5 → 25）

3-4. 複数の関数を合成

3つ以上の関数を合成したい場合は、compose-all を定義する。

;; 任意個の関数を合成
(defun compose-all (&rest fns)
  (if (null fns)
      #'identity                    ; 関数がなければ恒等関数
      (let ((fn1 (car fns))
            (rest-composed (apply #'compose-all (cdr fns))))
        (lambda (x)
          (funcall fn1 (funcall rest-composed x))))))

identity は「引数をそのまま返す」関数で、合成の単位元として機能する。

使用例：

;; 「2倍 → 絶対値 → 1を足す」を合成
(defparameter *f*
  (compose-all #'1+                    ; 3番目：1を足す
               #'abs                   ; 2番目：絶対値
               (lambda (x) (* x 2))))  ; 1番目：2倍

(funcall *f* -5)
;; → 11（-5 → -10 → 10 → 11）

4. 部分適用（Partial Application）

4-1. 部分適用とは

部分適用 は、関数の一部の引数を固定して新しい関数を作ることである。「汎用的な関数から、特化した関数を作る」技法と言える。

;; + は2つの引数を取る
(+ 5 10)
;; → 15

;; 「5を足す」関数を作りたい
;; → 最初の引数を 5 に固定

毎回 (lambda (x) (+ 5 x)) と書くのは面倒である。部分適用を使えば、より宣言的に書ける。

4-2. partial 関数の実装

(defun partial (fn &rest fixed-args)
  (lambda (&rest more-args)
    (apply fn (append fixed-args more-args))))

動作の説明：

fixed-args：あらかじめ固定する引数（リストとして受け取る）
more-args：呼び出し時に渡す追加の引数
append：固定引数と追加引数を1つのリストに結合
apply：結合した引数で元の関数を呼び出す

&rest は「残りの引数をすべてリストとして受け取る」という意味である（詳細は後述）。

4-3. 使用例

;; 5を足す関数
(defparameter *add5* (partial #'+ 5))
(funcall *add5* 10)
;; more-args = (10)
;; (append '(5) '(10)) = (5 10)
;; (apply #'+ '(5 10)) = (+ 5 10) = 15

;; 3倍する関数
(defparameter *triple* (partial #'* 3))
(funcall *triple* 7)
;; more-args = (7)
;; (append '(3) '(7)) = (3 7)
;; (apply #'* '(3 7)) = (* 3 7) = 21

;; リストの先頭に 'x を追加する関数
(defparameter *prepend-x* (partial #'cons 'x))
(funcall *prepend-x* '(1 2 3))
;; more-args = ((1 2 3))          ; リスト1つが引数
;; (append '(x) '((1 2 3))) = (x (1 2 3))
;; (apply #'cons '(x (1 2 3))) = (cons 'x '(1 2 3)) = (X 1 2 3)

4-4. 実用例：消費税計算

部分適用は、設定値を埋め込んだ関数を作るのに便利である。

;; 税率を固定した計算関数を作る
(defparameter *add-tax-10* (partial #'* 1.1))   ; 10%
(defparameter *add-tax-8* (partial #'* 1.08))   ; 8%

(funcall *add-tax-10* 1000)
;; → 1100.0

(funcall *add-tax-8* 1000)
;; → 1080.0

税率が変わっても、*add-tax-10* の定義を1箇所変えるだけで済む。

4-5. 合成と部分適用の組み合わせ

compose と partial を組み合わせると、複雑な処理を宣言的に構築できる。

;; 「5を足してから2倍する」関数
(defparameter *add5-then-double*
  (compose (partial #'* 2)
           (partial #'+ 5)))

(funcall *add5-then-double* 10)
;; → 30（10 → 15 → 30）

このように、小さな部品（関数）を組み合わせて大きな処理を作るのが、関数型プログラミングの本質である。

5. 引数の特殊な受け取り方

Common Lisp には、関数の引数を柔軟に受け取るための特殊な記法がある。これらを使いこなすと、より便利な関数を定義できる。

5-1. &rest：残りの引数をすべて受け取る

&rest は、「ここから後の引数をすべてリストとして受け取る」という意味である。引数の個数が不定の関数を作れる。

(defun sum-all (&rest numbers)
  (reduce #'+ numbers :initial-value 0))

(sum-all 1 2 3)
;; → 6

(sum-all 1 2 3 4 5)
;; → 15

(sum-all)
;; → 0（引数なしでも動く）

5-2. &optional：省略可能な引数

&optional は、「この引数は省略できる」という意味である。省略された場合のデフォルト値を指定できる。

(defun greet (name &optional (greeting "Hello"))
  (format nil "~a, ~a!" greeting name))

(greet "Alice")
;; → "Hello, Alice!"

(greet "Alice" "Good morning")
;; → "Good morning, Alice!"

デフォルト値は (変数名デフォルト値) の形式で指定する。

5-3. &key：キーワード引数

&key は、「名前付きで引数を渡せる」という意味である。引数の順序を気にせず、必要なものだけ指定できる。

(defun make-person (&key name age (city "Unknown"))
  (list :name name :age age :city city))

(make-person :name "Alice" :age 25)
;; → (:NAME "Alice" :AGE 25 :CITY "Unknown")

;; 順序は自由
(make-person :age 30 :name "Bob" :city "Tokyo")
;; → (:NAME "Bob" :AGE 30 :CITY "Tokyo")

キーワード引数は設定やオプションを渡すときに便利である。

5-4. まとめ

記号	意味	例
`&rest`	残り全部をリストで受け取る	`(&rest args)`
`&optional`	省略可能な引数	`(&optional x y)`
`&key`	キーワード引数	`(&key name age)`

これらは組み合わせて使うこともできる。順序は &optional → &rest → &key でなければならない。

6. 副作用と参照透過性

6-1. 副作用とは

副作用（side effect） は、関数が「値を返す」以外に行う操作である。副作用があると、プログラムの動作を予測しにくくなる。

;; 副作用の例
(setf *global* 10)     ; グローバル変数の変更
(print "hello")        ; 画面への出力
(incf counter)         ; 変数の更新

副作用自体は悪ではない。ファイルへの書き込みや画面表示は副作用だが、プログラムに必要な機能である。問題は、副作用が予期しない場所で起きることである。

6-2. 参照透過性

参照透過性（referential transparency） がある関数は、同じ引数に対して常に同じ結果を返す。数学の関数と同じ性質である。

;; 参照透過性あり：常に同じ結果
(defun square (x)
  (* x x))

(square 5)  ;; → 25
(square 5)  ;; → 25（何度呼んでも同じ）

参照透過性がない関数は、外部の状態に依存するため、結果が変わりうる。

;; 参照透過性なし：結果が変わりうる
(defparameter *factor* 2)

(defun multiply-by-factor (x)
  (* x *factor*))

(multiply-by-factor 5)  ;; → 10
(setf *factor* 3)
(multiply-by-factor 5)  ;; → 15（同じ引数でも結果が違う）

6-3. 副作用を避ける利点

副作用のない関数（純粋関数）には多くの利点がある。

利点	説明
テストしやすい	入力と出力だけ確認すればよい
バグが少ない	予期しない状態変化がない
並列処理に強い	共有状態がないので競合しない
理解しやすい	関数を見れば動作が分かる

6-4. 高階関数と副作用

高階関数に渡す関数は、純粋であるべきである。

良い例：純粋な変換

(mapcar (lambda (x) (* x 2)) '(1 2 3))
;; → (2 4 6)
;; 副作用なし、元のリストも変更されない

避けるべき例：副作用に頼る

;; mapcar の中で副作用を起こす（非推奨）
(defparameter *total* 0)
(mapcar (lambda (x) (incf *total* x)) '(1 2 3))
*total*
;; → 6
;; 動くが、mapcar の本来の目的から外れている

mapcar は「変換」のための関数である。副作用が目的なら dolist を使うべきである。

6-5. ガイドライン

高階関数に渡す関数では、以下を避ける。

グローバル変数の読み書き
print や format による出力
setf や incf による破壊的操作

代わりに

引数だけに依存する
新しい値を返す
元のデータを変更しない

副作用が必要な処理は、プログラムの外側（入出力の境界）にまとめるのがよい設計である。

7. 実践例

7-1. ログファイルの解析

ログの行から特定のパターンを抽出する例。search は文字列内に部分文字列があれば位置を、なければ NIL を返す。

(defparameter *log-lines*
  '("2024-01-15 INFO: Server started"
    "2024-01-15 ERROR: Database connection failed"
    "2024-01-15 INFO: Request processed"
    "2024-01-15 ERROR: Timeout occurred"))

;; エラー行だけを抽出
(remove-if-not (lambda (line)
                 (search "ERROR" line))
               *log-lines*)
;; → ("2024-01-15 ERROR: Database connection failed"
;;    "2024-01-15 ERROR: Timeout occurred")

7-2. データの正規化

数値データをカテゴリに変換する。mapcar でリスト全体を一括変換できる。

;; 点数を5段階評価に変換
(defun grade (score)
  (cond ((>= score 90) 'A)
        ((>= score 80) 'B)
        ((>= score 70) 'C)
        ((>= score 60) 'D)
        (t 'F)))

(mapcar #'grade '(95 82 76 55 91 68))
;; → (A B C F A D)

7-3. 統計処理

平均と分散を計算する関数。分散は「各値と平均の差の2乗の平均」である。

;; 平均値
(defun average (lst)
  (if (null lst)
      0
      (/ (reduce #'+ lst)
         (float (length lst)))))

;; 分散
(defun variance (lst)
  (let ((avg (average lst)))
    (average (mapcar (lambda (x)
                       (expt (- x avg) 2))
                     lst))))

(average '(2 4 4 4 5 5 7 9))
;; → 5.0

(variance '(2 4 4 4 5 5 7 9))
;; → 4.0

分散の計算では、まず mapcar で「各値と平均の差の2乗」のリストを作り、その平均を取っている。これも Map → Reduce パターンの一例である。

8. 練習課題

課題1：mapcar で変換

リストの各要素を3倍したリストを作れ。

(defparameter *numbers* '(2 5 8 10))
;; → (6 15 24 30)

解答

(mapcar (lambda (x) (* x 3)) *numbers*)
;; → (6 15 24 30)

課題2：Filter → Map → Reduce

偶数を抽出し、それぞれを2乗し、その合計を求めよ。

(defparameter *nums* '(1 2 3 4 5 6 7 8 9 10))
;; → 220（4 + 16 + 36 + 64 + 100）

解答

(reduce #'+
        (mapcar (lambda (x) (* x x))
                (remove-if-not #'evenp *nums*)))
;; → 220

課題3：compose を使う

「1を引いてから絶対値を取る」関数を compose で作れ。

;; (funcall *f* 5)  → 4
;; (funcall *f* 0)  → 1
;; (funcall *f* -3) → 4

解答

(defun compose (f g)
  (lambda (x)
    (funcall f (funcall g x))))

(defparameter *f*
  (compose #'abs #'1-))

(funcall *f* 5)   ;; → 4（5 → 4 → 4）
(funcall *f* 0)   ;; → 1（0 → -1 → 1）
(funcall *f* -3)  ;; → 4（-3 → -4 → 4）

課題4：partial を使う

10で割る関数を partial で作れ。

;; (funcall *div10* 100) → 10
;; (funcall *div10* 50)  → 5

解答

(defun partial (fn &rest fixed-args)
  (lambda (&rest more-args)
    (apply fn (append fixed-args more-args))))

;; 注意：/ は (/ 分子 分母) なので、分母を固定するには工夫が必要
(defparameter *div10*
  (lambda (x) (/ x 10)))

(funcall *div10* 100)  ;; → 10
(funcall *div10* 50)   ;; → 5

課題5：商品データの処理

商品リストから、在庫が10個以上ある商品だけを選び、価格を1.1倍（税込）にして、総額を求めよ。

(defparameter *inventory*
  '(("Pen" 100 5)
    ("Notebook" 200 15)
    ("Eraser" 50 20)
    ("Ruler" 150 3)))
;; → 4400.0

解答

(reduce #'+
        (mapcar (lambda (p)
                  (* (* (second p) 1.1)  ; 税込価格
                     (third p)))         ; 在庫数
                (remove-if-not
                  (lambda (p) (>= (third p) 10))
                  *inventory*)))
;; → 4400.0
;; Notebook: 200 * 1.1 * 15 = 3300
;; Eraser: 50 * 1.1 * 20 = 1100
;; 合計: 4400

課題6：compose-all の実装

任意個の関数を合成する compose-all を実装せよ。

(defparameter *f* 
  (compose-all #'1+ #'abs (lambda (x) (* x 2))))

(funcall *f* -5)
;; → 11（-5 → -10 → 10 → 11）

解答

(defun compose-all (&rest fns)
  (reduce (lambda (f g)
            (lambda (x) (funcall f (funcall g x))))
          fns
          :initial-value #'identity
          :from-end t))

;; テスト
(defparameter *f*
  (compose-all #'1+ #'abs (lambda (x) (* x 2))))

(funcall *f* -5)
;; → 11

9. まとめ

関数型プログラミングの3つの柱

Map → Filter → Reduce パターン

データ処理の多くは、この3つの操作の組み合わせで表現できる。

(reduce 集約関数
        (mapcar 変換関数
                (remove-if-not 条件関数 データ)))

関数合成と部分適用

小さな関数を組み合わせて、複雑な処理を構築する。

技法	目的	例
compose	関数を連鎖	`(compose #'abs #'1-)`
partial	引数を固定	`(partial #'+ 5)`

副作用を避ける

純粋な関数はテストしやすく、バグが少ない。

高階関数には純粋な関数を渡す
元のデータを変更しない
新しい値を返す