* Some Common lisp operators use EQ, rather than the usual EQL,
    in a way that cannot be overridden: CATCH, GET, GET-PROPERTIES,
    GETF, REMF, REMPROP, and THROW.  See table 5-11 on p 5-57 of the
    standard.

通常、比較関数は内部的に、EQではなくEQLを使うが、CATCH, GET, GET-PROPERTIES,
    GETF, REMF, REMPROP, THROWでは、EQが使われる。

(let ((tag 123))
  (handler-case (catch tag
                  (print "foo")
                  (print "bar")
                  (throw tag "quux")
                  (print "baz"))
    (error () (print "foo?"))))

"foo" 
"bar" かもしれないし、

比較が失敗して
"foo"
"bar"
"foo?"かもしれない。

  * The function LIST-LENGTH is not a faster, list-specific version
    of the sequence function LENGTH.  It is list-specific, but it's
    slower than LENGTH because it can handle circular lists.

list-lengthはLIST専用で速そうに思えるが、循環リストに対応しているため逆に遅い。

  * (FORMAT T ...) interprets T as *STANDARD-OUTPUT*
    All other I/O functions interpret T as *TERMINAL-IO*.

format関数は、Tを*standard-output*と解釈するが、他の関数は皆Tを*TERMINAL-IO*と解釈する。

(with-output-to-string (*terminal-io*) 
  (format T "foo")
  (format T "bar"))
;=> ""

(with-output-to-string (*standard-output*) 
  (format T "foo")
  (format T "bar"))
;=> "foobar"

(with-output-to-string (*terminal-io*) 
  (princ "foo" T)
  (princ "bar" T))
;=> "foobar"

  * COERCE will not perform all of the conversions that are available
    in the language.  There are good reasons for that, but some cases
    may be surprising.  For instance, COERCE will convert a single-character
    string to a character, but it will not convert a character to a 
    single-character string.  For that you need STRING.

(coerce "a" 'character)
;=> #\a

CL-USER> (with-output-to-string (*standard-output*)
	   (princ "foo")
	   (princ "bar"))
;=>"foobar"
CL-USER> (with-output-to-string (*standard-output*)
	   (princ "foo" nil)
	   (princ "bar" nil))
=>"foobar"

(coerce #\a 'string)
;=> できない

  * The DIRECTORY function returns the TRUENAME of each item in the
    result, which can be slow.  If you don't need the truenames, on
    some systems it's faster to run "/bin/ls" and read its standard
    output (if your Lisp supports this).

DIRECTORYは各アイテムのTRUENAMEを返すので遅い。
"/bin/ls"のような外部プロセスを呼びだして出力を取り込んだ方が速い場合がある。(処理系がサポートしている場合。)

  * The following trick for intercepting all unwinds is not portable
    and might not be allowed at all:

     (tagbody (unwind-protect (do-some-stuff)
                ;; Intercept all unwinds, ha ha!
                (go where-I-say))
       where-I-say
        ;; We always get here.
        (do-some-more-stuff))

    Informally: once an unwind to a certain point has begun, it must
    always go at least that far.  [See CLtL pages 189-192.]  Similar
    tricks using THROW or RETURN-FROM suffer the same fate.  I used 
    GO above because I think that makes the intention clearer.

http://www.lispworks.com/documentation/HyperSpec/Body/s_unwind.htm

(catch 'a
  (catch 'b
    (unwind-protect (throw 'a 1)
      (throw 'b 2))))

1. asdf::*central-registry*の設定
2. (asdf:oos 'asdf:load-op :asdf-install)
3. (load "/share/sys/cl/src/asdf-cache.lisp")
4. asdf-install:*locations*の設定
5. (asdf:oos 'asdf:load-op :asdf-install) ;設定が変ったので再度読み込み

(defun delete-asdf-install-fasls ()
  (mapc #'delete-file 
        (directory 
         (make-pathname :directory "/share/sys/cl/src/asdf-install/asdf-install/" 
                        :name :wild 
                        :type 
                        #+sbcl SB-FASL:*FASL-FILE-TYPE*
                        #+clozure (subseq (namestring ccl::*.fasl-pathname*) 1)))))

場所:    株式会社タイムインターメディア2F大会議室
        東京都新宿区坂町26-27 インテリジェントプラザビル 2F *3
参加費:  無料
参加条件:特にありませんが、上記の本とCommon Lisp処理系をインストールした
        ノートパソコンを持参することをお薦めします。
その他:  持ち込みネタ(PAIP本に関わる発表とかデモとか)大歓迎です。
        予定通りならp.79 3.10 Destructive Functionsから読み始めます。

2008-07-05  Tobias C. Rittweiler  

	`M-x slime-lisp-threads' will now contain a summary of what's
	currently executed in a thread that was created by Swank.

(defun peek-or-read-char (char stream)
  (if (char= char (peek-char t stream))
      (read-char stream)                
      (read stream nil t)))

(set-macro-character #\X 
 (lambda (stream char)
   `(say '(#\X
           ,(read stream nil t)
           ,(read stream nil t)
           ,(read stream nil t)
           ,(peek-or-read-char #\X stream)
           ,(read stream nil t))
         ,(read stream nil t))))

(defun say (who mesg)
  (let ((who (if (equal who '(#\X / _ / #\X <))
                 "ひだまりスケッチx365"
                 "ひなまりスケッテ869")))
    (format t "~A ~A" who mesg)))

X / _ / X < "来週も見てくださいね!"

;>>> ひだまりスケッチx365 来週も見てくださいね!

X / _ \ X < "来週も見てくださいね!"

;>>> ひなまりスケッテ869 来週も見てくださいね!

時間割:
20:00-21:30位まで
The Common Lisp Cookbook(LOOP篇) 終ったらStrings篇

The Common Lisp Cookbook:
http://cl-cookbook.sourceforge.net/
CLで色々書く(書きたい)方向け 

(loop for x in '(a b c d e)
      do (print x) )

(loop for x in '(a b c d e)
      for y in '(1 2 3 4 5)
      collect (list x y) )

((A 1) (B 2) (C 3) (D 4) (E 5))

* (loop for x from 1 to 5
      for y = (* x 2)
      collect y)

(2 4 6 8 10)* (loop for x from 1 to 5
      for y = (* x 2)
      collect y)

(2 4 6 8 10)

* (loop for x in '(a b c d e)
      for y from 1

      when (> y 1)
      do (format t ", ")

      do (format t "~A" x)
      )
      
A, B, C, D, E
NIL

(loop for x in '(a b c d e)
      for y from 1
      when (> y 1)
      do (format t ", ")
      end
      do (format t "~A" x))

(loop for x in '(a b c d e)
      for y from 1
      do (when (> y 1)
	   (format t ", "))
      do (format t "~A" x))

(loop for x in '(a b c d e)
      for y from 1
      do (when (> y 1)
	   (format t ", "))
      do (format t "~A" x))

* (loop for x in '(a b c d e 1 2 3 4)
	until (numberp x)
	collect (list x 'foo))

((A FOO) (B FOO) (C FOO) (D FOO) (E FOO))

(loop for x from 1
      for y = (* x 10)
      while (< y 100)

      do (print (* x 5))

      collect y)

5 
10 
15 
20 
25 
30 
35 
40 
45 
(10 20 30 40 50 60 70 80 90)

* (loop for x in '(a b c d e)
      for y from 1

      if (> y 1)
      do (format t ", ~A" x)
      else do (format t "~A" x)
      )
      
A, B, C, D, E
NIL

* (loop for x from 1 to 10
      collect (loop for y from 1 to x 
		    collect y) )

((1) (1 2) (1 2 3) (1 2 3 4) (1 2 3 4 5) (1 2 3 4 5 6) (1 2 3 4 5 6 7)
 (1 2 3 4 5 6 7 8) (1 2 3 4 5 6 7 8 9) (1 2 3 4 5 6 7 8 9 10))

(loop :repeat 5
   :do 
   (print "hello")
   (print "hello")
   (print "hello"))

(loop :repeat 5
   :do (print "hello") 
   :do (print "hello")
   :do (print "hello"))

(loop :repeat 5
   :do (progn
	 (print "hello")
	 (print "hello")
	 (print "hello")))

* (loop for (a b) in '((x 1) (y 2) (z 3))
      collect (list b a) )

((1 X) (2 Y) (3 Z))

* (let ((s "alpha45"))
  (loop for i from 0 below (length s)
	for ch =  (char s i)
	when (find ch "0123456789" :test #'eql)
	return ch) )

#\4

* (loop for x in '(foo 2) 
      thereis (numberp x))
T

* (loop for x in '(foo 2) 
      never (numberp x))
NIL

* (loop for x in '(foo 2) 
      always (numberp x))
NIL

これら3つがwhenとreturnを組み合わせたものというのは大体納得できるのですが、
最終的に返す値を決めるには、これら3つを使わない場合、どうやって指定するんでしょうか。

(loop :repeat 3 :finally (return "わん"))
;=> わん

(loop 
   :repeat 3
   :collect 1 :into one
   :collect 2 :into two
   :collect 3 :into three
   :finally (return (list one two three)))
;=> ((1 1 1) (2 2 2) (3 3 3))

(loop for x being cars of '((a b) c) collect x)
  => ((a b) a)

(loop for x = (car '((a b) c)) then (car x)
      collect x
      until (atom x))

(loop :with x := 1
      :and  y := 2
      :return (list x y))
;=> (1 2)

(loop :with x := 1
      :with  y := x
      :return (list x y))
;=> (1 1)

(loop :for i :from 0 :to 10 :collect i)
;=> (0 1 2 3 4 5 6 7 8 9 10)

(loop with from = 0
      and to = 10
      for collect from from to to collect collect)

(loop :with from = 0
      :and to = 10
      :for collect :from from :to to :collect collect)

(loop #:with from = 0
      #:and to = 10
      #:for collect #:from from #:to to #:collect collect)

(iter (for i :in '(1 2 3 4))
      (collect i))
;=> (1 2 3 4)

┌──┬──┐  ┌──┬──┐  ┌──┬──┐
│ a  │  ─┼→│ b  │ ──→ │ │ │  / │
└──┴──┘  └──┴──┘  └ │ ┴──┘
                                   ↓
                                ┌──┬──┐ ┌──┬──┐ 
                                │ c  │ ──→│  d │  / │ 
                                └──┴──┘ └──┴──┘

┌──┬──┐　┌──┬──┐　┌──┬──┐　
│ａ　ｌ　─┼→│ｂ　ｌ　─┼→│ｌ　ｌ　　│
└──┴──┘　└──┴──┘　└┼─┴──┘　
　　　　　　　　　　　　　　　　　↓
                            ┌──┬──┐　
                            │ｃ　ｌ　／│
                            └──┴──┘　

┌──┬──┐　┌──┬──┐　
│ａ　ｌ　─┼→│ｌ　ｌ　　│
└──┴──┘　└┼─┴──┘　
　　　　　　　　　↓
　　　　　　　　┌──┬──┐　
　　　　　　　　│ｂ　ｌ　／│
　　　　　　　　└──┴──┘　

20:00-21:30位まで
Common Lisp Pitfalls
CLでコーディングする方向け
http://www.aiai.ed.ac.uk/~jeff/lisp/cl-pitfalls
"potential numbers"から再開

  * Remember that there are "potential numbers" and that they are
    reserved tokens [CLtL pages 516-520].  Normally, only odd things
    such as 1.2.3 or 3^4/5 are "potnums", but when *READ-BASE* is
    greater than 10, many more tokens are effected.  (For real fun,
    set your read base to 36.)

  It may seem odd to have a whole section devoted to SORT, but I've
  seen so many erroneous SORT calls that I've decided it's necessary.

  * As mentioned above, SORT is (usually) destructive and so such
    combinations as (SORT (REMOVE ...) ...) may not do as you expect
    (if what you expect is that REMOVE will produce a new list).

(let ((foo (list 0 1 2 3 4 5 6 7 8 9)))
  (values (sort (remove 0 foo) #'>) foo))
;removeとsortの合わせ技で、
;(9 8 7 6 5 4 3 2 1),(0 9 8 7 6 5 4 3 2 1)
;という結果の場合もあったりする。

  * SORT may not return equal elements in the same order in different
    CL implementations, because different sorting algorithms are used.
    To ensure that you get the same result in all implementations, 
    when that's what you want, use STABLE-SORT (or write your own).

  * The comparison predicate given to SORT is treated as a strict
    "less than" and so should return NIL when its 1st argument is 
    considered greater than _or equal to_ its 2nd.

CL-USER> (sort (list '(a 3) '(b 1) '(c 2) '(d 3)) #'<= :key #'cadr)
((B 1) (C 2) (D 3) (A 3))
CL-USER> (sort (list '(a 3) '(b 1) '(c 2) '(d 3)) #'< :key #'cadr)
((B 1) (C 2) (A 3) (D 3))

CL-USER> (stable-sort  (list '(a 3) '(b 1) '(c 2) '(d 3)) #'< :key #'cadr)
((B 1) (C 2) (A 3) (D 3))
CL-USER> (stable-sort  (list '(a 3) '(b 1) '(c 2) '(d 3)) #'<= :key #'cadr)
((B 1) (C 2) (D 3) (A 3))

(sort (list 1 2 1 2 1 2 1 1) #'=)
;=> (1 1 1 1 1 2 2 2)

  * If the comparison predicate (strictly speaking, the combination
    of the predicate and the key function) does not consistently express
    a total order on the items being sorted, then the items "will be
    scrambled in some unpredictable way" [CLtL p 408].

    It's easy to go wrong when writing "lexicographic" multi-step
    comparisons and end up with a predicate that says both A < B 
    and B < A for some A and B.  For example:

      (defun fg-lessp (a b)
        (or (< (f a) (f b))    ;first compare f values
            (< (g a) (g b))))  ;then compare g values

    Fg-lessp does the right thing when (f a) is less than (f b):
    it returns true -- and when (f a) is equal to (f b): it goes
    on to compare g values.  But it also compares g values when
    (f a) is _greater than_ (f b), when what it should do is return
    false.

    Also make sure the predicate is _transitive_.  For instance,
    if you're comparing objects of different types and you decide
    (for example) that numbers are < strings and strings are < symbols,
    make sure the predicate says numbers are < symbols too.

  * CLtL suggests that using the :KEY argument to SORT may be more
    efficient than calling the key function inside the comparison
    predicate (p 408).  However, it may well be less efficient.
    Implementations may not take advantage of the separate :KEY
    to extract the keys only once; and the key function might be
    compiled in-line when it appears inside the predicate.

(mapcar #'list '(1 2 3 4 5))
(defun sort-car (lst)
  (sort lst #'> :key #'car))

(defun sort-car2 (lst)
  (sort lst (lambda (x y)
              (< (car x) (car y)))))

  * A FUNCTION special form may construct a new function object each
    time it's evaluated, and therefore even (flet ((f ...)) (eq #'f #'f))
    can return false.  The same is true with LABELS instead of FLET
    and for FUNCTION used with the name of a global function.
    However, function objects are proper objects-with-identity, and
    (let ((f #'(lambda ...))) (eq f f)) will always return true.

(flet ((f (x) x))
  (eq #'f #'f))
;=> t

  * DO and DO* update the iteration variables by assignment; DOLIST and
    DOTIMES are allowed to use assignment (rather than a new binding).
    (All CLtL says of DOLIST and DOTIMES is that the variable "is
    bound" which has been taken as _not_ implying that there will be
    separate bindings for each iteration.)

    Consequently, if you make closures over an iteration variable
    in separate iterations, they may nonetheless be closures over
    the same binding and hence will all find that the variable has
    the same value -- whatever value the variable was given last.  Eg,

     (let ((fns '()))
       (do ((x 1 (1+ x)))
           ((= x 3))
         (push #'(lambda () x)
               fns))
       (mapcar #'funcall (reverse fns)))

    returns (3 3), not (1 2).  However, it would return (1 2) if
    #'(lambda () x) were replaced by (let ((x x)) #'(lambda () x)).

(let (res)
  (dolist (i '(1 2 3 4) (mapcar #'funcall res))
    (push (lambda () i) res)))

(dolist (i '(1 2 3 4) i)
  (declare (number i))
  i)

(dolist (i '(1 2 3 4) i)
  (declare (type number i))
  i)

  * A related, but distinct, question is whether a loop such as the
    one above creates two different (ie, not EQ) function objects from
    #'(lambda () x) or only one.  On this second question, see CLtL
    pages 117-118.  For the example that returns (3 3) above, where 
    -- perhaps contrary to the author's intention -- the functions
    would be "behaviorally identical with respect to invocation",
    implementations are allowed to create only a single function object.

    This rule appears to apply only to "distinct evaluations of the
    same function form" [CLtL p 118], not to behaviorally identical
    functions in general.  However, it applies even if the functions
    are closures over different bindings.

  * The comparison predicate given to SORT is treated as a strict
    "less than" and so should return NIL when its 1st argument is 
    considered greater than _or equal to_ its 2nd.

(let (res)
  (dolist (i '(1 2 3 4) (eq (car res) (cdr res)))
    (push (lambda () i) res)))

g000001 2008-07-19T22:26:30+09:00
一時kozimaさんと自分だけの時期とか
kozimaさんだけの時期とかありましたねw

名無しさん 2008-07-19T22:27:25+09:00
わりと Common Lisp で投稿する人は限られてる感じですね
anarchy golfもですかね
CLでgolf？
ああゴルフもそうです。最近あまり手をつけていませんが・・・
SBCL Hackerのjsnellとかもgolfやってましたが、使ってた言語はPerlですよ
clの範囲でgolfです
mcさんが、g000001さんだったんですか。知らなかった
ゴルフは文字列処理がつらい気がします
golfは極々初期にsnでやってました

g000001 2008-07-19T22:30:28+09:00
そうなんですよね、g000001でやっとけば、
良かったw

名無しさん 2008-07-19T22:31:33+09:00
なんかformatくらいしか武器がないですよねcl
でも、言われてみれば、納得です。arcとかも。
じゃあ、あれで出てくる人の大半はこちらに来てるのか。^^; 俺も知らんかったし

g000001 2008-07-19T22:31:59+09:00
Arcは発表の日に投稿してみましたw

名無しさん 2008-07-19T22:32:29+09:00
ところで anarchy golfってなに？調べてもよく分からん

g000001 2008-07-19T22:33:10+09:00
CL部門は、全員ではないにしろほぼ全員ですねww

名無しさん 2008-07-19T22:33:25+09:00
言語横断でできるgolfです
http://www.shinh.org/
ここでいいのかしら
指定された入力で指定された出力を吐くプログラムを指定された拡張子でアップロードするだけ
バイト数で勝負
ふむふむ。バイト数勝負かぁ
cr+lfで編集しててアレ？と思って変更してからアップロードしなおすとかを楽しむ場所ではないかと
echoで11文字…えーっと
loop, write-char, read-char 駄目だな。
copy-stream …11文字。無理！
24は思い出せた…
clispであることは利用して良いので…っていう話なんでしょうかね…
先生…　print for<>…　perlでも11文字です…
11bytes は
しばらく気付きませんでした
むずかしいなぁ

g000001 2008-07-19T22:51:50+09:00
ちょっとコンピュータ移動するので、
はいりなおします(^^

名無しさん 2008-07-19T22:57:54+09:00
駄目だ
っていうかしばらくってかなり時間かかりましたよね

g000001 2008-07-19T22:58:15+09:00
自分にはゴルフ以前に解けなそうな問題ばっかりだww

名無しさん 2008-07-19T22:58:31+09:00
(loop(princ(read-char)))
素直な24byte
確か他の問題やっててたまたま気付いたような
雑談って感じじゃなくなりますね
そういえば刷り上った本をいただいたのですが、
onjoさんはまだですかね
(run-program"cat") 18byteだ！

g000001 2008-07-19T23:08:32+09:00
www > 雑談って感じじゃなくなりますね

名無しさん 2008-07-19T23:09:27+09:00
(do-all-symbol (s :cl) (when (and (fboundp s) (< (length (symbol-name s)) 11) ....
を眺めていますが。
なんかすごい近いきがする
こうゆうのもアリなんですか？
ないんですかね
ありだと思ってました
ありでもこれ以上短縮できないw
stdout に要求されたものが出てくればだいたいなんでもありです
run-programが11バイトなんですけど…
つまり、もっと枠を外さないといけないんだな。
(shell"cat")
これいけるかな
おぉぉぉ
あれ？12バイトありません？
うんあと一歩
しかし…shelldeこの路線は部分最適解に嵌っているのでは
うむー
もすこし普通に書いたところから削るプロセスを楽しむ物だと思うので
echoはいまいち楽しくないと思います。
なんというかもう少し早いじかんから
誰でも簡単にできる系統のやつを
formatの変態機能が活躍するとかを想像してしまった
大活躍する問題がひとつありました
~R…
使った記憶がほとんどなくてRということは、アレですか…ローマ字表示？
個人的に format 使って楽しかったのが 98. Divide the rectangle
おー
工夫のしがいがありそうだ
やっぱり雑談にならない
話題としてのゴルフは駄目っぽい…
golfの魔力だ

g000001 2008-07-19T23:45:38+09:00
まあ、何か書いてもネタばれの危険がありますしねw

名無しさん 2008-07-19T23:46:03+09:00
ネタバレどうでもいいんじゃないかと思うんですけどね

g000001 2008-07-19T23:47:17+09:00
そうなんですか？w

名無しさん 2008-07-19T23:48:30+09:00
話をするなら全部隠してたら意味ないのでは？

g000001 2008-07-19T23:48:51+09:00
ああ、なるほど、そういう意味ですか('-'*)
全然関係ないですが、
来週以降実践CL
を読んで興味持ったって人が
増えるといいなーとか
漠然と思ってます(^^

名無しさん 2008-07-19T23:51:05+09:00
いきなり激増とか考えるとメドイ感じしかしないですね

g000001 2008-07-19T23:51:06+09:00
CL
激増はあるのかなw

名無しさん 2008-07-19T23:51:34+09:00
どちらかというと今いる人でナイスな過去ログ残せたら良いなーとしか

g000001 2008-07-19T23:52:04+09:00
なんとなくの予感ですが、
発言する人の割合は
割合というか絶対数は
変わらない気はしますね。
あと100人位増えても
誤差の範囲くらいかなと

名無しさん 2008-07-19T23:53:34+09:00
まぁ似たような感じですかね
PCLでオフライン読書会やったら人来るかな

g000001 2008-07-19T23:55:11+09:00
そりゃあつまると思いますよ
絶対開催されるとは思うんですが、

名無しさん 2008-07-19T23:55:33+09:00
オンラインはオンラインで楽しいんですけど（特に忘れてても参加できるあたり）
オフラインのほうがすきですねー

g000001 2008-07-19T23:55:49+09:00
なるほどー。
自分はコミュニケーションスキル自体は
無い方じゃないと自分では思ってるんですが、
人間嫌いなので、
オンライン派になってしまうんですねwwww

名無しさん 2008-07-19T23:56:57+09:00
躊躇なくそういうこと言えるのはすごいですねー

g000001 2008-07-19T23:57:34+09:00
いや、きっと
人間が好きすぎるから、嫌いなんですwww
まあ、それはともかく
オフラインは開催しさえすれば、
集まると思いますねー
多分、各地で開催されるんじゃないかなーと
思うのですが。
On Lisp勉強会があるくらいだから
あと、PCLはオフライン勉強会の方が
向いてるかなーとか思いますね。

名無しさん 2008-07-20T00:04:14+09:00
結構時間かかりますからね。２時間/章くらいな感じです

g000001 2008-07-20T00:04:41+09:00
なるほどー。
そうなると、オフラインですよね。
オフライン勉強会は、
場所の確保さえできれば、って感じですよね。
ルノアールの貸し会議室とか良いかなとは
思うんですが。
10人位集まれば、一回1000円以内くらいに
収められたかな？確か。

名無しさん 2008-07-20T00:08:18+09:00
人数さえ大体決まってしまえば箱はいくらでもあると思うので
なんとでもできるのですが
RHGも飛ぶかもしれないけど最後まで読むっぽくて
さらにもう一個読書会を自分で！
とかなると死にそうな予感

g000001 2008-07-20T00:10:09+09:00
なるほどー。
RHGの告知自体もうちょっと
広くやったら
人集まるんじゃないですか？
PCLの読書会やってるってみんな
しってるのかしら。
途中からでも参加したい人は沢山いそう。
で、その中から、最初から読みたい！って人が、最初から読む会を実施。
みたいな。
ま、まったく違う流れからも、
きっと勉強会は開催されるんじゃないのかなと思いますけども。

名無しさん 2008-07-20T00:13:43+09:00
RHGは読書会っぽくない印象があるんですよね

g000001 2008-07-20T00:14:14+09:00
おお、そうなんですかー。
ustreamの中継みようみようとは
思ってるんですが、いまだに見たことないんですよね。

名無しさん 2008-07-20T00:14:52+09:00
あんまりされないんじゃないですかね
次週は何やるんですか？
ここ

g000001 2008-07-20T00:16:36+09:00
CL-cookbookと交互な感じなんですが、
割とcookbook
は厳しいかなと思ったりで
多分cookbookですが、
もっと良いのをみつけたら
それをするかも。
なんというか、
CLに関する疑問を質問できる場が
できれば、良いので、
まあ、私個人は
そうできれば良いかなと思っているので、
お題はなんでも良いとは思っているのですが、
そうはいっても、それなりに

名無しさん 2008-07-20T00:19:23+09:00
適当に集まれる口実が必要…と
そんな感じですね

g000001 2008-07-20T00:19:31+09:00
そういうことですねwww
それで知識が増えればなお良しと

名無しさん 2008-07-20T00:20:14+09:00
今日はfunctionについて詳しくなりました
えがった

g000001 2008-07-20T00:20:59+09:00
毎週結構自分は勉強になってます(^^
自分は以前から知っていたCL界隈の方と
一通りお話できたので、
ある程度、目的は達成できましたww

名無しさん 2008-07-20T00:24:22+09:00
golf難しい…11文字…32x32のお絵かき…
そっちは時間のブラックホールっすよ
適当に切り上げないと重力崩壊…
あわわ。そういえばSchemeな人にそんなに破壊的なループって嫌です？って聞こうと思ってたんだった。
タイミングが悪いですね

g000001 2008-07-20T00:28:22+09:00
多分、schemeの人で
あ、
naoya_tさんが
あ、凄いw

naoya_t 2008-07-20T00:29:52+09:00
呼ばれた

g000001 2008-07-20T00:30:16+09:00
Lingr Reader

naoya_t 2008-07-20T00:30:20+09:00
radar

g000001 2008-07-20T00:30:47+09:00
あ、radarなんですねw
Schemeな人にそんなに破壊的なループって嫌です？
という質問に
naoya_tさんは
どんなレスを！

naoya_t 2008-07-20T00:31:57+09:00
破壊的なループは快適なループ！
冗談はさておき

名無しさん 2008-07-20T00:32:29+09:00
それ冗談じゃなくてダジャレ…

g000001 2008-07-20T00:32:32+09:00
naoya_tさんは、幅広く使ってるから
あ、ホントだ
気付かなかったww
そういえば、 CL界の黒田さんのような
立ち位置のSchemerって
どなたですかねw
そういう感じのSchmerみたいなー。

名無しさん 2008-07-20T00:34:58+09:00
何にこだわるんだろう…

g000001 2008-07-20T00:35:24+09:00
海外には結構いるんじゃないかなと
勝手に想像してるんですけど。
呼び出しながら、収拾付かない方向に話を振ってしまって、すいません(^^; > naoya_tさん
IRCの#lisp_schemeだと
発言はCLer
が多いですが、
Schemerの方が多いので、
その辺りの話は、振ると盛り上がるかも…。

名無しさん 2008-07-20T00:41:53+09:00
破壊的なループそのものが嫌いなのか、それともScheme感覚だと破壊的でなさそなのに実際は違うからナンダコリャという感じなのか。

g000001 2008-07-20T00:44:31+09:00
自分の漠然とした感覚だと
破壊的　＝　カコワルい
ってことなのかなーと

名無しさん 2008-07-20T00:45:34+09:00
破壊的=注意が必要
くらいはあるので、それが存在しない世界にいたら
まぁ考えにくいんじゃないかと思います。
個人的にはschemeとclを半々というほうがどうやって頭切り替えてるのか謎だったりします。

naoya_t 2008-07-20T00:47:45+09:00
その辺りはshiroさんとかにインタビューしないと
>schemeとclの切替え

g000001 2008-07-20T00:48:34+09:00
そうだ、Gauche部屋に突撃ってのも
ありますね
w

naoya_t 2008-07-20T00:48:54+09:00
ぜひぜひ

g000001 2008-07-20T00:49:30+09:00
副作用云々だと、
haskellのnobsunもいらっしゃいますしw

名無しさん 2008-07-20T00:50:18+09:00
そういえば CL と OCaml 書いてるときだと思考形態が違うような気がします

g000001 2008-07-20T00:53:00+09:00
kozimaさんはどう書くでもOCamlとかHaskellでも投稿されてますよね

名無しさん 2008-07-20T00:54:36+09:00
あのあたりの言語も好きなんですよね
ただ、メタプログラミングしたくなったときにやりにくい

g000001 2008-07-20T00:55:57+09:00
そういえば、kozimaさんはscheme
の投稿はあまりみたことない気がしますが、
CLとOCamlの中間くらいの感じなんですか？　＞ scheme

名無しさん 2008-07-20T00:57:24+09:00
どうなのでしょう。あまり詳しくないのですが
R5RS は読みましたが
ならべるとしたら中間くらいでしょうかね
実際にコードを書こうとすると CL っぽい思考になりそうな
OCaml 書くときって、まずどんな型を定義するか考えるんです
そういうステップは Scheme にはないかなと

g000001 2008-07-20T01:02:02+09:00
なるほどー。
とにかくどんどん型をつくろうーっていうのは
OCamlでしたっけ？
Cleanだったかな。
純粋関数型言語から眺めると
また違った構図になりそうですね。
cl vs scheme

名無しさん 2008-07-20T01:06:11+09:00
OCaml, Haskell とかは静的型付けなので、その差が結構大きいかも

g000001 2008-07-20T01:08:34+09:00
なるほどー。
勉強会終わると
大体来週まで書き込みがない感じなので、
交流の場を集めたものを
貼ってみることにしましたw

IRC:
irc.freenode.net
#Lisp_Scheme
utf-8
ログ: (basic認証あり)
http://lambdarepos.org/kaela/

どう書くorg:
http://ja.doukaku.org/lang/commonlisp/
http://ja.doukaku.org/lang/scheme/

Lingr:
http://www.lingr.com/room/gKpArxPn9wi
http://www.lingr.com/room/gauche

golf:
http://golf.shinh.org/

2ch:
Lisp総合
http://pc11.2ch.net/test/read.cgi/tech/1215875388/
CLスレ:
http://pc11.2ch.net/test/read.cgi/tech/1215834213/
2chから発祥した?Wiki
http://wiki.fdiary.net/lisp/

Wassr:
http://wassr.jp/channel/lisp
http://wassr.jp/channel/gauche

とはいえ、このために書き込みが抑制されるというのは
本末転倒なので、是非こちらもご利用くださいw

名無しさん 2008-07-25T21:17:31+09:00
実践Common Lisp入手っと。

さすがジュンク堂といったところ？
早いなー。
そっすかねー
週末ですし今日には並ぶと思ってましたが
タイミング的には余裕でしょうが、
まぁ、個人的な感慨とスケジュールは別ですからね
裏の事情を勘案すると、感じるものも変わってくるってところですかね。
話は変わってsbcl 1.0.19 が来週リリース予定みたいッスね。http://groups.google.com/group/sbcl-devel/browse_thread/thread/70d6016b18fb519c
かつてのxyzzyのような勢いのリリースですよね。
サポートページの公開が間に合っていないという話などと絡みますかね。
ハヤイナーという気分には。
あー、サポートページは要りそうですね。どこに作る予定なのですか？
onjoさんにお願いしています。
というあたりで
勘を働かせればわかるかもしれませんが…
なるほどー
関連資料発見
ん？
http://lispuser.net/commonlisp/pcl.html
コメントを見てなんとなく
うへ
初めて見るけど（だから）書きかけなブツっぽいですね…
なんとなく見なかったことにした方が…
そのうち完成したものが読めるってことを期待する方向で。
…うん

g000001 2008-07-26T00:56:38+09:00
凄い、山積みになってる！

名無しさん 2008-07-26T00:59:58+09:00
よくわからんけど見に行こうと思った。

g000001 2008-07-26T01:39:00+09:00
http://lispuser.net/commonlisp/pcl.html
これはまたマニアックなアイテムが揃ってて面白そうですねー
便利なリファレンス登場 http://lispm.dyndns.org/news?ID=NEWS-2008-07-25-1

名無しさん 2008-07-26T07:21:43+09:00
今夜はここで乾杯騒ぎか?笑　出版をお祝いしてね。　

g000001 2008-07-26T16:37:12+09:00
こんにちはー。
お祭りもいいですねー('-'*)
自分のブログにNANRIさんの写真引用させていただきましたー。
こんばんはー。
本日もCL勉強会開催させて頂きます！

時間割:
20:00-21:30位まで
cl-cookbook:文字列操作編
CLでコーディングする方向け
http://cl-cookbook.sourceforge.net/strings.html 

という感じです。よろしくお願いします！
こんばんはー
では本日も20時になりましたので、
開始したいと思いますー

名無しさん 2008-07-26T20:00:57+09:00
よろしくお願いします。

g000001 2008-07-26T20:01:04+09:00
よろしくお願いしますー。

quek 2008-07-26T20:01:12+09:00
お願いします。

g000001 2008-07-26T20:01:14+09:00
今日は文字列の操作ということで、
なんとなく独自な感じが
あるところなような
そうでもないようなw
つい先日cl-unicodeというのが
weitz氏により発表になったのですが、
試した方はいらっしゃいますか？
http://weitz.de/cl-unicode/
今日の話題にぴったりかなと思って
取り上げようと思ってたんですが、
さっき思い出しましたw
cl-ppcreも若干拡張できるようです。
(has-property #\あ "HIRAGANA") ;=> T
とかいろいろできるようです
ではでは、
http://cl-cookbook.sourceforge.net/strings.html
をさっそく頭から進めて行きますー
皆さんご存知のことが多いとは思いますが

http://www.scheme-users.jp/images/clpm8.png

忘れてたw
*Accessing Substrings
からです。

名無しさん 2008-07-26T20:05:27+09:00
cl-unicodeはぱっと見、正規化とかに関わる部分かと思ってスルーしていました。

g000001 2008-07-26T20:05:28+09:00
文字列の部分切り出しについてのセクションですが、
自分も裏方でなにかやってくれるもんだと
おもってたんですが、

quek 2008-07-26T20:06:21+09:00
FLEXI-STREAMS とか CL-PPCRE の文字が期待をあおりますw

g000001 2008-07-26T20:06:22+09:00
http://xach.livejournal.com/182493.html
読んだらなんか違うみたいなので、再確認しましたw
ですねー。
是非多言語関係は推進していって頂きたい(^^
ということで
部分文字列のアクセス方法です
これには、subseqを使うということですね。
subseqはシーケンスに対する汎用的な関数なので、listや、ベクタにも使えます。
(subseq シーケンス 開始 終了)という感じで、
「終了」を省略したりnilを指定することにより、最後までという意味にもなります。
くらいの感じで
で、これは、setfも可能だという例がありますね
(setf (subseq *my-string* 0 5) "Chico")
みたいな
注意点としては、文字列は伸縮しないので、
元より長くなる場合は、切り詰まった感じになってしまうとのことですね。

quek 2008-07-26T20:09:30+09:00
setf できたんですね。

名無しさん 2008-07-26T20:09:46+09:00
subseqって後ろから数えるのができればなぁと思ったりします。
確かできなかった覚えが。

g000001 2008-07-26T20:10:06+09:00
ですね、
TAOだとできますねw
TAOはsubseqじゃなくてsubstringですけどw
マイナス指定数値で逆転とかだったかな？
ところで、setfが予め対応している関数って
処理系依存なんでしたっけ？
setfable? な関数というか
何がSETFableなのか一覧で分かると便利そうなんですけど
そういえば、一覧っていえば、http://clqr.berlios.de/
のリファレンスが便利ですね。
という感じで、とりあえず、
次にいこうかと思いますが
*Accessing Individual Characters
で今度は個別にアクセスすると
何種類か方法がありますが、ここの例では、charを使ってます。
(char 文字列 インデックス)
という形式ですね。
これも、setf可能で
みたいに指定していますね。
あれ、抜けた
(setf (char *my-string* 6) #\y)
みたいに指定していますね。
charの効率が良いバージョンとして、scharがあるそうで
どの辺が効率的なのか自分は、良く分かっていないのですが(笑)
それと、文字列は、ベクタということで、ベクタ用の関数もまた利用可能です。
arefや、eltがあります。charの方が効率が良いみたいです。
eltはもっと汎用でシーケンス用ですが
速い >>> 遅い
schar, char, aref, elt
という位の順番なのでしょうか。
それで
文字はそれぞれ番号が振られているんですが、どれくらいの種類を扱うかは処理系依存と
で、そのコードを使ってアクセスする関数
(code-char )で、番号→文字 char-codeで文字→番号という風にアクセスする関数があります。

名無しさん 2008-07-26T20:17:21+09:00
arefとeltの順番はどっちなんでしょうね？arefは多次元の配列なんかにも使うのであんまり速くなさそうな気がします。

g000001 2008-07-26T20:17:32+09:00
なるほど、なるほど。
実際ベンチとると
どういう感じなんですかね。
eltって遅いっていうイメージだけが
自分にはあるのでこのような順番で
書いてしまいましたw
実測基本ですね(^^;'
これは、宿題と。
最後の方に宿題リンクをまとめてみようかと
思いますw

名無しさん 2008-07-26T20:20:05+09:00
型が指定してあれば定数時間でアクセスできるのでarefが速いかなと思いますけど、型が無指定だとどうなるかなと。
リストとかを考える分eltが不利？

g000001 2008-07-26T20:21:00+09:00
elt vs arefがアツイw
型指定するとeltでも頑張れそうですよね
という感じなのですが、
ちなみに
SBCLや、Clozure CL、CLISPの場合、#\u3042のようにも表記できるようです。
Gaucheみたいですね。
と言う感じで次にゆきますと
*Manipulating Parts of a String
文字の部分部分を操作しようと
最初は、
(remove #\o "Harpo Marx")
で、removeがシーケンス用の関数なので
文字列にもつかえますよと
CLでは、文字列はベクタの仲間で、ベクタとリストは、シーケンスの仲間になります。
仲間というか、階層がそういう感じであると
なので、上のremoveの例は
文字列から、#\oという文字を削除した集合を返すことになるので、
集合というとアレですが、
"Harp Marx"となります。
で
(remove #\a "Harpo Marx" :start 2)
は3文字目(0起源)から開始つまり、(concatenate 'string "Ha" (remove #\a "rpo Marx"))
みたいなことになっています。
他に、:countを指定したり色々できますね。
(remove #\a "aaaaaaabcdefg" :count 4)
とか
"aaabcdefg"
となります
4回まで取り除きますよという
指定ですね。
次はremove-ifですが、これもリスト操作でお馴染みかと思います。
(remove-if #'upper-case-p "Harpo Marx")
"arpo arx"
という感じになります。
大文字だけ削除されるんですね。
次もシーケンス用の関数、substituteで、
(substitute new old sequence)
対象を新しい要素で置き換えます。置き換えるといっても非破壊的です。
ちなみに、これまで出て来た関数は、全部非破壊版ですね。
(substitute #\u #\o "Groucho Marx")
"Gruuchu Marx"
という感じで、全部のoをuで置き換えています。
個人的には、引数の順番で置き換えるものの方を先に指定する、というに良くはまります(笑)
unixのコマンド等には、old/newの順番が多いのでw
次はsubstitute-ifで、述語を与えるもの
(substitute-if #\_ #'upper-case-p "Groucho Marx")
"_roucho _arx"
大文字の場合だけ_に置換しています。
それで
次もシーケンス汎用の関数で、replaceです。
"Zeppo Marx"という文字列にたいして、
(replace "Zeppo Marx" "Harpo" :end1 5)
とすることで、
"Harpo Marx"という文字列に置き換えています。
:end1というのは、一番目の引数のシーケンスの最後の位置を指定しています。
なんとなくこの範囲指定が微妙なんですが

(replace "12345" "abcde")
"abcde"

(replace "12345" "abcde" :start1 1)
"1abcd"

(replace "12345" "abcde" :end1 1)
"a2345"
:start1

(replace "12345" "abcde" :start2 1)
"bcde5"

みたいな感じですね。
二つのシーケンスを重ね合わせて
マスキングの状態を変えるような
いい表現が浮かびませんがw
:start1/2、:end1/2を組み合わせることによって色々できると、いったところです。
それと補足としては、replaceは破壊的なので注意という感じです。
他の関数と違って名前の法則性のようなものが
replaceにはなにも適用されてないようなw
それで、この後に
ANSIで定義されてないけど、便利なものとして、replace-allが紹介されています。
(replace-all "Groucho Marx Groucho" "Groucho" "ReplacementForGroucho")
;=> "ReplacementForGroucho Marx ReplacementForGroucho"
という感じで、元の文字列中でマッチする文字列を全部置き換えるというものですね。
このreplace-allの定義もなかなか勉強になって、

(defun replace-all (string part replacement &key (test #'char=))
"Returns a new string in which all the occurences of the part 
is replaced with replacement."
    (with-output-to-string (out)
      (loop with part-length = (length part)
            for old-pos = 0 then (+ pos part-length)
            for pos = (search part string
                              :start2 old-pos
                              :test test)
            do (write-string string out
                             :start old-pos
                             :end (or pos (length string)))
            when pos do (write-string replacement out)
            while pos)))

という感じですが、
write-string等で放り投げた文字列をwith-output-to-stringで受けて合成した文字列を返しています。
こういうのって
割と定石なんでしょうか。
ちなみに定義をみれば分かるようにこの関数は、非破壊的です。
replaceからの連想でいくとあんまりいい名前でないような
w
もとが良くないようなw
さらにちなみに良く使うみたいなことを書いてあるのでなんかのライブラリに含まれていないかを探してみたんですが、みつけられませんでした。
ちなみに今回

名無しさん 2008-07-26T20:34:43+09:00
名前悪いですかね？

g000001 2008-07-26T20:34:46+09:00
異様に入力が思えるかもしれませんが、
事前に用意した内容を元にしていますww

名無しさん 2008-07-26T20:35:09+09:00
思える？

g000001 2008-07-26T20:35:15+09:00
あ、
入力が速いように思えるですねw
抜けました
remove vs deleteのような
対応を想像してしまうというか。
replaceの非破壊版ってあったりするんでしょうか？
自分はreplace自体今回の予習で初めて使ったのでw
まあ、sortとかの例もあるんで、

名無しさん 2008-07-26T20:37:12+09:00
JavaでいうStringBuffer的な => with-output-to-string

g000001 2008-07-26T20:37:25+09:00
変でもないのかな。
なるほど、Javaにもあるんですね、

名無しさん 2008-07-26T20:38:06+09:00
あー、なるほど。そうとらえると分かりやすいです。

g000001 2008-07-26T20:38:10+09:00
放り投げたものをまとめてくれるって便利ですね。
ちなみに
このコードは長い文字列に対しての効率は考えられていないので、その場合、cl-ppcle等を検討しましょうとのこと。
超意訳ですがw
で、次に行きますと
*Concatenating Strings
今度は文字列をくっつける方向で
これには、基本的に
concatenateという綴りの長い関数を使います。
綴りの長い上に型を指定するので、なんとも冗長になりますよね。
(concatenate 'string "Karl" " " "Marx")
みたいな
http://www.weitz.de/cl-interpol/
CL-INTERPOLとか
使い方によっては便利なのかな？

quek 2008-07-26T20:41:01+09:00
ACL では string+ って関数ができたみたです。
http://www.franz.com/support/documentation/current/doc/string-utilities.htm#string+-op-bookmarkxx

g000001 2008-07-26T20:41:58+09:00
これ便利そうですね。
mapとwith-output-to-stringとprincが合体したような
感じなんですかね？

名無しさん 2008-07-26T20:43:06+09:00
即知以外を混ぜたら遅いと宣言するところが渋い

quek 2008-07-26T20:44:50+09:00
CL-INTERPOL は気にいっているのですが、たまに Slime の C-c C-c ができなくなっちゃうのが悩みです。

g000001 2008-07-26T20:45:27+09:00
Gaucheとかみてると
cl-interpol使いたくなってきますよねー。
決定版はないものか
という感じなのですが、
沢山の部分に分かれているものをconcatenateでくつけるというのは効率が悪いそうなので、

名無しさん 2008-07-26T20:46:39+09:00
あぁ、リテラル文字列だけかと勘違いしてしまった。型の話か。＞string+

g000001 2008-07-26T20:47:34+09:00
いろいろ仕掛けはありそうですよね('-'*)

quek 2008-07-26T20:47:57+09:00
ソースを見てみたい

g000001 2008-07-26T20:48:04+09:00
で、concatenate連発のかわりに
その場合は、フィルポインタを0に初期化したベクタを作って、それにvector-push-extendで要素を継げて行くのが良いらしいです。
ですね　＞　ソース
公開されてないのかな？
ほんとに効率良いのかは
実測してみませんでしたw　すいません
あれ、util.stringがrequireできないな。
ソースがあったら確認してみたいですね。
これも宿題フラグw

quek 2008-07-26T20:52:14+09:00
vector-push-extend できるベクタの作りかたが難しいです。

g000001 2008-07-26T20:52:19+09:00
それで、
ですね、面倒ですよね。
それで、
上記2つの方法以外に
例えば、
構成する要素に数字や、文字や、リスト等色々なものが来る場合は、
formatで、1番目の引数にnilを指定することによって出力を文字列として取り出すという方法が良いとのこと。
これは、一番お馴染みな気もしますね。

(format nil "The Marx brothers are:~{ ~A~}."
          '("Groucho" "Harpo" "Chico" "Zeppo" "Karl"))
;=> "The Marx brothers are: Groucho Harpo Chico Zeppo Karl."

とかお馴染みですよね。

名無しさん 2008-07-26T20:54:44+09:00
よく使います＞format nil

g000001 2008-07-26T20:54:46+09:00
Elispのmapconcatってこんなのでしたっけ？
だったようなw
こういう連結で
効率について語ってるのだと
プログラミングGaucheに
毎回連結しないで、リストで保持していて
最後に必要になったらくっつけるという
方法が紹介されてましたね。
ということで次ですが、
***Processing a String One Character at a Time
ということで、
一文字ずつの処理
(map 'string #'(lambda (c) (print c)) *my-string*)
mapはシーケンス全般を扱えるので一文字毎の処理に使えるということですね。
LOOPだと
(loop for char across "Zeppo" collect char)
となると。
で、これはこれくらいで良いとして
***Reversing a String by Word or Character
文字列の逆転
というか、反転を
文字単位と、語句単位で
という
文字単位だと、そのままreverseで引っくり返せます。
(reverse "DSL")
みたいな。
それで、
英語の文章の単語を単位にするのはこれだと無理なので、split-sequenceのようなライブラリを使うことになるとのこと。
ここでは、split-by-one-spaceという関数を定義してみせています。
(split-by-one-space "Singing in the rain")
とすると
("Singing" "in" "the" "rain")
となってほしい。
で、定義ですが、

(defun split-by-one-space (string)
    "Returns a list of substrings of string
divided by ONE space each.
Note: Two consecutive spaces will be seen as
if there were an empty string between them."
    (loop for i = 0 then (1+ j)
          as j = (position #\Space string :start i)
          collect (subseq string i j)
          while j))

みたいな。
手法としては、
positionで#\Spaceの存在する位置を割り出して、位置情報をもとに切り出すというのは定石なんでしょうか。
それで逆に
合成は、JOIN-STRING-LISTという関数を定義。
これは簡単で

(defun join-string-list (string-list)
    "Concatenates a list of strings
and puts spaces between the elements."
    (format nil "~{~A~^ ~}" string-list))

こちらは、formatで纏めただけという感じ。
で、次ですが、
あまり日本語処理には役に立たなそうではありますが
***Controlling Case

名無しさん 2008-07-26T21:02:56+09:00
format のこの書き方はイディオムですよね。

g000001 2008-07-26T21:03:05+09:00
ですね、上でも出てきました
個人的にはこれで、~^の便利さをおぼえました
ばーっと挙げると

* (string-upcase "cool")
"COOL"
* (string-upcase "Cool")
"COOL"
* (string-downcase "COOL")
"cool"
* (string-downcase "Cool")
"cool"
* (string-capitalize "cool")
"Cool"
* (string-capitalize "cool example")
"Cool Example"
みたいなのがあると。

このあたりは、先ほどのcl-unicodeで
色々拡張して考えてみるのも良いかもしれません
あんまりひらがな→カタカナ変換とかは
ないような気もしますが、なにか
近い例があるような、ないような。
それで、これらの関数ですが、
:startや、:endキーワードが取れるので、

* (string-capitalize "cool example" :start 5)
"cool Example"
* (string-capitalize "cool example" :end 5)
"Cool example"

みたいなことも可能です。
適用する範囲を指定できると。
また、破壊的に文字列を変更する関数もあり。

* (defparameter *my-string* (string "BIG"))
*MY-STRING*
* (defparameter *my-downcase-string* (nstring-downcase *my-string*))
*MY-DOWNCASE-STRING*
* *my-downcase-string*
"big"
* *my-string*
"big"

みたいな。
それで落とし穴的なところですが、
string-upcase, string-downcase, string-capitalizeは文字列に変更が加えられなかった場合には、元の文字列をそのまま返しても良いしコピーしたものを返してもよい、とのことで安全を期すならば、copy-seqした方が良いみたいです。
http://www.lispworks.com/documentation/HyperSpec/Body/f_stg_up.htm
removeみたいですね。
それの例として

* (defparameter *my-string* (string "BIG"))
*MY-STRING*
* (defparameter *my-upcase-string* (string-upcase *my-string*))
*MY-UPCASE-STRING*
* (setf (char *my-string* 1) #\U)
#\U
* *my-string*
"BUG"
* *my-upcase-string*
"BIG"

が説明されています。
*my-upcase-string*がBIGでもBUGでも
良いということになってしまうので、
万全を期すなら、どっかでcopy-seqをはさんで置こうと。
と言う感じで
次ですが、
**Trimming Blanks from the Ends of a String
いらない空白の削除、
特に文字列の両端のいらない部分ですね
そういう不要な文字を端の方からトリミングしたい場合は、string-trimが使えると

(string-trim " " " trim me ")
;=> "trim me"
(string-trim "trime " " trim me ")
;=> ""

みたいになります。
上の例の場合、空白文字を削除するように
指定しています。
デフォルトは右側なんですが、
左方向からの場合は、string-trim-left
を使います。
削除するアイテムの指定ですが、

(string-trim '(#\t #\r #\i #\m #\e #\Space) " trim me ") 
(string-trim #(#\t #\r #\i #\m #\e #\Space) " trim me ")

という風にも指定可能です。
シーケンスで指定できるってことですね。
それで、この関数にも
返り値が新規ストリングとは限らない問題がある。
とのこと
remove系の関数の共通問題位のところなんでしょうか。
と言う感じで次ですが、
**Converting between Symbols and Strings
シンボルを文字列にしたり、その逆をしたり
まず、
文字列 => シンボル
ですが、
(intern "MY-SYMBOL")
になります。
;=> MY-SYMBOL
ですね。
大文字小文字は区別されるので注意
(intern "My-Symbol")
;=> |My-Symbol|
みたいな。
MY-SYMBOL と |My-Symbol| は別物になります
あと、たまに欲しくなるところとして
キーワードにしたい場合
(intern "MY-SYMBOL" :keyword)
;=> :MY-SYMBOL
という感じでキーワードパッケージにインターンすると
それで、今度は逆ですが、
シンボル => 文字列
は
(symbol-name 'my-symbol)
とか
(string 'my-symbol)
とかで
;=> "MY-SYMBOL"
ですね。
で、これはよいとして
**Converting between Characters and Strings
文字列と単一文字の変換ですが

名無しさん 2008-07-26T21:16:07+09:00
パッケージまで含めて文字列にできたりするんですかね？

g000001 2008-07-26T21:16:35+09:00
あれ、
なんかあったような、

名無しさん 2008-07-26T21:18:18+09:00
write-to-string... と思ったけど、*package* の値によりますね

g000001 2008-07-26T21:18:33+09:00
(format nil "~S" 'kmrcl:awhen)
(format nil "~A" 'kmrcl:awhen)
princとprin1の違いみたいな、

名無しさん 2008-07-26T21:19:22+09:00
でもカレントパッケージのはNAMEしかでないような

g000001 2008-07-26T21:19:25+09:00
ですね、現在の*package*の値に依存する感じです
別個取得しかないのかな

名無しさん 2008-07-26T21:20:01+09:00
package-name (symbol-package
と
ですね。

g000001 2008-07-26T21:20:47+09:00
これも宿題フラグを立てておこうかとw

名無しさん 2008-07-26T21:20:51+09:00
一般には colon を一つにすべきか二つにすべきかが微妙かも

g000001 2008-07-26T21:21:53+09:00
シンボルの表示にも色々ありますねー。

名無しさん 2008-07-26T21:22:11+09:00
それは外部シンボルかどうかで分ければいいかな
export されてたかどうかって一発でわかりましたっけ？

g000001 2008-07-26T21:24:23+09:00
うーん、もう一回internするとか？w
どういうのが定番なんでしょう。
internってのも色々まずそうですねw

名無しさん 2008-07-26T21:25:05+09:00
find-symbolかな
パッケージのexternal symbolsをみるしかないのかな

g000001 2008-07-26T21:25:49+09:00
なるほど、なるほど

quek 2008-07-26T21:25:54+09:00
describe...

g000001 2008-07-26T21:26:21+09:00
そうですね、describeもありますよね
もしくは、describeを構成している関数を分解して使うとかw
とりあえず、あと少しなので
進みますがw
文字列と文字の相互変換
文字列 => 文字
は
(coerce "a" 'character)
で
これはよしと
;=> #\a
;; リスト
で与える場合
(coerce '(#\h #\e #\y) 'string)
coerceで文字のリストから文字列に変換ですね
;=> "hey"
と言う感じです
で次は逆ですが、
これは落とし穴でもお題になりましたが、
coerceではできないので
(string #\a)
とすることになります。
リストの場合は
(coerce '(#\f #\o #\o) 'string)
で
;=> "foo"
という
で、これはよしとして次に行きますが
**Finding an Element of a String
文字列から要素を探すと
いうことで
position、position-if、find、find-ifが使える。
とこことです。
これはもとの例をみると良いかと思います。
また、count、count-ifも使えるので、特定の文字を勘定したりすることに使える
ようです。
**Finding a Substring of a String
今度は、
文字列から
部分文字列？を探すということになります。
この場合はsearchが使えて
(search "we" "If we can't be free we can at least be cheap")
みたいなのが
;=> 3
を返すと
インデックスを返す。みつからなかった場合は、nil
です。
で、これもよしとして
次は割と良く使う数値を文字列の変換です
**Converting a String to a Number

文字列から数値への変換

(parse-integer "42")
parse-integerが基本かなと
入力の基数を指定することも可能で
(parse-integer "100" :radix 2)　;=> 4
みたいな
(parse-integer "ff" :radix 16)　;=> 256
だったり。
ただ、#xffのような形式は扱えず、また、integer以外扱えないので、その場合read-from-stringを利用することになります
(read-from-string "#xff")
256
でsね
ですね
で、今度は逆で
数値から文字列へ
**Converting a Number to a String
write-to-stringか、派生形のprinc-to-string、prin1-to-stringを利用することになります
write-to-stringは基数を指定可能です
(write-to-string 1234 :base 2)
"10011010010"
とか。
で、最後は
文字列の比較です
**Comparing Strings
string=、string-equal、string<等...
で、文字の番号の比較
(string= "Marx" "Marx")
Tみたいな。
で、毛色が違うものとして
mismatchが使えます。
(mismatch "1234" "2234")

名無しさん 2008-07-26T21:36:22+09:00
charのリストはシーケンスだからcharのベクタになってもいいけど、charからstringはできなくても不思議じゃないなぁ
.oO(find-symbolかっ！と思ったらNANRIさんが既に解答をw)

g000001 2008-07-26T21:37:16+09:00
なるほど、なるほど。
あれ、Dylanはどうだったかな
まあ、Dylanなんかどうでも良いかw
Dylanもcoerceという名前で存在しているんですが、
どうだったかなと
あ、それでmismatchですが、
(mismatch "1234" "2234" :from-end t)
は１
上の例は0
ですね。
マッチしない部分の開始位置が返ってくると
言う感じです。
こんな感じで一通り眺め終わりました！
ちょっとオーバーしましたが、
cl-ppcreに頼らなくても割と色々できるんだなと
個人的には思いました。
自分はなんでもppcreに行ってしまうんですが…。
あと、参考文献として
PG氏のANSI CLと、On Lispには収録されてないユーティリティ/コードにも文字列処理の関数が幾つか定義されています。
これは、今回の内容の手法がいろいろ使われています

http://lib.store.yahoo.net/lib/paulgraham/utx.lisp

最後の方にまとまってあります。
Arcもこの手法を継承しているようなので、
PG氏はこの方法で満足なんでしょうかねw
という感じでございます！

名無しさん 2008-07-26T21:42:58+09:00
最初のほうにでてきたaref vs elt ですが、CLISPやSBCLはeltの中からarefをよんでるので、型の判定とディスパッチ分だけ遅いと思うけど、コンパイラががんばったら同等までいけるのかな？

g000001 2008-07-26T21:43:26+09:00
あ、そうだ宿題のまとめを貼らないと

http://www.lingr.com/room/gKpArxPn9wi/archives/2008/07/26#msg-43421663
http://www.lingr.com/room/gKpArxPn9wi/archives/2008/07/26#msg-43423946
http://www.lingr.com/room/gKpArxPn9wi/archives/2008/07/26#msg-43426131

3つ宿題、というか後回し、というか深追いテーマです。

名無しさん 2008-07-26T21:44:16+09:00
あと setfable についてはhttp://www.lispworks.com/documentation/HyperSpec/Body/05_a.htm、特にhttp://www.lispworks.com/documentation/HyperSpec/Body/05_ab.htmあたりが

g000001 2008-07-26T21:45:13+09:00
なるほど、なるほど、

名無しさん 2008-07-26T21:45:25+09:00
↑HyperSpecを調べてる間に進んでしまったw 予習しとかないと

g000001 2008-07-26T21:46:19+09:00
placeがどんな物かで色々あるんですねー

名無しさん 2008-07-26T21:46:44+09:00
http://www.lispworks.com/documentation/HyperSpec/Body/05_abb.htm
nthはあるけどnthcdrはやっぱりないんだなぁ

g000001 2008-07-26T21:47:15+09:00
ああ、前にNANRIさんが
考えてましたね(^^

名無しさん 2008-07-26T21:48:06+09:00
nthcdr は 0 のときにどうすればいいかっていう問題でしょうかね

g000001 2008-07-26T21:48:23+09:00
ですねー。

名無しさん 2008-07-26T21:48:24+09:00
まさしくそこだと思います

g000001 2008-07-26T21:49:01+09:00
同じポインタを返すべきなのか、否かかなんかで
何か例を作ったような憶えが。

名無しさん 2008-07-26T21:49:49+09:00
あれ？ (cdr (nthcdr ...)) か (car (nthcdr ...)) だからなくていいのでは？
nthcdrはconsセルを返すから、書き換えるのはcar か cdr => だから setf car と setf cdr があるからおk
なるほど、そう考えると良さげですね。nthcdrはcdrを返しているんだからsetfできてもいいんじゃないかとおもってました。
last に setf しようとしてはまった覚えが。
で、実は0のときはcdrを返していないという...
(setf last) がないのも同じ理由ですね
そういえば、最初は setf できるかどうかってあんまりイメージできてなくて、できるやつ => やってみてＯＫだったもの、できないやつ => エラーでたもの、みたいな感じだった

quek 2008-07-26T21:58:04+09:00
place っていう概念は S 式言語特有ですかね。

g000001 2008-07-26T21:58:37+09:00
なるほどー。
自分は安直に

(defun (setf nthcdr) (subst pos lst)
  (case pos
    (0 (rplaca lst (car subst))
       (rplacd lst (cdr subst)))
    (1 (rplacd lst subst))
    (otherwise (rplacd (nthcdr (1- pos) lst) subst))))

とか考えてましたねw
組み合わせるんですねw

名無しさん 2008-07-26T22:00:21+09:00
C の左辺値も place と似てるところはありますよね

g000001 2008-07-26T22:00:22+09:00
nthcdr 0の時はポインタだけ同じで中身が違うものになるというw
といった感じですが
今日は実践CL発売ということですので

名無しさん 2008-07-26T22:01:22+09:00
LISPがメジャーになったらポインタ並みに人々を苦しめるに違いない。＞place

quek 2008-07-26T22:01:47+09:00
なるほど、ポインタににてるw

名無しさん 2008-07-26T22:01:51+09:00
a[n]=b と (setf (elt a n) b) みたいな
ポインタ演算に相当するものがないし大丈夫（きっと）
メジャーになったら…

g000001 2008-07-26T22:03:34+09:00
lispマシンにもlocativeっていう
あからさまにポインタ操作の機構があるんですが、
演算はしないのかな？
しなかったような。

名無しさん 2008-07-26T22:04:30+09:00
ポインタのイメージ持ってると (setf subseq) で混乱するとかいう
左辺値というのはうまいたとえですね。なぜか代入できない
はじめまして。こんばんは。

g000001 2008-07-26T22:05:37+09:00
こんばんはー

名無しさん 2008-07-26T22:06:00+09:00
すみません。ここのログの見方を教えていただけませんか？

g000001 2008-07-26T22:06:21+09:00
スクロールでずーっと上に
たぐると
Read messages from the archives…
というのがでますので、
それを押して頂けると全部見れます(^^
スクロールバーを一番上までもっていくのかな？

名無しさん 2008-07-26T22:07:34+09:00
ありがとうございます。読んでみます。

g000001 2008-07-26T22:09:17+09:00
今日は実践CL発売ということですが、
特になにかw

名無しさん 2008-07-26T22:09:57+09:00
いつの間にか夜になってて買いにいけなかった orz

g000001 2008-07-26T22:10:18+09:00
おお、zickさん試験中ですか？

名無しさん 2008-07-26T22:10:32+09:00
近所の本屋にはなかった orz
新宿の紀伊国屋とジュンクいってみてきました
nanriさんのは池袋ですか？
池袋です
新宿はそれほどでもなかったっす

g000001 2008-07-26T22:11:40+09:00
新宿のヨドバシカメラも前にOn Lispが発売日に平積みになってましたねw
実践CLも平積みになってたのでしょうか？
w
なぜヨドバシカメラに？と思いましたw

名無しさん 2008-07-26T22:12:34+09:00
写真に撮った以外にLisp棚にまとめてあったりしました
Lisp棚！？

haiju 2008-07-26T22:13:00+09:00
わたしはAmazonで予約したのですが、まだ届きません。

g000001 2008-07-26T22:14:09+09:00
お、bulbさんだ！

bulb 2008-07-26T22:14:15+09:00
こんばんは

g000001 2008-07-26T22:14:24+09:00
こんばんはー

名無しさん 2008-07-26T22:14:35+09:00
onjoさん。東京には小さな書店でもですね（嘘
こんばんは
On LispとかCLtLとかハッカーと画家とかが並んでます>Lisp棚
いやコンビニでもですね（嘘

bulb 2008-07-26T22:15:11+09:00
こんばんはー。新宿のジュンクで1冊ゲットしました

名無しさん 2008-07-26T22:15:43+09:00
食堂に行ったら「実践CLはじめました」と書いてありました
お買い上げありがとうございます。
（笑）
なんと。東京は凄いなぁ、と信じました。
冬には終わってしまいそう…

bulb 2008-07-26T22:16:26+09:00
Lisp棚もだいぶ充実してます＞新宿ジュンク

名無しさん 2008-07-26T22:16:40+09:00
ジュンクだけはマジです

bulb 2008-07-26T22:17:02+09:00
AMOPとPAIPの2冊はあちらに移しても

名無しさん 2008-07-26T22:17:03+09:00
明日はジュンク堂かなぁ。本ばっかそろって進んでないで躊躇してしまいます。でも買っちゃうんだろうなぁ。

bulb 2008-07-26T22:17:05+09:00
いいのではないかと

g000001 2008-07-26T22:17:06+09:00
ジュンク堂って行ったことないんですが、
相当すごいんですねー。

名無しさん 2008-07-26T22:17:15+09:00
きっとやさしいLisp入門からLisp Style & Designみたいなマニアックな本まで揃ってるに違いない…

haiju 2008-07-26T22:17:32+09:00
いいなぁ

名無しさん 2008-07-26T22:17:35+09:00
ジュンクは洋書には期待できないけど、他はそこそこ。

g000001 2008-07-26T22:17:44+09:00
Let over lambdaとかありましたか？

bulb 2008-07-26T22:17:54+09:00
それはなかったです

名無しさん 2008-07-26T22:18:07+09:00
Lisp本は種類が少ないからコレクター魂をゆさぶり

haiju 2008-07-26T22:18:16+09:00
Let ove lambdaはAmazonで買えましたよ

名無しさん 2008-07-26T22:18:36+09:00
amopもpaipもその場で買って帰れるのは良いですよね…

g000001 2008-07-26T22:18:38+09:00
おお、quekさん以外に購入してる方を発見！
自分も読んでみようかな

quek 2008-07-26T22:18:55+09:00
w

g000001 2008-07-26T22:19:14+09:00
日本で一番LOLについて書いてるのはquekさんですねw

haiju 2008-07-26T22:19:31+09:00
そうなんだ！

quek 2008-07-26T22:19:41+09:00
まさに (let (...) (lambda (... でどこまでできるか追求している面白い本でした。

名無しさん 2008-07-26T22:19:45+09:00
ほぼ全編マクロという問題作
私はLittle Schemer と　Ansi Common Lispで挫折しています。

g000001 2008-07-26T22:20:27+09:00
割と隙間を埋める感じの本なので

名無しさん 2008-07-26T22:20:32+09:00
どこまで続いたっけ？

g000001 2008-07-26T22:20:35+09:00
そういう方にもおすすめかなと

名無しさん 2008-07-26T22:20:46+09:00
Let Over Lambda 買おうかなーと思っていたり
let over lambda over let over lambda, までだっけ？
きにしない。本の雑食でも何とかなるから>hoppy
既にウロ覚えｗ

g000001 2008-07-26T22:21:09+09:00
皆さんよんでるんですねw
割とはやってるのかな

名無しさん 2008-07-26T22:21:32+09:00
lolって？　,',のせかい？
素人を切り捨ててかかる素敵な本でした＞LoL

haiju 2008-07-26T22:21:43+09:00
作者の人のページでも少し読めましたよ

名無しさん 2008-07-26T22:22:06+09:00
Lispのデザインパターンの本ってありますか？
タイトルは二回目のlambdaまでだったような

g000001 2008-07-26T22:22:38+09:00
LISPでってことになると
ないようなのですが、
http://norvig.com/design-patterns/

名無しさん 2008-07-26T22:22:56+09:00
Norvigセンセのスライドが

g000001 2008-07-26T22:22:59+09:00
とかデザインパターンについての考察ですねー。
Dylanですけどw

名無しさん 2008-07-26T22:23:05+09:00
皆同じものを出すw

g000001 2008-07-26T22:23:27+09:00
でも、DylanもまんまLISPなので、
同じかなと。

名無しさん 2008-07-26T22:23:37+09:00
ありがとうございます。

g000001 2008-07-26T22:23:47+09:00
この勉強会のお題にもしようかと
おもってたんですが、

名無しさん 2008-07-26T22:23:51+09:00
偏ってるのか聖典なのかどっちだ :)

g000001 2008-07-26T22:24:08+09:00
自分がデザインパターンを理解してないのと
参加者があつまらない気がしたので
保留になっていますww

haiju 2008-07-26T22:24:47+09:00
Lispのデザインパターンは興味あります

名無しさん 2008-07-26T22:26:14+09:00
動的オブジェクト指向デザインパターンとかにすれば、多言語の人が興味持ちそうと思ったのですが。

g000001 2008-07-26T22:26:24+09:00
Norvig先生の視点は割と斜めなので、
ちょっと理解が追いつかないw

名無しさん 2008-07-26T22:26:39+09:00
他言語に訂正。
lispをさわってるとデザインパターンとかのはなしが遠い世界に見える^^;

g000001 2008-07-26T22:27:20+09:00
デザインパターン道の人がLisperを説教するイベント
ということをテーマに
考えてみてたりしましたw
人があつまるかなーとw

名無しさん 2008-07-26T22:27:53+09:00
意識しないですねぇ＞デザインパターン

g000001 2008-07-26T22:28:28+09:00
Norvig先生のスライドも

名無しさん 2008-07-26T22:28:31+09:00
closを使っててもあまり気にしたことがないからかも。

g000001 2008-07-26T22:28:37+09:00
基本のパターンは関数型言語には、

名無しさん 2008-07-26T22:28:40+09:00
パターンが発見された瞬間マクロになっているんじゃないかな〜

g000001 2008-07-26T22:28:50+09:00
既に多くが存在するので、
パターンとして認識されない
みたいなことを説明して

名無しさん 2008-07-26T22:29:15+09:00
CとかC++だと、ダメパターンに陥ったときには回復不可能だから意識せざるをえないんだけども。

g000001 2008-07-26T22:29:20+09:00
その上でLispのデザインパターンとはなにか
みたいな方向に展開してるっぽいんですよね。

名無しさん 2008-07-26T22:29:38+09:00
そういえば、CLISPメンテなのSamはOcaml使ってwith-open-fileが抽象化できないムカーとか過激なことを書いていたなぁ
ダイヤモンド型の継承なんてそんなに気にならないからなぁ。＜CLOS
C++/Javaの人なら気持ち悪いと思う。^^;
何で多重継承とか気にすんの？って世界ですからね＜CLOS
普通にオブジェクトシステムの側に手を突っ込むしW
うんうんw

quek 2008-07-26T22:31:03+09:00
Common Lisp は CLOS という最も強力な OO 機能をそなえた言語でありながら、最も OO を必要としない言語（let over lambda があるから）だ、ってなことが LOL にも書かれてました。

名無しさん 2008-07-26T22:31:23+09:00
あったあった>LoL
俺はCLOSの説明なんかしないぜ！って宣言してたよね
letとlambdaでどこまで行けるか見せてやる、みたいな

quek 2008-07-26T22:32:26+09:00
つっぱしてますよねw

名無しさん 2008-07-26T22:33:07+09:00
正直、誰が読むんだろうと思った＞LoL
そんで本当にでてこない。after, before もどきを作ったりでちょっと名前がでてくるだけ。ヒドイ扱いだ…＞CLOS
^^;
そういうのを聞くと、CLOSが無いといけない状況というのはほんとに無いんですかと質問したくなります。
俺もclosを使うより構造体を使う方が増えてるけど、CLOSを使う事情はどんな時か？は探してるなぁ。
難しい質問だなぁ…
AllegroCacheが便利だからォィ

quek 2008-07-26T22:36:48+09:00
Elephant もw

名無しさん 2008-07-26T22:37:08+09:00
使ってるライブラリがCLOSベースだった場合

g000001 2008-07-26T22:37:58+09:00
CLOSっていえば、

名無しさん 2008-07-26T22:38:06+09:00
あぁ。。。まだ使ってないけどclsqlとかもclosベースだったなぁ。そういや

g000001 2008-07-26T22:38:08+09:00
大規模なチームで開発してる
ITAはCLOSばりばりらしいですね
Weinreb氏がどっかに書いてたような

名無しさん 2008-07-26T22:38:42+09:00
ITA?
インフォメーション・テクノロジー・アライアンス？
違うだろうなw

g000001 2008-07-26T22:40:14+09:00
あれ、どこだっけな

名無しさん 2008-07-26T22:40:38+09:00
ITAはLisperがいっぱい居る会社ですよ。http://jp.franz.com/base/success/orbitz.doc

g000001 2008-07-26T22:40:57+09:00
http://www.itasoftware.com/careers/SolveThisWorkHerePuzzles.html?catid=114#Server_API_Developer_Puzzles
とかで最近shiroさんのwilikiで取り上げられていたような
CLOSばりばりで、SICPみたいな書き方はしないよ、みたいなことが書いてあったような

名無しさん 2008-07-26T22:42:36+09:00
なるほど。
きびきびした動きのページだねぇ。

g000001 2008-07-26T22:43:35+09:00
weinreb氏はCLでは割と有名な方で
http://wiki.alu.org/Daniel_Weinreb's_Road_to_Lisp
に詳しくのってます
詳しくもないかw
あ、この記事かな
http://xach.livejournal.com/146048.html

名無しさん 2008-07-26T22:45:19+09:00
http://www.itasoftware.com/about_us/acknowledgements.html　Good News: CL-HTTPのロゴが！　Bad News: その下のロゴw

quek 2008-07-26T22:45:59+09:00
ww

haiju 2008-07-26T22:46:25+09:00
メモするの大変です

名無しさん 2008-07-26T22:46:35+09:00
MITハッカーのヒトなのね。
Norvigも「漏れの目的にはPythonで十分」ってあっちの世界に行ってしまわれたしね orz
何？＞メモ

haiju 2008-07-26T22:48:08+09:00
ノートPCの画面が狭いのでブラウザだらけになってしまう

quek 2008-07-26T22:48:39+09:00
CL-HTTP ってどうなんでしょう？ むかしから気になっているのですが、何故かしら手をつけていない。。。

g000001 2008-07-26T22:49:26+09:00
面白そうですよねー。
昔はホワイトハウスのHTTPサーバだったと
どっかで聞いたような。
1994年位の頃の話だったと思いますがw

quek 2008-07-26T22:50:15+09:00
おぉ > ホワイトハウス

名無しさん 2008-07-26T22:50:22+09:00
Lispacheというのもありましたね

g000001 2008-07-26T22:50:24+09:00
ガセかもしれません(^^;

名無しさん 2008-07-26T22:50:40+09:00
何故その名を知っている＞Lispache

g000001 2008-07-26T22:50:41+09:00
苫米地氏のやつですねw
完全apache互換なんでしたっけ？

名無しさん 2008-07-26T22:51:49+09:00
いまもかどうかは分かりませんが。バグまでまねしてるとか。
新しいのリリースしてくれないので、動かすのが一苦労だったような。>CL-HTTP
あとApacheの4倍速いとも聞いたことがあります。
学生時代にCLIMのGUIを部分的にCL-HTTPで動かすとかいうのを見かけて、Viewが画面からWebになるのか！これがMVCってやつか！と思った記憶が。

quek 2008-07-26T22:53:03+09:00
JLUG Meeting 2000 で苫米地氏の発表をききました。
http://jp.franz.com/jlug/ja/jlugm2000/index.html

g000001 2008-07-26T22:54:39+09:00
おお、いろんな関連資料がありますね。

名無しさん 2008-07-26T22:54:47+09:00
JLUGって活動してんのかな。
サイトのメンテやってくれない？って小俣ちゃんに頼まれた記憶が

quek 2008-07-26T22:55:20+09:00
Netscape 用の Lisp VM プラグインっていうのもあったらしいです。

名無しさん 2008-07-26T22:55:49+09:00
苫米地氏って最近いろんな本出してますよね。。。

haiju 2008-07-26T22:55:57+09:00
へぇー凄い

quek 2008-07-26T22:56:01+09:00
JavaScript のかわりに CL がブラウザで動いてくれたらなぁ

g000001 2008-07-26T22:56:08+09:00
基本的に洗脳系ですよねw

名無しさん 2008-07-26T22:56:19+09:00
検索したらびっくりした。路線が…

g000001 2008-07-26T22:56:33+09:00
Scott Ferlmanの弟子だったり
するんですよね。
Scott Fahlmanか
エリートな方なのは間違いないんでしょうね。
なかなか独特な路線を歩んでらっしゃるようで。

名無しさん 2008-07-26T22:57:59+09:00
そうですね。一冊でもLispの本書いてくれれば・・・。

g000001 2008-07-26T22:58:11+09:00
あ、洗脳系のほんでも
書いてるらしいですよLISPのことw
前にブログ読んだらそんなことが書いてありました。
cl-httpといえば、
http://lispm.dyndns.org/
のjoswigさんが

名無しさん 2008-07-26T22:59:26+09:00
そうなんですか。じゃ、悟りをひらくために買ってみますｗ

g000001 2008-07-26T22:59:43+09:00
でもムービーとか、このサイト自体をcl-httpで
運用してるみたいですね。
何かが開けるんじゃないでしょうかw

名無しさん 2008-07-26T23:00:11+09:00
へんなCDが聞きたくって英語の奴かったけど<とまぶち
音の立体感はおもしろいよ。とおもったかな。
70.216のPrereleaseが二年前か…

g000001 2008-07-26T23:03:03+09:00
そういえば、symbolicsのサイトも
lispm+cl-httpだったような
もうlispmじゃない、というか、
サイト自体、ドメインだけですけどw
LispMのuptimeとか、メモリ状況とか表示されてて
面白かった思い出が

名無しさん 2008-07-26T23:07:02+09:00
JLUGM2000の Coming Soon to Allegro CL...Streams って SIMPLE-STREAMのことですね。むぅ、普及の速度が…。

g000001 2008-07-26T23:08:17+09:00
これまでは停滞していましたが、
実践CLで日本人のCL人工が増える→多言語対応の需要が伸びる→急速に進展
かもしれませんよw

名無しさん 2008-07-26T23:09:19+09:00
初版何部作ったんだろ>
それより今年に入ってから電車で「株式会社COBOL」の求人広告を何度か見掛けて感動してみたりｗ
残存者利益、って奴を狙ってるのかな。
例のPCL wikiってアナウンスしたんですか？＞onjoさん
や、まだです。アナウンスしていいのかな？
いいんじゃない？onjoさんのサイトだし。
正誤表とかがあちらこちらに散らばるよりは集約した方が吉かと。
では、 http://pcl.lispuser.net/ に実践Common Lispのサポートページを用意しました！
…というのをどこにアナウンスすればいいんだろう？ caddr グループと某掲示板くらいしか思いつかない。
お、目次見て買うの決めました
2chに書いとけば勝手に広まるのではw
2chに私が書いてきましょうか？
あ、お願いできますか？
ほい。
amazonに書けたりすんのかな。レビューのとことか。
レビューといえば翻訳がダメだとかボロクソに叩かれたらどうしようと怖くて"実践Common Lisp"とかをキーワードにしてググる勇気がないｗ
あー、下じゃなくて、そっちだったかー
下？
Amazonのページの下のカスタマーレビューのほかに、著者（訳者？）コメントみたいなのがあったような。
./commonlisp/pcl.html の方を見つけていたので＞下
書いてきました。

g000001 2008-07-26T23:23:22+09:00
http://pcl.lispuser.net/のことをブログに書いてもいいんだったら

名無しさん 2008-07-26T23:23:38+09:00

理解しました。>下のほう
どうやら org-mode のファイルの保存先を間違えて publish したらしいw 

g000001 2008-07-26T23:23:38+09:00
自分のブログにもエントリしたいと思いますー

名無しさん 2008-07-26T23:23:58+09:00
>maru きにしなくていいよ。
がうちぇになってる。
翻訳が駄目って言われるなら、それは甘んじて受けるしかないですね…
日本語ムツカシイネ :)
翻訳の本を積読してて、
終わってから読み始めて
モヤモヤしすぎてなんか涙がでそうだった
…
まぁなんすかね
ここの意味がとり難いとか言う指摘でも歓迎しますよ
直せる種類のものなら原稿に手を入れても悪くないでしょうし
sicpとかjavaの仕様書?の訳は結構ボロクソに言われてるみたいだけど
時として背景に必要な知識のなさを棚に上げてる場合があるんで、その辺を見極めて批判を判断した方がいいとおもう。
訳す作業をする前はそういうノリだったんですけど、
WiLiKiは小さくて便利。zickさーん、WiLiKiのWikiフォーマッタを是非CLに。CL-Wikiのは派手にバグっておりますゆえ。
訳しているうちにトーンダウンしてきました。
まぁ、読みやすくはないですよね？位で
仕様の訳があったらいいなーとは思うんですが、HyperSpecは権利関係がややこしくて駄目そうだしなぁ。
CLtL 2ndじゃなくて、本当のANSIの規格書ってこと？
CL庭師がやってたFreeSpecプロジェクトがそれで力尽きてたんで。期待のANSI CL Referenceは無かったことになりそうだしなぁ。
見たことないですわ＞ANSI規格
誰？＞CL庭師
http://wiki.alu.org/Gardeners_Projects ここの
Project FreeSpec　
です。残念。
参照はできるから困らないのかなぁ。でも翻訳は駄目そうだよなぁと。
なるほど。いろいろ複雑そうですね

g000001 2008-07-26T23:44:36+09:00
http://clqr.berlios.de/
は翻訳可能なんでしょうか。
なんか評判良いみたいですよね。
規模は小さいですけど。

名無しさん 2008-07-26T23:47:01+09:00
GNU Free Documentation Licenceに従うなら配っても変更してもいいとかいてあるからきっと大丈夫なんでしょう

g000001 2008-07-26T23:47:38+09:00
とりあえず実践CL購入層には受けそうかなと。
いう気がw

名無しさん 2008-07-26T23:48:27+09:00
・・・・。ＡＮＳＩ Common Lisp読み直したけど最短経路のソースがまだ分からない
購入者特典日本語クイックリファレンスが非公式サポートページだからダウンロード可！とか
そんなこと言われると、みんな ANSI Common Lisp を構えて待ち受けるのでは >hoppy
英語版は・・・引っ越したときの箱詰めのままか orz
問題なんだったっけ？
ぐぅぅ、どのダンボールのどの辺に埋めたっけ…
分かりました。codepadにでも書いてきます。
僕はいまboost::preprocessorの使い方を指南してくれるサイトを切に希望してます
boostは鬼門。C++0xとか自分はあきらめました。変態すぎる。
危険そうな名前ですね
食べ終わった魚にしか見えませんね
Lisp使えばマクロで一発解決なんですけどね。C言語だとそれはもう大変な苦難の道なのです。
ふむふむ http://www.boostpro.com/tmpbook/preprocessor.html
codepadはLispに対応してない。。。
http://paste.lisp.org/display/64253
こんな感じのソースです。
maruさんにはSCを
http://www.yuasa.kuis.kyoto-u.ac.jp/~hiraisi/sc/
おー、見えました。
幅優先探索ですね。疑問はどの辺ですか？
そうそう。こんな感じのコードジェネレータを書いてやろうとしてたんですよ（実際にしてた）。
どこ？＞見えた
http://paste.lisp.org/display/64253 <-- これ
てっきり魚かとオモッタ…
しばらくみんな発言ないなーと思ってたらブラウザが暴走してました。l
Gaucheだとメンテできる人限られるかなと思ってerb使ってたのに、他のメンバは何が嬉しいのかboost使って喜んでる orz
僕もコード見えたよ。
(list (list start)) まず、listが入れ子になっている意味が分からないです。
一回でいいように思えてしまいます。
なるほど。リスト構造でパスを表現しちゃってるところが問題なのか。
簡単なことなんだと思いますが。。。
bfs の第二引数は検索用のパスがつまったキューです。キューは (パス パス パス)
で、パスの表現が、(ノード　連結先 1 連結先2 ...)
schemeっぽい…
したがって (make-queue (make-path :node end :link nil)) と書くところを
あー、自分もこの辺読んでいるとき思いました＞schemeっぽい
(make-path ...) => (list ...), (make-queue ...) => (list ...)
で、 (list (list end)) となってるんですね。まだ構造体とかをやる前なんじゃないかな。
うーん
なんというか評価機の気持ちになる説明をしていけばいいのかなーと思いました。
そうですね。＜構造体をやる前
キの字が違った
onjoさんの説明でわかります？

USER(8): 
 0[4]: (BFS D ((A)) ((A B C) (B C) (C D)))
   1[4]: (BFS D ((B A) (C A)) ((A B C) (B C) (C D)))
     2[4]: (BFS D ((C A) (C B A)) ((A B C) (B C) (C D)))
       3[4]: (BFS D ((C B A) (D C A)) ((A B C) (B C) (C D)))
         4[4]: (BFS D ((D C A) (D C B A)) ((A B C) (B C) (C D)))
         4[4]: returned (A C D)
       3[4]: returned (A C D)
     2[4]: returned (A C D)
   1[4]: returned (A C D)
 0[4]: returned (A C D)
(A C D)USER(9): 

BFSのtrace貼ってみた
queuega
間違えた。queueがリストのリストとして表現されてるの、わかるかな。
そうか、TRACE BFS で評価器の気持ち（というかと中継経過）が…
カッコがたくさんあるのは分かりますね。
これって再帰ですか？
分かってきたような
再帰ですけど、あんまり関係ないです
というかこれ再帰で書く人いますか？
そして私の説明は微妙に間違っておりました :-( 御免なさい。QUEUEに入るのは探索した経路で、(今いる場所　経路　経路 ...　出発点) というリストですね
A からスタート -> A は B と C に接続されてる -> (B A), (C A) ができる。
bfsのアルゴリズムを1ステップずつ追ってく？
ぉ、onjoさんの解説が始まる予感
いま、(list (list.... にリストを入れてみて試してみました
きっとhoppyさんに相槌打ってもらうとやりやすいっす
そして経路はカッコで囲まれていないんですか

gosh> (list (list '((a, b, c) (b, c) (c, d))))
((((a ,b ,c) (b ,c) (c ,d))))

経路は A -> B を (B A) と表現します。
はい
A -> B -> C は (C B A) ですね。何でかというと経路は延びていくので cons してゆきたい。
はい
A -> B, A -> C の二つの経路を表現すると ((B A) (C A)) となります。
はい
…大変だ。そもそも疑問だった　shortest-path の　(list (list end)) を飛ばしてしまった。
list list startね
ちょっと戻りますが、スタート地点が A なのでこの経路は (A) です。で、キューは経路のリストなので ((A)) なんですね。
コレ↑がbfsの呼び出しの中でqueueの中に入っている「いままでに探索した経路」の表現になってるの。ここまではOK?
そそ。スタート地点しか見てないから((A))なの。
経路のリストの数－１だけカッコを付加するんですね
違うなー
うむ。どこから整理しよう。
先にnew-pathsの説明したほうがよいんじゃなかろか
と思ったのですが、traceでどういう操作をしているのかをリスト抜きで説明してもいいかも
もう遅いし、明日にしましょうか？もう少し自分でも考えて見ます。
そうですね。いきなり説明されると考える時間がありませんからね。
このチャットは週休６日ですが…
確かにしんどい時間ですね…
そのときはそのときです。＜週休6日
あい
ありがとうございました。
おやすみなさい。
教えるのが上手い人になるにはどんな訓練を積めばいいんだろか。
場数ですかねぇ…
駄目だったげでしたね。
無念じゃ
このbfsが読みにくい気がしてならない…
最初の失態を補うべく解説記事を書こうかな～
やる気過ぎる…
リスト云々でなくまず動作を説明すべきという指摘がド真ん中な気がしたので。
うーむANSI CLがみつからない…。とりあえず明日にします。おやすみなさい。
お疲れ様でした
お疲れさま〜
あら、
確かにこのbfsよみにくい。
そもそもbfsって何の略なんだろ
breadth-first search, スペルあってっかな
あってそう
どもです。http://eow.alc.co.jp/breadth-first+search/UTF-8/
そんなものまで載ってるのね＞英辞郎 :)
気持ち悪いなーと思っていた感覚がやっとこわかった
どうせ再帰を使うならqueueなんてつかわないで全部呼ぶのに…
って感じですね
loop代わりのbfsが単発なのが納得がいかないです
map系の操作をまだ説明してない段階なのかと思いきや、new-pathsでmapcar使ってるのね（謎
僕もbfsのtraceでqueueがくるくる回ってるのを見て変なことするなぁと思った
queueをvector使って再帰が深くならないようにしてるなら納得なんですけど無駄再帰があるので台無し…
その辺はほら、本文の後の方で改良版が示される手筈になってるのかも知れないし（もう覚えてない＞ANSI Common Lisp
queue使わないと幅優先になりそうにないことに気がついた…
寝よう…
おやすみ〜
僕はまだまだboostですｗ
macroexpand-1みたいのないのかな・・・デバッグができん orz
1が欲しいですよね…
寝ます
こんばんは
こんばんわ
どんなもんです？
listってただカッコで括るだけなんですよね
はい
listに渡された引数すべてを含んだlistを作る
なのですが　(list 'a) なら (A)になりますね
入れ子になったletが分かりません。
えっと
どういうわからないですかね
1.入れ子にする挙動
2.ここで入れ子にする理由
http://paste.lisp.org/display/64253
pathとnodeのところですよね
入れ子の仕組みです。変数を代入するという感覚しかないので
letの中にリストが出てくると混乱してしまいます。
じゃぁ少し簡単げな例を
お願いします。

(let ((a 0)) (let ((b 1)) (list a b)))

これの結果は何になるでしょうか？
むずかしいですか？
…
(let ((b 1)) (list a b))
で（（a,b))を((b,1))に代入でいいですか？
letの書式からですね
(let (束縛式) 束縛の利用*)
という感じです
束縛式で代入とは違うんですけど、上の (let ((a 0))　…)
はい。
の場合 aが0に束縛(厳密には違いますがaに0を代入と読んでもかまわないです）されます
束縛の利用の範囲ではaは0に見えるようになります
入れ子になった(let ((b 1)) …)では
はい。範囲はletのカッコの中ですね
(list a b)の時のa と bの値はなんになりますか？
((0 1))
ですか？
うーん
aは 0 bは1です
(list a b)は　(0 1)を返します
正解といっていいのかどうか、迷います
あ、カッコが多かったですね。
listは0 1を要素に持つリストを返すので括弧はひとつです
(list (list 0 1))なら　(0 1)を要素に持つリストを返すので
((0 1))になります
変種の問題で

(let ((a 0)) (let ((b 1))) (list a b))

これはどうなるでしょうか？
括弧の位置に気をつけてください。
？
(0 1)
((0) (1))]
どっちか分かりません。
どちらも違います…
あらら
(list a b)の時にaは何かとbは何かを
考えてみてください
ちょっとずるい感じなんですけど、
aを束縛するletの中なので、aは0ですよね？
はい
bを束縛するletからは出ちゃってますよね？
この場合bは1とは限りません
もしbが既に定義されていればその値になりますが、
大体の場合は定義されていないので、
unbound variable（未束縛の変数）ni
類するエラーが出る可能性がでかいっす
letはただの代入ではなくて。
代入の範囲を指定するものと思えるものです
はい
letの仕組みは理解できました？
どうも人に物を教えるのは下手な感じなので…へろへろやるしかない感じです…
いまインデントしてどういう構造か見ているところです。

(let ((a 0)) (let ((a 1)) a))
(let ((a 0)) (let ((a 1))) a)

同じことなんですけど、さっきのはちゃんと実行できないので、
この二つの違いがわかるならletの挙動はひとまずおけーですかね
下はaは不定かな
そうかな？
あ、0か
そっす。
上は1でしょうか？
パーフェクト
ありがとうございます～
さっきの質問は
letは束縛を複数作ることもできて
(let ((a 0) (b 1)) (list a b))
というようなことができるので、
なんでこういうのを使わないの？
と解釈することもできるので、
どっちだろうと思いました
なるほど。
んで、ついでなので
これについても説明しますが、
お願いします。
(let ((a 0) (b a)) (list a b))
これができないんです
aを参照できるのはさっきの
(let (束縛式) 束縛の利用*)
での束縛の利用と書いたところだけなんです
(b a)が利用されてないということですね。
bでaを参照できないんです
cの警告とは違う感じですね
bはlistで使われているので…
Cというのは言語のことですか？
あ、
はいごめんなさい
いえいえ
hoppyさんの確認でCの警告を連想してしまって…
おかげさまで理解することができました。ありがとうございます。
bfsは…
あ、そちらも説明してくださるんですか。ありがとうございます。
えーと
今どんな風に理解しています？
どんな風にといわれると難しいですが、
いろんな方向から説明することができるかと思いますが、
再帰は大分慣れてきているので、じっくり読めばなんとかなりそうです。
bfsの考え方でいいですかね
概観が掴めればわかりやすいかもしれません。
例題であるのは
aから　b cにつながる道があって
bから cにつながる道がある
あと cからd　ですね
はい
ここで aからdに行く最短の道を探しましょう
ということですよね
はい
まずa からつながる経路を列挙します
(b a)と(c a)があります
最初は((a))があって、
そこから(a)をとりだして
aからつながるルートを二つみつけて
(b a)と　(c a)を差込なおします
はい
つまり一段階で((b a) (c a))になります
次にさっきの結果から (b a)をとりだして
bからのルートを全部列挙します
といってもcしかありません
(c b a)になりますね
これをおしりにくっつけます
はい
((c a) (c b a))
になります。
これが二段階目
次に(c a)を取り出します
cからのルートを探します
(d c a)ですね
はい
結果をすぐチェックしているわけではなくて
最初に取り出したときにdに到達しているかどうかをチェックしているので
(d c a)も後ろにくっつけちゃいます
((c b a) (d c a))
次に(c b a)を取り出してパターンをさがします
(d c b a)になるんですね
これを後ろにくっつける。
はい
((d c a) (d c b a))
で
次に取り出したときに目的地にたどり着いたことがわかるので
それを
ひっくり返したものを返す
(a c d)
が結果になる
と
こんな感じで最短が見つかりました
めでたしになります
reverseでひっくり返すんですね
はい
わかりました。ありがとうございます。
このコード結構、読みにくいです
部分部分で何をやっているか読んでいくとわかるようになるかもしれません
hyperspec等々使ってがんばってみてください
ありがとうございます。
長い時間解説ありがとうございました。
ぼんやりと環境構築してました。
もう少し人来るかと思ったんですがねー
実践CL買って熟読とかではないでしょうか＾＾；
昨日解答に四苦八苦していた面子は半分以上関係者なので
ちょっとそれもなさげ…
普通に週休６日なんすよね
おおっ。そんな方に教えを乞うていたなんて
6日？
土曜以外機能してないですよ？
と昨日もいっていたような記憶があります
ああ、ここですね
学生さんとかに知れ渡ると賑やかになるかもですね。
賑やかになったらなったでフェードアウトしたくなるっぽいので、
適当な感じで
…
w
あはは
こんばんはー
こんばんはー
hoppyさんもいらっしゃいますね。TRACEするより詳細な表示を用意しましたよっと。http://lispuser.net/memo/lisp/2008-07-27-01-14.html
なるほどー
少し考え込んでしまいました…
ありがとうございます。
http://d.hatena.ne.jp/patterson/
なんとなく日本語版で読んでいる人を見つけたので…
妙にうれしいです
あと
http://lispuser.net/memo/lisp/2008-07-26-01-19.html
これはありえないっす
入門xyzzyをlispに分類した本屋はないですね
知らない…ですね
仕事でlispを使っている人いない、かぁ。schemeは居ましたね。
いましたね
えー。違うんですか。じゃあどこに分類されるんだろう
vi emacsとかunixの雑多なユーティリティっぽいところですかね
新米書店員らしき人が入門xyzzyについて「これはどこに置けばいいですか」
っつってるのを見たことがあります
買う人は見たこと無い…
秀丸の隣かなんかで、「まぁここでいいんじゃね」
という対応でした
あとlisp同士の結合よりも洋書和書の分類の方が強いので、
PAIPやamopとも泣き別れです
洋書のSICP、PAIP、AMOPは結構近いんですけどね
なるほど。LISP(和書), LISP(洋書) の棚にわかれるんですね。
こんどLisp棚の写真でもとってきますかね
まぁ大体そんな感じです
list とかの話だったんですか。cons とかクォートは最初は難しいですよねー。
慣れるとcar, cdr は右とか左とおなじくらいの概念になるんだけれど。
処理系を実際にいじりながら、脳内の評価器と本物の評価器の挙動をすりあわせる時期ってありますよね
いや、car, cdr には向きがあるから上下というべきか？
括弧の数がどうとか
funcall とfunctionの対応とか
バッククオートとカンマとか
hoppyさんはひょっとして一冊目がANSI Common Lispだったりしますか？
いや、やさしいLisp入門（カットシステム）＞Little Schemer、Gauche本、ANSI Common Lisp
SICPは積読
という感じです。
カットシステムというとEmacs-Lispのじゃなかったっけ。
やさしい～もあります。ただあんまし役に立たなかった＾＾；
文法を延々と書いているような本です。
著者　株式会社ニコラテスラ　酒井皇冶さんです
うーん、Amazonには目次がない。
という CL の本があるのか！
持ってないなー
cons セルの car と cdr は身につきました？
[↓|→] これが cons セルに見えてくる
consは繋げるというイメージしかないですね。
繋いだ結果が見えるようにならないと

理解がし難い印象はありますね
これがつなぎ合わさってリスト表現になるのです。

一番上のが (1) 、次が (2 1) 最後のが (+ 2 1)
lingrって画像になるんだ…すごいなぁ
そこまではまだですね。
おお、
これはブレイクスルーというか、よーわからんなぁ～考えていると、あるとき一気にわかるんですよ。
なんか演習でやらされた…からかどうだか知らないけど。そういうブレークスルーは実感できなかったなぁ…
consセルは見えているのに、構造に慣れていない状況が私はありました
あー、なるほどぉ。
で、リストはポインタってこういうイメージだったんですね。
演習でLispはなかったからなぁ…
文系学部だったので演習すらなかった
実際にはこんな行儀よくなく、ガンガン cons セルをつないでいくので
私も文系学部なんすけどね


こんなかんじで、どっから見るからによって見え方がちがってくる。
点線矢印が視線すね
Aからみると (1), Bからみると(2 1), D からみると (-1 2 1)
ふーん。この図って何で描いてるんですか？
昔 tgif で描いたんじゃないかな。
なるほど。
http://lispuser.net/memo/lisp/2006-12-08-03-54.html の記事から引用です。
http://www.cutt.co.jp/book/4-87783-102-9.html
やさしいLisp入門目次
文系でも心理学系の人は利用している人もいるみたい 学部卒業するのに必要な演習なんて好きなのえらべばいいんじゃねーの？
というポリシーでした
指定されない限りlispと
嫌がられたんじゃないかな…
いい大学ですね。
やさしいLispが既にあるとは…。じゃあ次は厳しいLisp入門か。
やらしいLispでも・・・
onjoさん…
hoppyさん…
本はそろったけどどれも途中で挫折してますね。
あっち読んだりこっち読んだり担ってます。
「薄いCommon Lisp入門」かな…
冗談ですけど。なんとなくフルメタルジャケットのハートマン軍曹を思い出してしまった。
読者は蛆虫だ！
こんな感じ？
きっと、途中で「貴様らはホワホワだ！」とかなんか適当にごまかされるに違いない。
エディタがEmacsなら、emacsのチュートリアルなんかもすぐに役にたって結構良いですよ。
持っている本からやりたいんだったら
little schemerを実際に実行しながらやってみる
のが一番よいですかね…
一番基礎固めっぽい印象があります
ありがとうございます。
関数定義して M-x edebug-defun してから関数を実行するとすごく動作がよくわかる。>Emacs
EmacsをVistaで動かすとしたらMeadowがいいですか？
良いんじゃないでしょうか
僕はvistaでntemacsを利用してた。
UNIXも使ってるなら、http://ntemacsjp.sourceforge.jp/matsuan/IndexJp.html#sec1 でしょうね。
メイリオフォントに設定すればずいぶん綺麗に見えるよ。
私はホームディレクトリを Win, Linux, BSD で共有しているので NTEmacs です。
あれ？メイリオフォント使ってませんでした。今度試してみよう。
どうも挙動不審で。Meadowでw3m使おうと思ってgc7.1をcygwinで./comnfigureしようとしたらsedとsortがないって言われて
コマンドベースでは使えるのに./configureだと駄目でした。
cygwinかー。昔使ったら遅かったのですっかり疎遠になってしまった。Vistaでも動くのかな？w3mまで動かすのは結構大変そうだけど。
vistaでもうごくけど、x11はだめだった うごかなそうですね。おそらくなんですけど、ultimateだとunixコマンドが使えるようになるらしくて
それとcygwinがかぶってそうです。
そろそろ寝ます。今日は本当にありがとうございました。
お疲れ様でした。今後も頑張ってください。
もう12時まわってるんだ。。。お休み〜
お休みなさい～
うーん、クイックリファレンスはeLaTeX使ってるのか…。日本語化できるのかなぁ。
寝よう…
e
r
P.41 4.3 S式
1.0e-4 ; 小数点数の「せんぶんのいち」と同じ
のところ。
「いちまんぶんのいち」では？
元の表現は「one-ten-thousanth」ですし
すべて我々の不徳のいたすところです m(__)m
10 x 1000 分の1なので1万分の1,
ですね。チェックすり抜けました。
間違ってますね
環境とばしていたので今svn co中
直してコミット…じゃなくてwikiを直しに行くべきですね
うむ。wikiがアップデートできん(謎
wrong number of arguments for # (required 6, got 5)
助けてonjoさ〜ん
うーん
よくわからんすね

(delete #\Return line :from-end t :end (length line) :start (1- (length line)))

かな？

g000001 2008-07-31T13:09:33+09:00
なるほどー。そういえば、元は破壊しても大丈夫ですよねー。
アレイに対するlengthとかpositionとかのコストがいまいち把握できていない私ですw
どういう関係になってるんだろう。リストはなんとなく分かって来たのですが…。

名無しさん 2008-07-31T14:06:30+09:00
もしlineがstringならば　(string-trim '(#\Return) line) か　(string-trim-right ......) のほうが書きやすいかも

g000001 2008-07-31T15:49:11+09:00
なるほど、string-trimですね！勉強会でやったばかりなのに私は思いつきませんでしたw

名無しさん 2008-07-31T21:18:17+09:00
wiliki の更新をミスっておりました。 復旧しました。>wiki

改行コードは処理系毎に external-format に指定するのが一般的ですね。DOS の crlf なら
CLISP
(make-encoding :charset "Shift_JIS" :line-terminator :dos)
JPパッケージ (pcl.lispuser.net)
(jp:make-encoding :sjis :eol-style :crlf)
で # オブジェクトが得られます。これを使えば改行コード crlf でもちゃんとread-lineできます。

あ、一部が顔文字に…
「実践CL」の付録参照ということで、対応している処理系はそれでOKなのですが、sbclが未対応っぽかったので自前で処理することも考えないとなぁとか思ったのでした。
#¥Newlineと比較して行末を判断しているっぽかったので。
あぁ、SBCLですかぁ。うーむ。
#¥NewlineでCRLFを表すってことはないでしょうし...
行末を :dos / :crlf に設定するとキャラクタストリームでは #\Newline が CRLF になりますよ。
あ、そうか。SBCLは行末コードの指定がないから駄目でしょうね。
その場合以下は両方nilになるんでしょうか？

(char= #\Newline #\Linefeed)
(char= #\Newline #\Return)

…逆にそれってtになるべきものなんですかね？
あれ？ どちらかは必ずTになるんだと思ってたんですが...
nilだったものがtになるような変化を想定しているようなきがしたので
違うんじゃないかと思ったのですが
Cでの暗黙な\n ->\r\n変換のようなことが起こるのだと思ったのですが
…なんとも自信の無い書き方。
暗黙の変換が起こっていいのですが、改行コードが混ざったものを読んだ時にどうなるのかなということですかね。
処理系依存のところで、あんまり悩んでも仕方がないのですが。
音沙汰無く蹴られていてきがつかないのが気持ち悪い>lingr
おぉ、つながった。
おかえりなさい
ガーン。書き込みが全部消えている…
む
msno
cで何が起こるかも説明できないな…
混ざったものは処理系によるでしょうね。Cでも処理系依存じゃないですか？
依存だったと思います。
はい。混ざったものを#\Newline #\Linefeed #\Returnで区別してたら、スゲー
と自分が思うというだけの関心事です。
CLISP で :dos でやってみたら #\Newline, #\Linefeed => crlf #\return => cr になりますね。まぁだとうなところかなぁ。
この状態で #\Return #\Linefeed って出力すると残念な事になりますが、まぁそれは C でもテキストモードで開いて I/O したらそうなるし…。

[1]> (char-code #\newline)

10
[2]> (char-code #\linefeed)

10
[3]> (char-code #\return)

13

これも…ですよね
read-line の読込みは　cr lf -> 改行一個、 cr -> 改行一個。まぁいいと思います。
単体のlfは…と思ったら上記条件だとちょっと面倒だな
おぉ、なるほど。やっぱり SIMPLE-STREAM が欲しいなぁ (write-byte (char-code #\Linefeed)) で…
また落ちた…なんか調子悪いのかなぁ。
なんかお二方接続が安定していませんね。
まだアクセスしてるのになぜか left …
前のが切れたんですよ
さっきまで二人いました。
あぁ、そゆことですか。なるほど。
nanriさんはどこらへんまで読みました？
すげー話を変えてしまった…
とりあえず付録から読んで、いまスペシャル変数だったかな。
のんびり読んでます。
知っていても2,3日で読み終わる本じゃないと思うので、
書評書く人はそういう技術があるんだろうなーと思いましたです
のんびりっていってますけど、遅くもないんじゃないでしょうか
(write-byte (char-code #\Linefeed) *standard-output*)
特に一回目に読む視点は貴重ですからね。二週目以降はスペシャル変数は後ででてくるもんな～と思ったりしてしまう。
読むだけなら土日でやっつけることもできたと思いますけど、今回は長く楽しむ方向でいこうかなと。
write-byteいけます？>tsuruさん
Allegro 以外はいけないと思いますけど、Allegroですかね？
あぁ、ごめん。あれはECLでいけたけど、SBCLはダメだった。SBCLはバイナリSTREAMが欲しい。
うーむ、書込みの右側でくるくるアイコンが回っている奴は消える運命になるのだろうか。
セッション切れるときはそうっぽいですねー
問題はまだ聞いていないけど、(with-open-file (stream "/tmp/test" :direction :output) (write-char #\Newline stream)) はダメ？
大本の問題はどちらかというと読む方だったりします。http://cadr.g.hatena.ne.jp/g000001/20080731
ACL/LispWorks/CLISPは external-format で改行コードが指定できるけれど、SBCLかなぁ。
そして snmstsさんの難題。external-format 改行コードに :crlf を指定した状態で 0x0a のみを出すには… SIMPLE-STREAM もしくは文字I/Oをすてて :element-type '(unsigned-byte 8) で :-)
前提が死んだ :crlf
僕もwin32と*NIXをサポートためによく(string-trim '(#\Return #\Newline) stream) を使います.　この場合は(string-trim-right '(#\Return #\Newline) stream) は十分かなぁ。
間違えた。streamの代わりにstringを書けばよかった
正誤表...>http://www.lingr.com/room/gKpArxPn9wi/archives/2008/07/31#msg-43768327

g000001 2008-08-01T11:53:45+09:00
おお、改行問題が盛り上がっていたww
勉強になります。
wikiに書くのも躊躇するのでここにさらっと
書いてみますが、
実践CLの最後の「原著者と訳者について」で
Barry MargolinのところのDavid Moonの記載なんですが、
Moon氏が手がけたのは、ITS MacLISPじゃなくて
Multics MacLISPじゃないかなと
思うんですよねー。
多分誰一人として気にしないし、気になっても
誰も指摘しないと思いますけどw
Moon氏はMacLISPをMulticsに移植するプロジェクトの主要開発者で、それで有名だった気がします。

こんばんはー
今日も20時よりCL勉強会を開催させて頂きたいと思います。
お題は、CLの落し穴で、"Limits"より再開です。
http://www.aiai.ed.ac.uk/~jeff/lisp/cl-pitfalls 

こんばんはー
では20時になりましたので、開始させて頂こうかと思います。

今回で10回目
お題は、CLの落し穴で、"Limits"より再開ですー。
http://www.aiai.ed.ac.uk/~jeff/lisp/cl-pitfalls

Limits.

  You should be aware that certain limits exist, even if you think
  your code won't have to take them into account.

色々なものにサイズの上限や制限があるので、それをきちんと把握しようということですね。
これから出てくる上限には、処理系によっては問題にならない位、大きかったりしますが、まあ、ANSI CLとして、そういう上限はありますよということかなと
では、
* The array-total-size-limit may be as small as 1024.
ですが、
array-total-size-limitの保証された下限は1024であることに留意
ということで割と有名なところかも
しれません。
ちなみに
64bit LinuxのSBCLだと
1152921504606846975
でした。

名無しさん 2008-08-02T20:05:24+09:00
64bit いいなぁ

g000001 2008-08-02T20:05:49+09:00
ですねー、1024だとちょっと小さすぎるのと
対照的というか極端というかw
という感じで次なのですが

* Such things as (apply #'append list-of-lists) to flatten a list
    of lists may run afoul of call-arguments-limit, which can be as
    small as 50.  In GCL 1.1 (to pick an implementation I have handy),
    it's 64; so fairly low values can occur.

    Alternatives include:

      (reduce #'append list-of-lists :from-end t)

      (mapcan #'copy-list list-of-lists)

ということで、
(apply #'append list-of-lists)
のようなことをする場合、call-arguments-limitが保証しているのは、50以上、ということに留意する必要がある
ということみたいです。
それで、上の例の場合は、reduce等でしのげるということですね。
これも64bit linux SBCLだと

名無しさん 2008-08-02T20:08:11+09:00
1024, 50 までだならノーチェックで使えるのはイイ！

g000001 2008-08-02T20:08:15+09:00
1152921504606846975
でしたw
そうですね、ポジティブに解釈するならそうですよねw

名無しさん 2008-08-02T20:08:50+09:00
決まってなかったら、ポータブルに書けない。処理系のサポートの値も調べられるようになっている。

g000001 2008-08-02T20:09:18+09:00
とりあえず、ちゃんと決まってるというのがCLのいいところですね。

名無しさん 2008-08-02T20:09:42+09:00
ふと他の言語だとどうなんだっけなーと思ったり。

g000001 2008-08-02T20:10:14+09:00
複数の処理系が存在する言語は
多いんでしょうか？
処理系依存を切り分けるということだと、

名無しさん 2008-08-02T20:11:02+09:00
たとえ一個でも、環境とかによってその手のリソースは上限があるでしょう。

g000001 2008-08-02T20:11:15+09:00
なるほど、なるほど。

名無しさん 2008-08-02T20:12:01+09:00
テストがあるのでROM気味ですが参加させていただきます。

g000001 2008-08-02T20:12:13+09:00
よろしくお願いしますー

名無しさん 2008-08-02T20:12:22+09:00
よろしくー

g000001 2008-08-02T20:12:24+09:00
それで次に進むのですが、

Definitions and declarations.

  * (DEFVAR var init) assigns to the variable only if it does not
    already have a value.  So if you edit a DEFVAR in a file and
    reload the file only to find that the value has not changed,
    this is the reason.  (Cf DEFPARAMETER.)

これは割とCLのひとには有名かなと思うのですが、
有名というか、知らないといけないところですかw
defvarは値を持っていなかった時のみ値が代入されることに注意と
どういう目的があるかといえば、例えばロードするファイルで値が設定されてたとすると、
defvarのような仕組みでないと、それが読み込まれる度に、
そのファイルでの設定で上書きされてしまいます。そのようなことがあると困るので、
存在しているということみたいです。
defparameterは、そういうことはなくて、毎度代入されます。
割と基本的な使い分けですねー。

名無しさん 2008-08-02T20:14:29+09:00
開発中に何度ファイルをロードしても値が古いままでいちいち setf しなきゃいけないムカーとイラつく人が多いのではw

g000001 2008-08-02T20:15:06+09:00
そういうこともありそうですねw
で、次は
次は、DEFCONSTANTのはまりどころ
で

* DEFCONSTANT has several potentially unexpected properties:

     - Once a name has been declared constant, it cannot be used a
       the name of a local variable (lexical or special) or function
       parameter.  Really.  See page 87 of CLtL II.

一度、コンスタント変数として宣言された名前は、ローカル変数の名前として使えないという

(defconstant const-value t)

(let (const-value)
  (list const-value))

こういうのがエラーになっちゃうんですね

;>>>error: The name of the lambda variable CONST-VALUE is already in use to name a constant.

みたいなエラーです。
変数名に+wo
を前後につけたりするのは、
見た目でこういう事故を防ぐ目的なんでしょうね

名無しさん 2008-08-02T20:17:26+09:00
絶対つけてください。

g000001 2008-08-02T20:18:12+09:00
それで、次ですが

     - A DEFCONSTANT cannot be re-evaluated (eg, by reloading the
       file in which it appears) unless the new value is EQL to the
       old one.

       Note that the EQL rule makes it difficult to use anything
       other than numbers, symbols, and characters as constants,
       especially given the "or both" in the next subitem.

名無しさん 2008-08-02T20:18:15+09:00
こないだ、LOLの著者が名前規則なんてどーでもいいじゃん。俺は動かすためにプログラム書いてるんだぜ！的な投稿をして叩かれていたw

g000001 2008-08-02T20:18:23+09:00
そうなんですかw
自由ですねw
昔のプログラムだと、defconstantも*foo*みたいな
名前になってるのがありますねー
SBCLだとはじかれるという…。

名無しさん 2008-08-02T20:19:14+09:00
へぇ～

g000001 2008-08-02T20:19:35+09:00
賛否両論みたいですけども
定数に*foo*って言う風に名前をつけると
怒られるという。

名無しさん 2008-08-02T20:19:59+09:00
ワーニングが出るんですね。はじめてみたw

g000001 2008-08-02T20:20:38+09:00
ですねー。古いプログラムをSBCLに読み込むときに
ちょっと変更しないといけない場合があるかもと

名無しさん 2008-08-02T20:20:58+09:00
この警告は愉快ですね。「へんな名前つけるなよ。*foo* つったらスペシャル変数だろ！」とか文句いうコンパイラとはｗ

g000001 2008-08-02T20:21:31+09:00
ですね、それで賛否両論だったようなw
あ、それで上のお題ですが、
defconstantの再読み込みで

(progn
  (defconstant +const-value+ t)
  (defconstant +const-value+ t))
;>>> 大丈夫

値をeqlで判定するので、
eqlで判定できるものは良いんですが、

(progn 
  (defconstant +const-value-2+ "foo")
  (defconstant +const-value-2+ "foo"))
;>>> 駄目 The constant +CONST-VALUE-2+ is being redefined

eqlで判定できないものだと
再定義になってひっかかるという
落とし穴です。

名無しさん 2008-08-02T20:24:04+09:00
コンパイラが定数展開しちゃってるかもしれないから、後から変更されたらどうしようもないんで未定義って事ですよね。

g000001 2008-08-02T20:24:32+09:00
defconstantは色々ありますねー。

名無しさん 2008-08-02T20:24:55+09:00
大抵の処理系では警告でる、なのかな。あとはその定数つかってるところを全部再コンパイルしなきゃいけないとか。

g000001 2008-08-02T20:24:55+09:00
関連した感じなんですが、
ですね、

     - When compiling (DEFCONSTANT name form) in a file, the form
       may be evaluated at compile-time, load-time, or both.  

       (You might think it would be evaluated at compile-time and
       the _value_ used to obtain the object at load-time, but it
       doesn't have to work that way.)

というのが次なんですが、
あ、関連してないやw
defconstantは、compile時にも値が評価される。
ってことなんですが、
上でも出てきたように
定数に展開されることもある、ということになると
コンパイル時に評価されるってのも
当然といえば、当然かもと
defvarとか、defunとか、compile時には評価されないので、必要な場合は、eval-whenで囲む必要があるんですが、defconstantの場合は、compile時に評価もされる
と。
仕組みというか性質を理解しておく必要がありますね。
これでdefconstantはおしまいで、
次ですが、

* Internal DEFUNs define global functions, not local ones.
    Scheme programmers, in particular, may expect otherwise.
    When the outermost form is not a DEFUN (or, presumably, a
    DEFMETHOD or DEFGENERIC), some implementations won't compile
    it (or the function definitions it contains).

内部defunですね
内部defunはグローバル定義になり、局所関数定義にはならない。

名無しさん 2008-08-02T20:29:07+09:00
あるいは、compilation-unit を分離するという手もある -> eval-when

g000001 2008-08-02T20:29:09+09:00
これは、Schemeに馴れた方がCLで書いてしまいそうな例ですねー。
なるほどー。

名無しさん 2008-08-02T20:30:05+09:00
そうなのかな。どうです？ > schemerの人

g000001 2008-08-02T20:30:19+09:00
schemeの方が
いないですねw
というか、今日は5人なので
すくないですw

名無しさん 2008-08-02T20:31:26+09:00
内部関数定義といえば flet, labels くらいでしょうか。

g000001 2008-08-02T20:31:36+09:00
ですねー。
schemeだとdefineは
ローカル定義にもつかえるので
そういう感覚で使ってしまうのも分かりますねー
このあたりはLISP系言語でも色々ですね
Arcとかは、
変数をローカルで宣言しないと
変数というかグローバルになるようなので、
不思議なことになりますw
まあ、仕様が決まってない気もしますが
ちなみに、
動かないこともないですが、外から内部関数に定義したつもりのものが見えてしまう訳ですね

(defun fib (n)
  (defun fib1 (n a1 a2)
    (if (< n 2)
        a1
        (fib1 (1- n) (+ a1 a2) a1)))
  (fib1 n 1 0))

(fib 10) ;=> 55
(fib1 10 1 0) ;=> 55

みたいな。

また、defun、defmethod..etcはトップレベル定義でないと、コンパイルされないこともある?

みたいなことも書いてますが、
これは自分もどこかで聞いたことがある気がするのですが、
HyperSpecでも探し出せませんで
こういう記載はあるんでしょうか？

名無しさん 2008-08-02T20:36:34+09:00
あるかなぁ。

g000001 2008-08-02T20:36:51+09:00
どっかで耳にした記憶はあるんですけど、
どこだったかと
とりあえず、これは宿題フラグということでw
で次なのですが、

* CLtL says that type declarations apply to names rather than to
    particular variables (bindings).  Consequently, they can cross
    lexical scopes.  Eg:

       (let ((x 1))
         (declare (fixnum x))
         (let ((x ...))
           ;; This x must be a fixnum too!
           ...))

    There is some doubt that this is what Common Lisp was meant to do,
    and (so far as I can tell) the ANSI standard disagrees with CLtL;
    but that is what CLtL II says on page 219.  On my reading of the
    standard, the fixnum declaration would apply only to the outer X,
    which is what lexical scope ought to imply.  But given that CLtL
    explicitly says otherwise, it's possible that some implementations
    have been misled.

これは
ちょっと仕様が変更になってる箇所ですね
CLtLでは、型宣言は、値ではなくて名前に付いてたんでしょうか

(let ((x 1))
  (declare (fixnum x))
  (let ((x 0.0))
    (list x)))

みたいな場合に問題になってたみたいです
内側のxもfixnumあつかいになってたと
ANSIでは、変更になって、値に付くようになった模様で

(let ((x ()))
  (declare (list x))
  (values 
   x
   (let ((x 0.0))
     (list x))))
;=> nil,(0.0)
; エラーにはならず。

です。
この落とし穴集はわりと古いので
こういうのが結構ありますね

名無しさん 2008-08-02T20:40:11+09:00
値につくというより内側のスコープに影響するかどうかってことじゃないかなぁ。

g000001 2008-08-02T20:40:26+09:00
おお、そうなんですか
(let ((x 0.0))
でぶつかるってことなんでしょうか
いや、どっちにせよ
いや、質問の表現が変でしたw
内側の境界が違っていた、みたいな
ところなんでしょうか
値に型云々っていう自分の表現は
まずいですね、確かにw
それについては、ANSIもCLtL2も同じでしょうし。

名無しさん 2008-08-02T20:45:35+09:00
うーん、どーゆうことかなぁ。CLtLも読まないとナァ。宿題にしましょう。

g000001 2008-08-02T20:45:53+09:00
では、これも宿題フラグということで
ということで
次なのですが、
なんかこれも微妙なのですが、

  * You often have to declare the result type to get the most
    efficient arithmetic.  Eg, 

       (the fixnum (+ (the fixnum e1) (the fixnum e2)))

     rather than

       (+ (the fixnum e1) (the fixnum e2))

最適化の話というか
最適を狙うなら演算結果の型も指定しなければならない
みたいなところのようです
試してみたんですが、

名無しさん 2008-08-02T20:48:01+09:00
fixnum と fixnum を足すと fixnum の範囲内に収まるとは限らないですからねぇ。

g000001 2008-08-02T20:48:25+09:00
なるほど、なるほど。
そうですよね。
SBCLで試したところでは
結果がfixnumに収まる場合は、
指定すると
逆に遅くなってるみたいで
なんか色々あるんでしょうかと
収まってない場合は試してないですね、そういえば。

(time
 (dotimes (i 100000000000)
   (the fixnum (+ (the fixnum 1)
                  (the fixnum 1)))))

Evaluation took:
  79.484 seconds of real time
  79.180948 seconds of total run time (79.176948 user, 0.004000 system)
  99.62% CPU
  190,425,320,307 processor cycles
  88,752 bytes consed

(time
 (dotimes (i 100000000000)
   (+ (the fixnum 1)
      (the fixnum 1))))

Evaluation took:
  66.452 seconds of real time
  65.600101 seconds of total run time (65.592100 user, 0.008001 system)
  98.72% CPU
  159,204,557,628 processor cycles
  73,632 bytes consed

(time
 (dotimes (i 100000000000)
   (+ 1 1)))

Evaluation took:
  72.182 seconds of real time
  71.256454 seconds of total run time (71.216451 user, 0.040003 system)
  98.72% CPU
  172,931,648,040 processor cycles
  80,608 bytes consed

みたいな簡単なところなんですけども…。
まあ、自分はあまり分かってないので、

名無しさん 2008-08-02T20:51:11+09:00
コンパイルされてないとか？

g000001 2008-08-02T20:51:27+09:00
なるほど！
その辺もちゃんと考慮しないと
いけないんですね。

名無しさん 2008-08-02T20:52:31+09:00
インタプリタから見ると (the fixnum ...) <-- 邪魔だなぁ…　って感じかも。

g000001 2008-08-02T20:53:33+09:00
関数にして計ってみれば
いいんでしょうか

名無しさん 2008-08-02T20:53:55+09:00
あるいはデバッグのコストがあがってるのかもしれません。

g000001 2008-08-02T20:54:06+09:00
なるほど、なるほど。
最適化は色々留意点がありますねー。
最適化フラグを調整してみると
いうことで、

名無しさん 2008-08-02T20:55:50+09:00
LispWorks は CPU の性能を出すために32bit 整数を演算する関数を備えてたり、Corman Lisp みたいに、defasm マクロでアセンブラだったり、処理系毎に面白いところ。

g000001 2008-08-02T20:56:22+09:00
なるほど、なるほど。

名無しさん 2008-08-02T20:56:26+09:00
理由は分からないけど、しばしばアルよ。指定で遅くなる

g000001 2008-08-02T20:57:53+09:00
ちょっとこれも

名無しさん 2008-08-02T20:57:58+09:00
boxing / unboxing が大量発生して逆に足をひっぱるとかかなぁ…

g000001 2008-08-02T20:58:00+09:00
いろいろ試してみたいと思いますw
そのうち
最適化についての
勉強会とかもやってみたいですねー

(defun foo ()
  (declare (optimize (speed 3) (safety 0) (debug 0)))
  (dotimes (i 10000000000)
    (+ (the fixnum 1)
       (the fixnum 1))))


(defun foo+ ()
  (declare (optimize (speed 3) (safety 0) (debug 0)))
  (dotimes (i 10000000000)
    (the fixnum (+ (the fixnum 1)
		   (the fixnum 1)))))


(time (foo))
(time (foo+))

名無しさん 2008-08-02T20:58:47+09:00
たとえば、 :type (or boolean fixnum)より何も指定しない方が速いとか＜defstruct

g000001 2008-08-02T20:58:50+09:00
とかにしたら
結果も指定した方が速くなりました
SBCLでも。
用研究という
要研究という感じで
次に進んでみたいと思いますが、

  * When calling a function on more than two arguments, remember that
    there can be intermediate results.  For instance, when adding three
    fixnums, it's not enough to say only that the _final_ result
    is a fixnum.  You'll have to break the computation down into
    2-argument calls.

これが良くわからなかったのですが、
3つ以上の引数を取った場合の結果の型ということで、

(typep (apply #'+ (list (the fixnum 3)
                        (the fixnum 3)
                        (the fixnum 3)))
       'fixnum)

;=> nil
な可能性もあるということでしょうか?
あ、そうか、
さっきの話かw
wじゃなくて！w
いや、3つ以上の引数の話だから違うか(^^;
これも私の理解不足のために記述が探し出せませんで

名無しさん 2008-08-02T21:03:22+09:00

(+ v1 v2 v3) => (+ v1 (+ v2 v3))

だと、結果と v1, v2, v3 を型指定するだけじゃ不足で、v2, v3 の結果も指定しないとイカン。限界の性能を出すなら二引数呼び出しに分割せよ！みたいな？

g000001 2008-08-02T21:04:51+09:00
なるほどー。
究極っぽいですよね。
これも若干宿題フラグな感じにしておくと
いうことで
次に進みますが

  * Declaring the iteration variable of a DOTIMES to have type FIXNUM
    does not guarantee that fixnum arithmetic will be used.  That is,
    implementations that use fixnum-specific arithmetic in the presence
    of appropriate declarations may not think _this_ declaration is
    sufficient.  It may help to declare that the limit is also a
    fixnum, or you may have to write out the loop as a DO and add
    appropriate declarations for each operation involved.  (This calls
    for a macro.)

これも微妙なんですが、
dotimesは変数にfixnum
で宣言がついてることがほとんどみたいなんですが、
それは、保証はされてないので、
自前でつけることも必要かもよ、くらいのところなんでしょうか。
とりあえず、fixnumがついたりunsigned-byteがついたりは
してくれる処理系が多いみたいですねー。
で、これは良いとして
次ですが、
型宣言の目的として

  * Remember that implementations often use type declarations for
    optimization rather than for checking.  Adding type declarations
    can _reduce_ the number of checks.  Different implementations do
    different things, and their behavior may be affected by OPTIMIZE
    declarations.

最適化がメインで、型チェックは
二の次ということみたいですね

名無しさん 2008-08-02T21:10:33+09:00
先ほどの話を読むとreduceを使うと速いって話は利にかなってるってことみたいだねぇ。

g000001 2008-08-02T21:10:35+09:00
自分は、theとかdeclareで型宣言するのが
あれ、reduceを使うと速いって最近も話どっかで読んだような
自分は、theとかdeclareで型宣言するのが
コンパイラが警告を出してくれるので
好きだったんですが、
そういう使い方は
メインじゃないみたいですね(^^;
check-typeとか使うんでしょうか。

名無しさん 2008-08-02T21:12:57+09:00
check-type をつかってください
あ

g000001 2008-08-02T21:13:08+09:00
theとか多値のチェックもしてくれるので、

名無しさん 2008-08-02T21:13:10+09:00
かぶったw

g000001 2008-08-02T21:13:14+09:00
好きだったんですけども
w

名無しさん 2008-08-02T21:13:53+09:00
それか Mark Traver の Qi を応援するw

g000001 2008-08-02T21:14:01+09:00
Qiですかw
あれもCLで3000行位でしたよね
とりあえず、定番としては、check-typeを使うと
いうところなのでしょうか。
とりあえず、型宣言の目的としては
こんな感じで、

  * PROCLAIM vs DECLAIM: compilers are not required to process top-level
    calls to PROCLAIM at compile time [CLtL p 223].  This is supposedly a
    "clarification", rather than a change in the language.  To ensure an
    effect at compile time, use DECLAIM or put EVAL-WHEN around PROCLAIM.
    You'll probably want (EVAL-WHEN (COMPILE LOAD EVAL) (PROCLAIM ...)),
    or whatever the new-style equivalent is [see CLtL pages 88-94].

が次なのですが、
proclaimとdeclaimの違いについて
proclaimはコンパイル時に評価して欲しい場合は、eval-whenでオプションを指定して囲う必要あり。
なので、上のような状況のばあい

declaim推奨と

それで、次なのですが、

名無しさん 2008-08-02T21:18:08+09:00
proclaim って関数ですもねぇ。declaim はマクロ。

g000001 2008-08-02T21:18:09+09:00
これがちょっと難解というか
ですね。
私には、次が難解というか語学力がないので
読解できなかったのですが、

  * Compile-time side-effects of defining macros (DEFVAR, DEFUN, DECLAIM,
    etc.) may or may not be visible in the interpreter or in later calls
    to COMPILE or COMPILE-FILE [CLtL p 689].  That's one reason while
    files are often loaded right after being compiled, when a sequence
    of files is being compiled using COMPILE-FILE.  But that practice
    has its own dangers since it might, for instance, (re)define
    functions.  That's one reason why you're sometimes advised to put
    macros and some other kinds of definitions in separate files.

あれ、コピペ失敗？

  * Compile-time side-effects of defining macros (DEFVAR, DEFUN, DECLAIM,
    etc.) may or may not be visible in the interpreter or in later calls
    to COMPILE or COMPILE-FILE [CLtL p 689].  That's one reason while
    files are often loaded right after being compiled, when a sequence
    of files is being compiled using COMPILE-FILE.  But that practice
    has its own dangers since it might, for instance, (re)define
    functions.  That's one reason why you're sometimes advised to put
    macros and some other kinds of definitions in separate files.

これでどうだ
おkみたいですね

コンパイル時の定義用のマクロの副作用は、インタープリタや後のcompileやcompile-file
呼び出しから見えるとは限らないってことでしょうか？

マクロと他の種類の定義を別々のファイルに書くように勧められる理由、らしきことも書いてあるのですが、
うすぼんやりとしか把握できませんでしたw

名無しさん 2008-08-02T21:23:37+09:00
コンパイル時に、DEFVAR, DEFUN, DECLAIM 等のマクロ定義の副作用を、インタプリタや後続の COMPILE, COMPILE-FILE で使おうとした場合に云々？

g000001 2008-08-02T21:24:23+09:00
なるほどー。
ありそうな、
なさそうな、どういう状況で必要になるのか、
なかなか、ぱっと想像できない(^^;
ちょっと、保留ということでw
次からも割と
理解が難しかったのですが、
inline宣言についてで

     - You should place an INLINE proclamation _before_ the definition
       of a function you want to have compiled inline.

INLINEにしたい関数の前に宣言する必要がある。

まあ、これは、そういうことなのかなと
思います。
で次ですが、

     - If you want a function to be inline only locally, when there's
       an INLINE declaration, but not everywhere, you still need an
       INLINE proclamation.  CLtL p 230 recommends:

          (declaim (inline gnards))
          (defun gnards ...)
          (declaim (notinline gnards))

部分的にインライン宣言したい場合は
          (declaim (inline gnards))
          (defun gnards ...)
          (declaim (notinline gnards))
みたいにする必要がある。

ってことなんでしょうか。
部分的にインラインにしたい場合に遭遇したことが
ないのですが、こういうケースもあると
で、次が分からないのですが、

     - You need a NOTINLINE declaration to make sure SETF of SYMBOL-
       FUNCTION will affect calls between functions defined in the
       same file.

これはどういう状況なのでしょう。

名無しさん 2008-08-02T21:29:28+09:00
再帰が関連する時かも。部分インライン

g000001 2008-08-02T21:29:51+09:00
末尾再帰を最適化する可能性があるんでしたよね＞inline
で、上の例ですが、
(declaim (notinline foo))
と

(defun foo ()
  'foo)

(setf (symbol-function 'bar) #'foo)
の3つを組み合わせるとして、
どういう状況なんでしょう？
という。
ところで時間になってしまいましたが…。
これも宿題フラグということでw
この辺りは自分のような初心者にはちょっと
手がでないですねー。

名無しさん 2008-08-02T21:34:21+09:00
check-type なんてしらなかった^^;
ありがと♪

g000001 2008-08-02T21:35:02+09:00
check-typeはそのものずばりって
感じではあるんですが、

名無しさん 2008-08-02T21:35:13+09:00
SETF of SYMBOL-FUNCTION と　INLINE ？なんかインライン展開されたらまずいのかなぁ。

g000001 2008-08-02T21:35:43+09:00
自分はdeclareで宣言できたらいいのになーとw
あ、そうだ、ちょうど切りがいいので、
inlineの最後をやってしまいますが、

     - Implementations aren't required to compile anything inline
       no matter what declarations you use.
INLINE宣言は処理系によっては無視してもよい。
これは残念。

ですね。

名無しさん 2008-08-02T21:37:15+09:00
で、コンパイラマクロを使って自分でやれ、と処理系のマニュアルに書いてあったりするw

g000001 2008-08-02T21:37:50+09:00
そういえば、コンパイラマクロを使って自前でやる方法が
http://www.pentaside.org/paper/compilermacro-lemmens/compiler-macros-for-publication.txt
に沢山のってますね

名無しさん 2008-08-02T21:38:28+09:00
自前で＾＾；かんべんしてよぉ〜＞＜

g000001 2008-08-02T21:38:46+09:00
そういう流れもあってのことなんですかね。
結構自前で定義してたりするみたいですw

名無しさん 2008-08-02T21:39:53+09:00
CL-PPCRE の定数パターンの自動コンパイルみたいにオイシイ事ができたりするから
引数が全部定数なんて！コンパイル時に計算しろといってるんですね！ :-)
なるほどなぁ。

g000001 2008-08-02T21:41:41+09:00
この辺りのチューニングは好きな人はハマりそうですねw
http://www.pentaside.org/paper/compilermacro-lemmens/compiler-macros-for-publication.txt
mo

名無しさん 2008-08-02T21:42:00+09:00
Cでsin/cosをあらかじめ計算してテーブルにいれとくという技法にはルックアップテーブルという名前がついてますけどね

g000001 2008-08-02T21:42:16+09:00
もこの勉強会でやってみようかと思いましたが、
なんかマニアック過ぎる気がしたので、
見送っていますw

名無しさん 2008-08-02T21:42:51+09:00
LISPの世界だと特になんも名前がないという。単に事前に計算しとくだけだから。Cでこの技法を知ったときは感動したんだけどなぁ…

g000001 2008-08-02T21:43:04+09:00
なるほど、なるほど。
お、higeponさんだ

higepon 2008-08-02T21:43:48+09:00
こんばんはROMさせていただきます

g000001 2008-08-02T21:43:55+09:00
チューニングの話とか
どうですか？w

名無しさん 2008-08-02T21:43:56+09:00
たしかに、あらかじめ計算させてテーブルにしておくことやりますよね＜C
printf で配列っぽく書式整形して出して俺Sugeee感を感じていたのに。今や #.(make-sin-table) とか…いまいち凄い感がでない…。

g000001 2008-08-02T21:45:04+09:00
#.とかもありますよねー
この辺りの使い分けも
わかりやすいドキュメントがあると
良いなあとたまに思います:-)
今日は人が少なかったですねー。
最初2人で
内容が難しいのを知ってたので、
やばい、遭難する！と思ってましたw
とりあえず、今回も皆様に助けていただきまして
乗りきれました:)

名無しさん 2008-08-02T21:50:17+09:00
勉強になりました。あんまり使わないところだしw

g000001 2008-08-02T21:50:59+09:00
今回の宿題フラグは

http://www.lingr.com/room/gKpArxPn9wi/archives/2008/08/02#msg-43973577
http://www.lingr.com/room/gKpArxPn9wi/archives/2008/08/02#msg-43973812
http://www.lingr.com/room/gKpArxPn9wi/archives/2008/08/02#msg-43976491
http://www.lingr.com/room/gKpArxPn9wi/archives/2008/08/02#msg-43977284

no
の4つですが、

名無しさん 2008-08-02T21:51:45+09:00
defconstantすれば、ほんと困ることがある。^^; delete-packageから作り直しを何度したことか　汗

g000001 2008-08-02T21:51:45+09:00
難しいですね。もとに状況を例示する

名無しさん 2008-08-02T21:51:53+09:00
処理系製作者に感謝しないとなー。コンパイル速度とかいろいろトレードオフがって大変そう。

g000001 2008-08-02T21:51:56+09:00
コードがついてれば一発な気もするんですが。

名無しさん 2008-08-02T21:52:08+09:00
いくつか例がよくわかんないやつが…
例が思いつかないというか。
そうですね。わかりにくいもんな＜コードなし。

g000001 2008-08-02T21:52:48+09:00
CLtLとかHyperSpecとかその点コードがついてて
素晴らしいですよね。

名無しさん 2008-08-02T21:53:54+09:00
それでも分かりにくい物がある＞＜

g000001 2008-08-02T21:55:16+09:00
そういう仕様になった経緯まであると
最高ですよね。

名無しさん 2008-08-02T21:55:32+09:00
最適化関連で最近ハマったのが、最適化宣言をファイルの先頭につけた後に、バグが見つかって直してるときに、最適化宣言を外しても最適化が自動的にかかったこと。非最適化宣言しなきゃいけないのかなぁ。何て後から思ってる。

g000001 2008-08-02T21:56:38+09:00
なるほど、slimeとかの所為なんですかね、

名無しさん 2008-08-02T21:56:52+09:00
早すぎる最適化はいけないというのは、よく聞くけど実感したくらい。^^;
よくわからないです。なんでやろね。

g000001 2008-08-02T21:57:25+09:00
イメージの中に元の

名無しさん 2008-08-02T21:57:26+09:00
proclaim でグローバルに最適化を宣言してしまったとかでは？

g000001 2008-08-02T21:57:32+09:00
コンパイルされた関数が残っててとか？

名無しさん 2008-08-02T21:58:17+09:00
グローバルでしたね。パッケージないとはいえファイルの先頭に近いところで宣言してたので。
ファイルコンパイラ(file compiler) 向けのdeclaimなら安心！
proclaim で debug 0, safety 0 とかすると、エラー時に悲しくなるので…。

g000001 2008-08-02T21:59:44+09:00
なるほど、なるほど。
自分は、よっぽどじゃないと最適化宣言しないので、
勉強になります:)

名無しさん 2008-08-02T22:00:12+09:00
覚えておこう。。
proclaim => 全体に利く、 declaim => ファイルに利く、declare => フォーム単位

g000001 2008-08-02T22:01:33+09:00
なるほどー。

名無しさん 2008-08-02T22:03:51+09:00
そういえば dynamic-extent は PCL にも登場しなかったなぁ…。残念。

g000001 2008-08-02T22:05:06+09:00
ANSI CLには登場してますね
PCL読んでからANSI CL読むと
ANSI CLは入門向けの本にはとても思えないw
PCLとPG氏のANSI CLを合わせて読むと
良さそうですねー。

名無しさん 2008-08-02T22:07:19+09:00
ほんとだでてきてる。すごいアッサリだけど…

g000001 2008-08-02T22:07:33+09:00
13章に使い方が
自分は、dynamic-extentは
この範囲でしか理解できないんですけど、
大抵は、この13章の例で間に合うんでしょうか？

名無しさん 2008-08-02T22:09:11+09:00
理想的には関数内でしかつかわないからGCなしですぐ消えて欲しい！なんだけど…
プログラマが dynamic-extent で宣言してスタック上にリストとか作っておきながら、なぜか関数が生成するクロージャから参照されていたり…とか駄目なケースが…
GCなしで消えてくれるとうれしいなぁ。

コンパイラというより人間の弱さが露呈する瞬間。
なんだっけ、「プログラマがdynamic-extentといったら絶対dynamic-extent俺を信じろ！」みたいなオプションを見た記憶がw

CMUCLの *trust-dynamic-extent-declarations* か。こんなものがあるくらいだからなー

g000001 2008-08-02T22:13:42+09:00
見極めがなかなか

名無しさん 2008-08-02T22:13:49+09:00
ダメなケースが想像できないっす。dynamic-extentなんて使ったことがないからかも

g000001 2008-08-02T22:13:49+09:00
むずかしそうですねー。

名無しさん 2008-08-02T22:14:26+09:00
コンパイル中に超能力で最適化をかけたいみたいなそんなオプションか?笑
Cでいう、スタック上に確保した領域へのポインタを返しちゃう系の失敗が駄目なケース
なるほど。
関数が終わったら消えるんだぞ！といいながら、そのオブジェクトを返してしまうという。

g000001 2008-08-02T22:16:12+09:00
ちなみに、ANSI CLでは、

(defun our-adjoin (obj lst &rest args)
  (if (apply #'member obj lst args)
      lst
      (cons obj lst)))

;=>
(defun our-adjoin (obj lst &rest args)
  (declare (dynamic-extent args))
  (if (apply #'member obj lst args)
      lst
      (cons obj lst)))

でさらっと説明してるだけですね。
自分がGoogle code searchで引っかかったコードを眺めても大体こんな感じのばっかりでした。

名無しさん 2008-08-02T22:19:15+09:00
ここの args は結果が必要なだけですからね。dynamic-extent にぴったり！ベクタとかも宣言できますしね。
Cから来た人には int foo () { int buf[10]; ... } みたいなのは LISP で dynamic-extent 宣言された変数と同じようなもんです。GC 不要ですよ！というとわかりやすいのかな。
(let ((buf (make-array 10 :element-type 'fixnum))) (declare (dynamic-extent buf)) ...

g000001 2008-08-02T22:24:06+09:00
やっぱりこういうのも
後で探して宣言をつけて行くという感じなのでしょうか。

名無しさん 2008-08-02T22:26:01+09:00
まぁ、そうでしょうね。頑張ろう！と思ったときに使うもんであって、いきなりこんな宣言を書きながら作ってく人はあんまりいないと思う。

g000001 2008-08-02T22:26:45+09:00
なるほど、なるほど。

名無しさん 2008-08-02T22:27:13+09:00
この宣言をしてしまうと、そのオブジェクトは関数内の寿命(extent)しかもてないはかない存在になってしまいますからね。

g000001 2008-08-02T22:30:16+09:00
最適化の方法も沢山あって
深いですねー。
オプションなので、徐々に覚えていこうと
言う感じですが、初心者の私としてはw

名無しさん 2008-08-02T22:32:49+09:00
必要なことは必要になってからでいいんじゃないでしょうかw そもそも処理系がサポートしてない場合もありますからね。
重い計算をさせないと必要性はあまり出てこないもんな。

g000001 2008-08-02T22:33:43+09:00
自分が眺めた限りでは、
重い数値計算と、大量の文字列処理
のコード位でした:)

名無しさん 2008-08-02T22:34:10+09:00
最適化がない、というより optimize の項目指定のうち compilation-speed を重視しているんですと主張しておけばポジティブなイメージ

g000001 2008-08-02T22:35:21+09:00
なるほどー。
最適化の項目にも色々あって
メモリ領域とかコンパイルのスピードとか

名無しさん 2008-08-02T22:36:04+09:00
何でもかんでも最適化に気合を入れるのは時間の無駄だろうし、必要な所だけで十分ですよね。
一度無駄ほど、やってみれば実感できる。^^;

g000001 2008-08-02T22:37:38+09:00
ちょっと話が変わってしまうのですが、
「マクロとクロージャとデータ型の実行時指定とによってLispはオブジェクト指向プログラミングを超える」という
PG氏の煽りがANSI CLの冒頭にあるのですが、
マクロとクロージャは
まあ良いとして、
データ型の実行時指定が挙げられているのは、
変数に型があるんじゃなくて値に型があるのが
柔軟だってことなんでしょうか？
たとえば最適化等に於いて
これWassrでも書いちゃったんですがw

名無しさん 2008-08-02T22:41:26+09:00
何ページですか？

g000001 2008-08-02T22:41:30+09:00
run-time typingがマクロとクロージャに続くのが良くわからないという
2ページ目ですね。
あと、ここでいうruntime typingの補足が、

名無しさん 2008-08-02T22:42:35+09:00
これは性能じゃなくて柔軟性の話じゃないかなー

g000001 2008-08-02T22:42:42+09:00
13章のp194の脚注にありますね
p194の脚注を読むと
ですね、柔軟性を強調しているのかなとも感じます
ここでいう「オブジェクト指向プログラミング」ってのも
曖昧な気もしますが:)

名無しさん 2008-08-02T22:49:35+09:00
おかしいな、ANSI CL 一通り読んだけどそこまで過激な思想にはならなかったようなw

g000001 2008-08-02T22:52:19+09:00
この3つの条件を含むものってCLしかないんでしょうか。
マクロとクロージャはSchemeでもおkだとして
型はどうなのか、ちょっと詳しくないので、なんとも…。

名無しさん 2008-08-02T22:56:18+09:00
最適化宣言やコンパイラが規格に入ってるのは珍しいような気がするけど、探せば他にもありそう？

g000001 2008-08-02T22:57:05+09:00
Smalltalkとかは、マクロはないでしょうけど
他の2つはありそうですよね。

名無しさん 2008-08-02T22:57:42+09:00
dylan とか？

g000001 2008-08-02T22:58:17+09:00
あ、
そうかもしれませんね。
型の扱いも
CLみたいだった気が…。

名無しさん 2008-08-02T23:01:54+09:00

今後は型がないと駄目なのかなぁ…。Qi に期待しよう。
(datatype odd-number
    if (number? X)
    if (odd? X)

______
X : odd-number;)

g000001 2008-08-02T23:02:48+09:00
Qiもこの夏に新しくなるらしいですね

名無しさん 2008-08-02T23:03:22+09:00
おぉ、何て使いやすい型定義なんだ！これぞ 21 世紀の Lisp！…と自分にいいきかせてますがまだ慣れない…

g000001 2008-08-02T23:04:01+09:00
自分は型の定義の前に挫折しましたw
バックトラックの記法とかも

名無しさん 2008-08-02T23:04:28+09:00
Qiってロシアの人だっけ?
作ってるのは。。。

g000001 2008-08-02T23:04:41+09:00
イギリスだったでしょうか？

名無しさん 2008-08-02T23:04:48+09:00
イギリスかぁ

g000001 2008-08-02T23:06:41+09:00
CLの関数がそのまま呼べたりとか
面白いような、邪道なようなw
しらないでQiの中で1+とか使ってましたw

名無しさん 2008-08-02T23:07:49+09:00
CLOSみたいなもの？＜言語内言語

g000001 2008-08-02T23:07:54+09:00
全部大文字にするとCLの関数を指定したことになったのかな？
1+だとその網をくぐってしまってたんですね。

名無しさん 2008-08-02T23:08:59+09:00
Qi のコード --> [Qi のコンパイラ] --> 最適化されたCLコード --> 処理系

なんという正しいやり方！
…でも、これでターゲットがCとかネイティブコード直接吐くとかならもうちょっと話題になったんでしょうね。現状では Lisper　以外には…。

g000001 2008-08-02T23:12:08+09:00
どうにもマイナーですよねw
Prologとか好きな人も好きだったりしないんでしょうか＞Qi

名無しさん 2008-08-02T23:15:22+09:00
そんなやつなんかQi。。。しばらく後になってみてみるわ。


g000001 2008-08-02T23:15:53+09:00
yasさんは結構好きなんじゃないかなと
思うんですよね。

名無しさん 2008-08-02T23:16:02+09:00
いま、いろんな言語を食い散らかしてるからQiをやる意欲がわかない笑

g000001 2008-08-02T23:16:21+09:00
いや、そんな今だからこそQiをw

名無しさん 2008-08-02T23:16:23+09:00
あれ？画像を張ってしまった。http://www.lambdassociates.org/studies/study01.htm
w

g000001 2008-08-02T23:17:13+09:00
Qiのブログもあったと思うんですが、

名無しさん 2008-08-02T23:17:17+09:00
８月ごろにメジャーバージョンアップするのでそっから取り組んで紹介してくださいｗ　ちょっと周回送れてついていきますんでｗ
ハスケルやMLは目じゃないと言う勢いがあるのか。（胡蝶しすぎの意訳　わら）

g000001 2008-08-02T23:17:20+09:00
内容が難しすぎて挫折しましたw
文章からの勢いは非常に感じますよねw

名無しさん 2008-08-02T23:19:28+09:00
一時期 c.l.l で Ocaml の人が「Lispなんて遅いぜ！Ocamlなら型安全でしかも行数も短い！」と荒らして（？）いた頃
紹介かぁ。汗
あ、投稿が消えた…
あら

g000001 2008-08-02T23:23:02+09:00
最近Lingrが調子悪い気がしますねー
前より、良く切断される気が。

名無しさん 2008-08-02T23:27:04+09:00
Manifestoは結構いい感じ。common lispの後をつぎながらML系を飲み込んでしまうぞって感じ。
ホラ、使いたくなってくる～
Phese IIIまでいけばもっと使う人が増えそう。Graphics,とwebプログラミングを含むつもりみたいやし。
確かに魔力があるな。笑

g000001 2008-08-02T23:30:06+09:00
自分は、Qiの記法も結構好きですねー。
綺麗にまとまってる気が

名無しさん 2008-08-02T23:32:08+09:00
次でてくるバージョンでwebプログラミングとtck/tkのプログラミングが関わってくるのかな?

あったあった、静的型の言語に真っ向から立ち向かう Qi の雄姿
http://groups.google.com/group/comp.lang.lisp/browse_thread/thread/62f4763457da186f/810d9c0b7e95526b

冷静に考えると俺言語ってのはアリなんか？と思わんでもないw
作者本人からかいてるのね。

g000001 2008-08-02T23:35:15+09:00
ですね、MLでも
作者さんがほとんどの質問に
回答してくれるような感じですw
という感じで、Qi談義も佳境なのですが、
私は、今日は早起きだったので落ちます〜。来週はもっと盛り上がるように
策を考えなくてはw

名無しさん 2008-08-02T23:37:18+09:00
おやすみぃ。
おやすみなさい

g000001 2008-08-02T23:38:19+09:00
おやすみなさいー。

名無しさん 2008-08-02T23:52:24+09:00
宿題も難しいなぁ。具体的な状況が想像できないとなー
g000001さん頑張ってるよなぁ。とおもう。
継続してもらって本当にありがたいっす。いろいろ調べるために普段読まないHyperSpecエントリを読むとあたらしい発見が
どんな発見だろう。
oyasumi :-)
おやすみなさい。

g000001 2008-08-03T09:48:52+09:00
どうしたんですか、急にw　＞頑張ってるよなぁ
とはいえ、ありがとうございます！
とりあえず、続けられるだけ続けたいとは
思っています(^^

1d3eqxV0wHq 2008-08-03T10:07:49+09:00

始めまして

Lisp が専門じゃないんですけど, optimize に関して少し...
cmucl とか SBCL のみたく, low-tag 使う奴って
fixnum で type 指定は良くないです
(+ fixnum fixnum) -> bignum とかのケースが存在するので
オーバーフロー検出して bignum に変換するコードが吐き出されてしまいます
(integer -nnnnnn +mmmmm) とかで, 必要なレンジを指定してやった方が
高速なコードを吐き出すはずです.

g000001 2008-08-03T10:14:15+09:00
こんにちはー
専門ではないとおっしゃりつつ
凄いですねw
なるほどー。ちょっと試してみたいですー

1d3eqxV0wHq 2008-08-03T10:41:53+09:00

オレオレ言語の処理系作るのが趣味何ですけど, C で作るのも飽きたんで, Lisp で何かできないかと...

g000001 2008-08-03T11:44:23+09:00
なるほどー。オレオレ言語ですかー。
昨晩話題のQiとかもCLの上で実装されてて
面白いですねー。
この部屋のURLなんですが、
いい加減gKpArxPn9wiという謎のURLでなくて
common-lisp-jpという名前に変更してみました
前のURLでアクセスできなくなるのかと思ったのですが、できるようなので、
変更した、と言う感じです。
.
テスト
2chのCLスレwikiにライブラリ集見たいなページを
つくってみました。
http://wiki.fdiary.net/lisp/?common-lisp-library
s/見たいな/みたいな/
何かあったら追加してみてくださいー。

(provide 'news)
ecl 0.9Lリリース

ECLの新バージョン 9.9Lがリリースされました。
アナウンス:
http://sourceforge.net/forum/forum.php?forum_id=853748
プロジェクトページ:
http://ecls.sourceforge.net/

あれ、9.9とか書いてる。0.9ですね(^^;

名無しさん 2008-08-06T20:56:04+09:00
lだと1と区別がつきづらい...
なんでkが抜けたんだろ? 謎

g000001 2008-08-06T22:36:00+09:00
そういえば、そうですね、なんでK
を飛ばしたんでしょう。
2月位だったかの発表のときには、0.9kだったので、
内部的には存在してたようですが、
それのバグ修正版とかでしょうか？(^^;

名無しさん 2008-08-07T06:20:28+09:00
i don't speak japanese but i like Common Lisp .. just taking a look .. .. :)
..bye bye all.. :)
Inostdal-san:
We have the meeting every Saturday night in Japan. :-)

g000001 2008-08-09T18:49:48+09:00
今日もCL勉強会開催させて頂きます! お暇ならいかがでしょうか! 20:00〜開始
今回は、cl-cookbookより時刻編です。
http://cl-cookbook.sourceforge.net/index.html
http://cl-cookbook.sourceforge.net/dates_and_times.html

名無しさん 2008-08-09T19:25:49+09:00
こんばんは。

g000001 2008-08-09T19:27:58+09:00
こんばんはー。
今日はオリンピックとお盆休みの関係で参加者はすくないですかねー(^^;

名無しさん 2008-08-09T19:45:37+09:00
少なそうですねぇー。

g000001 2008-08-09T19:46:32+09:00
まあ、内容もあまりぱっとしない内容なんですがw

haiju 2008-08-09T19:47:36+09:00
こんばんわ。予習が間に合っていないのですが、よろしくお願いします。

g000001 2008-08-09T19:49:46+09:00
よろしくお願いしますー。
こんばんはー
では20時になりましたので、開始しますー

今回で11回目
お題は、cl-cookbookより、日時と時刻篇です。
http://cl-cookbook.sourceforge.net/dates_and_times.html
予定より早めに終ってしまったら
CLの落し穴:
http://www.aiai.ed.ac.uk/~jeff/lisp/cl-pitfalls
すいません、落ちてしまいましたw
うえの
のパッケージ篇からの続きをしようかと思います。
では時刻編の開始です
基本的に上からざーっと眺めて行くだけになります
大きく3つの構成になっていまして

;    * Universal Time
;    * Internal Time
;    * Computing the day of the week 

という感じです。
では、最初にuniversal time
から
コンピュータ内部での経過時間と、コンピュータ外の実世界の時間を取得する方法があるのですが、
ut(universal time)は
実時間の方の時間を取得します
それで、
ユニバーサルタイムは、1900年の1月1日 0:00からの経過した秒数で表現されます。
この辺りはUNIX文化と若干異なるところですねー
それで
現在のユニバーサルタイムを取得するには、
* (get-universal-time)
とすると
3220993326
みたいに秒が帰ってくると

名無しさん 2008-08-09T20:06:18+09:00
こんばんわ！こんばんわ

g000001 2008-08-09T20:06:30+09:00
こんばんは、こんばんは、こんばんはー
この秒のまとまりだと
読み難いので、decode-universal-timeでカレンダー的に加工する関数があります。
* (decode-universal-time 3220993326)
で

6
22
19
25
1
2002
4
NIL
5

のように
多値で値が返ってきます
この関数は、9つの値を返し、
秒、分、時、日、月、年、曜日、夏時間調整、タイムゾーン
となっています
曜日は、0..6の範囲で数値として表現され、0が月曜日です。
0が月曜ってのに自分は良くハマりますw
現在の時刻をut形式で取得するには、
あ、違う、
この多値の形式で取得するには、
get-decoded-timeを使用します。
* (get-decoded-time)
という感じですね
これは、
* (decode-universal-time (get-universal-time))
と同じです。
で、ここで典型的な
プログラムの例です

* (defconstant *day-names*
    '("Monday" "Tuesday" "Wednesday"
      "Thursday" "Friday" "Saturday"
      "Sunday"))

* (multiple-value-bind
        (second minute hour date month year day-of-week dst-p tz)
        (get-decoded-time)
    (format t "It is now ~2,'0d:~2,'0d:~2,'0d of ~a, ~d/~2,'0d/~d (GMT~@d)"
              hour
              minute
              second
              (nth day-of-week *day-names*)
              month
              date
              year
              (- tz)))

で
It is now 16:56:21 of Saturday, 8/09/2008 (GMT+9)NIL
みたいに表示されると
定数で曜日の名前のリストを作成して
変換するってのは、定石っぽいですねー。
それで、進みますと
逆に日付の形式から
utが欲しい場合には、
encode-universal-timeを使用することになります
* (encode-universal-time 6 22 19 25 1 2002)
みたいな
これで、
3220993326
のような数値が得られます。
ここで注意点として
タイムゾーンが指定されないと自動的に夏時間調整がかかる。
みたいなことが書いてあって
指定すると適宜調整してくれるようです
日本で使ってる場合にはあまり
問題にならない気もしますが、
海外にサーバを置く場合等問題になることもあるのかもしれません。
それでUT形式の利点ですが、
ユニバーサルタイム形式は、単純な数値なので、カレンダー形式で演算するより簡単でしかも安全。
ということです。
ここの例では

* (setq *moon* (encode-universal-time 0 17 16 20 7 1969 4))
2194805820

として

* (setq *takeoff* (encode-universal-time 0 38 11 28 1 1986 5))
2716303080

として

* (- *takeoff* *moon*)
521497260
* (- *takeoff* *moon*)
521497260

みたいにして
時刻の差分を取得する例を紹介しています
大体、5千2百万秒、6035日と、20時間21分。
で、UTの紹介の最後として課題が提示されていますが、
日付の表示形式として
色々な形式がありますが、
そのような人間が読むための形式を
どう言う風にUTに変換するか？ということが
問題になるだろうと、
いうことが書いてあります。
自分が調べた限りでは、
net-telent-dateというライブラリにそういう感じのものがありました

(date:parse-time "Mon, 04 Jun 2001 17:16:05")
;=> 3200631365

とか

(date:parse-time "Mon, 04 Jun 2001")
;=> 3200569200

(date:parse-time "1999/12/31")
;=> 3155554800

等、賢いようです。
ということで、
ユニバーサルタイムについては
終わりなのですが、
何かご質問ありますでしょうか？
多分時間には余裕がありますので、
良かったらご質問でもw
まあ、あまり問題になるようなところも
ないかもしれないですね(^^
ということで、次のセクションの
インターナルタイムに移りたいと思います
インターナルタイムは、どこか規定の時間から開始されているのではなくて
Common Lispの処理系が起動されたときが基点となります
通常、インターナルタイムは、1秒より細かい時間単位となっていることが多いので、
内部的な時間の計測に
使われることが多いようです
それで、計測の粒度ですが
* internal-time-units-per-second
という定数で確認できます
SBCLだと1000ですが
CLISPだと1000000to
と
処理系によって粒度はまちまちです
それで、この内部時間には
2種類関数があるのですが、
CPUが働いた時間を取得する
(get-internal-run-time)
と
処理系が起動してからの時間を取得する
(get-internal-real-time)
があります

;; 経過時間
(get-internal-real-time)

(let ((start (get-internal-real-time)))
  (sleep 3)
  (- (get-internal-real-time) start))
;=> 3000

SBCLの例ですが、
3秒sleepしていますが、
3000という数値が返っています

;; プログラムによって消費された計算時間
(get-internal-run-time)

(let ((start (get-internal-run-time)))
  (sleep 3)
  (- (get-internal-run-time) start))
;=> 0

同じくですが、run-timeを計測しているので、
sleepの場合働いてないので、
0です。
それでcookbookでは、
timingto
というマクロを作って見せて
説明しています。
標準で用意されている
timeも大体こう言う感じで作られているようです。
と言った感じで、
予想したより
だいぶ速く
進んでしまっているのですが、
インターナルタイムについてはこれくらいです
まあ、説明する内容も多くないので、
こんな感じでしょうか(^^;
インターナルタイムは
普段使っている分にはあまり利用することも
ないかもしれません。
で、3つめのセクションですが、
Computing the day of the week
ということで、
曜日の割り出しです。
最初に

* (defun day-of-week (day month year)
    "Returns the day of the week as an integer.
Monday is 0."
    (nth-value
     6
     (decode-universal-time
      (encode-universal-time 0 0 0 day month year 0)
      0)))

という簡単な例を説明しています。
これだと綺麗なのですが、
1900年起源なので
それより前だとまずいということで、
2つめに

(defun day-of-week (day month year)
  "Returns the day of the week as an integer.
Sunday is 0. Works for years after 1752."
  (let ((offset '(0 3 2 5 0 3 5 1 4 6 2 4)))
    (when (< month 3)
      (decf year 1))
    (mod
     (truncate (+ year
                  (/ year 4)
                  (/ (- year)
                     100)
                  (/ year 400)
                  (nth (1- month) offset)
                  day
                  -1))

のようなものを挙げています。
これは、1752年以降に対応しているようですが、
日付関係は、色々歴史的な問題があって
厄介ですね(^^;
ということで、
さらっと日付と時刻編は終わってしまいましたが
おまけということで
自分が見つけた範囲で
時間関係を扱うライブラリを
紹介してみようかなと