2011-08-31

16進ダンプ

REPLから使いたくなって書いた。

使い方は以下の通り。(unsigned-byte 8)を要素に持つシーケンスを扱える。十行ごとにヘッダが入り、アドレス表示部分は長さ(標準で8桁)とオフセットを指定できる。テキスト表示部分はstandard characterかつgraphicな文字だけ表示できる。

> (hex-dump (sb-ext:string-to-octets "string"))
========== +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F =================
00000000 : 73 74 72 69 6E 67                               | string
NIL
>

2011-08-05

cl-fn

昨日のdefaliasだけど、似たようなコードを発見した。

Ron Garretがユーティリティライブラリで、

(defmacro define-synonym (s1 s2)
  `(progn
     (defun ,s1 (&rest args) (declare (ignore args)))
     (setf (symbol-function ',s1) (function ,s2))))

という関数を定義してた。

何度か目を通してるはずなのに何故気付かなかったんだ、と一瞬後悔したけど、良く見たらs2を直接function特殊形式に渡してる。これだと、関数名とlambda式以外を渡すことが許されないので、純粋に別名を付けるためだけを目的としたもののようだ。セーフ。こちらの主な目的は関数合成とかの結果に名前を付けることだから、上のコードは使えない。

安心した所で、無駄にならなかったdefaliasを、関数を扱うときに良く使われるユーティリティ関数とまとめてcl-fnというライブラリにした。ついでに、lambdaを書くのに疲れてきたので、前述のRon Garretのユーティリティからfnというマクロも貰ってきた。

;; &restを使わずに引数全体を束縛できる
(funcall (fn args args) 0 1 2)
;=> (0 1 2)

;; _で引数を無視できる(警告が出ないように宣言も付く)
(funcall (fn (x _) x) 0 1)
;=> 0

なんてことができるちょっと賢いやつ。ただし、リーダには手を入れないので、

((fn (x) x) 0)

みたいなことはできない。直接lambda式を呼びたいことなんてあんまりないから問題ないとは思うけど。

ちなみに、使いたい機能だけ楽にインポートできるように、パッケージを細かく分けておいた。例えば、curryとrcurryだけ使いたい場合は、cl-fn.paパッケージだけ使えば大丈夫。全部入りが欲しいならcl-fnを使う。余分なものまでインポートしなくて良いので綺麗好きな人でも安心。

2011-08-04

defalias

Emacs Lispには、関数に別名を付けるdefaliasという関数があるんだけど、これが欲しくなったので書いてみた。

(defmacro defalias (name function-designator)
  (with-gensyms (function designator)
    `(let* ((,designator ,function-designator)
            (,function (if (functionp ,designator)
                           ,designator
                           (symbol-function ,designator))))
       (setf (symbol-function ',name) ,function)
       ',name)))

マクロにしたのはクォートを付けるのが面倒だから。第二引数はfunction designatorなので、シンボルでも関数でも大丈夫。

普通に別名を付けることもできるけど、考えている主な使い所は、合成したり部分適用した関数に名前を付けたりするとき。

;; これを
(setf (symbol-function '2*)
      (curry #'* 2))

;; こう書ける
(defalias 2* (curry #'* 2))

(2* 3)  ;=> 6

他にも誰かが似たようなものを作ってそうだったから探してみたんだけど、見付けられなかった。

2011-07-06

string=の意外な利点

今まで、string=を使わずにequalで済ませていた。性能が要求される場面ではstring=の方が良いと思うけど(equalは汎用の比較関数なので、処理の振り分けの分だけどうしても遅くなる。ただ、型宣言をすれば、処理系によってはstring=と同じ処理に最適化されるかもしれない)、そんなコードなんて全然書かない。なので、すっかり存在を忘れていた今日この頃。Ron Garretのユーティリティを読んでいたら、自分にとっては意外な利点を発見した。string=は文字列とシンボルの比較に便利。

ユーティリティの中にある、

(defun ignorevar? (v)
  (and (symbolp v) (string= v "_")))

というコードを読んで気付いたんだけど、string=に直接シンボルを渡している。あれ? と思ってHyperSpecを引いたら、渡すのはstring designatorで良いらしい。string designatorっていうのは、文字とシンボルと文字列のこと。

以前書いたマクロの中で、

(defun <-p (x)
  (equal (symbol-name x) "<-"))

っていうコードがあったんだけど、string=を使えば、

(defun <-p (x)
  (string= x "<-"))

こう、ちょっとだけ短く書けて、ちょっとだけ嬉しい。大きな違いはないんだけど、ささやかな幸せ、というか。

何にせよ、勉強になった。

2011-06-28

パターンマッチングによる処理の分岐(2):Fare-matcher

Fare-matcherは、MLスタイルのパターンマッチングによる処理の分岐を、本格的にCommon Lispに取り入れるために作られたライブラリ。リストと多値、ベクタ、CLOSオブジェクトに対応し、パターンの表現力が高い。以下は2011年6月28日現在で最新のリビジョンの解説。

まずはパターンについて。パターンはS式で表現され、次のような種類がある。なお、定義リスト中の「*」と「+」は、0回以上の繰り返し、1回以上の繰り返しを表す。

リテラル
値同士をequalで比較して一致するときにマッチする
シンボル
どんな値にもマッチし、その値でシンボルを束縛する。ただし「_」と「*」の場合、値を束縛せずに捨てる(ワイルドカード)
(cons パターン パターン)
consは、car部とcdr部がそれぞれのパターンとマッチするコンスにマッチする
(list パターン+)
listは、要素の数がパターンの数と一致し、それぞれの要素の値とパターンがマッチするリストにマッチする
(list* パターン* シンボル)
list*は、要素の数がパターンの数以下で、それぞれの要素の値とパターンがマッチするリストにマッチする。最後のシンボルは、パターンのマッチングが済んだ後に残っている要素のリストで束縛される
(values パターン+)
valuesは、それぞれの値とパターンがマッチする多値にマッチする。多値の数とパターンの数が一致しない場合、nilがマッチングに使われる
(vector パターン+)
vectorは、要素の数がパターンの数と一致し、それぞれの要素の値とパターンがマッチするベクタ(一次元の配列)にマッチする
(slot* (スロット名 パターン)+)
slot*は、スロットの値とパターンがマッチするCLOSオブジェクトにマッチする
(accessor* (アクセサ名 パターン)+)
accessor*は、アクセサが返す値とパターンがマッチするCLOSオブジェクトにマッチする
(and パターン+)
andは、値とすべてのパターンがマッチしたときにマッチする
(or パターン+)
orは、値とパターンのいずれかがマッチしたときにマッチする
(of-type 型)
of-typeは、値の型と型が一致したときにマッチする
(when テスト)
whenは、テストが真のときにマッチする(ガード)
(like-when パターン テスト)
like-whenは、値とパターンがマッチし、テストが真のときにマッチする。(and パターン (when テスト))の構文糖

whenやlike-when、andやorの組み合わせで、複雑なパターンを作ることができる。

次はAPIについて。

ifmatch pattern exp &optional (ifmatches t) iffails
ifm pattern exp &optional (ifmatches t) iffails
ifと同じ二方向の条件分岐。expがpatternにマッチした場合ifmatchesを評価し、しなかった場合iffailsを評価する。ifmはifmatchの別名。
match exp &rest clauses
ematch exp &rest clauses
condやcaseなどと同じ、任意の数の方向への条件分岐。clauseのcar部がパターンで、cdr部がマッチした場合の処理。caseとecaseの関係と同じで、ematchはどのパターンにもマッチしない場合、エラーを発生させる。
letm pattern val &body body
destructuring-bindのような、構造化代入のためのマクロ。valがpatternにマッチした場合bodyを評価し、しなかった場合はエラーを発生させる。

letmという名前はモナド方面で使われている可能性があるため、use-packageするときは気を付けたほうが良いかもしれない。

使用例を挙げる。

(ql:quickload :fare-matcher)
(defpackage :fare-matcher-test (:use :cl :fare-matcher))
(in-package :fare-matcher-test)

(ifm 0 0)
(ifm 'x 'x)
(ifm #\a #\a)
(ifm "a" "a")
;=> T

(ifm x 2 x)
;=> 2

(ifm (list x y) '(0 1) (values x y))
;=> 0, 1

(ifm (cons f r) '(0 1 2) (values f r))
(ifm (list* f r) '(0 1 2) (values f r))
;=> 0, (1 2)

(ifm (values x y) (truncate 3.14) (values x y))
;=> 3, 0.1400001

(ifm (vector 1 2 x) #(1 2 3) x)
;=> 3

(defclass point ()
  ((x :accessor point-x :initarg :x :initform 0)
   (y :accessor point-y :initarg :y :initform 0)))

(let ((p (make-instance 'point :x 3 :y 2)))
  (ifm (slot* (x px) (y py)) p (values px py)))
;=> 3, 2

(let ((p (make-instance 'point :x 4 :y 5)))
  (ifm (accessor* (point-x px) (point-y py)) p (values px py)))
;=> 4, 5

(ifm (and (cons x 2) (cons 1 y)) '(1 . 2) (values x y))
;=> 1, 2

(ifm (or 1 3) 3)
;=> T

(ifm (of-type number) 1)
;=> T

(ifm (when t) :anytime-t)
(ifm (and x (when (symbolp x))) 'symbol)
;=> T

(ifm (like-when (list x y z) (eql (+ x y z) 6)) '(1 2 3))
(ifm (like-when (list x y z) (eql (+ x y z) 6)) '(0 0 6))
;=> T

(ifm (list (list x y) z) '((:a :b) :c) (values x y z))
;=> :A, :B, :C

(ifm (cons (cons key value) rest) '((:x . 100) (:y . 200)) (values key value rest))
;=> :X, 100, ((:Y . 200))

複雑な構造のリストも難なく処理できるため、リスト処理に威力を発揮する。

マクロを展開してみる。

; (ifm (cons f r) '(0 1 2) (values f r))
(FLET ((#:FAILURE-CONTINUATION NIL NIL))
  (DECLARE (IGNORABLE #'#:FAILURE-CONTINUATION))
  (LET ((#:FORM
         (MULTIPLE-VALUE-BIND (#:R012110)
             '(0 1 2)
           #'(LAMBDA NIL (VALUES #:R012110))))
        F
        R)
    (DECLARE (IGNORABLE #:FORM))
    (FUNCALL (BLOCK #:M%POINT
               (MULTIPLE-VALUE-CALL
                 (FUNCALL #'(LAMBDA (#:R012110 #:R112111)
                              #'(LAMBDA (#:FORM)
                                  (FARE-UTILS:MVBIND (#:R212112 #:R312113)
                                                     (FUNCALL
                                                      #'(LAMBDA
                                                         (FARE-MATCHER::FORM)
                                                         (IF (CONSP FARE-MATCHER::FORM)
                                                             (PROGN (VALUES (CAR FARE-MATCHER::FORM) (CDR FARE-MATCHER::FORM)))
                                                             (RETURN-FROM #:M%POINT #'#:FAILURE-CONTINUATION)))
                                                      #:FORM)
                                                     (PROGN (FUNCALL #:R012110 #:R212112) (FUNCALL #:R112111 #:R312113)))))
                          #'(LAMBDA (#:FORM) (SETF F #:FORM))
                          #'(LAMBDA (#:FORM) (SETF R #:FORM)))
                 (FUNCALL #:FORM))
               #'(LAMBDA NIL (VALUES F R))))))

funcallでクロージャを呼ぶようになっている。このため、On Lispの「構造化代入」で紹介されているような、マクロでifなどのプリミティブな式まで変換する手法に比べて、コストが大きい。

(declaim (optimize (speed 3) (safety 1) (debug 1) (space 1)))

(time (iter (repeat 1000000)
            (letm (list x y z)
                (list (random 10) (random 10) (random 10))
              (values x y z))))
;-> (ITER (REPEAT 1000000) (LETM (LIST X Y Z) (LIST (RANDOM 10) (RANDOM 10) (RANDOM 10)) (VALUES X Y Z))) took 1,906 milliseconds (1.906 seconds) to run 
;                       with 2 available CPU cores.
;   During that period, 1,766 milliseconds (1.766 seconds) were spent in user mode
;                       47 milliseconds (0.047 seconds) were spent in system mode
;   531 milliseconds (0.531 seconds) was spent in GC.
;    352,000,032 bytes of memory allocated.

(time (iter (repeat 1000000)
            (destructuring-bind (x y z)
                (list (random 10) (random 10) (random 10))
              (values x y z))))
;-> (ITER (REPEAT 1000000) (DESTRUCTURING-BIND (X Y Z) (LIST (RANDOM 10) (RANDOM 10) (RANDOM 10)) (VALUES X Y Z))) took 312 milliseconds (0.312 seconds) to run 
;                       with 2 available CPU cores.
;   During that period, 312 milliseconds (0.312 seconds) were spent in user mode
;                       0 milliseconds (0.000 seconds) were spent in system mode
;   63 milliseconds (0.063 seconds) was spent in GC.
;    24,000,032 bytes of memory allocated.

速度を気にしない場所では問題にならないけど、性能が必要な部分で使うには厳しいかもしれない。とは言え、いつでも速度が求められるわけではないから、例えば、複雑なリスト処理が必要とされがちだけど、速度は問題にならないマクロの定義などでは、便利に使えるんじゃないだろうか。少なくとも自分は便利に使っている。

まとめると、性能が要求される部分ではボトルネックになる可能性があるが、複数のデータ型に対応し、表現力も高いため、速度を気にしないで良い部分では威力を発揮する。

以下参考文献。