masatoi.github.io Index
2026-03-17: memo: yaskkserv2 をUbuntu 24.04で使う手順
memo: yaskkserv2 をUbuntu 24.04で使う手順
SKKを使いつつ、新語や合成語の変換にはGoogleサジェストを使いたい。 そのようなときにyaskkserv2を使ってみてなかなか良かった。以下はmacos用の記事。
なかなか良かったので、Ubuntuでも使えるようにセットアップしてみた。以下はそのメモ
Rustのセットアップ(もしされていなければ)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
yaskkserv2をclone、ビルド、インストール
git clone https://github.com/wachikun/yaskkserv2.git
cd yaskkserv2
cargo build --release
sudo cp -av target/release/yaskkserv2 /usr/sbin/
sudo cp -av target/release/yaskkserv2_make_dictionary /usr/bin/
SKK辞書を取得、辞書作成
mkdir -p $HOME/dic
wget http://openlab.ring.gr.jp/skk/skk/dic/SKK-JISYO.L
yaskkserv2_make_dictionary --dictionary-filename=$HOME/dic/dictionary.yaskkserv2 SKK-JISYO.L
yaskkserv2 をsystemdユーザーサービスとして自動起動する手順
Ubuntu 24.04でyaskkserv2をユーザーログイン時に自動起動し、常駐させる設定手順。
1. systemdユーザーサービスディレクトリを作成
mkdir -p ~/.config/systemd/user
2. サービスファイルを作成
vi ~/.config/systemd/user/yaskkserv2.service
以下の内容を記述：
[Unit]
Description=yaskkserv2 Japanese input server
After=network.target
[Service]
Type=simple
ExecStart=/usr/sbin/yaskkserv2 --no-daemonize --google-suggest %h/dic/dictionary.yaskkserv2
Restart=always
RestartSec=3
StandardOutput=journal
StandardError=journal
[Install]
WantedBy=default.target
重要ポイント:
--no-daemonize: systemdがプロセスを管理するため、デーモン化しない%h: ホームディレクトリに自動展開されるType=simple: フォアグラウンドで実行Restart=always: プロセス終了時に自動再起動
3. systemdに設定を読み込ませる
systemctl --user daemon-reload
4. サービスを起動
systemctl --user start yaskkserv2.service
5. 起動状態を確認
systemctl --user status yaskkserv2.service
以下のように表示されればOK：
● yaskkserv2.service - yaskkserv2 Japanese input server
Loaded: loaded (...)
Active: active (running) since ...
Main PID: xxxxx (yaskkserv2)
エラーがある場合はここにログが出るはず。
プロセスも確認：
ps aux | grep yaskkserv2
ddskkなどのクライアントで実際に動作確認してみる。 絶対に辞書に登録されていなさそうな新語を変換してみるとよい。
6. ログイン時の自動起動を有効化
systemctl --user enable yaskkserv2.service
確認：
systemctl --user is-enabled yaskkserv2.service
# => enabled と表示される
管理コマンド
# サービスを停止
systemctl --user stop yaskkserv2.service
# サービスを再起動
systemctl --user restart yaskkserv2.service
# 自動起動を無効化
systemctl --user disable yaskkserv2.service
# ログを確認
journalctl --user -u yaskkserv2.service -f
# 過去50件のログを表示
journalctl --user -u yaskkserv2.service -n 50 --no-pager
トラブルシューティング
エラーコード 203/EXEC が出る場合
which yaskkserv2でパスを確認し、ExecStartのパスを修正- フルパスで指定する（
~や変数は使わない）
サービスがすぐ終了する場合
--no-daemonizeオプションを追加- ログで原因を確認:
journalctl --user -u yaskkserv2.service -n 50
辞書ファイルが見つからない場合
- パスが正しいか確認:
ls -la ~/dic/dictionary.yaskkserv2 - サービスファイルのパスを修正して
daemon-reloadを実行
完了
次回ログイン時から自動的にyaskkserv2が起動します（ポート1178で待ち受け）。
2025-10-13: Codex CLIでClojure開発する際のメモ: cljコマンドがsandbox下で動かないとき
Codex CLI の非対話シェル環境で clj コマンドを動かす設定方法
Codex CLI や CI/CD 環境などの「非対話シェル」では、~/.bashrc 内の brew shellenv が ps コマンドを実行するため、サンドボックス制限でエラーを起こすことがあります。
これを回避しつつ Homebrew 経由でインストールしたコマンドを利用するには、非対話シェル時のみ固定パスを設定して即終了するのが最も安全です。
以下は、実際に Codex CLI 環境で clj コマンドを正常に動かせた設定例です。
設定例：~/.bashrc
# For non-interactive shells (e.g. Codex CLI):
# pass only the fixed PATH of Homebrew and exit immediately
case $- in
*i*) ;;
*)
export PATH="/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/bin:/bin${PATH:+:$PATH}"
export PATH="$HOME/local/bin:$HOME/bin:$HOME/.local/bin:/usr/local/bin/:/opt/homebrew/opt/openjdk/bin:$PATH"
return
;;
esac
# From this point down, it is executed only in an interactive shell.
# Homebrew setting
eval "$(/opt/homebrew/bin/brew shellenv)"
Codex CLI サンドボックス内での clj-kondo の実行
CLI がサンドボックス内で実行される場合、lint コマンドは警告のみを出力する場合でも「失敗」することがよくあります。サンドボックスはゼロ以外の終了コードをエラーとして扱うため、clj-kondo のデフォルトの終了コード（警告の場合は 2、設定の問題の場合は 3）により、自動化処理の継続が妨げられることがあります。
対処方法
-
clj-kondo の生のエイリアスを維持する。
deps.ednに:lint-runエイリアスの例を作成し、clj-kondo.mainを指定して、希望するオプション（キャッシュディレクトリ、パスなど）を設定します。 - ラッパースクリプトを追加する（例：
script/lint.clj）。このスクリプトは：clojure -M:lint-run（または生のエイリアス）をシェル実行し、- stdout/stderr をそのまま出力し、
- 終了コードを無視してラッパーが常に
0で終了するようにします（オプションで抑制されたコードをログに記録）。 これにより、検出結果を保持しながらサンドボックスを正常に動作させます。
-
公開エイリアスをラッパーに向ける。 プロジェクトの
:lintエイリアス（または開発者が呼び出すコマンド）を変更し、:main-opts ["-i" "script/lint.clj"]または-m clojure.main script/lint.cljを使用してラッパーを読み込むようにします。 - lint を再実行する。
clj -M:lintは、Codex CLI サンドボックスの制限下でも、すべての警告/エラーを表示し、正常に終了するようになります。
同じパターンは、基礎となるコマンドが致命的でない理由でゼロ以外の終了コードを返す可能性がある場合、他のツール（fmt、spec、カスタムタスク）でも機能します。ツールをラップし、その出力を転送し、終了コードを正規化します。
lint.clj
(require '[clojure.java.shell :as shell])
(let [args (vec *command-line-args*)
{:keys [exit out err]} (apply shell/sh "clojure" "-M:lint-run" args)]
(when (seq out)
(print out)
(flush))
(when (seq err)
(binding [*out* *err*]
(print err)
(flush)))
(when (pos? exit)
(binding [*out* *err*]
(println (format "clj-kondo exited with %d; treating as success per repo policy." exit))
(flush))))
deps.edn
:lint
{:main-opts ["-i" "script/lint.clj"]}
:lint-run
{:extra-deps {clj-kondo/clj-kondo {:mvn/version "2025.09.22"}}
:mvn/repos {"clojars" {:url "https://repo.clojars.org/"}}
:main-opts ["-m" "clj-kondo.main" "--cache-dir" ".clj-kondo/.cache" "--lint" "src" "test"]}
2025-01-05: 関数
関数の定義方法
Common Lispでは、関数を定義する基本的な方法としてdefunが用意されています。
defunは関数名とパラメータリスト、そして関数の本体を指定することで関数を定義します。
本体の最後の式の値が返り値となります。
以下は、defunを使用した基本的な関数定義の例です。
(defun add-two-numbers (a b)
(+ a b))
この関数 add-two-numbers は、2つの引数aとbを受け取り、それらを加算した結果を返します。
定義した関数は以下のように呼び出すことができます。
(add-two-numbers 3 5)
; => 8
無名関数（lambda）
関数を一時的に利用したい場合や、関数に名前を付ける必要がない場合、lambda式を使用して関数オブジェクトを直接作ることができます。
(lambda (x) (* x x))
このlambda式は、引数xを平方する無名関数を作ります。この無名関数をその場で呼び出すこともできます。
(funcall (lambda (x) (* x x)) 4)
; => 16
無名関数は、関数を引数として受け取る高階関数（例: mapcarやreduce）と組み合わせる際にも便利です。
(mapcar (lambda (x) (* x x)) '(1 2 3 4))
; => (1 4 9 16)
関数定義の柔軟性
Common Lispの関数定義には以下のような柔軟な特徴があります。
- パラメータリストの柔軟性: パラメータリストには、必須引数だけでなく、デフォルト値を持つオプショナル引数や任意の数の引数を受け取るための機構（
optional,rest）が用意されています（詳細は2.2で解説） - 再定義可能性: Common Lispでは、既存の関数を動的に再定義することが可能です。これにより、システム全体を再ロードすることなく、特定の関数の振る舞いのみを即座に変更できます
(defun square (n) (* n n))
(defun cube (n) (* n (square n)))
;; squareを最適化されたバージョンで再定義
(defun square (n)
(declare (type fixnum n)
(optimize (speed 3) (safety 0)))
(* n n))
;; cubeはそのまま使える
(cube 3) ; => 27
- 独自の名前空間の利用: 関数は関数専用の名前空間に属しており、シンボルの名前空間とは区別されています。そのため、関数名と同じ名前を持つ変数を定義しても衝突することはありません
- 関数名のシンボルから関数の実体を参照するには
symbol-functionを用います。これとsetfを組み合わせることでdefunを使わずに関数を定義することもできます - 通常の名前空間に存在する関数オブジェクトを呼び出すには
funcallを使います。
- 関数名のシンボルから関数の実体を参照するには
;; 関数と変数では名前空間が分かれている
(defun my-function () "This is a function")
(setf my-function "This is a variable")
(my-function) ; => "This is a function"
my-function ; => "This is a variable"
;; 関数の名前空間に関数オブジェクトを設定することで関数定義と同じことができる
(setf (symbol-function 'square) (lambda (x) (* x x)))
(square 3) ; => 9
;; 変数の名前空間に関数オブジェクトを設定するとfuncallが必要
(setf square-as-variable (lambda (x) (* x x)))
(funcall square-as-variable 3) ; => 9
局所関数
局所関数は、特定のスコープ内でのみ利用可能な関数です。Common Lispでは flet や labels で局所関数を定義します。
これにより、プログラムの構造化、名前の衝突回避、コードの可読性向上が可能です。
flet: シンプルな局所関数の定義
fletは、スコープ内で一時的に利用する関数を定義します。
定義された関数は再帰呼び出しをサポートしません。
(defun calculate-sum (numbers)
(flet ((square (x) (* x x)))
(mapcar #'square numbers)))
この例では、局所関数squareを定義し、numbersの各要素を平方する処理を実現しています。
labels: 再帰や相互再帰をサポートする局所関数の定義
labelsは再帰や相互再帰を必要とする局所関数を定義する場合に使用します。
例: 再帰を用いた階乗計算
(defun calculate-factorial (n)
(labels ((factorial (x acc)
(if (zerop x)
acc
(factorial (1- x) (* x acc))))) ; 再帰呼び出し
(factorial n 1)))
この例では、局所関数factorialが再帰的に自身を呼び出して階乗を計算しています。
flet は再帰呼び出しをサポートしませんが、labels は再帰および相互再帰をサポートします。また、labelsでは複数の関数を並べて定義したときに先に定義したものを後の定義から使えます。
例: 相互再帰を利用した偶数・奇数の判定
(defun is-even (n)
(labels ((evenp (x) (if (zerop x) t (oddp (1- x))))
(oddp (x) (if (zerop x) nil (evenp (1- x)))))
(evenp n)))
再帰の有無で使い分けることで意図を明確化できます。
局所関数は、プログラムのスコープを制御し、命名の衝突を回避するために非常に有効な手段です。
fletとlabelsを適切に使い分けることで、コードの構造化と可読性を向上させることができます。これらを活用し、簡潔でメンテナンスしやすいコードを目指しましょう。
パラメータリスト
Common Lispの関数定義には、さまざまなパラメータ指定方法があります。 これにより、より柔軟な関数のインターフェースを設計することが可能です。
必須パラメータ
必須パラメータは、関数が呼び出される際に常に指定される必要がある引数です。
defunで単純にパラメータを列挙することで定義します。
(defun add (a b)
(+ a b))
(add 3 5) ; => 8
オプショナルパラメータ
オプショナルパラメータは、引数が指定されない場合にデフォルト値を使用する引数です。
&optionalを使って定義します。
(defun greet (name &optional (greeting "Hello"))
(format t "~A, ~A!~%" greeting name))
(greet "Alice") ; => Hello, Alice!
(greet "Alice" "Hi") ; => Hi, Alice!
キーワードパラメータ
キーワードパラメータは、引数を名前付きで指定できる引数です。
&keyを使って定義します。
(defun configure (width &key (height 100) (color "blue"))
(format t "Width: ~A, Height: ~A, Color: ~A~%" width height color))
(configure 200 :height 150 :color "red")
; => Width: 200, Height: 150, Color: red
(configure 200)
; => Width: 200, Height: 100, Color: blue
restパラメータ (可変長引数)
restパラメータは、任意の数の引数をリストとして受け取る引数です。
&restを使って定義します。
(defun sum (&rest numbers)
(reduce #'+ numbers))
(sum 1 2 3 4) ; => 10
(sum) ; => 0
これらのパラメータリストの組み合わせにより、関数の引数設計は柔軟かつ強力になります。 次節では、それぞれのパラメータタイプを活用した実践例を紹介します。
2024-03-03: On Lisp読書会(2) 参加メモ
On Lisp読書会@Shibuya.lisp
2章 関数
末尾再帰
末尾再帰とは再帰呼び出しから戻ってきた後に何も処理がない再帰のこと。 最近の処理系なら単純なループに変換してくれる。
例として、リストの長さを計算する関数の末尾再帰でないバージョンが出てくる。
#>はデバッグプリント用のリーダーマクロで事前にロードしておく。
(ql:quickload :cl-debug-print)
(cl-debug-print:use-debug-print)
(defun our-length (lst)
(if (null #>lst)
0
#>(1+ (our-length (cdr lst)))))
(our-length '(1 2 3))
; LST => (1 2 3)
; LST => (2 3)
; LST => (3)
; LST => NIL
; (1+ (OUR-LENGTH (CDR LST))) => 1
; (1+ (OUR-LENGTH (CDR LST))) => 2
; (1+ (OUR-LENGTH (CDR LST))) => 3
これを見るとlstが再帰呼び出しの度に縮退していき、空リストに到達してから長さに1ずつ足されていっているのが分かる。
この末尾再帰でないバージョンで100万件のリストの長さをカウントしようとするとstackoverflowになる。
(defun our-length (lst)
(if (null lst)
0
(1+ (our-length (cdr lst)))))
(let ((huge-list (loop for i from 1 to 1000000 collect i)))
(our-length huge-list))
;; Control stack exhausted (no more space for function call frames).
;; This is probably due to heavily nested or infinitely recursive function
;; calls, or a tail call that SBCL cannot or has not optimized away.
;; PROCEED WITH CAUTION.
;; [Condition of type SB-KERNEL::CONTROL-STACK-EXHAUSTED]
次にdisassembleしてみる。 大体の見方は
RSIなどのRから始まるのがレジスタL0などがラベルCALLが関数呼び出しJMPやJNEがジャンプで指定したラベル位置にジャンプするJNEはJump Not Equalで、直前のTESTが失敗したときにジャンプするという条件分岐命令でもある
(disassemble 'our-length)
; disassembly for OUR-LENGTH
; Size: 83 bytes. Origin: #x54CE23E3 ; OUR-LENGTH
; 3E3: 498B4510 MOV RAX, [R13+16] ; thread.binding-stack-pointer
; 3E7: 488945F8 MOV [RBP-8], RAX
; 3EB: 4881FE17010050 CMP RSI, #x50000117 ; NIL
; 3F2: 7505 JNE L1
; 3F4: 31D2 XOR EDX, EDX
; 3F6: L0: C9 LEAVE
; 3F7: F8 CLC
; 3F8: C3 RET
; 3F9: L1: 8D46F9 LEA EAX, [RSI-7]
; 3FC: A80F TEST AL, 15
; 3FE: 7531 JNE L2
; 400: 488B5601 MOV RDX, [RSI+1]
; 404: 4883EC10 SUB RSP, 16
; 408: B902000000 MOV ECX, 2
; 40D: 48892C24 MOV [RSP], RBP
; 411: 488BEC MOV RBP, RSP
; 414: E8C9DA65FB CALL #x5033FEE2 ; #<FDEFN OUR-LENGTH> <= 再帰呼び出し
; 419: 480F42E3 CMOVB RSP, RBX
; 41D: 488B75F0 MOV RSI, [RBP-16]
; 421: BF02000000 MOV EDI, 2
; 426: E8E5EA11FF CALL #x53E00F10 ; SB-VM::GENERIC-+
; 42B: 488B75F0 MOV RSI, [RBP-16]
; 42F: EBC5 JMP L0
; 431: L2: CC53 INT3 83 ; OBJECT-NOT-LIST-ERROR
; 433: 18 BYTE #X18 ; RSI(d)
; 434: CC10 INT3 16 ; Invalid argument count trap
42FのJMPと3F6のL0の間でループしており、その途中で再帰呼び出しのCALL命令があるのでループの度に関数が呼ばれていることが分かる。
次に、末尾最適化版の例が出てくる。 アキュームレータaccを導入することで計算の途中結果を関数の引数として次の再帰呼び出し時に渡している。
こちらはlstの縮退とaccへの加算が並行して進んでいることが分かる。
(defun our-length-tco (lst)
(labels ((rec (lst acc)
#>lst #>acc
(if (null lst)
acc
(rec (cdr lst) (1+ acc)))))
(rec lst 0)))
(our-length-tco '(1 2 3))
; LST => (1 2 3)
; ACC => 0
; LST => (2 3)
; ACC => 1
; LST => (3)
; ACC => 2
; LST => NIL
; ACC => 3
これは100万要素のリストに対して呼び出してもstackoverflowエラーにならない。
(defun our-length-tco (lst)
(labels ((rec (lst acc)
(if (null lst)
acc
(rec (cdr lst) (1+ acc)))))
(rec lst 0)))
(let ((huge-list (loop for i from 1 to 1000000 collect i)))
(our-length-tco huge-list))
; => 1000000
disassembleしてみると、4FAのJNEと4D0のL0の間でループになっており、間には加算以外の関数呼び出しはないことが分かる。
(disassemble 'our-length-tco)
; disassembly for OUR-LENGTH-TCO
; Size: 84 bytes. Origin: #x54CE24B3 ; OUR-LENGTH-TCO
; 4B3: 498B4510 MOV RAX, [R13+16] ; thread.binding-stack-pointer
; 4B7: 488945F8 MOV [RBP-8], RAX
; 4BB: 488B75F0 MOV RSI, [RBP-16]
; 4BF: 4531C0 XOR R8D, R8D
; 4C2: EB2F JMP L1
; 4C4: 660F1F440000 NOP
; 4CA: 660F1F440000 NOP
; 4D0: L0: 8D46F9 LEA EAX, [RSI-7]
; 4D3: A80F TEST AL, 15
; 4D5: 752B JNE L2
; 4D7: 488B7601 MOV RSI, [RSI+1]
; 4DB: 488975E8 MOV [RBP-24], RSI
; 4DF: BF02000000 MOV EDI, 2
; 4E4: 498BD0 MOV RDX, R8
; 4E7: E824EA11FF CALL #x53E00F10 ; SB-VM::GENERIC-+
; 4EC: 4C8BC2 MOV R8, RDX
; 4EF: 488B75E8 MOV RSI, [RBP-24]
; 4F3: L1: 4881FE17010050 CMP RSI, #x50000117 ; NIL
; 4FA: 75D4 JNE L0 ; 再帰呼び出しがなく、L0へのジャンプ(ループになっている)
; 4FC: 498BD0 MOV RDX, R8
; 4FF: C9 LEAVE
; 500: F8 CLC
; 501: C3 RET
; 502: L2: CC53 INT3 83 ; OBJECT-NOT-LIST-ERROR
; 504: 18 BYTE #X18 ; RSI(d)
; 505: CC10 INT3 16 ; Invalid argument count trap
SBCLの場合は (proclaim '(optimize speed)) などはしなくても末尾再帰最適化はやってくれるようだ。
再帰アルゴリズムの中には必ずしも末尾再帰の形にできないものもある。(quicksortとか)
(defun quicksort (list)
(if (null list)
nil
(let ((pivot (first list))
(rest (rest list)))
(append (quicksort (remove-if-not (lambda (x) (<= x pivot)) rest))
(list pivot)
(quicksort (remove-if-not (lambda (x) (> x pivot)) rest))))))
ここで最適化オプションの話が出てきており、1からnまでの整数の和を返す関数triangleの例が出てくる。
10億までの総和にすると10倍くらいの違いが出てくる。
(defun triangle (n)
(labels ((tri (c n)
(declare (optimize (speed 3) (safety 0))
(type fixnum n c))
(if (zerop n)
c
(tri (the fixnum (+ n c))
(the fixnum (- n 1))))))
(tri 0 n)))
(time (triangle 1000000000))
; Evaluation took:
; 0.252 seconds of real time
; 0.251020 seconds of total run time (0.251020 user, 0.000000 system)
; 99.60% CPU
; 953,885,348 processor cycles
; 0 bytes consed
(defun triangle-no-optimize (n)
(labels ((tri (c n)
(if (zerop n)
c
(tri (+ n c)
(- n 1)))))
(tri 0 n)))
(time (triangle-no-optimize 1000000000))
; Evaluation took:
; 2.948 seconds of real time
; 2.950525 seconds of total run time (2.950434 user, 0.000091 system)
; 100.10% CPU
; 11,212,179,642 processor cycles
; 0 bytes consed
コンパイル
compile関数で関数をコンパイルし、compiled-function-pで確認するという流れになっているのだが、SBCLの場合は普通に関数定義などを評価しただけでコンパイル済みになっていることが分かる。
clispのインタプリタで明示的にコンパイルする例を示した。
ここでSBCLはJITコンパイルか？という議論になった。 関数毎にインタラクティブに定義できるが、使われるときになってはじめてコンパイルされる(Just In Time)わけでないのでAhead of Timeコンパイルだろうという話になった。
インライン宣言の話にも軽く触れられている。4章のユーティリティ関数のところで実際に使っているのでそのときに紹介することにした。
3章 関数的プログラミング
関数的プログラミングとは、副作用を使わず、参照透明にしておくこと。(参照透明: 内部状態を持たず、同じ引数に対して常に返値を返すこと) このようになっていると関数単位でテスト、デバッグがしやすい。REPL上でのインタラクティブな開発とも相性がよい。
副作用を使う例:
;; 悪いポイント: 値を返さない。副作用のみを目的にしている
(defun bad-reverse (lst)
(declare (optimize speed))
(let* ((len (length lst))
(ilimit (truncate (/ len 2))))
(do ((i 0 (1+ i))
(j (1- len) (1- j)))
((>= i ilimit))
(rotatef (nth i lst) (nth j lst)))))
(setf lst '(a b c))
(bad-reverse lst)
; => NIL
lst ; => (C B A)
rotatefはsetfのように汎変数を受け取って、リスト要素のポインタ操作によって要素の置き換えを実現する。 そのためコンシングは発生しないが、リストは破壊的に変更される。
(time (rotatef (car lst) (caddr lst)))
; 0 bytes consed
lst ; => (A B C)
2024-02-23: On Lisp読書会(1) 参加メモ
On Lisp読書会@Shibuya.lisp
Shiubya.lispで、最近RustでSci-Lispという独自処理系を作られているchaploudさんからご提案があり、週一でOn Lispの読書会に参加することになった。 参加者は予定範囲を読んでいることを前提としており、モデレータが本の流れをなぞりながら都度質問や議論をするという感じの進め方だった。 以下は第1回の個人的なメモである。
1章 拡張可能なプログラミング言語
Lispが拡張可能な言語であり、ボトムアップスタイルのプログラミングに向いているということが主張されている。 ボトムアッププログラミングの対義語はトップダウンなデザインであり、ダムの建設など事前に全てパーツを計画し、それらを順序立てて組み立てていくやり方のことを指している。 ボトムアッププログラミングでは細かく汎用的なユーティリティを作っていき、その層を重ねていくということのようだ。より探索的なアプローチといえる。
プログラムはソフトウェアなのでダムの建設と違って柔らかく、一度作ってしまえば後戻りできないというものでもないため、このようなアプローチが向いている場面もある。
Lispは言語自体が柔軟なので汎用的なユーティリティを作りやすい(例として高階関数とマクロが挙げられている) → 言語自体を成長させていくことが容易、ということだと思った。
この辺はUNIX的な考え方−すなわち直交したシンプルなコマンドラインツールをシェル上で組み合わせることによって複雑なタスクを実現する−と近いという意見も出た。
問題に合わせてDSLを作るとより問題を短く記述できるため、メンテナンス性が増し、独自に導入した流儀を揃えることができる環境では威力を発揮すると主張している。 そのため小規模グループでの開発に向いているとされている。
感想: 最近では、高階関数やパターンマッチベースのマクロ機能はLispの専売特許というわけでもなくなってきているので、他の言語でもボトムアップアプローチはできるし、普通にやられていると思う。 とはいえCommon Lispのいい意味での枯れ具合とインタラクティブ性が高性能な処理系と同居しているというのは、いまだに特異的だと思っている。
2章 関数
Lispはほとんど関数の集合体であり、例外が少ない。
普通の言語では組込みオペレータであるような+も単なる関数として実装されている。
2章冒頭では関数定義の方法、lambdaによる無名関数、関数と変数の名前空間が異なりそれぞれにアクセスする方法が異なることが説明される。 関数もLispのデータ(操作対象)であるという例として、シンボルの属性リストに関数を格納して呼び出す例が出てきた。 Common Lispのシンボルが実はリッチなデータ構造で、属性リストを持てるというのが説明なしに出てくるのでシンボルの中身をインスペクタで見ることで解説した。
(defun behave (animal)
(funcall (get animal 'behavior)))
(setf (get 'dog 'behavior)
#'(lambda ()
(print "bark")))
(behave 'dog)
;; "bark"
(setf (get 'dog 'height) 30)
(inspect 'dog)
#|
The object is a SYMBOL.
0. Name: "DOG"
1. Package: #<PACKAGE "COMMON-LISP-USER">
2. Value: #<unbound slot>
3. Function: #<unbound slot>
4. Plist: (HEIGHT 30 BEHAVIOR #<FUNCTION (LAMBDA ()) {54CEF72B}>)
> 4
The object is a proper list of length 4.
0. 0: HEIGHT
1. 1: 30
2. 2: BEHAVIOR
3. 3: #<FUNCTION (LAMBDA ()) {54CEF72B}>
|#
レキシカルスコープとダイナミックスコープ
最近の言語ではレキシカルスコープが当たり前になっているので、むしろダイナミックスコープが何かという話になった。
defvarなどでスペシャル変数宣言するとダイナミックスコープになる(関数内部で自由な変数を外側のletで束縛するなどして実行時に変更できる)という説明をした(たぶん合ってる)
;; ダイナミックスコープの例
(defvar *y*)
(defun scope-test2 (x)
(list x *y*))
(let ((*y* 5))
(scope-test 3))
; => (3 5)
レキシカルクロージャ
関数が作られた環境への参照を関数内に閉じ込めることができ、そのような関数をクロージャと呼ぶ、ということだと理解している。
次の例では db が連想リストで、make-dbms内で作られている3つのアクセサ関数経由でしか参照も変更もできないというカプセル化がなされている。
あとは継承があればオブジェクト指向がほぼ実現できる、と書かれている。
(defun make-dbms (db)
(list
;; referrer
#'(lambda (key)
(cdr (assoc key db)))
;; setter
#'(lambda (key val)
(push (cons key val) db)
key)
;; cleaner
#'(lambda (key)
(setf db (delete key db :key #'car))
key)))
(defparameter cities (make-dbms '((boston . us) (paris . france))))
;; referrer
(funcall (first cities) 'boston) ; => US
(funcall (first cities) 'paris) ; => FRANCE
;; setter
(funcall (second cities) 'london 'england)
(funcall (first cities) 'london) ; => ENGLAND
;; cleaner
(funcall (third cities) 'london)
(funcall (first cities) 'london) ; => NIL
ローカル関数
labelsを導入して関数内の補助関数をローカル関数として定義する例が出てくる。
このinstances-inが外側のobjを閉じ込めているのでこれもクロージャの例になっている。
(defun count-instances (obj lsts)
(labels ((instances-in (lst)
(if (consp lst)
(+ (if (eq (car lst) obj) 1 0)
(instances-in (cdr lst)))
0)))
(mapcar #'instances-in lsts)))
;; リストの各要素リスト内のaの数を数える
(count-instances 'a '((a b c) (d a r p a) (d a r) (a a)))
余談として、labels以外にも flet や flet* などもあって、これらを使うと再帰を使っていないことが明確になるという話をした。
とはいえlabelsがあればこれらは基本いらないはず。とにかく言語要素を少なくするという考え方と、用途が微妙に異なる構文を多数用意しておくことでコンテキスト情報を与えるとう考え方があり、Common Lispは後者であるということだと思う。
Schemeのように内部関数定義でもいいのでは？と思うが、defunを使うとトップレベルに定義される。
(defun count-instances (obj lsts)
(defun instances-in (lst)
(if (consp lst)
(+ (if (eq (car lst) obj) 1 0)
(instances-in (cdr lst)))
0))
(mapcar #'instances-in lsts))
;; count-instancesを呼ぶ度にinstances-inが上書かれる
(count-instances 'b '((a b c) (d a r p a) (d a r) (a a)))
(instances-in '(d a r p a)) ; => 0
末尾再帰
ここから次回ということになった。 次回は自分がモデレータなので予習しておかねば…