HN 日本語サマリー

← 一覧へ戻る
プログラミング

Macの物語:〜だからこうなった物語

The Story of Mac: A Just-So Story (gigamonkeys.com)

22 pointsby kscarlet2 コメント

要約

Lispのマクロは、コードを生成するコードとして機能します。この記事では、「Mac」という架空のプログラマーの物語を通して、マクロがどのようにしてコード生成を自動化し、プログラマーの負担を軽減したかを解説します。また、マクロの実行時(マクロ展開時)と通常のコードの実行時(ランタイム)の違いについても説明しています。

全文翻訳

8. マクロ:独自の定義

Copyright © 2003-2005, Peter Seibel

いよいよ独自の Lisp マクロを書き始める時間です。前章で触れた標準マクロは、マクロで何ができるかの一部を示唆していますが、それは始まりに過ぎません。Common Lisp がマクロをサポートしているのは、すべての Lisp プログラマーが標準ライブラリの関数と些細なバリエーションを作成できるからという理由で C が関数をサポートしているわけではないのと同じように、すべての Lisp プログラマーが標準制御構造の独自のバリエーションを作成できるようにするためではありません。マクロは、コア言語と標準ライブラリの上に抽象化を作成し、あなたが表現したいことを直接表現できるようにするためのものです。

おそらく、マクロを正しく理解する上での最大の障壁は、皮肉なことに、それらが言語に非常によく統合されていることです。多くの点で、それらは単なる奇妙な種類の関数のように見えます――Lisp で書かれ、引数を取り、結果を返し、注意をそらす詳細を抽象化することを可能にします。しかし、これらの多くの類似点にもかかわらず、マクロは関数とは異なるレベルで動作し、まったく異なる種類の抽象化を作成します。

マクロと関数の違いを理解すれば、言語におけるマクロの緊密な統合は大きな利点となります。しかし、それまでは、新しい Lisper にとって混乱の頻繁な原因となります。以下の物語は、歴史的または技術的な意味では真実ではありませんが、マクロがどのように機能するかを考える方法を提供することで、混乱を軽減しようとします。

Macの物語:〜だから〜という話

昔々、ずっと昔、Lisp プログラマーの会社がありました。実際、それは非常に昔だったので、Lisp にはマクロがありませんでした。関数で定義できないものや特殊な演算子で行えないものは、毎回完全に記述する必要があり、それはかなり面倒でした。残念ながら、この会社のプログラマーは――優秀でしたが――非常に怠惰でもありました。プログラムの途中で、大量のコードを書くという退屈さが耐えられなくなると、代わりにそこに書く必要のあるコードを説明するメモを書きました。さらに残念なことに、彼らは怠惰だったので、メモで説明されたコードを実際に書くことを嫌いました。すぐに、会社にはメモだらけで誰も実行できないプログラムの山ができ、まだ書かれていないコードについてのメモがありました。

絶望した上司たちは、ジュニアプログラマーの Mac を雇いました。彼の仕事は、メモを見つけ、必要なコードを書き、プログラムのその場所に挿入することでした。Mac はプログラムを実行しませんでした――もちろん、まだ完成していなかったので、実行できませんでした。しかし、たとえ完成していたとしても、Mac はどのような入力を使えばよいか知らなかったでしょう。そこで彼はメモの内容に基づいてコードを書き、元のプログラマーに送り返しました。

Mac の助けを借りて、すべてのプログラムはすぐに完成し、会社はそれらを販売して大儲けしました――それほど大儲けしたので、プログラミングスタッフを倍増させることができました。しかし、なぜか誰も Mac を手伝う人を雇おうと考えませんでした。すぐに彼は数十人のプログラマーを一人で手伝っていました。ソースコードの中からメモを探すのにすべての時間を費やすのを避けるため、Mac はプログラマーが使用していたコンパイラに小さな変更を加えました。それ以降、コンパイラがメモに当たると、Mac にメモを E メールで送信し、彼が置き換えコードを E メールで返信するのを待つようになりました。残念ながら、この変更があっても、Mac はプログラマーに追いつくのに苦労しました。彼はできる限り注意深く作業しましたが、時には――特にメモが不明瞭な場合――間違いを犯しました。

しかし、プログラマーは、メモをより正確に書けば書くほど、Mac が正しいコードを返信する可能性が高くなることに気づきました。ある日、一人のプログラマーは、言葉で欲しいコードを説明するのに苦労し、メモの1つに、欲しいコードを生成する Lisp プログラムを含めました。それは Mac にとっては問題ありませんでした。彼はプログラムを実行し、結果をコンパイラに送りました。

次の革新は、あるプログラマーがプログラムの先頭に、関数定義と「Mac、ここではコードを書かないでください。後で使うのでこの関数を保持してください。他のメモで使います」というコメントを含むメモを置いたときでした。同じプログラムの他のメモには、「Mac、このメモを、その別の関数をシンボル x と y を引数として実行した結果で置き換えてください」といったことが書かれていました。

このテクニックは非常に速く広まり、数日後にはほとんどのプログラムに、他のメモのコードからしか使用されない関数の定義を含む数十個のメモが含まれるようになりました。Mac が定義のみを含むメモをすぐに識別できるようにするために、プログラマーは標準の接頭辞「Definition for Mac, Read Only.」を付けました。これは――プログラマーはまだ非常に怠惰だったので――すぐに「DEF. MAC. R/O」に短縮され、次に「DEFMACRO」となりました。

すぐに、メモには Mac のための実際の英語は何も残らなくなりました。彼が一日中していたことは、コンパイラからの DEFMACRO メモと DEFMACRO で定義された関数への呼び出しを含む E メールを読み、返信することだけでした。メモの中の Lisp プログラムがすべての実際の作業を行っていたので、E メールに追いつくことは問題ありませんでした。Mac は突然たくさんの時間を手に入れ、白い砂浜、澄んだ青い海、そして小さな紙の傘が付いた飲み物のことを空想してオフィスに座っていました。

数ヶ月後、プログラマーたちは Mac をしばらく見かけないことに気づきました。彼のオフィスに行くと、すべてに薄いほこりの層があり、机には様々な熱帯の場所への旅行パンフレットが散乱し、コンピューターはオフになっていました。しかし、コンパイラはまだ機能していました――どうしてでしょうか? Mac はコンパイラに最後の変更を加えていたのです。コンパイラは、メモを Mac に E メールで送信する代わりに、DEFMACRO メモによって定義された関数を保存し、他のメモで呼び出されたときにそれらを実行するようになりました。プログラマーたちは、Mac がもうオフィスに来ないことを上司に伝える理由はないと判断しました。そのため、今日に至るまで、Mac は給料を受け取り、時折、様々な熱帯の場所からプログラマーに絵葉書を送っています。

マクロ展開時 vs. 実行時

マクロを理解する鍵は、コードを生成するコード(マクロ)と、最終的にプログラムを構成するコード(それ以外すべて)との区別を非常に明確にすることです。マクロを書くとき、あなたはコンパイラがコードを生成するために使用するプログラムを書いており、そのコードがコンパイルされます。すべてのマクロが完全に展開され、結果のコードがコンパイルされた後になって初めて、プログラムは実際に実行できます。マクロが実行される時間はマクロ展開時と呼ばれます。これは、マクロによって生成されたコードを含む通常のコードが実行される実行時とは区別されます。

この区別をしっかりと心に留めておくことが重要です。なぜなら、マクロ展開時に実行されるコードは、実行時に実行されるコードとは非常に異なる環境で実行されるからです。具体的には、マクロ展開時には、実行時に存在するデータにアクセスする方法はありません。Mac が、プログラムがまだ完成していなかったために実行できなかったように、マクロ展開時に実行されるコードは、ソースコードに固有のデータしか扱うことができません。たとえば、プログラムのどこかに次のソースコードが現れるとします。

(defun foo (x)
  (when (> x 10) (print 'big)))

通常、x は foo への呼び出しで渡される引数を保持する変数として考えます。しかし、マクロ展開時には、たとえばコンパイラが **WHEN** マクロを実行しているときなど、利用可能なデータはソースコードのみです。プログラムはまだ実行されていないため、foo への呼び出しはなく、したがって x に関連付けられた値もありません。代わりに、コンパイラが **WHEN** に渡す値は、ソースコードを表す Lisp リスト、すなわち (> x 10) と (print 'big) です。前の章で見たように、**WHEN** が次のようなマクロで定義されていると仮定します。

(defmacro when (condition &rest body)
  `(if ,condition (progn ,@body)))

foo のコードがコンパイルされるとき、**WHEN** マクロはこれらの2つのフォームを引数として実行されます。condition パラメータは (> x 10) フォームに束縛され、(print 'big) フォームは **&rest** body パラメータの値となるリストに収集されます。その後、バッククォート式は次のコードを生成します。

(if (> x 10) (progn (print 'big)))

condition の値を補間し、body の値を **PROGN** にスプライスすることによって。

Lisp がコンパイルではなく解釈される場合、マクロ展開時と実行時の区別は、それらが時間的に絡み合っているため、それほど明確ではありません。また、言語標準は、インタプリタがマクロをどのように処理しなければならないかを正確に指定していません――インタプリタは、解釈されるフォームのマクロをすべて展開してから結果のコードを解釈するか、フォームの解釈を開始してマクロに遭遇したときにマクロを展開するかのどちらかです。どちらの場合でも、マクロには常にマクロフォームのサブフォームを表す評価されていない Lisp オブジェクトが渡され、マクロの仕事は直接何かを行うことではなく、何かを行うコードを生成することです。

DEFMACRO

第3章で見たように、マクロは実際に **DEFMACRO** フォームで定義されますが、これはもちろん、DEFine MACRO の略であり、Definition for Mac の略ではありません。**DEFMACRO** の基本的な骨組みは、**DEFUN** の骨組みと非常によく似ています。

(defmacro name (parameter*)
  "Optional documentation string."
  body-form*)

関数と同様に、マクロは名前、パラメータリスト、オプションのドキュメント文字列、および Lisp 式の本体で構成されます。1 しかし、先ほど説明したように、マクロの仕事は直接何かを行うことではありません――その仕事は、後であなたが望むことを行うコードを生成することです。

マクロは、Lisp の全能力を使用してその展開を生成できます。これは、この章では表面をかすめることしかできないことを意味します。しかし、最も単純なマクロから最も複雑なマクロまで、すべてのマクロに適用できるマクロを作成するための一般的なプロセスを説明することはできます。

マクロの仕事は、マクロフォーム――つまり、最初の要素がマクロの名前である Lisp フォーム――を特定のことを行うコードに変換することです。時には、書きたいコードからマクロを書き始めることもあります。つまり、マクロ呼び出しの例から始めることもあります。他の時には、同じコードパターンのコードを数回書いた後で、パターンを抽象化することでコードをより明確にできることに気づいてからマクロを書くことを決定します。

どちらの端から始めても、マクロを書き始める前に、もう一方の端を把握する必要があります。つまり、自動的にコードを書くことを期待する前に、どこから来てどこへ行くのかを知る必要があります。したがって、マクロを書く最初のステップは、マクロの呼び出しの例と、その呼び出しが展開されるべきコードを少なくとも1つ書くことです。

例となる呼び出しと望ましい展開が得られたら、2番目のステップの準備が整いました。実際のマクロコードを書くことです。単純なマクロの場合、これはマクロパラメータを適切な場所に挿入したバッククォートテンプレートを書くだけの簡単な作業になります。複雑なマクロは、それ自体で重要なプログラムとなり、ヘルパー関数やデータ構造を備えています。

例となる呼び出しを適切な展開に変換するコードを書き終えたら、抽象化が実装の詳細を「漏らさない」ことを確認する必要があります。漏洩するマクロ抽象化は、特定の引数ではうまく機能しますが、他の引数では機能しないか、望ましくない方法で呼び出し環境のコードと相互作用する可能性があります。実際、マクロは少数の方法で漏洩する可能性があり、それらはすべて、チェックすることを覚えていれば簡単に回避できます。「漏洩の修正」のセクションで説明します。

要約すると、マクロを作成する手順は次のとおりです。

  1. マクロのサンプル呼び出しと、それが展開されるべきコード、またはその逆を書く。
  2. サンプル呼び出しの引数から手書きの展開を生成するコードを書く。
  3. マクロ抽象化が「漏洩」しないことを確認する。

サンプルマクロ:do-primes

この3ステップのプロセスがどのように機能するかを見るために、do-primes というマクロを記述します。これは、整数やリストの要素を反復するのではなく、連続する素数を反復する以外は、**DOTIMES** や **DOLIST** に似たループ構造を提供するマクロです。これは特に有用なマクロの例として意図されているわけではありません――単にプロセスを実証するための手段です。

まず、与えられた数が素数であるかどうかをテストする関数と、引数以上の次の素数を返す関数の2つのユーティリティ関数が必要になります。どちらの場合も、単純で非効率的な総当たりアプローチを使用できます。

(defun primep (number)
  (when (> number 1)
    (loop for fac from 2 to (isqrt number) never (zerop (mod number fac)))))

(defun next-prime (number)
  (loop for n from number when (primep n) return n))

これでマクロを書くことができます。前述の手順に従って、マクロの呼び出しの例と、それが展開されるべきコードが少なくとも1つ必要です。次のようなことを書きたいという考えから始めると仮定します。

(do-primes (p 0 19)
  (format t "~d " p))

これは、変数 p が素数を保持する状態で、0 以上 19 以下の各素数に対して本体が1回実行されるループを表現します。標準の **DOLIST** および **DOTIMES** マクロの形式でこのマクロをモデル化するのは理にかなっています――既存のマクロのパターンに従うマクロは、不必要に新しい構文を導入するマクロよりも理解しやすく使用しやすいです。

do-primes マクロなしでは、次のように **DO**(および前述の2つのユーティリティ関数)を使用してそのようなループを書くことができます。

(do ((p (next-prime 0) (next-prime (1+ p))))
    ((> p 19))
  (format t "~d " p))

これで、前者から後者へ変換するマクロコードの作成を開始する準備ができました。

マクロパラメータ

マクロに渡される引数はマクロ呼び出しのソースコードを表す Lisp オブジェクトであるため、どのマクロでも最初のステップは、展開を計算するために必要なオブジェクトのどの部分を抽出することです。引数をテンプレートに直接補間するだけの単純なマクロの場合、このステップは簡単です――適切なパラメータを定義してさまざまな引数を保持するだけで十分です。

しかし、このアプローチは do-primes には適さないようです。do-primes 呼び出しの最初の引数は、ループ変数の名前 p、下限 0、上限 19 を含むリストです。しかし、展開を見ると、リスト全体は展開に現れません。3つの要素は分割され、異なる場所に配置されます。

do-primes を2つのパラメータで定義し、1つはリストを保持し、もう1つは **&rest** パラメータで本体フォームを保持し、リストを手動で分解することもできます。

(defmacro do-primes (var-and-range &rest body)
  (let ((var (first var-and-range))
        (start (second var-and-range))
        (end (third var-and-range)))
    `(do ((,var (next-prime ,start) (next-prime (1+ ,var))))
         ((> ,var ,end))
       ,@body)))

しばらくすると、本体が正しい展開を生成する方法を説明します。今のところ、変数 var、start、end がそれぞれ var-and-range から抽出された値を持っており、それが do-primes の展開を生成するバッククォート式に補間されることに注意してください。

しかし、var-and-range を「手動で」分解する必要はありません。なぜなら、マクロのパラメータリストはデストラクチャリングパラメータリストと呼ばれるものだからです。デストラクチャリングは、その名前が示すように、構造――この場合はマクロに渡されるフォームのリスト構造――を分解することを含みます。

デストラクチャリングパラメータリスト内では、単純なパラメータ名をネストされたパラメータリストに置き換えることができます。ネストされたパラメータリスト内のパラメータは、リストが置き換えた式から値を受け取ります。たとえば、var-and-range をリスト (var start end) に置き換えることができます。リストの3つの要素は自動的にこれらの3つのパラメータにデストラクチャリングされます。

マクロパラメータリストのもう1つの特別な機能は、**&body** を **&rest** の同義語として使用できることです。意味的には **&body** と **&rest** は同等ですが、多くの開発環境では **&body** パラメータの存在を使用して、マクロの使用方法のインデントを変更します――通常、**&body** パラメータは、マクロの本体を構成するフォームのリストを保持するために使用されます。

したがって、do-primes の定義を簡略化し、その意図された使用法について人間と開発ツールの両方にヒントを与えるために、次のように定義できます。

(defmacro do-primes ((var start end) &body body)
  `(do ((,var (next-prime ,start) (next-prime (1+ ,var))))
       ((> ,var ,end))
     ,@body))

より簡潔であることに加えて、デストラクチャリングパラメータリストは自動的なエラーチェックも提供します――このように定義された do-primes では、Lisp は最初の引数が3要素リストでない呼び出しを検出でき、関数に引数が多すぎるか少なすぎる場合と同様に、意味のあるエラーメッセージを提供できます。また、関数の名前を入力するとすぐに期待される引数を示す SLIME のような開発環境では、デストラクチャリングパラメータリストを使用すると、環境はマクロ呼び出しの構文をより具体的に伝えることができます。元の定義では、SLIME は do-primes が次のように呼び出されると教えてくれます。

(do-primes var-and-range &rest body)

しかし、新しい定義では、呼び出しは次のようになると教えてくれます。

(do-primes (var start end) &body body)

デストラクチャリングパラメータリストには **&optional**、**&key**、**&rest** パラメータを含めることができ、ネストされたデストラクチャリングリストを含めることもできます。しかし、do-primes を書くのにこれらのオプションのいずれも必要ありません。

展開の生成

do-primes は比較的単純なマクロなので、引数をデストラクチャリングした後、残りはそれらをテンプレートに補間して展開を取得することだけです。

do-primes のような単純なマクロの場合、特別なバッククォート構文が最適です。復習すると、バッククォートされた式は引用された式に似ていますが、コンマの前にコンマを付けることで特定のサブ式を「アンクォート」できます。コンマの後にアットマーク(@)記号が付く場合もあります。アットマークがない場合、コンマはサブ式の値をそのまま含める原因となります。アットマークがある場合、値(リストでなければならない)は、囲むリストに「スプライス」されます。

バッククォート構文を考えるもう一つの有用な方法は、リストを生成するコードを書くための非常に簡潔な方法として考えることです。この考え方には、舞台裏で実際に何が起こっているのかとほぼ同じであるという利点があります――リーダーがバッククォートされた式を読むとき、それは適切なリスト構造を生成するコードに変換します。たとえば、`(,a b) は (list a 'b) と読まれるかもしれません。言語標準は、正しいリスト構造を生成する限り、リーダーが生成しなければならない正確なコードを指定していません。

表8-1は、バッククォートされた式の例と、同等のリスト構築コード、およびバッククォートされた式または同等のコードのいずれかを評価した場合に得られる結果を示しています。2

表8-1. バッククォートの例

バッククォート構文同等のリスト構築コード結果
`(a (+ 1 2) c)(list 'a '(+ 1 2) 'c)(a (+ 1 2) c)
`(a ,(+ 1 2) c)(list 'a (+ 1 2) 'c)(a 3 c)
`(a (list 1 2) c)(list 'a '(list 1 2) 'c)(a (list 1 2) c)
`(a ,(list 1 2) c)(list 'a (list 1 2) 'c)(a (1 2) c)
`(a ,@(list 1 2) c)(append (list 'a) (list 1 2) (list 'c))(a 1 2 c)

バッククォートは単なる便宜であることに注意することが重要です。しかし、それは大きな便宜です。その大きさを理解するために、do-primes のバッククォートバージョンを、明示的なリスト構築コードを使用する次のバージョンと比較してください。

(defmacro do-primes-a ((var start end) &body body)
  (append '(do)
          (list  (list (list var
                             (list 'next-prime start)
                             (list 'next-prime (list '1+ var)))))
          (list (list (list '> var end)))
          body))

すぐにわかるように、do-primes の現在の実装は、特定の端のケースを正しく処理していません。しかし、まず、それが少なくとも元の例で機能することを確認する必要があります。2つの方法でテストできます。それを使用するだけで間接的にテストできます――おそらく、結果の動作が正しい場合、展開は正しいです。たとえば、REPL で do-primes の元の例の使用法を入力し、それが実際に正しい素数の系列を出力することを確認できます。

CL-USER> (do-primes (p 0 19) (format t "~d " p))
2 3 5 7 11 13 17 19
NIL

または、特定の呼び出しの展開を直接確認することもできます。**MACROEXPAND-1** 関数は、任意の Lisp 式を引数として取り、1レベルのマクロ展開の結果を返します。3 **MACROEXPAND-1** は関数であるため、リテラルのマクロフォームを渡すには引用する必要があります。以前の呼び出しの展開を確認するために使用できます。4

CL-USER> (macroexpand-1 '(do-primes (p 0 19) (format t "~d " p)))
(DO ((P (NEXT-PRIME 0) (NEXT-PRIME (1+ P))))
    ((> P 19))
  (FORMAT T "~d " P))
T

または、より便利には、SLIME では、ソースコードのマクロフォームの開き括弧の上にカーソルを置き、C-c RET をタイプして Emacs 関数 slime-macroexpand-1 を呼び出すことでマクロの展開を確認できます。これは、マクロフォームを **MACROEXPAND-1** に渡し、一時バッファに結果を「きれいに印刷」します。

どのように取得しても、マクロ展開の結果が元の手書き展開と同じであることがわかります。したがって、do-primes は機能しているようです。

漏洩の修正

Joel Spolsky は、エッセイ「漏洩する抽象化の法則」で、抽象化しようとしている詳細を「漏らしている」抽象化を説明するために漏洩する抽象化という用語を造語しました。マクロを書くことは抽象化を作成する方法であるため、マクロが無駄に漏洩しないようにする必要があります。5

実際には、マクロは3つの方法で内部動作の詳細を漏らす可能性があります。幸いなことに、特定の макро がこれらの漏洩のいずれかに苦しんでいるかどうかを判断し、それらを修正するのはかなり簡単です。

現在の定義は、3つの可能なマクロ漏洩の1つに苦しんでいます。つまり、end サブ式を何度も評価してしまうことです。たとえば、do-primes を、リテラルの数値 19 の代わりに、end の位置に (random 100) のような式で呼び出したと仮定します。

(do-primes (p 0 (random 100))
  (format t "~d " p))

おそらく意図は、0から (random 100) が返すランダムな数までの素数をループすることです。しかし、これは現在の実装が行っていることではありません。**MACROEXPAND-1** が示すように。

CL-USER> (macroexpand-1 '(do-primes (p 0 (random 100)) (format t "~d " p)))
(DO ((P (NEXT-PRIME 0) (NEXT-PRIME (1+ P))))
    ((> P (RANDOM 100)))
  (FORMAT T "~d " P))
T

この展開コードが実行されると、ループの終了テストが評価されるたびに **RANDOM** が呼び出されます。したがって、p が最初に選択されたランダムな数より大きくなるまでループする代わりに、このループは p の現在の値以下のランダムな数を描画するまで繰り返されます。総反復回数は依然としてランダムになりますが、**RANDOM** が返す一様分布とは大きく異なる分布から描画されます。

これは抽象化の漏洩です。なぜなら、マクロを正しく使用するために、呼び出し元は end フォームが複数回評価されることを認識する必要があるからです。この漏洩を修正する1つの方法は、これを do-primes の動作として単純に定義することです。しかし、それはあまり満足のいくものではありません――マクロを実装するときは、最小驚きの原則を遵守しようとすべきです。そして、プログラマーは通常、マクロに渡すフォームが絶対に必要以上に多く評価されないことを期待します。6 さらに、do-primes は標準マクロ **DOTIMES** および **DOLIST** のモデルに基づいて構築されており、これらのマクロは本体のフォームを除いて、いずれのフォームも複数回評価しないため、ほとんどのプログラマーは do-primes も同様に動作することを期待するでしょう。

複数の評価は簡単に修正できます。end を一度評価し、後で使用するために変数を保存するコードを生成するだけで済みます。**DO** ループで、初期化フォームがありステップフォームがない変数は、反復ごとに変更されないことを思い出してください。したがって、この定義で複数の評価の問題を修正できます。

(defmacro do-primes ((var start end) &body body)
  `(do ((ending-value ,end)
        (,var (next-prime ,start) (next-prime (1+ ,var))))
       ((> ,var ending-value))
     ,@body))

残念ながら、この修正はマクロ抽象化に2つの新しい漏洩を導入します。

1つの新しい漏洩は、複数評価漏洩に似ています。**DO** ループの変数の初期化フォームは変数が定義されている順序で評価されるため、マクロ展開が評価されるとき、end として渡された式は、マクロ呼び出しでの出現順序とは逆に、start として渡された式よりも前に評価されます。start と end が 19 のようなリテラルの値である場合は問題ありませんが、副作用を持つ可能性のあるフォームである場合、それらを順序外で評価することは、再び最小驚きの原則に反する可能性があります。

この漏洩は、2つの変数の定義の順序を入れ替えるだけで簡単に修正できます。

(defmacro do-primes ((var start end) &body body)
  `(do ((,var (next-prime ,start) (next-prime (1+ ,var)))
        (ending-value ,end))
       ((> ,var ending-value))
     ,@body))

最後に修正する必要がある漏洩は、ending-value という変数名を使用したことによって作成されました。問題は、マクロ実装の純粋に内部的な詳細であるべき名前が、マクロに渡されるコードやマクロが呼び出されるコンテキストと相互作用する可能性があることです。次の、一見無害な do-primes の呼び出しは、この漏洩のために正しく機能しません。

(do-primes (ending-value 0 10)
  (print ending-value))

これも、次のようになりません。

(let ((ending-value 0))
  (do-primes (p 0 10)
    (incf ending-value p))
  ending-value)

ここでも、**MACROEXPAND-1** が問題を示すことができます。最初の呼び出しは次のように展開されます。

(do ((ending-value (next-prime 0) (next-prime (1+ ending-value)))
     (ending-value 10))
    ((> ending-value ending-value))
  (print ending-value))

一部の Lisp では、**DO** ループで ending-value という変数名が2回使用されているため、このコードが拒否される可能性があります。たとえ拒否されなくても、ending-value はそれ自体より大きくなることがないため、コードは無限ループします。

2番目の問題のある呼び出しは次のように展開されます。

(let ((ending-value 0))
  (do ((p (next-prime 0) (next-prime (1+ p)))
       (ending-value 10))
      ((> p ending-value))
    (incf ending-value p))
  ending-value)

この場合、生成されたコードは完全に合法ですが、動作はまったく望ましいものではありません。ループの外側にある **LET** によって確立された ending-value の束縛は、**DO** 内部の同じ名前の変数によってシャドウされているため、(incf ending-value p) フォームは、外側の同じ名前の変数ではなく、ループ変数 ending-value をインクリメントし、別の無限ループを作成します。7

明らかに、この漏洩を修正するために必要なのは、マクロによって生成されたコードの外では決して使用されないシンボルです。非常にありそうもない名前を使おうとするかもしれませんが、それは保証ではありません。パッケージを使用することである程度保護することもできます(第21章で説明)。しかし、より良い解決策があります。

**GENSYM** 関数は、呼び出されるたびに一意のシンボルを返します。これは、Lisp リーダーによって読み取られたことがなく、どのパッケージにもインターンされていないため、今後も読み取られることのないシンボルです。したがって、ending-value のようなリテラルの名前を使用する代わりに、do-primes が展開されるたびに新しいシンボルを生成できます。

(defmacro do-primes ((var start end) &body body)
  (let ((ending-value-name (gensym)))
    `(do ((,var (next-prime ,start) (next-prime (1+ ,var)))
          (,ending-value-name ,end))
         ((> ,var ,ending-value-name))
       ,@body)))

**GENSYM** を呼び出すコードは展開の一部ではなく、マクロエクスペンダーの一部として実行されるため、マクロが展開されるたびに新しいシンボルが作成されることに注意してください。これは最初は少し奇妙に見えるかもしれませんが――ending-value-name は別の変数の名前を保持する変数です――実際には、変数の名前が値であるパラメータ var と違いはありません。違いは、var の値はマクロフォームが読み取られたときにリーダーによって作成されたのに対し、ending-value-name の値はマクロコードが実行されたときにプログラムで生成されることです。

この定義により、以前の問題があった2つのフォームは、期待どおりに機能するコードに展開されます。最初のフォーム:

(do-primes (ending-value 0 10)
  (print ending-value))

次のように展開されます。

(do ((ending-value (next-prime 0) (next-prime (1+ ending-value)))
     (#:g2141 10))
    ((> ending-value #:g2141))
  (print ending-value))

これで、終了値を保持するために使用される変数は、gensym されたシンボル #:g2141 になりました。シンボルの名前 G2141 は **GENSYM** によって生成されましたが、重要ではありません。重要なのはシンボルのオブジェクト ID です。Gensym されたシンボルは、先頭に #: が付いた、インターンされていないシンボルの通常の構文で印刷されます。

もう一方の以前の問題があったフォーム:

(let ((ending-value 0))
  (do-primes (p 0 10)
    (incf ending-value p))
  ending-value)

do-primes フォームをその展開に置き換えると、次のようになります。

(let ((ending-value 0))
  (do ((p (next-prime 0) (next-prime (1+ p)))
       (#:g2140 10))
      ((> p #:g2140))
    (incf ending-value p))
  ending-value)

ここでも漏洩はありません。なぜなら、do-primes ループを囲む **LET** によって束縛された ending-value 変数は、展開されたコードで導入された変数によってシャドウされなくなったからです。

すべてのリテラルの名前がマクロ展開で使用されるわけではありません――さまざまな束縛フォームに関する経験を積むにつれて、特定の名前が漏洩を引き起こす可能性のある位置で使用されているかどうかを判断できるようになります。しかし、安全のために gensym された名前を使用することに実質的な欠点はありません。

この修正により、do-primes の実装のすべての漏洩が修正されました。マクロ作成の経験を積めば、これらの種類の漏洩が事前に修正されたマクロを書くことができるようになります。これらの経験則に従えば、実際にはかなり簡単です。

  • 特に理由がない限り、展開内のサブフォームは、サブフォームがマクロ呼び出しに現れる順序と同じ順序で評価される位置に含める。
  • 特に理由がない限り、サブフォームは一度だけ評価されるようにし、展開に変数を生成して引数フォームの評価値を保持し、その後、展開の他の場所でその値が必要なときにその変数を使用する。
  • マクロ展開時に **GENSYM** を使用して、展開で使用される変数名を生成する。

マクロを書くマクロ

もちろん、関数を書くだけでなく、マクロを利用できる理由はありません。マクロの仕事は、一般的な構文パターンを抽象化することであり、マクロを書く際に繰り返し現れる特定のパターンがあり、それらも抽象化の恩恵を受けることができます。

実際、すでにそのようなパターンの1つを見てきました――多くのマクロは、do-primes の最後のバージョンのように、マクロの展開に使用される gensym されたシンボルを保持するいくつかの変数を導入する **LET** で始まります。これは非常に一般的なパターンなので、独自の макро で抽象化してみてはどうでしょうか?

このセクションでは、そのためのマクロ、with-gensyms を記述します。つまり、コードを生成するコードを生成するマクロを書きます。複雑なマクロ作成マクロは、さまざまなレベルのコードを心の中で明確に保つことに慣れるまで少し混乱する可能性がありますが、with-gensyms はかなり単純で、有用ですが、あまり strenuous でない精神的な運動になります。

次のようなことを書けるようになりたいと考えています。

(defmacro do-primes ((var start end) &body body)
  (with-gensyms (ending-value-name)
    `(do ((,var (next-prime ,start) (next-prime (1+ ,var)))
          (,ending-value-name ,end))
         ((> ,var ,ending-value-name))
       ,@body)))

そして、それは前のバージョンの do-primes と同等になります。つまり、with-gensyms は、名前付き変数(この場合は ending-value-name)を gensym されたシンボルに束縛する **LET** に展開する必要があります。これは単純なバッククォートテンプレートで簡単に記述できます。

(defmacro with-gensyms ((&rest names) &body body)
  `(let ,(loop for n in names collect `(,n (gensym)))
     ,@body))

**LOOP** 式の値を補間するためにコンマを使用できることに注意してください。ループは、各束縛フォームが with-gensyms に与えられた名前の1つとリテラルのコード (gensym) を含むリストで構成される束縛フォームのリストを生成します。REPL で names をシンボルのリストに置き換えることで、**LOOP** 式が生成するコードをテストできます。

CL-USER> (loop for n in '(a b c) collect `(,n (gensym)))
((A (GENSYM)) (B (GENSYM)) (C (GENSYM)))

束縛フォームのリストの後、with-gensyms の body 引数は **LET** の本体としてスプライスされます。したがって、with-gensyms でラップするコードでは、with-gensyms に渡された変数のリスト内のいずれかの変数に参照できます。

do-primes の新しい定義で with-gensyms フォームをマクロ展開すると、次のようなものが見えるはずです。

(let ((ending-value-name (gensym)))
  `(do ((,var (next-prime ,start) (next-prime (1+ ,var)))
        (,ending-value-name ,end))
       ((> ,var ,ending-value-name))
     ,@body))

うまくいったようです。このマクロはかなり些細なものですが、さまざまなマクロがいつ展開されるかを明確に保つことが重要です。**DEFMACRO** of do-primes をコンパイルするとき、with-gensyms フォームは上記のコードに展開され、コンパイルされます。したがって、do-primes のコンパイル済みバージョンは、外側の **LET** を手動で記述した場合と同じです。do-primes を使用する関数をコンパイルするとき、with-gensyms によって生成されたコードが実行され、do-primes の展開が生成されますが、do-primes 自体は、do-primes がコンパイルされたときにすでに展開されているため、do-primes フォームをコンパイルするために必要ではありません。

単純なマクロを超えて

もちろん、マクロについてもっと多くのことを言うことができます。これまで見てきたすべてのマクロは、少しのタイピングを節約するかなり単純な例であり、物事を表現するための根本的に新しい方法を提供するものではありません。今後の章では、マクロなしでは事実上不可能だった方法で物事を表現できるマクロの例を見るでしょう。次の章から始めます。そこでは、シンプルでありながら効果的な単体テストフレームワークを構築します。


1関数と同様に、マクロは宣言を含めることもできますが、今はそれらを気にする必要はありません。

2**APPEND** は、まだ説明していませんが、任意の数のリスト引数を取り、それらを単一のリストにスプライスした結果を返す関数です。

3別の関数 **MACROEXPAND** は、結果の展開の最初の要素がマクロの名前である限り、結果を展開し続けます。しかし、これはしばしば、あなたが望むものよりもコードが何をしているのかのずっと低レベルなビューを示します。なぜなら、**DO** のような基本的な制御構造もマクロとして実装されているからです。つまり、マクロが最終的に展開されるものを見ることは教育的かもしれませんが、あなた自身のマクロが何をしているのかを見るにはあまり有用ではありません。

4マクロ展開がすべて1行で表示される場合、おそらく変数 ***PRINT-PRETTY*** が **NIL** であるためです。もしそうなら、(setf *print-pretty* t) を評価すると、マクロ展開が読みやすくなるはずです。

5これは Joel Spolsky の『Joel on Software』からのものです。http://www.joelonsoftware.com/articles/LeakyAbstractions.html でも入手可能です。Spolsky のエッセイでのポイントは、すべての抽象化はある程度漏洩するということです。つまり、完璧な抽象化は存在しないということです。しかし、それはあなたが簡単に修正できる漏洩を容認すべきだという意味ではありません。

6もちろん、do-primes ループの本体のフォームのように、複数回評価されるべきフォームもあります。

7このループが、素数の非一様な出現を考えると、必然的に無限であるかどうかは明らかではないかもしれません。それが実際に無限であるという証明の出発点は、任意の n > 1 に対して、n < p < 2n となる素数 p が存在するというベルトラントの公理です。そこから、前の素数の合計よりも小さい素数 P に対して、次の素数 P' も元の合計に P を加えたものより小さいことを証明できます。