Lisp Scheme Part25

※ ここはCommon Lisp、SchemeをはじめとするLisp族全般のスレです ※

Part24: ttp://pc11.2ch.net/test/read.cgi/tech/1224939205/
Part23: ttp://pc11.2ch.net/test/read.cgi/tech/1215875388/
Part22: ttp://pc11.2ch.net/test/read.cgi/tech/1211381920/
Part21: ttp://pc11.2ch.net/test/read.cgi/tech/1207300697/
Part20: ttp://pc11.2ch.net/test/read.cgi/tech/1205021786/
Part19: ttp://pc11.2ch.net/test/read.cgi/tech/1200237296/
Part18: ttp://pc11.2ch.net/test/read.cgi/tech/1186922295/
Part17: ttp://pc11.2ch.net/test/read.cgi/tech/1177065699/
Part16: ttp://pc11.2ch.net/test/read.cgi/tech/1172404795/
Part15: ttp://pc10.2ch.net/test/read.cgi/tech/1151025773/
Part14: ttp://pc8.2ch.net/test/read.cgi/tech/1132275726/
Part13: ttp://pc8.2ch.net/test/read.cgi/tech/1115901841/
Part12: ttp://pc8.2ch.net/test/read.cgi/tech/1100229366/
Part11: ttp://pc5.2ch.net/test/read.cgi/tech/1091456033/
Part10: ttp://pc5.2ch.net/test/read.cgi/tech/1075630259/
Part09: ttp://pc2.2ch.net/test/read.cgi/tech/1069594582/
Part08: ttp://pc5.2ch.net/tech/kako/1058/10582/1058263391.html
Part07: ttp://pc5.2ch.net/tech/kako/1042/10421/1042167213.html
Part06: ttp://pc3.2ch.net/tech/kako/1031/10315/1031560687.html
Part05: ttp://pc3.2ch.net/tech/kako/1023/10230/1023091882.html
Part04: ttp://pc.2ch.net/tech/kako/1016/10162/1016211619.html
Part03: ttp://pc.2ch.net/tech/kako/1008/10082/1008220265.html
Part02: ttp://pc.2ch.net/tech/kako/1002/10025/1002584344.html
Part01: ttp://piza2.2ch.net/tech/kako/987/987169286.html

□テンプレート置き場□
ttp://wiki.fdiary.net/lisp/ (id:guest pass:cl)

□参考リンク□

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

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

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

Practical Scheme (日本語)
ttp://practical-scheme.net/index-j.html
Scheme処理系「Gauche」の作者である川合史朗氏のサイト。
「普通のやつらの上を行け」など、興味深い文書を沢山翻訳されてます。

LispUser.net (日本語)
ttp://lispuser.net/
Lisp関連の有用な情報がまとめられています。Common Lispの話題が中心。

面倒くせえ
後は誰か頼むw

□仕様関係□

CLtL2: Common Lisp the Language 2nd edition (英語)
ttp://www-2.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html

CLHS: Common Lisp Hyper Spec (英語)
ttp://www.lispworks.com/documentation/HyperSpec/Front/index.htm

Common Lisp Quick Reference (英語)
ttp://clqr.berlios.de/

R5RS: Revised(5) Report on the Algorithmic Language Scheme (英語)
ttp://swiss.csail.mit.edu/~jaffer/r5rs_toc.html

R5RS: Revised(5) Report on the Algorithmic Language Scheme (日本語)
ttp://www.sci.u-toyama.ac.jp/~iwao/Scheme/r5rsj/html/r5rsj.html

ERR5RS: A proposal for an Extended R5RS Scheme (英語)
ttp://scheme-punks.cyber-rush.org/wiki/index.php?title=ERR5RS:Charter

R6RS: Revised(6) Report on the Algorithmic Language Scheme (英語)
ttp://www.r6rs.org/final/html/r6rs/r6rs.html

□Wikipedia関連□

ttp://ja.wikipedia.org/wiki/LISP
ttp://ja.wikipedia.org/wiki/Common_Lisp
ttp://ja.wikipedia.org/wiki/Scheme

□継続関連□

なんでも継続 (日本語)
ttp://practical-scheme.net/docs/cont-j.html

Schemeへの道:継続 (日本語)
ttp://www.stdio.h.kyoto-u.ac.jp/~hioki/gairon-enshuu/SchemeNotes/continuation.html

継続の使い方 (日本語)
ttp://www.geocities.co.jp/SiliconValley-PaloAlto/7043/index.html#continuation

継続の使用法 (日本語)
ttp://www.ice.nuie.nagoya-u.ac.jp/~h003149b/lang/block.html

Kahua: 継続ベースのアプリケーションサーバ。
ttp://www.kahua.org/

□書籍関連(1)□

Structure and Interpretation of Computer Programs (英語)
ttp://mitpress.mit.edu/sicp/
通称「SICP」として知られる『計算機プログラムの構造と解釈』の原書です。
全文がオンラインで読めます。
ttp://sicp.ipl.t.u-tokyo.ac.jp/ (日本語版サポートサイト)

Programming Languages: Application and Interpretation (英語)
ttp://www.cs.brown.edu/~sk/Publications/Books/ProgLangs/
ブラウン大学で使われている、Schemeを使ったプログラミング言語論の教科書。
SICPでは触れられていない継続についても、Webアプリと関連づけて詳述されています。
全文がpdf形式でダウンロードできます。

How to Design Programs (英語)
ttp://www.htdp.org/2003-09-26/Book/
Schemeを使った優れたプログラミング入門書。全文がオンラインで読めます。

The Little Schemer (英語)
ttp://www.ccs.neu.edu/home/matthias/BTLS/
The Seasoned Schemer (英語)
ttp://www.ccs.neu.edu/home/matthias/BTSS/
Schemeの教科書として定評のある「Schemerシリーズ」のサポートページです。

The Scheme Programming Language (英語)
ttp://www.scheme.com/tspl3/
Scheme入門書。全文がオンラインで読めます。

□書籍関連(2)□

『プログラミングGauche』 (日本語)
ttp://ssl.ohmsha.co.jp/cgi-bin/menu.cgi?&ISBN=978-4-87311-348-7
ttp://karetta.jp/book/gauche-hacks (立ち読み版)
ttp://karetta.jp/book-cover/programming-gauche (サポートページ)
Scheme処理系言語Gaucheの初の解説書！

『入門Scheme』 (日本語)
ttp://www4.ocn.ne.jp/~inukai/scheme_primer_j.html
幻となったScheme入門書。全文がダウンロードできます。

Common Lisp: A Gentle Introduction to Symbolic Computation (英語)
ttp://www.cs.cmu.edu/~dst/LispBook/
Common Lispを使った非常に丁寧なプログラミング入門書。
全文がpdf形式でダウンロードできます。

Practical Common Lisp (英語)
ttp://www.gigamonkeys.com/book/
ttp://ssl.ohmsha.co.jp/cgi-bin/menu.cgi?ISBN=978-4-274-06721-1
S式の羅列で現実的な問題をどう解くのか、そのギャップに悩まされてる人に。
全文がオンラインで読めます。日本語版は『実践Common Lisp』として出版されています。
ttp://pcl.lispuser.net/ (日本語版非公式サポートページ)

『On Lisp』 (日本語)
ttp://ssl.ohmsha.co.jp/cgi-bin/menu.cgi?ISBN=978-4-274-06637-5
ttp://user.ecc.u-tokyo.ac.jp/~tt076524/onlispjhtml/ (日本語訳HTML版)
ttp://www.paulgraham.com/onlisp.html (英語原文がダウンロード可)
LispハッカーPaul Grahamが、Lispの力の源泉であるマクロプログラミングを解説。

実装いろいろ
ttp://community.schemewiki.org/?scheme-faq-standards#implementations

□その他(1)□

John McCarthy's Home Page (英語): Lispの生みの親、ジョン・マッカーシーのサイトです。
ttp://www-formal.stanford.edu/jmc/

Association of Lisp Users (英語): 米国のLispユーザ会です。
ttp://www.alu.org/alu/home

CLiki (英語): Common Lisp関連のリソースが集積されています。
ttp://www.cliki.net/index

CMU Common Lisp Repository (英語): 新旧様々なプログラムが置いてあります。
ftp://ftp.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/lisp/0.html

The Common Lisp Cookbook (英語): いわゆるCookbookです。
ttp://cl-cookbook.sourceforge.net/

The EncyCMUCLopedia (英語): CMUCL関連文書。CMUCLユーザーでなくとも有益なはず。
ttp://www.isr.ist.utl.pt/library/docs/encycmuclopedia/doc/

Common-Lisp.net (英語): 多くのプロジェクトがホスティングされています。
ttp://common-lisp.net/

よろずや (日本語): Lisp関連の実用的な情報が色々。
ttp://www.geocities.co.jp/SiliconValley-SanJose/7474/

どう転んでもLisp (日本語): 竹内郁雄氏による発表のスライドです。
ttp://jp.franz.com/base/seminar/2005-11-18/SeminarNov2005-Takeuchi.files/v3_document.htm

Lispとは何か (日本語): 中村正三郎氏による発表のスライドです。
ttp://www.asahi-net.or.jp/%7Eki4s-nkmr/lisp20061121/lisp.html

□その他(2)□

独習Scheme三週間 (日本語): Schemeの教科書。
ttp://www.sampou.org/scheme/t-y-scheme/t-y-scheme-Z-H-1.html

Bibliography of Scheme-related Research (英語): Scheme関連の論文リンク集。
ttp://library.readscheme.org/

Scheme Hash (英語): S式でXMLを使えるようにするSXML等。
ttp://okmij.org/ftp/Scheme/index.html

Scheme-users.jp (日本語): Schemeユーザのためのハブサイトです。
ttp://scheme-users.jp/

(Scheme) (Lisp) (日本語): 各種Scheme処理系をCygwin上でビルドする方法など。
ttp://www.geocities.co.jp/SiliconValley-PaloAlto/7043/

SLIB (英語): Scheme用のライブラリとして有名なSLIBのサイトです。
ttp://swiss.csail.mit.edu/~jaffer/SLIB

Scheme Requests for Implementation (英語): いわゆる「SRFI」のサイトです。
ttp://srfi.schemers.org/

Meadow memo: 2ちゃんねるログ: dat落ちした過去スレの一部が見られます。
ttp://www.bookshelf.jp/2ch/index.html

□その他(3)□

初心者が集うIRC（布教してくれる先生も大募集です）。
irc.scenecritique.com
port 6667
チャンネル　#Lisp_Scheme

Schemeのテストコード書いたり、簡単な実行したりコードさらしたりするにはここへカモン。
ttp://codepad.org/
コードを書いて実行した時のURLを記録しておけば、実行結果も一緒にさらす事が出来て幸せです。

□Schemeの実装(1)□

Gauche: マルチバイト文字に対応したR5RS準拠のScheme処理系。川合史朗氏作。
ttp://practical-scheme.net/gauche/index-j.html
ttp://jp.youtube.com/watch?v=WEBOdWyGE3E (川合史朗氏によるGaucheに関するトーク)

PLT Scheme: DrScheme、MzSchemeなどのR5RS準拠および独自拡張のScheme処理系。
ttp://www.plt-scheme.org/

Scheme48: R5RS準拠のSchemeバイトコードインタプリタ。
ttp://www.s48.org/

Gambit-C: R5RS準拠のScheme処理系。
ttp://dynamo.iro.umontreal.ca/~gambit/wiki/index.php/Main_Page

Chicken: R5RS準拠のScheme処理系。スタンドアロン実行ファイルが簡単に作成可能。
ttp://www.call-with-current-continuation.org/

Stalin: 激烈な最適化を施すScheme処理系。人間の書くCコードより速いという噂。
ttp://cobweb.ecn.purdue.edu/~qobi/software.html
ftp://ftp.ecn.purdue.edu/qobi/fdlcc.pdf (Stalinの最適化技術を解説した論文)

Bigloo: CLR用のコードを吐けるようになったらしい。
ttp://www-sop.inria.fr/mimosa/fp/Bigloo/

Guile: R5RS準拠のGNU公式拡張用言語。もちろんSLIBも使えます。
ttp://www.gnu.org/software/guile/guile.html

JScheme: Javaで書かれたR4RS準拠Scheme処理系。Javaインターフェイスをサポート。
ttp://jscheme.sourceforge.net/jscheme/main.html

□Schemeの実装(2)□

Chez Scheme: R6RS準拠の商用Scheme処理系。インタプリタはフリー。
ttp://www.scheme.com/

Ypsilon Scheme System: 藤田善勝氏が開発中のR6RS準拠のScheme処理系。
ttp://www.littlewingpinball.net/mediawiki-ja/index.php/Ypsilon_Scheme_System

Mosh: higepon氏が開発中のR6RS準拠Scheme処理系。
ttp://code.google.com/p/mosh-scheme/

SECDR-Scheme: SECD machine modelに基づく実装。
ttp://lily.fan.gr.jp/~kmd/adhoc/view.rhtml?n=SECDR-Scheme_woyomu

LispMe: Palm上で動くScheme処理系。これもSECD virtual machine。
ttp://www.lispme.de/lispme/

Minischeme: 1ファイルに凝縮されたScheme処理系。
ttp://tinyscheme.sourceforge.net/minischeme.tar.gz

TinyScheme: Minischemeを色々弄ったもの。
ttp://tinyscheme.sourceforge.net/

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

Bit: Minischemeよりも小さい（？）バイトコード変換系。
ttp://www.iro.umontreal.ca/~dube/

KI-Scheme, AM-Scheme, etc...
ttp://www.nifty.com/download/dos/prog/lisp/

□Common Lispの実装□

Steel Bank Common Lisp: 代表的なCommon Lisp処理系。CMUCLより派生。
ttp://www.sbcl.org/

CMUCL: Common Lisp処理系。
ttp://www.cons.org/cmucl/

GNU CLISP: Common Lisp処理系。バイトコード変換系。
ttp://www.clisp.org/

Clozure CL: Common Lisp処理系。
ttp://trac.clozure.com/openmcl

Embeddable Common Lisp: Cで書かれたプログラムへの埋め込みが可能なCommon Lisp処理系。
ttp://ecls.sourceforge.net/

Armed Bear Common Lisp: JVM上で動くCommon Lisp処理系。JVMバイトコード変換系。
ttp://armedbear.org/abcl.html

Allegro Common Lisp: 代表的な商用Common Lisp処理系。
ttp://www.franz.com/products/allegrocl/

LispWorks: 商用Common Lisp処理系。
ttp://www.lispworks.com/

Corman Common Lisp: 商用Common Lisp処理系。
ttp://www.cormanlisp.com/

Scieneer Common Lisp: 商用Common Lisp処理系。
ttp://www.scieneer.com/scl/index.html

　　　　　　　／/
　　　　　／　 /　　　ﾊﾟｶｯ
　　　　 //⌒)∩＿＿∩
　　　　/.|　.| ノ　　　　　ヽ
　　　 /　|　| 　●　　　● | 　　　　
　　　/ 　|　彡　　( _●_)　ミ 　まピョーん☆
　　 /　　|　ヽ　　|∪|　　/＿
　　/／　│　　　ヽノ　　＼／
　　"￣￣￣￣￣￣￣（..ノ

□その他の実装□

awklisp: Awkで書かれたわずか500行のLispインタプリタ。
ttp://www.accesscom.com/~darius/

CAMPUS LIsP Lemon version: Cでわずか1000行。
ttp://www-masu.ist.osaka-u.ac.jp/~kakugawa/hacks/clisp/

Lisp interpreter in AS3: ActionScriptで書かれたLispインタプリタ。
ttp://www.solve-et-coagula.com/?p=8

Arc: ポール・グレアム氏が開発中の新しいLisp。
ttp://arclanguage.org/

Clojure: MLやHaskellの特長を取り入れた新しいLisp。JVMバイトコード変換系。
ttp://clojure.org/

Qi: MLやHaskellの特長を取り入れた新しいLisp。型の定義にシーケント計算表記を用います。
ttp://www.lambdassociates.org/

GOO: DylanとSchemeの影響を受け、OOPをサポートした新しいLisp。
ttp://people.csail.mit.edu/jrb/goo/

Liskell: Lispの顔をしたHaskell。
ttp://liskell.org/

□イベント関連□

Shibuya.lisp
ttp://shibuya.lisp-users.org/
東京地区、特に渋谷周辺半径2万キロの Lisp 系プログラマによる非営利団体。
第1回テクニカルトークは2008年10月18日に開催されました。

GaucheNight (2008-03-08)
ttp://practical-scheme.net/wiliki/wiliki.cgi?gauche.night
「SchemeとGaucheとλとS式を愛するすべての人に贈るマクロな一夜」
出演：川合史朗、伊藤篤、山下伸夫、笹田耕一、ひげぽん、zick、
　　　黒田寿男、えんどうやすゆき、ほか

GaucheNight (2007-05-09)
ttp://practical-scheme.net/wiliki/wiliki.cgi?GaucheNight%3a2007
出演：川合史朗、黒田寿男、まつもとゆきひろ(Skype中継)、小飼弾、
　　　伊東勝利、久井亨、小黒直樹、ほか

黒田寿男氏関係 (黒板の人)
ttp://pc10.2ch.net/test/read.cgi/tech/1151025773/901-909
ttp://www.bookshelf.jp/2ch/tech/1151025773.html#901
Schemeのマクロに関する黒田氏の所感
ttp://cl-www.msi.co.jp/solutions/knowledge/lisp-world/articles/scheme
それに対する川合史朗氏の応答
ttp://practical-scheme.net/wiliki/wiliki.cgi?Scheme%3a%e3%83%9e%e3%82%af%e3%83%ad%3aCommonLisp%e3%81%a8%e3%81%ae%e6%af%94%e8%bc%83
それに対する黒田氏の再反論
ttp://cl-www.msi.co.jp/solutions/knowledge/lisp-world/articles/gauche-night
それに対する川合氏の応答
ttp://practical-scheme.net/wiliki/wiliki.cgi?Scheme%3a%e3%83%9e%e3%82%af%e3%83%ad%3aCommonLisp%e3%81%a8%e3%81%ae%e6%af%94%e8%bc%83%3a%e6%84%8f%e5%91%b3%e8%ab%96

その他、黒田氏によるLisp関連のエッセイがこちらで読めます。
ttp://cl-www.msi.co.jp/solutions/knowledge/lisp-world/

□2ch上にあるLisp関連のスレ□

(make-thread :name common-lisp :part 5)
ttp://pc11.2ch.net/test/read.cgi/tech/1215834213/
Emacs Lisp 3
ttp://pc11.2ch.net/test/read.cgi/tech/1191875993/
【魔法】リリカル☆Lisp【言語】
ttp://pc11.2ch.net/test/read.cgi/tech/1183396621/
【SICP】計算機プログラムの構造と解釈 Part2
ttp://pc11.2ch.net/test/read.cgi/tech/1203096230/
【普通のやつらの】 Arc Language 0 【上を行け】
ttp://pc11.2ch.net/test/read.cgi/tech/1202098949/
【ＣＧＩ】実用比較Lisp vs C/C++【ＧＵＩ】
ttp://pc11.2ch.net/test/read.cgi/tech/1150501484/
【ﾔﾊﾟｰﾘ】XMLをS式に置換えていくスレ【LISP最強】
ttp://pc11.2ch.net/test/read.cgi/tech/1140006937/
Lisp@UNIX版
ttp://pc11.2ch.net/test/read.cgi/unix/1019926525/
Lisperこそ真のプログラマーよ！！
ttp://pc11.2ch.net/test/read.cgi/prog/1175791979/
LISPってさ〜
ttp://science6.2ch.net/test/read.cgi/sim/1015169050/
【数式処理システム】 Maxima 【Common Lisp】
ttp://science6.2ch.net/test/read.cgi/math/1220340695/

テンプレ長いよ！　連投規制に二回も引っ掛かったよ！

>>3
諦めんなよ！

>>8 >>15
お前らも手伝えよ！

これは乙じゃなくてλなんだからね

乙です

>>1
っT

1乙

Little終わったので萩谷先生の関数プログラミング買った。
3月まではこれとものまね鳥読む。

てんぷら増えすぎじゃないか？
毎回20レス近く潰れるのは無駄な気がする
どうせ雑談しかしてないし、こんな長いと読まないっしょ
仕様書程度でいいんじゃないか

つまり
Common Lisp→EuLisp
R6RS→R5RS
ですね 乙と違うんだからね

>>24
「仕方ない。代わりに貼るか→この分量マジすか」
というコンボを喰らった身としては、同意せざるを得ない。

細かい内容は、テンプレ置き場でまとめれば良いと思う。

　　　　　　　　　　 ∩＿
　　　　　　　　　 　〈〈〈　ヽ
　　　　　　　　　　〈⊃　　}
　　 ∩＿＿＿∩　 |　　 |
　　 | ノ　　　　　 ヽ !　　 !
　　/　　●　　　● |　　/
　 |　　　　( _●_)　 ミ／ まピョーん☆
　彡､　　　|∪|　　／
/　＿＿　 ヽノ　/
(＿＿＿）　　　

なんだお前？やるんか？
くらえ！つ nil

テンプレ置き場ってないし。

WiLikiあたり借りる？

>>29
>>2

テンプレが役に立ってないことがよくわかる。

>>30 の役には立っている。

on lisp読み終わったんだが
次はpractical common lisp読んだらいいのかな

schemeの対応する本はないのかな

SICP

>>34
昔、飛ばし読みしちゃったので
今度は問題やりながら読んできます

http://cheese.2ch.net/math/kako/1000/10001/1000107761.html
★１００！と１０００！の桁数の出し方★

http://codepad.org/lbITOona

>>36
このほうがいい。10000!の桁数も楽々

(define (place-of n)
(+ 1 (inexact->exact (floor (* 0.4342944819032518 (log n))))))

http://codepad.org/8evfGr7x

関数のアーギュメントの順番ってこうするのがいいって習慣みたいなのはないの？


(setf 出力　入力）
(with-open-file 変数　ファイル）

だと、出力 入力の順番なのかな？


この辺の例をみてると
http://www.geocities.jp/m_hiroi/xyzzy_lisp/abclisp11.html

(fun 主要なもの　補助的なもの　さらに補助的なもの...）

と定義してるようにも見えるんだけど　

その辺は場合にもよるから一般化はできないね。
反例は例えば with-input-from-string は入力が先だし。
まぁ、主要なもの、対象とするものが前のほう、くらいだろうね。

http://jibun.atmarkit.co.jp/ljibun01/rensai/genius/03/01.html
誰も言及しないのは何故。

既にCyanスレで見たから。

そんなのもあるんだ

クラスのないオブジェクト指向とかS式のないマクロとかは面白いね
大前提をぶっ壊すところが

>>43
S式の無いマクロならDylanがあるし、
プロトタイプベースのOOPならSelfとかがあるじゃん。

むしろ、そういう引用元の概念を、あの歳できっちり理解してるのが末恐ろしいよ。

５つの自然言語ならよかったのになあ

高速で使えるライブラリのそろったCyan実装が登場したら
Ruby以上に世界中のハッカーにインパクトを与えそう。

>>40
ニュータイプって感じだね。

私は信じんよ、ニュータイプの存在など

既存のpythonのlibraryが使えてマクロありなら便利かもね

現状だと荒削りだし、そりゃ言い杉なんじゃないかな。将来は楽しみだけど。
素直に理論面とかハードウェアの知識を学んでいったら楽しみだね。
まだだ、まだ終わらんよ！とか言わされちゃうのかなー

本人乙ｗｗｗ

クワトロ・バジーナ降臨ときいてすっ飛んできました。
アクシズ落とさないでね。

wikipediaのclikiのリンクが古いままだ

>>53
なんのための「Wiki」pediaだよ

>>53,54
直しておきますた ﾉｼ

>>37
goshだとexactな数値のlogがとれなかった

>>56
他の処理系みた？
Gaucheで数値計算するから・・・

>>56
普通にとれるだろ
gosh> (log 1000)
6.907755278982137
gosh> (log 10000)
9.210340371976184
gosh> (log 100000)
11.512925464970229
gosh> (* 0.4342944819032518 (log 1000))
3.0
gosh> (* 0.4342944819032518 (log 10000))
4.0
gosh> (* 0.4342944819032518 (log 100000))
5.0

gosh> (* 0.4342944819032518 (log 3628800))
6.559763032876794
gosh> (* 0.4342944819032518 (log 93326215443944152681699238856266700490715968264
38162146859296389521759999322991560894146397615651828625369792082722375825118521
0916864000000000000000000000000))
157.97000365471578

gosh> (log 402387260077093773543702433923003985719374864210714632543799910429938
51239862902059204420848696940480047998861019719605863166687299480855890132382966
99445909974245040870737599188236277271887325197795059509952761208749754624970436
01418278094646496291056393887437886487337119181045825783647849977012476632889835
95573543251318532395846307555740911426241747434934755342864657661166779739666882
02912073791438537195882498081268678383745597317461360853795345242215865932019280
90878297308431392844403281231558611036976801357304216168747609675871348312025478
58932076716913244842623613141250878020800026168315102734182797770478463586817016
43650241536913982812648102130927612448963599287051149649754199093422215668325720
80821333186116811553615836546984046708975602900950537616475847728421889679646244
94516076535340819890138544248798495995331910172335555660213945039973628075013783
76153071277619268490343526252000158885351473316117021039681759215109077880193931
78114194545257223865541461062892187960223838971476088506276862967146674697562911
23408243920816015378088989396451826324367161676217916890977991190375403127462228
99880051954444142820121873617459926429565817466283029555702990243241531816172104
65832036786906117260158783520751516284225540265170483304226143974286933061690897

96848259012545832716822645806652676995865268227280707578139185817888965220816434
83448259932660433676601769996128318607883861502794659551311565520360939881806121
38558600301435694527224206344631797460594682573103790084024432438465657245014402
82188525247093519062092902313649327349756551395872055965422874977401141334696271
54228458623773875382304838656889764619273838149001407673104466402598994902222217
65904339901886018566526485061799702356193897017860040811889729918311021171229845
90164192106888438712185564612496079872290851929681937238864261483965738229112312
50241866493531439701374285319266498753372189406942814341185201580141233448280150
51399694290153483077644569099073152433278288269864602789864321139083506217095002
59738986355427719674282224875758676575234422020757363056949882508796892816275384
88633969099598262809561214509948717012445164612603790293091208890869420285106401
82154399457156805941872748998094254742173582401063677404595741785160829230135358
08184009699637252423056085590370062427124341690900415369010593398383577793941097
00277534720000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000)
+inf.0

(log (fact 1000))が計算できないのはGaucheの事情。
http://practical-scheme.net/wiliki/wiliki.cgi?Gauche%3A%E6%95%B0%E5%80%A4%E3%81%AE%E5%85%A5%E5%87%BA%E5%8A%9B

http://practical-scheme.net/wiliki/wiliki.cgi?Gauche%3A%E7%B5%84%E3%81%BF%E8%BE%BC%E3%81%BF%E9%96%A2%E6%95%B0%E3%81%AE%E5%86%8D%E5%AE%9A%E7%BE%A9

一般的なlog10の計算の注意点
http://codepad.org/MjooyHH4

on lispの原著が34000円もするなんて・・・
最後のいくつかの章で図がみえないから欲しかったのに

何千ページの本なの？

http://www.paulgraham.com/onlisp.html
>> 65 ここから落とせない？　著者公開してるけど．

>>67
そこのは、例えばFigure 24.1
が見えないよ。他にも見えない図がいくつかあった

on lisp $13 しかし日本への送料が４０００円
http://www.lulu.com/content/3060872

こっちから買うかな
何冊かまとめ買いすれば送料安くなんないかな

日本語訳の本に載ってないって事？

ttp://www.amazon.co.jp/dp/0130305529/
ttp://www.amazon.com/dp/0130305529/
高いな

Head First Common Lispはまだか。

たぶん一生でないよw

主婦の友増刊号「誰にもわかるコモンリスプ」

片仮名で書くとめちゃくちゃイメージ違うなぁ。

フランス語みたい。

イロムサコン・フィヨンセ・コモンリスプ

特別寄稿ガイ・スチール・ジュニア氏
「君もリスプやらないか？」

「いいこと思いついた。
お前、俺のテイルジャンプで、メッセージパッシングしろ」

「アッーーク！」

アンジー・コモン・リスプ

微妙にﾜﾛﾀ

GaucheにIDE付けれの人まだ張り付いてるのか

Lisp 系言語だと emacs か vi しか選択肢が無いのは事実だけど、
あらたに統合環境を用意する積極的な理由ってのも無いんだよなー。

欲しいのはデバッガみたいだけど、
仮にデバッガが便利だとしても Scheme にふさわしいデバッガのモデル
は過去事例を研究したところで容易に決められるとは思わんのだよなー。

これだけ長い Lisp の歴史の中でいわゆる「デバッガ」が言及された
ことがそんなにないってのはただの偶然だとでも思ってんだろうか。

pltはそのへんがんばってるんじゃないの

なんでlispは歴史的にデバッガが言及されないの？

>>85
文脈嫁。

>>83 は、GCを考案し、動的言語の先駆けとなったLisp に、デバッガの話が持ち上がらなかったのは、Lispにデバッガが不要だから、と云いたいんだろ。

>>83は、これだけ長い Lisp (スレ)の歴史の中で、と言いたかったんだよ。

>>83
Schemeの話をLisp系と一般化しないでくれ。Emacs Lispのデバッガはなかなかいい、
CL系は昔から規格に最適化オプションで debug 指定ができたりと、デバッガは
売りにしてたよ。SchemeでもPLTやGuileはがんばってるじゃん。

DebuggerのないLisp machineなど存在しない。
もともとsmalltalk実装のモデルになったような
統合プログラミング環境を持っていたのがLisp。
今はむしろLLみたいな軽い環境が流行りで、
外界とのインターフェースは昔より豊か。

eclipseあたりに自力で作ってみたらいいのに

調べるのめんどくさいんでここで聞きますがscheme ってバイトコードはけるの

>>91
Kawa, JSchemeでｸﾞｸﾞﾚｶｽ

>>89
Smalltalkより前にIDEを持っていたLispってどんなLispだよｗ

つ ttp://ja.wikipedia.org/wiki/Interlisp

まったく関係ないがh抜き不便

アセンブラ使え

>>93
TECO+MacLisp
後継のEmacsがSmalltalk-76と同時期。

超古代文明の発掘みたいな。
断絶があるのはなぜだろう。

車輪の再発明と言ってだな、

>>82
別にどんな主張をしようが構わないが、
「デバッガ」っていう重要なカテゴリ以下を私物化してるのがちょっと……。
あれのどこがGaucheのデバッガの話なのよ？

何で、自分のページとか作って、そこでやらないんだろうね？

まあWiLilki的にひどすぎるということになれば管理者のShiroさんが強権発動するでしょ

俺はffiの項目を私物化したいぞおお
ジョジョオ〜

継続渡しマクロなんて作るぐらいなら
common lispの上にscheme作っちゃえばいいのに

みんながACL使えばみんなが幸せ

もっとお手頃価格でACL売ってくれ。
俺も使うから。

一方、ロシアのSchemerは黒板を使った。

>一方、ロシアのSchemerは黒板を使った。
作らないところが寂しいよな

>もっとお手頃価格でACL売ってくれ。
なんであんなに高いんだろうね？
年間売り上げみてみたいよ。


株主になっても一票そこに投じられそうもないのが悲しいやね

ロシアのLisp事情ってどんな感じなんだろう。
あそこは数学も物理も凄いんでしょ？

行って確かめてこいよ

ロシアは遠いし言葉がわからないから
かわりにロシアンパブ行ってきます。

ttp://sourceforge.jp/magazine/09/01/27/0039208

あとまあ、これもある意味予想通りではあるが、LispやScheme、Haskellと言ったあたりは、
結局のところ「語られる」言語であって、「使われる」言語ではないようだ。
HaskellにしろCommon Lispにしろ、近年ではライブラリも相当揃ってきており、
パフォーマンスの面から言っても実用言語として遜色ないものになりつつあるので、個人的には残念なのだが。

Emacs Lispも仲間に入れてほしいんですけど。

だが断る

各個人の問題として何故使わないのか。

先週新聞に載ってたセンター試験の数学�UAをやってみたんだけど
21世紀になって10年たとうというのにひどいBASICのプログラムが載ってたんだわ
高校生に勉強させるなら
COMETでもMIPSでもいいからアセンブラでやらせるか
BFで難易度高めにするか
LispやHaskelやForthで教養を身につけさせるかすればいいのに
あるいはスパコンのためにFortranを教えるか

>>114
次々と新たな処理系が開発されるのは、既にある処理系を使いたくないのかもな。
勉強のためだとしても、なんで人のソースを読むことより自分で書くことを選ぶのか。
それが問題だと思うよ。

IT音痴大国の名に恥じないな。

Lispはラテン語ではない。と誰かが言ったとか言わないとか。

むしろラテン語だろ

まあもう少し待ってれば予想外の変化が起きるかもよ

Lisp/Scheme類は法律で禁止され、地下で開発するしかないのだ。

>>115
あれはなんの冗談なんだろうと思ったな。
釣りじゃないのか、とか日付を確認したりとか。
徐々にその事実が恐ろしくなっていった。

>LispやHaskelやForthで教養を身につけさせるかすればいいのに
お前は俺かｗ

BFで難易度をってところにﾜﾛﾀ

http://d.hatena.ne.jp/niitsuma/20080209/1233260146

Lisperだけで会社作ったら、経営していけるかな。

http://codepad.org/7ozb95V2

漢詩って何かいいね。

情景が目に浮かぶようだね。霜ってのがまた良いな。

……ところで、ここ何のスレだっけ？

comp.lang.lispに何度か書き込みしてるはずなのに反映されない
なんでだろ

ネットニュースだから配送の問題とか？

http://quasiquote.org/log2/Scheme/Gauche/Gauche-lazy-ffi
をconfigure make make installしてから

gosh> (use lazy-ffi)
*** ERROR: Compile Error: failed to link "lazy-ffi" dynamically: /usr/lib/gauche/site/0.8.12/i486-pc-linux-gnu/lazy-ffi.so: undefined symbol: strlcpy
"(stdin)":2:(use lazy-ffi)

Stack Trace:
_______________________________________
gosh>


何が問題なのでしょうか

だからここはサポート掲示板じゃねえっつーの
またどうせバージョン違うんだろ

>>131
glibcにOpenBSD由来のstrlcpy(3)はありません。
http://www.openbsd.org/cgi-bin/cvsweb/src/lib/libc/string/
から持ってきてリンクしてください。
デストリによってはパッケージで提供されているかも知れませんが。

やっぱlinuxってきもいなー

gimp2.6.3(ほぼR5RS互換) のscript-fu で

(let ((foo 2)
(bar 3))
(display foo)
(display bar))
->23#t

これと同じ事がしたくて(返り値は無視して)
下のように書きましたが変数ではなく
文字列として扱われてしまいます。

(let ((foo 2)
(bar 3))
(mapcar (lambda (arg)
(display arg)) '(foo bar)))
->foobar(#t #t)

上に書いたlispと同じ動作にするにはどう書けば良いでしょうか？

>>135
「'」(クォート)をつかわず、 (list foo bar) としたら良いのでは。
あるいは `(,foo ,bar) (先頭はバッククォートね)かな。

letやmapcarが出てくるのにquoteが判らないとは
えらい偏った学び方したんだな
quoteはLISPの基礎

>>137
偏ってない。変数とシンボルを混同するのはLISPの名物。
変数とimmutableな文字列なら、混同することはあまりないのだが。

最近思うんだが、LISPは動的スコープに戻したほうがいいんじゃないか?
変数は常に(eval シンボル)と等価で、関数は常にS式と等価。
静的スコープではこれが成立しない。

'(1 2)と(list 1 2)の結果が同じだし、勘違いしちゃうことってあるよね

'multiple-value-bindについてるクオートがよくわからない．


(defmacro mvbind (&rest args)
(let ((name 'multiple-value-bind))
`(,name ,@args)))

これでうまくいった
(let ((foo 2)
(bar 3))
(mapcar (lambda (arg)
(display (eval arg))) '(foo bar)))

>>138
かなり偏ってるね
混同するのが名物とか、変な偏見も持ってそうだが
多分>>140-141もお前じゃないか？
きちんとした処理系で基礎から勉強し直した方がいいと思うね

>>136
そうだね。前スレ372-390でも話題になってたよね。
(list foo bar)
== (list `,foo `,bar)
== `(,foo ,bar)
quasiquoteの分配則では気をつけないとね。

データとコードの違いは最初に叩き込まれると思っていたがそうでもないのか？

>>139
>結果が同じだし

微妙な違いは理解してるのか？
同じ臭いがするんだよ>>138-141はよ。

マクロの勉強でもしてみれ

eval使って解決した気になれるとか、初心者の特権だねえ。

>>135
それよりmapcarの使い所を間違えてないかね？
処理系変えるとうまく動かないかもよ。
quoteはちゃんと理解した方がいいよ。

>>140
どんだけ頓珍漢なことやってるのかって
最初は気付かないもんだよ。

ありがとうございます。
もう一度 quote の部分を見直しましたが
まだいまいちわかっていないので
もう一度じっくり読んでみます。

>>148
mapcar の使い方を確認しようと
Revised5 Report on the Algorithmic Language Scheme
を見てみたところ mapcar は乗っていなかったので
map を使うことにしました。

>>135は展開すると
'(foo bar)
== (list 'foo 'bar)
となる。
これと>>143を比べると違うことは明白。
(list 'foo 'bar)ではlistの要素はシンボルになっている。>>135
(list foo bar)ではlistの要素は変数になっている。>>136,>>143

初心者ならそこまで気を回さなくてもいいかもしれないけど
(equal? '(foo bar) (list 'foo 'bar)) => #t
だけど
(eq? '(foo bar) (list 'foo 'bar)) => #f ; ほとんどの場合
quoteはquoteでlistとは別物（返り値も含めて、書き換え可能かどうか等も）
返ってくる値がequalなだけ

それからR5RSのmapは返り値の順序は規定されているけど
評価順序は未規定
だから
(map display '(A B C)) => '(#<undef> #<undef #<undef>)
標準出力にはABC、ACB、BAC、BCA、CAB、CBAのいずれか
評価順序をリストの順通りにしたいのならfor-eachを使う
(for-each display '(A B C)) => #<undef>
標準出力には必ずABC
評価順序と戻り値のデータ構造内の順序の区別は
HaskelのIOモナドにもつながる
（たぶん）
R5RSでは関数の引数の評価順さえ未規定

>>152
>>それからR5RSのmapは返り値の順序は規定されているけど
>>評価順序は未規定

うわ…これ今ごろ知ったよ、ありがとう。つかこの仕様で誰が得するんだろ。
慌てて調べたけど、Gauche は独自仕様で常にリスト内の順番どおり、なのね。
ちょっと安心。

並列処理が楽になるとは聞いたな。

少しActorも意識してるんだろうね。
各要素に並行にfがメッセージパッシングされて。

>>138
funarg問題の時代までタイムスリップかよ。

funarg問題の例: compose
(lambda (f g) '(lambda (x) (f (g x))))

こうすればいいんじゃないの？
(lambda (f g) `(lambda (x) (,f (,g x))))

quoteが嫌いな人はクロージャやsyntax-rulesを使う
quoteが大嫌いな人はPythonやRubyを使う
そんな気がする

quasi-quoteの便利さは異常。
そんな嫌いになるなんて、これが本当のくぉーつ嫌いってやつか・・・

昔のマクロにはバッククォートなんてなかったよな
ひたすらlistでS式をこさえてたっけｗ

どんだけ昔の人だよ

Lisp-85とかって言っても分からんだろうなｗ

そんな最近かよ
とっくにバッククオートあるよw

Lisp-85ってS-OSというZ-80のOS上で動く奴なんだが
fexpr形式やmacro形式はあってもバッククォートは無かったぞ

Alan Bawden, "Quasiquotation in Lisp"によれば、

　現在とは少し記号法が違うが、1972年のConniverが現代的な
　quasi-quoteの起源。

　少なくとも1977年ごろのLisp machineには、現在使われているのと
　ほぼ同じquasi-quoteがあった。

ということらしい。

D. V. McDermott and G. J. Sussman, "The Conniver reference manual," 1972
ftp://publications.ai.mit.edu/ai-publications/0-499/AIM-259a.ps

Alan Bawden, "Quasiquotation in Lisp," 1999
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.5.2566

'の逆はevalだと思ってた

>>163
Z80には荷が重かったのでは
メモリどんだけ積んでたとか知らないけど
展開後は再帰関数のかたまりだし

全然問題ない。

あっそ
ならLisp-85作った人が入れ忘れたんだね

quasi-quoteを効率を保ってきちんと実装するのは意外と難しい。
80年代になってもマクロと組み合わせた時の実装手法の論文があった。
アンチquasi-quote派というのが昔はいた。Common Lispで決着。

Gauche　WiLiLiのあんまり目立たないとこに自分の作ったパッケージ書き足す方法はないものだろうか

>>156
その関数の引数f,gにシンボルxを引数として渡すと死ねる。

やっぱり gensym が必要なんだね。

関数名じゃなく、関数「値」を式に埋め込めばいい。
gosh> (define x (list + 1 2))
x
gosh> (define y (list '+ 1 2))
y
gosh> (define + -)
+
gosh> (+ 1 2)
-1
gosh> (eval x (current-module))
3
gosh> (eval y (current-module))
-1

再帰関数だったら？

そこまで行くとR5RSでも解決できてるかどうか怪しい
R6RSは再定義禁止だっけ

R5RSの件は
(define f (letrec ((f ...)) f))
と書けば安全かも

仕様に自由があるから面白い。

>>173
で'の使い方わかった気がするけど
本格的に勉強するならどの本がいいのでしょうか？

>>178
SICPがいいよ
マクロの話題は一切ないけど、マクロは遊ぶものであって勉強するものではない
それでもSICPがSchemeを使ってる理由を考えながら読めばおもしろいかもね

俺はOnLispをお勧めする。

ふつうにあのお魚の本でよくないか?

処理系のソースで十分

ttp://user.ecc.u-tokyo.ac.jp/~tt076524/onlispjhtml/
ほれ

うわーっ！びっくりした
と避ける

>>169
ふむふむ、勉強になります。
そういえば関係あるかわからないけど、 scheme じゃなくて elisp も、
Emacs19 のころは

`(foo ,bar)

とはかけなくて、

(` (foo (, bar)))

と書いていたような。

関係ないけどチャイティンのLispでは'はシンボルで
(QUOTE X) == (' X)
って書いてたな

(define (% num1 num2)　(remainder num1 num2))
としてるんですが、関数に別名与えるもっと良い方法はありますか？

引数の数が一致しているのなら
(define % remainder)

それでいいんですね。
気づきませんでした。

ありがとうございます。

指定のクロージャが束縛されているシンボルを探す方法ってありますか？

処理系によってはあるかもしれないけどRnRSにはないんじゃないかなぁ。
CLにはあるかもしれませんけどSchemerだから知らないです。
シンボルのリストを引数に与えるのであれば
グローバル束縛されているクロージャをevalで取り出してeq?して調べられるけど
グローバル変数のリストはどうやって得ればいいかわかりません。
それにローカル束縛も含めるとなると不可能じゃないでしょうか。

CL なら do-symbols で探せるんじゃないかと。

Haskellとlispの得意不得意ってどんなところなのでしょうか？

別に無いよ？

>>193
特にないんじゃないの？
文字列を扱うとめちゃくちゃメモリ食うってのがHaskellの弱点かもしれんけど
今時のマシンだったら何の問題も無いし。

Haskellとlispを戦わせたくてしょうがないらしい

ムシキングか何かでやってください

[Lisp] 攻撃:85 素早さ:94 防御:96 命中:68 運:32 HP:154
[Haskell] 攻撃:68 素早さ:55 防御:65 命中:52 運:31 HP:233

Lisp vs Haskell 戦闘開始！！
[Lisp]の攻撃 HIT [Haskell]は91のダメージを受けた。
[Haskell]の攻撃 HIT [Lisp]は11のダメージを受けた。
[Lisp]の攻撃 HIT [Haskell]は109のダメージを受けた。
[Haskell]の攻撃 HIT [Lisp]は0のダメージを受けた。
[Lisp]の攻撃 HIT [Haskell]は76のダメージを受けた。
[Lisp]が[Haskell]を倒しました(ラウンド数：3)。
魔法のＭＤ５ - ＭＤ５バトル http://www.newspace21.com/mix/btl.php

いちいち貼らなくていいよ

>>193
Haskellは近くのコンビニにぬり絵が売ってます。
Lispはドンキホーテに行けばぬいぐるみが売っています。
>>193君はどちらが好きですか？

外に出なくても済む方がいいです

λ

maximaの中に面白いのみっけた

(defun for-eval-then-quote (var)
`(list 'quote ,var))

(setq x 1)
(for-eval-then-quote x)
-> '1

>>203
えーと、ほんとにそれを動かしたら'1になったのかい？
正しい結果は(list 'quote 1)になるのでは。
関数とマクロの評価はごっちゃにしないように。
この辺り何か思い違いしてると思うよ。
ちなみに'1を期待するなら関数の中身は`',var または(list 'quote var)

>>204
間違えました
(eval (for-eval-then-quote x))
->'1

loopマクロ勉強したのにiterateの方が使われてたり
言語の発展はゆるやかだ
とか言ってたのどこのどいつだ

>>206
それ言語じゃなくてライブラリの発展だと思うんだが……。

>>206
これ読め。
http://pc11.2ch.net/test/read.cgi/tech/1203096230/251

[clojure] 攻撃:28 素早さ:67 防御:78 命中:87 運:55 HP:202
[Qi II] 攻撃:51 素早さ:21 防御:48 命中:69 運:23 HP:189

clojure vs Qi II 戦闘開始！！
[clojure]の攻撃 HIT [Qi II]は1のダメージを受けた。
[Qi II]の攻撃 HIT [clojure]は16のダメージを受けた。
[clojure]の攻撃 HIT [Qi II]は56のダメージを受けた。
[Qi II]の攻撃 HIT [clojure]は1のダメージを受けた。
[clojure]の攻撃 HIT [Qi II]は56のダメージを受けた。
[Qi II]の攻撃 HIT [clojure]は10のダメージを受けた。
[clojure]の攻撃 HIT [Qi II]は38のダメージを受けた。
[Qi II]の攻撃 HIT [clojure]は1のダメージを受けた。
[clojure]の攻撃 HIT [Qi II]は25のダメージを受けた。
[Qi II]の攻撃 HIT [clojure]は1のダメージを受けた。
[clojure]の攻撃 HIT [Qi II]は57のダメージを受けた。
[clojure]が[Qi II]を倒しました(ラウンド数：6)。
魔法のＭＤ５ - ＭＤ５バトル http://www.newspace21.com/mix/btl.php

kill

連邦のモビルスーツは化け物か！？

array->list 変換関数がみつからない
自分で書くものなの？
(array->list
#2a((1 2)(3 4)))
->((1 2)(3 4))

>>自分で書くものなの？
R5RSには記述がないからそうだと思うけど，
それより#2a(...の2aって何？

#2A(..)ってのはCommon Lispの二次元配列かな。
ARRAY (2)のリストになってほしいのか、リストのリストになってほしいのか。
まぁ、結論からいうと>>212ARRAY (2 2)はLISTと互換性がないからムリ。自分で書く。
ベクタとかなら (coerce #(1 2 3) 'list) で変換できる。

lispに興味があるんですが、
いまからlispを勉強するならなんの書籍がお勧めですか？
SICPってのがお勧めっぽいんですが、MITで使われてるとなると・・・
読みこなせるかなー

オンラインで読める無料の
・独習Scheme三週間 ttp://www.sampou.org/scheme/t-y-scheme/
・入門Scheme ttp://www4.ocn.ne.jp/~inukai/scheme_primer_j.html
や
書籍じゃないけど
・もうひとつのScheme ttp://www.shido.info/lisp/idx_scm.html
あたりを読んでから買えばいいんじゃないでしょうか。

>>215
SICP読んでみて、自分に合いそうなら買うのがいいとおも。
http://mitpress.mit.edu/sicp/

SICP日本語版はちょっと高い

なんでいきなりSICPなんじゃーー

「良い本だ」ってよくScheme関連のWEBに載ってるから。

良い本には違いないけど、
SICPも買いたいなら、別の本と併読した方がいいと思う。
言語仕様書が日本語化されているからそれでいいか、
って人ならSICPだけで問題なし。

maximaが使いたいだけだったので
on lispはじっくり読んだが
SICPは問題もやらずに流し読み

SICP は Scheme の本というわけではない。
Scheme を使って解説してる本。

>>223
え、そうなんですか？
自分はアルゴリズムの勉強のために買いました。

序盤の関数 f(x) の話とか、大学の数学が懐かしいです。

SICPにアルゴリズムの話が出てないわけではないが、
SICPをやってもアルゴリズムを勉強したとは言えない。

>>223
何を解説してるの? w

>>226

っ人生

>>226
本のタイトル

>>226
降り続く雨
きしむ廊下
立ち止まる足音
遠のく意識

SICP読んだら魔法使いになれますか？

>>230
なれません。

>>230
なれます。
就活に有利です。

>>230
さあ、30歳になるまで貞操を守る作業に戻るんだ

30歳を越えてるのですがSICPは読めますか？

読めなかったら困ると思いますよ

60歳とかでも読めるらしいですよ
読めなかったら数学勉強してから再挑戦しましょう

30歳過ぎてもSICP読むと童貞になりますか？

俺はSICPを読んで、背が１０cm伸びたよ

SICP読んで宝くじ当たったよ。

もしかして訳者の和田さんってスーフリの和田さん？

プログラマ50人に1人ぐらいはSICP読んでるよね。

>>250
和田って俺のことだけど。

SICP未読で許されるのは小学生までだよね！

ちょっと待ってくれ。「人生に必要な知恵はぜんぶ幼稚園の砂場で学んだ」とあるように、幼稚園のうちに読んでおくべきものではないだろうか？

なんてこったい／(＾o＾)＼

人生に必要な知恵はぜんぶサンドボックで学んだ。

俺、人生に必要な知恵はぜんぶ死後の世界で学ぶんだ…

次はアメンボに生まれてきたりして

おれも人生に必要なことは幼稚園で一通り学んだ覚えがあるな

>>249
ってことは、幼稚園で、チュー済ませたタイプか。

登り棒オナニーなら幼稚園の時に覚えました

SICP以外誇れるものはないのか

essential of なんたらとかreasoned schemerとかもいいかも

時代は宝石の名前の言語じゃね？

党員の友人とMercuryを学んでいます。

Perlのことですね、わかります

あのバージョン6がすべった言語のことか

>>255
それは金属であって宝石ではない(ﾟдﾟ)！

真珠の綴りはPerlじゃないぞ・・・

まぁなんにせよ変な宗教言語は使いたくないわなｗ

()とか幼稚園じゃ習わなかった

幼稚園の時、世の中はすべてnilだと習った。

うちの幼稚園ではnil派と()派が闘争を繰り返していた。

little schemerって幼稚園児でも理解できるように書かれたんだっけ

誰が象のラムダ君役をするかで喧嘩になってみっちゃんが泣いた。

ここは幼稚園で人生のすべてが再帰的だと悟ったみなさんが集まるスレですかね。

継続渡しスタイルで幼稚園ドロップアウトした。

ところで、
チョコはいくつもらえましたか

カーチャンから一個、姉さんから一個

(´；ω；｀)

ええい、FOR文でもらえた奴はいないのか！

「末尾再帰！」と叫んで保母さんのスカートをめくったのはいい思い出

Next Boston Lisp Meeting: Monday February 23th 2009 at 1800 at MIT 34-401B
http://fare.livejournal.com/139926.html

vyzo will talk about gerbil, a little language for distributedprogramming
using PLT-Scheme. Gerbil is a macro language that provides facilities
for actor-based distributed programs and transparent network simulation.

これおもしろそうね。

Seasoned Schemer　ってどうですか？

Let Over the Lambda　ってどうですか？

海は死にますか？

nilもそうですか？

水曜どうですか？

明日来てくれるかな？

このスレのネタの応酬はハイレベル過ぎて

終いますか〜？

括弧の山を愛する連中の嗜好が平凡なわけがなかった・・・・

別に愛してるわけじゃないけど、無いと不安になるというか不安定に感じる。

十分平凡でないです！

アイちゃんも冗談を言うようになったか。

>>274
何が？
俺は好きだよ？

hogehoge

(hage? >287)

一連の1行の糞レスをあぼーんするプログラムを作れ

(waha >>288)

あぼ〜ん

>>289
navi2chちょっといじればいいだけ

iPhone/iPod touch用のLisp/Schemeを発見。次スレのテンプレに入れて。

http://www.turbozen.com/sourceCode/TinyLisp/
http://programming.nu/

こういうlist が返ってくるときに
((1 2 3) (1 2 3) (1 2 3))

こういう処理にするにはどうすればできますか？
(map + '(1 2 3) '(1 2 3) '(1 2 3))

(apply map (cons + list))

>>295
ありがとうございます！

>>293
wikiのテンプレに書き加えておいて。

(setq list1 '((message "X") (message "Y")))
があったとして、list1 の各要素を順番に実行していく方法を教えてください。

(eval (cons 'progn list1))
こういう話？
それともこんなのをお望み？
(mapcar #'(lambda (x) (apply (car x) (cdr x))) list1)

(mapcar #'eval '((message "X") (message "Y")))
とかでもいいのか。

仮定が分からないな。
messageというのが関数なのか？
(setf *func-hash* (make-hash-table))
(setf (gethash 'message *func-hash*) #'(lambda (x) (princ x)))
(setf list1 '((message "x") (message "y")))
(mapc #'(lambda(x)(funcall (gethash (car x) *func-hash*) (cadr x))) list1)
=> 以下が結果 maximaとかはこの手のことをやってるね。
xy
("x" "y")

>>299
>(eval (cons 'progn list1))

すごいです。これでできました。
ありがとうございました。

Scheme

(let ((list1 '((display "X") (display "Y"))))
　(map eval list1))
⇒XY(#<void> #<void>)

(cons 1 '(2 3))
-> (1 2 3)

となりますが

(cons '(1 2) 3)
-> ((1 2) . 3)

になりますよね

今は (append '(1 2) '(3)) と書いてますが
(cons 1 '(2 3)) に比べて冗長だと感じます
もっと良い書き方はありますか？

書き方というか、片方向リストの仕様だから

(define (wahacons a b) (append a (list b)))
(wahacons '(1 2) 3)

>>305
仕様ですか…。
>>306
関数を書いてしまえば良かったんですね
ありがとうございます

>>307
quasiquoteは？

> (define x '(1 2))
x
> `(,x 3)
((1 2) 3)

肝心な部分コピペし忘れとかどうなのよ、俺……orz

> `(,@x 3)
(1 2 3)

Luaスレがschemeネタで盛り上がってるｗ

ちょっと見てくルア

見てきたけど、あんまり面白い流れでも無かった。
速いなら実装を参考にしよう、とか建設的な意見が出る訳でもなく、
単にSchemeイラネ、だし。

括弧うぜえとか。

Schemeは作るの簡単とか。

>>312
Luaってのはどういう言語かもよく知らないんだが、
処理系は結構よくできているみたいで遅くはないよ。
http://shootout.alioth.debian.org/gp4/benchmark.php?test=all&lang=all&box=1

ypsilon軍団とgauche軍団どっちが多い？

[gauche] 攻撃:52 素早さ:32 防御:27 命中:74 運:17 HP:258
[Ypsilon] 攻撃:88 素早さ:69 防御:92 命中:95 運:96 HP:144

gauche vs Ypsilon 戦闘開始！！
[Ypsilon]の攻撃 HIT [gauche]は154のダメージを受けた。
[gauche]の攻撃 HIT [Ypsilon]は1のダメージを受けた。
[Ypsilon]の攻撃 HIT [gauche]は173のダメージを受けた。
[Ypsilon]が[gauche]を倒しました(ラウンド数：2)。
魔法のＭＤ５ - ＭＤ５バトル http://www.newspace21.com/mix/btl.php

何という二番煎じ、お前は車輪の再発明でもしてろ

車輪の再発明はハッカーの大好物

>>315
遅くないのは知ってるけど、向こうの話題の発端がそういう話だった。

俺の場合、VCSのmonotoneで組み込まれてて知ったんだけど、
かなり評価高い言語だよね。Adobeとかも採用してるとか。

Lispが早いとか

CLでもSchemeでもいいので話題のHSPみたいに簡単にゲーム作れるソフトはありますか？

>>322
CL/scheme はしらんが、どこぞのメーカは
ゲーム開発ベッドで専用 Lisp 使ってなかったっけ?

>>322
LispやSchemeをゲーム制作に生かしている企業とかはあるみたいだけど、
誰でも分かり易いライブラリだの、特化した処理系だのはないんじゃない？
一応、SDLとかOpenGLとか使ってゲーム作るのは、大抵の処理系で出来ると思うけど。

というか、HSPが話題っていつの話だ。

>>323
これね。
http://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp

LuaとかSquirrelは遅かったらC++に書き直せばいいだけだからな

Lisp/Schemeも同じことができると思うんだが……。

書き直す際に
実装が多いのが弱点ではないかと。

Squirrelは書き直すのが楽そうだ

StalinならCより速くなることもあるんじゃなかったっけ？

Stalinって実際どんな感じ？

StalinってCを出力するんでしょ？
Cより速くなる事は無いと思うけど…
Cで「人間が」書くより速くなる事ならあるかもしれないけど

stalin ... それは、かつてソ連で大量虐殺をおこなった恐怖の支配者。。。
だから
非人間的な行動(コード)だろ？人間が書くCのコードより速いってことじゃ？

Stalinは、人間がかくCコードよりかなり早い場合も多い。
ただし、継続が使えないとか制限が多いし、コンパイル時間がめっちゃかかる。

>>332
> Cより速くなる事は無いと思うけど…
> Cで「人間が」書くより速くなる事ならあるかもしれないけど
こんなこというやつ初めて見た。

そうか？理論値と実情を別に語るのは良くあると思うが。

だって、人間が書いたものではないCを含めて 「C言語より速い」
を語るなら、それって実質的にCコンパイラの最適化の差に帰着するじゃん。

コンパイラによってはCから （ほぼ）最小のアセンブリを生成できることだってできるし、
そうすると何をもって「Cのソース」とするのかって話になって、
「Cのソースを吐くんだからCより速いはずがない」 っていう議論は空虚じゃない？

まぁ言い出しておいてアレだけどスレチだな。すまん

Stalinの話は定期的にでてくるけど、流れとしては・・・

「同じ問題を解くのに俺様の書いたCよりXXにあるStalinのコードの方が速かった！」
「でも俺様のCのコードがヘボいことはありえない！そんなことは考えられない！」<- これが間違い
「Stalinはどんな魔法を使ってるんだ！スゲーよStalin！」

一部で盛り上がるけどスルーする人も多い。
同じ速度を出すのにStalinを使った方が簡潔に短時間で書けるというのはあると思う。
だからあれほどコンパイル時間がかかってもユーザーは気にしないんじゃないかな。

まぁStalinはある種の一発モノだからな。
研究とか勉強の材料としてはすごいけど、プロダクションでは使えないから
盛り上がるのは一部にとどまる。

俺は盛り上がった派だけどｗ
最適化の解説の論文は勉強になった

schemeのマクロを使って 
見た目から括弧を無くしていくことって出来ますか？ 
例えば括弧のない1 + 2を3と評価するとか 
for リスト do 処理 done 
みたいな構文がmapの意味で動くようにしてみたい 

>>339
まえにどっかでみたことがある。srfiなんとか だったと思う。

SRFI 49のI-expressionsは、インデントで構文木を表す表記法であって、
マクロは関係なかった気がするんだけど、違ったっけ？

SRFI 49: Indentation-sensitive syntax
http://srfi.schemers.org/srfi-49/srfi-49.html

最高にキモい Lisp コードを書いてみよう with 100 行リーダーマクロ
http://lispuser.net/memo/lisp/2006-03-30-23-58.html

つ Standard Lispの記号モード

>>339
「schemeのマクロを使って」も
マクロ使用を囲う括弧と、マクロ名さえあれば中置記法もできます。
ただしこの３つをなくするのはRnRSではできない。
処理系によってはリーダマクロをサポートしているのでそれを使うと可。

なるほど、やはり出来ないのかー
リーダーマクロ、存在だけは知ってましたが
コンパクトでかっこいいSchemeで出来たらなぁって思いまして

昨日考えてたんですが、
Schemeには演算子の優先順位がないのが原因でしょうね
もし優先順位がつけば、括弧省略出来る
それはそれで、F#やらHaskellやらでみかける
パイプライン演算子みたいなのが定義出来たり、と夢が膨らむが
言葉に表せない大切な物が犠牲になってしまう気がします

>マクロ使用を囲う括弧と、マクロ名さえあれば中置記法もできます。
これ非常に興味あるんですが、どういうことでしょうか？

適当に試してはみたんですが、わかりません
(define-syntax plus
(syntax-rules ()
; ((x _ y) (+ x y))))
; ((x (_) y) (+ x y))))
; (((x _ y))(+ x y))))

Gaucheの拡張で優先順位を計算して括弧を省略ってページなら見つけましたが
そういった話でしょうか？

こういうことじゃないの
(define-syntax calc
(syntax-rules (+ -)
((_ a + . rest) (+ a (calc . rest)))
((_ a - . rest) (- a (calc . rest)))
((_ a) a)
)
)
> (calc 1 + 10 - 5)
5

5かよ

> Schemeには演算子の優先順位がないのが原因でしょうね
> >マクロ使用を囲う括弧と、マクロ名さえあれば中置記法もできます。
> これ非常に興味あるんですが、どういうことでしょうか？
そうゆう reader を作ればいいじゃね？
作るだけだったら誰でも作れると思うし…

>>345
俺は344じゃないけど、344の言ってることは違う。

344が言ってるのは、「一番その側のカッコがあれば」 ということ。
いちばん外側のカッコは、どう頑張ってもRnRSでは省略不可能。
しかし、一番外側のカッコとマクロ名を許容すれば、
そのマクロの引数を全部自力で解釈すれば、そういうことは可能ということ。

文字通り、言語をもう１つ作るようなもんだけど。

× 一番その側
○ 一番外側

>>344
これ面白いなぁ。
引き算は
(calc 1 - 2 - 3)
こう展開されてしまうから
(- 1 (- 2 3))
正しい値にならないね
けど、面白いからちょっと考えてみます

>>349
なるほど、勉強になります。
「マクロ使用を囲う括弧と、マクロ名さえあれば」
というのは、344氏の例でいけば、
一番外側の()とマクロ名であるcalcっていう意味なわけですね
そして、それより内側であれば、がんばり次第で自由自在だ、と。

('A`)y-~

そもそも、何で括弧なくしたいんだ？
知的好奇心満たしたいだけなら何も言わんが。

Lisp Scheme初心者です。マグロウヒルの「プログラムの構造と実行」をテキストに
Schemeを勉強しようと思っています。
そこで皆様のアドバイスをお願いしたいのですが、どのScheme処理系がお勧めでしょうか？
あまりにもたくさんありすぎて判断できません。
OSはWindows XPです。よろしくお願いします。

>>354
windows上で勉強目的なら統合環境のほうが楽だろうしPLT schemeで良いんじゃないかな。
さもないなら、linux上でemacs+gauche(日本語の本があるから)とかでも良いように思うん
だけどね。

>>338
stalinがダメなら
記述力と速度を同時に達成できるのって
ocamleぐらい？

GCの停止時間がなくて
記述力も同時に達成できるのはC++しかないんだぜ

確か2月前半ぐらいに
comp.lang.lisp
でreadable なlisp -> C 変換の話がでてたはずなのに見つからない

C++はOOPの振りをした関数型言語だからな

>>359
テンプレートで遊ぶ分にはそうだけどな

OOPは言語関係ねーす

c++でoneceonlyマクロって書けるんだろうか
前にoneconleyできない関係で何度も代入評価されてる
「そんなエラー絶対みつかんないだろう」ってエラーがboost関係で報告されてた

>>353
どっちかっていうと実用的な理由
　・タイプ量を減らしたい
　・括弧がネストすると、対応が激しくおいづらい

emacsを使えばそんなこと屁でもないな
むしろ()がある方がタイプ量が減るし、移動が楽ってぐらいになる
逆にエディタの支援が無いとなるとなるほどそれは確かに致命的だ

エディタの機能でどうのこうのっていうのは
言語の話とは別のような・・
俺もemacsは使ってるが

>()があるほうがタイプ量が減る
それはない
letよりlet1のほうが読みやすいし打ちやすい

>>363
実用的な理由で括弧を消すのはないだろー。
前者の理由なら、そのために高階関数やマクロがある。
後者の理由なら、そのためにエディタの支援機能がある。
というか、インデントで対応を追うのが普通。

まあ、実際にやってみて、構文を増やす度に複雑化する、
仕様やリーダーマクロのメンテにうんざりしてみれば、
その辺良く分かるとは思うけど。

実用ってことはコードを編集することを含むだろう？
ならエディタは関係あるじゃないか

emacsの括弧うんぬんはいじる方の腕しだいで楽になる。

emacs はこのへんを組み込んでるかどうかでも全然ちがうよ。
1. insert-parentheses を使ってるかどうか
2. show-paren-mode を使ってるかどうか
3. transient-mark-mode を使ってるかどうか

>>365
プログラムのコードのタイプ量は減るだろうけど、
編集作業全体のタイプ量は驚きの増加量、って感じになる気がするよ。
S式単位での編集を使わないと、移動に掛かる手間が段違い。

emacs userは1匹見ると10匹いると思え

>>371
ごきぶりみたいにいうな にがわらひ
370みたいなべてらんもいるけど、C-F C-B C-N C-Pもままならずマウスな初心者も
いるから。
viでもlispモードは普通にあるよ。

>>371
むしろ1匹しかいない絶滅危惧種扱いの所が多いよ。

google trendsをみても検索数の指数は減ってるけど、多い地域はアカデミックなところが
多いね。日本も亜米利加もね。

俺ベテランじゃなくて異端。
viper-modeで、viとEmacs両方のキーバインドを同程度に使う変態。

vipperかお？

お　じゃない。

>>375
viper-modeかぁ。15年以上起動したことがない。笑い

>>375
　　 ＿__l＿__　　　/､｀二//-‐''"´::l|::l　　　　　　 l! ';!u ';/:::l ', ';::::::l ';:::::i:::::
　　　ﾉ l　Jヽ　　　ﾚ/::／ /:ｲ:＼/l:l l::l　　　u　　　!. l　/ ';:::l　', ';:::::l. ';::::l:::::
　　　　ノﾇ　　　　　レ　　/:l l:::::lヽ|l　l:l　し　　　　　 !/　　';:l,､-‐､::::l　';::::l::::
　　　 ／ ヽ､_　　　　　　/::l l:::::l　 l＼l　　　　　　ヽ-'　 ／ ';!-ｰ ､';::ト､';::::l:::
　　　ム　ヒ　　　　　　 /::::l/l::::lﾆ‐-､｀`　　　　　　　　/　/;;;;;;;;;;;;;ヽ! 　 i::::l:::
　　　月　ヒ　　　　　　/i::/　 l::l;;;;;ヽ ＼ 　 　 　 　 　 　　i;;;;;;;;;;;;;;;;;;;l　　 l::l:::
　　　ノ l ヽヽノ　　　 /:::l/:l /;;l:!;;;;;;;;;', 　 　 　 　 　 　　　 ';;;;;;;;;;;;;;;;;ﾉ 　 　l:l::
　　　　 ￣￣　　　　/::::;ｨ::l. l;;;;!;;;;;;;;;;;l　　　　　　　　　　　 ｀‐--‐'´.....:::::::::!l
　　　__|＿ ヽヽ　　 /ｲ//l::l　ヽ､;;;;;;;ノ....　　　　　　し　　　:::::::::::::::::::::ヽ　/!ﾘ l
　　　　| ー　　　　　　/::::l';!::::::::::::::::::::　 ｕ　　　　　　　　　　　　　　　', i　ﾉ l
　　　　| ヽｰ　　　　　/ｲ';::l　　　　　　　　　 ’　　　　　　　　　し　u. 　i l　　l
　　　　　|　　　　　　　/';:';:!,.イ　　 し　　　　入 　 　 　 　　　　　　　　l l U
　　　　　|　　　　　　/,､-'´／　し　　　　　 /　　ヽ､　　　u　　　　し　,' ,'　 l
　　　　　|　　　　　　　　／l　し　　　　 _,.ノ　　　　　｀ﾌ"　　　　　　 ,' ,'　 ,ｨ::/:
　　　　　|　　　　　　 ／::::::ヽ　　　　　　　ヽ　　　　／　　　　　し　,' ,' ／ l::
　　　　　|　　　　　　／::::::::::::｀‐､ し 　 　　 ',　　／　　　　u　　　,､-'´　　l,､-
　　　　　|　　　　　　｀`‐-､._::::::::::｀ ‐ ､ 　 　 ',／　　　　　　　, -'´｀'´ ,-'´
　　　　　|　　　　　　_,､-‐'"´';:::::::::ｲ:l';:::｀ ‐ ､._＿＿__,､-‐'"´　　u ／
　　　|　|　|　|　　　　＼　l::/　l::::::/リ ';:::::lﾘ:::::l';:::l　l:l:::::l＼　　u ／
　　　|　|　|　|

>>375
viperモードたまに使うけど、完全に終了させる方法教えて下さい。
viper-go-away しても別のファイル開いたらまたviperになってて、
仕方ないからemacs毎再起動してる。

>>380
せっかくなので、ソースコードを読んで原因を探ってきました。

viper-go-awayを呼ぶと、viper.elのviper-remove-hooksで、
仕掛けていた各メジャーモードのフックを解除していくのですが、
コードを見ればお分かりの通り、とても素敵なバグがありまして、
find-file-hooksとかは完全スルーです。

なので、自分でコードを修正するか、本家にフィードバックするか、
俺のようにVIPER常駐野郎になるか選んでください。

と思ったんだけど、追加で調べていったら、
デフォルトのメジャーモードを元に戻さないってバグもあって、
これが本筋っぽい。CVS最新版では修正されてる。
↓を.emacsに追加でひとつ。

(defadvice viper-go-away (after revert-default-major-mode activate)
(setq default-major-mode 'fundamental-mode))

maximaの細かいbugが未だに放置なのは
common lispの問題なんだろうか
schemeで書かれてるならbugは少なくなるんだろうか

妄想はそのくらいに

もともと"Common Lisp"じゃないものをGCLに、そして"Common Lisp"に書き直したからじゃない？
最初から"Common Lisp"で書かれていたら違っていたかも
Maxima使ってないからよくわからないけど

質問。この2つに違いってありますか？

(define (f x)
(define g 10)
(+ x g))

(define (g x)
(let ((h 10))
(+ x h)))

5.2.2 internal definitionsに変らないと書いてある。

> A <body> containing internal definitions can always be converted
> into acompletely equivalent letrec expression.

(define (g x)
　(letrec ((h 10))
　　(+ x h)))
となら同じ、が正しいのでは？
letとletrecは違う
この例はたまたまコンビネータ式が束縛されているに過ぎない
（正確には式が束縛されているわけではないけど）

質問の意図によるだろうけど
最終的な機械語に落とす段階では同じコードになる

とはいったものの、束縛する式が１つならSchemeレベルではletとletrecは等価ですね

>>387
ありがとうございます
自分の知らない、
何か違う意味があるんだろうと思って質問したんですが
letrecと同じ意味なんですね

おっちょこちょいですね。

>>391
>>386の例ではletで問題ない。

>>393
了解です。Schemeってシンプルですね。ありがとうございます

>>387
編集ミスった。
acompletely→a completely

否定のa-に見えてしまう すまん

さしずめ「うは宇宙のう」

>>382
遅くなったけどありがとう。これでviperモードと仲良く暮らせそうです。

お

399

400

shibuya.lisp ストリーミング中!
って今ごろ気付いたorz

見逃した……
ニコニコ動画辺りに上げてくれないかあ

>>402
マイリスト Shibuya.lispテクニカルトーク#2‐ニコニコ動画(ββ)
http://www.nicovideo.jp/mylist/11305224

>>403と投稿者に感謝を

>>403
マジでありがとう!!

他の関数型言語でこの手の集まりをみないのは
学会で代用してるからなのだろうか

>>406
勉強会ならあるけどな。

>>403
あー、配信のときとは別テイクで音声がずいぶん聞きやすくなってる！
ありがとうございます。

>>406
HaskellとかOCamlだと人がそんなにまだ多くないし（Lispに比べれば）、
ゲーム作りましたみたいな大きいネタとか、その筋なら誰でも知ってる大先生とか
そういうのないからねぇ。
さがせば>>407が書いてるみたいに勉強会とかあるからメイリングリストとか
入ってみれば？　今時捨てアドのひとつやふたついくらでも作れるし。

lispが多いといってもschemerが多いんじゃない？
やはり、川合さんとか、処理系製作者が3人もいるくらいだからね。
common lispは人は少ないよ。Qiやclojure,newLispに至っては壊滅的。

そーいえば、abclがバージョンアップしてたな。

ircを覗くと、常駐者が

#lisp 250
#haskell 550
#ocaml 50
#scala 50
#clojure 100
#ruby 250

くらいみたいだね。haskellがなんでこんなに多いんだ？

has略は中ニ設定豊富だからな

http://pc11.2ch.net/test/read.cgi/tech/1234635513/378

自分はLispが全然書けないけど、どんだけ短くなるのか見てみたいです。
どなたお願いします〜

>>410
Qiというものを始めて知りましたが、Haskellっぽくて面白そうですね。
ところで皆さんはこういった面白い実装の情報をどこで得てるんでしょうか?
英語のメーリングリストなのかな?とは思ってるんですが・・・

>>414
それはねぇ。。。こまめに調べてるだけよ。ふふふ。。。lisperがあつまる日本語のチャット
も情報源だよ。
うんQiはHaskellっぽいね。

ttp://www.zazzle.com/lisp+gifts

これがメリケンだ！？

>>416
made with secret alien technologyのシャツが無いなんて信じられん

schemer多いのはシンプルだからなんだろうか

Qi ECLでは駄目なんだ・・・
高速化って書いてるから期待したのに

>>413
(use srfi-1)
(define request '((hoge . 1) (fuga . 2) (piyo . 3)))
(filter (lambda (x) (member (car x) '(hoge fuga))) request)
とか

>>414
Planet LispってRSSあるよ。

>>421
おおっ、有り難うございます!! さっそくGoogle Readerに追加しました。

>>420 3行目 srfi-26使って(gaucheならuse不要)
(map (cut assoc <> request) '(hoge fuga))

ハッシュテーブルに代入したら負けですねわかります

(defvar *request* (make-hash-table))
(mapc #'(lambda (elem)
(setf (gethash (car elem) *request*) (cdr elem)))
'((hoge . 1) (fuga . 2) (piyo . 3) ...))
(let ((res (make-hash-table)))
(mapc #'(lambda(key)(setf (gethash key res)
(gethash key *request*)))
'(hoge fuga piyo))
res)

とくに簡潔ではないな。

schemeで論理の勉強しようと思って
(tflist n)で#tと#fの組み合わせを列挙してくれる関数を書こうとしたんだが
意外と難しい
最初mapで#t → (#t #f) (#t #t)という風に書こうとしたが
これだとflattenが居るし、flattenを再帰で呼び出してみたら
全部平らになってしまって(#t #t #t #t #t #f #t #f #t ...)みたくなっちまった
誰かたすけて

動作イメージ
(tflist 1)
　'(#t #f) or '((#t) (#f))
(tflist 2)
　'((#t #f) (#t #t) (#f #f) (#f #t))
(tflist 3)
　'((#t #t #t) (#t #t #f) (#t #f #t) (#t #f #f) (#f #t #t) (#f #t #f) (#f #f #t) (#f #f #f))

(define (tflist n)
 (cond
  ((<= n 0) '())
  ((= n 1) '((#t) (#f)))
  (else
   (let ((l (tflist (- n 1))))
    (define (add-t l) (cons #t l))
    (define (add-f l) (cons #f l))
    (append (map add-t l) (map add-f l))))))

(define (tflist n)
(if (= n 1)
(list (list #t) (list #f))
(append
(map (lambda (x) (cons #t x)) (tflist (- n 1)))
(map (lambda (x) (cons #f x)) (tflist (- n 1))))))

>>427-428
おお、神よ。なるほど、(append (map..)(map..))の形になるのか
もしよろしければもう1個
以下の例で最後の行は動くようになりませうか？
;guile/gaucheでどちらもエラー
(define (mujunritu p) (not (and p (not p))))
(define (haityuritu p) (or p (not p)))
(define (try1 f) (map f '(#t #f)))
(try1 mujunritu)
;これがダメ。try1のfでλx(apply f x)やλx(eval(f x))も試してみたものの
(map try1 '(mujunritu haityuritu))

OCamlでは動作
let mu p = not (p && (not p));;
let hai p = p || (not p);;
let tr f = List.map f [true;false];;
List.map tr [mu;hai];;

>>420>>425
サンクス。今の自分じゃ全然理解できないけどorz

前きたquote判ってない人かね

>>429
`(,mujunritu ,haityuritu)または(list mujunritu haityuritu)
'(mujunritu haityuritu)との違いわかるかな

>>431
別人です。あれからROMしかしてないですよ。

>>432
Lisp属の初心者には、このあたりは難しすぎます
調べるのは本当に大変でしたが、何とか見つかりました
ttp://www.ice.nuie.nagoya-u.ac.jp/~h003149b/lang/comparison.html
これのことですよね？
　Common Lispでも、関数引数に関数実体も名前も両方使える。
　(略)
　Schemeでは、関数しか受けとらない

確かに、CLでは両方動作することを確認
(defun muj (x) (not (and x (not x))))
(defun hai (y) (or y (not y)))
(defun tr (f) (mapcar #'(lambda (z) (funcall f z)) (list t nil)))
(mapcar #'tr (quote (hai muj)))
(mapcar #'tr (list 'hai 'muj))

schemeの場合
(list mujunritu haityuritu)だと関数実態が返ってくるが
(quote (mujunritu haityuritu))だと名前が返ってくる
schemeにもCLのsymbol-functionみたいな関数があれば
quoteのほうでも動作すると思い調べてみたものの
該当の関数が全然見つからない＼(＾o＾)／
しかし、関数はおいといて、この考えでたぶん、大丈夫ですよね？

>>434
つ「eval」

quoteとevalは静的スコープな言語にふさわしくないとつくづく思う

スコープと評価が？

schemeのシンボルは文字列に毛の生えた特殊オブジェクトと思えばよろし。
プログラム内でそのシンボルに何が束縛されているかとは基本的に全く関係ない。

R5RS の eval だと、その時点の環境での評価ができないから symbol-function の代わりにはできないし。

あくまでも、定義中の名前はシンボルではなくただの変数の入れ物の
名前として使われる。また、プログラムを実行するには変数の位置を
表現できれば名前のような冗長な情報は必要ない。
よって名前は実行前のある時点でアドレスに変換されていると考えるべき。

evalやCLのsymbol-functionみたいな実行時にシンボルからその位置情報へ
変換する仕組みを作るとなると、処理系のインタプリタやコンパイラ相当を
必要時に起動するのと全く事になり、非常に馬鹿げたコストが掛かる。

>>436
evalはともかくquoteはこの件と関係ない

>>440
文章として突っ込みどころ多すぎw

内容的にも、後段のsymbol-functionについては、
特殊オペレータのfunctionと勘違いしているとしか思えない。

(defun foo ()
(print 'foo))
(flet ((foo () (print 'foolet)))
(foo)
(funcall (function foo))
(funcall (symbol-function 'foo))))
FOOLET
FOOLET
FOO

急に流れが止まったから釣りかと思ったが
やっと>>422の言っていることがわかった
symbol-functionってグローバルな関数定義しか参照しないんだな

schemeにシンボルが無いってことが少し分かってきた
やっぱ Common Lisp 最強だな!

>>442
(let ((foo #'(lambda () (print 'fooval))))
(flet ((foo () (print 'foolet)))
(foo)
(funcall foo)
(funcall 'foo)
(funcall (function foo))
(funcall (symbol-function 'foo))))
FOOLET
FOOVAL
FOO
FOOLET
FOO

Common Lispは、symbol-valueとsymbol-functionが
シンボルセル内の別スロット。

funcallは>>440の後段のような処理は、
functionに任せて、関数呼び出しに専念する仕様。
funcallの第一引数は関数か、シンボル。
シンボルの場合symbol-functionの結果を使う。

何が真実なのかさっぱりわからんのでまとめてみたら
カオスになった。つっこみ希望

・evalは静的スコープにはふさわしくない
　動的スコープなら1つしか環境を考えなくて良いためと想像

・schemeのシンボルは文字列に毛の生えた特殊オブジェクト

・呼び出し
　(hoge)はレキシカルな環境での関数呼び出し(関数セル)
　(funcall hoge)はレキシカルな環境での関数呼び出し(値セル)
　(funcall 'hoge)は↓と同様。symbol-functionを使うため
　(funcall (symbol-function 'hoge))はグローバルに定義されたシンボルの関数呼び出し(関数セル)
　(funcall (function hoge))はレキシカルな環境での関数呼び出し(関数セル)
　レキシカル環境で同名の変数がある場合に
　グローバルなシンボルのsymbol-value(値セル)を参照する方法はなさそう

>>442氏の440へのコメント
　ここのあたりが一番わからない
　symbol-functionは(トップレベル変数が動的スコープのため)
　動的スコープを参照出来る
　→functionのようにレキシカルスコープの変数を考慮しなくてよい
　→symbol-functionに関してはevalもそんなにコストかからんぜ、ってこと？

>>446
442,445はCommon Lispのコードっていうのは分かってる?

> ・evalは静的スコープにはふさわしくない

これは俺も何が言いたいのかさっぱりわからんというか、
はっきり言って間違い。反証はScheme。

> evalは静的スコープにはふさわしくない
はLisp1.5世代の人の意見なのかな。

現在のevalはLispらしさを演出するためだけの存在だからな

evalを使うってのは、速度的にも不利になるし、普通にlispでプログラムを組む人は
避けるところだと思うよ。避けないとすれば腕の悪い人という印象しかないな。少な
くとも他の方法を探すだろう。

大抵マクロでおkだからな

Qiは
データ
[]
program
()
のカッコをわけたらlispの意味ないとは思わなかったんだろうか

>>451
マクロでできることはevalでもできるみたいな言い方だな
第一印象はそんなものだろうけど
それをいつまでも引きずっていていいのかな？

451じゃないけど違うの？

Lispのマクロ機能はevalで実装されていると思うのだが・・・

http://codepad.org/kiclBi61

(display (eval (let1 'y 2 `(+ ,x y))))
これで動くよ
何が言いたいのかわからんが

言いたいことは
>>443
>symbol-functionってグローバルな関数定義しか参照しないんだな
と同じことがevalにも言えるということ。

evalは外側のローカル変数xの定義を参照できないから
>>457では、事前にxのところを値で置き換えたものをevalに渡している。

つーかevalは他のローカル変数のことなんか知らんから。
関数の引数として渡されたコンテクストで評価するしかない。
それを知らせる手段として(current-environment)みたいなものが
処理系にあればやりたいことは実現できるんじゃないか。

Schemeのevalの話？

Common Lispでは、

(defvar x 1)
(print (eval '(+ x x)))
2
(let ((x 10))
(print (eval '(+ x x))))
20

Schemeのevalは渡された環境への変更に制限もあるよね。
;; R5RSとR6RSで少し違う

(let ((x 10))
(print (eval '(+ x x))))

*** - EVAL: variable X has no value

>>460が一見意図通り動いてるように見えるのは
最初のdefvarでxをスペシャル変数にしてるから。

schemeで同じことをする場合はfluid-letを使う。

(define x 1)
(display (eval '(+ x x)))
2
(fluid-let ((x 10))
(display (eval '(+ x x))))
20
x
1

mzschemeで、CGIをPOSTメソッドで使いたいのですが（クライアント側）、うまくいきません。

たとえば、
http://en.wikipedia.org/w/api.php?action=query&meta=siteinfo&siprop=namespaces
と同じことをしたいのですが（これはGETメソッド）、

(let* ((url (string->url "http://en.wikipedia.org/w/api.php"))
(post (string->bytes/utf-8 "action=query&meta=siteinfo&siprop=namespaces"))
(port (post-pure-port url post))
(xml (read-string 1000 port))
)
xml)

でいけると思ったのですが、エラーメッセージが帰ってきます。
どこがまずいのでしょうか？

コンビネータパーサを作ったから
せっかくなのでR5RSかR6RS準拠のパーサを書いてみようと思ったんだが
全体のBNFのリストってどこかにまとまってる？
仕様書をざっと見した感じでは、
ばらばらにちょっとずつBNFが載っているように感じるんだが
仕様書ってのはこんな感じのもん？

Schemeの仕様書はこんな感じのもん。
まぁLispでBNFもくそもないが。

Lisp系言語の場合、構文のフォーマルな定義がBNFとはちょっと合わない。書けなくはないけれど。
構文の定義はこんな感じのレイヤになってる。
(1)まずtokenに分解 (R6RSの用語ではlexical syntax)
(2)S式として読み込み (R6RSの用語ではdatum syntax)
(3)S式の中の特定の構造をプログラムの構文として認識 (R6RSの用語ではprogram syntax)
このうち、(2)の出力は既に抽象的な木構造のデータなんで、(3)のレベルの構文定義っていうのは
木構造に対する定義になる。もちろん木構造にマッチする文法を書けばいいんだけど。
プログラムの字面に対するBNFとは違ってくるな。
例えば、"(if x y z)" と"(if . (x . (y . (z))))" は字面では違うけどdatum syntaxとして
読まれた後は全く同じ木構造になる。program syntaxはその木構造だけを見る。

コンビネタ・パーザだとレキサも一体で書くスタイルが多い。
>>466で言うと(1)と(2)が一体。
ただ演算子多重定義出来る言語じゃないと、
見た目がシンプルにならない。

>>467
それは知ってるんだが、要点はそこじゃなくて(2)と(3)が分離してるってとこ。仕様からして。
>>464 は言語構文のBNF定義がまとまってないってことに違和感を覚えたわけだろ。
(1)-(3)までまとめて書くことはできると思うがきれいになるかな?

(3)は、R5RSとR6RSでちょっと違うし、
内部表現的には変える必要ない上に、
read/evalの分離構造ともマッチしているから、
あえて混ぜる必要はないと思う。

>>449
そういえばEuLispにはevalがなかったな。
おもしろい試みだったけどあっさりと廃れたね。
YooTooはまだ更新されているみたいだけど。
R6RSのmoduleも一部影響受けてるね。

>>463ですが、自己解決しました。
このコードで動きます。


(let* ((url (string->url "http://en.wikipedia.org/w/api.php"))
(post (string->bytes/utf-8 "action=query&meta=siteinfo&siprop=namespaces&format=xml"))
(header
'("User-Agent: MzScheme"
"Accept: application/xml"
"Accept-Encoding: deflate"
"Accept-Charset: utf-8"
"Content-Type: application/x-www-form-urlencoded"))
(port (post-pure-port url post header))
(xml (read-string 1000 port)))
xml)

すくなくともen.wikipedia.orgのサーバーは、Content-Typeを指定しないとCGIだと認識してくれないようです。

>>465-469
ありがとう。こういうもんか
特に466の説明はとてもわかりやすい。
R5RSのほうはBNFついてそうだから
こっちやってみよかな

しかし、PDFって扱いにくいわ
<hoge>って表記をテキストでコピペするとhhogeiになるし
<で検索できんから不便

ファイルの basenameを取得する関数ってありますか？

"foo.txt" -> "foo"
"foo.bar.txt -> "foo.bar"

といった風に取得したいのですが

自分で書くなら
一文字ずつ後ろから文字比較して . が来るまで探して
その部分を削除。とするんですが

もし既にあるなら書くのも悲しいので
どなたかご存知ありませんか？

(pregexp-replace "(.*)\\.[^.]+" "foo.bar.txt" "\\1")

pathname-name
http://www.lispworks.com/documentation/HyperSpec/Body/f_pn_hos.htm

>>473-474
レスありがとうございます。

環境を書いていませんでした申し訳ありません。
R5RSで行うにはどうすれば良いでしょうか？

R5RSにそんな高レベルな標準関数ないと思う

R5RSで動く出来合いのライブラリが欲しいってことかね

>>476-477
ありませんか…。

仕方がないので自分で書いてみました。
もうちょっとすっきり書けないもんかと思うんですが
今の自分にはこれが限界でした。

(define (chop str)
(substring str 0 (- (string-length str) 1)))
(define (basename str)
(if (string? (basename-if-thereis str))
(basename-if-thereis str)
str))
(define (basename-if-thereis str)
(cond ((= (string-length str) 0) #f)
((eqv? (string-ref str (- (string-length str) 1)) #\.)
(chop str))
(#t (basename-if-thereis (chop str)))))

>>472
SRFI 13 使えばいいんじゃね

(let ((i (string-index-right s #¥.)))
(if i
(substring s 0 i)
s))

basenameの本質って拡張子を省くことじゃなくてディレクトリパスの削除じゃないのかな？
(my-basename "foo.txt") => "foo.txt"
(my-basename "foo.txt" #t) => "foo"
(my-basename "/foo/bar.txt") => "bar.txt"
みたいな
472の例はgaucheではpath-sans-extensionという手続きが割り当てられている

クラススロットを辞書のように自由に登録したいのですが、
何かいい方法はありませんか？

例えば、
　(define-class <test> () (()))
というクラスから
　(define foo (make <test> :xxx 0 :yyy 10))
　(ref foo 'xxx) -> 0
　(ref foo 'yyy) -> 10
を可能にしたいのです。

>>481
処理系は？

>>482
gaucheです

簡単にやるならこんな感じかな
(use gauche.sequence) (use util.list)
(define-class <test> () (%slots))
(define-method initialize ((self <test>) initargs)
(next-method)
(slot-set! self '%slots (map (lambda (x) (cons (string->symbol (keyword->string (car x))) (cadr x))) (slices initargs 2))))
(define-method ref ((self <test>) slot) (assq-ref (slot-ref self '%slots) slot))
(define-method (setter ref) ((self <test>) slot val) (assq-set! (slot-ref self '%slots) slot val))
ほんとうのスロットのようにふるまわせたいならMOP使わないとだめかも。

>>484
それだとクラス内に辞書を確保して、
setterとgetterをスロット操作のようにエミュレートするってことですね。
なるほど〜
ありがとうございます。

ところで、Gauche本やリファレンスを見てもMOPの使い方がいまいち分からないのですが、
MOPを使うとどのようなソースになるのでしょうか？
よかったら教えてください。
よろしくお願いします。

>>479
こういうライブラリがあるんですね、紹介ありがとうございます。
ただ、これだけのためにライブラリ入れるのも何なんで
もう少し難しい文字列処理が必要になったら入れることにします。

>>480
そうですね、確かに言われてみれば。
名前は変えることにします。

コンビネータの勉強がしたいんですが
(expand S)とすると
(fun x (fun y (fun z ((x z) (y z)))))
が返ってくるような関数orマクロを作ろうとしたら
実質インタプリタを作るようなもんでしょうか？
もし楽な方法(特定の処理系の拡張機能etc)等があるのであれば知りたいです

lispな方はバージョン管理は何を使ってますか？

git
svn
cvs

>>488
darcs

mercurial,
git

Bazaar

質問します。
組合せ問題、経路問題などの、記号処理問題をリストを使って解決するのに
相応しい言語を教えてください。
環境はできるだけ特定のOSに限定されない方が結構です。
グラフ表示は別の専門家が扱うのでロジック部分のみです。

すみません。誤爆です。"初心者のためのプログラミング言語ガイド Part14"に書き込む
つもりでした。直前にこのスレを確認していたのでpasteされたURLがここになって
いました。
このスレの方々は それはSchemeだ! っておしゃいますよねw

cl-graph
boost::graph

>>492
「リストを使って解決するのに相応しい」って、その質問がすでにLISPを想定しているとしか。その名も、LISt Processer。
昔は人工知能を書くために使われていたので、ターゲット分野的にもぴったり。

LISPをはずすなら、Haskellかなぁ。
ただ、Haskellはマルチバイト文字の処理周りが痛いらしい。

>>485 Gauche特有の話だし、wilikiででも質問してみたら?

ものまね鳥をまねる、14000円つけてるなw
今図書館で借りっぱなしで催促の電話が何度もかかってる。
忙しくて読めなかったんです。
この場を借りて予約入れてる人に謝るよ。

lispのラーメンタイマーだよ
(require :pythononlisp)
(py::py "import noodletimer;noodletimer.noodletimer")

QiはQiからlispよぶのは簡単なのに
Qiをdumpしてlispから呼ばせるにはコードいじれって書いてある
自動でできないものなんだろうか

lispは、カッコばかりでみづらいとよく言われるけど
これは、慣れだね

生産効率性については、まだよくわからないけど

入門者レベルなんですが、lambdaを使わないと書けないんでしょうか

練習問題 1

次の関数を再帰を使って書いてください。
3. リスト (ls) から要素 (x) を取り除いたリストを返す関数。

; 3　模範解答
(define (remove x ls)
(if (null? ls)
'()
(let ((h (car ls)))
((if (eqv? x h)
(lambda (y) y)
(lambda (y) (cons h y)))
(remove x (cdr ls))))))

>>501

(define (remove x ls)
(cond
((eq? x (car ls)) (cdr ls))
(else (cons (car ls) (remove x (cdr ls))))))

Σ(ﾟдﾟ)

ls の中に x が二回以上出る場合はこうだ。

(define (remove x ls)
(cond
((null? ls) '())
((eq? x (car ls)) (remove x (cdr ls)))
(else (cons (car ls) (remove x (cdr ls))))))

>>502
突っ込もうと思っていました
最初のは、(remove 5 '(1 2 3 2))でもコケますね

ヒントで実装までできました
ありがとうございました

これ読んでいるとlispのほうが良さそうにみえるね
http://www.unixuser.org/~euske/doc/python/python-lisp-j.html

Schemeでスタックを書こうとした場合
スタックのデータはグローバル変数に置くのが普通ですか？
出来たらクロージャとかに閉じ込めたいのですが
引数を2個にして1個目でpush/pop判断だとpopの時は引数が一つ無駄だし
個別にクロージャを使うと環境が別々になるし。

Gaucheのオブジェクト指向拡張とかだと綺麗にかけるんでしょうかね
他に思いつくのは、モジュールを作って
そこにスタック本体のデータを置くとかですが
どれが良いと思いますか
環境はGauche0.8.14です

どれがって、consセルで作れば簡単じゃないかと

(define top car)
(define pop cdr)
(define push cons)
じゃまずいですか？

>>505
例外処理の項目の数値が未だに信じられない

>>508
スタックをリストとして直接触らせたくないってことなんじゃね？

まぁ、Gauche の OO 関連はそんなに効率が良くないので、
クロージャに閉じ込める方がまだ無駄は少いかもね。

>>509
> まぁ、Gauche の OO 関連はそんなに効率が良くないので、
> クロージャに閉じ込める方がまだ無駄は少いかもね。

くわしく
なにと比べて？
効率って生産効率？

>>506-508

想像だけど、破壊的更新をしたいじゃないの？

オブジェト志向なら、
　a = stack.pop()
stack.push(b)
　…
とか書くわけジャン。

>>511
速度とかメモリ効率とか。
メソッドのディスパッチも基本的には実行時にしか出来ないし。
どうでもいいけど、アンカ間違ってるぞ。

速度的には検証していないけど、
なんとなく>>506がイメージしているものを想像して書いてみた。
Gauche には依存していないつもり。

(define (make-stack)
(let ((stack (cons '() '())))
(lambda(proc)
(proc stack))))

(define (push stack-obj elem)
(stack-obj
(lambda(stack)
(set-cdr! stack
(cons (car stack)
(cdr stack)))
(set-car! stack elem))))

(define (pop stack-obj)
(stack-obj
(lambda(stack)
(if (null? (car stack))
'()
(let ((elem (car stack)))
(set-car! stack (cadr stack))
(set-cdr! stack (cddr stack))
elem)))))

スタックはconsで実装するつもりだったし、
なんか話がかみ合わないと思ったら・・そういうことか、理解しました
自分がやりたかったのは510氏のいうような意味でして
ちょっと調べてたら可変長引数なる便利なものがあるってわかったので
これで実装出来ました。もう少し処理を追加したら自分の目的には使えそうな感じ

(define (stack)
(let1 val '()
(lambda a
(let-optionals*
a
((b 'none)(c '()))
(cond ((eq? b 'none) val)
((eq? b 'top) (if (eq? val '()) '() (car val)))
((eq? b 'push) (set! val (cons c val)) c)
((eq? b 'pop) (if (eq? val '()) '() (let1 r (car val) (set! val (cdr val)) r))))))))
(define a (stack))
(a 'push 1)
(a 'push 2)
(a 'push)
(a)
(a 'pop)
(a)

>>513
(規制されてて書き込みのタイミングが悪かったのですが・・)
そういえば、Schemeのライブラリは、こういう形のほうが多いですね
参考にさせてもらいます
ありがとうございました

最近のスタックインターフェースは、
top, pop, pushと三つに分けるのが主流だよ。
もはやイディオムになっているといっていい。

;; クロージャに閉じ込める
(define (with-stack f)
(let ((stack '()))
(f
;; push
(lambda (obj) (set! stack (cons obj stack)))
;; pop
(lambda ()
(if (null? stack)
'()
(let ((obj (car stack))) (set! stack (cdr stack)) obj)))
;; top
(lambda () (if (null? stack) '() (car stack))))))

(with-stack
(lambda (push pop top)
(push 1) (push 2) (push 3)
(write (top)) (write (pop))
(write (top)) (write (pop))
(write (pop))
(write (pop))))

topってなんや？

解決
あとemptyっていうのも重要っぽいね

[]も使うようにしたほうがいいの？

処理系によっては [] を () と同じように使えて、多少見かけを区別することができます：

(let ([x (calculate-x a b c)]
[y (calculate-y d e f)])
body ...)

(cond [(predicate x)
(do-something) (do-something2)]
[(predicate y)
(do-another-thing)]
[else
(do-whatever)])

括弧の意味の多重化 (中段)
http://practical-scheme.net/wiliki/wiliki.cgi?Lisp%3aS%E5%BC%8F%E3%81%AE%E7%90%86%E7%94%B1

どうせそんなのはppしたら消えてしまうでしょ。
意味がある試みとは思えない。

つーかカッコが何種類も入り乱れるのは激しくウザい

世間でC言語みたいなものが好まれるのは、
演算子を含む式と文とのバランスが良く、
メリハリが付くからだと思う。
LISPは書式が関数も式も文も全く同じ規則で
さらにそれを括る括弧に極端に縛られる。
C言語でも関数呼び出しだけで書いていけば
同じ印象になるが、C言語では関数のネストなんて
書こうと思わなければほとんどする必要がない。
要するに括弧の形を変えたところであまり効果はない。
S式ベースでうだうだ考えるよりは、括弧に縛られない
都合の良い構文フロントエンドを作った方がマシである。

俺は好きでよく使っているけどなぁ。
処理系によっては()[]{}の3種類が使えるから、数学の式を書くときみたいな感覚で。

・よく言われる演算子の有無
前置記法である事と関係する。
a.b.cは
(ref(ref a 'b)'c)
1　　2　　　　3

のような書き方になる。
見ての通り1を脳内スタックに積んで2を読み、
1を降ろして3と結合する、という思考を要求する。
また、aとb,cは同一に扱えない。
((ref a b c)とは書けず、何かしら歪になる)
演算子があれば
a.b.c
1 2 3
や
a().b().c()
1　2　 3
どちらも1から3まで、左から右へと目を動かすだけで良い。
修正が発生しても一箇所で済む。
これはS式というより、前置記法では解決できない問題と認識している。

前置記法を排除すればS式でも(a -> b -> c)と書ける。
ここで、aをマクロ的に加工して実装してしまう事も考えられる。
が、それが現実的ではない事も判っている。
自分で演算子を作り、管理するのと同じ事になる。

また>>526の(a -> b -> c)のように、
S式内で独自言語を構築する場合、
独自言語の構文としての括弧もあるので、
S式のくくりの括弧がどうしても邪魔に見える。
ここまでやるならもうS式である意味がない。
a->b->cと書きたいならそのまま書けばいい。

だから、どうせやるなら>>523に書いた通り、必要時にS式も扱えるような
ちゃんぽん言語でもLISPで作ったらどうかというわけ。
不毛な縛りの中で何かやるよりはよっぽど健全ではないかと思う。
S式はデータとしてならともかく、コードとして出てくる必然性はあまりない。

>>520とどっちが読みやすいだろうか？
let x=calculate-x(a, b, c), y=calculate-y(d, e, f)
in body ...;

if (predicate(x)) { do-something(); do-something2(); }
else if (predicate(y)) { do-another-thing(); }
else { do-whatever(); }

入門者なんですが、shchemeでS式以外の書き方の標準構文ってあるんでしょうか？

人間のパターン認知力なのか、人間の適応力のすごさ、慣れなのか、よくわからないけど
今のままのほうがいい気がする
基本レベルの正規表現が使える人で、schemeを100時間触ってみて、それで真っ当な意見を聞きたいかも
みんな、「このまままでいいんじゃねえ？」って言いそう

採用する理由になった論文の疑似コードもみてみたいところだが

>>525
refが関数なら、(define ref* (lambda x (fold ref (car x) (cdr x))) で
(ref* a 'b 'c) って書けるんじゃない。
つか一般に二項演算子があるならfoldしてやりゃ不定長でも扱えるでしょ。
マクロならマクロでくるんでやればいいだろうし。
まあquoteは必要だけど、それは別の話だよね。

>>529
昔の Lisp の論文とかには M 式ってあったね。
http://en.wikipedia.org/wiki/M-expression
Scheme の方だと SRFI 49 で I 式っていうのが提案されてる。
http://srfi.schemers.org/srfi-49/srfi-49.html
正規表現云々は知らないが、どっちもあまり流行ってない。

そういえば、syntax が安定するまでは yacc を使って試行錯誤して
安定したら手書きの parser を使うという話を聞いたことがある。
lisper は逆に yacc より更に柔軟な方向に進もうとするのか。

リードマクロがあるからね。

>>528
マクロを忘れてるぜ。
コードがS式だからマクロ変換子は単なるリスト操作をすれば済むんだろう。
Scheme のマクロは単なるリスト操作じゃないけど、S式は大前提だ。
リーダーマクロにしたところで、内部的にはやっぱりS式だしな。

リードマクロってキャラクタストリームベースじゃなかったっけ？

; M-x run-scheme で下のコードをC-x C-eすると、最後に添付するエラーになってしまいます
(define (foo x)
(if (= x 0) '()
(cond ((= (modulo x 15) 0) (cons "FizzBuzz" (foo (- x 1))))
((= (modulo x 5) 0) (cons "Buzz" (foo (- x 1))))
((= (modulo x 3) 0) (cons "Fizz" (foo (- x 1))))
(else (cons x (foo (- x 1)))))))

環境
"GNU Emacs 22.3.1 (x86_64-unknown-linux-gnu)
of 2009-03-10 on localhost.localdomain"
guile> "1.8.0"
ちなみにon emacsでloadすると、うまくいきます。
guile> (load "fizzbuzz.scm")
guile> (foo 21)
("Fizz" "Buzz" 19 "Fizz" 17 16 "FizzBuzz" 14 13 "Fizz" 11 "Buzz" "Fizz" 8 7 "Fizz" "Buzz" 4 "Fizz" 2 1)
また、gosh on emacsだと、こうなります
gosh> (32 31 #0="FizzBuzz" 29 28 #1="Fizz" 26 #2="Buzz" #1# 23 22 #1# #2# 19 #1# 17 16 #0# 14 13 #1# 11 #2# #1# 8 7 #1# #2# 4 #1# 2 1)
OS再起動してもダメでした

エラー(長いので、一部略)
guile> ... ...
Display all 1922 possibilities? (y or n)
...
Display all 1922 possibilities? (y or n)
$abs
EISCONN
ERROR: Unbound variable: s
ABORT: (unbound-variable)
"Fizz"

Backtrace:
In current input:
307: 0* [foo 3]
304: 1 (if (= x 0) (quote ()) ...)

<unnamed port>:304:1: In procedure memoization in expression (if (= x 0) (quote ()) ...):
<unnamed port>:304:1: In line 303: Missing or extra expression in (if (= x 0) (quote ()) d ((= (modulo x 15) 0) (cons "FizzBuzz" (foo (- x 1)))) s "Buzz" (foo (- x 1))).
ABORT: (syntax-error)
ERROR: In procedure scm_lreadr:
ERROR: #<unknown port>:307:24: unexpected ")"
ABORT: (read-error)
ERROR: In procedure scm_lreadr:
ERROR: #<unknown port>:307:25: unexpected ")"
ABORT: (read-error)
guile>
Display all 1922 possibilities? (y or n)
$abs
%app
%cond-expand-features
%cond-expand-table
%get-pre-modules-obarray
%guile-build-info
ERROR: Unbound variable: s
ABORT: (unbound-variable)
4

Backtrace:
In current input:
308: 0* [foo 3]

<unnamed port>:304:1: In procedure memoization in expression (if (= x 0) (quote ()) ...):
<unnamed port>:304:1: In line 303: Missing or extra expression in (if (= x 0) (quote ()) d ((= (modulo x 15) 0) (cons "FizzBuzz" (foo (- x 1)))) s "Buzz" (foo (- x 1))).
ABORT: (syntax-error)
ERROR: In procedure scm_lreadr:
ERROR: #<unknown port>:308:19: unexpected ")"
ABORT: (read-error)
ERROR: In procedure scm_lreadr:
ERROR: #<unknown port>:308:20: unexpected ")"
ABORT: (read-error)
ERROR: In procedure scm_lreadr:
ERROR: #<unknown port>:308:21: unexpected ")"
ABORT: (read-error)
ERROR: In procedure scm_lreadr:
ERROR: #<unknown port>:308:22: unexpected ")"
ABORT: (read-error)
ERROR: In procedure scm_lreadr:
ERROR: #<unknown port>:308:23: unexpected ")"
ABORT: (read-error)
guile>

(print (foo 21)) or (write (foo 21))
トップレベルプリンタが同一オブジェクトを複数回出力しないだけの問題では？

>>539
どういう意味ですか？
自分なりに解釈して、やってみたけど、ダメでした

>>540
>>539 の言っているのは gosh の出力についてだね。
guile のエラーについては式が guile にちゃんと渡されてない感じがする。
プロンプトが複数回表示されてるあたり、
式が複数に分割されて渡されている形になってそうなんだけど。
gosh だと C-x C-e でちゃんと動いてるのかな。

アドバイスをきっかけに解決しました
タブによるインデント構造をつくるとこのエラーになるみたいです
スペースに置換してみたら、通りました
おとといまでは、普通に使えていた気がしたので、謎です
特別な設定をしたとしたら、メニューバーのschme欄をちょっと触ったときなのかな
触ったあとに特別不都合は、なかった気がしたけど
>>541
> >>539 の言っているのは gosh の出力についてだね。
把握しました

> gosh だと C-x C-e でちゃんと動いてるのかな。
もちろん、そうです

ドキュメント関係とデバッグ関係が整備されていそうなguileで行きたいんですよね
言語に慣れていないレベルなので、文字列処理関係は、まだ先っぽいので

気に掛けてくださったみなさま、お世話になりました

ああそっちの問題か
readlineが悪さをしてる予感
emacsで使うときはactivate-readlineを無効にしたらどうでしょう

>>543
本当だ
cat ~/.guile
(use-modules (ice-9 readline))
(activate-readline)
の設定を外したら、tabインデントでもC-x C-eが通るようになりました

また、安直にcat ~/.gosh
(use-modules (ice-9 readline))
(activate-readline)
としていたんですが、これって効いていないんですね
goshに関しては、info関連をまだ目を通していないので、あれなんですけど

構文を多少読めるようになったので、readline.scmとguile関連のinfoを眺めてみることにします

gaucheのインタラクティブモードで読み込まれるスクリプトは.gaucherc。
それとice-9モジュールはguileの物であってgaucheにはない。
.guileから外すのは(activate-readline)だけでいいと思う。
gaucheを使うのならttp://practical-scheme.net/gauche/man/gauche-refj_toc.htmlを読む事を勧めます。

guileのgaucheに対する利点：多くのOSでportやpackageが用意されている。リードマクロがある。親方GNU。
gaucheのguileに対する利点：速い。日本語のドキュメントが多い。マルチバイト文字がサポートされている。

(activate-readline)を外すのが嫌だったので、とりあえず関数に割り当ててみました

scheme, lisp関連の設定って、みなさんは、どういうふつうにされているんでしょうか？
不都合がなければ、晒してほしい・・・

cat ~/.guile
; first setting
(use-modules (ice-9 readline))
(define (a) (activate-readline))
; adding
(use-modules (ice-9 popen))
(use-modules (ice-9 rdelim))
(define date (read-line (open-input-pipe "date -R")))
(define pwd (read-line (open-input-pipe "pwd")))
(define echo-home (read-line (open-input-pipe "echo $PATH")))

activate-readlineはemacsからrun-schemeで使うときは不要。っていうか邪魔。
(or (string=? "dumb" (getenv "TERM")) (activate-readline))
とか書けばいいんじゃないかな
（run-schemeのときは環境変数TERMがdumbに設定されるから）

ああそれからactivate-readlineは起動後の任意の段階で評価できるから
.guileに書かないでおいて、シェルから直にguileを起動しただけ
手動で評価してもいい。
$ guile
guile> (activate-readline)
guile>

scheme、lisp関連の設定といっても自分は.emacsくらいですね。
ttp://karetta.jp/book-node/gauche-hacks/004682などを参考にするといいと思います。

>>543
なるほど、readline が \t を食っちゃうのか。
知らないと意外とはまりそうだな。覚えておこう。

逆に言えばreadlineでシンボル補完が効きます

ドキュメントとデバッグ環境でGuileを選ぶってのも珍しい気がする。
そういう場合はPLTとかに行きそうなもんだけど。

>>547
コンソール時
echo $TERM
linux

gnome-terminal時　
echo $TERM
xterm

emacs時 echo $TERM
emacs
なのに、なぜemacs時だけ(activate-readline)が実行されないの？
>>551
scheme処女なもんで4つのinfoがあるguileなのかなと思って
PLTは、存じませんでした
候補として考えたのは、Gauche, guile(, tiny scheme)の2つ(3つ)ですね
ちょっとした疑問なんですが、guileにあるhelp関数ってGaucheにもあるんでしょうか？
あと日本人のguile率って少ないんでしょうか？
SchemeでぐぐるとGaucheがいっぱいひっかかりますね

Gaucheは高機能な上、日本人のShiro Kawaiさん作なので日本語のドキュメントがたくさんある。
guileはGNU標準でポータビリティは高いんだけど動作が遅くてスタックが（標準では）少ない。
入門用ならばR5RS規格に最も厳格にマッチしている上にguile以上のポータビリティがあるScheme48もお勧め。
自分はGauche＞＞guile＞Scheme48の順に使ってます。
マクロの種類で言えば
Gauche：syntax-rulesマクロ、伝統的マクロ
guile：syntax-rulesマクロ、syntax-caseマクロ、伝統的マクロ、リードマクロ
Scheme48：syntax-rulesマクロ、明示的改名マクロ
なのでguileが最も充実してますが。

>>552
gaucheにはhelp関数は無いけどinfo関数というのがある。
ただ、表示されるのが「その関数を含むinfoの1ページ」なのでちょっと面倒。
emacsから使ってるなら、カーソルのある関数のinfoエントリを一発で*info*バッファに
表示するelispが昔MLに流れたことがあった気がする。

describeもaproposも使えるけど
なんだかんだでhyperspecとslimeが使いやすいやね

自己解決しました
コピペまんまだと、activate-readlineきいていました
"dumb"のところを"emacs"に変えればいいわけですね
当たり前と言えば、当たり前なんだけど

日本語WikipediaのSchemeの項目の最下部の外部リンクの「関数プログラミングは、なぜ必要か、うんぬん」の文章ってわけわからないっすね
あの疑似コード、わかりにくいw

プログラミングしていて、なんとなく関数言語がいうモジュール化がわかってきたかも
>>553
今、気づいたんですが、日本語WikipediaにSchemeの処理系の項目は、Gauche以外書かれていないんですね
そういう意味でもGaucheに流れる人が多いのかな
>>554
info関数なんてあるんですね
Gaucheのインストール失敗したのか、よくわかりませんが、info閲覧できないんですよね
まだ必要に迫られていないので、ちゃんと調べていませんが

>emacsから使ってるなら、カーソルのある関数のinfoエントリを一発で*info*バッファに
>表示するelispが昔MLに流れたことがあった気がする。
便利そうですね

>>555
slimeって聞きますね
もうちょっとしたら、導入してみます

あれ、run-schemeで起動したguileで
guile> (getenv "TERM")
"dumb"
ってなりませんでしたか？
guile> (getenv "TERM")
"emacs"
なら"dumb"を"emacs"でいいですけど…

>>557
shellモードもrun-schemeモードも"emacs"と返りますね

infoドキュメントでがんばって、勉強しているんですが
けっこう大変ですね

基本的なlet, set, lambda関連の記述の仕方は、わかるんですが
ちょっと複雑になると理解しにくい・・・

>SchemeでぐぐるとGaucheがいっぱいひっかかりますね
絶望した！横文字をウェブ全体から検索した結果に絶望した！

infoで勉強する心意気は結構ですけど
先ずは>>216あたりのウェブページで勉強するほうが楽かもしれません。
わからない所はこことかに具体的にドシドシ書きこむと
さらに後に続く人の為にもなるでしょう。

>>560
> infoで勉強する心意気は結構ですけど
> 先ずは>>216あたりのウェブページで勉強するほうが楽かもしれません。

infoで勉強するのが今回の目的だったりするんですよね
あとguileは、なにができるだ(どういう機能があるの？)というのも速く知りたいから、
とりあえず、なぞっているのもあります

もちろん、Schemeの学習階段的には、日本語の入門サイトは有用ですね

英語圏の人は、infoだけで事足りるのか、プログラミング経験度を前提しているのかとか

>infoだけで事足りるのか
そんな完璧な文書があると思うか？
あるわけねーだろ
完璧を目指すのはいいが少しずつ地道に改善していくしかない


ちなみに、アジャイルとかなんとか言われるようになる以前は
一発で完璧なものが作れると思ってる奴がたくさんいたとかいないとか

>>562
完璧な文書だとは、思わないけど
十分な文書だと思うよ

common lispの情報探そうとするとhatenaなどのblogにいきあたること多い
schemeは2chの過去スレが検索にかかることが多い

この違いは何？

Googleの中の人に聞いて下さい。

schemeしか知らないけど、lispでぐぐればいいんじゃない？
lisp --> common lisp
scheme --> scheme
という理解だけど

&hl=en付けたら2chにもhatenaにもいきあたらないな

>564
実用性があるか無いか、実アプリ開発に使ってるか否かの差だとオモ。
言い方を変えればSchemeは教育的効果は高いが…

おっとBASICの悪口はそこまでだ

schemeで、(car '())や(cdr '())の結果はどうなるんしょうか？
昔読んだLISPの本か何かでnilのcarやcdrはnilになるという
説明を見た気がするのですが、schemeにも当てはまるんでしょうか。

r5rsでは空のリストにcar,cdrはエラーって定義されてるな

R5RS 6.3.2

r5rs-ja.pdfにありました。ありがとうございました。

>>497
オレ、とある図書館でその本の順番待ちなんだが、
まさかオマエが止めてるのか?w

なんだこいつ

これをLIFOと言います

後入れ中出しだっけ

アッー！

guile, gaucheよりelispのほうがデバッガが整備されているの？

>Shiro(2007/09/05 13:39:49 PDT): 慣れが半分、後は「バグを出しにくいコードの書き方」が半分でしょうか。出来る限り副作用無しで書いておくとバグの切り分けが非常に容易になります。
>たぶん、「ソースの動きを追う」という考え方自体、C/C++とSchemeで差があるんではないかと思います。
http://practical-scheme.net/wiliki/wiliki.cgi?Scheme%3a%E5%88%9D%E5%BF%83%E8%80%85%E3%81%AE%E8%B3%AA%E5%95%8F%E7%AE%B1#H-1frlpc5

C(手続き型言語)との対比でschemeにとってソースの動きを追うってどんな感じなんですか？
個人的にデバッガを使って、「ソースをよく読み、ときどき書き」というのをしたいんですが

>>579
そのすぐ下に書いてある通りでは。
デバッガを使わずとも、replで個々の手続きを呼べるので、色々な入力を与えて出力を
見るかな。入力と出力の関係がすぐに把握できない(手続き内でステップ実行したいと思う)
ようであればたぶん手続きが(あなたにとって)大きすぎる。

で、何のソースを読みたいの？
抽象論はもう飽きたよ

>C(手続き型言語)との対比でschemeにとってソースの動きを追うってどんな感じなんですか？
そういえばあんまり追ったことないかも・・・スタックトレースが1000行と出ちゃうから。面倒なんでデバッガ使わなくなった。"Type (debug) to enter the debugger."とか出されても、もう無視（w

>>580
処理系への絶対的な信頼性ってこと？
効率的なデバッグ術の個人の差ってかなり開きがありそうだね
>>581
日本語サイトのサンプルとか、とりあえず、デバッグツールで読みたいなあと思って

バグでハマって、解決はしたけど、ものすごく時間がかかった場合は
バグの見つけ方のポイントを教えてくださいね

初心者ですけど

(define (f x)
(let ((a (hoge1 x))
(b (hoge2 a))
(c (hoge3 b))
(d (hoge4 c)))
d))

;; (f "なんちゃら")

みたいな書き方をしています。

Emacsで、最後のコメントアウト行でC-c C-eで評価。
思ったような主力がでないときは、最後のdをcとかbとかに書き換えて、その段階での出力をみます。

手続き型に毒されたやり方でしょうか？

それをやるならlet*じゃないかね

>>579
自分はC++でプログラム書く時も、
デバッガ使うのはcore dump(assert含む)した時くらい。
基本的にユニットテストやってる。
自分のことを全然信用してないから、
全自動で網羅的なチェックした方がよい。

もちろんテストコードの方が圧倒的に多いし、
assertも馬鹿みたいに書いてる。
コードを書いたらすぐにユニットテストも書いてるから、
何かテストしたい時には、デバッガ立ち上げて操作するより、
既存のユニットテストコードを基に新たに書く方が速いw

テスト、assertコードを書くのは設計の検討にもなってる。
設計をあらゆる角度から観察する必要があるから。
もちろんdtrace, profilerなんかも使いますが。

>自分のことを全然信用してないから、
分かるわ〜
自分もいっつもデイジー・デイジー歌っちゃう

そんなんじゃボーマンさんにスイッチ切られちゃうぞ。

>>585
ご指摘のとおり、let* でした。

そのテストツールの作り方の方針というか
みたいなものをまとめている本ってないでしょうか

そのってどの？

まずデバッガに依存するのをやめて徹底的に構造化プログラミングを意識するようにした方がいいんじゃね？

具体的に何のコードをテストしたいのかを意識するべき。
そうでないと、ツールとか方針とかが正しいのか、そもそも必要なのかを検証できない。

>>592
デバッガ使ってうまくいっている人は使えばいいと思うよ。

デバッグのしやすさをよく考えて作ったほうがいいよ。つまり
手続っぽく作るのも可能だけど、なるべく関数のスタイルを身につけたほうが
効率的だよ。関数のスタイルをとるなら、デバッグはassertやtraceさえ出来れ
ば、大体なんとかなるし。いわゆるデバッガが必要なのは、関数がでかくって、
その中で手続的に処理が乱雑になっちゃうからなのでは？

そもそもの話はコードの読み方じゃなかったっけ。
まあ、それはreplで関数叩いて入出力確かめろ、ですでに結論出てるな。
とは言え、じゃあひどいコードはどうやったら効率よく読めますか、
とか訊かれると、どうしたもんかね、となるが。

本屋でO'reilly Gaucheをみかけて、軽く立ち読みしたけど
良さそうな感じだね

>>590
処理系のソースに付いてくるテストコード読みなよ。

>>597
新しいGauche本が出たのかと喜んでオライリーを覗きに行ったら
ふぬああ本のことだったのか…

2133?

フ ムフム
ヌ クヌク
ア プ
ア ア

フムフムヌクヌクアプアア ♪

http://www.youtube.com/watch?v=ir38tIOQdT0

すまんがカッコ付きで話してくれんか

(+ (* フム 2) (* ヌク 2) アプアア)

Syntax Error

>>605
お前が閉じろよ。

私のカギカッコは渚でしか見つけられませんでした。

))) ←波

))) ←こんなん見て人生おかしくならないか？

>>609
おれのヘッドホンは
beyerdynamics))))
だよ。

((((((((((（パナウェーブ)))))))))))

Lisp使い初めてから人生おかしくなったとか損したなんて人は
今まで一人も見たことがないな。



その前に周りにLisp使える人が一人も居ないお(´；ω；｀)

損はしていないが、Lisp使えるだけでアレゲな現場に投入された経験はある。
周りが変態ばかりで困った記憶がある。
かくいう俺もド変態だ。どうだまいったか。

アレゲってエロゲでAI作るとか？

ぬるぽ

LISPにNullPointerExceptionあるの？

規格上はない。
補足してトップレベルに復帰する処理系はある。

おお、安心しました。

値が束縛されてないシンボルを参照したりすると出るエラーがぬるぽに相当するんでは？

それはUNBOUND-VARIABLEだよね。
NILのCDR取るとか規格の範囲内で起きるものじゃなくて、
MEMREFなどの低レベルAPIや処理系バグで起きる、
*((char *)0)な話かと思ったが。

>>574
謝ってるのにオマエとか言う奴には貸したくないな。

いやいや、アナタの本じゃないし
読んでなくても一度返すのがスジですよ。
そして列の最後尾に並び直すのです。
（セドラーから5000円だか7000円だかで新古本を買った者より）

筋というか、普通はそういう規則じゃないの。
予約を入れた人がいなくても
貸し出し期間内に図書館にいって延長手続き(借り直し)するものだと思うんだけど。

>>622
へー新古品なんてあるところにはあるんだなあ。
ところで訳書を出してたとこってたしかオンデマンド印刷とかで
幾つか出してるし、これもそれで復刊してくれないかなあ。

某大手書店の最後のディヴィグ本をゲットして喜んでたのに
いつの間にか増刷されてamazonでさえ普通に新本が手に入るようになってて涙目w
手習いとかものまねも復刊されるかもね

>>625
ま、そんなこともあるさ。 どんまいどんまい。

筋ってw
ヤクザやさんがこんなところに居るとはw
規則なんだから返すに決まってるでしょ。
あればね…

ていうか本なくしちゃったw

>> 627
細かいこと気にするなって。買って返せば無問題♪

>>621とか>>627とか、こういう奴がいるから、
図書館の中の人が苦労するんだろうな、と思った。
釣りならいいけど、素でその態度なら頭おかしいだろ。

わざわざ言うことかw

絶版Lisp本ではものまね鳥と竹内先生の本が読みたいな。
あとLisp以外ではPrologの技芸。ヤフオクみたら29500円とかwwwwww
オンデマンドで売ってくれくれ。

Prologの技芸ってたまに名前を聞くんだが、そんなに偉大な本だったのか・・・・・

Prologの技芸持ってるけど読んでないぜ
そんなプレミア付きとは知らなんだ

>>633
よかったら読んだら売ってよ。1万なら買うよ。

「Prologの技芸」はProlog版SICP。
SICPはアーキテクチャよりだけど、こっちは応用より。
内容グーで印刷ショボ。

間違ったヤフオクじゃなくてアマゾンだった。> 29500円

これって業者がつり上げてんの？ひどい値段だなぁ。

>Prolog版SICP
なるほど

the art of prologの和訳本だよね

MITの教科書か。既に新しい版が出てるみたいだね。

話ぶった切ってすまないけど、SchemeでProcessingみたいに
Arduinoを制御することができる処理系ってあるのかな？
GaucheとかPLTってどうなんだろ？
できればやりかた書いてあるリンク教えてください。

>>641
chicken scheme + avr-gcc + avrdude
http://1010.co.uk/arduino.html#2

一方ポールグレアムはクラウドを制御した

crowdコンピューター？

生きのこる術は大衆言語。

だが気を付けたまえ。

>>641
"Getting Started with Arduino"の６章"Talking to the Cloud"で
Proce55ingを使ってクラウド上のPhysical computingを制御してます。
実はRubyやPerlやPythonでも出来るので、
もしかしたらGaucheとかPLTでもできるかも･･･Arduinoはavrdude経由で操作するかと思いますが･･･
スクリプトでなければ>>642のようにavr-gccでArduino上のプログラムを
作成するのが良いでしょう。
そんな感じでクラウド側もPhysical computing側もSchemeは使えます。
といってもArduino上のというかAVR上のSchemeはまだないですね。
最近はメモリサイズが大分大きくなったようですが･･･

>>647
>Arduino上のというかAVR上のSchemeはまだないですね。
つーかそもそもmegaの内蔵SRAM程度では厳しい。
外部コンパイルしてAVR上でVMを走らせる
みたいな使い方ならできるだろうけど。
マイコンでscheme動かすならアドレス空間大きめの
ものを選んだ方がいい。

>>648
PICでSchemeが動いているｗ

atmegaでも無理なのか
ならschemeからマシン語のコードを吐くコンパイラというのならどうかな

ハーバードアーキテクチャだからフラッシュとSRAMの扱いが違うんだよね
フラッシュにオンタイムで書き込むにはブートローダもどきがいる

Schemeじゃないけどこんなのはあるよ。
簡単なλ計算のインタプリタをArduinoで動かしてる。

Project LambdaCan: Lambda Calculus in a Can
http://alum.wpi.edu/~tfraser/Software/Arduino/lambdacan.html

>>652
有り難う御座います。このスレでもλ計算の話は久しぶりですね。
とっても気に入りました。でも、素のλ計算はメモリを喰うので
この計算ぐらいが限界って例が書いてありますね。
簡約戦略がまずいとメモリオーバーしそうですねｗ

関数型スレでスルーされてしまったのでコチラで聞いてみますが
lazy-kやunlambdaの式をλ式にしてくれる変換器ってないでしょうか
(もしあればCombinator Birdsのような式が直接計算出来るのが理想ですが)
というのも、W=C(BMR)=λab.bbb≠λab.abbな気がするので
検算してみたいんです。
後Combinator Birdsのページ、
W=SS(KI)がおそらく一番シンプルな答えですね

なんか流れを止めてしまったみたいなので、654は撤回します
ごめんなさい

過疎板の過疎スレで気にするような事じゃない

>>655
いや、関係ないだろ

W=C(BMR)=λab.bbb≠λab.abbとW=SS(KI)ってどういう意味なの？
暗号にしかみえないｗ

撤回するな！CLかSchemeで実装してみろ！
と焚きつけてみる

良かった。それじゃせっかくなので解説してみます
λをlと表記すると
lab.abbってのは(lambda (a) (lambda (b) ((a b) b))と同じ意味(abbの部分は左結合)で、
これはWコンビネータのλ式の表現でもあります。
W=SS(KI)、つまり((S S) (KI))ってのは以下のS,Kを用いてWが表せますよ、という意味

;lxyz.xz(yz)
(define S (lambda (x) (lambda (y) (lambda (z) ((x z) (y z))))))
;lxy.x
(define K (lambda (x) (lambda (y) x)))
;lx.x
(define I (lambda (x) x))
(define turing-type-quine
(lambda (x)
(lambda (y)
(list y (list x
(list 'quote x)
(list 'quote y))))))
(define w (lambda (x) (lambda (y) ((x y) y))))
((((S S) (K I)) turing-type-quine) 2)
((w turing-type-quine) 2)

最後の2行は同じ結果になりますよね

Combinator Birdsでググるとトップに出てくるページには
この他にW=C(BMR)っていう定義が載っていて
これを簡約するとlab.bbbになるのではないか、というのが自分の疑問です。
というか、上のようなコードを書いて気づいたけど、
Scheme殿に計算してもらえば良かったわけだ
今から試してきます。気づかせてくれてさんきゅ

(define C (lambda (x) (lambda (y) (lambda (z) ((x z) y)))))
(define B (lambda (x) (lambda (y) (lambda (z) (x (y z))))))
(define M (lambda (x) (x x)))
(define R (lambda (x) (lambda (y) (lambda (z) ((y z) x)))))
(define W (C ((B M) R)))
((W turing-type-quine) 2)

普通に出来た。
自分の計算ミスかー、ショック

ちなみにW=SS(KI)はこんな感じで計算できます。
lab.abb
=lab.(ab)b
=la.S(lb.ab)(lb.b)
=la.SaI
=la.(Sa)(KIa)
=S(la.Sa)(la.KIa)
=SS(KI)

>>660
2割ぐらい理解したｗ
あとで再挑戦・再理解してみる
lambdaを3つ使うのを初めてみた
おれはlambdaを3つ使うコードを書くことがあるのだろうか

このロジック(表記法？)は、どういう用途で使えそうなの？

意味はさっぱり分からんがラムダだらけで楽しそうだ

>>661
オレ、660じゃないけど、べつに実用性とかじゃなくて最小の関数型言語の形のひとつ：
http://e.tir.jp/wiliki?%CB%DD%CC%F5%3A%A5%D7%A5%ED%A5%B0%A5%E9%A5%DF%A5%F3%A5%B0%B8%C0%B8%ECLazy_K

>>663
Thank you
知らない概念や処理系が、いっぱいあったけど
2割ぐらい理解した

感想は、うまく言葉にできない

660ですが、ML系(たぶんHaskellも)の言語ではカリー化という機能があって
Schemeでいう以下の2つは同じ物として扱われる
　(lambda (x) (lambda (y) (lambda (z) ...
　(lambda (x y z) ...
3引数の関数なら書いたことあるでしょ？
そう考えたらそんなに複雑でもなく見えてくるかもね

>>665
素朴な疑問なんですが
普段は、なんの言語を使っているんですか？
ちなみに自分はbash 5％, C/C++ 30％, gauche 10％, Python 30％, その他 25％
エディタはemacs？
差し支えなければ、教えてください

聞かれていない自分も晒すと
gauche95%、sh3%、sed1%、C1%くらいだな。
1年半くらい前はsh70%、sed20%、C8%、(Scheme48+guile)2%くらいだったけど。

カリー化と可変長引数は両立がむずかしげでML系はカリー化を、Lisp系は可変長引数を取ったんだとおもう。
あとカリー化とthunkも相性が悪くて
正格評価のMLは、評価を遅延させる式を
():unitを受け取るなんちゃってthunkで実現してた気がする。

>>667
gaucheを使っていて、不都合はないの？
他の言語を選ばずに、gaucheを選んだいくつかの理由ってなに？
lisp系じゃなくて、gaucheの理由も知りたいかも

Gauche使ってる時間が50%ぐらいで、
OCaml&F# 30% C++ 15%　Perl 5%ぐらい
エディタはVC付属エディタとemacs/viです

ところで、可変長引数がダメなのはカリー化というより
型付けが出来ないからではないでしょうか？
呼び出し時に引数の型を指定するprintfのような関数なら
I,T,Qコンビネータと関数合成とカリー化で一応実現できます
効率にハンデはあるかもしれませんが

500 ：Classical名無しさん ：09/04/01 20:55 ID:qtulE/8k
よろしくお願いします。

【URL】　http://pc12.2ch.net/test/read.cgi/tech/1231856193/
【名前欄】 660
【メール欄】 sage
【本文】↓
Gauche使ってる時間が50%ぐらいで、
OCaml&F# 30% C++ 15%　Perl 5%ぐらい
エディタはVC付属エディタとemacs/viです

ところで、可変長引数がダメなのはカリー化というより
型付けが出来ないからではないでしょうか？
呼び出し時に引数の型を指定するprintfのような関数なら
I,T,Qコンビネータと関数合成とカリー化で一応実現できます
効率にハンデはあるかもしれませんが

>>668
自分のScheme処理系の変遷は
１．scm。多倍長整数が使いたくなる。
２．Gambit-C。SRFI周りがオレ様過ぎる。
３．MzScheme。非メジャーCPU、非メジャーOSへのポートに挫折。
４．Scheme48。本格的にSchemeを使い始めるが非保健的マクロが独自、SLIBのサポートがビミョー。
５．Guile。機能的にはほぼ文句はないが、遅い。そして重い。
６．Chicken。非メジャーCPUで最適化バグがあったような気がする。
７．Gauche。現状フリーR5RS処理系でベスト。非メジャーCPU、非メジャーOSへのポートも楽。
という感じです。
ドキュメントも豊富、高機能で軽くて高速、とくに正規表現周りはcl-ppcreよりも使いやすいのも◎。
いままでC＋sed＋shでやってたことをgaucheだけで置き換えられるようになったのがいいですね。
速度重視とかマルチスレッドバリバリなことをしなくなったということもありますが。

SGIが倒産したらしい

そうか、そうか

lisp系は自作に限るよ

LispスレでSGIといったら創価じゃなくて
シリコン・グラフィックの方だろJK

2度目の倒産なんだって？
なんかLispに関して大きいことやってたっけ？
OpenGLぐらいしかシランわ。

ずっと自作のSchemeモドキを使っています。モドキというのは、あまり
使わない機能を削って代わりに部分継続やソフトタイピングを入れたり
してるためです。それなりに高速でデバッグ機能も充実していると思って
いますが、RnRSやSRFIの類は全く考慮せず作っているので公開していま
せん。ドキュメント書くのもめんどくさいし(論文は書いたけど)。

>>672
エイプリルフールだと思ってた…

勘違いしたかも。
SGI(非創価)ってLisperが作った会社だと思ってました。

lispでモナディウスなみの速度は出せるのだろうか

>>679
ジムクラーク？　Lisper ではないね。専門は CG らしい。
ワークステーション屋で Lisper が作った会社ってあったっけ？
Sun のビルジョイはハッカーだけど Lisper じゃないし。

昔、N-Worldって、SGI (Indy?)向けの3D CG作成アプリなかった?
Lispマシンから移植されたものだったと思う。Lispで動いていたはず。
プロトタイピング強いから、いろいろな分野の初期大型アプリで使われてるね。
数式処理、ウィンドウシステム、プログラミング可能エディタなど。
CG関係も昔はもっと多かった。

sgiといえば、インディゴだな。doomでネット対戦に使わせてもらったよ。

sigは破産申請したらしいね

CGはもうからないのか

>>682
ニチメンなんとか、ってやつのことかな。Shiroさんが詳しそう

前回の破産でCG方面からサーバー屋に商売変えしてたんじゃなかったっけ？

なんかMIPSの灯がどんどん消えてく気がするなぁ…

/.Jによると、どこだかに買収されるんで、それに必要な手続きなんだと。

>>681
そうゆう名前で呼ばれてかかどうかはおいといて、MIT 由来の
LISP マシンってワークステーション以外のなのものでもないが…

>>685
技術の発展とともに、作業端末は高価なUNIXワークステーションではなく
安価なWindowsマシンが優位になり、未開の領域に強く柔軟なLispから
高速で大規模なプログラムに強い? C++に置き換わったとかじゃないの。

>>690
あーそうね。シンボリクスとかがそうか。
Unixワークステーション屋で、と言うべきだったかな。

carやcdrがちゃんと理解できん・・・
アセンブラの方が簡単かも。

そんなに難しいかな？

単方向リンクリストの、先頭を取り出すか、それ以外を取り出すか、
だけなんだが。

括弧とドットの表記法でつまづくか、ポインタでつまづくかのどっちかですよねー

carは左って覚えれば良いと思うよ

>>693
コンスは単なる2つのポインタの対
Lispよりも低レベルではcarとcdrは可換で線形リストとは何の関係もない
線形リストに利用しているのはLispより高レベルだけの話
アセンブラ的に考えればこう

まずボックス表記を手で書いて
それからいろんな構造をconsだけで組み立てる
ドット対→線形単リスト→２分木みたいに徐々に複雑にしていくといい

Common Lisp: A Gentle Introduction to Symbolic Computation 付録の sdraw 使うと図示してくれる

CL-USER> (sdraw '(1 2 3 (4 5)))

[*|*]--->[*|*]--->[*|*]--->[*|*]--->NIL
|　　 　　　|　　 　　　|　　 　　　|
v　　　　　v　　　　　v　　　　　v
1　　　　　2　　　　　3　　　　 [*|*]--->[*|*]--->NIL
　　　　 　　　　　　　　　　　　　|　　　　　|
　　　　　 　　　　　　　　　　　　v　　　 　v
　　　　　　 　　　　　　　　　　　4　　　　 5

http://www.cs.cmu.edu/~dst/Lisp/sdraw/

ちゃんと理解できないったって(と)の対応はわかりますよね？
Lispのリスト記法はドット記法の構文糖
任意のリスト記法はドット記法で表せる（逆は偽）
ドット記法の基本は( A . B )でホワイトスペース＋ドット＋ホワイトスペースがcarとcdrの間の仕切り
（開き／閉じ括弧の周りはホワイトスペースの省略可）
そしてドット記法を(A B C)みたいなに直すのは
ドット＋開き括弧を見つけたら、それと、それに対応する閉じ括弧を消しゴムで消すだけ

( A . B )　≡　[ A | B ]

(cons 'a 'b) => (a . b)
(cons 'a (cons 'b '())) => (a b)
'(a . (b . (c . ()))) => (a b c)

'とかquoteが絡んでくると解りづらくなるから
任意のアルファベット１文字のシンボルと空リストは自己評価的という設定にしよう
(cons A B) => (A . B) ;; [ A | B ]
(cons A ()) => (A . ()) ≡ (A) ;; [ A | NIL ]
(cons (cons A B) ()) => ((A . B) . ()) ≡ ((A . B)) ;; [ [ A | B ] | NIL ]
(cons () (cons A ())) => (() . (A . ())) ≡ (() A) ;; [ NIL | [ A | NIL ] ]
(cons A (cons B C)) => (A . (B . C)) ≡ (A B . C) ;; [ A | [ B | C ] ]

lispのリストはヘテロジニアスリストでさらにペアにもなるから難しいよな
ML系みたいにリストは空か値とリストを持つコンスって定義だとまだわかりやすいのに

分かりにくくないだろw

ふと思ったんですけど
効率の為にlistではなくvectorを使っているアルゴリズムって
静的にコンパイル＋破壊的代入なしって条件なら
プログラマにはlistとして見せつつ
内部的にはvectorとして処理できませんかね？
たとえば(list 1 2 3 4 5)は
表面的にはコンスによる線形リストなんだけど内部的には#(1 2 3 4 5)であるオブジェクトを返すとか。
書き換えられない事が解っているn要素の線形リストは2ワードのセルをn個アロケートするより
nワード+αのベクタで記憶するほうがよさそう。
Haskellが文字列をリストとして実装してるのはそんな理由だったりするのでしょうか？

それは「cdr coding」と呼ばれるもので散々実験済み。

書き込んでから気づいたけど、
部分リストを複数オブジェクトで共有している場合
先頭部分の参照がはずれてもGCで回収できなくて逆に効率が悪くなりますね。
ベクタの最初の方だけGCできる方法を取れば別ですけど
そうするとベクタの情報が増えて結局コンスと大差なくなるかも

>>707
おや、そうでしたか。不勉強でした。
見た所、線形リストを少しでも効率よく処理する為の物の様で
ベクタを置き換えるには至らなかったようですね。

vector的利用がはっきりしているところでは、
vectorを使えばいいしね。
listで構造体を模倣してprototypingしても、
accessor使っておけば簡単に移行できるし。

evalと大域変数でhashを模倣する初心者を見てニヤニヤするんですよねー

それは君だけ。

やべえ、サボってたらSeasoned Schemerわかんねえw
また後戻りか…英語もやってないし… λ.......

関数型言語を勉強してる人が増えるのは喜ばしいことだけど
初心者が初心者に教えてる姿は危なっかしくて思わず突っ込みたくなる。
話を聞いてると、初心者にはカリー化が珍しいのか興味を示していた。
ただ、もうそろそろこのうざい雰囲気がなくなればいいのにと切に願う。さっさと成長しろ。

初心者は永遠に居なくならない時点でずっとそのままうざい雰囲気のままだと思うが？

先達はあらまほしきことなり

なぜそう邪険に扱う。教え導くのも初学者を脱した人の使命でしょ。

雰囲気の濃度を薄めればいいのだが、溶媒がどんどん蒸発してる。

ドライクリーニングは危ないから誰もやらない。

>>714
成長しろってどのくらいのレベルになればいいんだ？
下のサイトで言うどのレベルよ

Scheme:Schemeプログラマのレベル10
http://practical-scheme.net/wiliki/wiliki.cgi?Scheme%3AScheme%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9E%E3%81%AE%E3%83%AC%E3%83%99%E3%83%AB10

>>716
その通り。邪険にすれば衰退しかありえない。

>>714のように背伸びしたい初心者もかわいらしいじゃないか

自覚している初心者と自覚していない初心者しかいないじゃないか

せっかく勉強になる流れになりつつあったのに元に戻ってしまったかｗｗｗ

いや、正直うざかった

で何の話がしたかったの？

他人の事をうざいと言いたいだけだろ。そういう奴居るよね。

じゃあ漏れが話ふる。
SICPスレでLispからPythonへの移行の話が出てる。
どうして私は信仰を捨てたか、という文章が興味深かった。
こんな話。
↓
自分はApple II時代からのLisperで
Lispで開発してきてほかの言語を使う人に実質負けたことがなかった。
Lispは圧倒的に効率がよいから。
でもなぜかLispユーザーが少ないのはどうしてなんだぜ？
Lisp求人無いのは何故なんだよな？
Googleに入ってみたら特にLispが開発効率良いってものでもなかった。
だからそれまで持っていたLisp信仰を捨てた。
Novicも今はPython使ってる。

捨てた過程はわかったが、直接の原因がさっぱりわからん。

Lisp「だけ」、ってのにそれほど拘る必要性も感じないが。

How I lost my faith - ウヰキエリア
http://web.archive.org/web/20060621010832/www.gembook.jp/tsum/page.pys?wiki=How+I+lost+my+faith

> Lispで財をなしたのはPaul Grahamだけ

Lispを捨てたのは仕方ないとして
PerlにもC#にもなりきれないPythonでは、問題を先送りにしただけじゃないか

lispを知ってると知らないではプログラミングの発想は全然違ってくるよ。
捨てようが捨てまいがそれはどうでもいいけど、その心の影響は消えないからね。
簡単に言えば、手続型ばかりやってると関数ポインタみたいなことに到達するのは
時間がかかるけど、lispはそんなもの最初にやるからね。
map的発想ってのもそうだな。最初に付き合うかどうかって違いが実は大きい。

プログラミングに必要な抽象化の道具が最初からそろってるものと、目先のことを解くだけの
道具だけが最初にないかの違いでもある。
pythonやrubyもlisp的な観点で教えたほうが幅が広いとおもうが、どうもjava屋とかC/C++屋的
な発想でやっちゃうよな。あれははっきりいうけど愚かだと思ってるね。

Cやってないからよくわからないんですが
よく初心者にポインタが難しいって聞きます。
Lispやっていれば将来Cのポインタもすんなり理解できるということですか？

また古いのをもってきたな。その文章書いたErann Gat（今はRon Garretに名前かわってる）は信仰を捨てたんであって、
Lispを捨てたわけじゃないぞ。Pythonも生産的だと認めて使うようになった、というのが正しい。

mapやfoldならhaskellの方が簡単だし
関数型プログラミングとしてしか使わないならlispなんて要らない

Cのポインタが難しいと言われるのは、
「これは難しいよ〜」と言われて紹介されるのが被害を助長させてると思う。

理解して無くてもなんとかなる。

少なくともあわてて複数の人が言い訳しなくてはならないような程度ってことね、Lispって。

Haskellのモナドが難しいと言われるのは、
「これは難しいよ〜」と言われて紹介されるのが被害を助長させてると思う。

理解して無くてもなんとかなる。

emacsが使いたくて、schemeを勉強しているだけだな
昔からある言語なんだし、後発言語はlispの影響を受けているわけで
優位差というものは、ほとんどないでしょ

emacs使いたいならschemeよりもclispだし、clispよりもelispを学ぶべきだろｗ

お前ら変なフラグを立てるなよ
「Pythonで財をなしたのはGoogleだけ」なんてことになったら目も当てられない

いっぽうSunはJavaを開発した

SunがCommon Lispに力を入れないのはどうしてなんだろう。

>>744
力を入れても収益になる見込みが低いからじゃね？
企業なんてそんなもんだ。

Sunは昔、Symbolic Programming Environmentってのを出していた。
LispView(OpenViewのCLOSバインディング)は面白かった。
まあ儲からないものを続けるわけにはいかない。

JavaをもってしてもSunは身売りしなくてはならないわけだし。

lispのコードが出てこなくなると話が弾むな。

お前はそんなレスばっかりだなw

初心者スレに何期待してんだ

(gc) ; ゴミレスをガーベージコレクション

>>751
未実装です。次期バージョンにご期待ください。

pythonの方が便利
マクロを使いこなせれば違うのだろうか

そういうどっちが便利みたいな話はよそでやれよ。

その手の話用っぽいスレもあるしね。

いや ホントに便利なんだって

そうだね、でもここはLispのスレだからPythonはスレ違いなの、ばいばい

宝石の名前の言語だけは使うな
ってばっちゃが言ってた

ほんとどうでもいい話だが花とか植物の名前つけたlisp方言ってないもんかね。

関数型言語学びたいんだけどHaskellとSchemeどっちがいいかな？

>>760
それをこのスレで聞くの？
純粋な関数型言語をやりたいなら、Haskellでもやっとけばいいじゃない。

>>760
無理せず、両方やればよいと思う。
まぁ、>>761のいうように、「これぞ関数型言語」というのがやりたいのならHaskellじゃね？

まずSchemeで型無しλ計算のイメージをつかむのが先決。

>>761-763
お答えありがとうございます。
純粋関数型言語にこだわりはないのでとりあえずScheme触ってみます。

>>763というフリがあったので、質問です
lambdaで下のプログラミングってどうやって書くの？
再帰的には使えないんだよね？

;1からnまでの和を計算する
;とりあえず、n = 50とする
(define (foo x)
(if (= x 1)
1
(+ x (foo (- x 1)))))
; これはなしで
(define (foo x)
(/ (* x (+ x 1)) 2))
(foo 50)

((lambda (f) (f f 50)) (lambda (f x) (if (= x 1) 1 (+ x (f f (- x 1))))))

これをMLやhaskellで定義するとどういう形になる？

あ、多分そのままだと型推論失敗するんだと思うけど
書くとしたらどうなるのかなと

>>766
fが重複していて、なんなのか、よくわからなかったけど
((lambda (like-func-a)
(like-func-a like-func-a 50))
(lambda (like-func-b x)
(if (= x 1)
1
(+ x (like-func-b like-func-b (- x 1))))))
こうすると多少、みやすくなるのかな？
このコードをdefineに置き換えて、できるだけで忠実に書くとどうなるの？

数式処理と数値計算の混合をしたいです
haskellとlispのどっちがお勧めでしょうか

>>770
maximaが何で作られているか調べてみ。 そしたら結論でるよ。
haskellに数式処理の簡単に扱えるライブラリがあればそっちのほうが
数式に馴染みやすい扱いができる。
lispで数値計算をするときは、最適化するために、型宣言のことやプロファイラを
あつかってボトルネックを潰して行っくって作業なしでは難しいかも。型宣言や
最適化の工夫はグレアムおじちゃんのANSI common lispをお勧めしとく。on lisp
じゃないよ。
maximaからlispは直接操作も可能だしあなたがやりたいことは実力さえつければ
可能です。

いちおうね。maximaには数値計算が出来るライブラリは幾つかあるから、
速さは保証しないけどね。lispでかかれたかなり癖のあるコードだがlapack
まで一応ついてる

両方覚えて用途毎に使い分けるのがオススメだ

誰か判りませんか>>766-768

>>774
なんでそんなこと知りたいのか知らんけど、
Haskell にベタ移植するとこんな感じじゃね

(\f -> f f 50)(\f x -> if x==1 then 1 else (x+f f (x-1)))

もちろん型推論には失敗する。

cannot construct the infinite type: a = a -> t -> b

ぐぐったらMLとかだと型推論通すにはこれ相当になるみたいです
(letrec ((y (lambda (f) (lambda(x) ((f (y f)) x)))))
((y (lambda (f) (lambda (x) (if (= x 1) 1 (+ x (f (- x 1))))))) 50))
=>1275

ところで、↑letrecのyは「lambdaで定義する」という問題からしたら
反則な気がしますが、letrecをlambdaだけで定義できるでしょうか？

当然set!を使わず、かつ型推論が通るような形で。
前者はともかく、後者を満たすのは無理っぽいと考えてます

>>777
> letrecをlambdaだけで定義できるでしょうか？

無理。 set! とかも必要。

R5RSで提案されているletrecの実装方法がset!を使っているだけであって
多変数相互再帰はlambdaだけで書けるからletrecもlambdaだけでできる
過去スレにあったと思う。
もっともMLの型推論を通せるかどうかはしりません。
自分が読んだ本には、型付きラムダ計算ではfixという演算子を導入すると書いてあった。

>>776 で定義している y はまさに fix の一種だよ

ですよね・・
昔そのfix云々を見てMLの限界を感じたので
この程度ならLISPに後付けで型推論つけても同じなんだと
引数が面倒ですが

lambdaの使い方の勉強したいだけなんだけど
レベル高い話になり過ぎてますよ
(like-func-a like-func-a 50)と(like-func-b like-func-b (- x 1))がわからないんですけど
(lambda (like-func-a)
(like-func-a like-func-a 50))って何よ？
765の問題をlambdaで再帰的に書くには、こう書くみたいに覚えるしかないの？

再帰する時って再帰したい関数に名前をつけなきゃならない。

f 1 = 1
f x = x+f (x-1)
main = print $ f 50

fix (ここではyオペレータ) があれば define や let 類が無くても再帰できるぜー

y f x = f (y f) x
main = print $ y (\f x -> if x==1 then 1 else x+f (x-1)) 50

というのが fix 。

>>783
λ計算でオブジェクトに名前をつける唯一の方法は、引数にすること。
なので、自分自身を引数にするのです。

>>783
>>766を分解すると
(1) (lambda (f) (f f 50))
(2) (lambda (f x) (if (= x 1) 1 (+ x (f f (- x 1)))))

(1)は引数を1つとる関数で、その引数を「引数を2つ取る関数」
と見なし呼び出す。呼び出す際、引数にそれ自身も渡す。
(1)は一度読んだら役割を終えるので、
(1)の呼び出しは(2)のための初期化に相当する。
(2)は渡された自身を使って再帰ができる。

>>774が失敗する原因は推論順序に関係するらしいので
((lambda (f) (f ((lambda (x) x) f) 50))
(lambda (f x) (if (= x 1) 1 (+ x (f ((lambda (x) x) f) (- x 1))))))
のような形にすれば通るっぽい

>>786
役割を終えるというのと初期化に相当するというのがよくわからない
>>787
> ((lambda (f) (f ((lambda (x) x) f) 50))
> (lambda (f x) (if (= x 1) 1 (+ x (f ((lambda (x) x) f) (- x 1))))))
ちょっとわかりやすくなったかも
複雑になったとも言えるけど

((lambda (x) (+ x x)) 5) => 10 ;理解できる
((lambda (x) x) "ab") => "ab" ;理解できる
(string? ((lambda (x) x) "ab")) => #t ;理解できる
((lambda (x) x) 5) => 5 ;理解できる
(integer? ((lambda (x) x) 5)) => #t ;理解できる
((lambda x x) 5) => (5)
(list? ((lambda x x) 5)) => #t ;理解できる
((lambda x x x x) 5) => (5)
((lambda (x) x x) 5) => 5
((lambda x 2) 5) => 2 ;理解できる
((lambda) 5) => error

みたいにチマチマlambdaについて理解しようとしているんだけど
理解できるようになるのかなｗ

>>785
((lambda (f) (f f)) (lambda (g) (display "called!\n")(g g)))

無限末尾再帰だから評価するには注意が必要だけど、これなら少し分かりやすいかな。

(f f)は、fを引数にしてfを呼び出している。
一番目のfは関数呼び出し、二番目のfはその呼び出しへの引数。

(g g)は、gを引数にしてgを呼び出している。
一番目のgは関数呼び出し、二番目のgはその呼び出しへの引数。


評価してみて、なぜそういう動作をするのか、考えてみて。
(lambda (g) (display "called!\n")(g g)) を無限末尾再帰にするためには、gに何を渡せばよい？


答えは、「(lambda (g) (display "called!\n")(g g)) に、それと同じ (lambda (g) (display "called!\n")(g g)) を渡す」。
単純な答えすぎて騙されているみたいだけど、そうとしか考えられない。

で、その答え「(lambda (g) (display "called!\n")(g g)) に、それと同じ (lambda (g) (display "called!\n")(g g)) を渡す」をやっているのが、(f f)の部分。

>>785じゃねーや、>>783。

>推論順序に関係するらしい

>騙されているみたいだけど、そうとしか考えられない

>>787 がどうしてもちゃんと通るHaskellのコードが見たいってんなら
let fix f = f (fix f)
let arithProgSum n = fix (\f -> \x -> \y -> \z -> if x == y then z else f x (1 + y) (1 + y + z)) n 0 0
と書けば
arithProgSum 3 == 6, arithProgSum 4 == 10, ...

もうスレチはこれで終わりにしようぜ。ヤレヤレ。

よく考えたら
let arithProgSum n = fix (\f -> \x -> \y -> if x == 0 then y else f (x - 1) (x + y)) n 0
でいいね。スマソ

SchemeかCommon Lispか勉強してみたいんですが、どちらから入るのがおすすめでしょうか？
とりあえずC/C++で書いたGUIプログラムの下請けとして呼び出すリスト処理部分に使いたいと考えていますが、将来的にはGUI部分もSchemeあるいはCommon Lispで書いてみたいです。

自分で考えてみた限りでは、
・多言語との相性もある程度よいが、必要なものは全部自分で作らないといけないScheme
・最初から最後まで自己完結するCommon Lisp。他の言語の下請けにはなりにくい。
という印象です。

関数型言語を勉強するのにはSchemeがいいけれど、Common Lispじゃないと色々とめんどくさいのかな、という気がします。
そこで本題なんですが、Schemeをあるていど勉強したあとにCommon Lispへ移行（もしくはその逆）するのは、どの程度のハードルがあるのでしょうか。
（defineをdefunに直せば同じソースコードが通るほどに似ているのか、まったく別物だと思って勉強した方がいいのか、というようなことなのですが・・・）

長文失礼しました。

便乗質問として、schme, lispをやるなら、統合環境は、やっぱりemacsなの？
非emcas使いは、どうするのがいいの？
それでも(最終的には)emacs？

lushというlispでshを書く方法があるみたいなのですが
使ってる人はけっこういるのでしょうか

>>795
理由もわからずに道具を使いだすと信者化するんで
メモ帳で十分とか、まがりなりにも自分の信念を持ってるほうがいいと思う

>>795
「非emacs使い」なのならなぜ最初にvi(m)のlispモードを考えない?

非emacsならviとか
頭おかしい考え方だと思った

>>799
windowsな人ならそう思うかもな。でも、lispをwindowsでするのは
無駄な労力がかかるから、それもあって798はviが浮んだんだろう。
unix系ならばあながちおかしくはない発想なのです。いちおう
vimならばlispの環境はあるからなぁ。

ちなみに非emacs使いという言葉の意味は、反emacs派というわけでもありません
なんら宗教上の理由は、ありませんよｗ
vimを薦めている方は、なにか宗教上の理由を感じるんですが、違いますか？
Linux上ならemacs一択でいいんでしょうかね？
またWindows上(のcygwinなど)でschme(, lisp)を使うのは、適していないんでしょうか？
>>800
いちおう、存在する程度では、困るんですけど

どっちでも良いよ。早く始めちゃえ。

schmeが気になってしょうがない

eclipseでも出来るよ。

eclipseみたいなロートルPC殺しなんて使う気になれないよ

eclispの間違いでしょ？

>>800, 801
胸をはって「使っている」といえるほどではありませんが、Windows + Meadow + mzschemeで、とくに支障ないです（.emacsをちょっと書く必要があるけど）。
Linux + emacs + mzschemeと同じ環境、同じコードで書けるし。

改めて読み返してみると799のほうが過剰反応しているように見えてしまった
いつの間にやら俺も毒されて

>>801
よくしらんけど、vimって宗教がらみ？clispみたいなの？

>>801
schemeだったら、807もかいているように、mzschemeとかあるからなんとかなる。
windows上のemacsはpath表現ではまることがあるから注意が必要。IDEまであるからね。
Dr.schemeさんは。
common lispでもwindowsで動くものはでてはきてるけど、外部のライブラリを使うとき
に困ることがあるかもしれない。
emacsのほうがあとあと楽だと思うけど、グレアムみたいにviつかいで有名なのもいるから
CUIのみでやる場合は選択としておかしくはないかな。screen+zsh+vimという組み合せは
CUIではかなり強力になるから。windowsならばどうだろうね。cygwinでは同じことはでき
そうだが。ほかはeclisp（笑）というlisperのためのIDE(4/1ではないか。をい！)でも
common lispならばcupsというのがありますね。

801
まで読んだ

>>794さんの質問に(部分的にもでも)答えてあげてください

>>801
有名な方でvi使いの方がいらっしゃるんですね
vimとか、ネタかと思っていました

みなさま、レス、ありがとうございます
勉強の方向性として参考にさせていただきます
とりあえず、パッケージにguileがあったので、試しにこれを触ってみます

>>794
common lispで現状の選択ならばclispやsbcl+ltkを使えば良いよ。一番気楽。
schemeほどの美しさはないけど、気に入ったなら良い選択だ。
lisp方言は似てるから、微妙な違いはあっても片方を学んでおけばなんとかなりますよ。:p

俺も vim で書いてるけど、話を何段も飛ばして一足飛びに宗教認定されててﾜﾗﾀ。
vi は宗教と言うより made with secret alian technology なだけだと思うけどな。
Lispnik なら理解出来なくとも価値観を共有出来ると思ってたが、まぁ良いよ。

俺はemacsとvi(vim)を使ってる。
けどそういうのに慣れてない人には、
jEditとか他の選択肢でもいいんじゃね?
シンタックス支援があれば何でもいい。

言語を学ぶのに、いきなり統合環境を聞くのも時代なのかな。
javaでいうEclipseみたいなものは便利だけど、勉強しないと補完されないと完成しないコードを書く癖が付くよ。

まあ使いたい人は使えばいいんじゃないの。

>>816
俺も同じ考えだな
初心者はIDEやデバッガは使わない方がいいと思う

>>794
プラットフォームにもよるんだけどさ
unix系(mac含む）ならemacs+common lisp+slime環境はマジでおすすめ(+HyperSpec)
windowsでならeclipse+CUPSがおすすめ(meadow+commonlispでもいいかもしれんがasdf環境の設置が面倒くさいんだ)


schemeはわからん、slime並に統合された環境ってschemeとペアになってる開発環境に依存しすぎてるら（emacsライクなエディタがscheme自身でかかれてたりする）

最初はviでしこしこかいていたなぁ。年寄ですね。。。

>>819
うんうん。そうおもう。どういですよ。おにぃちゃん。
windowsでというと如何してもcygwinに頼ることもあるかもしれんけど、
あれをやるなら、仮想環境でubuntuでも入れてそこで、emacs + cl +slimeを
やったほうが手間がかからないかな。学習のみじゃなくて、本気でやりたいなら
脱winをおすすめするよ。macならunix系だからwinほど障害がないから問題はない。
どうしてもwinラヴなら、まだ、eclipseにたよったほうがいい。

Macはマイナー言語天国だよね

>>822
いろんな言語が触れるのはunix系の強みだと思う。
まだ、CUIの扱いがunix準拠なら救われるけど、そうじゃない上に弱点だから
windowsではどうしても多様なものがでにくい。その特殊性ゆえに移植が難しい
のが影響してるんだと思うよ。lispだけじゃなくて動的言語の強みが消えやすいし。

>>818
Unixという名の統合環境がないと動かないLisp処理系が結構多いから・・・

practical common lispで説明してるのはslime

>>813,819,821
ありがとうございます！
Mac OS X上でemacs使っているので、slime+sbclでCommon Lispから入ってみようと思います。

それはそうと、Common Lispにも、SchemeのSICPのような「聖典」的なものはあるのでしょうか？
HyperSpecが相当するのでしょうか？

CLtL2とかも

Practical Common LispのサイトでLisp Box落としてくるのが一番手っとり早い。

設定済みmeadowは?

>>826
うん。ちょっとまえの記憶でもうしわけないけど、銭谷版はslimeも付いてるけど、
古いバージョンで、今のsbclやcmucl、clojure clと組みあわせて使ったときに動作が
ちがうかもしれないので、なるべく、本家で配布しているslimeを使ってやってください

>>829
Lispboxも設定済みmeadow学習用なら問題なしよ。asdfを本格的に使う段階になっ
てくる時から試行錯誤の連続になるかもしれない。

Scheme初心者です。このスレで歓迎される模範的初心者になるには
どういう点に注意すればいいのかご教示くだされば幸いです。
よろしくお願いします。

>>826
> Common Lispにも、SchemeのSICPのような「聖典」的なものはあるのでしょうか？
CLtL2とかPAIPあたりがそういう位置づけかな。

>>831

>Individuals and interactions over processes and tools

>Working software over comprehensive documentation

>>826,832
SICP が Scheme にとっての聖典ってのは誤解だよ。
Scheme を使ってプログラミングの考え方を解説してるけど、
言語自体の説明はほとんど無いし、
Scheme の最低限の機能しか使ってない。
Scheme のバイブルはTSPLだと思うなぁ。

cltl2はどこかpdfで配布されていたけど、わすれちゃった。
知ってるひとおらんか？

>>835
.psをttp://www.ps2pdf.com/convert.htmで.pdfにするのはどうですか？
ついでに、ttp://www.daansystems.com/lispide/のzipの中にはCLtL2とHyperSpec
の.chmが入っています。

>>834
Jargon filesに"One of the bibles of the LISP/Scheme world."って書いてあるから、
それをうけてるんじゃないのか。別に「誤解」というほどのものでもないだろう。

>>836
ありがと。 やってみたら作れた。

検索キーワードを思いだしたら見つかった。他にもおもしろいpdfがあるから
お礼にのせておくね。

http://www.lispmachine.net/

The final public draft of the ANSI X3.226-1994の一本にまとまったpdfもあるので一応ご紹介。
http://lispm.dyndns.org/news?ID=NEWS-2009-02-22-1

Erik Naggumのサイトでもps形式のものが公開されてるけど、章ごとにばらばらのファイルなので
いまいち使いにくい。

>>831
割と親切な人も多いから、謙虚に、かつエスパーを要求しなければ、
結構色々教えてくれると思う。

ただ、最終的には、自分で動かないとやってられない言語でもあるので、
そういう覚悟は必要のはず。手厚いサポートとか期待するだけ無駄。

http://uxul.wordpress.com/2009/04/07/a-detailed-preview-of-my-jnr-game-written-in-common-lisp/

>>842
すごい。リアルタイムでうごくゲームだ。

>>744
結局アレグロの独占なんですね

皆さんご教示ありがとうございます。
人工知能関係はまったく勉強したことがないのでPAIPにはちょっと身構えてしまいますが、
839さんや840さんに紹介していただいたサイトには初心者向けの文書もいくつか載っていたので、
複数見比べながら勉強していくことにします。

ガイ・スティールにもサスマンにも見放されたってこと。かな…？

http://elhumidor.blogspot.com/2009/04/clojure-on-google-appengine.html

ヒントをたくさんもらって、いろいろといじくり回して、lambdaについて理解が進んだかもしれない
とりあえず、簡単なものをlambda再帰してみた
;; fibonacii lambda version
((lambda (f) (f f 1 1))
(lambda (g x y)
(if (> x 2147483648)
'()
(cons x (g g y (+ x y))))))
;; fizzbuzz lambda version
(reverse
((lambda (f) (f f 100))
(lambda (g x)
(cond ((= x 0) '())
((= (modulo x 15) 0) (cons "FizzBuzz" (g g (- x 1))))
((= (modulo x 5) 0) (cons "Buzz" (g g (- x 1))))
((= (modulo x 3) 0) (cons "Fizz" (g g (- x 1))))
(else (cons x (g g (- x 1))))))))
でも、>>776の(lambda(x) ((f (y f)) x))は未だに理解できていないが
(lambda (x) x)はxを返すのは、わかるんだけど
(lambda (x) (x))は、何を返すの？

引数のない関数を渡せばそれを引数なしで呼び出した結果を返す
(define f (lambda () (lambda (x) (+ x 1))))
(((lambda (x) (x)) f) 2)

λ式の関数適用ってλx.M Nの形だから
(lambda(x) (x))は、理論的にはラムダ式ではないな
間違ってたらつっこみ希望

>>849
頭が回りませんでした
こう書けばよかったんですね
(define f (lambda () ((lambda (x) (+ x 1)) 2)))
((lambda (x) (x)) f)
; (lambda (x) ((x)))だと、こうして渡すとちゃんと受け取ってくれるのか
(define f (lambda () (lambda () ((lambda (x) (+ x 1)) 2))))
((lambda (x) ((x))) f)

> λ式の関数適用ってλx.M Nの形だから
> (lambda(x) (x))は、理論的にはラムダ式ではないな
抽象度が高くて、わからないっす
λ式の関数適用ってλx.M NのN形のの意味がわかりません
x,M,Nは、何の意味は、なんですか？
xは変数(関数も含む?),M,Nは自然数ですか？w

(lambda (x) (x))の扱い方が理解できたので、満足しました
解説、ありがとうございました

>>849
む、いわれてみれば、不思議だ。
そもそも、(f)という無引数の関数評価自体、ラムダ計算的にはどういうことなんだろう？

たぶん、lisp内の関数適用用一般関数applyを入れて(f)は(λx.apply x)fと考える、よって、(lambda(x) (x))は(λx.(λy.apply y)x)⇒(λy.apply y)みたいに考えるべきなのかな。
教えて、エロイ人。

5という値と5を返す無引数の関数は遅延評価ベースの関数型言語的には同値。
だからthunkとthunkの返す値を同一視する。
正格評価のLispやOCamlだとそうはいかないから
Lispではthunkという概念を導入し、OCamlでは無引数の関数がない。たぶん
あんまり詳しくないんで間違っていたらツッコミ希望。

なんとなく乱暴なような気がするけど具体的に突っ込めない駄目な僕

MIT以外のSick Peeの講義が！

Lispのapplyは
(apply 関数 リスト)
引数が０個なら、空リストに関数を適用する。
(apply 関数 '())
つまり長さが０だろうが何だろうがリストが１個必要なことには変わりない。

一方、λ計算の関数適用にも引数が１個必要だがそれはリストでなくても良い。

無引数の関数なんてものはありません。

関数的には
・デフォルトでは簡約されない
・しかし一度簡約すると決めたら簡約できなくなるまで簡約するぞ
なんで
無引数の関数みたいに「一段階だけ簡約します」みたいなものがないってことかな
というか「簡約の段階」ってのは実装上の問題であって
言語内に持ち合わせていないってほうが近いのかな

ああ、そうか。849は撤回
(f)という表記を
λx.M Nに当てはめるとλx.f ()と考えれば良いわけだ
car/cdr/cons自体はλ式で表現出来るから
()に当たるλ式を適当に一つ決めれば
(lambda (x) (x))は
(lambda (x) (x '()のλ式表現'))とすればよいね

>>850
M,Nもλ式。自然数もλ式で表現する
ラムダ計算でググったらwikiに3行で定義がかいてある

訂正　λx.f () -> λf.f ()

ラクダ計算かぁ。

やばい、おもしろくなってきた

関数適用って(M N)じゃないのかなぁ ;; M N
(λx. M N)は(M N)のλ抽象でしょう
それとカリー化λ計算は全ての関数は一つの引数を受け取るという前提だから
(x) ≡ xであって(x ())では無いと思う

lispは言語の仕様上たまたま0引数の関数定義も許すというだけだからね
副作用も扱うから1以上に強制する意味もないだろうし
何の基盤もないのに無理矢理当てはめようとしてもうまくいかない

(equal? (list) list)
#f
(equal? (+) +)
#f

結局、理論的なものを触るのにlispは向いてないってことですね

Lisp式は拡張されたλ計算とでもいうものであって
Lisp式で直接純粋λ計算を扱うのには向いてないだけ
リストを扱うのは得意だからλ式の簡約の実装には向いているはず
(S式でλ式を表現するのは容易だし）

>>862
(x) ≡ (apply x '())

零の発見みたいだな
nilもそうだが、applyの発見もおもしろい

逆だった
純粋λ計算がLispの式を表現するのに向いてない、かな

かっこを省略したりしなかったりするあれのことを言ってるのか？
確かにあれは構文木というものを教えるのに向いてない気がする

単純に無引数の関数と言う概念がλ計算やHaskell（とたぶんML）にはないから
構文木そのものをλ項として表現しないといけない。
構文木を受け取り、一段階だけ簡約した構文木を返す関数の連鎖みたいなメンドイことになりそう。
そこまでいくとForthを
「全てのワードは１つのスタックを受け取り１つのスタックを返す関数である参照透明な言語」とみなすくらいの労力がいるんじゃなかろうか。

λ式の評価器はLisp系でも関数型系でも、
単純なものは簡単に書けるけど、
(もちろんProlog系や、Perl系のスクリプト言語でも)
プリティプリントの実装と、
使う評価方式の仕様策定が意外と面倒だし、
場合によっては複数の評価方式を実装しないと、
簡約具合をいろいろ試すのに実用的にならない。

過度に一般化されたλ計算を学ぶ前に、
Schemeの最小のサブセット的なλ計算もどきをやるのがよさげだな。
そうすれば、Haskellにはうんぬんとか余計なことを考えなくて済む。

>>872
> Schemeの最小のサブセット的なλ計算もどきをやるのがよさげだな。
具体的になんのことを指しているの？

>>873
defineやletrecやset!を封印したScheme

、、Little Schemer？

♪見知らぬ国のtripper

>>873
Yコンビネータなくても再帰定義できるλ式もどきじゃないのかな。
Call by valueの評価器作るのはわりと簡単なんだけど、
それじゃYコンビネータは扱えないし。

λf.(λx.f(λz.xxz))(λx.f(λz.xxz))

>>877
おいおい、一段階だけ簡約、、の話はもう終わりか

お、チューリングさんのほうのやつだね

λ計算は少しかじった程度なのですが、
Yコンビネータなしの再帰ってどんな表現になるのですか？

Y のかわりに λf.(λx.f (x x)) (λx.f (x x)) を使えばおk

それってYそのものじゃない？

Y コンビネータは Y f = f (Y f) というコンビネータ

>>884は>>882にYという名前をつければいい、というわけにはいかないの？

>>881
自分を参照するには自分を引数にする
という簡単なロジックですよ
Yはその応用例のひとつにすぎない

猥コンビネータ

ロジック トリック

試行錯誤で弄ってたら
(define theta
(let ((x (lambda (x) (lambda (y) (y (lambda (arg) (((x x) y) arg))))) ))
(x x)))
こうなったんだけど

なーんかλを使った表記と綺麗に対応が取れてないように思える
(lambda (arg) ...て部分は一体どこから来るの？