いまから始めるCommon Lisp

この記事は[Lisp Advent Calendar 2017](https://qiita.com/advent-calendar/2017/lisp)の二日目の記事です。

# はじめに

この記事は、Common Lispという初めての人には初めましてな言語の入門記事です。

この世には、Common Lispというとってもカッコいい言語が存在します。その言語は[ANSIで規格が定められて](http://www.techstreet.com/cgi-bin/detail?product_id=56214)おり、[宇宙空間で動いたり深海で動いたり](https://qiita.com/guicho271828/items/1b78d8a7335e81e11791)し、[メタプログラミングが可能](http://keens.github.io/blog/2015/07/04/makuronitsuiteseirishitemiru/)で、しかも[C言語並に速い](http://keens.github.io/blog/2015/07/04/makuronitsuiteseirishitemiru/)という、超クールな言語なのです。

歴史あり、逸話ありのLispであって、実用的と言われるLispです。そんな言語、いますぐに始めてみたいと思いますよね？

しかしググってみると、なんだか処理系っていうの (?) がたくさんあったりしてどれを選んでいいのかわからない。rbenv的なものはないの？　パッケージマネージャは？　アプリケーションのビルドとかどうしたらいいの？　ぱっと実用的なプログラムをどう書いたらいいかわからない。おれたちはふんいきでCommon Lispをやっている……。

そんな疑問を解決するべくこの記事では、2017年12月時点におけるCommon Lispへの入門方法を解説します。

まず、処理系を導入したあと、Common Lispの文法を軽く概観し、その後実際にアプリケーション(lsコマンドとJSON APIサーバ)を作って実用性を確認します。

では、まず導入方法からです。

# Common Lisp環境の導入

Common Lispの導入はとっても簡単です。[Roswell](https://github.com/roswell/roswell)という、Rubyで言うところのrbenvのような処理系マネージャが存在します。なので、まずはroswellを導入します。

参考: [Installation - roswell wiki](https://github.com/roswell/roswell/wiki/Installation)

## macOS

有志の手によりhomebrewに登録されているため、簡単に入れることができます。

```shell-session
$ brew install roswell
```

## Windows

[こちらのページ](https://github.com/roswell/roswell/wiki/Installation#windows)から、自分のマシンに合ったものをダウンロードして展開し、パスを通してください。

## Linux

linuxbrewが入っているならば、以下のコマンドで入ります:

```shell-session
$ brew install roswell
```

あるいはソースからビルドしましょう(以下ではUbuntuを想定)。

```shell-session
# 依存パッケージのインストール
$ sudo apt update
$ sudo apt install git build-essential automake libcurl4-openssl-dev
# リポジトリの取得
$ git clone https://github.com/roswell/roswell
# ビルド
$ cd roswell
$ ./bootstrap && ./configure && make
# インストール
# /usr/local/bin/にrosコマンドがインストールされる
$ sudo make install
```

## セットアップ

Roswellはそれ自身、コア以外の部分にCommon Lisp処理系を必要とします。以下のコマンドを叩くことで、Common Lisp処理系を取得し、roswellの設定の初期化やパッケージマネージャ (quicklisp) のインストールが行われ、完全に機能するようになります。

```shell-session
$ ros setup
```

なお、ふつうに`ros`コマンドを実行しても、処理系が足りていなければ自動でセットアップを行ってくれます。

## (Common Lispの処理系事情解説)

Common Lispのインストール方法を調べると、「〜の処理系は〜に特徴があり…」とでてきて混乱するかもしれません。

Common Lispは、Pythonなどと違い、一つの公式の実装が存在するわけではありません。ANSIで規定された規格があるため、規格で定められた機能を実装したものはすべてCommon Lispを名乗ることができます。そのため、Common Lispといっても、複数の実装がありうるのです。

ただ、規格があるとはいえ、スレッドやOSとのやりとりなど規格で規定されていないものは処理系の独自拡張を利用することになります。（処理系を跨いで可搬に書けるライブラリはもちろんあります。）

著名な処理系として、処理が速いオープンソースの処理系Steel Bank Common Lisp (SBCL)や、macのサポートが手厚いオープンソースの処理系Clozure Common Lisp (CCL)、GNUが保守するGNU CLISP (最近開発があまりアクティブでない気がする)、商用処理系でとても速いと噂のAllegro Common Lispなどがあります。

ここでは、roswellのセットアップで導入されるSBCLを用いて説明していきます。

# Common Lispの基本

それではまず、Common Lispのインタプリタ (REPLと呼ばれます) を立ち上げてみましょう。

```shell-session
$ ros run
*
```

SBCLでは`*`がプロンプトです (カレントパッケージを表示してほしい……)。ここにプログラムを入力すると、プログラムが読み込まれ、評価され、その結果が印字されます。

Hello Worldを出力するには`format`関数を使います。構文は後の項目で説明するとして、コードはこうです:

```lisp
* (format t "Hello World!~%")
Hello World!
nil
```

## デバッガからの抜けかた (12/02 21時ごろ追記)

typoしたりしてREPLがデバッガモードに移行したとき、抜けかたがわからないと指摘があったため、抜けかたを追記します。

たとえばHello Worldで`format`を打ち間違えて*foramt* (aとmが逆)と入力してしまったとしましょう。きっとこんなエラーがでます:

```lisp
* (foramt t "Hello world!~%")
; in: FORAMT T
;     (FORAMT T "Hello world!~%")
;
; caught STYLE-WARNING:
;   undefined function: FORAMT
;
; compilation unit finished
;   Undefined function:
;     FORAMT
;   caught 1 STYLE-WARNING condition

debugger invoked on a UNDEFINED-FUNCTION in thread
#<THREAD "main thread" RUNNING {1001928083}>:
  The function COMMON-LISP-USER::FORAMT is undefined.

Type HELP for debugger help, or (SB-EXT:EXIT) to exit from SBCL.

restarts (invokable by number or by possibly-abbreviated name):
  0: [CONTINUE      ] Retry calling FORAMT.
  1: [USE-VALUE     ] Call specified function.
  2: [RETURN-VALUE  ] Return specified values.
  3: [RETURN-NOTHING] Return zero values.
  4: [ABORT         ] Exit debugger, returning to top level.

("undefined function" T "Hello world!~%")
0]
```

いきなり大量に怒られるしプロンプトが変わってしまうし、だいぶ焦りますよね。このデバッガはけっこう高機能で、値が間違ってる程度であればその場で値を変更してエラーになった時点からプログラムを続行することもできてしまいます。が、ここではさっさと抜けてしまいます。`abort`と入力してエンターを押すと、デバッガモードを終了して通常のREPLに戻ることができます。

なので、デバッガが出てしまってもおどろかず飛び退かず、落ち着いて`abort`と打ってください。

-----

以下、ちょっとだけCommon Lispの構文等の紹介が入りますが、ここでは軽い紹介に留めます。詳しくは最下部の”Common Lispをさらに学ぶには"に記載のウェブサイトや書籍を参照してください。

## Common Lispのプログラムの書き方

Common Lispのプログラムの書き方はとっても簡単。覚えることは少ししかありません。

1. とりあえず開き括弧を書く
2. まずは関数名を書く
3. 関数に必要なだけ、引数を書く…
4. えいやっと閉じ括弧を書く

とっても簡単ですよね。これが関数呼び出しです。3.の引数がまた別の関数呼び出しだったりするときは、括弧がネストされていく感じです。

上で見たHello Worldの関数をもう一度見てみましょう:

```lisp
(format t "Hello World!~%")
```

開き括弧があり、`format`が関数名で、`t`と`"Hello World!~%"`が引数で、最後に閉じ括弧というわけです。`format`関数はC言語でいう`printf`のように書式化文字列を出力する関数で、出力先ストリーム(例では`t`)と書式文字列 (例では`"Hello World!~%"`) を引数にとります (お察しの通り、`~%`は改行です)。

これからCommon Lispのデータ型の話をします。

そこでリストというデータ型の話をしますが、**関数呼び出しのコードがリストとも見做せる**という点にはちょっとだけ意識を留めておいてください。この「プログラムがデータとして表現される」ことは、Lispにとってとても大事なことなのです。

### データ構造

#### アトム

アトムとは、リストではないデータのことです。たとえば、文字列や数値です。ほかにもCommon Lispにはシンボルという変わったデータ型が存在します。

例を見ましょう:

```lisp
;;; 数値
* 42
42
;;; 文字列
* "hello"
"hello"
```

これらはREPLに打ち込むと、評価された結果として自分自身が印字されます。この点ではシンボルも同じように、自分自身に評価されるデータ型です。

```lisp
;;; シンボル
* 'symbol
```

ちょっと待って。シンボルに`'`がついていますが、これは「変数名ではなくシンボルだよ」とREPLに伝えるための記法です。また、Common Lispではシンボルを読み込む際、**勝手に大文字に**変換されます (Common Lispに慣れていても、たまにイラッときます…)。

シンボルとは何か。Lisp初心者に聞かれると説明に困る質問ですね。ざっくり言うとシンボルは**名前**です。そして、変数として用いるときには**変数の格納場所の名前**になります。ちょっとむずかしいですね。

例を出すと、Hello Worldのコードの先頭にある`format`というのがシンボルです。あのコードでは、「リスト(後ほど説明します)の先頭にあるシンボルはオペレータ名である」というCommon Lispの規則によって、`format`というシンボルに結び付く関数そのものが取り出されて実行されていたわけです(「オペレータ名」と言ったのは、関数でない場合もあるためです)。

また、変数の格納場所の名前として、以下のようにして代入できます:

```lisp
;;; ちなみにここでたくさん警告がでますが無視してください
;;; グローバルな変数を作ったよ、と処理系が警告してくれているのです
* (setf hoge 42)
42
* hoge
42
```

このとき`hoge`には`'`を付けていません。これは`setf`の場合は、`setf`が**`hoge`を特別扱いしてくれる**からです。じつは`setf`は関数ではありません(マクロといいます)。一般には、「リストの先頭以外に現れたシンボルは変数である」という規則によって、シンボルが保持する値(シンボルが値を保持している状態を*シンボルが値に束縛されている*といいます)が取り出されます。REPLに`hoge`とだけ打ち込んでいるのがまさにそれです。

つぎはシンボルの中でも特殊なシンボルを見てみます。

```lisp
;;; キーワード
* :keyword
:keyword
;;; 空リスト兼、偽値
* nil
nil
;;; 真値
* t
t
SYMBOL 
```

`:`で始まるシンボル、キーワードは特殊なシンボルです。通常のシンボルはパッケージ(後述)の異なるシンボルを別のシンボルであると区別します(`CL-USER::HOGE`と`MY-PACKAGE::HOGE`は異なる)。しかし`:`で始まるシンボルは常に`KEYWORD`パッケージのシンボルとなります。なので名前が同じであれば等しいのです。その性質から、パッケージ名や関数のキーワード引数を表現するのにしばしば使われます。

`nil`はアトムでもありリストでもあるという、変わった値です。アトムとしてみるとき、偽値として使われます。リストとしてみるときは、空リストを表現する値です。

一方で`t`は、真値を表す値です。

アトムについてはひととおり説明しました。次はLispの主なデータ構造、リストについてです。

#### リスト

リストとは、括弧で囲まれたデータを連ねた形式のデータです。その実体はコンスセルというデータ型を用いた一方向線形リストですが、コンスセルについては詳しく説明しません。

ここでは、**リストの見た目がLispの関数呼び出し等にクリソツである**という点に留意してください。

```lisp
;;; 数値のリスト
* '(1 2 3)
(1 2 3)
;;; シンボルのリスト
* '(a b c)
(A B C)
```

リストにも`'`を付けます。これはREPLに「関数呼びだしではなく(データとしての)リストだよ」と伝えるためのものです。これがないと、以下の二つを区別することができなくなってしまうためです:

```lisp
;;; シンボルと文字列の混在リスト (リストとして受け取られる)
* '(format t "hello~%")
(FORMAT T "hello~%")
;;; 関数呼び出し (プログラムとして受け取られる)
* (format t "hello~%")
hello
```

Common Lispの持つ他のデータ型には、ハッシュテーブル、配列、パス名(pathname)などありますが、使うときに適宜解説します。

つぎは、関数の定義方法を紹介します。

### 関数定義

関数を定義するには`defun`を使います。再三言いますが、**コードがリストになっていて`オペレータ名 + 引数...`の形式になっている**ことに注意しましょう。

```lisp
* (defun hello (name)
    (format t "hello, ~a!~%" name))
HELLO
* (hello "wintermute")
hello, wintermute!
```

引数は通常の引数以外にも、キーワード引数や可変長引数、オプション引数などといったものがありますが、ここでは解説しません。

つぎは、条件分岐が繰り返しのやり方を見てみます。

### フロー制御

Common Lispの条件分岐や繰り返しのオペレータはいくつかあります。ここではFizz Buzzを実装しつつ紹介していきます。何度でも言いますが、コードがリストになっていて…(省略

まず`if`。Common Lispでは偽が`nil`でそれ以外の値が真です。

```lisp
* (setf num 42)
42
* (if (> num 40)
    'over-forty   ; 真のとき
    'under-forty) ; 偽のとき
OVER-FORTY
```

Common Lispの`if`は文ではなく式なので、実行後に真偽それぞれの場合実行される式の値が返ってきます。

偽のときはなにもしない場合、`when`というマクロが使えます。

```lisp
* (when (> num 40)
    'over-forty)  ; 真のとき
OVER-FORTY
```

ループは計数繰り返しができる`dotimes`やリスト上の繰り返しができる`dolist`があります。ちなみに`format`関数の書式指定子`~a`は「後ろのパラメータを一つ表示する」という意味です。

```lisp
* (dotimes (n 5)
    (format t "~a, " n))
0, 1, 2, 3, 4, 
* (dolist (e '(0 1 2 3 4))
    (format t "~a, " e))
0, 1, 2, 3, 4, 
```

これでFizz Buzzを実装する準備が整いました。Common LispにおけるFizz Buzzはこうです:

```lisp
* (defun fizzbuzz (n)
    (if (or (zerop (mod n 3))
            (zerop (mod n 5)))
      (progn
        (when (and (zerop (mod n 3)))
          (format t "fizz"))
        (when (and (zerop (mod n 5)))
          (format t "buzz"))
        (format t " "))
      (format t "~a " n)))
FIZZBUZZ
* (dotimes (n 20)
    (fizzbuzz (1+ n)))
1 2 fizz 4 buzz fizz 7 8 fizz buzz 11 fizz 13 14 fizzbuzz 16 17 fizz 19 buzz 
```

わーお。なっがーい。
あんまりカッコよくないやり方な気がしますが、カッコよくするのは読者への課題とする。

ちなみにさらっと使いましたが`progn`というのはC言語でいうと`if {...}`の`{...}`に相当するオペレータです。複数の式を実行するときに、特に副作用を目的として使います(実際に`format`で副作用している)。

つぎはメタプログラミング！　Lispのマクロについて説明します。

### マクロ

Lispの力の真髄といえばメタプログラミングを可能にする、マクロです。ちなみに**C言語のマクロとはまったく別物**なので、そちらを想起している方は忘れてください。ぜんぜん違います。

C言語のマクロは文字列処理です。他方、Common Lispのマクロは構文木変換です。

ここまでの説明で「`defun`とか`if`とか`setf`がリストに見える」ことを散々強調してきました。ここまででリストに対するオペレータをあまり説明しませんでしたが、プログラムでリストを処理できます。プログラムがリストであるなら、プログラムでプログラムを処理することができるはずです。そして、マクロがまさにそれを実現する機能なのです。

ここでは`when`を自分で実装してみましょう。`my-when`の使い方(仕様)は以下です:

```lisp
(my-when 条件式
  真のとき実行される式...)
```

これは機能的には、以下の`if`と等価です:

```lisp
(if 条件式
    (progn
      真のとき実行される式...)
    nil) ; なにもしない
```

`when`として`条件式`と`真のとき実行される式`が与えられれば、`if`のほうの式を機械的に組み立てられますね。そんなの機械にやってほしいですね。やらせましょう！

```lisp
(defmacro my-when (cond &body body)
  `(if ,cond
       (progn ,@body)
       nil))
```

はい、機械に`my-when`の展開を教えました。ここで`&body body`という引数がでてきますが、これは可変長引数で、`&body`の後のシンボルに以降の引数が入ります。

`if`の式の前についているクォートはシングルクォート`'`ではありません。バッククォート`` ` ``です。これはリストのテンプレートに値を埋め込むことのできるクォートです。値の埋め込みは`,`で示します。つまり、`,cond`は条件式(アトムかリストがくる)をそのまま`if`の条件部分に埋め込みます。`,@body`は可変長引数として渡ってくるリストの中身を、そこに埋め込みます。

バッククォートは慣れないと分かりづらいので、デバッグ例を出して説明します。

マクロのデバッグには`macroexpand-1`が使えます。式を受け取り、マクロ呼び出しだったらそのマクロを展開した式を返す関数です。こいつに`my-when`呼び出しの式を渡してやると…。

```lisp
* (macroexpand-1 '(my-when (> num 40)
                    (format t "40!~%")
                    'over-forty))
(IF (> NUM 40)
    (PROGN (FORMAT T "40!~%") 'OVER-FORTY)
    NIL)
T
```

`progn`の中が可変長引数`((format t "40!~%") 'over-forty)`の外側の括弧を外したものになっていますね。これが`,@body`の埋め込み方法です。

ここまでCommon Lispの構文をざっと説明しました。つぎはちょっと脇道に逸れて、Common Lispの開発環境のお話です。

## SLIMEあるいはslimv.vimのすすめ

Common Lispで開発するときに、エディタの支援は欠かせません。コードフォーマッタや名前補完の面でも利点がありますが、それよりも、処理系との連携がとても容易になるためです。そして、この力はとても強烈です。

ここで、EmacsにおけるSLIME、Vimにおけるslimv.vimを使うとどのようなことが実現するか、例を出しましょう。

以下のような関数書いたファイルをエディタで開き、同時にSLIMEを立ち上げます:

![cl-slime1.png](https://qiita-image-store.s3.amazonaws.com/0/109205/5ab3f352-205a-de84-2ae5-5579765f9f23.png)

エディタのバッファで`hello`関数を評価(SLIMEではカーソルを末尾に置いてC-x C-e)してやると、ファイルに書かれた関数定義が即、下のREPLのプロセスに送られます。

これを、まさに**プログラムの実行中に**行うことができます！　ホットデプロイです！

![out-1.optimized.gif](https://qiita-image-store.s3.amazonaws.com/0/109205/537b80f4-f716-c941-eec2-8a004630bec0.gif)


この画像ではREPLで、無限ループの中で`hello`関数の実行と2秒のスリープをひたすら実行しています。その実行中に上の関数定義を変更し(`hello`→`helloooo`)、その定義をREPLに送りました(WARNINGが出ている箇所)。

その結果、**プログラムの実行中にも関わらず**`hello`関数の出力が変わっています！

Deep Space 1の宇宙機に載ったプログラムの地球-木星間バグフィックスは、まさにこの機能を使って行われたそうです。カッコいい！

この恩恵に与るために、EmacsではSLIME、vimではslimv.vimの利用を強くお勧めします。

- Emacs: SLIMEの導入と使用方法は[モダンCommon Lisp第3回: SLIMEの使い方 基礎編](http://dev.ariel-networks.com/wp/archives/462)を参照
    - 今だと導入は`M-x package-install`で`slime`を入れればいいはず
- Vim: Slimvの導入と使用方法は[[備忘録] Roswell & Slimv の環境構築](https://blog.rudolph-miller.com/2016/12/02/roswell-and-slimv/)を参照

**2018-01-28更新**

今現在の各エディタにおける導入方法はこちらの記事が詳しいです: [「CommonLispの環境構築まとめ」](https://asciian.github.io/2018/seting-up-common-lisp/)


# Common Lispにおけるモジュールとライブラリ

## モジュール

Common Lispにおいてモジュールに相当するのは「パッケージ」です。SLIMEやSlimvでREPLを触っているとわかるのですが、REPLを立ち上げたときにはパッケージが`CL-USER`に設定されています。この中にはCommon Lispの標準関数が含まれているため、標準関数を利用できるというわけです。

パッケージは作ることもでき、カレントパッケージを切り替えることも可能です。これ以降は**プロンプトをSLIMEの表示に則りカレントパッケージを表示したものにして**説明していきます。

まず、パッケージを作るには`defpackage`を使います。

```lisp
CL-USER> (defpackage hoge-package
           (:use :cl))
#<PACKAGE "HOGE-PACKAGE">
```

このとき`(:use :cl)`を忘れないようにしてください。これは「Common Lispの標準関数が入ったパッケージ`CL`の関数を`hoge-package`に全てインポートする」という意味です。これを忘れると、このパッケージ内ではCommon Lispの標準関数を使えなくなり、パッケージ切り替えすらできなくなります。

パッケージの切り替えは`in-package`を使います。

```lisp
CL-USER> (in-package :hoge-package)
#<PACKAGE "HOGE-PACKAGE">
HOGE-PACKAGE> 
```

## ライブラリ

Common Lispの仕様には、プログラムをひとまとまりにしたライブラリを構成する方法が定められていません。そこで[ASDF (Another System Definition Facillity)](https://common-lisp.net/project/asdf/)というプログラムがライブラリ(システムと呼びます)の定義、ロードやコンパイルの仕方の制御を行ってくれます。ASDFは処理系に始めからバンドルされているものを使えるほか、roswellが最新のASDFを導入してくれたりします。

だいたい以下のようなディレクトリ構造が、Common LispのASDFを利用したライブラリでは一般的です。

```
hoge/
+ hoge.asd       ; システムhogeの定義(バージョン等情報、依存ライブラリ、ファイル定義)
+ hoge-test.asd  ; システムhogeのテスト用システムの定義
+ src/
  + hoge.lisp    ; システムhogeのプログラム
+ t/
  + hoge.lisp    ; hoge.lispのテストコード
```

システムの定義の流儀には、古いものは2000年ごろのコードで使われているものから、ここ二年ほどで提案されたものなど、いくつかがありますが、この記事では最近提案されたpackage-inferred-systemの流儀で説明します。

システム定義にはどのようなことを書けばいいのか(`hoge.asd`の中身)については、実際にプログラムを作成するときに解説します。

## パッケージマネージャ

ライブラリのインストールについても、規格で規定はされていませんが、有志の手でPythonのpipやnode.jsのnpmのようなものが作られています。[Quicklisp](http://cl.cddddr.org/index.cgi?Quicklisp)です。じつは、roswellが処理系をインストールした際に一緒に導入してくれています。

基本的にはREPL上で操作します。たとえばCommon LispのPerl互換正規表現ライブラリ`cl-ppcre`を検索して、ロードしてみます:

```lisp
;;; 名前で検索
CL-USER> (ql:system-apropos "ppcre")
#<SYSTEM arnesi/cl-ppcre-extras / arnesi-20170403-git / quicklisp 2017-10-23>
#<SYSTEM cl-ppcre / cl-ppcre-2.0.11 / quicklisp 2017-10-23>
#<SYSTEM cl-ppcre-template / cl-unification-20170630-git / quicklisp 2017-10-23>
#<SYSTEM cl-ppcre-test / cl-ppcre-2.0.11 / quicklisp 2017-10-23>
#<SYSTEM cl-ppcre-unicode / cl-ppcre-2.0.11 / quicklisp 2017-10-23>
#<SYSTEM cl-ppcre-unicode-test / cl-ppcre-2.0.11 / quicklisp 2017-10-23>
#<SYSTEM optima.ppcre / optima-20150709-git / quicklisp 2017-10-23>
#<SYSTEM parser-combinators-cl-ppcre / cl-parser-combinators-20131111-git / quicklisp 2017-10-23>
#<SYSTEM trivia.ppcre / trivia-20170830-git / quicklisp 2017-10-23>
#<SYSTEM trivia.ppcre.test / trivia-20170830-git / quicklisp 2017-10-23>

;;; ロード
CL-USER> (ql:quickload :cl-ppcre)
To load "cl-ppcre":
  Load 1 ASDF system:
    cl-ppcre
; Loading "cl-ppcre"
.
(:CL-PPCRE)

;;; 利用
CL-USER> (cl-ppcre:regex-replace-all "い" "おじいさんのとけい" "イェー！")
"おじイェー！さんのとけイェー！"
T
```

### (Quicklispの問題点とその解決)

Quicklispには二つの問題点があります。Quicklispのライブラリリポジトリは月に一回しか更新されないこと、ライブラリバージョンを指定できないことです。そのため、環境によってquicklispでの導入タイミングが異なると、ライブラリのバージョンに差が発生し、プログラムが動かないといった事態が発生します。

また、roswellのquicklispでインストールされたライブラリは`~/.roswell/lisp/quicklisp`に置かれ、すべてのアプリケーションがここを見ます。アプリケーション毎に依存ライブラリのバージョンを変えたい場合、これは不便です。

ここでは、それらの問題点を解決するライブラリ[qlot](https://github.com/fukamachi/qlot)があることを紹介しておくに留めます。Qlotでは、プロジェクトローカルにquicklispを導入することで、上記の問題を解決しています([作者によるqlot説明記事](http://blog.8arrow.org/entry/2014/08/01/234941))。

# Common Lispを実用する

Common Lispは実用的なことができる言語であることを説明するために、実際に実用的なプログラムを作ってみます。ここでは二つの実用的なプログラムを作ります:

1. `cat`コマンド - コマンドラインアプリケーション
2. JSON APIサーバ - Webアプリケーション


## 実用1: catコマンドを作る

実用的なアプリケーションその1は、`cat`コマンドです。ここでは簡単に、以下の仕様で作ります。

- `cat`という名前の実行可能ファイル
- `cat FILE`でテキストファイルの中身を標準出力に出力
- `cat`とだけ打ったときは入力を標準入力とする

なお、解説が目的のためテストは書きませんが(長くなるので)、ちゃんとしたものを作るときはテストを書きましょう。

### プロジェクトを用意する

まずはcl-catプロジェクト(trivialな機能のライブラリは`cl-*`という命名が多い)を構成するファイルを`touch`コマンド等で作成します。場所は`~/.roswell/local-projects/`の中にしてください。ここがroswellにおけるPATH的な場所になります。

ただし`cat.ros`は`cl-cat/roswell`ディレクトリに移動してから`ros init cat`で作成してください。そうすることでroswellスクリプトのテンプレートからファイルが作られます。

```
cl-cat/
+ roswell/     ; roswellスクリプト用のディレクトリ
  + cat.ros     ; catコマンドのエントリポイントを持つroswellスクリプト
+ cl-cat.asd    ; ASDFのシステム定義ファイル
+ main.lisp    ; コア機能の入ったソースファイル
```

#### ASDFのシステムを定義する

まずはASDFのシステム定義を書きます。`cl-cat.asd`の中身はこのような感じです:

```lisp
;;; cl-cat.asd
(in-package :cl-user)    ; どのパッケージにいるかわからないのでCL-USERパッケージにする
(defpackage :cl-cat-asd  ; ASDFのシステム定義用のパッケージをつくる
  (:use :cl :asdf))      ; 標準関数とASDFの関数をパッケージ修飾なしで呼べるようにする
(in-package :cl-cat-asd) ; 作ったパッケージにする

(defsystem :cl-cat
  :class :package-inferred-system   ; システム定義のスタイルをpackage-inferred-systemにする
  :description "cat command implemented with Common Lisp"
  :version "0.1"
  :author "t-sin"
  :license "Public Domain"
  :depends-on ("cl-cat/main"))  ; ソースファイルを相対パスで指定する
```

ほぼおまじないにはなるのですが、コメントで説明を付けました。システムをpackage-inferred-systemスタイルで定義するよう指定しています。Common Lispはファイルとパッケージが結び付いていなくていい言語ですが、近年「それだとわかりにくいよね」といったような動機でone-package-one-fileが提案されました。Common Lisp界では今後このスタイルがナウでヤングでモダンになりそうです。従来式だと、プロジェクトのソースファイル間の依存関係を手書き(!)していたのですが、このスタイルだと自動で推測してくれるので、利点もあります。

`main.lisp`にもパッケージを定義しておきましょう。なおパッケージ名とシステム名が同じで混乱しそうですが、別のレイヤーのものなので問題はありません:

```lisp
;;; main.lisp
(in-package :cl-user)
(defpackage :cl-cat
  (:use cl)
  (:export :cat))  ; 今回作成する関数(まだない)をパッケージ外部に公開
(in-package :cl-cat)
```

この状態で一度プロジェクトをREPLでロードしてみましょう:

```lisp
CL-USER> (ql:quickload :cl-cat)
To load "cl-cat":
  Load 1 ASDF system:
    cl-cat
; Loading "cl-cat"
[package cl-cat/main]
(:CL-CAT)
```

ここまでは成功しました！　これから`main.lisp`にcatコマンドの中核である入力を読んで出力を吐く動作を書きます。それはこんな関数です: 

```lisp
(defun cat (input-stream output-stream)
  (loop
     for line = (read-line input-stream nil :eof)
     until (eq line :eof)
     do (write-line line output-stream)))
```

Common Lispにはストリームがあります。標準入出力だったりファイルを開いたりすると得られるものです。そのストリームを二つ受け取って、入力ストリームの内容を出力ストリームに順次流し込んでやる、というのが上記のコードです。ちなみに`:eof`とあるのは、通常`read-line`関数はEOFに達した状態で呼ぶとエラーを投げますが、その代わりに`:eof`というキーワードを返すよう指定しているものです。

また、コマンド部分を以下のように書きます:

```lisp
#!/bin/sh
#|-*- mode:lisp -*-|#
#|
exec ros -Q -- $0 "$@"
|#
(progn ;;init forms
  (ros:ensure-asdf)
  #+quicklisp (ql:quickload '(:cl-cat) :silent t)  ; cl-catをロード
  )

(defpackage :ros.script.ls.3720612639
  (:use :cl))
(in-package :ros.script.ls.3720612639)

(defun main (&rest argv)  ; roswellスクリプトのエントリポイント
  (declare (ignorable argv))
  (if (>= (length argv) 1)   ; 引数があるとき
      (with-open-file (in (first argv))  ; 一つめの引数をファイル名として入力ストリームを開き
        ; 入力を開いたファイル、出力を標準出力ストリームにしてcatする
        (cl-cat:cat in *standard-output*))
      ; 引数がないので、標準入力と標準出力を指定してcatする
      (cl-cat:cat *standard-input* *standard-output*))) ; 
;;; vim: set ft=lisp lisp:
```

長いですがほぼテンプレートなので`main`関数に注目しましょう。

コマンドライン引数は、処理系毎にアクセス方法に差があり非常に煩雑な部分なのですが、Roswellが抽象化して`argv`としてリストで渡してくれます。これにより、roswell登場以前には難しかったCommon Lispによるスクリプティングが可能になったのです！

上のようにライブラリのロードと`main`関数だけ実装すれば、実行可能なスクリプトができあがります。では、試しに実行してみましょう:

```shell-session
$ ./cat.ros ../cl-cat.asd
# 表示されるまでちょっと間がある…
(in-package :cl-user)
(defpackage :cl-cat-asd
  (:use :cl :asdf))
...
```

はい、できました！　でも、起動が遅いですよね。このスクリプト、roswellが起動し、処理系を起動し、ライブラリを読み込み(ライブラリソースを読み込むし、必要ならネットからダウンロードする!)…とオーバーヘッドが大きいんです。なので、これらを行ったあとの状態のメモリイメージをそのまま実行可能バイナリにしてしまい、実行速度を速くしてしまいましょう。こうやります:

```shell-session
$ ros build cat.ros
$ ls
cat  cat.ros
$ ./cat ../cl-cat.asd
(in-package :cl-user)
(defpackage :cl-cat-asd
  (:use :cl :asdf))
...
```

一瞬で起動しました。やったぜ。すごいぜ。ちなみに実行可能バイナリのファイルサイズは見ないほうが身のためです。

というわけで、コマンドラインアプリケーションをCommon Lispで書くのはすごく簡単です。では、二つめの実例です。

## 実用2: JSON APIを作る

つぎの実用的な例として、簡単なWebアプリケーションを作ります。ここで作るのはデータをJSONで返すAPIです。以下のような仕様で作ります:

- `/`では`Hello API!`と返す
- `/post/list`では記事のリストをJSON形式で返す
    - ID、タイトル、投稿日時、タグを返す
- `/post/id/xxxx`ではID`xxxx`の記事の情報をJSON形式で返す
- 記事の情報は変数にリストで持つ (簡略化のため)

ここでは、Common LispのマイクロWebフレームワークである[ningle](http://8arrow.org/ningle/)を使って開発します。ningleはプロジェクトスケルトンを必要としない、とても小さなフレームワークなので、ここではその流儀に従って、一つのファイルで開発していきます。

まずはじめに、`/`に対して`Hello API!`を返すコードを書いてみます。ファイル名は`app.lisp`としましょう。こんな感じです:

```lisp
;;;; app.lisp
;;; ningleをロード (ロード状況を出力しない)
(ql:quickload '(:ningle) :silent t)

;;; ningleのアプリケーションクラスをインスタンス化する
(defparameter *app* (make-instance 'ningle:<app>))

;;; アプリケーションクラスの`/`の戻り値を設定
(setf (ningle:route *app* "/")
      "Hello API!")

;;; clackupするためにアプリケーションインスタンスが返るようにする (後述)
*app*
```

Common Lispってオブジェクト指向言語でもあるんです。知ってました？

さて、アプリケーションを実行してみる前にひとつ説明を。ningleはサーバのインターフェースを抽象化してくれるCommon Lispのライブラリ[clack](https://github.com/fukamachi/clack)の上に作られています。このライブラリが`clackup`というアプリケーションを実行するコマンドを提供してくれていて、こいつに**最後がclackアプケーションを返すコードで終わる**Common Lispのソースファイルを渡してやるとアプリケーションが実行されるのです。上記のコードの最後が`*app*`をただ返すだけになっているのは、そのような理由があるからなんです。

では実行してみましょう。

```shell-session
$ clackup app.lisp
Hunchentoot server is going to start.
Listening on localhost:5000.
```

これでアプリケーションが実行されている状態です。別のターミナルからcurlで叩いてみると

```shell-session
$ curl localhost:5000
Hello API!$
```

こうなります。ちなみにアプリケーションの実行をREPLの上でやることもできます。REPLの上で実行すると、ソースファイル上の変更を実行中のプロセスに即時送ることができるので、こっちのほうが便利です。

```lisp
CL-USER> (defparameter app-handler (clack:clackup *app*))
Hunchentoot server is started.
Listening on localhost:5000.
APP-HANDLER
CL-USER>
```

`app-handler`で`clackup`の結果を受け取っているのは、アプリケーションを停止させたいときのためです。

では、まずデータを用意しておきましょう。ここではハッシュテーブル的なデータ構造としてkeyとvalueをリスト中に交互に並べる属性リスト (property list, plist) を使います。

```lisp
(defparameter *db*
  '((:id 1 :title "記事1" :date "2017-01-01" :tags ("tag1" "tag2" "tag3")
     :body "本文1本文1本文1本文1")
    (:id 2 :title "記事2" :date "2017-01-02" :tags ("tag2" "tag3")
     :body "本文2本文2本文2本文2")
    (:id 3 :title "記事3" :date "2017-01-03" :tags ("tag1" "tag3")
     :body "本文3本文3本文3本文3")))
```

`defparameter`は初出ですね。これは、スペシャル変数(ダイナミック変数ともいう)をという、グローバルで上書き可能な変数を定義するためのものです。スペシャル変数は名前を`*`で囲む、というのがCommon Lispの慣例的な命名規則です。

`*db*`からデータを取り出すのに`mapcar`を、取り出したplistをJSON形式にするのに[jonathan (Common LispのJSONライブラリ)](http://rudolph-miller.github.io/jonathan/)を使います。まず、冒頭の`ql:quickload`は以下のように変更します:

```lisp
(ql:quickload '(:jonathan  ; 追加した
                :ningle)
              :silent t)
```

次に、レコードを`/post/list`に含めるデータ(ID、タイトル、投稿日時、タグ)に変換する関数を書きましょう。

```lisp
(defun to-list (record)
  (list :id (getf record :id)
        :title (getf record :title)
        :date (getf record :date)
        :tags (getf record :tags)))
```

そして最後に、`/post/list`にルーティングします

```lisp
(setf (ningle:route *app* "/post/list")
      (jonathan:to-json (mapcar #'to-list *db*)))
```

この状態でファイルを`clackup`してみてください。REPLで書いている人は、アプリケーションを終了させず、ただ定義をREPLに送るだけです。

```lisp
$ curl localhost:5000/post/list
[{"ID":1,"TITLE":"記事1","DATE":"2017-01-01","TAGS":["tag1","tag2","tag3"]},{"ID":2,"TITLE":"記事2","DATE":"2017-01-02","TAGS":["tag2","tag3"]},{"ID":3,"TITLE":"記事3","DATE":"2017-01-03","TAGS":["tag1","tag3"]}]
```

つぎに、IDを与えられたポストの情報を返すAPIを実装します。コードはこんな感じです:

```lisp
(setf (ningle:route *app* "/post/id/:id")
      #'(lambda (params)
          (let ((record (find (parse-integer (cdr (assoc :id params))) *db*
                              :key #'(lambda (r) (getf r :id)))))
            (if (null record)
                "{}"
                (jonathan:to-json record)))))
```

いろいろ出てきました。

`lambda`は無名関数ですが、ningleではURLに関数をルーティングすることができ、その場合URLから取り出されたパラメータが`params`に連想リスト(association list, alist)として渡されます。基本方針としては、URLで渡ってきたIDを取り出して(`(cdr (assoc :id params))`)、整数に変換(`parse-integer`)したもので、`*db*`の`:id`の値を検索(`find`)します。

たとえばID 2に対してAPIを呼んでみると…

```shell-session
$ curl localhost:5000/post/id/2
{"ID":2,"TITLE":"記事2","DATE":"2017-01-02","TAGS":["tag2","tag3"],"BODY":"本文2本文2本文2本文2"}
```

とまあ、こんな感じです。


# おわりに

Common Lispで実アプリケーションを書くところまで持っていってみました。いかがでしょうか。「LISPは人工知能を書くのに使われた、黴の生えた古臭い言語だ」という都市伝説と異なり、実用的なアプリケーションを書くことのできる言語であることがおわかりいただけたと思います。

Common Lispは、まだまだ死んでいません。そのエコシステムは発展を続けており、現代的な構成でアプリケーションを構築することも可能です。

# Common Lispをさらに学ぶには

もしここまで読んで、Common Lispをさらに学習したくなった場合、以下のサイトや書籍が参考になりますよ。

では、Happy Hacking!

## 書籍

- [Land of Lisp](https://www.oreilly.co.jp/books/9784873115870/)
    - ゲームを作りながらCommon Lispに入門する本。たのしい。
- [実践Common Lisp](https://www.ohmsha.co.jp/book/9784274067211/)
    - Common Lispの基礎を解説しつつ、音楽配信サーバを作成する本。良書。
- [On Lisp](https://estore.ohmsha.co.jp/titles/978427406637P)
    - Common Lispにおけるマクロの妙技を『ハッカーと画家』の著者が伝授する本。良書。
    - 日本語訳がWebでも読めます: <http://www.asahi-net.or.jp/~kc7k-nd/onlispjhtml/>

## ウェブサイト

- [Common Lisp Hyperspec](http://clhs.lisp.se/) (英語)
    - Common LispのANSI仕様をHTML化したもの。標準関数の仕様を確認するのに便利。
- [CLiki.net](http://www.cliki.net/) (英語)
    - Common Lisp情報サイト。カテゴリ別に分類されたライブラリ一覧がある。
- [微酔半壊: Common Lisp: loopマクロ用法抄](http://smpl.seesaa.net/article/29800843.html) (日本語)
    - loopマクロの概要を知りたいとき、または使い方を思い出すときに。
- [Common Lispのformat関数](http://super.para.media.kyoto-u.ac.jp/~tasuku/format-func.html)
    - format関数の`~a`とか`~%`のことをもっと知りたいときに。