diff --git a/package.l b/package.l
index 4ca6cd3..856d134 100644
--- a/package.l
+++ b/package.l
@@ -155,7 +155,7 @@
       (and intern
 	   (push `(mapc #'(lambda (x) (intern x package)) ',intern) forms))
       (and export
-	   (push `(export ',export package) forms))
+	   (push `(export (mapcar #'(lambda (x) (intern x package)) ',export) package) forms))
       (if forms
 	  `(eval-when (:compile-toplevel :load-toplevel :execute)
 	     (let* ((package (or (find-package ,package-name)

CL-USER> (boundp t)
T

CL-USER> (defun () () ())
NIL
CL-USER> (())
NIL

CL-USER> (defun &rest () '&body)
&REST
CL-USER> (&rest)
&BODY

CL-USER> (defparameter &body '&rest)
&BODY

((lambda (x asdf::&rest y)(list x y)) 1 2 3 4)

((lambda (x :&rest y)(list x y)) 1 2 3 4)

Welcome to Clozure Common Lisp Version 1.3-RC1-r11719M  (DarwinX8632)!
? (random 100)
13
? *random-state*
#.(CCL::INITIALIZE-RANDOM-STATE 14245 41223)
? (random 100)
46
? *random-state*
#.(CCL::INITIALIZE-RANDOM-STATE 47046 5865)

画面の共有が出来た方がいいのかなと思いますね。
昨日snmstsさんからslime.elのソースコードについて教えてもらっていた時の反省点です。

(slime-start)
(load "/path/to/swank-loader.lisp" :verbose t)
(swank-loader:init)
(setq swank::*log-events* t)
(swank:start-server "/path/to/tmpfile" :coding-system "utf-8-unix")

puttyのrawで接続(unixだとtelnet接続と同じこと）

00004F(:emacs-rex (swank:interactive-eval "(swank:connection-info)")  "cl-user" t 23)
00004F(:emacs-rex (swank:interactive-eval "(swank:connection-info)")  "cl-user" t 22)
で落ち

[1]> (format t "~,6E" 9.9999999d-6)

*** - +: NIL is not a number
The following restarts are available:
USE-VALUE      :R1      Input a value to be used instead.
ABORT          :R2      Abort main loop
Break 1 [2]> 
[3]> (format t "~,6G" 9.9999999d-6)

*** - +: NIL is not a number
The following restarts are available:
USE-VALUE      :R1      Input a value to be used instead.
ABORT          :R2      Abort main loop

* (format t "~,6E" 9.9999999d-6)
10.000000d-6
NIL
* (format t "~,6G" 9.9999999d-6)
10.000000d-6
NIL

elcome to Clozure Common Lisp Version 1.3-RC1-r11719M  (DarwinX8632)!
? (format t "~,6E" 9.9999999d-6)
1.000000D-5
NIL
? (format t "~,6G" 9.9999999d-6)
1.000000D-5
NIL

[1]> (format t "~,6G" 9.9999999d-6)
10.000000d-6
NIL

[2]>  (format t "~,6E" 9.9999999d-6)
10.000000d-6

+ Improved floating point number formatting. [ 1790496, 1928759 ]

メッセージからすると
http://clisp.cvs.sourceforge.net/viewvc/clisp/clisp/src/format.lisp?view=log
の 1.59 で修正された件ですかね

(defpackage "LOOP.CL-TEST.1"
  (:use)
  (:intern "FOO" "BAR" "BAZ")
  (:export "A" "B" "C"))
-> 不正なデータ型です: "A": symbol

defclass foo () 
  ((foo :initform 0 :accessor :foo)))

(:foo (make-instance 'foo))

(in-package :cl)
(:foo (make-instance 'cl-user::foo))
;=> 0

(pushnew "/Users/ancient/letter/lisp/clbuild/source/cl-fad/"
         asdf:*central-registry* :test #'equal)
(require :cl-fad)
(labels ((f (x)
           (cl-fad:walk-directory
            x
            #'(lambda (path)
                (let ((pd (pathname-directory path)))
                  (unless (member "_darcs" pd :test #'equal)
                    (pushnew
                     (make-pathname :directory pd)
                     asdf:*central-registry*
                     :test #'equal))))
            :test #'(lambda (path)
                      (string-equal "asd" (pathname-type path))))))
  (f "/Users/ancient/letter/lisp/lib/")
  (f "/Users/ancient/letter/lisp/clbuild/source/"))

Swing使う時の invokeLater とかダルかったんですよねー
(defmacro with-invoke-later  [& body]
  `(javax.swing.SwingUtilities/invokeLater (fn [] ~@body)))
とかすれば、
(defn alert [text]
  (with-invoke-later
    (. JOptionPane (showMessageDialog nil text))))
おぉ、シンプル～

前にソースに proper list じゃないリストがきたらどうなるんだ？という話を聞いて、改めて HyperSpec みたら
「とくになんもなければ、規格でいうリストは proper list の意」
と書いてあってびっくりした。

(define-syntax test-macro
  (syntax-rules ()
    ((_ body ...)
     (lambda (param) (warapper param (case-body body ... ))))))

(define-syntax case-body
  (syntax-rules ()
    ((_ body ...)
     ((#t) body ...))))

(define-syntax wrapper
  (syntax-rules ()
    ((_ param body ...)
     (case (param) body ...))))

(define hoge (test-macro (display "hoge")))
(hoge #t)

(define-syntax test-macro
  (syntax-rules ()
    ((_ body ...)
     (lambda (param) (case param (case-body body ... ))))))

(define-syntax case-body
  (syntax-rules ()
    ((_ body ...)
     (((#t) body ...)))))

(define hoge (test-macro (display "hoge")))
(hoge #t)

(define-syntax test-macro
  (lambda (x)
    (syntax-case x ()
      ((_ body ...)
       #`(lambda (param) (case param #,(case-body #'(body ...) )))))))

(define-syntax test-macro
  (lambda (x)
    (syntax-case x ()
      ((_ body ...)
       (with-syntax
           ((case-body
             (datum->syntax-object
              #'k
              (let ((bdy (syntax-object->datum #'(body ...))))
                (list '(#t) (car bdy))))))
         #'(lambda (param) (case param case-body)))))))

(defmacro let-bits ((&rest specs) num &body body)
  (let ((len (gensym))
        (offset (gensym)))
    `(let ((,len (integer-length ,num))
           (,offset 0))
       (let ,(mapcar (lambda (x)
                       (destructuring-bind (var size) x
                         `(,var (ldb (byte ,size (- ,len ,size (prog1 ,offset (incf ,offset ,size))))
                                     ,num))))
                     specs)
         ,@body))))

(define-syntax test-macro
  (syntax-rules ()
    ((_ e ...)
     (lambda (param) (case-body param e ...)))))

(define-syntax case-body
  (syntax-rules ()
    ((_ param) #f)
    ((_ param e1 e2 ...)
     (case param ((#t) e1)))))

(import (match))

(define-syntax dlambda
  (lambda (x)
    (let ((expand-body
	   (lambda (m)
	     (match m ((method-name arg-list . body)
		       `((,method-name) (apply (lambda ,arg-list ,@body) (cdr param))))))))
      (syntax-case x ()
	 ((_ () body ...)
	  (with-syntax
           ((case-body
             (datum->syntax
              #'_
              (let ((body (syntax->datum #'(body ...))))
		(map expand-body body)))))
	   #`(lambda param (case (car param) #,@#'case-body))))
	 ((_ (super) body ...)
	  (with-syntax
	   ((case-body
	     (datum->syntax
	      #'_
	      (let ((body (syntax->datum #'(body ...))))
		(map expand-body body)))))
	   #`(lambda param (case (car param) #,@#'case-body (else (apply super param))))))))))

うわぁ、大きいですね。
すいませんがサンプルの入力と展開系を…

今考えたのだと、たとえばこんな感じで
(define-syntax dlambda
  (syntax-rules ()
    ((_ () methods ...)
     (lambda (method-name . param) (dlambda-expand method-name param (methods .\
..))))))

(define-syntax dlambda-expand
  (syntax-rules ()
    ((_ method-name param ()) #f)
    ((_ method-name param ((name args body ...) . rest))
     (if (eq? method-name 'name)
         (apply (lambda args body ...) param)
         (dlambda-expand method-name param rest)))))

((dlambda () (methodA (x) (display x)) (methodB (x y) (cons x y))) 'metho\
dB 10 20)
=> (10 . 20)
こんな感じ

ジャンプテーブル好きなCL派にはこれ！
http://www.tfeb.org/lisp/toys.html#NCASE
整数で分岐するときに、コンパイラががんばってくれない場合につかいます。
分岐先をクロージャの配列として定義して、n番目の配列を funcall して自力ジャンプテーブルw

(define-syntax dlambda
  (syntax-rules ()
    ((_ () methods ...)
     (lambda (call-name . param) (dlambda-expand (lambda args (error "unhandled message")) call-name param methods ...)))
    ((_ (super) methods ...)
     (lambda (call-name . param) (dlambda-expand super call-name param methods ...)))))

(define-syntax dlambda-expand
  (syntax-rules ()
    ((_ super call-name param (method-name args body ...) . rest)
     (if (eq? call-name 'method-name)
	 (apply (lambda args body ...) param)
	 (dlambda-expand super call-name param rest)))
    ((_ super call-name param () ) (apply super `(,call-name ,@param)))))

(defun transform-bit-specs (specs value)
  (do* ((l (reverse specs) (cdr l))
        (item (car l) (car l))
        (sym (gensym))
        (n 0)
        (r nil))
      ((null l) (push `(,sym ,value) r) r)
    (push `(,(first item) (ldb (byte ,(second item) ,n) ,sym)) r)
    (incf n (second item))))
(defmacro let-bits ((&rest specs) num &body body)
  `(let* ,(transform-bit-specs specs num)
     ,@body))

(define-syntax %dlambda
  (syntax-rules ()
    ((_ super (method-name args body ...) ...)
     (lambda param
       (case (car param)
         ((method-name)
          (apply (lambda args body ...) (cdr param)))
         ...
         (else
          (super param)))))))

(define-syntax dlambda
  (syntax-rules ()
    ((_ () cls ...)
     (%dlambda (lambda args
                 (assertion-violation 'dlambda "unrecognized message" args))
               cls ...))
    ((_ (super) cls ...)
     (%dlambda super cls ...))))

(define (add a b) (+ a b))
(define-syntax test1
  (lambda (x)
    (syntax-case x ()
      ((_) #`(#,(add 1 2))))))

(define-syntax test
  (lambda (x)
    (define (add a b)
      (+ a b))
    (syntax-case x ()
      ((_) (add 1 2)))))

#
# お! casting spellの人の本ですね!
# 一瞬オライリーかと思いましたが、残念ながらオライリーじゃないんですねー
# オライリーはLispの本は出さないんでしょうかｗ
# 概要を眺めるに、実践CL路線なんですかね。
# ゲームがお題ってのは面白そう。
# これは誰が訳すんだろう(*'-')
# Lingrが5/31に閉鎖だそうで!!
# ここのデータはエクスポートできるそうなんですが、急だなー
# 2:09am 26x26g000001
# http://img.f.hatena.ne.jp/images/fotolife/g/g000001/20090218/20090218111740.gif
# 2:09am 26x26g000001
# とりあえずデータのエクスポートの申し込みはできました。
# 2:10am 26x26g000001
# メールで知らせてくれるらしいので、データエクスポートしてどっかに保存したいと思います。
# 2:11am 26x26g000001
# どこに非難しよう。shibuya.lispとかで保護してくれないかしら。
# 2:13am 26x26g000001
# IRCよりLingrの方が好きだったんですが、残念です
# 2:14am 26x26g000001
# http://img.f.hatena.ne.jp/images/fotolife/g/g000001/20090218/20090218111741.gif
# snmsts has joined
# 2:45am 26x26snmsts
# どこにおくー？
# (び) has joined
# 9:44am 26x26(び)
# SBCL 1.0.28来ましたね(アナウンスも)
# (び) has left
# (び) has joined
# g000001 has joined
# 3:06pm 26x26g000001