Common Lisp, Scheme Part 14

過去スレ
Part1: http://piza2.2ch.net/tech/kako/987/987169286.html
Part2: http://pc.2ch.net/tech/kako/1002/10025/1002584344.html
Part3: http://pc.2ch.net/tech/kako/1008/10082/1008220265.html
Part4: http://pc.2ch.net/tech/kako/1016/10162/1016211619.html
Part5: http://pc3.2ch.net/tech/kako/1023/10230/1023091882.html
Part6: http://pc3.2ch.net/tech/kako/1031/10315/1031560687.html
Part7: http://pc5.2ch.net/tech/kako/1042/10421/1042167213.html
Part8: http://pc5.2ch.net/tech/kako/1058/10582/1058263391.html
Part9: http://pc2.2ch.net/test/read.cgi/tech/1069594582/
Part10: http://pc5.2ch.net/test/read.cgi/tech/1075630259/
Part11: http://pc5.2ch.net/test/read.cgi/tech/1091456033/
Part12: http://pc8.2ch.net/test/read.cgi/tech/1100229366/
Part13: http://pc8.2ch.net/test/read.cgi/tech/1115901841/

□参考リンク□

日本Lispユーザ会(日本語)
http://jp.franz.com/jlug/index.html
ここにかなりの情報があります。
http://jp.franz.com/
削るとAllegro Common Lispのページへ

プログラミング言語Scheme(日本語)
ttp://www.sci.toyama-u.ac.jp/~iwao/Scheme/scheme.html
Schemeの人はまずここを見ましょう。

Lisper への道(日本語)
ttp://www.geocities.co.jp/SiliconValley-Oakland/1680/rakup.html
判りやすいLISP入門サイト。

Schemeへの道(日本語)
ttp://www.stdio.h.kyoto-u.ac.jp/~hioki/gairon-enshuu/SchemeNotes/scheme.html
ここはschemeの入門サイト。

慶応の授業のページ・記号処理プログラミング 2001
http://buri.sfc.keio.ac.jp/lisp/menu.html

Practical Scheme(日本語)
ttp://www.shiro.dreamhost.com/scheme/index-j.html
「普通のやつらの上を行け」など、興味深い文書を沢山翻訳されてます。
(Gaucheという完成度の高いscheme処理系作者さんのページでもあります。)

Scheme Hash(英語)
http://okmij.org/ftp/Scheme/index.html
S式でXMLを使える様にするSXMLなど

John McCarthy's Home Page
http://www-formal.stanford.edu/jmc/
LISPの生みの親、Ｊ・マッカーシーのページだそうです。

Association of Lisp Users
http://www.alu.org/alu/home
米国のLispユーザ会

□SICP関係□

SICP(英語)
http://mitpress.mit.edu/sicp/full-text/book/book.html
「計算機プログラムの構造と解釈」の原書です。
全てオンラインで読めます。

計算機プログラムの構造と解釈 第二版 (snip) に関連するホームページ
http://www.ipl.t.u-tokyo.ac.jp/sicp/

SICPの回答集
http://www.melt.kyutech.ac.jp/~gogogo/sicp_ex/
http://pluto.aurorasd.co.jp/~mkama/sicp/
http://www.ipl.t.u-tokyo.ac.jp/sicp/solution.root.html
http://www.sampou.org/scheme/sicp/answer/

□その他□

Schemeで書かれた正規表現ライブラリ
ttp://www.cs.rice.edu/~dorai/pregexp/pregexp.html

幻の「入門Scheme」
ttp://www4.ocn.ne.jp/~inukai/scheme_primer_j.html
オンラインで読める

各種scheme処理系をcygwin上からビルドする方法など。
ttp://www.geocities.co.jp/SiliconValley-PaloAlto/7043/

Bit - Implantation compacte de Scheme
http://www.iro.umontreal.ca/~dube/
mini-schemeよりも小さい(?)bytecode変換系

Lisp 言語処理系: CAMPUS LIsP, Lemon version
http://aten.aial.hiroshima-u.ac.jp/~kakugawa/clisp/index-ja.shtml
Cコードによるわずか1000行の実装

Cliki
http://www.cliki.net/index
CommonLispのプログラムがたくさん紹介されているのでここを当たるべし。

encyCMUCLopedia
http://www.isr.ist.utl.pt/library/docs/encycmuclopedia/doc/
cmucl以外でも有益なはず

CMUのLisp Repository
ftp://ftp.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/lisp/0.html
新旧様々なプログラムが置いてある

Tiny CLOS Tutorial
http://home.adelphi.edu/~sbloch/class/272/tclos/tutorial.shtml

Schemix
http://www.abstractnonsense.com/schemix/
Linuxのkernelへのパッチで、/dev/として扱えるTinyScheme

Bibliography of Scheme-related Research
http://library.readscheme.org/
Scheme関連の論文リンク集

その他よさそうなリンク

awkで書かれたわずか500行のLispインタプリタ
awklispを読めばLispが理解できる
ttp://www.accesscom.com/~darius/

Emacs Lisp 2
http://pc2.2ch.net/test/read.cgi/tech/1068467385/

* Hotdog Scheme http://rover.cs.nwu.edu/~scheme/
　MS が金出してたみたい
* Bigloo http://www-sop.inria.fr/mimosa/fp/Bigloo/
　CLR 用のコードを吐けるようになったらしい

継続

なんでも継続
ttp://www.shiro.dreamhost.com/scheme/docs/cont-j.html
Schemeへの道:継続
http://www.stdio.h.kyoto-u.ac.jp/~hioki/gairon-enshuu/SchemeNotes/continuation.html
継続の使い方
http://www.geocities.co.jp/SiliconValley-PaloAlto/7043/index.html#continuation
継続の使用法
http://www.ice.nuie.nagoya-u.ac.jp/~h003149b/lang/block.html
CPS(継続渡しスタイル)の説明
http://www.csl.sony.co.jp/person/masui/Forum/data/20011215023622/
Kahua: 継続ベースのアプリケーションサーバー
ttp://www.kahua.org/

仕様関係）
CLtL2: Common Lisp the Language 2nd edition
http://www-2.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html
CLHS: Common Lisp Hyper Spec
http://www.ai.mit.edu/projects/iiip/doc/CommonLISP/HyperSpec/FrontMatter/Chapter-Index.html
R5RS: Revised(5) Scheme(ja)
http://www.sci.toyama-u.ac.jp/~iwao/Scheme/r5rsj/html/r5rsj.html

便利な情報リソース）
The Common Lisp Cookbook: いわゆる Cookbook
http://cl-cookbook.sourceforge.net/

小さい実装）
SECDR-Scheme: SECD machine model に基づく実装
ttp://lily.fan.gr.jp/~kmd/adhoc/view.rhtml?n=SECDR-Scheme_woyomu
Minischeme: 1 ファイルに凝縮された Scheme 処理系
http://tinyscheme.sourceforge.net/minischeme.tar.gz
TinyScheme: Minischeme を色々弄ったもの
http://tinyscheme.sourceforge.net/
KI-Scheme, AM-Scheme, etc...
http://www.nifty.com/download/dos/prog/lisp/
LispMe: Palm 上で動く Scheme 処理系. これも SECD virtual machine.
http://www.lispme.de/lispme/

LISP Scheme Part9 (html化)
http://ruku.qp.tc/dat2ch/0403/01/1069594582.html

独習 Scheme 三週間
http://www.sampou.org/scheme/t-y-scheme/t-y-scheme-Z-H-1.html
Schemeの教科書

よろずや
http://www.geocities.co.jp/SiliconValley-SanJose/7474/
lispの実用的な情報が色々。

Common-Lisp.net: 多くのプロジェクトがホスティングされてる
ttp://common-lisp.net/

Bill Clementson's Blog: Lisp関連の話題が中心のBlog
ttp://home.comcast.net/~bc19191/blog/

Practical Common Lisp: S式の羅列で現実的な問題をどう解くのかそのギャップに悩まされてる人に
ttp://www.gigamonkeys.com/book/

>>1乙。

どうでもいいけどなんでスレタイ"Common" Lisp, Schemeなの？
Lisp Schemeじゃだめなの？
ちょっと前までLisp Schemeだったよね。
Common付けないといけない理由でもできた？

あと>>7の
>CPS(継続渡しスタイル)の説明
>http://www.csl.sony.co.jp/person/masui/Forum/data/20011215023622/
が404になってた。

>>10
Emacs Lisp とか xyzzy はスレ違いだと明示するためかな。

>>10
そのページの内容はWilikiに転載されてます。
http://www.shiro.dreamhost.com/scheme/wiliki/wiliki.cgi?Scheme%3aCPS

>>10
そういうのはスレが立つ前、900 過ぎで言わないと。
前スレの 980 が言ってるように、981 過ぎたらスレが落ちる前に次スレを
立てるのが先決。それまでにテンプレ議論ができてないと前スレそのままに
なってもしょうがない。

フランツのセミナーだれかいった？

仕事なんていう
つまんない理由で
キャンセルしちゃった
残念

on lispの翻訳本、年末までにでてくれると休み中に読めるなぁと言ってみるテスト。

>>16
結局どういう話だったの？
フランツのセミナー行った人詳報頼む。

http://itpro.nikkeibp.co.jp/article/NEWS/20051117/224835/

>>16
現在査読中。
発売は来年。値段は\4000-を超えないようにしたい。

>>994
マクロ文字でシンボルに意味を持たせるという手もあるみたい。
http://lambda.s55.xrea.com/20040325.html
つか、このサイト Google から消えてるな？

一日目は午前中はゲームプログラミングの話、午後はセマンテイックウェブの話、に
してくれるとよかったんだけど。XMLパーサとかjLinkerとかドキュメント読めば
書いてある内容をわざわざ改めて聴かされてもこちらとしては嬉しくないんだが。

あと両日とも会場が窮屈なのはどうにかならないのかなぁ。変な姿勢でスライド眺めてたら
首が痛くなっちゃったよ。

遠方からこのセミナーの為に自費で上京してくる学生さんとかが現れたのはあれかな、
Lispが年寄りの懐古趣味ではなくなりつつあるっていうことなのかな。

Haskellが流行りだしてる海外と比べると、
懐古趣味だけどな。

>>17
いってきたものです。昨年度同様資料は掲載予定とのこと。

** SemanticWeb
迷って新宿御苑一周して遅刻して逃した。翌日ネタにしてたくらいなので何かしゃべったはずだが、このため不明。
誰か知ってたら補完よろしく。

** Lisp とゲーム
子供向けゲーム開発プラットフォームを作った話。以降の OpenGL+SWIG とあわせて15分の
セッションなので超簡単に終わる。ものとしてはSqueakとかでデモってる子供から使える
ビジュアルプログラミング環境とかと似たようなもんなのかな。ベースエンジンは25KLOC,
40class 程の規模。Agent Cubes とかいう名前でオープンソース化予定。

このプラットフォームの一環としてOpenGL/GLUTや外部のフリーの物理演算ライブラリをACLから
使えるようにして、ゲーム記述のためのDSLを作った。SWIGがACLに対応したのでC/C++ライブラリを
簡単に組み込めるようになったとのこと。

libusbのSWIG化してるときにLisp/Scheme対応もやっとこうかと思ったんだけど、その時はどの実装向けにしたら
いいかよくわからんかったので、Lisp界はACLとGCLで大体カバーできて、できはACL>>>>GCLらしいとわかったのが収穫。

** On Lisp 翻訳
高校の時Lispに関心を持って、PaulGrahamのCL本の続刊OnLispが未訳なことを知って勉強をかねて翻訳に着手。

二年後2chでの協力などにより完成。CL本と違い、Macroの徹底応用本で、現在LispHackerな人の突っ込みを受けつつ
大幅改善＋出版準備中。値段は<4000円予定。ちなみに、実は本人はあんまりLispでは書いてないらしい。

内容紹介の中ではMacroとMultimethodについて解説してた。Multimethodはトップレベルのレシーバが構成上ない
だけと思ってたので、レシーバを消滅させることで匿名のアドホックなクラスに対してメソッド定義できると
いうのはなるほどと思った（あまりに初心者ですまん。自分はLisp歴0年なんで）。

続く…（技術的に見てLisperな人にとっては既知の話が多かったと思う）

マクロと関数について質問なのですが、
例えば+をマクロと関数に分けて作って、
(+ 1 2 3 ...) という直接使用のときはマクロとして可能な限り簡約してしまい、
((if test + -) 1 2 3 ...) みたいなときは関数を選択、という風に使い分けたいのですが、
こういう文脈によって切り分ける事はできるでしょうか？
CommonLisp、Schemeどっちでもいいです。

（CommonLispのシンボルが変数と関数別スロットにあるように、）
マクロと関数が別スロットにあるような処理系ならできそうな気がしますが、
実際のところそういった処理系はあるでしょうか。

>>24
つ http://www.ai.mit.edu/projects/iiip/doc/CommonLISP/HyperSpec/Body/sec_3-2-2-1.html

>>25
ありがとうございます。

えーと、つまりそのリンクの説明によると、関数とマクロは切り分けられる
ということらしいのですが、
シンボルに対応するマクロ定義用スロットというのがどこか別に存在する、
という解釈で合ってますでしょうか？
第一引数を評価するときにmacroexpandフックが呼び出されるということは
そのフックの中でマクロシンボルの管理をしているということでしょうか。

それと、symbol-macro-letについて疑問があります。
この特殊フォームの機能を成立させるには、正確にシンボルを置き換えるために
bodyで生成されるかもしれないフレームの変数について全て知っていないと
いけないはずで、そのためにはマクロで書かれた未知の構文に対応するために、
bodyのシーケンスに対してmacroexpandしていかなくてはいけない、
延いてはその処理系の変数生成フォームのパターンを全て把握している必要がある、
ということだと思うのですが、
やはりそういう複雑なことをやっているのでしょうか？

流れと関係ないけど見つけたので貼っておきます。

LISP Scheme hierarchy図
http://dreamsongs.com/NewFiles/Hopl2Slides.pdf

>>28
なかなか面白いね。

>>27
つまりはシンボルマクロの名前がシャドウイングされたときの話？
逐次展開して行くってのはまあそれでいいし、
シャドウイングが発生するような式の中では
ちゃんと展開しないようにしなきゃいけないのも確かだけれど。

でもマクロ展開しちゃったら出てくるのはアトムか、
式だったら特殊形式か関数適用かなわけで、
しかもシャドウイングするような特殊形式の数なんて高が知れている気がするけれど。

少なくとも macrolet と比べてとりわけ複雑だとは思えないなあ。

>>26
一般的に「関数とマクロは切り分けられる」って話じゃなくて、>>24 で
言ってたように「直接適用する時だけマクロみたいな処理をしたい」という
まさにその要求を実現するために、compiler-macroっていう特殊なマクロが
CLでは規格化されてるってこと。だからANSI準拠なCL処理系だったら 24 の
やりたいことはできるよ。

実装上はシンボルにfunctionスロットとcompiler-macroスロットを持っとく
のが素直だろうけど、そうではない実装だってあり得る。

>>28
凄い調べようだな…

>>30-31
ありがとうございます。
マクロとシンボルの関係について謎だったのですが、これで理解できた気がします。
マクロはシンボルの値として必ずしも参照できなくても良いみたいですね。

値として参照できなくてもいいと言うより、
話の筋としてはマクロは first class object じゃない、
つまり言語に於いて値となり得る対象ではないので
値として参照できちゃいけないといった方がいい。

マクロ定義・展開関数を、なにかタグをつけるとかして
関数スロットに突っ込んでおくような実装もあるだろうけれど、
というか xyzzy がそんな感じなんだけれど、
それが何かマクロ型とでもいうべき値として意味を持っているわけじゃない。

基本的なことを教えて下さい。
Lispでは、ボトムアップスタイルでコードが
書ける、とよく言われておりますが、
イメージ的には関数を個別に書いてゆき
後でそれを統合し易いといったような
意味なのでしょうか？

十分に設計されたものと同等かそれ以上の汎用性があり、
設計の時間を殆ど要しない。
ネックは実行速度のみ と 開発&コーディングスタイルの違いだけである。

頭悪いとできないかもしれんね。

>>35
とりあえずプログラム数千行も書けばわかるよ。
素養のない人に説明するのは難しい。

語彙力も文章表現能力もないので人に説明するのは難しい。

知性の欠片もない人間には伝わらないよ。

ネックが実行速度ってどんな貧乏処理系使ってんだよ。
プロジェクトを回すだけのLisperを揃えるのが困難とか開発したプロダクトを
投げて保守させるのが困難とか、環境とか政治的な要因の方がネックだな。

Lisperが揃ったプロジェクト！
一度やってみたいなぁ。いつもLisperは俺一人か、良くてあと一人くらいだよ。orz

>>41
> Lisperが揃ったプロジェクト！
> 一度やってみたいなぁ。いつもLisperは俺一人か、良くてあと一人くらいだよ。orz
履歴書と、職務経歴書もって、苫米地英人博士のコグニティリサーチラボ行ってみれば？
苫米地博士はCommonLisp大好きで、Lispハッカー募集してるから。

>>42
一時期会社が傾いて、新規の技術者募集は今はやってないんでない？

事実上更迭されて仕切ってるのは弟だからLisperの会社じゃなくなってるでしょ。きっと。

>プロジェクトを回すだけのLisperを揃えるのが困難とか開発したプロダクトを
>投げて保守させるのが困難とか、環境とか政治的な要因の方がネックだな。

誰でも使える言語で一人で開発してる自分には無縁だな。
さらに、EVALに近い機能を使ってカリー化とかしてるし。

何の言語使おうが、生産性を1/10に下げて誰でも使えるようにするか、
そうでないかの違いな気がする。

>>45
> >プロジェクトを回すだけのLisperを揃えるのが困難とか開発したプロダクトを
> >投げて保守させるのが困難とか、環境とか政治的な要因の方がネックだな。
>
> 誰でも使える言語で一人で開発してる自分には無縁だな。
> さらに、EVALに近い機能を使ってカリー化とかしてるし。
>
> 何の言語使おうが、生産性を1/10に下げて誰でも使えるようにするか、
> そうでないかの違いな気がする。

そこでMatz Lispですよ！(Rubyのことなので検索しないように）

誰でも使えるかどうかは…

>46
パフォーマンスが……

あのなぁ、Ｒｕｂｙ，Ｌｉｓｐと対立する言語の話題を持ち込んで、このスレを炎上させるおつもりですか？

対立してるんだ。知らんかった。
言語なんか適材適所で使い分けるもんだと思っていたよ。

グレアムさんだって、viaweb時代にLispだけでやってたわけじゃないしねぇ。

>>48
RubyやJavaScriptはLisp方言だと思ってる。

>>51
その言い回しはパラダイム論争になるわえ。

>>51
プログラムを（文字列ではなく）リストとして扱えなくちゃLispとは呼べないだろ。
RubyやJavaScriptでできるんだっけ？

Perlなら可能。Perl最高！

>>53
んなことない。プログラムが S 式なのは Lisp のある方言群の特徴でしかない。
dynamic typing で call by reference な言語は全部 Lisp。

>>55
リスト処理できなくてもLispなのか。おまえの友達は少ないだろうな。ｗ

>>56
私は>>55に賛成。
プログラムがオブジェクト(ラムダ)であることに意義があると考える。
その形がリストであることにこだわるのは意味的に重要でない。

どちらにしても、ここは Common Lisp と Scheme のスレなのだから、
>>55 >>57 の言うような言語はスレ違い。どっか他でやってくれや。

LISt Programming の略じゃなかったのか。

LISt Processor だったような気がするす

LISt Producer じゃなかったっけ？

Lots of Irritating Superfluous Parentheses

コンパイラスレでも気になっていたがつまらん自演が流行っているのか？

「リスト処理ができること」と
「プログラムをリストとして扱えること」は関係無いだろ

>>64
実際CommonLISPは組み込みの特殊フォームが25程度で、
後は全て関数かマクロによるリスト処理で成り立ってる。
ただしリストじゃないとLISPのマクロのようなものが書けない、
ということではない、ということかな？
ほんとはシーケンスのような抽象化をしたいとこなんだけど、
たまたまリスト操作と「見なす」表現が理解に都合良かったということ。
中身が実はベクタだったりするLISPも実際あるだろう。
初心者や表層だけ見て判断する馬鹿には最初は単なる「リスト処理言語」としての
側面しか見えないかもしれないが、その側面はまさに初心者や馬鹿でも
わかるように設置した受け皿なので、それでかまわないのだろう。

sage忘れたorz。

>>64
そう。無関係。
だけどそれら両方を備えている言語以外は一般にはLispとは呼ばない。
DylanやJavaScriptは「Lispと似た特徴を備えている」がLispではないでしょ？

>35
あくまでこれはイメージですが、

(hoge ムッチャ複雑な処理の中に
(poge まぁ複雑な処理の中に(moge 単純な処理))
(jo まぁ複雑な処理の中に(jojo 単純な処理)))

このようなLispのプログラムにおける
ボトムアップ開発とは
１．まず単純なmoge,jojoを作り
２．次にまぁ複雑なpoge,joを作り
３．最後にムッチャ複雑なhogeを完成させる。
ってことですよね？
カプセル化無しのスッポンポン。
確かに全体の透明性は高い、が一目では
何をやってるのかさっぱり分からんって
ことはないのでしょうか？

ことで…

>>68
全然Lisp知らないでしょ。おはなしにならないよ。

>>68
>>35じゃないですが。
それって、他の言語でも普通にできますよね？Lispとどう関係あるのかいまいちわからないです。

JoJoォォ----波紋の呼吸を(Ry

>>70
他の言語でも出来るけど、mainとか何とか書かなきゃ実行もできない。
面倒っしょ？対話的環境最高。

そもそも単純な処理から複雑な処理を作るって何か違和感…
単純な処理の組み合わせにするんじゃね？

>70
Lispに戻ってくればわかる。

リストが抽象的でないという意見はわからない。
シーケンスとか言っても
(map (lambda (x) (* 2 x)) (cons 3 (make-array 10 1)))
=> (3 . [2 2 2 2 2 2 2 2 2 2])
とかできないんじゃ意味ないし。

リストこそが抽象である。

>>73
それは思考停止というものだよ。
確かにリストの形に抽象化されたスタイルは素晴らしいものだが、
逆に言えばそれはリストでしかないということだ。

抽象の意味分ってるのか？
万能と抽象は違うと思うが。
(vector 1 (vector 1 (vector 1)))
これはまさしくリストの構造だ。

ま、データ構造を先に作らなくても car cdr cons でぽちぽちやれるからね。
オブジェクト指向的な言い方をすれば、先にクラスを設計しなくても、必要に
応じてメソッドをぽちぽち作っていけば、気が付いたらクラス（的なもの）が
出来ているって感じだな。

>>76
インスタンスベースのオブジェクト指向言語に対して
それではあんましメリット無いような…

javascriptとかrubyとかでも出来るんじゃないの？
もっとlispらしい話を！

というとデータ構造と制御構造がリストと渾然一体なことと
マクロとかマクロとかマクロとかしかないのかな…
＃個人的にはそれで十分というかそれこそが全てなんですけど

短くてわかりやすい例を示したいといつも思っているんだけど
なんか表現力がたらんくていつも挫折。orz

>>76
car cdr consとかでやってると、データの並び順が変わったとき、car cdrとかやってる部分は全部書き換えになっちゃうんじゃない？その辺がlispって面倒そうなイメージなんですが、どうやって回避するんですか？

>>71
なるほど。mainを書かないでいいのは楽チンでいいですね。コンパイルとかも、関数単位でできるみたいですし。只、lispだけじゃないですが、うっかり既にある関数を上書きしてしまいそうなのが恐いイメージがあります。

>>78
ラッパ書けばいいんじゃない？
あるいはハッシュとかdefstractとかdefclassとか。

read と eval が別関数で、
言ってみれば構文木を first class object として扱えるところかなあ。
他の言語の eval だと大抵受け取るのがパース前の文字列なんで、
それを使ってごにょごにょしようとした場合構文木をいじるんじゃなくて
文字列・ソースコードをいじることになるのが面倒くさい。
マクロも同じで、文字列→文字列変換だと、無いよりはいいかもしれないけれど、
lisp のマクロと比べてあんまり魅力的ではない。

まあ、そこはどうにか構文木を直に触れるようになったとしても、
構文木オブジェクト周りで内部表現と外部表現が齟齬をきたす可能性が高い気がする。
つまりソースコードを read して print したら何が表示されるか、
という話で、lisp であるなら元の S 式が表示されるわけだけれど。
そこで表示されるのは構文木の外部表現なのか、元のソースコードなのか。
或いは構文木を write して read したらどうなるのか。
そこで read/write Invariance は保障するのは S 式を採用しないと結構面倒そう。

個人的には read と eval が分かれていて、
read/write Invariance が保障されるなら別にリストじゃなくてもいいかなあとは思う。
ただ、せっかく手軽に切ったり貼ったりできるのにリストじゃなくする理由もあんまりない気がする。
リストって言うか cons,car,cdr で弄れる対象と言った方がいいか。
内部的に対になったメモリ領域じゃなくて匿名関数でもいいけれど、
そりゃ効率が悪い、という話でしかない。
措いてしかし、構文木の内部表現がベクタで、なおかつそれをいじることを前提とした言語であったら、
ベクタを弄り回すライブラリが充実していることだろうから、あまり問題にならないかもしれない。

scheme の syntax-rules みたいなパターンマッチベースのマクロだったら
それなりに他の言語でも上手くいく可能性はあるかもなあと思わなくもないけれど。
少なくとも symbol 型のデータ型は必要になるんじゃないかなあ。
識別子が first class object じゃないと困るって言うか。

ごめん、>>80 は >>77。

>>68
本当に複雑な問題っていうのは、まず (hoge ムッチャ複雑な処理)
の中身をどうすべきか、っていうのが事前にわからない。
問題の本質自体が見えていない。そこが出発点。

とりあえず手元には生のデータがある。その生のデータをいじくりながら、
まず問題を記述するための単語にあたるパターンを見つけ出す。もちろん
最初はそれが正しいかどうかはわからないが、仮説を立てて、生データを
単語にまとめるルーチンを書いてみる。それがmogeやjojo。

その単語を色々組み立てて、問題を記述できる句が構成できないどうかを
調べてみる。句できたらそれを色々組み合わせて文ができないか調べてみる。
その途中で、最初のパターン化が間違ってたことがわかり、下に戻る
こともある。ときには、多少間違っていてもそれを使って無理矢理全体を
組んで様子を見てみると、どこがおかしいかわかる場合もある。そうやって
粘土をこねたりLegoを組み立てるみたいに作っていくと、最後に

「(hoge ムッチャ複雑な処理の中に
(poge まぁ複雑な処理の中に(moge 単純な処理))
(jo まぁ複雑な処理の中に(jojo 単純な処理)))」

と書けば問題がきちんと記述できることがわかる。これがわかれば後は簡単だ。
君の言うように、どんな言語にだって落とせる。もっともこれが分かった時点で
Lispの場合は既に動くプログラムが手元にあるわけだが。
まあ、大抵はこのあとリファクタリングして整理してゆくがね。

君は、答えが分かった後どうするかって話をしている。難しいのはその前だ。

On Lisp の Preface でも読めばいいんじゃないかな

>82
懇切丁寧なる解説＜−深謝。
いよいよLispらしいことを伺いますが、
)))　このカッコのネストは人間にとって、どこまでの
深さが理解出来る限度なのでしょうか？
ワインバーグがPL/Iの例ですがプログラマに
とって基本は三段まで、五段以上は理解不能と
書いています。
ところがLispの場合,setqで関数内部を隠蔽するのを
良しとしない気風？もあってか))))))六段〜七段！
なんて普通に見かけますよね？
（まぁインデント無しで読むのはチト苦しいが…）
Lisperの素質ってネストにどれだけ耐えられるか？
もっと言えば、頭がよじれそうな複雑なネスト構造に
「被虐的な快感！」を覚えるかどうか、
これがポイントでは？

>>84
> もっと言えば、頭がよじれそうな複雑なネスト構造に
> 「被虐的な快感！」を覚えるかどうか、
> これがポイントでは？

実際に読むのには全く使っていない。
書き方に作法があるので支援環境で組まれたソースを読むのは
pythonと同じスタックしかいらない。（基本はぶら下げで全部表現）

>>84
並みよりは深いネストに耐えなきゃなんないが、
画面の幅を超えるほどの深さになることはまれ。
要するに問題の深さを抑えられるかどうかがポイント。
つまり、効率的に分割できる能力のこと。

>>84
Webに転がっているコードを良く見るとわかるが、
開き括弧'('がネストしているケースはそれほどないはずだ。

Lisperがコードを読むときはリスト先頭の名前と
インデントの仕方で判断してると思ってよい。
名前で始まらないリストが現れる場合は何かの構文の中か、
インライン関数の呼び出しぐらいしかない。
Lisperでも
((lambda (a b c) body) x y z)
より
(let ((a x)(b y)(c z)) body)
の様に名前が先頭にある方が読みやすいと考えている。

また、Lispはコードがデータであるが故、
専用エディタが無くてもコードをreadしてpretty printすることで
適切にインデントされたコードを得ることができ、
そのインデント具合から間違いがわかったりする。

ていうか閉じ括弧ってあんま注目しない気が。
開き括弧とその直後とインデントで、全体の「かたち」は9割くらい把握できません？

Lispのインデントって基本的にこうだしな。
[
　　[
　　　　[
　　　　　　[

ネストなんか気にしないよね普通。Emacs様がどこと対応するかなんて教えてくれるし。
S式単位での編集に慣れたら括弧がない言語の編集がめんどくさくてかなわん。

沢山、でもないな、ある程度の量のコードを読み書きすると
カッコは(特に閉じカッコは)見えなくなるよ。
意識の上ではまさに>>89のような感じ。

ついでにいうとインデントが深いのも
1関数が長すぎるのもリファクタリング不足って気がする。
高階関数とマクロでいくらでも短くできるはず。

喪前ら 社内の使えない人材より数百倍役に立つ
Emacs様をちゃんと使いこなしてますか。

Spoon Boy: Do not try and bend the list. That's impossible. Instead
. . . only try to realize the truth.

Neo: What truth?

Spoon Boy: There is no list.

Neo: There is no list?

Spoon Boy: Then you'll see that it is not the list that bends; it is
only yourself.

>>93
dabbrevに慣れたせいで別のエディタやIDE(Javaとか使うとき)が使えません。

Lispに、はまる人間の数はここ20年世界中で
一定だそうです。WEBの発展とプログラマの
増加を考えれば相対的には減少傾向にあります。
しかしながら、少なくとも、このLisp言語には
逆風のなかでも、「しつこく」Lisperは存在する
訳です。この「極」東、日本にさえ…
何故か？
やはり(((())))の魅力にはまるのではないで
しょうか？
それ以外にもう、他の言語に対して差異化するもの
は何もない、と言い切って過言ではないからです。
ネストによる複雑さは初心者にとって確かにLispへの
障壁かもしれませんが、逆に言えばLispに残された
唯一の魅力なんです。
異様な(((())))が気にならない、これこそ既に
Lispにはまっている証ではないでしょうか？
スタック構造って本来、人間の記憶機能に最も近い。
(何とか（何とか（何とか　最後に）））
この（カッコを越えるたびに頭脳負荷がかかりますよね？
各々の機能を理解してスタックに積みこんで行く訳ですから。
解放されるのは）））の後でしかない。
これを楽だって言っちゃ駄目なんです。
この頭脳負荷そのものが快感なんだって言わなければ。

最近では ( ) の魅力ではなく、 <x>...</x> の呪いにまってる香具師が多いよな。

<x>...</x>は動かんから面白くない。
ところで、
LispWorksって結構評判良さげ？
Personal Editionを使用された
経験のある方ぁ！
道誉？

> Lispに、はまる人間の数はここ20年世界中で
> 一定だそうです。

> WEBの発展とプログラマの
> 増加を考えれば相対的には減少傾向にあります。
> しかしながら、少なくとも、このLisp言語には
> 逆風のなかでも、「しつこく」Lisperは存在する
> 訳です。この「極」東、日本にさえ…
> 何故か？
> やはり(((())))の魅力にはまるのではないで
> しょうか？

> ************************************************************
> それ以外にもう、他の言語に対して差異化するもの
> は何もない、と言い切って過言ではないからです。
> ************************************************************

> ************************************************************
> ネストによる複雑さは初心者にとって確かにLispへの
> 障壁かもしれませんが、逆に言えばLispに残された
> 唯一の魅力なんです。
> ************************************************************

> 異様な(((())))が気にならない、これこそ既に
> Lispにはまっている証ではないでしょうか？

> ************************************************************
> スタック構造って本来、人間の記憶機能に最も近い。
> ************************************************************

> (何とか（何とか（何とか　最後に）））
> この（カッコを越えるたびに頭脳負荷がかかりますよね？
> 各々の機能を理解してスタックに積みこんで行く訳ですから。
> 解放されるのは）））の後でしかない。
> これを楽だって言っちゃ駄目なんです。
> この頭脳負荷そのものが快感なんだって言わなければ。

実際に書いてみないと身につかないなと思い、一念発起してlispで簡単なスクリプトを書いてみた。
書いてしばらくして気付いた。

関数でいいのにマクロがいっぱい...。

>>101
詳しく

関数やマクロがいっぱいあるプログラムを
簡単なスクリプト
と言い切ってしまう101は天才

関数やマクロ以外にLispの構文で他に
何があるのでしょうか？

>85
>そうやって
>粘土をこねたりLegoを組み立てるみたいに作っていくと、最後に
>「(hoge ムッチャ複雑な処理の中に
>(poge まぁ複雑な処理の中に(moge 単純な処理))
>(jo まぁ複雑な処理の中に(jojo 単純な処理)))」
>と書けば問題がきちんと記述できることがわかる。

どうなんでしょう？これをもっと敷衍すると
pogeやjoから作り始めるのがLisp流の開発
スタイルかと。
まずアイデアはpogeから考え始める。そして
(moge 単純な処理)を考えてモリッとpogeの中に
注入するイメージで組み込んで行く。
どんどんモリッ、モリッてpogeの機能が具体化し
拡大すると同時に発想が膨らむ。
そこで並行するjoが生まれる。それもモリッ、モリッて
関数を注入して膨らます。
そこである瞬間、統合するイメージが湧く訳です。
で、今度はマルッて全体をhogeが閉包する。
またさらに、それをマルッて包含するhoが生まれるかも。
ポイントはモリッの下方関数注入とマルッの上位関数閉包で、
その都度当初のpogeやjo自体が変質変容するところです。
またこのようにコーディングが進むにつれて、
全体プログラムや構想自体もダイナミックに
変質変容を繰り返しますよね？
勿論、この発生順は不定です。
ただ変質変容だけが本質かと。
それは「決して簡単でも単純でもない。極めて頭脳負荷の
高い作業」です。
が、面白い。ってところでしょうか。

読み手に極めて高い頭脳負荷と心的負荷をかける改行をありがとう。

キャパを越えない限りは頭脳負荷なんて大して変わらない。

漏れは頭脳が壊れると困るので３行目くらいで止めたよ

破壊はよいことだよ。
必要ならば。

破壊って rplaca, rplacd のことか？

>>109
最適化の基本だね。

美しい末尾再帰のコードをイジりたくなくて
それ以上最適化をしたがらないオレはヘタレorz

generational GCにとっては破壊は悪であると教わりました。

引数の数が違う同名のメソッドが同じパッケージに共存できない
CLOSって使い物になるの？
たとえ同じパッケージの中でも、他のクラスで引数の数が違う
メソッドが定義されていないかなんて気にしたくないんだけど。

なるからあの仕様なんだろう。

>>115
自分にとってなってるの？
どうにか使えるだけじゃなく、快適で柔軟だと思える？
複数の引数でディスパッチできることと引き換えに
他のクラスのメソッドの名前を気にするのって割に合わない気がする。
gaucheなら全然そんな制限ないのに。
仕事とかでCLOS使ってる人はどう思ってるんだろう。
もっと制限の緩いオブジェクトシステムの移植性のある実装とか無い？
なんであんなのが標準なんだ。

>>116
ものの考え方が違うから。

仕事で使ったことあるけど、特に不自由はしなかったが。generic-function の
考え方が馴染めないなら、普通の OO 言語使ったほうがいいよ。Java とかとは
設計方針がかなり違うから「メソッドはオブジェクトに属する」みたいな考え
を切り替えて設計しないとそう思うだろうね。

オブジェクトシステム自体はいろいろあるけど、標準でもなくサポートもない
のは仕事ではちょっと使えないな…

いわゆる「普通の」オブジェクト指向言語に毒されてるんじゃないかな。
そういう意味ではCLOSには隠蔽機構も欠けている。
「普通の」オブジェクト指向言語風に使いたいのであれば「クラス」ごとに
パッケージを分けるという方法もある。ここでの「クラス」は隠蔽単位で
あって、CLOSのclassと一致する必要はない。つまり、より自由度が高い
と考えることもできる。
要するに「普通の」オブジェクト指向言語は置いといて、よりCLOS的な発想
でクラスやパッケージのデザインをやりなおすのが吉。

いや、>>114 はジェネリックファンクションの考え方は
わかってるんじゃない? CLOSの、同じジェネリックファンクションに
属するメソッドのlambda listが合同じゃないとだめって制限に
ついて言ってるんでしょ。TinyCLOS派生のstklos, gauche,
goops (guile) なんかはそういう制限が無いし。
個人的には、メソッドのシグネチャを変えてreloadした時に
エラーが出るのがうざいけど、不自由だと思ったことはないなあ。
もともと名前をあんまり覚えられないたちなんで、ジェネリック
ファンクションがやるべきことを名前を見ただけでわかるように
特徴的につけてるから、全然関係ないメソッドの名前が偶然
重なっちゃうってことはほとんどない。
でも、何でそういう制限があるのかは不思議。

CLtL3 では制限を取り除く方向で改訂しましょう

>>120
generic functionを機能としては理解していてもCLOSとしてはわかってなさげ、
という話だと思うが。

>>122
そうなのか? なら俺もCLOSわかってないなあ。
この制限があって嬉しいことって何?
確かにAMOPに書かれているように実装したらそういう制限が必要そうだけど、
それって実装上の制限であって、言語としてのメリットじゃないような気がする。

>>120みたいに丁寧に言ってやらなきゃ分からんほど、気にならない制限なの？
実際、仕事で使ってるような人が気になってるか、なってないかを知りたかった。
CLOSみたいな制限があると、機能的に、メソッドがクラスに属している言語の
スーパーセットとしてみなすことはできないじゃない。
(hoge (x <A>))を書いてるときに、全然関係ない(hoge (x <B>) y)の
ことなんか考えたくない。存在する可能性すら気にしたくない。
>>119
だからパッケージに分けるのがめんどくさいときの話をしてんの。
あるいは一つの複雑な問題を解くために、いくつかのクラスが必要で、
しかし、パッケージ外にさらしたいインタフェースは単純にしたい場合、
そういうクラスは一つのパッケージに詰め込みたいことが多いと思う。
そのなかで、(hoge x)と(hoge x y)を共存させたかったら、
結局、片方を書くためにもう片方を意識させられる分けで･･･
まあ、120が言うように、まれだろうとは思うけど。
>>119>>122
そのCLOS的な発送とやらを教えてくれ。
その方針に従えば、名前付けるときに悩まなくてすむわけか？
たいていのメソッドは動詞+目的語みたいなシンプルな名前を付けて
来たけど、なんだか、関係ないメソッドが被っちゃって、
不自然だけどパッケージ分けるか、A-hoge B-hogeみたいな名前つけるか、
どうにか別の同意語をこね繰り出すか？仕様書で使ってる用語と違うけど。
みたいなことを後からしないといけなくなるような、
そういう手間を回避できるノウハウがあるなら教えて欲しい。

>>124
まぁそんなにムキになりなさんな。ｗ

(hoge x) と (hoge x y) はそもそも操作の対象は違えども同じ意味の操作である
はずなので、あまりそういうことが起きないのかもしれないという気がしてきた。
CLOSに慣れてるとhogeにあまり一般的な名前を使わない癖は付くかもしれん。

別の言い方をすると、オーバーライドの意味でgenericは使うけど、オーバーロード
の意味ではあまり使わない（別の名前を付ける）って感じかな。

>>114
言いたい事はわかってるって。だから考え方を切り替える必要があるってゆっ
てるじゃん。CLOS ではインターフェースが凄く重視される。クラス毎に同じ名
前のメソッドが違う仕様というわけにはいかない。逆にマルチメソッドディス
パッチを利用したシンプルなインターフェースが要求される。C++/Java からき
た時は最初とまどったけどね。切り替えができれば同じメソッドなのに異なる
インターフェースがある事なんか考えたくないってーか。

> CLOSみたいな制限
> メソッドがクラスに属している言語のスーパーセット
> (hoge x)と(hoge x y)を共存
このへんからは多分、CLOS に合わない人だろうなとは思う。
総称関数という考え方での設計ができてない。

>>CLOSに慣れてるとhogeにあまり一般的な名前を使わない癖は付くかもしれん。
結局、そうなの？でもSchemeでは使えるよね。
結構、Common LisperとSchemerではスタイル違ったりするのかな。

一般的な名前のメソッドも使うよ。
具体的にどんなプログラムでどんな設計をしてるわけ？

総称関数を、別個の操作に同じ名前をつけることを許す仕組みだとしか、
つまりオブジェクト・セントリックなOOPモデルでメソッドで名前空間
がクラスごとに分割されていることの代替機構だとしか認識できないから
114みたいに思うんだろう。

でもこういう認識ってのは、わかってない人、特に自分で頭を切り替える
つもりのない人に2chで何万言費してもわかってもらえる望みは薄い。
それが出来る人は、114みたいにすぐに他罰的な結論に飛び付くことなく、
まずモデルの違いやその理由を把握すべく知識を増やしたりするから。

> 何万言費してもわかってもらえる望みは薄い。
少しは役に立つこと書ける奴がこう述べるならいいんだけどさ。

他罰的反応の見本のようなレスだな。

なるほど。これはどうにもならないね。何人か回答しているのにすべてスルー
してるし、もはや見たいものしか見えないんだろうね…

おれも >>114 と同じことを思ってた。
cl 使ってる人たちが皆 120 みたいならどうしようもないな

本当に >>119 が言ってるみたいに CLOS ではクラスは「隠蔽単位」でないの?
パッケージで隠蔽っていうのはものすごく辛くないか。
一つのモジュールになっているものをパッケージにして隠蔽するのは簡単だけど
二つの関係あるクラス同士を連係させつつ名前を分離したりするのはどうするんだ。
lisp 最近はじめたんだけど、正直使ってる人はどうやってるのか知りたい。

>114
仕様がなぜそうなったかという辺りは知らないけど、
単にCLOSの制限が嫌だと言うなら、それを直接使っていく必要性もない。
例えば可変個の引数を扱いたいならば、&restを使って引数の数から
該当するメソッドへディスパッチを行う宣言や構文でも追加すればいい。
ディスパッチをコンパイルタイムで解決する工夫をすれば効率も変わらない。
とりあえずLispでJavaなどの機能を実現したいという事なら、まずは
意味的に同じになるようにシステムを構築した上で試行すべきじゃないかな。
Lispではそれが可能なんだし。
違う概念を無理に既成の物へ当てはめようとして、それがダメだった、
とここで癇癪起こされても、それはただの白痴だろう。
もうちょっと広い視野を持ったり、理知的に考えてみたらどうだろうか。

114じゃないし、仕事でCL使ってて不自由を感じたこともないんだけど、
Lispのいいところは、言語による不条理な制限がもとからほとんど無いため、
他の言語だと制限を回避するために手間をかけなきゃならないところを
ストレートに書けるところだと思ってる。だから>>135の主張には同意できない。
CLOSの仕様の制限が言語の自由度と表現力を増しているという説得力のある
議論がない限り、その仕様は「非Lisp的」だと感じるな。
完璧な仕様なんて無いから、仕様に穴があること自体をとやかく言うつもりは
ないけれど、「これは仕様の穴なんじゃない?」って意見に対して「それは
こういうまっとうな理由があるんだよ」と答える代わりに発言者の考えを
とやかく言うのは健全ではない。

ちなみに俺個人の体験では、メソッドの必須引数を変えて再読み込みした
場合に、必須引数の数が違うメソッドが残っているとはまることがある
(ちょっといい具体例が出せないけれど、例えば foo ((a string) &rest z)
があって、後で foo ((a string) (b string)) に変えた時に、
(foo "abc" 3) がエラーになると思い込んでたら古い定義に捕まってた、とか)
だからインタフェースを変えた時にリセットしてくれるのは有難いかな。

詳しい奴も一向に出てこないし、結局CLOSは今風じゃないってことだろ。
UNIXとかX Window Systemが主流になれなかったのと同じで、
柔軟に作ったとしてもかえって複雑になりすぎて誰も使{わ|え}なくなった。
CLOSを全て把握して使うのが得なのか、それとも１から自分に合った
オブジェクト指向システムを構築するのが良いのか、お前ら判断できないだろ。
GLSもJavaに逃げちゃったし。

結論：
CLOSは不条理でできています。

詳しい人が来た所で話が通じるのかどうかも疑問ですが。

>>137
その論調だとCLOSを全てLISPで置き換えても成り立ちそうだな。
LISPにとって今風でないことはどうでもいいことだし、LISPから柔軟性を取ったら何が残らないじゃん。
だからその論調は、少なくともLISPスレでは違うんじゃないの?

>>139
>LISPにとって今風でないことはどうでもいいことだし

そんなことないだろ。
今風と言ったら、前から出てきてるメソッドがクラスにぶら下がる
シングルメソッドディスパッチ方式なんじゃね？
CLOS視点でのオブジェクト指向設計という側面はかなり古臭いものと思うが。
これはLISP自体の概念とはまた別のものだよ。

古臭いかどうかほど、LispやLispに含まれる諸概念を評価するのに不適当な物差しもないと思うが。

例えばLISPの構文はRubyやJavaだとかの構文木を
S式で記述したものと見なすことができる。
以下の式をLISPに変換するとして
object.a.b.c(1 2);
この各演算子をS式の構文木として素直に変換するなら
(method-call (member-ref (member-ref object :a) :b) :c 1 2)
のようになると思う。

これをCLOSの流儀に従って
(c (slot-ref (slot-ref object :a) :b) 1 2)
というように、cを総称関数としてわざわざ定義する必然性は無い。
むしろcは単にメソッド呼び出しである、という標識があれば良いので、
前者と同様にslot-refと同じ形式でmethod-callを定義しても良いだろう。
こういった流儀ならば114からの流れで出てきた制限はなくなるかもしれない。

>>142
別に (method-call (member-ref (member-ref object :a) :b) :c 1 2)
の流儀にしなくても>>114の言う制限はなくせると思う。
gauche ではなくなってるでしょ？

>>141
俺が言いたいのはCLOSもgeneric-functionもあってかまわないが、
今風のOO設計もできた方が良いはずだということ。
今風とは>>119で出てきた「「普通の」オブジェクト指向言語」
で実現されている事がまさにそれだと言える。
するとCLOSは普通ではないということになる。
これを古臭いと表現した。

CLOSが一般的だった時代もあったのかもしれないが、
もはや外の常識は引っ繰り返っている。
119は「CLOS的な発想〜やりなおすのが吉。」と言っているが、
吉とは限らない。
そもそもCLOS的な発想とは何か？119は説明できるだろうか？
ほとんどの人間はCLOS的な発想をしろと言ったところで、
異質である、時代を退行しているかもしれない、他でつぶしが利かない
と判断した時点で学習を止め、より主流の言語へ流れて行くだろう。
これではCLOSのグルーは育たない。

グルーを集めるには、今風のデザインを追いかけていき、
より魅力的な物にしていく流れみたいなものが必要だろう。
CLOSを捨てるのも選択枝に入るかもしれない。
今風のデザインを用意しておけば、少なくとも他のOO言語の
経験者であればとっつきやすいと感じるだろうし、
今風のOO設計手法について共通の話題にも参加することができる。
LISPのOOはCLOSだからと盲目的にCLOSを薦めるのは
止めるべきじゃないかと思う。

>>144
メソッドがオブジェクトに属するべきだ、という考え方をやめろってことじゃない？

144は、メソッドがオブジェクトに属さなきゃいけない言語を使ってて、
違和感を感じることはない？

>>144
別に最初CLOSみたいなオブジェクト指向があって、それが発展してSmalltalk的なオブジェクト指向になったというわけではない。
両者は別々に生れたもので、どっちが古いとか新しいとかじゃないよ。

>145
>〜をやめろってことじゃない？
これの言い回しの意図が不明だけど
今風の考え方で素直に理解できるデザインにした方が
混乱が少ないですよ、CLOSに固執するメリットは不明ですよ、
としか言えない。
違和感については、今風の思考をしていれば全くないんじゃないかと。
ただ、CLOSの考え方の押し付けは、
あまり実にならない気がするなあ、といった所。

>146
>別に〜なったというわけではない。
そんな話はしてないよ。
単にこれだけCLOS、CLOSと話がされているからには
CLOSが流行した時代でもあるのかと思っただけ。
歴史的価値があったかどうかより、
今それがほんとに有効なのかどうか、
再度考えた方が良いんじゃないの、と言う事。

結構伸びてるなあ･･･論点がシフトしてるし。
俺はgeneric functionではなく変な制限のあるCLOSが嫌なだけだけど。
>>128
特に何も。単にCLOSを使い込んでる人がどう思ってるのか知りたいだけ。
>>132
ずっと2chに貼り付いてすぐにレスするのは無理。
>>135
前半と同じようなことは少し考えたことがある。
｢CLOSを使い続けるしかない状況｣で折り合いを付けるひとつの方法として。
でも、それって結局CLOSの世話のために考慮したり労力を割くってことでしょ？
>>136
restって書いてるけど、それは制限の緩いSchemeの方ではまったってこと？
Common Lispみたいな制限があったほうが間違いが少なくなる例ってことでいいのかな。
そういうはまり方をするのはgeneric functionとrest引数という概念の
相性の悪さがでてる気がする。
単一のリストを渡すか、可変長引数にするかっていう選択の余地があるところが
裏目にでてるんじゃないかな。
それは他の関数型言語には無いものだよね。
generic functionの引数を可変長にするとはまりやすい･･･なんて法則は無いのかな？

メソッド名が一般名であることってそんなに重要かなぁ。
汎用なオーバロードが便利なのは同意するけど、単なるシンタックスシュガーでしょ。
極端な話、メソッド名はクラス名をプレフィックスするなりして一意にすればいい。
generic functionはあくまでポリモーフィズムを実現するために存在する気がする。

genericを高機能化する方向へ行けば、最終的にはfunctionとgenericの統合だろう
し、そういう言語も面白いとは思う。だけど、それはCommon Lispではないよね。

>>147
>> 〜をやめろってことじゃない？
> これの言い回しの意図が不明だけど
これは
> CLOS的な発想とは何か？
の話ね。
これが全部じゃないけど。

> 違和感
シミュレーションか何かで「磁石と鉄がくっつく」を表現したいとき、
「くっつく」メソッドは磁石と鉄とどちらに属するべきか、とか。
addメソッドは数値オブジェクトに属するべきなのか？とか。

マクロである程度のことができるのに、
なんで原型にこだわるのかわからない。
マクロ嫌いですか？

これは俺の考えだから、別に誰かの考えを否定するつもりはないけどさ、
やっぱり、こういう疑問は｢メソッドがクラスに属してる」って考えから
抜け出せてないんだろうと思う。
それは、“普通の”言語からLispに移った時にやった考え方のシフトを
もう一度してくださいってことなんじゃないかと。

もっというと、引数の数とかを変えたいって言うのは、それはJavaとかの
シンタックスシュガーにどっぷり寄りかかっているだけで、Java的にも、
あんまり引数をガラっと変えるならメソッド名を変えるべきじゃないかと
思うけど(一部の、本当に汎用的な、半分言語仕様になってるようなメソッドは
除く)。Javaではデフォルト引数が使えないから、そのためにオーバーロードを
使うべきかと。
（例えば、この引数は必要なければnullでいいよ、とか）

なんかJavaの話になったけど、つまり、引数をガラっと変えたいなら
メソッド名を変えれば良いし、多少省略したいなら&optionalを使えば？
ってこと。

>>149
俺もそれしか無い気がしたが、Common Lisperの間でそういうスタイルが
一般的だとかいう話は聞いたことがないので。
あと、一番俺にとって重要なのはタイプするのが面倒だとかいうくだらないこと。
>>151
マクロがあるからLispに興味あるんだが、
ありふれたことをするのにも、例えば、大抵の問題を扱うのに
メッセージ伝達モデルのほうがタイプ量減るからといって、
マイ言語の世界に突入しなきゃならんのはどうかと。
共通プロトコルが安定してないとJavaみたいな大規模なライブラリなんて
作れないでしょ。
総称関数で書かれたライブラリと
メッセージ伝達モデルのオブジェクトシステムで書かれたライブラリが
平気で混在してるのがある意味、理想的な状況にも思えるけど、どうかな？
そんなのおぞましいって思うかな？

俺、ちょっと論点はずしたかな？
パッケージ内で偶然バッティングするケースもあると思うけど、
「同じパッケージ内でも気にしたくない」ってのは、ちょっと
どうかと思うけど。気にしろよ、とか思う。

ってか、プログラマが｢気にできる｣範囲に分割するのがパッケージの
役割なんだから、｢気にしたくない｣なら、さらに分割すべき

だけど、その制限が｢仕様として」どうか、ときかれれば、まぁ、
ちょっと恣意的な制限ではあると思う。

>>153
だから>>149で「メソッド名はクラス名をプレフィックスするなりして一意に」という
のはあくまで「極端な話」だってばさ。基本的には>>152氏も言っているように
同じ名称のメソッドは対象となるクラスが異なっても同じ機能を持つはずであって
同じパターンで引数を取るはずであるというのが設計思想の根底にあると思う。

あとは昔のbit別冊に載ってた記憶があるが効率の問題もあるかもしれん。

>>153
メッセージという特定のクラス系統に特定の意味を持つものにgenericな
名前をつけてしまうのがオブジェクト・セントリックな世界から頭を
切り替えられない人の敗因。

C++やJavaのメソッドの名前というのはあくまである対象固有の操作に
つける名前であるから、その一面を切り取って命名しているに過ぎない
(または名前がもつ意味の一面しかその操作が表していないとも言える)。
だから対象となる系統が変われば同じ名前の操作でも引数の数から何から
変わるということがおこりえる。それはメリットでもあれば統一した意味論で
全てのクラスを語れないというデメリットでもある。

generic functionは例えばC++のコンテナでpush_backというメンバ関数の
形式と意味論が共通に約束されているとか(イテレータの++や*演算子もそうだ)、
Ruby方面でいうduck typingに近い。
だから特定のクラス系統にのみ意味を持つものなら、それ相応に特定的な動詞が
思い付かないならそれを示すプレフィクスを付けるのが一番安全。
でなきゃパッケージで区切る。

あくまでbruteにメッセージ形式を持ち込みたいなら、メッセージと対応する処理を
定義するマクロを作って、あとはメッセージをsendする関数を作ってしまうのが
いいんじゃないか。
全体で合意できるのはレシーバとなる第一引数の存在くらいしかないのだろうから。

個人的にはC++にも(最近ではJava方面も?)Generic Programmingという概念は
入っているだろうに、なぜそっちからLispにくる人はそれを理解の一助とせず
無視するのかが理解に苦しむところ。

少し訂正。
> 入っているだろうに、なぜそっちからLispにくる人はそれを理解の一助とせず
> 無視するのかが理解に苦しむところ。

自分もC++やJavaからLispに入ってきた人なのだった。
なぜ114のような文句垂れる人は、にしておこう。

>156
>だから特定のクラス系統にのみ意味を持つものなら、それ相応に特定的な動詞が
>思い付かないならそれを示すプレフィクスを付けるのが一番安全。

それじゃCに逆戻りなんだよね……名前空間の便利さを知ると、とてもじゃないけど
やってらんない。関連性の高い関数とオブジェクトはセットで管理したいですな。

LISPでも名前空間の実装無いの？

>>158
その引用部分の直後に書いてあるけど、パッケージ。

>>158
だから、そのためのパッケージだべさ。

どーしても同じ名前で別な lambda list なメソッドを使いたいなら
(defun hoge (&rest args) ...)
で受けて手動ディスパッチすりゃいいんじゃねーの?
処理系によっては defmethod するより typecase で分岐の方が速かったりするし。

愚痴ってる連中はまず自分で理想のオブジェクトシステムを定義してみろよ。
で、それを実装してみればいいじゃないか。

>159-160
なるほど。

パッケージの名前解決ってどんな感じ？（C++みたいに）引数の型の定義に近い
メソッドを検索して持ってくるの？それともやっぱりパッケージ名で修飾しないとダメ？

>個人的にはC++にも(最近ではJava方面も?)Generic Programmingという概念は
>入っているだろうに、なぜそっちからLispにくる人はそれを理解の一助とせず
>無視するのかが理解に苦しむところ。

そんなの簡単。そっちも理解できないから。
そして自分の頭に既にある図面(しかも半端な)にあてはめることでしかものを理解できない・しようとしないわけさ。

ここんとこC++でいやいや仕事させられてるんで変なライブラリとかも見る機会が
あるんだが、BOOSTとか見ると何であんな複雑怪奇なことをしてGeneric Programmingに
取り組んでいるのか理解に苦しむ。素直にLisp/Scheme使えばいいのに・・・
アレは理解できない・というよりしたくない。エラーメッセージもわけわからんし、
修正→コンパイル→デバッグのサイクルに費やす時間が異常に長いしで不毛なことこの上なし。

>>165
確かに boost の lambda は笑った。すべてをコンパイル時にやろうという
C++ の執念は凄いが、実用性は？だよね。

全てはUNIX/Cの呪縛

C言語って現代的な高級言語からみた機械語

Cは遥か昔から高級アセンブラと呼ばれてますが何か？

はあ、それが何か?

>>156は人の話を聞かずに言いたいことばかり言っている。
>>だから特定のクラス系統にのみ意味を持つものなら、それ相応に特定的な動詞が
>>思い付かないならそれを示すプレフィクスを付けるのが一番安全。
>>でなきゃパッケージで区切る。
だから、そうするしかないねえ、という話をすぐ上でしている。
そして、俺はそれすら 面倒 だという下らない話をしてるんだよ。
タイプ量が増えるからな。
CLOSのモデルに合わせてプログラムを書けないなんて話は
俺の最初の書き込み以降、誰一人していない。
逆にgeneric functionも必要/有用だと認める意見が多かった気がするがな。
ただ、多重ディスパッチを必要としないプログラムを書いてる限り、それは
タイプ量と考慮すべきことを増やすだけで、それが他のOO言語に慣れた人間には
納得のいくトレードオフに思えないことは結構多いんじゃないか？
そもそも、Gaucheに無い制限を持つCLOSの話題から始まったことも忘れるなよ。
RubyやPythonから今のオブジェクトシステムを除いて、
CLOSだけを加えたらどうなるか考えてみろよ。
俺の普段の仕事には多重ディスパッチなんかより、
Rubyみたいな属性アクセスの抽象化と実際のアクセスを
少ないタイプ量で(マイ言語の世界も構築せずに)できる機能のほうが全然重要だったりする。
っつーか、たまにそういう要求に出会ったら、それこそ
自分でディスパッチの仕組みを作ったっていいんじゃないかと思ったりもする。
そういう場合、対象の集合が持つ性質は多分、かなり予期・コントロールできると想像する。
つまり、その集合、その問題に特化したディスパッチシステムを作るのは容易な可能性が高い。
だけど、無引数のget-hogeを定義したあとで、なんらかのキーを引数に要求する
get-hogeを継承関係にすらない異クラスに追加したくならないか、
なんて予期できないんだよ。

ちなみに俺はCLOSの制限でイラついてるCommon Lisperはあまり居ないらしいっていう
統計的情報(?)を聞けた時点で、ほとんど満足なわけだが、156みたいなアホがいるから
反論したくなる。
メッセージ伝達モデルを欲しがる人間をあからさまに馬鹿にする態度が気に食わない。
CLOSなんて唯のライブラリでLispの本質じゃないのにさ。
Paul Grahamのエッセイを読んでみろよ。
クロージャ詰め込んだハッシュなんて、まんまメッセージのレシーバじゃないか。

申し訳ないが、今忙しいので長い文章は読めない。
ごめんね。暇になったら必ず読むよ。

>>171
あんまり重要じゃないところに突っ込むけどさ、Paul Grahamも、
Common Lispが、"タイプ量"的にまずいってことは認めてるし、
まぁ、欠点は欠点として認めるとして、
タイプ量をケチるなら、それなりのエディタを使うとか、
そもそもCommonLispは使わないとか、そういう方向になるんじゃ
ないのかな？
タイプ量からCLOS批判するのは少し納得がいかない希ガス。

CLOS ってようするに、あんまり役にたたんということか。
dispatch だけだったら CLOS なしでも大差ないだろ。
それとも optimize とかが何か違うのか。

> メッセージ伝達モデルを欲しがる人間をあからさまに馬鹿にする態度が気に食わない

>>114、>>116 あたりの自分の態度を見直したほうがいいよ…。
同じ Gauche 使ってる身としては、Common な人々は心が広いなーと思た。
残念だろうけど、どっちかというとアホなのは 156 じゃなくて 114 だと思うよ…

Beyond Java?
http://www.functionalobjects.com/resources/beyond-java.phtml

結局、generic programmingを理解しようとせずに、元から考え方の違う道具で
自分のやり方が実現できないと文句言ってるだけの人だったね。
Haskellは変数を破壊的に変更できないから使い物にならん、というのと同レベル。

ついでにいうとgeneric functionのlambda listが合同なのはgeneric function
っつーくらいだから本来当たり前の話で、
Tiny CLOSでlambda listが違っても使えるってのの方が単なる余録。

誰か >163 にコメントを……
いくらパッケージで分割できるつうても、自動的に名前解決してくれないんだったら
プリフィックスと同じで不便なことには変わりないなぁ。

というか、おまいら名前空間・generic programming・メッセージングその他もろもろを
ごっちゃにしとらんか？傍目からは疑似問題起こしとるような気がしてならんが……

どちらかというと、ごっちゃにしてるというか理解してないのは君。
156を理解せずにかろうじて食いつけるところだけ食いついてみた
という感じだけど、元々理解できてないから完全に見当外れ。
だからコメントもつかない、つまり相手にされてない。

何か必死なやつが一人いる予感...

元のテーマも忘れかけてそうだよね

>>179
ttp://user.ecc.u-tokyo.ac.jp/~t50473/onlispjhtml/packages.html
検索くらいしる。

・Lispの型は値に、C++の型は変数名にくっついている
・CLOSのgenricは実行時、C++のgenericはコンパイル時にメソッドが選ばれる
・CLOSのmethodはオブジェクトに属さない
この辺ちゃんと理解してる？

CLOS の method はスパーンと切り込むキラーパスのようなイメージ。
レシーバを規定する method は鎖で繋がれたペットみたいなイメージ。

昔、湯浅先生の本とともに、DOS版のTUTSchemeっていうのを買って
使ってたのを思い出して、ググってみたら今でもあるんですね。

ttp://www.yuasa.kuis.kyoto-u.ac.jp/~komiya/tus_intro.html

UNIX版を落として使ってみたら、ﾃﾗﾅﾂｶｽ

ちょっと遅いけど、いろんなプラットフォームで動くし、
エディタついてるし、お勉強用には良いかも。

tusとかmtusとか、cmtusとかstusとか作れるみたいだけど
違いはなんだろ？

RubyがLispの良い点を継承しているので、「受け入れられる」Lispになるかも
しれないという話。
http://www.rubyist.net/~matz/20051205.html#p02

元のblogは読まずにmatzのブログしか読んでないんか。

>>186
Lisperから見ると、良い点の大半を捨てたように見えるんだけどな。

Rubyはいい言語だと思うが、acceptable LispというにしてはLispから
かけ離れすぎてて無理があると思う。
Lispにない利点もあり、Lisperにも(どの言語にもあるような機能の範囲では)
ストレス少ないので、
more acceptable (かつ、いくつかの面ではmore comfortable) than Lisp
ではあると思う。
関数型的な利用にはあんまり向かないよね。
思考の枠組みとしてはLispより狭いけど、まあそれで十分なことも多い。

よしキラーアプリ作ってLispの王国を復活させるんだ！
…と思ったけどmatz氏が良い指摘をしてるね。
一般人(悪い意味じゃないよ)ってのは抽象化になれてないんだろうな。

普通の人がわかる抽象化ってのはデータ型とかくらいでしょう。
アルゴリズムの抽象化なんかは関数型言語をやったりLispを使い慣れたりしないと、
あまり理解できないか、少しわかっても難しく感じるだけで
有り難みやかっこよさを感じるところまでいかないと思う。
せいぜい高階関数いいね、止まりじゃないかな。

抽象化ってのは突き詰めれば自然数みたいなプリミティブなところに行き着く。
先の見えない世界が延々と続いているような恐ろしいものを想像してる人が
たまにいるが、それは違うと思う。

自然数は抽象化によって捨象される側じゃないか。

抽象化を突き詰めるたら群とか環とかそっちに行くだろ。

そして記号で記述できないほど抽象化されたシステムが誕生する。

数学好きとLisp好きは相当被ってるよな。
Lisperにとっても誰にとっても抽象的なものってのは
難しいものだと思う。
だけど、一旦分かると格好良い！とか美しい！
と思うのがLisperや数学好きな奴だな。

というより、抽象化されたレベルで単純な言語だから、暗記しなけりゃいけないことが
少なくて楽なんだよね。Perlなんて一見楽そうだけど、覚えておかなきゃいけないこと、
注意しなくちゃいけないことが不規則に多すぎて神経衰弱しちゃう。

注意しなくちゃいけないことが不規則に多すぎて七並べしちゃう。

注意しても無駄なことが不規則に多すぎてババ抜きしちゃう

>>198-199
…

以下、何事もなかったよーにLispの話題ドゾー↓

(let ((r (hoge)))
(foo)
r)
を楽に書けるマクロってあったりする？

(prog1 (hoge) (foo))

prog?のネーミングセンスってどうよ？

きくまでも なかろうよ！

もしWindowsのAPIみたいな名前だったら、と想像したら、
現状が素晴らしく思えてきます。

http://www.cs.helsinki.fi/u/jesnellm/blog/archive/2005-12-11.html
SBCL on Windows

進展があったみたい

おおすげー

で、どうやって動かすんだい？
C:\sbcl-win32-0.9.6-binaries>sbcl
fatal error encountered in SBCL pid 4032:
can't find core file

coreファイルあるのに読んでくれないや。

と思ったら
環境変数SBCL_HOMEを設定したら動いたよ
set SBCL_HOME=C:\sbcl-win32-0.9.6-binaries\

C:\sbcl-win32-0.9.6-binaries>sbcl
This is SBCL 0.9.6, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.
os_map: 3, 0x1000, 01000000, 0x1000.
os_map: 3, 0x2000, 05000000, 0x1000.
os_map: 3, 0x3000, 09000000, 0x17ce000.
Your Kitten of Death awaits!
*

これでいいのかい？

つーか
sbcl --core sbcl.coreで逝けたよ

すげー
ちょー速い
こりゃネイティブコンパイルだね
Windowsでこんだけ速いのってフリーじゃなくね？

SBCL ON Windows　確かに早い！
以前（ずっと昔）このスレで速さ比べが載ってて
CLISPのコンパイル後より
Petie Chez Scheme のVMが速いとあったが
SBCL ON Windows には足元にも及ばないぞ。
シェル上で動いてる、って事はVMじゃないのか？

>>209
JITじゃね？　と、いいかげんなことを言ってみるテスト。

普通にネイティブコンパイルだよ… disassemble 試してみれ。

SBCL は暗黙的にコンパイルしちゃうからね
http://www.sbcl.org/manual/Compiler-only-Implementation.html

さっきはじめてgauche使ってlispを触ってみた。
今までは実行せずに「リスト遊び」と「SICP」を読んでただけ。
で、「コマンドライン引数に指定されたファイルを印字する」スクリプト
書いてみた。(関数名変かもしれんが気にしないでくれ)

(define ret_data (lambda (fname)
  (port->string-list (open-input-file fname))))

(define print_forlist
  (lambda (x)
    (if (not (null? x))
      (and
        (print (car x))
        (print_forlist (cdr x))
      ))))

(define main
  (lambda (env)
    (if (not (null? (cdr env)))
      (and
        (print_forlist (ret_data (car (cdr env))))
        (main (cdr env))
      ))))

gauche使いな偉い人達はどういう風に書くの?

(define (main args)
  (for-each (lambda (f)
              (call-with-input-file f
                  (lambda (p)
                  (display (port->string p)))))
            (cdr args))
  0)
かな？

(use file.util)
(define (print-file f) (print (file->string f)))
(define (main args) (for-each print-file args))

>>214-215
す　すげー

displayとかfile.utilとか気になりまくりだ
さっそく調べてみよう。ありがとう。

> (define (main args) (for-each print-file args))
これは
(define (main args) (for-each print-file (cdr args)))
か。すまそ。

文字列を介さないで copy-port すべき。

(use file.filter)

(define (main args)
(for-each (cut file-filter copy-port :input <>)
(cdr args))
0)

最後の0は何？

優しさ

srfi-22を見れ。

>>22
こんなの決まってたんだね。
ttp://members.at.infoseek.co.jp/zzyyb/srfi/ja/srfi-22/srfi-22.html

#!は先頭行以外では別の意味に使っていいのかな。

WiLiKiだかどこだかにSchemeコードを書くためのelispの設定を築き上げるための
叩き台をGaucheに含めると書いてあったと思うのですが、該当するコードが含まれて
いるのはどのリリースですか？CVS HEADも覗いているのですが見当たらないので
ご存知の方いましたら教えて下さい。

>>224
Gauche-devel-jp ML あたりで聞くほうが良いと思う。

PLT Scheme が v300 に上がったので一応貼り。
これが 300 系統で最初の正式リリースってことになるのかな。
win 版だと msvcr71.dll が必要になるそうなので注意。
http://download.plt-scheme.org/drscheme/

Chez Scheme(Petiteも含めて)も7.0aが出てますよ
DrScheme(PLT)のエディタで書いて、
Petite Chez で動かすのが一番かな?
･･･OSがWindowsですから。

質問させてください。

(define a '(1 + 2))

として、

((car (cdr a)) 1 2)

として、3 が出力されるようにしたいのですが、(quote +) を
primitive の＋に変換する方法はありますか？
little schemer のソースでは、全部 cond でスイッチケースしてた
んだけど・・・

eval

>>229 THX!!
((eval (car (cdr a))) 1 2)
でうまくいきますた

Y combinator って何に使うの？理屈はわかるんだけど
実用面ではどんな風に応用されてるのかさぱーりわからん

そりゃ意味論の話だから。

>>231
たまには意味あるんじゃないか？
名前空間を汚さずにラムダ式だけで計算できるから
実例は知らないけど…

>>231
for-eachとかcall-with-*とかに再帰的な手続きを渡せたりとか。

letrec使えばいいじゃん。

>>231
コンパイラ作る時に使うとか

http://luisguillermo.com/PL_ega.gif
ちょｗｗｗｗｗ LISPｗｗｗｗｗ

>>237
何を表現してるのかさっぱりわからんｗｗｗｗｗ

http://www.yuasa.kuis.kyoto-u.ac.jp/~nobu/study/palm/chap2.html
ここの2.6に書いてある、ダイナミックヒープ中の一時的なビットベクタを使う
とはどういう意味なんでしょうか。
どこがマークされたか保存しておいて、スイープの時に照し合わせるんでしょうか?
だとしたら滅茶苦茶時間かかると思うんですけど。

リストにネイティブなポインタを使うと下位2ビットしか使えないんですが
そこをGCのフラグに使うのが一般的なんでしょうか?

それともポインタの代わりに配列のインデックスを使った方がいいんでしょうか?
これのやり方がいまいち良く分かりません。

対象ポインタ中にmark bitを取るとmarkするだけでそのページが
dirtyになるから、incremental gcとかが面倒にならんかな。
まあ、write barrierの実装方法にもよるし、ケースバイケースだね。

>>237
とりあえずBASICは前科者

あとFORTRANは怒らせないほうがいい

>>239
src/store.c読め。
markBitという変数がビットベクタ。
わざわざLispMeのソース持ってきて調べちゃったじゃないか。
ちなみにセルはインデックスになっていた。
これのメリットはフラグビットが多く取れる事、永続化する際に
アドレス変換しなくて良い(そのままfwrite/fread可)といった点。

>>242
読まずに質問してすいません。
マークビットにインデックスで直接アクセスするので、余計な時間はかからないんですね。
フラグビットが多く取れることやダンプが簡単なことはとっても魅力的なんですけど
メモリの無駄が多いことと、いっぱいになったときに reallocするのが重そうなので
なんだかためらってしまいます。
reallocしない方法も考えられますが、生きてるセルの間が大きくなったりしたら
困る気がします。

ヒープが小さいんだからたいして困らん。

>>244
それは Palmの場合ですよね。
LispMeではヒープのサイズは固定ですが、一般にはヒープサイズを可変にした方が
いいと思ったので。
言葉足らずですいません。

CL でも Scheme でもないけど、xlispstat の本が出たみたい

http://www.kohgakusha.co.jp/books/detail/4-7775-1180-4

うっ、微妙だな…目次みた感じだと、まだ統計を習ってない（かつ R とかにで
あってない）人の入門向けってとこかな。高校生くらいには丁度いいのかも。

まぁ、せっかくここまで揃えた Lisp 本コレクションが欠けるのも悔しいので
買ってしまうんだけどね…。

高校生ですが、その本の
「計算機科学の方面では『λ算法』とかいうものがあると聞きますが、
詳しいことは筆者もよく知りません」
という記述はどうかと思いました。

CS 専攻じゃなければ名前だけって人も多いだろう。
計算モデルを知らなくても使えるからいいじゃん。
無意味にしったかぶりするよりは好印象。

でも本に書くなら調べて簡単な註釈なりリファレンスなり示しとけと。

工学社の本なら「筆者もよく知りません(笑」でなかっただけマシだろ。
あそこパソ通時代のノリそのままの半可通本が多いわけだし

ＣＳ専攻（だった。10年前）でもλ算法知りませんが何か？

たしかに、λ「算法」は聞いたことないなあ

無知を自慢するなよ

λ...
　ﾄﾎﾞﾄﾎﾞ

>>254
「無知の知」という言葉もある。
知らないことを自覚しているのはただ知らないよりもマシではあるまいか。
無論、知っている方がよりよいが。

ああ、λ算法ともいうのか。。
今検索して初めて知った。

lambda calculi

むちむち

ラムダ算法騎士団乙

この無知の行進に驚いてしまった自分は古い人間なんだろうか。


# ま、数学基礎論専攻だったので知ってるのは当たり前なんですが

>>261
そんな事はどうでも良いから、Lisp の話題を振ってくれ。

bSI１

これだけの無知っぷりだと、話題を振るのもためらわれます。

ほぉ

L Sharp (Lisp for .NET) の新版がでましたね．Scheme でも Common でもない
けどがんがってほしい．原理主義者ではない俺は気にしない．

LISPの運勢

安い……

Schemeの運勢

λ算法なんてLisp/Scheme使いでも知ってる人間のほうが少数では？
そりゃ「名前くらいなら聞いたことが」って人間は大半だろうがその数学的な概念をきちんと理解している人間が
どれくらいいるってんだよ。

きちんと理解してない人間がLisp, Schemeを語るなんてありえない。
ここもレベルが下がったな。

レベル高かったの？ここ。

餌
http://en.wikipedia.org/wiki/Lisp_programming_language
http://en.wikipedia.org/wiki/Scheme_programming_language
http://en.wikipedia.org/wiki/Programming_paradigm
http://en.wikipedia.org/wiki/Foundations_of_mathematics
http://en.wikipedia.org/wiki/Lambda_calculus

>>272
ム板でも指折りの高レベルスレ

>>271
一応わかっている（つもりの者）だが、
Lisp Scheme のどの辺の知識を知るのに
わかっていないとありえないとおっしゃるのかな

初心者ですが
(car . ((quote . ((20 . (10 . NIL)) . NIL)) . NIL))
これを評価する場合、
→(quote . ((20 . (10 . NIL)) . NIL))
→(20 . (10 . NIL))
ときて、なぜ
→((20 . (10 . NIL)) . nil)
となって
答え：(20 . (10 . NIL))
にならないんですか？
？？(･∀･)何か勘違いしてる...？

意味不明。
どういう式を評価してみたのか、自分が入力したものをそのまま載せてみ。

式は
(car . ((quote . ((20 . (10 . NIL)) . NIL)) . NIL))
これです
(car '(20 10))
これをドット対に直してみて
(car . ((quote . ((20 . (10 . NIL)) . NIL)) . NIL))
となったんですけど
頭で考えると>>276で書いた手順で答えが
(20 . (10 . NIL))
になっちゃうんですけど実際に評価してみると
20
となります。
根本的なところで勘違いしてる悪寒です。。。

>>278
最初に言っておくと、評価プロセスを学ぶ上では、
データ構造としてのリストのドット対表記は使う意味が無い。

(car '(20 10)) を順に辿っていくと、
まず評価のはじめとして、関数とその引数が全て評価される。
特殊形式のquoteもこの時に取れる。

　car => #<function car>
　'(20 10) => (20 10)

#<function car>とは、シンボルcarに束縛された関数そのものを指す。
そして、ここまでの評価の中間結果として以下が得られる。

(#<function car> (20 10))

最後に、リスト先頭の#<primitive car>が(20 10)を引数として関数適用され、
その結果として20が返却される。

最後のは#<primitive car>じゃなくて#<function car>の間違いね。
この#<〜>という表記の仕方は処理系によって変化する。
例えば#<primitive car>だったり#<closure 00abcdef>など。
ちなみに評価器で#<〜>と出力されるオブジェクトは基本的にreadできない。

>>279-280
新年早々ご親切にありがとうございました。

() と '() について質問させてくらはい
(cons 1 ()) -> (1)
(cons 1 '()) -> (1)
どちらも一緒ですよね
だから構文解析するときどちらも nil として
返すようにしているのですが、問題でしょうか？

write readしてequalで一致しなかったら、
悲しいと俺は思う

>>282
(consp ()) => NIL
(consp '()) => NIL
(consp ''()) => T

'()と()が同じになるってことは''()と'()が同じってことで、
つまり''()と()は同じってことになる？
やっぱ問題あるような気がするけど。

>>284
なるほど、''() は pair ですよね、(eval ()) と (eval '()) が
ともに () だからといって、一緒くたにしちゃだめですね、なんか
ぼけてました。

>>284
同じではなく NIL というシンボルの変数としての値が NIL だというだけ。

>>3
URL 変わってた。次にスレ立てする人は気をつけてちょ。

慶應の授業のページ・記号処理プログラミング 2005
http://web.sfc.keio.ac.jp/~t02064si/lisp2005/

;; GCL 使ってんのね。2006 の講義では SBCL の Windows 版が使える頃じゃないかな。

素朴な疑問なんだけど (concatenate 'string "foo" "bar") は、何で
(concatenate "foo" "bar") や (concatenate-string "foo" "bar")
じゃないんだろう。実際は誤差の範囲だとしても、パフォーマンスペナルティ
が気になる。マクロでもないみたいだし。歴史的な理由かな?

>>288
処理系によってはcompiler macro定義してるから、typeが定数なら
パフォーマンスは気にしなくていいんじゃね? Allegroで試したら
string専用の内部関数の呼び出しにコンパイルされてたよ。
仕様としては、中途半端にジェネリックなところが気持ち悪いと思うが。

中途半端にジェネリックってのはまあ、歴史をしょってるから仕方ないんじゃね。

>>289,290
ありがとうございます。Allegro ではマクロになってるんですね。
自分が使ってるコンパイラをもう少し調べてみます。

最古のScheme処理系ってなんだろな

>>292
SussmanとSteeleが1975年頃に最初の処理系を作ったと言われている。
当初"Schemer"という名前で計画されていたが、そのとき使用したITSというOSの
ファイル名が6文字までだったために"Scheme"という名前になった。

>>292
SussmanとSteeleの論文(MIT AI-memo 349, 1975)に全ソースコードが
載ってるよ。実装言語はLISP。今のSchemeとはちょっと趣が違う。
で、たぶん2番目に古い処理系はSteeleによる最適化コンパイラRABBIT。
その後SteeleはSchemeチップの設計もやってる。
全部オンラインで読めるよ。
http://library.readscheme.org/page1.html

その後SteeleはJavaの設計にも携わってるんでしょ。
すごい人だなー。

Steele は色んな所に引っ張り出されてるよ。
CL は勿論、ECMAScript とか C とか。Java の後は Sun で Fortran の研究してたような。

>>293-294
あざーっす

>>296
今のお仕事は Fortress だね。
http://research.sun.com/projects/plrg/fortress0785.pdf
って lisp に関係ないけどな。

そういうことに詳しいおまいらも凄いよ
院生？

いや、本人だから。

Steeleさんはコンピュータ言語だけでなく、
自然言語にも精通していらっしゃるのですね。

>>287
さすがに SBCL Win32 port がそんなにはやく安定するとは思えん．つか
CLISP でいいじゃんな．どうせなら ANSI CL 準拠のほうがいいと思うがなぁ．
GCL は配布物でかいし，本家の配布物ってまだ ANSI 互換モードがデフォじゃ
なかったような．

単に動けばいいのなら、CLよりSchemeのほうがよくない？
CLISPよりPetite Chez Schemeのほうが・・・
エディタならDrSchemeあるし。
あくまでWindows環境なら、って話ね。
WindowsでLISPでとなればSBCLははずせないんじゃないの？

…いや CL の授業なんでないの？開発環境としては LispWorks Personal とか
Allegro CL のがいいような．インストールメチャかんたんだし，統合開発環境
こみだし．LispWorks Personal なんか授業で使うならいいと思うけどねー．

SBCL Win32 port は現段階，マージがはじまった段階で，そのあと残りの
ToDo を片づけていくっつーレベルなんで SBCL Win32 は Lisp マニア以外には
敷居高杉．すくなくとも 0.9.8.x のうちは授業で使う環境の選択肢には入れちゃ
ダメ．だから開発者もまだ実用は無理とゆってるのわけで…

#!-win32 だらけだしなあ。
まだ sbcl-devel #lisp 参加者以外が使ってもしょうがないだろ。

Schemeのsyntax-rulesと似たようなものを作ってみたいのですが、
不勉強なもので、よくわかりません。
gaucheのソースとか見てみたのですが、さっぱりで、、、。
macro.cあたりにまとまって書いてあるようなのですが。
パターン言語とかいうらしいのですが。
よい参考資料などありましたら教えてください。

>>306
syntax-rulesで難しいのはむしろ健全性の方だと思うが、
パターンマッチが知りたいんだよね？
繰り返し (...) を除けばパターンマッチはそんなに難しくない。
アルゴリズムの入門書あたりに出てないかな。
健全性の方はWill Clingerの論文Macros That Workがいいよ。

アルゴリズムの入門書の書名を具体的に教えて。勉強したい。

>>307
ありがとうございます。

まずは、パターンマッチから知りたいところです。
自分で調べてみて、xyzzy lisp programmingの
common lisp入門を読んでみてます。

http://www.geocities.jp/m_hiroi/xyzzy_lisp/abclisp22.html

SICPにも書いてあるようなのですが、難しく感じてしまって、、、。

健全性の方はWill Clingerの論文Macros That Workがいいんですね。
探してみます。きっと英語なんでしょうねぇ。先は長い。。。

on lispの翻訳
ttp://user.ecc.u-tokyo.ac.jp/~t50473/

知らんのだ。すまん。>>308
効率良くするのは難しいが、原理は簡単なんで、
入門書のアルゴリズムの練習問題にありそうだと思っただけ。
ざっと説明すると、パターン言語は(1)入力とパターンのマッチをかけて、
パターン中のパターン変数と入力との対応づけをつくる、(2)成功したら
テンプレートを走査してパターン変数を入力に置き換える、ということを
やってるだけだ。(続く)

で、とりあえず単純なマッチと置き換えのコードを示しておくから
後は好きに拡張してくれ。シンボルは全てパターン変数として扱い、
シンボル以外のものは考慮してない。

(define (match template input)
(define (walk template input binding succ)
(cond
((null? template) (and (null? input) (succ binding)))
((symbol? template) (succ (acons template input binding)))
((pair? template)
(and (pair? input)
(walk (car template) (car input) binding
(cut walk (cdr template) (cdr input) <> succ))))))
(walk template input '() values))

(define (subst tree binding)
(cond
((pair? tree)
(cons (subst (car tree) binding) (subst (cdr tree) binding)))
((and (symbol? tree) (assq tree binding)) => (cut cdr <>))
(else tree)))

gosh> (subst '(d c b a) (match '((a b) (c . d)) '((1 2) (3 4 5))))
((4 5) 3 2 1)

>>306
こないだC#で実装した（我流で）。
(define-syntax m (syntax-rules () ( (_ "constant" a (b (c ...)) ...) (a x (1 b ...) (c ...) ...))) というマクロがあり、
(m 1 (2 (3 4 5)) (a (b)) (x ())) というパラメータが渡されたとする。

マクロを解析すると、
パターン部は
((const "constant") (param a) (... (param b) (... (param c)))) というツリー構造になり、
テンプレート部は同じく
((param a) (var x) ((const 1) (... (param b)) (... (... (param c)))) となる。

パターンマッチはパターン部とマクロのパラメータを再帰的に比較すればよい。

適合するパターンが見つかったら、パラメータとパターンから
a:level0 data:1
b:level1 data:(2 a x)
c:level2 data:((3 4 5) (b) ())
という表を作り（このへんはGaucheのコメントを参考にしたような）、それをTemplate部に適用する

(param a) → テーブルからaの値を引いてくる。1を生成
(... (param b)) → ...（これの正式名称なんだっけ？）が出現したら、前述の表から……どうするんだっけ？
いま手元にソースがないので忘れたが、
b:level0 data:2
b:level0 data:a
b:level0 data:x
という3つの表を順番に生成して(param b)部に適用。
ネストした...も同様に再帰的処理して生成。

>>311 >>312
ほー。すごい。
schemeは素人なので、すぐわからないのですが、参考にさせてもらいます。

(subst '(d c b a) (match '((a b) (c . d)) '((1 2) (3 4 5))))
の意味は
((1 2) (3 4 5))を((a b) (c . d))にマッチさせて(d c b a)に変換するってことですよね。
((1 2) (3 4 5))は((4 5) 3 2 1)に変換されてると。
matchがマッチしたものを返して、substはmatchした結果を使って置き換えしてると。

ありがとうございました。

はいじにっくのほうだが、マクロによって生成されたシンボルにユニークなキーを付加してどうにかした。

(m1 a) → (m2 a x)
(m2 a b) → (let ((a 100)) b)
というマクロにおいて、

(m1 x) → (m2-1 x-0 x-1) → (let ((x-0 100)) x-1)

パターンマッチに興味があるなら Unification で検索しる．
Common Lisp の cl-unification ライブラリのマニュアルと実装も参考になるお．

UnificationならPrologだな

でもここじゃ双方向unificationは必要なかろう。

>>313
いろいろ、具体的な解説ありがとうございます。
まだ、わかっていないのですが、参考にさせてもらいます。

>>315
その説明は考えてみても、よくわかりません。
(m1 a)を(m1 a x)と展開するマクロなのであれば、xは外のスコープから
データを持ってくるものなのじゃないかと思うので、
(m1 x)→(m2 x x)って変換されていい気がするのですが、、、。
(m1 b)→(m2 b x)なのですよねぇ。

はいじにっくのほうは、
マクロを呼んでいるスコープ内で使われている変数や関数名と
名前がぶつかった場合は、例えばxがぶつかったのであれば、
x-0などと言った風に名前をユニークにしてあげればいいって考えてました。

>>316 >>317
Unificationはとても面白そうなのですが、
マクロを作るのにはそこまで必要ではなさそうなので、
後で挑戦してみようと思います。

Schemeって対話環境とファイルを読んで実行する場合とあると思うんですが、
ファイル読んで実行する場合、トップレベルの defineはあらかじめ分かるので
全体が letrecに入っている風に解釈してもいいでしょうか?
検索が必要なくなりますし、set!が無ければもっと最適化できそうな予感がするので。

後からloadとかevalによる環境の置き換えを許さないのならね。
Stalinはそれを前提にプログラム全部を読み込んで最適化をかけるので
出てくるコードは激速らしい。

あと、
(define (f a b) (+ (g a) b))
なんて行があったとして、gがこの行以前に束縛されていて
この後変更されないことが保証されていれば最適化ができると思うのです。

(define (a f) (lambda (b) (f (+ 1 b))))
(map (a func) l)
なんて時は(a func)の返り値は実行時にコンパイルするんでしょうか?


手続きを束縛するシンボルを破壊的に操作することって
ほぼない上に最適化の邪魔になるからとても嫌なんですが。

>>321
そうなんですか、あんまり一般的な最適化じゃないんですね。
loadは...手続きなんですね。#includeみたくマクロだったら良かったのに。
(eval '(define a e) (interaction-environment))
なんてしたらトップレベルが汚れちゃうんですね。こんなの使わないのに。
Schemeのなんでもありって仕様が最適化の邪魔になってる気がしてます。

>>322の「実行時にコンパイル」は「実行時に最適化」の間違いです。

最適化のために仕様を逸脱します、てのは実装としては
ありなんじゃないかな。動作さえ明確に定義できれば。

>>317
あれは組み込みでは…
でも Prolog はバックトラックも組み込みだしちょっと面白みがねー．
もっと別の探索手法がつかいたいとか，そーゆうレベルでいじりたいと
結局 Lisp で作っちゃうんだよな

>>319
(m1 a) → (m2 x a)
(m2 a b) → (let ((a 100)) b)
とゆうマクロがあったときに、(m1 x) → (m2 x x)と展開するとどうなるか。
(define x 200)
(define y 200)

(m1 x) → (m2 x x) → (let ((x 100)) x) → 100
(m1 y) → (m2 x y) → (let ((x 100)) y) → 200

はいじにっくじゃない！！！！！！ひどい！！！！
というわけで、「外から渡されたもの」と「自分のテンプレートにより生成されたもの」は区別しなきゃいけないのよ。

>>326
＞なんて時は(a func)の返り値は実行時にコンパイルするんでしょうか?
んなわけない。グローバル最適化とか考える以前にクロージャを含む言語の
コンパイルについて勉強すべし。

＞手続きを束縛するシンボルを破壊的に操作することって
＞ほぼない上に最適化の邪魔になるからとても嫌なんですが。
目的による。Lisp系言語の場合、インタラクティブな開発時には
ひとつの関数定義を修正してリロードして、というのを繰り返すから、
グローバルな手続きが再定義できるのは便利でもある。
デバッグが済んだ段階で「全部constantと考えて最適化」という
オプションはあってもいい。

ただ、歴史がある商用のLisp処理系でさえそういうことを重視してないのは
何故だかは考えて見る必要はあるだろうね。
単なるインライニングくらいじゃそんなに速くならないんよ。
型推論して実行時型チェックを減らせるとかなり効果があるけどね。

改行が多すぎますって言われて全部消えた...

>>327
>んなわけない。グローバル最適化とか考える以前にクロージャを含む言語の
>コンパイルについて勉強すべし。
内部でクロージャを生成し、それを返す、又は set!する手続きの場合
一般的に環境をスタックからヒープにコピーする必要があると思うんですが
あらかじめ以降の引数などをヒープにつくれば後の環境のコピーが省けるかなあ
と思いました。
リストが与えられた時に先頭がどういう手続きかあらかじめ分かっていれば
その条件分岐もいらないですし、組込みの手続きとの条件分岐もいらない気がします。
動的にクロージャが生成され((a func)みたいに)、変更されないことが保証された上で
何度も使われる((map (a func) l)みたいに)前にコード化すれば実行中の条件分岐が
なくなっていいかなあと思いました。妄想ですが。
SECDマシーンみたいのを想像しているので間違っているかもしれません。

>>327
>ただ、歴史がある商用のLisp処理系でさえそういうことを重視してないのは
>何故だかは考えて見る必要はあるだろうね。
>単なるインライニングくらいじゃそんなに速くならないんよ。
>型推論して実行時型チェックを減らせるとかなり効果があるけどね。
単なるインライニングならトップレベルを letrecに入れるだけなので
ほとんど変わらないでしょうね。
型推論は全体が letrecに入っていると思えばできるのかも。もしくは Scheme->Ocamlとか。
Ocamlの場合、関数定義のなかに未知のシンボルが現われるとエラーなので
インタラクティブに型推論ができるのかもしれませんが、Schemeだと難しそう。
また、
# let f x = x;;
# let g x y = x + y;;
# let h = ref f;;
# !h = g;;
This expression has type int -> int -> int but is here used with type
int -> int
となりますし。開発中とはいえ手続きの型まで変えることはあまりないと思いますが。

開発言語と実行言語に分けて、実行言語は制限つけて高速コードにコンパイルと
いう風にすれば Schemeが天下とれませんかね?

>>326
うー、わかったようなわからないような。

(m1 x) → (m2-1 x-0 x-1) → (let ((x-0 100)) x-1)
これが、
(m1 x) → (m2 x-0 x) → (let ((x-0 100)) x)
って話ならわかるような気がするんですが、、、。

scheme理解できてないからかなぁ。。。

例がよくわからないので、すいませんがcで書きますと

#define swap(a,b) {int tmp=a;a=b;b=tmp;}
int x = 1, y = 2; swap(x,y);
=> {int tmp=x;x=y;y=tmp;}　ＯＫ

int a = 1, tmp = 2; swap(a,tmp);
=> {int tmp=a;a=tmp;tmp=tmp;} だめ

となって、うれしくないのがはいじにっくでないと
で、その場合は
{int tmp1=a;a=tmp1;tmp=tmp1;}
として解決してくれれば、はいじにっくだとそういう話
以外に何かありそうなのですが、わからなくて、、、。すいません。

>>329
> 開発言語と実行言語に分けて、実行言語は制限つけて高速コードにコンパイルと
> いう風にすれば Schemeが天下とれませんかね?
それは CL っぽく色々 declare とかコンパイラマクロをぶち込むってのじゃ駄目なのん？

もう一個のスレにも書き込んだんですが、
gclでウィンドウを生成して線を描くようなプログラム
をどなたか教えていただけませんか？
お願いします。

いやです

>>329
開発はインタラクティブな処理系でやって、実行バージョンを
Stalinでコンパイルするとかやってる人はいるよね。
ただ、実行コードの速さってそれだけじゃあんまり訴求力が無いんだよね。

CPUのクロックだのキャッシュミスだのを削るような世界の連中は
大抵CかC++、時にアセンブラで仕事してて、Schemeなんて眼中にない。
流行のLLで抽象力を楽しんでる連中は、自分の言語がもう少し速く
なってくれたらとは思ってるけれど、実行速度だけが乗り換えの動機には
ならない(そもそも実行速度をあまり気にしないからその言語を選んだわけで)。

どっちのグループにも、少数ながら相手のグループの(速度|言語機能)を
横目で見ながらもなんらかの事情で自グループの言語を使わざるを得ない
連中がいる。めっさ速いScheme処理系を持ってけば、そういう連中は飛びつく
かもしれない。でも残り大多数は動かないだろう。

ひとつ突破口があるとすれば、めっさ速いScheme処理系をつくって、それで
流行のLLを実装することだ。結果がそのLLのデファクトの処理系より速ければ、
十分な乗り換えのインセンティブになる。乗り換えさせてから、「実は裏では
S式が動いててマクロだってほら自由自在〜」のように洗脳してゆくのだ。

>>334
チョムスキーが初めて生成文法を定式化したとき
まで読んだ。

もうちょっと読めばエロシーンに入るのに、馬鹿なやつだ。

LLって何すか

LL: Lightweight Language
VHLL: Very High Level Language

LL 発祥の地ってここ?
https://lists.csail.mit.edu/pipermail/ll-discuss/

こっちの方が適切だったか。

http://ll1.ai.mit.edu/

ll1-discuss には Guy Steele も顔を出してたよね。

LLでLLを書こう！みたいな・・・

>>334
Schemeでも C並に速くなるんじゃないかなあと思ったのです。
本当に速度を重視している人は「最速」以外には興味がないと思うので
Cとアセンブラ以外は眼中にないんでしょうが。

機能的には全ての LLは Lispの劣化版の様に思えるのです(Haskellなんかは別として)。
Rubyが Lispに近づけば近づくほど Lispでいいじゃんと思います。
しかし Lispより Rubyが流行る理由も分ります。
Schemeで字句上、リストに従わないものは ' ` , ,@ くらいだと思いますが
ここら辺を拡張する、もしくは拡張できるようにすると Object.method(arg)を
(method Object arg) や (Object 'method arg) みたいに変換できるんじゃないかと
思います。それに Packageがあれば最強じゃないですか。
まあ他の言語を構文木をいじれるようにしても同じですけど。

Ocaml は不動点演算子を定義できない気がしてたんですが、できるみたいですし
Lispにできて Ocamlにできないことがよく分からないです。
Ocaml のマクロ(camlp4)は全然知らないですが。

> まあ他の言語を構文木をいじれるようにしても同じですけど。

今年はコレが来ます

どれ?

>>342
Openコンパイラって知ってるか？





流行らなかったなー。

流行らないからダメだよねー

捨て捨て

>>341
いくつかのSchemeコンパイラは既にC並に速いと主張してるよ。
object.methodを特別に解釈するようなことはCommon Lispで
やったことがあるが、良し悪しだね。埋め込みの領域特定言語
の中でなら結構使える。全てのコードで使うと、どうも言語の
他の部分とのバランスが悪くて。慣れの問題かもしれんが。
packageもなー。read時の動的環境に左右されるってとこでたまに
はまるんだよね。外部とS式をやりとりするような場面で。
でも、Schemeで天下取ろうって気概はいいね。処理系が公開
できた暁には是非教えてくれ。応援するぜ。

Schemeでbinutilsとgccそっくりそのままの機能を持ったソフトウェアを書いてくれ。

>>346
フットプリントも小さくなるかな？

リソース制限が多少緩和されてきてるとはいえ組み込み系の非リアルタイム部分をインタラクティブに作れるだけで幸せになれそうなんだけどな。

kcl処理系をいじる課題があるんですが、
コマンドラインからの入力は、なんていう変数に格納されてるんですか？
あと、lispを起動した際、自動的にこちらの指定したlispのコードを実行するように
するには、どこにコードを書けばいいでしょうか？

gclのソースを手に入れたので、
弄ろうと思うのですが。
main関数はどこにあるのでしょうか？

つ http://www.loveruby.net/ja/misc/readingcode.html

>>350
つgrep

>>350,352
とetags

gclを弄らなきゃいけないのですが、
大域変数用のクロージャってソースのどこにありますか？

最近の中学校は変な宿題が出ているようだな。

ごめん前から気になっててんけど
「つ」ってよくみるけど何のこと？
手でなんかをサッと出すようなイメージ？

>>356
つ http://members.at.infoseek.co.jp/maruheso/aadic/ta.html#tu

つ夢と

なるほど

最近gaucheを触りはじめたのですが、Emacsで書くのに便利な環境ありますか?
みなさんどうしてますか。

今のところ scheme-mode + run-scheme なのですが、
- 関数のeldocぽい表示 and/or info参照
- 動的補完
が欲しいなあと。

Common Lisp用のSLIME並に快適便利なのがあると言うことなしですけど。

>>360
http://lambda.s55.xrea.com/Scheme.html

卯にいたから誘導されてきました.

どっかに continuation の各種実装方式あたりを集めてあるサイト
ありませんかぁ???

ありません

>>362
こことか。
http://library.readscheme.org/page6.html

Smalltalk にも継続があるのは知らなかった...
http://en.wikipedia.org/wiki/Continuation

>>362
実装に興味あるならこことか。
http://www.shiro.dreamhost.com/scheme/stack-j.html

Franz ACL8.0でてますね。

http://www.franz.com/products/allegrocl/

常々思うのですがパンピーに買える値段なんですかね。


Lispworks 5.0が2Qにでるってことだったがあてになんないよなぁ．．．

>>364,365
ありがと.

>>365
知らなかった。
わかりやすいページでつね。ＴＨＸ

>>366
会社を騙して買わせる。これ。

商用版ＡＣＬの個人ユーザなんているの？

SBCL 0.9.9 がリリースされている。

月一なんだから、いちいち報告しなくても大丈夫だよ。
0.10.0 が出る頃には Linux 以外でもネイティブスレッドが使えるようになると良いね。

Lisp には関係無いが、Steele が作った曲なんてあるんだね。

http://alcor.concordia.ca/~smw/home/telnet_song.html

>>373
曲のタイトル見てＲＭＳを彷彿とさせる物を感じた俺はチキンかもしれない。

質問です。

(define (new-counter)
(let ((count 0))
(lambda ()
(begin
(set! count (+ count 1))
count))))

この(new-counter)手続きは評価されるたびにその回数を返すらしいのですが、それはどうしてですか？

(new-counter)が返すのが、評価されるたびにその回数を返す手続き。

>>375
詳しく言うと、
(define counter (new-counter))
(counter) ; 1が返ってくる
(counter) ; 2が返ってくる
ということ。
countという変数(正確にはcountの束縛)はnew-counterが呼ばれるごとに新しい物が作られる。しかし内側の(lambda () ...)が参照する限り削除されない。

LISPをやってみようかな、と考えている者ですが
>375-377 を読んで感動しました。
関数を作る関数を書けるなんて！

感動した人に言っておくけど，関数型言語によくある「関数を返す関数」でも
実装レイヤでは関数を毎回コンパイルして機械語にしている訳ではないからね．
「環境」だけが毎回新しく作られる．
環境ってのは，naiveに言えば変数名をキーとしたハッシュ表ね．
まぁSICPでも嫁．

SICPはMITのサイトで見つけたので読んできます。

>>379
環境(少なくともローカル)はハッシュじゃないんじゃないの?
引数フレームのリンクリストみたいな感じで。
SECDマシンの LD命令みたいに深さとインデックスでアクセスできる。
トップレベルはハッシュでもいいけど。

勉強でScheme の処理系を作ってるんですが、GCについてよい論文はあるでしょうか?
全オブジェクトの数に比例する Mark and sweepよりも
生きているオブジェクトの数だけに比例する Copyingの方がいいとか
Mark and sweepはインクリメンタルにできるからいいとか
Generational GCで新世代は Copying、旧世代は Mark and sweepがいいとか
そこら辺が知りたいです。

>>380
画面で読んで分かるほど短い本ではないんだなこれが．

>>381
まぅまぅ，難しいことは抜きで．

http://www.logos.t.u-tokyo.ac.jp/~endo/gc/ で物足りないなら挙げられてる参考文献を．
Wilsonのものは無料で読める：
http://citeseer.ist.psu.edu/wilson92uniprocessor.html

SBCL で実行ファイルが作成できるようになったね。

実行ファイルにはランタイムが全部付いてくるのか。
Hello, world が 20MB...

% ./src/runtime/sbcl --core output/sbcl.core
This is SBCL 0.9.9.16, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.
* (save-lisp-and-die "hello" :executable t
:toplevel (lambda ()
(princ "Hello, world!") (terpri) (quit)))
[undoing binding stack and other enclosing state... done]
[saving current Lisp image into /path/to/sbcl/hello:
writing 1584 bytes from the read-only space at 0x10000000
writing 1328 bytes from the static space at 0x30000000
writing 22577152 bytes from the dynamic space at 0x48000000
done]
% ./hello --noinform
Hello, world!
% ls -l hello
-rwxr-xr-x 1 nobody nobody 22921228 2 6 22:51 hello

実行ファイル生成出来るのって今の所 Linux と FreeBSD だけ?

>>379
| 実装レイヤでは関数を毎回コンパイルして機械語にしている訳ではないからね．

それってSchemeだから？
手元のAllegroだとコンパイル済みの函数ジェネレータが返してくるのは
やはりコンパイル済みの函数オブジェクトになってるけど。compiled-function-pでtね。

詳細知ってる人の降臨希望。

>>386
コンパイル済みの函数ジェネレータならコンパイル済みの函数を返すのが普通。
Schemeの場合、lambda式を評価した時点で中間コードなどにコンパイルする処理系が
多いが、このとき中にネストしたlambda式があればこれも含めてコンパイルする。
Common Lispの場合はリストのまま持っていてコンパイルしたときに中の関数も含めて
コンパイルする処理系が多いと思う。

>>386
機械語コードはクロージャを生成するごとに変化するわけではない。

>>375をC言語的に書くとこうなる。型やその他色々の厳密さは勘弁してくれ。

typedef struct { 何かの関数 func; 何かの構造体 *env; } lambda_t;
typedef struct { int count; } new_counter_t;
#define FUNCALL(lambda) (lambda->func(lambda->env))

static int counter ( new_counter_t *up ) {
　　up->counter += 1;
　　return up->counter;
}

lambda_t *new_counter () {
　　lambda_t lambda;
　　new_counter_t *nc = GC_malloc ( sizeof(new_counter_t) );

　　nc->count = 0;
　　lambda.func = counter;
　　lambda.env = nc;
　　return lambda;
}

void func () {
　　lambda_t lambda = new_counter ();
　　FUNCALL(lambda);  /*  => 1 */
　　FUNCALL(lambda);　/*  => 2 */
}

GC_mallocで返されてるのがいわゆる環境というやつ。

>>385
Mac と Win もできると思う。
他の OS でも os_get_runtime_executable_path() を実装するだけでいけるはず。

>>390
many thanks!!
Mach-O だから Mac は後回しかなぁと思ってたけど、ソース見たらちゃんと有るね。
リリースされたら試してみます。

Common Lisp実装で動く、
EUC/JIS/SJIS/Unicodeなどを相互変換する
ライブラリはどこで見つかりますか？
Googleしてみても、見つけられなかったのです。

>>392
CLISP.
ライブラリってより処理系そのものだけど。SchemeならGauche.
金持ちならAllegroCL. これもライブラリではないな(w

どこで見付かるかって話ならc.l.l.読むとかCLikiとかcommon-lisp.netとか。

>393
CLISPだと
http://clisp.cons.org/impnotes/encoding.html#charset
に使えるエンコーディングの一覧がありました。
また、ライブラリとしてはGNU iconvが使えるようです。
http://www.cliki.net/iconv
これで日本語処理もなんとかなりそうです。
ありがとうございました。

CLISPはGNU iconvをまるまる取り込んでるからね。
直接iconvを叩かないで済むからエンコーディングまわりいじるには便利だよ。

Common Lisp で実装されてるのはないの?

すでに C のライブラリがあるからねぇ。参考にしたいっつーなら
SBCL のエンコーディングサポートはほぼ Common Lisp だよ。

EUC <-> UCS なら SBCL に含まれてるよ。
条件を絞れば難しいもんじゃないし、練習がてら自分で書いてみては?

質問です。
LISPとかFortranだったら、C言語では実現できないアルゴリズムとかもあるのでしょうか？

Javaはアルゴリズムのライブラリがあるらしいですけど

>>399
ヒント：チューリング完全

> LISPとかFortranだったら、C言語では実現できないアルゴリズムとかもあるのでしょうか？
日本語でおｋ

リンク
http://pc8.2ch.net/test/read.cgi/tech/1104066264/l50

http://pc8.2ch.net/test/read.cgi/tech/1104066264/643
http://pc8.2ch.net/test/read.cgi/tech/1104066264/648
http://pc8.2ch.net/test/read.cgi/tech/1104066264/649

プログラムは我流でいいさちゃんと　”仕様をはみ出さず、全て満たしてくれれば”　な
プログラミングなんてちょっと頑張りゃ誰でも出来る
設計は馴れるしかない
ソフトウェア工学みたいな変なのもあるしな

実現できないアルゴリズムってなんだよ

上で出てきた「関数を返す関数」なんてのはLISPだったらやりやすいよな。
CやFORTRANでもできなくはないだろうけど、苦労するんじゃないか？
>400 も言ってるように、チューリングマシン的にはどの言語も等価だから
「Aに書けてBに書けないもの」はなさげ。

問題は使いやすいかどうか。
アセンブラよりCが使いやすいように、
Lisp使ってる人にはCよかLispのが使いやすい。

>>399
Lisp初心者は、まず「グリーンスパンの第10法則」を知っておきましょう。

Greenspun's Tenth Rule of Programming
http://www.practical-scheme.net/wiliki/wiliki.cgi/Lisp:GreenspunsTenthRule

"Any sufficiently complicated C or Fortran program contains
an ad-hoc, informally-specified bug-ridden slow implementation
of half of Common Lisp."

>>408
訳してみた
「クンニの時間はフェラの時間の半分とすべし」

>>400
>>406-408
皆さん。レス有難うございます。
とても為になりましたです。

>>408
リンク先をお気に入りへ追加させて頂きました。

plt-scheme(Dr.MZ)ってJITになったんだ。
http://list.cs.brown.edu/pipermail/plt-scheme/2006-January/011364.html

JITのschemeって初かな？

UNICODE が使えて、ライセンスは LGPL か。スレッドはグリーンスレッドだけど、
ちょっと良いかも。ベンチマークきぼんぬ。

ライセンスがLGPLってちっとも良くねぇよ。
リンクしたら著作権表示が必要とかなって、
調べるといろんなライセンスのライブラリ使ってて
わけわからなくなるし。
まあ、GPLで公開しちゃえば楽なんだが。

>>413
本当は Scheme 版の CMUCL みたいなのがあると良いんだけどね。
チョッパヤのコンパイラで、リベラルなライセンスで、クロスプラットフォームなのが。

さっき SRFI を surfie って読むと知ってプチショック。サーフボードの絵が描いてあるから
怪しいとは思ってたけど、最初にスーフィーって読んじゃってからはスーフィズムのイメージ
と相まってずっとスーフィーと読んでたよ...

CL 版 SRFI の CLRFI はクラリファイ (clarify) って読んでるけど、こっちは寂れてるなぁ。

>>415
SRFIはサーフィと読んでたが、CLRFIのほうは知らなかった。ｗ
サンクス。というわけでリンク貼っとく。 http://clrfi.alu.org/

こんなのあったのかー。>CLRFI
ところでなんでPerforceのバナーがはってあるんだろ

>>417
Editor の趣味だろう。Nick Levine とか Perforce 用インターフェースを公開
してくらいだしね。

Schemeでstringがimmutableかどうかを調べる方法ってある?

scmはimmutableにならないのか。R5RSに書いてあることとは違うが、
これはこれでよいな。
(define s "abc")
(string-set! s 0 #\A)
s
=> "Abc"

(immutable? "immutable")

SchemeのトップレベルにはCommon Lispの*, **, ***みたいな履歴参照はないの？

Scheme48は ## で直前の値が参照できるみたい。他のは知らん。

Common Lisp好きだけど、OCamlに行くよ。
また戻ってくるかもしれないけど、
とりあえず、さばらじゃ！

一神教の人は大変だね。俺は他の関数型言語とも併用してるけど。

はじめに神は "(" と ")" を創造された

中には教祖になっちまう奴もいるけどな。Mで始まる名前のやつとか

グレアM?

>>428
M で終ってるじゃねぇか。やはり Lisp といえばあのお方しかいない。
どうみても McCarthy 先生です。本当にありがとうございます。
アレ Minsky 先生か？

教祖と言えばあいつしかいない。
リチャード・M・ストールマン

>>427
松井秀喜？

文脈から lisp 族じゃなくても良いと読めるので、matz と推理

R5RSで定義しているけど使われない関数ランキング
トップはたぶんrationalize

transcript-on, transcript-off

>>434
授業なんかで、前から使ってた。

なんとなく cddadr あたりを挙げてみたい。

>>436
確かに使ったことない。・・・たぶん

caadarあたりなら使ったことがありそう。・・・たぶん

caaaarの方が少なそうな気が

色んな言語で継続を表現してみたページってどっかになかったっけか。

たった今CommonLispスレが逝ったけど
別にどうでも良いよな

なんか一日一膳みたいな名前のスレが別にあったと思う。

【一日】CommonLisp【一門】
http://pc8.2ch.net/test/read.cgi/tech/1106587515/

>>441
何気に良スレだったんで、次スレが立っても良いかなと思った。
Common Lisp だけでも、それなりに一スレ使い尽くせるもんだね。

と書いたら、次スレが立ったみたい。立て逃げっぽいけど...

【入門】CommonLispその2【質問よろず】
http://pc8.2ch.net/test/read.cgi/tech/1140012484/

>>440
ここにちょっとだけ載ってる。

http://en.wikipedia.org/wiki/Continuation

サンクス。
ところで継続って作ったスレッドと別のスレッドでも普通に使えるものなの?

処理系依存。
スレッド自体が継続を使って作られてるならもちろん使える。
スレッド毎にスタックを持ってて、スタックそのままコピーして
保存してるならたぶん無理。

継続って便利なん？
外へ戻る脱出はわかるけど、外→内の継続が使えて便利なことってある？

>>449
まぁ君の人生と違ってやり直しがきくってことだね。

>>449
コルーチン。
やったことないけど。

外→内とかって変数の値とかどうなるの？復元されるの？

>>449
普段のプログラミングで多用するものではないが、新しい言語機能を
実験したい時に便利。ユーザレベルスレッドとか、ジェネレータとか、
デバッガとか。

>>452
レキシカル変数の値は復元される、というか、クロージャが環境を
保持するのと同じように、継続もその時点で見えている環境を保持する。

call/ccをcall/ccがない言語でも式の変換で表現できるかどうか考えたが、
call/cc以後の処理をクロージャにして継続として渡してやればいいわけだが、
それにはcall/cc出現までの呼び出し階層が全てCPSで書かれてないとダメかな?

foo -> bar -> baz というように関数を呼び出して、bazの中でcall/ccと同等の
ことをしたい(続く処理をクロージャにして継続渡ししたい)とする。
そうするとfoo, barが末尾呼び出しであるか、それらも継続渡しでbar, bazを
呼んでないとダメだよね?

そう。CPS変換はグローバルな変換になる。

すいませんが質問させてください．
以下のように書くべきだったのですが

(define hoge
(lambda (a lst)
(cond ((null? lst) #f)
((atom? (car lst))
(cond ((eq? (car lst) a) #t)
(else (hoge a (cdr lst)))))
(else (or (hoge a (car lst)) ;A
(hoge a (cdr lst)))))));B

> (hoge 'a '((a)))
#t

or を思い付くことができず、Aの部分で
(else (hoge ...
と書いてしまい、以下のようになりました。

> (hoge 'a '((a)))
#f

A、Bの再帰をたどった場合、Aの結果は#t、Bの結果は#fに
なると思うのですが、全体の結果が#fとなる理由を教えて
いただいてもよろしいでしょうか。

わー、ずれた。
すいません。

else句には複数の式を書くことができる。その場合最後の式の値がcondの値になる。

> 458さん
超高速のご回答ありがとうございます。
そういうことだったんですね。理解しました．

Common Lispは組込みにするには大きく、
Schemeはfull continuationを要求するので(C/C++とのインターリーブを
考えると特に)簡単には実装しづらい、というのがLisp系の悲劇だと思う。

Schemeでfull continuationをoptionalにしたような、
内→外への脱出のみ + Scheme的なコンパクト仕様が一つ決まっていれば
今よりも使われてたんじゃないでしょうか。

今の基準ではCommon Lispってさほど大きいとは思わないけどな。
例えばJavaのクラスライブラリとかのほうがずっと大きいと思う。
（もちろんその分高機能だけど）

個人的にはネットワーク、XML等の機能を盛り込んだ最新のより大きい
新Common Lisp (CLtL3?)の制定が必要だと思う。

UNICODE とスレッドも標準化して欲しい。

>>461
大きさについては、組込みにするには、って書いたのでそこを汲んでくださいな。
Javaのライブラリの方がはるかに大きいのは同意です。
1.1の頃は(それでもでかかったけど)まだあんなじゃなかったのに。

あとは開発環境と実行環境の分離でしょうかねえ。普及の障害。

継続レスSchemeならマジ簡単だよ
昔７行スレに（７行じゃないけど）あったよ

>>460

忘れ去られている ISLISP

match が便利な件について

継続引渡しスタイルについて質問です。
「プログラミング言語 Scheme」の p.64、英語版第 3 版だと、
http://www.scheme.com/tspl3/further.html#./further:h4
のあたりです。

(define product
(lambda (ls k)
(let ((break k))
(let f ((ls ls) (k k))
(cond
((null? ls) (k 1))
((= (car ls) 0) (break 0))
(else (f (cdr ls)
(lambda (x)
(k (* (car ls) x))))))))))

(product '(1 2 3 4 5) (lambda (x) x))
=> 120
(product '(1 2 0 3 4 5) (lambda (x) x))
=> 0
となりますが、、、以下続く。

継続引渡しスタイルなんて面倒なことをせずとももっと単純に、

(define product-b
(lambda (ls)
(let f ((ls ls) (result 1))
(cond
((null? ls) result)
((= (car ls) 0) 0)
(else
(f (cdr ls)
(* (car ls) result)))))))

(product-b '(1 2 3 4 5))
=> 120
(product-b '(1 2 0 3 4 5))
=> 0

で充分じゃないかと思ってしまいました。
実際、リストに 0 が出現するとループからも脱出できているようですし。
どこを勘違いしているのでしょうか？
継続引渡しスタイルの何が嬉しいのでしょうか？

まあ、例のための例なのであれだが、とりあえず前者では0を含むリストに対してはかけ算は一切行われないが、後者だと0が出てくるところまでのかけ算は行なわれる。

評価を遅延できるってとこがいいとこなのかな？
かけ算じゃあまりありがたみがないけど、
もっと重い処理を考えたらうまみがでる?

この文書のセクション5あたりが参考になるかも。
ttp://www.sampou.org/haskell/article/whyfp.html

それとここも参考に。
ttp://practical-scheme.net/wiliki/wiliki.cgi?Scheme%3aCPS

>>469
なるほど、ありがとうございます。

>>470
いえまあ、かけ算が例でも >>469 ということであれば利点はわかります。

ところで、セクション 4 で言ってる
g (f input)
を例とした「怠惰(遅延)評価」って、Scheme での継続引渡しスタイルでも
同様の効果が得られるんでしょうか。つまり強力なモジュール化が可能になる？
また、「プログラミング言語Scheme」の索引で「遅延評価」をひくと、(delay)
と (force) を使う旨の説明が出てくる(p.94)んですが、これと継続引渡しスタイルは
関係しているんでしょうか。もう一つの索引参照先(p.199)の
「ヒント：評価を遅らせるには lambda を使用します」
はきっと関係しているんだろうなぁ、と思うのですが。

>> 471
ありがとうございます。
まだちゃんと理解できていませんが、
http://practical-scheme.net/docs/cont-j.html
とあわせて読んでみています。

「プログラミング言語 Scheme」の継続引渡しスタイルの説明(p.64)に、
「継続を実装したプロシージャは任意個数の引数を受け取ることができるため、
継続引渡しスタイルを用いて複数の結果を返すプロシージャを定義すること
ができるようになる」
という記述がありますが、これはどういう意味でしょうか？
普通のプロシージャだって任意個数の引数を受け取れますよね？
「複数の結果を返す」と言っていますが、例を見ても戻り値は一つにしか見え
ません。

任意の手続きを渡せて、それに従って結果も変えられる、ってのはわかりますが、
それだけだったら、継続引渡しスタイルなんてわざわざ言わなくても、プロシー
ジャ渡し、などと言った方がすっきりしそうに思えます。

ちなみに例は以下。

(define car&cdr
(lambda (p k)
(k (car p) (cdr p))))

(car&cdr '(a b c)
(lambda (x y)
(list y x))) => ((b c) a)
(car&cdr '(a b c) cons) => (a b c)
(car&cdr '(a b c a d) memv) => (a d)

>>473
たとえばC言語の関数とかだと引数は複数指定可能なのに
返り値は1つしかだめだよね？(特別の場合として0というのもあるけど)
でもCPSでは，サブルーチンからリターンするというのは，
継続に(返り値であるところの)値を渡す，ということになるから
(ここらへん図が書けないと厳しいな……)
自然と複数の値を渡すことができるようになるの．

ちなみにContinuationはそのときの環境なども含まれるから
単純なプロシージャとは違います．
>>473の例は複数の値を返せる，という継続の特徴の一部を示している
だけのプログラム例なのでこの辺りは実感できないと思いますが．

>>474
ありがとうございます。

しかし >>473 の例、
(car&cdr '(a b c)
(lambda (x y)
(list y x))) => ((b c) a)
(car&cdr '(a b c) cons) => (a b c)
(car&cdr '(a b c a d) memv) => (a d)

これらはいずれも、返り値は複数ではなくて一つだけ(リスト一つ)です
よね。

これがなぜ
> >>473の例は複数の値を返せる，という継続の特徴の一部を示している
> だけのプログラム例
ということになるんでしょうか？

> ちなみにContinuationはそのときの環境なども含まれるから
> 単純なプロシージャとは違います．

では、代わりにクロージャ渡しと言えば、それは CPS と同義なんでしょうか？

>>475
car&cdr って関数はその名の通り，listをもらってそのcar部とcdr部を
返す関数ってぐらいの意味．

(let (((x y) (car&cdr '(a b c)))) ;; car&cdr が複数(2つ)の値を返している．
　(list y x))

っていうプログラムがあったとして(これは疑似コードだけど)，
これをCPSに変換したものが

(car&cdr '(a b c)
　(lambda (x y)
　　(list y x)))

というプログラムになる訳．
(当然car&cdrの定義は前者と後者で異なります)

car&cdrはリターンする代わりに継続のkに2つの値を渡している。1つのリストを返しているのは継続k。
という風に見る。この辺ややこしい。

>では、代わりにクロージャ渡しと言えば、それは CPS と同義なんでしょうか？
CPSを実現するための1手法としてクロージャーを渡している。
クロージャーを渡していてもそれが継続でなければCPSではないし、別の方法で継続を渡す実装があるかもしれない。

>>476
ありがとうございます。
ですが、そもそも擬似コードの意味が不明ですし、加えて前者と後者で
当然定義の違う car&cdr、などと言われると、ますます意図を汲めません。
せっかく説明してくださってるのに、申し訳ないです。

>>477
> car&cdrはリターンする代わりに継続のkに2つの値を渡している。
> 1つのリストを返しているのは継続k。という風に見る。この辺ややこしい。

なるほど、納得しました。

> CPSを実現するための1手法としてクロージャーを渡している。
>クロージャーを渡していてもそれが継続でなければCPSではないし、

クロージャと継続は、どう区別するんでしょう？
クロージャを渡していても、それが継続ではない例を挙げてもらっても
良いでしょうか？

> 別の方法で継続を渡す実装があるかもしれない。

これは、Scheme の処理系ごとに方法が違うかもしれないってことですか？
それとも、他の言語では違うかも、という意味？

クロージャと継続は全く別物

継続といえばコレよね
http://www.shiro.dreamhost.com/scheme/docs/cont-j.html

>> 479
では (lambda (x) x) は、クロージャですか、それとも継続ですか？

>>480
ありがとうございます。読みました。
Scheme のコード上、どう区別がつくのかしらん、ってのが疑問なん
です。

CPS の前の継続のセクションはちゃんと理解したの?

>>481
クロージャですし、何も計算しない継続を表していると考えることもできます。
その質問は
「我輩は猫である。名前はまだない。…」
は日本語ですか、それとも小説ですか？
と聴いてるようなもの。

>>482
順を追って読んでいますが、じつは理解していないのかもしれませんね。

>>483
なるほど。
継続(小説)はクロージャ(日本語)で表現される、ということでしょうか。

では、質問を変えます。
ある関数の引数にクロージャを渡しているが、それを CPS とは呼ばない
場合というのはありえるのでしょうか？ ありえるとして、それはどんな
場合ですか？

CPSを意図してない場合は全部。

なんが用語の定義に翻弄されているようだな。
もっと実質的な考えをしないと駄目。

よりによって、これまでのレスが全て無意味だったと思わせる質問に変えたなあ。

お前ら親切だな

クロージャっていうのは環境を持ったコード。
クロージャの生成方法は lambdaだけ。誤解のしようがない。

継続っていうのは内部的にはスタックとレジスタを保存したもの。
継続の生成方法は call-with-current-continuation(なにげに syntaxじゃない)だけ。
これも誤解しようがない。

CPSはクロージャで継続を表現してたらい回しにしていくやり方のこと。
これは意味だから解釈の問題。
(lambda (x) x)だけでクロージャだのCPSだのは言えない。

>>480 はかなり分かりやすいよ。

>>485
> CPSを意図してない場合は全部。

なるほど。
コードの書き手の主観依存であって、客観的にはクロージャ渡しと CPS は区別
できないと。

>>489
> 継続の生成方法は call-with-current-continuation(なにげに syntaxじゃない)だけ。

矛盾してませんか？
たとえば >>473 の例は、call-with-current-continuation を使っていません。
クロージャを渡しているだけですが、渡されたクロージャすなわち lambda 式が
継続なんですよね？

> >>480 はかなり分かりやすいよ。

そうですね。
完成が楽しみです。

単に用語の定義を知りたい人なのかな。
なんかこの人、すべての質問が奇妙に思える。

>>473の例はすでにCPS変換後のプログラム．
だから変換前のプログラムを考えなければ
(lambda (x y) (list y x))
が継続である，という主張は意味を持たない．

473 はどうやっても継続が理解できないタイプなんだろ。
継続が理解できてないから継続渡しなんて言われてもさっぱりだし、
高階関数との区別もつかない。
あきらめて他のことでもしたほうがいいよ。

>>492
うーん、やっぱりよくわからん、と思ったんですが、さかのぼって
>>454
>>455
のやりとりを読んで、疑問が解けました。
ありがとうございました。

>>489
間違っちゃいないが、ちょっと狭義過ぎるかと。
特に今はもう少し一般的なCPSの話だからちょっと不適切。

Petite Chez Scheme の Windows 版を落としてみたんですが、
threaded 1,472KB、non-threaded 4,716KB です。
素人考えでは、スレッド対応してる方がサイズでかくなりそげ
なんですけど、なんででしょう?

non-threadedって何だろ。
ついにJITコンパイラでも組み込んだかな。

働けど働けど
わが暮らし楽にならざり
ぢつと手を見る

これをgoshで実行すると
10
2030
となります。
10
20
30
となるのを期待して書いたのですが、なぜでしょうか?

ちなみにscmでは仮想マシンの入れ子呼び出しをまたいだ継続は使えないのか、
エラーになります。

(define x #f)
(define y #f)

(display
 (call-with-current-continuation
  (lambda (k)
    (set! x k)
    10)))
(newline)

(if y
    #f
    (begin
      (set! y #t)
      (eval (list x 20) (interaction-environment))))
(display 30)
(newline)

evalを
(eval '(x 20) (interaction-environment))
としたらscmでも実行でき、やはり
10
2030
と出力されました。

eval関係ないっすね。
(x 20)
でも同じでした。すんません。でもどうして
10
20
30
じゃないんでしょうか。

全体を関数の中に入れたら期待通りになりました。
トップレベルは継続も特別?

基本的には処理系依存だろうけど、多くの処理系では継続は
トップレベルを巻き戻さない。

ああ、わかりました。トップレベルの式単位で完結するんですね。

すいませんがschemeについて質問させてください。

以下のようなリストにおいて、

1 まずcarでsortし、
2 carが同じ値の時はcadr順にならべる

方法を教えていただいてもよろしいでしょうか。

'((1 3) (1 2) (2 4) (2 1))

スペースで区切られたデータがならんでいるテキストデータを
読み込んで１列目だけ出力するプログラムってどうかけばいい？

awkでかくとこんな感じなもの

awk '{print $1}' input_file.txt

宿題は(ry

>506
どの Lisp でどの処理系かによってぜんぜん変わると思うが。

おれの手元には Gauche があるが、それなら1行の文字列データが line に入っているとして
(car (string-split line #/\s/))
とかすれば1列目が取り出せる。読み込んで行を割り振ってこの処理を繰り返
せばおしまい。でも string-split は Gauche の実装でしかないからほかの
scheme 処理系にあるかは知らない。


>505
問題文の意味が取りづらいのだがようするにいわゆる辞書順で並べろってこと？
まず (1 3) と (1 2) の比較関数を考えればいいんじゃね。

#!/usr/bin/env gosh

(use srfi-13)

(define (first-columns port)
(with-input-from-port port
(lambda ()
(port-map
(lambda (line) (car (string-tokenize line)))
read-line))))

(define (main args)
(for-each print (call-with-input-file (cadr args) first-columns))
0)

> まず (1 3) と (1 2) の比較関数を考えればいいんじゃね。
出来ましたー！
>>508さん。ありがとうございます。carでだけならsortできるのに。。。と
悩んでいましたが、おかげで出来ました．

(sort
'((1 3) (1 2) (2 4) (2 1))
(lambda (a b) (if (= (car a) (car b))
(< (cadr a) (cadr b))
(< (car a) (car b)))))
((1 2) (1 3) (2 1) (2 4))

CL-AWK ライブラリをロードしてから

(use-package :clawk)

(defawk print-col-1-only ()
(t ($print $1)))

もしくはもう少し Lispy に

(use-package :clawk)

(defun print-col1-only (filename)
(do-file-fields (filename)
(format t "~A~%" $1)))

Schemeの継続の考え方、使い方、言語処理系内部での実装方法について
学べる書籍、論文を紹介して頂けないでしょうか。
SICPを期待しながら読んだのですが、何だか、はぐらかされたような気分です。

全部いっぺんに書いてあるものはなかなかないと思うぞ。
まず必要な理解はユーザ側なのか実装側なのかはっきりしる。

>>512
全部まとめてとなると厳しいけれど、使い方ってんならこれとかどうでしょ。
http://www.cs.indiana.edu/~dfried/appcont.pdf
あと、>>480。

実装の説明はこれが分かりやすい
http://lists.sourceforge.jp/mailman/archives/gauche-devel-jp/2002-November/000018.html

あえて補足すると
(1)は作成時にスタックを memcpyして setjmp、呼び出し時にスタックが足りなければ
ダミー関数を呼びまくってスタックを伸ばして memcpy, longjmpという感じ。
SCM, guileのソースを見れば分かる。

(2)は普通にVMにコンパイルすると実装できる。
作成時にスタックとその他必要なレジスタの値をコピーして、呼び出し時にレジスタ
の値を復元、スタックは保存しておいた方を使えばいいのでコピーがいらない。

(3)は全然知らない。相当マニアック。

(4)のStack GCのやつは実装してみたことは無いけれど、あまり難しくなさそう。
GCといってもポインタが指しているのが環境なのか継続なのかはっきりしているから。

Stack GC はスタック上の生きているサイズに比べて十分スタックのサイズが大きくないと
explicit popに比べて不利になる。逆に十分スタックのサイズが確保されるなら、
Gaucheみたいな末尾呼び出しの実装には勝てそう。

scm 5e1で、Schemeを学んでいます。
(define (reduce f i l)
(if (equal? '() l)
i
(f (car l) (reduce f i (cdr l)))))
を実行し、次に、
(define (anytrue? l)
(reduce or #f l))
を実行しました。
anytrue?には、
リストlの要素のいずれかが#tなら#t、
そうでないなら、#fを返して欲しいと思っています。
ところが、
;ERROR: Use of keyword as variable or
; in expression: (or #f #@l)
; in scope:
; (l) procedure anytrue?
;STACK TRACE
1; ((#@reduce or #f #@l))
2; (#@anytrue? (#@quote (#f #f #f)))
といわれてしまいます。
何がいけないのでしょうか。

(define (sum l)
(reduce + 0 l))
では、うまくいくのですが...

or は関数じゃないよってこと
or の代わりに (lambda (x y) (or x y))
にしてみ

>517
ありがとうございます。うまくいきました。
でも関数じゃないというのは、どういうことなんでしょうか。
defineやlambdaで定義されている規則に従って、
単純に置き換えが行われていくのかと思っていたのですが...

関数じゃないというのはマクロだっちゅうことだ。
引数が評価されない場合があるっしょ？

>519
ありがとうございます。
R^5RSをよく読んでみます。

Special Form ってやつだね。ifとかcondみたいな。

便乗質問。
mapcarとか引数に関数を取る高階関数って、
マクロは引数に取れないよね？
関数やマクロを定義するとき、
マクロか関数か、名前で判断できるようにすべきなのか？

>>522
第一の質問の答えばyes。
第二の質問の答えは好きにすればいい。一般的にはno。

>>522
emacsとか、充分なインテリセンスがある環境ならキーひとつで
定義箇所に飛べるから名前で区別するほどではないんじゃないかな。

MSN サーチで "CLISP Win32 日本語" って検索したら libiconv を
リンクした Windows 用の CLISP バイナリみつけた。
http://lispuser.net/commonlisp/clisp.html
CLISP って exe の実行形式出力できるんですね。知らなんだー。

exe が吐けると………何か嬉しいの？

deploy意識したことないのか。幸せだな。
それはそうとACL MacOSX PPC 32bit版の投げ売りやってるみたいよ。
Linux x86 64bit版だったら即買いだったのに。intel Macの影響だと
思うけどMacな方は突撃どうぞ。$995でFree Deploymentってマジでうらやましぃ。

R6RS の Status Report が出てますな。
http://www.cs.indiana.edu/~dyb/r6rs/status.html

あんまりでかい言語にならずに済んでくれるといいなあ。
特にモジュール周辺とかコンパイラ周辺とか、
Common Lisp は有用であるとはいえやや複雑すぎるきらいがあるから。
そこらへんコンパクトに収めてくれるとありがたいなあと思う次第。

ところで [] を実際使ってる人っている？

使ってないしR6RSで()と同じ意味にするのもやめてほしい。
実際のところ、カッコの対応はインデントだけで見てるから、
[]混ぜるの意味なくない?

印刷されたコードなんかだと読みやすいけどね []

独自の言語拡張などで [ ] を使いたい人は多いだろうから、Scheme言語の一部
として規定するのはやめてほしい。有用性も疑問。

「プログラミング言語 Scheme」の p.92 について質問です。

(define reenter #f)
(define x 0)
(fluid-let ((x 1))
(call/cc (lambda (k) (set! reenter k)))
(set! x (+ x 1))
x)
=> 2
x
=> 0

とここまではその通りなんですが、
(reenter '*)
=> 3
(reenter '*)
=> 4
とはならず、エラーになります。試したのは Gauche と Petite Chez Scheme です。

errata には特に何も書かれていないようなのですが、(reenter '*) ってのは
何をしたいんでしょうか？

エラーにならないよ (Gauche 0.8.6)。どんなエラーが出てるの?
ちなみにreenterを呼び出すと

(fluid-let ((x 1))
(call/cc (lambda (k) (set! reenter k))) <-- この式から戻ってくる
(set! x (+ x 1))
x)

引数に渡している '* は call/cc の戻り値になるけど、ここでは
捨ててるからあんまり意味はない。

>>533
ありがとうございます。

(define reenter #f)
(define x 0)
(fluid-let ((x 1))
(call/cc (lambda (k) (set! reenter k)))
(set! x (+ x 1))
x)

までを foo.scm に書いて、その後、
gosh> (load "./foo.scm")
#t
gosh> x
0
gosh> (reenter '*)
*** IO-CLOSED-ERROR: I/O attempted on closed port: #<iport(closed) ./foo.scm 0x102
e7b60>
Stack Trace:
_______________________________________

となったので、つまずいてました。
ファイルに書かずに、全部 gosh> の状態(何ていうんでしょう？)から入力すれば
大丈夫なんですね。気がつきませんでした。でも、なぜ違いが出るのでしょうか？

>>532
Gauche 0.8.6 でやってみたところ問題なく　3, 4 となりますが。
どういうエラーになったんですか。

>>534
Schemeの中の人の気持ちになって考えよう。
loadの中の人はfluid-letで始まる式を読んだ後に何をしようとしていたのか。

ちなみにトップレベル絡みの継続は剣呑だから実用的には避けたほうがよいぞ。

>>536
ありがとうございます。
load 時に開いていた出力ポートがトップレベルでは閉じられているのに、
継続で load 時の出力ポートを使おうとしたのでエラーになった、って
ことでしょうか？
トップレベルと load 時では、デフォルトではどちらも標準入出力を使う
んだろう、と思ってたんですけど、違うってことなのかなぁ。

>>537
とりあえず、その辺は実装依存だな。

ネット上の解説を読み漁って、たった今継続を理解した気になっている
Scheme勉強中の私が、何が起こっているのか説明してみて良い？

継続とはつまりその時点からトップレベルに戻るまでに行われる処理の流れであって、
この場合、そのトップレベルに戻るまでの間にはloadによって開かれた、
入力ポートから続きを読むor閉じる処理が含まれている。
よって、既に閉じられているポートに対する処理が行われることになりエラーが発生する。
さらに、既に読み込み終わっていて継続にはそのポートに対する処理が含まれていないとしても、
fluid-letで始まる式の戻り値は破棄されるために望む結果は得られない。
(loadの戻り値は成功/失敗を#t/#fで返す)
ということで良いんでしょうか。

>>528-531
quackでは'['と']'はそれぞれ'('と')'に変換される

Gaucheでは[a 'b]を(ref a 'b)に展開するリーダ拡張
が考えられていた。refはジェネリック関数で
[hash 'key] => value みたいに使えるようなアイデアが
あったらしい。

R6RSから外れなくなかったので、このアイデアを放棄
したみたいだが。

Gaucheでスクリプト書いてるんだけど、
インストールしたスクリプトに別のファイルを読ませる場合、どうすればいい?
おおまかに次のような選択肢があるだろうけど。
1. loadにフルパスで書く
2. 環境変数 or gaucheの変数(なんかあるだろ)でパスを指定、loadはファイル名のみ
3. ファイルをgaucheが標準で探すディレクトリのどこかに置く

インストールしない、開発中の都合の良さも考えて一番いいのはどれかなあ。

mylib.scm
mylib/other.scm

みたいに置いといて、mylib.scmの中で

(load "mylib/other")

インストール前のテスト時には gosh -I. で起動する。
ってやってる。

インストール先はgaucheのライブラリパスですか?
ともあれ、ありがとう。

>>544
-I. で load-path に . を追加してるんじゃないのか?

ちょっと質問させてください ﾉｼ
Schemeを覚えたら、そのプログラムって
defineをdefunにしたりとか、
単純なキーワード置き換えだけでCommon Lisp環境で動いたりするもんなの？

>>546
名前空間が違う、ライブラリが違う、
末尾再帰の最適化は未保証、とかとかあるから無理じゃね？
ただ簡単なリスト処理くらいのプログラムなら
頭のなかで変換できると思うけど…

まぁ他の言語でトランスレータを書くのに比べればLispで書くのは100倍くらいは
簡単だな。極端な話、SchemeインタプリタをCommon Lispで書くことさえさほど
難しいことではないし。

おなじS式を使っているLISPファミリーの一員だけど、
単純な移行はできないんですね。
Schemeのほうがライブラリも含めた言語の規模が小さそうなので勉強が簡単かなと思ったんですが、
とりあえずCommon Lispで行ってみることにします。
ありがとうございました。

>>548
継続とインタプリタの入れ子呼び出しが絡むと難しくならない？

>>550
そこは別に難しくはないだろ．Scheme インタプリタに継続を実装すりゃいいだ
けだからな．Scheme 処理系間の互換性と同じ問題にブチあたるほうがキツいと
おもわれ．

>>551
インタプリタ→Common Lispで書いたメソッド(の中でunwind-protect等)
→インタプリタ
という場合で、中のインタプリタで作った継続を外側のインタプリタで
適用しようとしたときとか、どうするの？

実装言語が何でもネストしたらまずいだろ。
トランポリンでやるか、最初にCPS変換かけるかすればいいじゃん。

>>553
kwsk

orを

(define-syntax my-or
  (syntax-rules ()
    ((_) #f)
    ((_ e) e)
    ((_ e1 e2 e3 ...)
     (cond (e1) (e2) (e3) ...
           (#t #f)))))

のようにも定義できると思うのですが、
何か見落としている問題点があるでしょうか?

あからさまに文法エラーに見えるのは俺だけ？

俺だけだね。ごめん。

例えば(or (f)) という式を考えると
orが末尾コンテクストにある場合は(f)は、末尾呼び出しにならなきゃならない
my-orの場合は
(let ((temp (f)))
  (if temp
       temp
      (cond (#t #f))))
と展開されるから(f)は末尾呼び出しにならない。という問題点がある

どういう式を555のmy-orに与えると557のように展開されるのか謎ですが……
とまれ、末尾呼び出しについては失念していました。どうも。

すいませーん、COMMON LISP のトライアル
ダウンロードしたんですけど、devel.lic
ってファイルが無いって起動出来ないんです。
開発元にはメールアドレスは登録したんだけど、
どのくらい待てばいいんですか？
裏技とかないんですかね？

TextSSの64bit化ってできない？

>>559
どこのCOMMON LISPの話だ？

トライアルとdevel.licからallegroだろうと思うけど、
どれくらい待つかは中の人じゃないからわからん。

TSPLのChapter 8を読むと

(define-syntax my-or
  (syntax-rules ()
    ((_) #f)
    ((_ e) e)
    ((_ e1 e2 ... en)
     (cond (e1) (e2) ... (else en)))))

なんてできそうですが、これはChezの独自拡張ですよね。R6RSに入らないものか。

>>562
Allegro だな。なつかしい。若い頃ライセンス更新がだるいので CMUCL に走っ
てしまったのを思い出した。まぁ体験版じゃ所有欲をみたせないっつー理由が
おおきかったが。

>>563 srfi-46

サンクス。多くの処理系で使えるようになるのを待ちます。

Allegro Common Lisp トライアル版だけど、ファイルは直ぐ来たよ（5分と待たずに）。
ついこの間からは、ファイルも待たずにインストールできるようになったみたい。
http://www.franz.com/downloads/clp/survey
からダウンロード（無償）できる。

>>567を見てダウンロードする場合、
What prompted today's visit to our Web site?
にはどう答えればよいのかな。other?

>>568
Newsgroup をチェックしたあと、
隣にhttp://www.2ch.net/　って書けば？

それnewsgroupじゃないし

ようやく gauche pg を windowsにインストールできた。

>>570
じゃ、http://www.franz.com/downloads/clp/survey
のOtherをチェックして
隣にhttp://www.2ch.net/　って書くのは？

こんなのを、来週月曜日にやってる。

詳細：http://jp.franz.com/base/seminar-2006-03-27.html
開催日時: 2006年03月27日 (月) 13：30〜17：00
　*スケーラブルな RDF triple store （セマンティックWeb構築）
　*Lispアプリケーションの高速化を計る
　*Lispを使ってのポータルサイト構築方法

インタプリタで高速なのって SCM, MzScheme以外になにありますか?

>>574
スキームならチキンやプチチーズも優秀。
コモンリスプならシーリスプとか商用でよければリスプワークスとか。

Qschemeがインタプリタ最速だと思うけど、微妙に文法違うところとか
ちょっとした間違いでコア吐いたりする。

csiは遅いと思います。プチチーズってどれでしょうか?
QSchemeは前コンパイルできなかったんですが、いろいろいじってみます。
GCC拡張を使ってますね。

SCMはマシンスタック、MzSchemeは非マシンスタックですよね。
非マシンスタックでスタック溢れた時、reallocするのとスタックをchunkに分けて
増やしていくのとではどっちがいいでしょうか? オーバーフローの時は後者の方が
いいんでしょうけど、総合的に見たら微妙ですかね。

あと、継続フレームだけマシンスタックにする手もあるかなあと思いました。

美しい・・・
http://kansai2channeler.hp.infoseek.co.jp/cgi-bin/joyful/img/1712.txt

どこか(2ch?何かの本?)に出ていたコードかもしれませんが、
なぜ例-Aのほうはfooを変更しても結果が変わらないのに、
例-Bのほうはfooを変更すると結果が変わるのでしょうか？

;;; 例-A
(define foo begin)
(define bar (lambda (a b c) (foo a b c)))
(bar #t 0 1)
;;==> 1
(define foo list)
(bar #t 0 1)
;;==> 1

;;; 例-B
(define foo (lambda (m) (- m 3)))
(define bar (lambda (n) (foo n)))
(bar 10)
;;==> 7
(define foo (lambda (m) (+ m 3)))
(bar 10)
;;==> 13

>>579
実装依存じゃないかな。
多くの実装がなぜそうなってるかは実装者の気持ちになって考えてみれば
わかると思うが。

>>579
Bは変わらなきゃだめ、
Aは (define foo begin)が普通はエラー。

>>580
自分で実装してみればわかる、と書かないと通じないと思われ。
なぜなら実装者の気持ちになるために必要な知識が欠けているだろうから。

>>581
何をもって普通とするのかよくわからんが、
処理系の動作としてはエラーにはならんことが多いでしょ。

>>582
どんな処理系使ってるのかしらんが。
エラーになる: SCM MzScheme scheme48 csi bigloo ksi
エラーにならない: Gauche guile STk

Aみたく扱うのはマクロ使えばできる。
適当にいじった感じだと guileと STkは一度高階関数に syntaxが渡されると
以降その動作になるっぽい。

579質問者です。
いろいろご意見をありがとうございます。
Schemeの話ですので、どうしても実装絡みの
話になるとは思いますが、実装から離れて、
「理想的なSchemeマシン」なら、579の二例に
対して論理的にどのような挙動をとるべき
なのでしょうか？
もし明確な規定がないのなら、どのように
振る舞うのがより好ましいのでしょう？

「理想的なSchemeマシン」など定義されていない。
必要なら君が定義すればいい。

>>584
同じスコープの定義は「同時」と考えるべきと思われ。
よって>>579は「未定義」とするのが妥当かと。

>586
定義が同時であるという解釈は、この例ならば成立するが、問題の本質はそこ
にないと思う。
二度目の define を set! にしたらどうなるべきだと思う？

>>587
set!で束縛した方が優先されるべきじゃないかな。
defineを「初期化」のイメージで捉えた。
だいぶん主観で言ってることは承知してる。
set!が複数の場合はやっぱり「未定義」

質問。「なぜ関数プログラミングは重要か」を読んだばっかり
の素人です。遅延評価ってUNIXのパイプ処理みたいなもの、
と思っていいですか？

>>589
どのへんを「みたいなもの」といってるのかよくわからん。
そういういいかげんな連想に頼るのはヤメレ。
どういった点で「みたいなもの」と考えるのかはっきりさせろ。

>>590
スマソ。
UNIXのパイプ処理って複数のプロセスが同時に走って
少しづつデータを処理するじゃないすか。
で、それぞれのプログラムはstdioだけ気にすりゃいいから簡単。

遅延処理も同時に複数の関数が必要なデータを
同時に処理するもので、普通の関数が全部評価しおわるまで
値が返らないのとは違う、
と思ったんですが全然違ってます？

パイプ処理みたいなもの、という例え話やら妄想やらはけっこうあるという意
味ではまったく外しているわけではないとも言えると思う。ぐぐってみればわ
かるよ。
なので、「思っていいですか？」と問われればあなたがそうだと思うことにつ
いては禁止する人は少ないと思うが、完全に一致するものでは(当然)ないから、
その理解でストップしてしまうことはおすすめしない。

>>591のいうようなstreamの表現も用途の一つ、というだけの話だな。
まあ安易な喩えで満足するのではなく自分で学んでくれ。

>589-593
おかげで遅延評価がわかってきたような気がする。
ありがとう。

ここで抽象論じゃなくコードで遅延評価を語れる
さすらいのLisper登場キボン。

定番の例はたらいまわし関数だよな。

(define (gtarai x y z)
(gtarai
(gtarai (- x 1) y z)
(gtarai (- y 1) z x)
(gtarai (- z 1) x y)
))

(define (tarai x y z)
(if (<= (force x) (force y))
(force y)
(tarai (delay (tarai (- (force x) 1) y z))
(delay (tarai (- (force y) 1) z x))
(delay (tarai (- (force z) 1) x y)))))

なるほど、遅延評価じゃないgtaraiはなかなか計算が終わらないね…


っておい！無限ループじゃねーかyo！！！

guileのschemeとして変な所ってどんなところ？

髪型・・・とか

600

Guileって末尾再帰がdoループより遅いね。
Gauche, DrScheme, JSchemeでは末尾再帰のが速いのに。

guileの利点って、ほとんどのLinuxにプレインストールされてることくらいかな。

cmuclで (dotimes (i 10000000)) が死ぬほど速かった希ガス

俺様のschemeはネイティブコンパイルだから速いよ。
普通の制御式はCと同じぐらい。

公開キボン

ちょっと前にググったらこんなのあった。試してないけど。

http://hiratch.net/blog/archives/computer/programing/scheme/

Scheme のネイティブコンパイラって殆どないんだよね。
CL は CLISP 以外のメジャー所は全部ネイティブコンパイラなのに。

>>596
taraiは良く例としてみるけどさ、
関数型言語界隈でしか聞かないんだよな…

贅沢言ってすまんがおれのような
非リスパーが感動するような遅延評価の例って無い？

>>607
過去スレで遅延評価版たらいまわしのC++コードがあったよ。
#include <iostream>
using namespace std;

class tarai {
const int x, y;
const tarai* tp;
public:
tarai(int y)
: x(y), y(y), tp(NULL) {}

tarai(int x, int y, const tarai& t)
: x(x), y(y), tp(&t) {}

operator int() const {
return (x <= y) ? y :
(int) tarai(tarai(x-1,y,*tp),
tarai(y-1,*tp,x),
tarai(*tp-1,x,y));
}
};

int main(void) {
cout << tarai(192, 96, 0);
return 0;
}

たらいまわしベンチは関数呼び出しのコストを計測するんだから変えちゃだめだろ。
同等なコードに最適化していいなら
(defun tarai (x y z)
(if (<= x y) y (if (<= y z) z x)))
になるわけだし。

>>607
ttp://mono.kmc.gr.jp/~oxy/hiki.cgi?Lazy+Evaluation
このへんとか? 循環的な定義が書けるよ、っていう話。

#ページのタイトルはRubyのある風景だけどHaskellの話です。

Lispを使い始めて半年くらいで
carとcdrの読み方を知って愕然としたんですが
cadarとかはどう読むんですか？

>>611
シーエーディーエーアール

>>611
カダーだろ。

>>613
cadrは？

>>614
カダーだろ。

cadr はカドゥル

>>606

何人かの人にチェックして貰ってるみたいですが、最近はあまり進んでなくて申し訳ないです。
今は参考書や論文を読んでる。

ネイティブコンパイラですが、Kyoto Common Lisp の頃にはすでに Lisp 界隈ではトランスレータが流行ってたみたいですね。低レベルなところの最適化と移植性はCコンパイラに任せて、それより上の実装に専念できるので、処理系の開発者には嬉しいのでしょう。

最初のLisp処理系であるLisp 1.5 (1962年)からコンパイラは備わっていた。
これはIBM 7090のコードを出力するネイティブコンパイラだ。

KahuaというScheme製アプリケーションサーバのチュートリアルを読んだのですが、
ここで使われている
(define (hello-kahua)
(html/ (head/ (title/ "hello kahua!"))
(body/ (h1/ "Hello Kahua!"))))
みたいなのって、SXMLですか？チュートリアルには特にSXMLに言及はしてなかったのですが、よく似てるので。

あと、Kahuaの場合はタグの属性はどうやって指定するんですか？

ドキュメント読め
つ http://www.kahua.org/cgi-bin/kahua.fcgi/kahua-web/show/doc/Modules/kahua.elem#H-vtqime

Scheme で処理系に応じて使う関数を変更するのって、どうしてますか？
たとえば乱数を生成したい場合、Chez Scheme は random、Gauche では
SRFI-27 の random-integer を使うようなので、トップレベルで

(if random
(define random-integer random)
(use srfi-27))

みたいに書いておければいいのかと思ったんだけど、これではエラーに
なってしまうし。

>>621
SRFI-0 の cond-expand を使うべし。

>>622
おおー、さんくす！

、、、でも Chez Scheme には cond-expand がないのでダメぽ。

>>623
chez 事情はよく判らんけれど、 slib でどうかな？
http://www.swiss.ai.mit.edu/~jaffer/SLIB.html
http://www.swiss.ai.mit.edu/~jaffer/slib_7.html#SEC249

LispやSchemeを好きな人も、関係データベースが要るときはSQLを使うんですか?
それともSQLよりもっと便利なデータベース言語(マクロ?)とか
ライブラリとかがあってそれを使っているんでしょうか?

>>625
「関係データベース」が必要なときは使うんじゃないですかね。

>>611
かだああ

lispを見てるとdefmacro内で
#1# みたいなのを使うことがあるみたいですが
これの説明をしてるサイトってありませんか？

gensymの代わりってのはなんとなくはわかるんですが、
念のためちゃんとした説明を見たいんです。

>>628
#n# は #n= でラベル付けされたものを参照する。
[CLtL2日本語版474ページ]

>>620
さんくす。SXMLとは関係なく、ただの関数だったんですね。

Petite Chez Schemeってめちゃくちゃ速いですね。
これってレジスタマシンなんでしょうか。
それとも Gaucheみたいにグローバル変数をインライン展開してるから速いんでしょうか。

direct threaded codeだからじゃなかったか。

>>632
そうですか。ありがとうございます。
direct threaded codeというと GCC拡張の &&を使ってるんでしょうか。
switch-case と比べて結構違うものなんですかね。

あと一般的にスタックマシンよりレジスタマシンの方が速いですよね。
コンパイルは難しそうですが。他にもキューマシンっていうのがあるみたいです。

自作のインタプリタがswitchだったのを直接ラベルでジャンプするように改良してみたんですが
少ししか速くなりませんでした。
petiteは異様に速いので
1. StackGC
2. Register Machine
3. インライン展開
辺りかなあと思いました。
Gaucheは -fno-inline-globalsありと無しとで速度が全然違うのでこれかもしれません。
とりあえず Kent氏の論文を読んでみます。

インタプリタじゃ速くならんでしょ。

>>635
ネイティブコンパイラ書いても速いインタプリタの10倍速くするのは相当難しいぞ

最速と思っていた petiteにも弱点がありました。
(define loop (lambda (n) (if (= n 0) 0 (loop (- n 1)))))
(loop 2000000)

(define loop2 (lambda (n a b c d e f g h i j k l m r o p q) (if (= n 0) 0 (loop2 (- n 1) a b c d e f g h i j k l m r o p q))))
(loop2 2000000 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)

この二つのベンチマークを比較すると、
SCM: 0.50s 2.67s
MzScheme: 0.63s 1.16s
Gauche: 0.30s 0.91s
Scheme48: 1.09s 1.66s
Guile: 2.99s 9.37s
自作: 0.70s 1.19s
Petite: 0.33s 4.64s

となります。

この二つのベンチマークに差があるのは、末尾呼出しに引数シフトを使っているのだと思います。
(その割に Gaucheであまり差がないのは不思議です。-fno-inlineを付けるともっと微妙になりますし
今のGaucheは引数シフトじゃないのかも?)
自作のは引数シフトじゃなくオリジナル(誰かがやってるかもしれないけど)のやり方なのであんまり差が
ありません。
petiteは極端に差があるので、引数シフトでもない別のやり方かもしれませんが。

>>625
shiroさんの昔の日記
ttp://www.lava.net/~shiro/Private/diary/0010.html#001019
>独自のクエリー言語も、ドキュメントを書いてサポートしてさらには布教して
>SQLに対する優位性をアピールするという広報活動が重要になる。
>そこまで手がまわらない。SQLなら「本買って読んどいて」で済むのに。

たいがいのSchemeの処理系で
(define cont #f)
(define (bar)
  (let ((a 0) (b 0))
    (set! b (call-with-current-continuation
                (lambda (k) (set! cont k)
                  0)))
    (set! a (+ a b))
    a))
(define (print x) (write x)(newline))
(define (foo)
  (print (bar))
  (print (cont 1)))
(foo)
を実行すると、継続を呼び出すごとにaの値は変わっていくけど、
guileとかのCのスタックをコピーする継続の実装を使ってbarを
SCM cont;
int bar() {
  int a=0,b,first;
  b = scm_make_continuation(&first);
  if (!first) { a = a+SCM_INUM(b); } else { cont = b; }
  return a;
}
としたら、何回contに飛んでもaは最初に作ったコピーから書き戻されるから
変わらないよね。どっちが正しいの?

>>640
未定義。処理系依存。

トップレベル環境での継続の保存は使わないのが吉。

トップレベルには見えないが。

別のトップレベルから盗んできた継続は使わないほうが良いってことだな。

なんで別のトップレベルから盗んできたことになるんだ？
馬鹿の一つ覚えだな。

>>644
トップレベルの意味わかってる？
馬鹿はおまえだ。

ということにして質問にこたえられないことを誤魔化したい645

変なのが粘着してるなぁ

>>640
前者。
後者では書き戻されて欲しくない変数 a b を SCM_VARIABLE_* を使って
環境に入れないとだめなんじゃない?

>>645
トップレベルとはトップのレベルということだ。
すなわちサッカーならマラドーナ、ボクシングならマイクタイソン。野球なら王さんと
いうことだ。

>>649
なんで野球だけアジア限定なのとかおもったらWBCで監督として世界一だったんだね。
僕はモルツでいいからもう一度一本足打法がホームランを打つところを見たいと思う。

642=644は上手く逃げ切ったな。

...

なんか変な流れだな。
>>640 に真面目に答えると、guileの方のCコードが間違ってる。
>>648 のが正解。環境が変更される場合は変更される変数の実体を
別にヒープアロケートしておく必要がある。SCM_VARIABLE_* を
使わずに自分で何かアロケートしてもいいんだけれども。

さらに詳しく説明すると、本来「全ての」環境は継続スタックとは
別にアロケートされて共有されないとだめ。ただし変更を受けない変数に
ついてはコピーを持っててもいいから、最適化として書き戻される
スタックに直接保持しても構わない。

どのローカル変数が書き換えられるか静的にわかるから、Cへの
トランスレータでSCM/Guile方式の継続を使っている処理系なら
変更を受けるローカル変数だけ特別扱いしてるよ。適当な処理系の
出すコードを読んでみ。

以前C++で書かれた処理系を公開してて、その説明も載っているサイトを見ました。
またそのサイトを見たいんですけどURLとか処理系の名前とかを忘れてしまいました。
フレームが使ってあってリンクの文字色は黄色だったと思います。背景は若干暗かったです。
そのサイトを知りませんか？

>>648,653
ありがとうございます。
環境のスナップショットは継続には含んじゃいけないんですね。

> どのローカル変数が書き換えられるか静的にわかるから、Cへの
> トランスレータでSCM/Guile方式の継続を使っている処理系なら
> 変更を受けるローカル変数だけ特別扱いしてるよ。適当な処理系の
> 出すコードを読んでみ。

例えばどの処理系がこれにあたるのでしょうか?

Scheme->C という処理系の出すCコードがわりとわかりやすかったが、
まだ手に入るだろうか。R3RSかR4RSの時代のものだったが。

これのこと？
http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/scheme/impl/scheme2c/0.html

フレーム構造の性能を計りたい時に有効なベンチマークって
fib, tarai, ack 以外になにがありますか?

>>658
フレーム構造の性能を計りたい時という意図がいまいちわからんけど、
とりあえず Gabriel の本に載ってるベンチマークは全部やってみたら？

>>659
>フレーム構造の性能を計りたい時という意図がいまいちわからんけど、
継続や引数を積んでジャンプしたり、末尾呼び出しをしたりといった
基本的な性能を計りたいです。

>とりあえず Gabriel の本に載ってるベンチマークは全部やってみたら？
そんなものがあるとは知りませんでした。
"Performance and Evaluation of Lisp Systems" というやつでしょうか。
ネットでは読めないんでしょうか。図書館で探してみます。

Lispシステムの評価・活用法
http://www.amazon.co.jp/exec/obidos/ASIN/4526024937
Performance and Evaluation of LISP Systems
http://www.amazon.co.jp/exec/obidos/ASIN/0262571935

だね。ちょっと古いけど Lisp ベンチマークの業界標準だ。

>>654
http://www.roy.hi-ho.ne.jp/pastel/home/Lisp/index.html
これだな。

>>662
そこでした。ありがとう！

http://clozure.com/pipermail/openmcl-devel/2006-April/003265.html

OpenMCL for x86-64/Linux のテスター募集してるみたい。
リリースまではまだしばらく時間が掛かる感じだけど。

Gauche 0.8.7リリースあげ

>>665
shiroたん乙

Gauche-0.8.7をCygwinでmakeすると、docディレクトリでmakeinfoの段階でこける。
--enable-encodingを付けるとよいみたい。

SICP再発見
http://d.hatena.ne.jp/higepon/19700103/1145105233

>>660
遅レスですが。
http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/lisp/code/bench/gabriel/0.html

>>669
ありがとうございます。

自作のSchemeはまだ pair型を作ってない状態でして、
納得できるまで速くなってから先に進もうと思ってます。
gabriel benchmarkだとtakぐらいしか使えないみたいでした。

ちなみに左から (fib 33) (tak 18 12 6) (ack 3 9) (loop 2000000) (loop2 2000000)で
5.79s 5.28s 5.25s 0.65s 1.11s original
4.45s 5.36s 6.50s 0.51s 2.68s scm
5.38s 5.37s 6.51s 0.63s 1.20s mzscheme
2.67s 2.91s 4.86s 0.32s 0.91s gosh
2.45s 3.19s 2.66s 0.32s 4.66s petite
という感じです。CPSみたいに closure作りまくるベンチの性能はかなりいいんですが
continuationを実装すると変わる可能性もあるのでなんとも言えないです。

LISP勢は
4.42s 0.05s xxxxx 0.49s 2.44s OpenLisp
0.63s 0.02s 0.54s 0.06s 0.10s SBCL
です。OpenLisp は(ack 3 9)だと stack over flowで (ack 3 8)だと
1.09sでかなり速いです。
特に takとackの速さが圧倒的なのが気になります。
LISP勢の方が速いのは継続がないからできる最適化ですかね。
あと、TISLは今は手に入らないんでしょうか。

>"A program may use a top-level definition to bind any variable.
>It may subsequently alter any such binding by an assignment (see see section 4.1.6 Assignments).
>These operations do not modify the behavior of Scheme's built-in procedures.
>Altering any top-level binding that has not been introduced by a definition has an unspecified
>effect on the behavior of the built-in procedures."

(define + (lambda (n) n))
は未定義としても

(define a +)
(define a (lambda (n) n))
これも未定義なんでしょうか?

後者のどこが引用のunspecified回りに該当するのだろうか。

>>671
| LISP勢の方が速いのは継続がないからできる最適化ですかね。
Scheme の言語仕様はまだコンパイラの事考えてないからねぇ
R7RS あたりを待て。

>>674
>Scheme の言語仕様はまだコンパイラの事考えてないからねぇ
そうなんですか。コンパイラで思い出したんですが Shiroさんのとこに書いてある
>同じソースファイルを、インタプリトした場合とコンパイルした場合に、
>全く同じ動作を保証するのは見かけほど自明な話ではない。
っていうのにとても興味があるんですが意味よくが分かりません。
一式づつコンパイルすればいいってことじゃないんですかね。
(load)があると駄目とか？(loadの意味を今いち理解してないんですが)
なんか論理学チックな匂いがする気もします。

loadとかevalとかcompile-file（もしあれば）の挙動とか考えるといろいろある。
Common Lispのeval-whenに相当するものが必要になるケースもあり得る。

>>676
なるほど。define-syntaxってトップレベルでしか使えないのにload やevalで使えちゃう
って変じゃないですか?

Schemeのややこしさってほとんどトップレベルに起因すると思うんですよ。
トップレベルは開発環境のためにあるようなものだと思うので、コンパイル時には邪魔なだけっていう。
let, letrec, let-syntax, letrec-syntaxあたりだけで書けばずいぶんすっきり
すると思うんですけどね。

>>674
ええっ?
むしろ1980年代には、実装の関心はコンパイラになかったっけ。
RabbitとかTとか。PC上でもTIが出してたやつとか。
インタプリタがこんだけ広く使われるようになったのが
最近のような気がする。
仕様としてCLほど厳密にコンパイル時の動作を決めていないってのは
あるけれど、それはThe Right Thingを決めるにはまだ経験が足りないって
ことであって、コンパイラのことを考えてないってんじゃないと思うなあ。
evalがR5RSまで入らなかったのも、モジュールシステムが未だに無いのも、
コンパイラのことを考えて (考え過ぎて?) いるからでしょ。

Schemeの本はここ6年間、出版されてませんが何か。

The Reasoned Schemerの出版は去年ですが何か。

考えすぎた末にいろんな宗派が出来てしまって今更まとまらない。

Scheme界でそれを言ったらおしめえよ。

>>676
今日図書館で論文を読んでいたらその話が書いてありました。
"Weak Consを用いたマクロ再定義時の自動再コンパイル"
というやつです。
マクロや関数の依存関係をグラフで持っておいて、マクロが
定義されると依存関係にあるマクロ、関数を再定義、再コンパイル
するというものです。これによってコンパイラでも最新のマクロ
定義が使えます。
思ったんですが変数にも同じことができるんじゃないでしょうか。
定数を埋めこんだり、手続きをインライン展開できたりします。
再コンパイルが起きまくるようなコードを書くことも可能なので
再コンパイルはlazyの方がいいかもしれません。
SBCLで disassembleしてみたところ、そのような最適化はされて
いないようでした。

>>683
disassembleじゃあるかどうかわからないと思うけど。
そういうグラフがあったとしても、関数のコードの外部に持つから。

>>684
えっと
(setq a 3)
(defun f (n) (+ n a))
(disassemble 'f)
や

(defun g (n) (+ n 1))
(defun h (n) (+ 2 (g n)))
(disassemble 'h)
とかしてもaが埋めこまれたり、gがインライン展開されたり
していなかったからです。

それどころか
(defmacro test (x) `(+ ,x 1))
(defun f (n) (+ 2 (test n)))
(disassemble 'f)
(defmacro test (x) `(+ ,x 10))
(disassemble 'f)
でも fは変わっていませんでした。
上の論文では変わらなきゃいけないと書いてあったと思うんですが、
Common Lisp的にこれはOKなんですかね?

Scheme 仲間では Bigloo がかなり高速です。ネイティブコードにコンパイルした場合、SBCL のような高速 CL に匹敵する場合もあります。
ちょっと古いけど、ベンチ。
http://www.cs.bath.ac.uk/~jap/ak1/youtoo/Bench/

とくに Bigloo の場合、コンパイラ用にコードに型情報を付加できたり、floating point 専用の関数 fl+, fl-, fl< ... のようなものが付いてきたり、かなりアグレッシブな処理系です。
もちろん互換性だとか Scheme のシンプルな美しさは失われますけど。また、今どきの Scheme にしてはややライブラリが少ないです。

ちょっと使った印象としては、Scheme で数値処理などを中心に行いたければチェックしてみてみる価値はあります。
私の場合、そこまでするくらいなら Scheme 使わなくていいやと思って、SBCL を採用しましたが。

>>686
OK なんじゃない？新しい定義使いたきゃコンパイルしなおせばいいだけでしょ？

スレ違い覚悟で訊くけど、CPS(継続渡しスタイル)って、
実用的なプログラムで使っても、プロセスのスタック足りる？
とくにLisp/schemeじゃなくて普通の言語で書いた場合とか。

例えば、数千ノードのグラフ処理とか、かなり無理っぽい気がするんだけど…

>>689
足りるわけないだろ。
普通はスタックの GC を行う。

おお、なるほどスタックのＧＣか。
…って、ＣＰＳでスタックにゴミなんて発生するの？普通に全部戻ると思うんだけど。
関数末尾での呼び出しは、ゴミ以前にそもそも最初からスタックに積む必要はなさそうだし。

中でクロージャ使ってたらエクステントは長くなるでしょ。
環境をヒープにとるならともかく。

>>688
OpenLispはコンパイルしなおさなくても新しいマクロが反映して
clispはコンパイルしなおせば反映するんですが SBCLはコンパイルしても古いままです。

>>689
CPSだとスタックの消費がクロージャセル+環境の消費になります。
環境全体を保存すると 環境の消費 >= スタックの消費 なのでメモリ消費は減らないと思います。
クロージャから参照されている変数だけ環境に保存すれば減ると思います。
schemeなら末尾呼び出しでいいですけど末尾呼び出しが最適化されていない言語では
他の方法を考えないといけません。

>>691 >>693
意味わからん。

関数の再コンパイルもコンパイルにかかる時間とそれで得する時間を考えると
自動化は難しいのかもしれないです。
compile! expr levelで(compile! f 3)みたいに手動ですればいいのかも。

SBCL でもコンパイルしなおせば新しいマクロが反映されるけど?

>>695
コンパイルしなおすっていうのはもう一回 defunの式を書くってことですね。
(compile 'f)としていたので古いマクロが使われてました。
clispはデフォルトで(compiled-function-p #'f)がNILなので新しいマクロが
使われているだけでした。

しかしこれでは evalや loadでマクロが定義された時の動作が処理系依存に
なるような。CommonLispのことは全然知らないので外してるかもしれませんが。
Schemeでもいろいろ調べてみます。

>>696
> clispはデフォルトで(compiled-function-p #'f)がNILなので新しいマクロが
> 使われているだけでした。

そりゃコンパイルしてないってことじゃ？
それと sbcl って repl 上でも on the fly でコンパイルするんじゃなかったっけ。
ええと、何はともあれその辺の微妙な挙動を詰めたいなら、
仕様書をちゃんと当たっといた方がいいかと。
http://www.lispworks.com/documentation/HyperSpec/Body/03_b.htm

gaucheのライブラリをCで書くときのお作法のドキュメント、どこかにありますか？

Gauche-mqueueってのを実装するサンプルがアーカイブに入ってた希ガス。
ドキュメントもちゃんとShiroさんが書いたの入ってたと思うけど。
スタブジェネレータとか既存のスタブで勉強しないで手取り足取り親切に
教えてくれるようなのを期待してるとしたら多分ない。

この辺のAPI見直す予定ってアナウンスされてるからそれまで待てば？

>>699
あ、ほんとだ。READMEにも説明書いてありますね。
ネット上だけ探してた…

>>687
> Scheme にしてはややライブラリが少ないです。
bigloo-lib http://bigloo-lib.sourceforge.net/(ダンロードhttp://sourceforge.net/project/showfiles.php?group_id=3455)
もあります。

内部にHaskellのような型システムを持っているのでbiglooとCの型から新しい型を定義することも可能ですが、ドキュメント化されてません。bigloo-libの人達が「ドキュメント化してくれ〜」と言っても「未完成だからドキュメント化しない」と答えて6年以上になるでしょうか。

bigloo-libのSRFIですら取り込まれる気配が無いし、*bigloo-version*のような基本的なシンボルをChangeLogに書かずに消してしまってbigloo-libがコンパイルできなくなったりとか、孤高の天才の高性能コンパイラ、という印象です。

>>687
>Scheme で数値処理などを中心に行いたければチェックしてみてみる価値はあります
biglooでデータ構造の最適化をしようとするとCの型が増えていきますが、書いているうちに制限の多いCでコーディングしているような錯覚に陥って、なんでこんなことしてるんだろうと思ったこともあります。

>Scheme のシンプルな美しさは失われますけど。
A practical Scheme compilerとあるように、美しさではなくて簡単にCと共存できる実用性を目指している処理系だと思います。Xlib.hを読み込んでbiglooのインクルードファイルが平気で生成されたときにはびっくりしました。

何かまともなことをやろうとすると独特のコーディングが要求されるので、それに慣れるまでけっこう大変だと思います。私がいじってた頃はインタプリタのreplが末尾再帰でなかったので途中でやめてしまいましたが。
アグレッシブと言うよりアレゲかもしれません。名前はstalinに負けてますが。

ただし出来上がってしまえば、やたらにパフォーマンスのいいものが出来ると思いますよ

>>701
補足しておくとbiglooの型システムはbigloo上のオジェクトシステムとは別物です。
bigloo本体を書換えずにプリミティブを作成したり、既存型を拡張したりできます。
type、subtype、coerceなどのキーワードが出てきます。

bigloo-libのcgenがbiglooへのプリプロセッサとして型に対する細々とした操作を
代りにやってくれます。

ChangeLogのバグフィックスが気にならなければ、少し古いbiglooでbigloo-libの
コンパイルは可能だと思います。

biglooがbigloo-libとの連携さえしっかりしてくれれば、またbiglooやりたいと
思ってます。bigloo-libのコンパイルで失敗する度にbigloo-libの人達の気持を勝手に
想像して、暗い気分になるのが嫌なだけかもしれません。それも思い込みで。

期待しすぎてコケたので否定的なことを書きましたが、biglooにはいじれる所がたくさん
あるので、最初はschemeだとは思わずに遊んでみると幸せになれるんでないでしょうか。

すれ違いで悪いけど
bigloo って INRIA でしょう？
良く知らないけど INRIA の本命は OCaml じゃないのかなあ。

>>704
INRIAだって大組織だからいろんな先生が居るだろうし、統一した意思を
持っているとはとても思えない。

Eiffel やってる人も居るね。

http://smarteiffel.loria.fr/

これも C or Java に変換する系

>>689
末尾再帰の最適化がきちんとされる言語ならば。
例えばluaはそう。

>>707
lua sugeeeeeeee!!!!

>>689, >>707
＞とくにLisp/schemeじゃなくて普通の言語で書いた場合とか。

普通の言語ってのがよくわからんが、luaは普通の言語なの？
とりあえずメジャーな言語だと、Javaが処理系依存だけど末尾再帰を最適化してた。
たしかIBMのVM、SUNはやってなかったと思う。

末尾再帰の最適化は多くの場合はコンパイラの最適化オプション（GCC とか）であって、
言語仕様として要求される事は少ないですね。関数型言語くらい?

おまいら、DrSchemeの話しようぜ

L#なんてのもあったんですね。.Net用のLispだとか。
http://www.lsharp.org/

普通の奴らの上を行け、を読んで
ハッカーはlispを習うもんだと洗脳されたので
GWにschemeを勉強しようと思うのですが
間違っていないですよね？

はい。間違っていません。

>>713
GW 中に SICP 読破できれば完璧です。

>>709
luaはふつ〜の言語だよおｗ
JavaScrpit似でゲームに組み込まれてる言語の中では一番メジャー

>>715
もうちょっとでかい字で印刷してほしかったと思った。

眼鏡新調かのぉ

http://www.ccs.neu.edu/home/will/Larceny/

Larceny って地味に更新されてるのね。IA32 向けのアセンブリ出力
出来るようになってたの知らんかった。

>>710
関数型言語でも、言語仕様で末尾最適化が明記されてるのは稀だとおもう
HaskellもOCamlも当たり前のように最適化を行うけど、言語仕様には含まれてなかったような・・・
(間違ってたらスマソ)

MLは常識、Haskellはする必要がない

coerceってなんて発音するの？

こえーす

http://www.m-w.com/dictionary/coerce で発音が聞ける。

おまいらDrSchemeの話をしろ。
強制だ。

昨日、MacにGaucheをインストールしようとして、うまくいかなかったので、
Dr.Schemeを代わりにインストールした。
学習目的にはいいかも。他にもおもちゃ的要素があって楽しい。

MrED というのを見るたび、勃起不全の知人を思い出して笑ってしまう。

>>726
そこは笑うところじゃないだろ。

処理系を(特にCで)作るとき、どこからどんな順で作っていきますか?
自分はエラー処理は当初はabort一択、GCもさっぱり忘れて
作り始めて、ある程度形になるまではそのままいっちゃうんですが。

GCは、少なくともどういう方針でゆくか (オブジェクトの移動は
ありか/conservativeで行くか明示的にprotectするか/SCMみたいに
固定長ヘッダだけ自前で管理して後はmallocに任せるか、それとも
全て自分で面倒みるか、等) だけは決めとかないときつくない?

Schemeで、文字列だけでなく数値やリストを連結してひとつの文字列にしてくれるような関数はありますか。
(concat "foo" 123 '("a" "b" "c"))
が
"foo123abc"
になるような感じです。

>>730
自分で書いてみました。初心者なんであまりうまくないでしょうけど。
(define (string-concat list)
(if (eq? list '())
""
(string-append (car list)
(string-concat (cdr list)))))

(define (to-string val)
(cond ((string? val)
val)
((number? val)
(number->string val))
((boolean? val)
(if val "true" "false"))
((symbol? val)
(symbol->string val))
((eq? '() val)
"")
((list? val)
(string-concat (map to-string val)))))

(to-string '("foo" 123 #f 'symbol (10 20 30))) ;; 結果："foo123falsequotesymbol10quote2030"

なんか、この程度なら標準関数にありそうな気はするんですけど。
というか、Shemeの入門ページはいくつかありますが、関数リファレンスみたいなのが見つからないです。
どこかによさげなのないですか。

>>731
関数リファレンスなんてR5RS（とSRFI）を見ればいいじゃん。

>>731
Gaucheのマニュアルが充実してる。
根拠になる規格(SRFI)の番号も付記してるから何かと便利。
Gauche使いでなくても手元にあって損はないと思うよ。
日本語でこれだけそろってる資料は少ないんじゃないかな。

話の腰を折って申し訳ないんですけど、質問す。
当方 SCM のインストールを試みているのですが、
build の途中で以下のメッセージが出て scmlit のプロンプトに入ってしまいます。

> ;In file loaded from /home/hoge/work/cvs/scm/Init5e2.scm:782:
> ;ERROR: "/usr/local/lib/slib/require.scm": unbound variable: *features*
> ; in expression: (cons (#@software-type) *features*)
> ; in scope:
> ; (provided? feature-list . #@define)
> ; (expression) procedure provided?
> ; defined by load: "/usr/local/lib/slib/require.scm"
>
> ;STACK TRACE
> 1; (#@define ((provided? (#@lambda (expression) (if (memq express ...
> 2; (#@cond ((#@slib:provided? (#@quote srfi)) (slib:provide (quot ...
> 3; (#@define ((hss (#@has-suffix? #@file (#@scheme-file-suffix))) ...
> 4; (#@load (#@in-vicinity (#@library-vicinity) "require"))

SCM だと特に slib の init を弄らなくていい、ということだったので、
てっきり簡単に build できるものと思っていたのに…。
slib 同梱の Template.scm に *features* のための configure だとかなんとか
書いてあったのでこれをどうにかするのでしょうか？
あと build のオプションも -F をいろいろ試してみましたが結果は同じ。
いかにも素人くさい質問なんですがご助力おねがい致します。

SCM -> cvs 先端
slib -> 3a3
環境 -> linux Kernel 2.6.16.11 (Archlinuxというマイナーなやつです)

releaseじゃなくていきなりcvsから引っ張ってきて失敗したからって
質問されても。しかもドキュメントもろくに読んでないっぽいな。

>>729
ある程度の見通しは立てて、それを阻害しないような選択はするけど、
基本的には忘れます。

>>735 レスどうもです。
まったくおっしゃる通りで返す言葉もございません。
release落としてやってみたらすんなり通りましたorz...。

ドキュメントは読んだんですが、エラーメッセージからしてきっと単純なミスなんだと
思い込み、あれかこれかと憶測で試みた後、結局自分の無理解を思い知らされた格好です。

それでも懲りずに質問なんですが、r4rstest.scm を走らせると

> errors were:
> (SECTION (got expected (call)))
> ((6 5 6) (#f #t (mult-float-print-test #f)))
> ((6 5 6) (#f #t (mult-float-print-test #f)))
> ((6 5 6) (#f #t (mult-float-print-test #f)))
> ((6 5 6) (#f #t (mult-float-print-test #f)))
> ((6 5 6) (#f #t (mult-float-print-test #f)))

というエラーが出ます。
どこかでこれは実行環境の浮動小数点数の入出力の精度によるもので、
大して気にすることはないとあったと思うのですが、そういうものでしょうか。
初心者が気にするようなところではないのでしょうが、
どうにかしようがあるのなら、どうにかしたい気がします。

>>737
そんなに気になるならどういうテストだかちゃんと調べて自分の頭で考えて
みればいいじゃないか。謙遜かもしれんが、自分で自分を「初心者」と呼ん
でるうちは進歩しないぞ。

>> 738
そうですね。泣き言いわずに自分で頑張って調べてみることにします。
Bootstrap にするには良い取っ掛かりかも知れません。
どうもでした。

俺はふどー小数点は諦めてる
どうせ使わないし
Cと同じ動作すればとりあえず実用上問題ないし

CLtL2の浮動小数点のとこはGuy Steeleの執念を感じる

むしろ浮動小数点数を基本にして NaN の中に fixnum 等を埋め込む

>>742
ALUレベルから設計したくなるな。

前に今は亡きbitで読んだJava関係のGLSのネタには感動した。
sinの精密な定義にえらい時間をかけてるとか。

>>743
あれだ、Opteronのソケットに挿せるFPGA。

>>737
まったく気にしないよりは気にした方がいいと思うけど、
気にしたからといって全ての問題が解決できるわけじゃないからね。
ここはそういうことがあったと心に留めておいて、ひとまずは先に進むのがいいのでは?
何をしたくてSCMをインストールしたのか知らないけど、目的はあったんでしょ?

Gauchのコマンドgoshって、readlineをサポートしないのでしょうか。
インタラクティブに実行できるのはいいんですが、C-pとか使えるようになってほしいんですけど。

>>747
ledit
ttp://cristal.inria.fr/~ddr/

rlwrap
ttp://utopia.knoware.nl/~hlub/uck/rlwrap/

>>747
Gauche-readline
http://www.netlab.is.tsukuba.ac.jp/~yokota/izumi/gauche/

このごろscheme勉強はじめたんですが、
listの操作でいろいろなクイズ（パズル？）ありますよね。
あれでおもったんですが、ああいったlistの操作を群論にあてはめるような
研究(遊び？)ってないんでしょうか。
つまり、群論の最初でやる置換群を拡張したようなもの。

もしあるならば、任意のリスト遊びがある記号に対応し、
その記号を分解していくことで、
任意のリスト遊びが、記号の積で自明にあらわせないものかと。

こういうことは誰でもおもいつくものだから、
すでに誰かやっている、もしくはやっても意味無い事の説明でも
どこかにころがってないかな、と思い質問いたします。

http://www.amazon.co.jp/exec/obidos/ASIN/4757727151/
S式ってあるけど、Lispとは関係なさげ

ライトノベルってやつか。
以前もプログラミング用語使った題名の作品をこの板で見たな。

登場人物のお姉ちゃんの名前にコンパイラだのインタプリタだのついてる漫画もあった気がする。

eq とかを名前に使うのはどうかしてる。

ヒロインが大学院で関数型言語を研究してたりな。

ttp://scrapbook.ameba.jp/lightnovel_book/entry-10011000402.html
＞惣一くん……足で踏まれて逝ってしまったり、無理矢理服を
＞脱がされて全身の隅々までニオイを嗅がれて
＞しまったりと、汚され過ぎですっ！　うはっｗｗｗをｋｗｗｗｗ

どうやらLispとは関係なさそうです。

LispでOpenGLを扱いたいのですが、何かオススメの処理系はありませんか？
OSはWinXPを考えております。今のところGauche-glぐらいしか知りません。

SRFI をつらつら眺めてみたけど、Scheme って便利そうね。
R6RS はいつになるんだろう…

桜が咲く頃かな

アイスランドで桜が咲く頃になれば・・・

vim7が、リリースされましたが、
mzscheme interfaceが、内蔵されました。
vim6の時点で、perl,python,rubyがdynamic linkされたvimを作ることが出来ましたが、
mzschemeは、そのまま、staticに取り込まれているみたいです。

詳しくは、vim7上で、
:help mzscheme
してみてください。


;;schemeの開発環境としては、どうなんでしょうね？

;;ここまで書いて気づいたけど、pythonもstatic linkっぽい。

もうちょっとだけ、すいません。

helpをもうすこし読んでみたら、上記の言語、(perl,python,ruby,mzscheme)の他に
tclも含めて、vimのエディターマクロっぽく使えるみたいですね。
(別途、vim scriptもあるんですが。)

エディターマクロっぽくっていうのは、エディターの環境/設定が変更できて、
バッファの内容が、操作できるって意味で使っています。

例を上げると、
(set-buff-line-list {start} {end} {string-list} [buffer])
みたいな関数が有りました。

と、言うことは、emacsみたいじゃーーん。scheme版のーー。

と、ちょっと興奮してしまいました。

;;すれ違いぽかったら、ごめんなさい。
;;けど、text操作なら、私的にはperlの方が楽チンかなぁ…。

guile scheme のインタプリタ使ってるんだけど、環境をクリアするにはどうしたらいいの?
いつもはguileを終了して再起動してるんだけど、もっと簡単な方法ない?

はじめまして，最近研究でacl(linux)をはじめたものです．
今,lispでfortranを走らせようとしているのですが，loadがうまくいきません.
環境変数の設定
setenv LD_LIBRARY_PATH /usr/local/acl80.64:$LD_LIBRARY_PATH
共有ライブラリの作成とリンク
f77 -c -DAcl64Bit -l/usr/local/acl80.64/misc/ fnames.f
ld -shared -o fnames.so fnames.o /usr/local/acl80.64/libacli8010.so
を行った後， (load "fnames.so")としても
; Foreign loading fnames.so.
Error: Loading fnames.so failed with error:
fnames.so: cannot open shared object file: No such file or directory.
[condition type: file-error]
というエラーがでてしまい，共有ファイルが作成されていないと出てしまいます．
.soファイルが作成されているのに何故このようなエラーが出るのか，ご存知の方
がいらっしゃれば教えていただけないでしょうか？マニュアルを読んでいるのですが，
解決方法がみつからなくて・・・お願いします．

linuxならLDのPATHに無いとか？

straceとかでどのファイルを読みに行ってるか
見れなかったっけ？

REPLで:pwdしてみるとか*default-pathname-defaults*に何がバインドされてるかとか
調べて何処見に行ってるか確認したら？
いいなぁ64bit版ACL。とてもじゃないが買ってもらえんわ。うちじゃ。

色々と回答していただいてありがとうございました．早速試してみます．
内の教授がlisp好きで，大枚はたいて買っちゃったんですよ．俺は，lispがあるということさえ
知らなかったんでこれから勉強していきます．

>>750
Schemeじゃないが、飯高先生がPrologで入り口付近をやってた。
『Prologで作る数学の世界』（朝倉書店）

固定小数点数演算みたいな、ストレージクラスに依存する処理は Scheme では
どうするのでしょうか。使用目的は画像処理です。

MIT Scheme には fixed pointer が組み込みであるみたいだけど、普通は homo-
geneous vector とかを使うのかな。

あの、基本的なことで申し訳ないけど、schemeで改行文字ってどうやって表すの？

aという文字は#\aと表すけど、改行文字は？

#\newline

>>771
#\newline
つか、せっかくペラペラな言語仕様書（R5RS）なんだから、隅から隅まで読め

>>772-773
ｻﾝｸｽ。分かった読んでみる。

>>770
vector でがんばるか、自作の処理系に独自拡張をいれる。
でもこの言語に固定小数点が欲しいとか言われても…

>>770, >>775 知ってるとは思うけどSRFI-4 Homogeneous numeric vector data typeshttp://srfi.schemers.org/srfi-4SRFI-63 Homogeneous and heterogeneous arrayhttp://srfi.schemers.org/srfi-63SRFI-4 は使える処理系多いと思う。

>>775,776
レスどうもです。
homogeneous vector の SRFI を読んで、計算効率に付いても
ある程度考えている言語かなと思いました。やはり自作するのが
早道っぽいですね。

#scheme-jpというIRCチャンネルができたらしい

>>778
カッコだけで会話するの?

continuation を使って会話をします

(begin (call/cc (lambda (c) (display ">>780") (newline) (display "ふふ〜ん") (newline) (c (values 782 'デフォルトの名無しさん 'sage)))))

values いらんだろ

>>781 >>782
r5rsだといるんじゃねえの？
r6rsだといらんみたいだけど
どうなんだろう？

どうも，仕事の遅い翻訳者です．
WIDEの#scheme-jpに入ってみました．

Scheme かぁ。lisp-jp とかにしてくれればいいのに…。CL な人は入りにくいな