関数型言語

Lisp Scheme ML Haskell FP Mirranda など
関数型言語について話し合いましょう

関数型言語の定義って何ですか？

>2
関数の組合せによって形成していく言語
変数への代入が無い。
でもLISPやSchemeなどでは見かけ上、ローカル変数が使えます。

ここに関数型言語の説明がある
ttp://www.icsd2.tj.chiba-u.ac.jp/oldmember/shimoda/node1.html

Haskellに期待age

状態を持つ Schemeや Lispなんて関数型じゃねえ、っていいたいんだね?
Ocamlも論外。

>6 俺はschemeやML系の副作用のあるものも、関数型言語として認めるよ。
基本的にプログラムって状態を変化させるものでしょ。Haskellみたいに
purityを保ちながら、今っぽいGUIとかネットワークのプログラムを書く
のは少しこじつけが必要になってくる。

でも、Haskell大好きよ。GHC-5.0リリース万歳!

関数型言語だと並列化が容易って聞きますが本当ですか？

HaskellはSchemeのような美しさに欠けますが、現実的な機能
を盛り込んでいて、大規模な開発にも使えそうだと思っている
のですが、実際にはどうなんでしょうか。Haskellで大きなプロ
グラムを組んだことがある人、意外な欠点などがあったら教えて
ください。

関数型言語でRDB読み書きってできるの？
まあ、やりゃぁできんだろけど、向いてる?

RDB読み書きに向き不向きなんてあるんですか？>10

代入がないってのは、もしかして状態がないんでしょうか？
状態のかたまりであるOOPばっかりやってきたもんで、
ものすごくカルチャーショックです。
どういう風になってるんだろう？？？

set!

いや、関数の引数に対しての代入はある。
なので状態は作れる。

ループも再帰で作る。

手続き型であるC言語でglobal, static使わないと
関数型プログラミングになるってこと？
単に手続き型を制限しただけ？

いまいち利点がわからないな

>>16
俺もよくわかってないけど
君の言ってる事はなんか違うと思う。

つか、いっぺん触ってみれ。
したら利点がわかるよ。

>>16

純粋に関数型な部分については、引数と関数が定まると、出力(戻り値)が
定まるので、たとえば遅延評価(webで牽いてね)なんかができる。
そうして遅延評価をベースにして、ほかの言語ではコルーチンを使う
ような処理が、ごく自然なアルゴリズムとして記述できるようになったりする。

あそこらへんってアルゴリズムなのか? って気もするけどな。
無限リストをかえす関数なんてのは、それだけじゃ停止性も
ないわけだし。
まあ、制御構造を書かなくていいので、自然に記述できる(こともある)
ってのがうりだね。
&& の shortcutが言語のすべてに行き渡ったような。

スレ伸びないね。とりあえずage

型推論萌えage

やっぱりlambdaは基本でしょうか。
インターナルイテレーターが自然に書けるのも利点？

>>14
うう。そういや「リスト遊び」も読んだんだっけか。
でも表面的なことはさとえき
やっぱり関数型言語のキモって奴は全然判れなかった(T_T)

>関数の引数に対しての代入

うーむ。わからぬー(T_T)

状態の純粋な器としての変数、が無いということでしょうか？
＃だとすると、状態の安息地を求めてOOPに至った俺としては、ちょっと…

関数型言語は順次処理とかをするためのものじゃないから
状態とかはあまり関係ない話なんでは？

>12 純粋な関数型言語(Haskell等)には代入がない。つまり状態はありません。
ではどうしているかというと、mainルーチンを現在の計算機の状態をうけとり
新しい計算機の状態を返す関数だと考えることで回避しています。

>23 正解です。

>24 でも、現実のプログラムでは状態を扱うと考えた方が自然な問題もあると思う。

関数型の肝がわかる入門書ねえ...
R.バード、P.ワドラー共著、武市正人訳「関数プログラミング」
か?
http://www.sampou.org/haskell/ にある易しい Haskell入門はどうかな。

>26
日本語でおねがいします

>>25
ココでいうのもなんなんですが、
ガッコで習った算数/数学でピンとこなくて
一方プログラミング(といっても手続き系言語ばかり)で
ピンと来たのが、「状態」の有無なんですよね…。

ところでさらに。自分も使ったことがあるわけじゃない
んですが(笑)、もしかして関数型言語って
アナログコンピュータに似ていますか？
アナログだとデジタルと違って状態の記憶はプリミティブにやれないし、
たしか微分とか発振とかの演算をする部品を
FunctionGeneratorとか呼ぶんでしたよね。
で、あるFunctionの出力を別のFunctionに(配線で)突っ込むことで
計算を行うわけで。似てませんか？

Haskellの日本語な頁はどっかで見たような記憶が。
全然判らなかったのは相変わらずですが(T_T)。
検索したら出てくるんじゃないかなあ。
＃最近はGoogleかな…

そろそろ具体的な例でも出してみようや。
誰かなんか関数型言語で解く問題きぼんぬ。

>>29
関数型言語ならでは、ってやつですか？
自分はちょっと思いつかないです。
とりあえず違う切り口で。

・平均値を求める関数
(average 1 2 3 4 5)
=> 3

(define (average . l)
　[define list-plus
　　(lambda (y l)
　　　(if (null? l) y
　　　　(list-plus (+ y (car l)) (cdr l)]
　([lambda (x) (if (zero? x) 0 (/ x (length l)]
　　(list-plus 0 l)))
Schemeですが、ローカル変数は使ってないです。
このコードは関数型言語に乗っ取った記述と言えるでしょうか？

こういう書き方もあります。(本質的に同じですが)
(define (average2 . l)
　(let loop ;named let
　　((y 0) (c 0) (z l)) ;仮引数
　　(if (null? z)
　　　[if (zero? y) 0 (/ y c)]
　　　　(loop (+ y (car z)) (+ c 1) (cdr z))]

>>30のaverageをlengthを使わないで記述するとこうなります。
(define (average3 . l)
　[define list-plus
　　(lambda (y c l)
　　　(if (null? l) (list y c) ;リストを返す(合計 個数)
　　　　(list-plus (+ y (car l)) (+ c 1) (cdr l)]
　([lambda (x) (if (zero? (car x)) 0 (/ (car x) (cadr x)]
　　(list-plus 0 0 l)))
無理矢理っぽいかな
Cでも書けるし。しかも短くなるじゃん(鬱
int average_rec(int var, int len, int *list) {
　　if (!len)
　　　　return var;
　　return average_rec(var + *list, len - 1, list + 1);
}
int average(int *list int len) {
　　return average_rec(0, len, list) / len;
}

こっちでした
int average(int *list int len) {
　　if (!len) return 0;
　　return average_rec(0, len, list) / len;
}

(define (average . l)
　(/ (apply + l) (length l)))
反則？

Cならreturn文だけでも書けますね。
int average_rec(int var, int len, int *list) {
　　return (!len) ? var : average_rec(var + *list, len - 1, list + 1);
}
int average(int *list int len) {
　　return (!len) ? 0 : average_rec(0, len, list) / len;
}
・・何が言いたかったのか判らなくなってきた。もう寝ます。

関数型言語って無理矢理副作用が無い理由を作ってるけど、
あまり意味無いよね。
副作用の例外を認めてもいいんじゃないかな。

>>34
あああそういう方法があったんですか。
applyあんまり使った事ないんで。(汗
(+ 1 2 3 ...)って風に書けるのはlisp/scheme独特の利点ですね

(defun average (l)
　　(/ (apply '+ l) (length l)))

(average '(1 2 3 4))
=>5/2

>>12
逆にOOPはすべてが「振る舞う」ものとして考えることも出来るようだよ。
Behaviorismというらしい。

>>36 副作用をなくす利点って、遅延評価ができるようになること以外
のメリットはなんなのかなぁ−。わかるひと教えて。

あと、OcamlやSML,Schemeとかは副作用を認めてるよね。
ホントに副作用がないようにしてるのはHaskellとCleanだけ。

全てを関数としてみるのも不自然だし、全てを手続きとしてみるのも
不自然だと思う。

でも, Haskellまんせ−

>>39
つーか、振舞うだけなら他の言語形態でもたいてい
(語弊?)出来るんで、それはまたちょっと傍論かと。

OOPの味噌は細胞膜を作ったことでしょう。
ソレの内部と外部を規定するという。

どうなんでしょう？
関数って、それ自体には内も外もないんじゃないでしょうか？

ところでLispってListProcessorでしたよね。
List自体は変数と大差無いものであるように
思えたんですが、それでも関数型というのでしょうか？

>41 関数の外と内という表現はよく分からんが、スコープはある。
あと、Haskellなんかはグローバルな(手続き型言語のような)変数
はない。

Listは変数とも見れるが、Lisperは基本的には破壊的代入をあまり
しないでプログラムを書くので関数型とも見れる。

話はずれますが、
MLでは型推論という方法でgc起動回数を抑えてるらしいんですが、
LISP/Schemeで、その型推論は可能でしょうか。
appendやreverseなんかで大量にセル消費するけど、
gcに(あまり)頼らずにセルを還元する様なアルゴリズムにならないかな。

>43 型推論でGCを回避？なんじゃそりは？初耳です。

Lisp, Schemeには型がないので型推論はできません。

>>43
よくわからんが（君の言ってることのせいじゃなく俺が馬鹿だからね）
MLの型推論は処理系がコンパイル時にって話で
LISP/Schemeじゃ無理なんじゃないでしょか。

やっぱり型無いと無理ですか。
地道に関数の呼出し時にプロファイリングして不要になるセルを
チェックしていけば還元は結構できるかもしれないですね。

>Lisp, Schemeには型がない
初耳だな。

それは例の「形なし言語逝ってよし」のスレでの
変数の型と値の型の話かい？

ここでは変数の型についていっているよん。

引数の型チェックが無い

という言いかたが正しいかな？

「LISP Scheme」と「関数型言語」のスレの住人は同じに違いないのにスレだけが別れていてキモイなあ。

俺はこっちしかかきこんでないぞ！
でも、しょぼ関数型プログラマよりグレートなlisper
の方が多そうなのでいろいろ聞きたいです。

>>43 Region Based Memory Managementのことかしらん?
http://www.itu.dk/research/mlkit/kit2/readme.html
型推論じゃなくて effect inferenceとかいったような...
萌える理論である事はたしか。

>>51
厨房Lisp信者発見。

別にいいじゃないかage>50

>Lisp, Schemeには型がない
これは曖昧な表現だと思います。
「変数にはどんな型のデータも入る」の方が良いかと。
つまりデータについての型は存在します。
(a . b) =>pair型(dot対)
(a) =>list型 (=> (a . '()))
a=>symbol型
#\a=>character型
"a"=>string型
#(〜)=>vector型
#t #f =>boolean型
(lambda ()〜)=>closure型
(call/cc 〜)=>継続型
など
変数として使えるのはsymbol型とpair,list型だけですが。

そういうのも昔は型がないといったもんだが...まあ弱い型って
いうのが最近の呼び方かな。

>>56
もしかして昔は、データ(今風にいえばObject)に
(実行時)型情報も持たせるのは、コスト的に重いんで
メジャーな戦略ではなかった、のでしょうか？

つーても、卑近な意味でのジツヨー言語のことだけ考えても
この場合ショウガナイだろうしなあ。

>>55
>変数として使えるのはsymbol型とpair,list型だけですが。
vector型も追加だ(ﾟДﾟ)

いやー、Lisp1.5のころ (Fortranと同じぐらい) からだから、
そうともいえないだろうが >>57
そのころの Lispは、汎用言語とは考えられてなかったかも知れぬが。
型なし言語(BCPLとか?) はそもそも「型なし」と形容する必要さえ
認識されてなかった、というのが俺の邪推。

>>58 変数として使える、って意味はなんだ??
55にあがってるのはみんな一級の値(First class value)だから
代入とかはできるはずだが。
後 number型がないな >>55

defineとか〜set!ができるって意味です>>60
number型だったら
(define 1 'a)
とかできないでしょ？

>>40
OCamlとかSMLは副作用を認めてると言うより（多少は認めてるけど）
型推論を可能にしつつreferenceを表せるような
強力な型理論を頑張って作ったんだよね。
だからwhileループなんかが関数型の枠組みのなかで表現できる。

>>61 vector型を変数として使えるのか?
(define #(a) 1) なんてできないよな?
(define (a b) ...) だって
(define a (lambda (b) ...)) のsyntactic sugarに過ぎないし。
∴変数として使えるのは symbolにきまっとる。

あの〜、
vector-set!とか忘れてません？
(define vec (vector 'a 'b)) ;=> vec
(vector-set! vec 0 'c) ;=> #(c b)
vec
=> #(c b)

listも
(define lis (list 'a 'b)) ;=> lis
(set-car! lis 'c) ;=> (c b)
lis
=>(c b)

あ、defineができないって意味ですか。
失礼しました。

defineは「何かを」人間が判りやすいように、
「名前で参照」可能にするための物で、
変数としても見れるけど、意味が少し異なる。

あ、>67
変数→入れ物のまちがい。
変数って用語は「名前」を前提にしないと意味不明なので。
よってsymbolは変数、
list/vector/pairなどは入れ物。
って解釈で良い？

または無名変数とか。>入れ物

てことは、
(lambda〜
(let〜
なんかも入れ物の内に入るのか。
(lambda〜) ;=>closueの入れ物
(let〜) ;=>環境の入れ物

ということは、
(define s
　(let ((x 300))
　　(lambda (param)
　　　(list-ref (current-environment) param))))
とした時、
(s 0)
=> ((param . 0))
(s 1)
=> ((x . 300))
が返るわけだ。

(set-cdr! (car (s 1)) 100)
(s 1)
=> ((x . 100))
だんだんわかってきました。

>>71-72 を応用すればローカルスコープの変数を増やしたりもできる。

結論：Schemeは自由度がかなり高い。
なんであんまり普及しないんだろう？
・・括弧だらけだからか。

頭のなかをリカーシブにしなくちゃいけないから。
リスト構造の物を扱うときは、Cでもリカーシブで
プログラムつくるけど、そうすると引き継いだやつから
こんなプログラム書いていいんですか、といわれる。
理解できないだって。

>>68 mutable data typeじゃダメか?
変数はどうやっても defineで定義するか lambdaで導入するもの。

>>74 本来、再帰のほうが自然な構造だと思うけどな。
数学でも再帰のほうがよく使われるし。
Fortranからの悪しき伝統だと思いたい。
#でもやぱり末尾再帰できる形にコードを変換するのは
#面倒だったり

>>74 >>76

再帰を難しいと思って(思い込んで)いるかどうか？が、
そいつの頭悪い度＆プログラマ不向き度(笑)を計る
1つのバロメータだと思われ。

でも
>#でもやぱり末尾再帰できる形にコードを変換するのは

なんかそんなことをわざわざする(しないとならない)
ってのは本末転倒だなとも思う。

再帰は慣れだと思うけど。
末尾再帰はテンプレートとして覚えれば良いと思う。
↓は末尾再帰
末尾再帰でスタックフレームを生成しない処理系ならばwhile(rest)と同じ。
func(rest) {
return (rest) func(rest - 1) : rest; }
こっちは普通の再帰。+restのせいでスタックフレームが生成される。
func(rest) {
return (rest) func(rest - 1) + rest : rest; }

再帰を普通のループに直す方法で参考になるサイトありませんか？

副作用について教えてください。
代入は副作用だそうですが、なぜ関数型言語での代入に相当するような
動作は副作用ではないとされているのですか？

>関数型言語での代入に相当するような動作
どの事いってるの？
もうちょっと具体的に。

>>81
例えば、a=1;という文があったとき、これはどう見ても代入に
しか見えないのですが、なぜこれは関数型言語では副作用では
ないのですか？
常に新しい変数を作るからという解説は良く見かけますが、
それだとなぜ副作用にならないんですか?

あげ。
どの言語ですか？>82

>>83
だから代入の無い関数型言語だろ。

>>82
代入じゃなくって定義だと思えば？

時間軸に沿って見た場合、aの値がずっと同じなら定義。で、変化するなら
代入。って感じかな。Pascalの = と := の違いを思い出す。
ああ、スコープが別な aはもちろん別物として扱ってな。

っていうか、時間軸なんかなくて、本来すべて静的な定義として書くのが
関数型言語の理想。数学にも時間軸はないように。
でも対話的処理とか時間がからむものを書こうとすると
monadとかいって苦労するんだな、これが..

>>86
ふーん。
ってことは、UMLでいう状態図とシーケンス図は
最も遠い存在ってことか…。

うーん。「数学に時間軸がない」こと自体が既に
(数学を)嫌なんで、やっぱりパスかな俺にとっては。

＃でも、ほんとうに数学に時間軸無いの？
＃時間軸ある数学だって当然だが構築可能だよね？だよね？

>>85-86
そういう違いはわかるんだけど、だったら、
なんで定義の方は副作用じゃないんですか？
環境に新しい物を加えるのだから副作用じゃない
のですか？

object的 identityはない世界だからねえ。
まあ、それがゆえに実世界の問題のモデリングは面倒じゃ、
とは思えなくもない。

数学 (つーか論理学) にも時間が入ったのはあって、
様相論理ってのはその一つだな。◇や□が出てくる。
monadと様相論理が関係あったかどうかは忘れた。
monadと線形論理をからめた論文は見た気がするがな。
見ただけで読んでない。

「加えた」のではなくて「定義が記述されている」といえば？

>>90
状況によっては、動的に変数が増えていくことになりますよね？
だから、静的なあらかじめ記述された定義とは根本的に違うような
気がするんです。

定義にしろなんにしろ、動的にオブジェクトが増えていく場合、これを
副作用と言わないのはなぜでしょうか？
環境は変化していると思いますし、値を返す以上のことを行っている
ように思えます。

よくわかりませんが、
Scheme流に言えば、「定義」を「破壊」した時点で、
それはもはや「定義」とは見なせないとは思います。
(define a 1) => aは1、という定義。
(set! a 2) => aは1、という定義を破壊(消滅)し、
新たにaは2、という定義を作る。
=>これが変数。
const-defineなんて構文があったら都合がいいのかな？

>>89
実世界のモデリングという言い方にはいつも
ひっかかりを覚えるんだけど(^^;、
OOの立場(?)から言えば、
イデアだってメタクラスのインスタンス
でしかないんだよね。
形而上だからってOOのモデルで扱えない
って言いきることは無理なんで、まぁ…

>>80
>>82
62に書いたことが理論的には答えなんだけど，
論文が見つかったのでもう少し詳しく説明してみるね．

MLでのx=1というのは，既に存在する環境
（変数名と値の対の集まり）を明示するコマンドであり，
式を評価するときに自由変数xの値を使えるように明示すると思えばいい．
これを変えるような操作を代入というわけだけど，
これは時間軸にそって環境が変化することを意味するから
状態を持つことになるので関数型では許されない．

でもやっぱり代入に相当することは欲しいので状態の変化を何とかして表したい．
そこでどうするかというと，ポインタのようなもので
それは単なる値を指しているのではなく
次の状態の環境込みのもの（クロージャ）を指していると考える．
すると，そのクロージャの中の環境にその変数名がまた現れている可能性があるので
ここでぐるぐる回る自己参照のような問題が起こる．
よって，こういうデータを扱えるようにMLの型システムを拡張してやれば
見かけ上代入可能な変数が使えることになる．

これの理論的な意味付けを行った論文が

R. Milner（MLを作った人ね） and M. Tofte
Co-induction in relational semantics
Theoretical Computer Science 87 (1991) 209--200.

であり，例えばOCamlではmutableな変数とimmutableな変数は
理論的には違うものなのでわざわざ区別しているし，
SMLでも代入に見える:=（だっけ？最近書いてないもんで）が
関数型の枠組みで正当化できる．

こういう変数があれば手続き型言語での
ループのカウンタ（ループを回る度に状態が変化する）に使えるので、
そういったループが関数型の枠組みで自然にかけるようになる．
こんなとこかな？

>>87
時間がない、というのは要するにコンパイル時の静的な（つまり実行する前の）
プログラム解析（型チェックとか型推論とか）に意味を見いだしているから。
時間が入っているような動作も、95のようになんとかして
静的な解析が可能なように理論づけをしようとするわけ。

だから元々実行時のチェックが本質的な応用とはあまり相性がよくない。
それでも継続とかmonadとか使って頑張るわけだが、各monadの定義は
理論上メタレベルで行われる（論理で様相を自分で定義するようなもの）
のでまあ一種の反則ともいえる。

Schemeの話です。
破壊的代入も環境モデルを使えば素直に理解できると思うが。

>>97
80-84は副作用のない純粋な関数型言語の話だと思ったけど、違った？
MLは例に過ぎなくて、代入らしきことを副作用のない関数型の枠組みに
どのように取り込むかという話だと思って頂ければ幸いなり。

>>95
ちょこっと修正．

> こういうデータを扱えるように

こういうモデルで意味が与えられるように

> Theoretical Computer Science 87 (1991) 209--200.

209--220

> SMLでも代入に見える:=（だっけ？最近書いてないもんで）が
> 関数型の枠組みで正当化できる．

SMLでは参照型を導入してそれを:=の左に持ってくることにより実現している．
真面目に調べたい物好きな人向けには

Mads Tofte
Type Inference for Polymorphic References
Information and Computation 89 (1990) 1--34.

に具体的な型システムが載っているので参考までに．

>>88
プログラムの静的な解析が可能ということから
使用する値は最初からどこかの領域に格納されていると考えることができます．
終了しないプログラムもあるので領域は無限にあることもあります．
val x = 1;などで1が格納されたある領域がxという名前で
アクセスできるようになりますが，
その領域は作られたのではなく以前からあったと考えるわけです．
val x = 2;とすると別の場所にある2というデータを
xという名前でアクセスするということになります．
これは以前のxと領域を共有していないので
必要ならば適切に変数の変換をしてやることにより
以前のxとは別の名前と考えることができることが保証されています．
よって本質的には代入ではないわけです．

本質的には代入じゃないけど、実装は変数とあんま変わらないんだよなあ。
へ理屈というか、考え方が違うって事なんだろうけど。
とりあえずage

切り番おめあげ

>>100
そうですね，上の話でも現実には領域は有限だから，
実装では使わなくなった領域をせっせとGCで集めて再利用しています．
このように実装は理論の与える直観そのものでなくても
それと矛盾してなければよいわけですが，一方で良い実装が可能であることは
理論を考えるときでも重要なポイントになります．

あとユーザが理論をそれほどよく知らなくても使えることも重要です
（call/ccなんかはその点でちょっと苦しい）．
ですからOCamlやMLの動作をユーザが代入による副作用と理解することが
おかしいと主張しているわけではありません．
ML系の場合，型推論という旨味も失いたくないので
副作用でない新たな理屈付けが必要だったわけですが，
それをユーザの方には参照型とかmutable/immutable（可変/不変）という
比較的理解しやすいと思われる見かけで提示しているわけです．

連休も終わったしそろそろこの話もおしまいかな．

>>102
代入を許すと型推論が出来なくなるのか？

>>62 MLみたいな副作用がある片端関数型言語を
正統的理論みたいに宣伝するなゴルァ!
強い型付けと代入の有無は本来直交した概念。
弱い型で代入がない純粋関数型言語ってのもありうるだろう。

まあ、実際代入があると型推論あたりで面倒なことが
起こった気はするがね。それの解決法が [62]だったような。
変数定義時よりも一般的な型が代入される可能性もあるわけだし。

>> 103
単に代入だけならいくらでも意味は付くけど，
静的で複雑な型が絡むと色々難しいねえ．
MLの型理論の場合は高階型や多相型などの豊かな型と
停止する型推論などの便利さが巧妙にバランスしているので，
なんとかそこから大きく外れずに解決したいというとこかな．

>> 104
おう、好きな言語をどんどん語ってくれぃ．
MLは適度にいい加減で汚いところがいいっす．
SML/NJは好きじゃないけど．

> 弱い型で代入がない純粋関数型言語ってのもありうるだろう。

もちろんっす．その場合も99後半の考え方は使える．
でもそういう言語はドメイン理論を使う方が説明しやすいな．
話の都合上，代入の話と型付きの話が混じってしまったのはスマソ．

さあ仕事仕事。

>>104
純粋な関数型言語と言っても代入を屁理屈で代入じゃないと
強弁してるだけじゃないの？
型推論のしやすさ等で実質的違いは無いと思うけど。

ってか、もうちょっと簡単な日本語しゃべりやがれ。
さっぱりわからん（鬱

>>95
型システムを改良することでどうして代入が扱えるようになるんでしょうか？
さっぱりわかりません。
>Co-induction in relational semantics
この論文はネット上では公開されていないですね。
大学で探してみることにします。

>>99
でもxという名前と値のつながりを変更したことになりますよね？
名前と値のつながりは環境ではないのでしょうか？

関数型言語の originalである、Backusの FPにはそもそも
変数がないぞ!!
αとか意味不明の記号が出てきてわけわかだけどな。
こっから辿れば、関数型言語における変数なんて、sytactic sugarに
すぎないと思えるもの。

>>109
syntax sugarのことか？
ま、へ理屈だろ。

>>108
>でもxという名前と値のつながりを変更したことになりますよね？
変更じゃなくて、定義のスコープが変化して見掛け上、
上書きされたということでは？
（ちょっと違うかもしれないけど、考え方として）
静的なschemeのプログラムの継続をlambdaで表現すると
こんな感じになると思います。
ちなみにschemeの継続はプログラムが終るまで無限に続きます。
(lambda (x1 x)
　　　　　 ...
　(lambda (x2 y)
　　　　　 ...
　　(lambda (x3 z x)
　　　　　 ...
　　　　　　(lambda (xn) )))....)
で、x1x2x3の地点でそれぞれのxの定義は内部のlambdaによって
隠す事ができる。例えばx3のxとx1のxは同じ値を持ってる必要は
無いと。わかりにくいかな？

ついでに、schemeの継続はプログラム終了まで無限に作られるが、
継続がどこからも参照されてないと証明できればその継続はgc時に
回収される。
(define x 'a)
...
(define x ())
の継続の変化を図にすると、

継続→
**************************************//****|プログラム終端
　　　↑x=a ↑x=()

xは次回のgcで回収が見込める部分
*********xxxxxxxxxxxxxx**************//****|プログラム終端
　　　↑x=a ↑x=()

>>111
正解

ああ、ずれた・・
正しくは↑x=a から↑x=() の間がxxxx..です。

>>111-112
これ、すごくわかりやすい。
関数型言語のイメージが掴めた様な気がします。ありがとう。

まだ型推論の意味が謎ですが。

>>111
新しいxを生成するのは副作用でない？

新しいx＝仮引数パラメータだから副作用とは言いません。>116

111さんが継続を使って色々説明をしてくださっていますが，
私の書いていたことに関連する日本語での記述がありました．

コンピュータサイエンス入門 --- アルゴリズムとプログラミング言語
大堀淳，ジャック・ガリグ，西村進 著
岩波書店

の14章で，ラムダ計算の操作的意味論として，
コンビネータへのコンパイル，自然意味論，
SECDマシンへのコンパイル，の三つが簡潔に紹介されています．
このうちの前二者が上で話したことと関係しています．

コンビネータ論理というのは，コンビネータと呼ばれる定数項と
その組み合わせの変形規則からなる体系で，変数は現れません．
>>109で紹介されていたBackusのFPはその一種と考えることができます．
コンビネータ論理では変数がないので
その変形を計算と考えると副作用というものも当然ありません．
そして実はコンビネータとラムダ項は
S → λx.λy.λz.(xz)(yz)
K → λx.λy.x
λx.x → SKK
といった具合いにお互いに翻訳が可能です．
>>99 で述べた変数を隠してしまう変換の極端な場合が
ラムダ項からコンビネータへのコンパイルだと思って頂いても構いません．

一方，Milner-Tofteの論文でrelational semanticsと
呼んでいた意味論がここで言う自然意味論です．
>>95 の説明でも触れたようにここでは式に対応する値に環境をくっつけます．
（これは副作用を導入すると言うより環境を値の一部と考えることに近い）．
当然ながらクロージャの意味などは自然に付けることができます．

これらはどれもラムダ計算に対する操作的意味論であり，
同じ計算結果を与えますが，見方の違いにより
ラムダ計算を純粋な関数型の変形と見ることもできるし，
環境を取り込んだものと見ることもできるということです．

同じ言語に対する異なる屁理屈なわけですね．

そしてさらに上記のテキストには書いてありませんが，
>>95 で説明したように，Milner-TofteおよびTofteの論文の手法により
自然意味論を使って参照型に意味を与えることができます．
ただしこのとき環境に循環が発生してしまう可能性があり，
ある種の無限対象として必要がでてくるので，
これを最大不動点として意味を考えて余帰納法（coinduction）で
推論することにより解決しています．
（最大不動点と余帰納法は，無限プロセスなどの無限対象の
厳密な意味と同値性を与えるときによく使われる手法です．
無限のものは全部比較して同値判定するわけにはいかないから
普通の帰納法は使えない）．

こう書くと多少はすっきりするかなあ。

>>118 訂正。

> >>99 で述べた変数を隠してしまう変換の極端な場合が
>>99 で述べた代入を隠してしまう変換の極端な場合が

> ある種の無限対象として必要がでてくるので，
ある種の無限対象として扱う必要がでてくるので，

>>115
型推論
val y = x+1;
+は両辺同じ型でなくてはなら無いのでxは整数型。
よってyも整数型と推論できる。
だから yの型を宣言する必要が無い。
fun z(x) = x;
とすると、xがどの型でも取りうると推論できるから、
関数z(x)は特定の型に捕らわれない関数宣言になる。
fun z(x:int) = x;
とすると、xはint型しか取らないようにできる。
このようにして、状況に応じて、型の限定を利用するのか
型無し言語のような柔軟性を持たせるのか、切り替える
ことができる。

C言語も見方を変えるだけで、代入の無い言語に出来ます。(藁

「新しい x とその値の対応を生成するのは副作用ではない？」
という問いは、実はλ式とはなにか、置き換えとは何か、変数
(仮引数)とはなにか、という本質的問いにつながる大きな質問
なのですが、実際にはそこまで行かずとも通常の言語における
副作用は排除できているので問題なし、という捕らえ方でよい
んだよね？＞学術系の人

(変数などの)項書き換え規則の「意味」や「解釈」をさらに後ろから
支える論理体系って、何かあるのだろうか。

いや、バックにくっついている理論によって副作用になったり
ならなかったりするだけで、本当は違いが無いってことだろ？
何が違うのさ？

そりゃ何もかも考え方の違いを除けばすべていっしょ、
なわけだけど、その「考え方の違い」というか記数法の
違いによって、ものごとを考える範囲や考え方が異なって
くる、ってとこに意味があるんじゃないの？

実際、ローマ数字のままで現代数学は発展しえたか、とか。

void*ばかり使ってたらCも型無し言語と同じだがや。
もちろんCのコンパイラは型推論なんてしてくれへんねん。
C++や型推論の使える(可能性がある)型無し言語より分が悪いの。
インライン化やオプチマイヅつーか、そこんとこで。

SMLだと関数を定義するのも変数を定義するのも同じこと。
よって変数を定義するのを副作用というなら
関数の定義も副作用ということになる。

>>125
型推論の使える形無し言語って何だ？
型ありじゃないと型推論なんてありえんぞ。

>>124
そういう意味じゃない。
記数法に実質的違いがないだろ。
関数型言語のx=1だろうがC言語のx=1だろうが、
どれも同じだろ。

>>120 参照。
データ型が１つでも指定されてれば型推論は可能なのねん。
決まったデータ型を返す関数からも、もちろん可能。

void*ばかり使うってのは実質不可能だろ。
キャストしないと演算子が使えなくないか？

>>129
え？変数の型を推論するのが型推論だろ？

>>131
関数の型も推論するよ。

つか、120を書いたのは俺なんだが。

>>133
ﾜﾗﾀ

>>131
なるほど、確かにそのとおりだ。
しかし、変数に型が無い言語で関数の型を
推論してなんか意味があるのか？

lisp/schemeでもデータ型から辿っていって、
型チェックをするってプログラムを書けます。
関数定義がデータと同義なので、
定義自体をデータとして解析できるのです。
当然文法チェッカや型チェッカも作れます。
Cでいうlintが自分のプログラムと同じ階層で走る様な物です。
さらに、動的に部分コンパイルやインライン展開する事もできます。
Cでいうコンパイラが自分のプログラムと同じ階層で走る様な物です。
まさにlisp/scheme言語は誰もが憧れる夢の言語なのです。

>>135
ごめん。ちゃんと読んでなかった。
型無し言語の話だったのね…。

>>137
そうなのか。それなら別に良いけど。

ちょちねぼけてました。すんません

Haskellﾏﾝｾｰ

>>136
煽りにマジレスしておくと，夢の言語かどうかは別にして
私もLispの最大の特徴はquoteだと思っています．
これがレスになっていることは分かるよね？>136．

面白いのでこちらに挙げておこう．
http://www.shiro.dreamhost.com/scheme/trans/beating-the-averages-j.html

>>141
確かにquoteが無いと、マクロが書けないし、
シンボルそのものが欲しいときなどにどうしようもないですね。
'(+ - =)
=>(+ - =)
(list + - =)
;=>(#<prim+> #<prim-> #<prim=>)
`( ,+ ,- ,=)
;=>(#<prim+> #<prim-> #<prim=>)
`,`( ,+ ,- ,=)
;=>(#<prim+> #<prim-> #<prim=>)
`(,@`( ,+ ,- ,=))
;=>(#<prim+> #<prim-> #<prim=>)
(define a `(,@`( ,+ ,- ,=)))
;=>a
(eval '`,a)
;=>(#<prim+> #<prim-> #<prim=>)
(eval '`(,@a))
;=>(#<prim+> #<prim-> #<prim=>)
(eval '(eval '(eval '(eval '`(,@a)]
;=>(#<prim+> #<prim-> #<prim=>)
'quoteマンセー
=>quoteマンセー

>>141 のリンクから飛べるけど、これおもろいね。
管理職のためのハッカー FAQ
ttp://www1.neweb.ne.jp/wa/yamdas/column/technique/hackerj.html
ハッカーのための管理職 FAQ
ttp://www1.neweb.ne.jp/wa/yamdas/column/technique/managerj.html
ハッカーのための管理職 FAQ(パロディ)
ttp://hp.vector.co.jp/authors/VA009232/stinger/Hackerfaq.html

evalがある言語なら136の言ってること全部できるじゃん。

あっそ>144

up

Lispの開発効率とHaskellの開発効率ってどっちが高いんだろう。
個人的にはHaskellのような気がする。

ここの人たちって、MLやHaskellをどこで学んだんですか？
マイナーすぎて本とか全く見ないんですが。

>>148
http://www.amazon.co.jp/exec/obidos/ASIN/4756116418/qid%3D989507729/249-3155492-9933113

Haskellはないのかな？
http://www.amazon.co.jp/exec/obidos/search-handle-form/249-3155492-9933113

下の奴開けない？
Haskellで検索してもないんだよね。
どうやって勉強したのでしょ？

>>150
http://www.haskell.org/tutorial
上の日本語訳
http://www.sampou.org/haskell/tutorial-j

>>151
少し読んでみたが、あんまりやさしい入門じゃない。
SchemeかMLの知識がないとだめだろ。

>>151
ありがたう。

age

Lispとschemeって結構近いやん？
haskellってMLに近いの？
>>1であがってるFPやMirrandaって話題出てないけど
どんな感じなの？

http://www.cs.chalmers.se/~augustss/AFP/overview.html

Haskell vs. Ada vs. C++ vs Awk vs. ... An
experiment in Software Prototyping Productivity

compares a number of programming languages in a
prototyping experiment conducted by the US
Advanced Research Project Agency (ARPA) and others.
Among the results: The prototype required 83
lines of code and 10 hours of development time
when coded in Haskell. The figures for Ada were
767 lines / 23 hours, and for C++ 1105 lines.
A graduate student who first got 8 days to learn
Haskell wrote a prototype in 8 hours!

ほんまかいな? 論文へのリンクは切れてる。

>>156
Haskellはすごいって話？
C++は糞ってか？
つーか英語わかんねぇよ。
Haskellでは83行に10時間かかったの？

ああ鬱だ

>>147
そういえば理論屋でないHaskellな人に聞きたいんだけど
モナドって分かりやすいと思いますか？どのように理解していますか？
元の理論を知っていればそれなりに納得できるだろうけど，
普通のプログラマにとっては取っ掛かりがなくて分かりにくいと思うんだけど．
個人的にはここが気になるのでちょっと最強の言語とは言えないなあ（あ，スレ違いか）．

>>157
つまり、同じ問題出して一斉に解かせたら、
Haskellの場合、たったの83行のコードで問題を解決することができて、
10時間しか問題解決にかからなかったと言うことだろ。
Adaは767行で23時間。C++は1105行もかかったと。

つまりHaskellは凄すぎるってこと。

探したらその論文結構有名なようで、あちこち検索に引っかかった。
論文本体もここにあった。
www.cs.uwa.edu.au/undergraduate/units/230.301/papers/hudak-prototyping.pdf
www.ai.sri.com/~heller/Lisp/jfp.ps.Z

pdfの方は横になって見にくかったので、PostScriptの方を見たが、
Relatinal Lispという言語は3時間で終わってる…(藁
行数はでかくなったようだが。

C++はどうやら時間かかりすぎて計測不能だったようだ。
あと、Haskell初級者の学生が、Haskellで8時間で終わらせてしまったという
結果もある。

>>156
論文のpsファイルをここからダウンロードできる。

http://www.ai.sri.com/~heller/Lisp/

アメリカ海軍が問題を提供し評価をしたようだが、論文の著者は
2人とも関数型言語の研究者で、特にPaul HudakはHaskell
コミュニティーの中心的な人物です。かなり眉唾か?

prototypeが関数型言語で書きやすい物だったに一票

>>161
つーか、その二人目のやつが実際に問題解いたそうだ。
しかし、中心的な人物が学生に負けるとは…

ん？Paulはファーストアーサーか。
問題解いたのはMarkの方だ。

>>136
＞型チェックをするってプログラムを書けます。

わざわざ書かなあかんの？

わざわざって、そんなに難しい事か？>165

それなりに面倒だと思うけど。
それにコンパイラがチェックしてくれるわけでもないなら
あまり意味が無い。

意味ないわけないだろ。作りようによっては推測・自動修正して
結果を報告する様にもできるぞ。>167
結局、環境リストと定義リストの探索だから、そんなに難しくはない。
変数（バインドされたシンボル）の使われ方を辿っていって、
外部データ表現(または構造)に辿り着く様であれば、それで変数の
型が特定する。

168によって型が特定したら、イリーガルな操作を行なっている部分
を列挙できる。
ちなみに型の特定は、処理系が用意している基本プリミティブや、
入出力の型が確定しているclosureからもできる。

Haskellって人の名前なのね。
ML知ってる人はこのスレに何人かいる様だけど、
Haskellって皆無なんじゃ？

Haskellマンセーとか言ってた人は、使ってんの？

Haskellマンセーとか言ってた人は、使ってんの？

型チェックと型推論は区別してくれい．

型チェックは変数や対象の型が整合しているかどうかチェックすること．
型推論は型宣言が省かれた変数や対象の型を導くこと．
例えばCには型チェックはあるが型推論はない．
すべて明示的に型が宣言されているから．

それで単純な型だけならいいんだが，型システムを多相型に拡張しだすと
どちらについてもコンパイル時に行うには困ることが起こる．
例えば，ある種の多相型に部分型を導入すると
型チェックが止まらないケースが出てくるとか，
MLの型システムに普通にレコード型を導入したら
MLの型推論の意味での単一の型が決定できないケースが出てくるとか．

だから，もしオブジェクト指向のようなことができるように
型システムを拡張しようとするなら，そいつは全然簡単じゃない．

つかったことあるよHaskell
モナドはわかりずらいよね。
Introduction to functional programming using Haskell 2nd ed.
でべんきょした

すみません。もう1つ猿な話させてください。

関数型なる概念の定義の概略はここの皆さんの発言で
なんとなく判った気はします。

で、Lispって関数型言語だということになっているんですよねえ？

でも書籍「List遊び」を読んだ感じでは、(Emacs)Lispは
Listという「データ構造」をいじる言語である、という風に
読めちゃいました。それは明示的な状態(の一種)だと思う
のですが、すると関数型言語っぽくないということに
なるような気が…？
関数云々というよりも、関数もデータも全部Listと見なしてから
全てを考え始める、というノリに思えました。

(Emacs)Lispはたまたまそういう(関数型としては不純な)
言語であり、それは関数型の本質とは無関係だ、
ということでしょうか？
それともそれ以外のなんらかの意味なんでしょうか？

>>175
listを弄るとは言っても、入力されたlistを
直接書き換える事では無いって事。
出力するリストはconsで生成するでしょ。
lispは破壊操作を行なわなければ関数型言語と同じ。

>>168
意味ねぇよ。
その間違った所が実行されきゃ間違った所がわからないだろ。
実行する前に、どこがおかしいか一目瞭然でわかる方が
遥かに良い。

このスレを眺めて思い浮かんだ言葉。
「象牙の塔」
「砂上の楼閣」

熱く語っている方々へ。

○○ってすごいぜ。
□□できるし、
△△はあるし。

と各言語をまとめるとどんな感じになります？

例えば、
C++ってすごいぜ。
オブジェクト指向言語だし、
STLはあるし。

>>178
君のレスを眺めて思い浮かんだ言葉。
「食わず嫌い」

>>179
それぐらいのこと自分で勉強しろ。

>>178
http://www.shiro.dreamhost.com/scheme/trans/beating-the-averages-j.html
とか読んでみそ。
使える人が少ないから業務で使われたりしないだけで
ほんとは十分実用的。

>>181
VB厨はほっといたほうが良いかと思われ。

仕事で必要だったので、Schemeを勉強し、今業務で使っています。
仕事以外でもSchemeやHaskellをいじって遊ぶのはほんとに楽
しい。それだけで十分だと思います。

>>50とか>>178ってなんなんだろ？
VB厨かな？C++厨？

えーと、このスレで話されてることに非常に惹かれるのですが、
読んでもさっぱりわからないし、一体何故そんなに熱く語れるのか
是非知りたいので質問して見ました。

ちなみに>>107も僕です(鬱

>>185
とりあえずSICPの第１章だけでも読んでみてください。
http://sicp.arsdigita.org/text/sicp/
１章で関数型プログラミングの基礎を説明しています。言語はSchemeです。

>>185
VB厨なんていってごめんなさい。
死んでおわびします。
がんばって関数型言語勉強してちょ。

>>186-187
さんきう。
紹介していただいたページのタイトル
'Building Abstractions with Procedures'
のうまい訳がわからずいきなり鬱に入ってますが、
とりあえず読みすすめてみます。

ぬぅ、この分量だと、俺の英語力だと一ヶ月くらいかかりそうだ。
早く、'Satori'を体験して見たいなぁ。
では、またROMに戻るナリ。

そんなに英語力が無いなら、素直に日本語のSchemeや
ML書籍読めば？

SICP(計算機プログラムの構造と解釈)は外せないと、思った。
ちょっと古いせいか、マクロや継続の説明は無かったけど。
サンプルコードはMITのサイトにあった様な。

>>191
SICPはプログラミングの教科書であって、Schemeの解説書では
ないので、使っているSchemeの機能は限定されてますね。ちなみ
に第２版は1996年出版なのでそれほど古くはないと思います。

age

下がってきたので、皆で関数型でのプログラミング経験を書いてみよう。
俺、Haskell5000行くらい。

行数？
lisp 昔は結構書いた(今はあんまり)
SML ちょびっと
scheme10kステップぐらい。
関数型言語として書いたのはその半分以下に落ち込むでしょう。

Scheme 仕事で3000行ぐらい。遊びでは２万行ぐらい。
>>194
Haskellに憧れているのですが、どんなプログラムを作ったの
ですか。差し支えない程度に教えてください。

HaskellよりMLの方がわかりやすい。
ところで、MLってOOPはどうやるの？
クラスのかわりにモジュール使うの？

>>197
OOやる必要あるのか？
とりあえず Objective caml とかありますぞ。

http://www.linuxdoc.org/HOWTO/mini/Programming-Languages-2.html
に関数型プログラミングはOOPのスーパーセットだと書いてあります。

Functional languages (Lisp for example) are a bit
different breed - among other things, functional
programming is a superset of OOP.

MLはわからないですが、SICPではSchemeでのOOPがでてきますね。

>>197
モジュールをクラスにしてファンクタを継承がわりに
するんじゃないか？

>196 Haskellで書いたのはコンパイラもどき。

>197 関数型言語がOOPのスーパーセットだっていうのはきつくないか。
OCamlとかはやってるみたいだけど、俺は使ったことない。
俺の友達はやっぱり、関数型とオブジェクト指向って馴染まないと
言っていた。

馴染まないって事はないんじゃないか？
HaskellやO'Camlにはクラスはちゃんとあるし。
何を根拠にそんなことを？

Haskellのクラスはタイプクラスと言うもので
オブジェクト指向のクラスとは異なる。
どっちかと言うとJavaのinterfaceみたいなもの。

Ocamlはオブジェクト指向の要素をとりいれているが
これをつかった友達がしっくり来ないと言っていた。
(自分は使ったことがない)

少なくともHaskellでは状態がないのでOOPでのオブジェクト
は実現が苦しいし、皆が認識しているOOPのプログラミング
スタイルをHaskellのプログラミングスタイルに取り込むの
はきついと思ってるけど。

うーん。説明しづらい。

そういう所は適度に副作用を許しているMLやLISPが都合がいいのかもしれないね。

Haskellって数学好きの人が使うもの？
難しくない？
CとかRubyとかとは、好む人が本質的に違うような雰囲気。

誰かhaskellの特徴的なサンプルコード教えてください。
どこかからのコピペでもいいです。

副作用が無いってことは、作った関数群は恒久的に使いまわせる(再利用できる)
と考えていいですか？

じゃあ、Haskellでのクイックソート

qsort [] = []
qsort (x:xs) = qsort small ++ [x] ++ qsort large
where
small = [y | y <- xs, y < x]
large = [y | y <- xs, y >= x]

small,largeのとこで使ってるのがList Comprehensionという
Haskellにしかない構文

>205 確かに、少し難しいとは思う。かなりプログラムに対する
考え方を変えなければいけないので、Cとかになれてしまっている
人で固執してしまっている人は嫌うんじゃないかな。

>207 そうです。そういった部品(関数)をつなぎ合わせてやっていく
のが関数型のプログラミングともいえるかなぁ。

>>206
Haskellでのクイックソート

qsort [] = []
qsort (x:xs) = qsort [a|a<-xs,a<=x] ++ [x] ++ qsort [a|a<-xs,a>x]

>>207
引数が同一なら必ず同じ値が関数から返される、というのが
参照透明性といって関数型プログラミングの基本です。Cでも
関数の使いまわしをしたい場合はそうするでしょう。

考えていたらかぶってしまった。スマソ。

>>207
一瞬ネタかとも思ったが、
そう言われてみれば、状態を変化させないなら
状態を変化させる手続きより使いまわしが数段楽つーか安全
なのは確かなんですね。うーむ。

まぁ、だからといってその見かえりに
状態そのモノを放棄する度胸は、ちょっと…(^^;
OOPは状態を捨てずに救った言語スタイル。

「状態がない」ってのは理屈をつけてごねてるだけで、
実際は状態があるのと大差ない。

無礼と知っててここに書き込みます。
haskellの質問スレが見つからなかったので。すみません。
実は今学校の課題でhaskellつかっているのですが、
さっぱりわかりません。

課題というのは、
有理数aから区間列{(a-(1/(2^n)),a+(1/(2^n)}を表示するというものです。
それで、

list::Int->[Integer]
list n= let f x = (x*2):(f(x*2)) in take n (f 1)

で2のn乗が計算でき、

list2::Rational->[(Rational,Rational)]
list2 a=[(a-1%(n+1),a+1%(n+1)) | n<- [1..]]

で有理数aから区間列{(a-(1/(n+1)),a+(1/(n+1)}を表示できたのですが、
どうしても2のn乗を表示できません。
どなたか教えていただけませんか?

>>213
だーかーらー、理屈をこねるのはそれだけの見返りがあるからだってば。

見返りが無いとは誰も言ってない気が…

>216
文章である以上ちゃんと書かないと伝わらないよ。
で、アンチ的な発言なんですか？

ちゃんと伝わらないってどういうこと？
アンチ的なのかどうか分類できない発言を、勝手に
間違えてアンチに分類されるってことか？(藁

>>213はあれだけだとこのスレでさんざん出没した
アンチ側の意見に見えるけど>>218

age

age

age

age

age

荒らされてる？

ありゃりゃ、なんなの？中身のあるカキコしてん>>220-224

荒らしです>226
00:15〜00:19頃に上位20のスレが狙われた模様

>>219
そのさんざんあらわれたアンチは、本当にアンチだったんでしょうかね？(藁

さんざん現れたアンチってどこら辺のこといってるの？

>>185さんはアンチ発言らしきものをしたがアンチじゃないらしいし。

めんどっちいから、もうアンチ発言らしきものをした人はアンチでいいじゃん。(w

比べてもしょうがないかもしれないけど、
副作用がないってことは関数型のほうがOOよりさらに再利用性が高いのかな？

OOPのライブラリとかって、結局大きい塊としてしか扱えないような気がするし。

細かい使い回しはいろいろ聞くと思うよ。
高階関数もあるし。

ていうか、副作用が無いことにしたって、プログラムの
考え方が解析しやすくなっただけだろ。
それはプログラムの見方の問題であって、言語の文法
は何ら変わってないだろ？

再利用もそうだけど、加工が容易な気がする。
見通しが良いからかな？

>>234
基本的に制御構文の考え方ははほとんど変わりないです。

>>234 なんで文法の話しになったんだかわかんないけど、
Haskellじゃ ifは組み込み構文じゃなくて、
単なる関数になってるよ。

pow2 = 1 : map (2 *) pow2
series a = [(a - 1%n, a + 1%n) | n <- pow2]
じゃだめ? >>214
先頭 nコが欲しいときは take n (series a)

>>231 アンチかどうかは call-by-needで評価しようよ

>>236
関数だったらifの要である、分岐ロジックってどうやってるの？

そもそもifって副作用とか状態とか関係ないでしょ。

>>240
いや、だから
if a then b else c
の
bやcには関数でどうやって分岐してるのか聞きたいんだけど。

ifが関数ならば、if自身の関数定義はどうなってんの？って事か。

ちなみにschemeやMLでのifは関数ではなくて、syntax

>>239
パターンとかかなぁ。知らないけど。

>>241
Cでいうところの関数ポインタ渡すんだよ。

>>245
んだんだ。Cで、

IF(int, (void*)(), (void*()));

って関数が書けるもんな。あれの延長だ。
あとは無名つーかInlineな関数(?)を書く機能が
Cにもし有れば、ノリも完全同じなことができたんだが…

>>246
> IF(int, (void*)(), (void*()));

これって、内部でif文使うだろ？

なんでここでCの話が出てくるんだよ>>245-246
関数のポインタの話なんてしてねえだろ。

>>248
話の流れ読めてるか？

haskellの「if関数」の定義の話じゃないの？>249

>>247 Ｃプログラマに説明するなら
「 A ? B : C の三項演算子を関数化したようなもの」
といえばすんなり納得してくれると思う。

>>249
理解してないのはキミ。
↓これ。

>236 名前：デフォルトの名無しさん 投稿日：2001/05/20(日) 22:30
>>>234 なんで文法の話しになったんだかわかんないけど、
>Haskellじゃ ifは組み込み構文じゃなくて、
>単なる関数になってるよ。

「単なる関数」なら、どうやって定義してんだって話。

>251
だから今、Cの話なんてしてないだろ。

haskellのifは>>236が言うには「単なる関数」らしいので、
それをhaskell自身でどうやって定義してるのか示せって言ってるの。

問題
if = [?]
[?]を埋めよ。

だからHaskellの話にCを持ち出して比較することで
話をわかりやすくしようという意図だろ？
そういう目的なら別にCの話を持ち出したっていいだろ。

全然理解してないな。寝てしまえ>254

[?]は外部呼出しなんじゃ？
でもhaskellはパターンマッチがあるんだからifなんて必要なのか？
#Haskellはちょっとかじっただけなのでまったく自信無し

>>254
なんでここで、「Cを持ち出して比較する」必要があるわけ？

矛盾してる。
haskellのifは関数だという。
でもその関数の定義は示せないらしい。
(示そうとする人が現れない)

>>256
>[?]は外部呼出しなんじゃ？
外部呼出しを「単なる関数」とはいいませんよ。

>ifなんて必要なのか？
そんなこと議論してません。

>>257
例えば、「関数である」ということを聞いて、「ほう、Cのあれと同じだな」と
思った人がいて、「CのIF()と同じようなもんさ」と発言する場合など。
その人は間違ってるかもしれないけどね。

つーか>>236 解答おねがいします。

だからC言語の例はあくまでも「喩え話」だから関係無いだろ。>259
haskellでどう定義するかって話。

>>261
例え話を発言しちゃいかんのか？

haskellでの関数定義

if = [?]

[?]を埋めよ。

いくら喩え話をした所で問題は解決しないって事>262

>外部呼出しを「単なる関数」とはいいませんよ。
なじぇ？WindowsAPIは単なる関数呼び出しでしょ？

>ifなんて必要なのか？
>そんなこと議論してません。
まあそうだけど、パターンマッチてのはswitch見たいなもんだから､
･･･ってヨーク考えればパターンマッチ使えばifも実装できるね。
#しつこいようだが自信無し

>>265
>パターンマッチ使えばifも実装できるね。
だったらそれを示してくれ。

>>265
>なじぇ？WindowsAPIは単なる関数呼び出しでしょ？
なんでWindowsAPIの話になる。
WindowsAPIでif関数が定義できるのか？

問題

if = [?]

haskellの言語機能のみを使って、関数ifの定義[?]を埋めよ。

>>234-268

>>264
でも話にはなってるだろ？
本人はC言語の例えで解決になってると思って発言してるのかもしれないし。
もう一回ログを読んで、話の流れを読めよ。

手続き型言語しかしらない人に
関数型言語を布教するのによい説明方法を話し合うのも
それなりに生産的な議論だとおもうんだけどな、、、、
果てしなく脱線する可能性が高いけど。

>>268の問題を解いてくれる人を待ってます。
if自身の定義にifを使うのはナシね

if b funcA funcB | b == true　　　　= funcA
　　　　　　　　　| b == false　　　 = funcB
見たいな感じかなぁ。
#自信無し

lisp schemeスレで、ループを３つのlambdaで表現した人が
いたけど、これもそんな解答になって欲しいなあ。

>haskellの言語機能のみを使って
この思い込みはどこからくるの？
ifが外部関数もしくはビルトイン関数であっても、制御構造ではなくて
関数であることには変わりはないと思うのだが。

>>273
ありがとう。パターンってそういうことなのね。
でも結局if相当の事は行なうわけか・・

それ、制御構造じゃん>275

>>275
>外部関数もしくはビルトイン関数
０点。

if p then else = case p of
True -> then
False -> else

>>278
なんで？

<<Haskell
でも実際はthen elseは構文として間に入るから出来ないよ。
あくまでも概念

Haskellのif "cond" then A else Bは
case "cond" of | True = A
| False = B
のシンタックスシュガーでしょ？

SMLだと（ifって識別子は使えないけど）
fun if(true,a,b) = a
| if(false,a,b) = b;
で出来るなぁ。

なんか見たことない言語がいっぱい（笑

>>276
僕の言ったパターンてのは>>283ね。
>>273はパターンっぽいけど違うかと。

>>279
iF :: Bool -> a -> a -> a
iF = \p -> \tHen -> \eLse -> case p of {True -> tHen; False -> eLse}

>>283
でも遅いし、副作用が無いのが前提か……

237番のかた、どうもありがとうございました！！
本当にたすかりました。

ていうか、先生が小声で早口でわかりにくいうえに
参考書も英語なんでかなりてこずってます・・・あう。

>288
化石レスには引用付けて欲しいなあ・・
>>214 >>237 みたいに。

それにしても学校の授業でhaskell使うなんて恵まれてるね。

>>290
どーい。

どこの大学？
相当偏差値高くない？

Haskellでforやwhileループのようなことをやるには
どうしたら良いの？

>>293
ループでやるようなことをするのなら
takeWhile や dropWhile なんかを使うかなあ。
ループをリスト上の再帰にしてしまう。そういうことじゃない？

Haskellのやさしい入門っていうの、どこかのHPの私訳を一通り読んだけど

はっきりいってむずかしすぎて分からん。
相当頭のいい人が使うものと感じた。
そもそも型の再帰的定義からしてかなり難解。
ひとまずMLの資料を探してみることにします。
ていうか、言語よりはもっと本質的な理論が重要なように感じる。

あれはMLを多少知ってた俺でも難しいと思ったからな。

単に慣れや覚えた順番の問題じゃないかなあ。
Haskell より ML 方が難しいと思う人もいたりする。

先にSchemeやったら、HaskellもMLもみんな
構文が複雑すぎるように感じられる。

御意
でも、Scheme に比べれば大抵の言語は複雑な構文だよね。

Lispの文法もかなり凄いことになってるよね…

SMLはストラクチャ辺りが複雑だと思う。

HaskellやMLの場合言語の構文が複雑というよりも、主に
研究者が使ってる言語だからドキュメントがやたら難しい
言葉で書かれている。
複数の文を書く方法やfor、while相当の機能の説明が
ずいぶん後の方でちょろっとだけ出てきたりする。
その辺が必要以上に複雑だと思わせているんだと思う。

複雑なところと言ってもルールの組み合わせ方が複雑なん
じゃなくて、機能が豊富だから複雑になってる所がいい。

for, while相当のものなんて教えてもらう必要あるのか？
再帰を使うって事だけ知ってりゃ簡単だと思うが。

知ってりゃ簡単なんです。てりゃそりゃ。
悩んだ後で、「あっそうか」に辿りつけるかどうか。
ちょこっと、アドバイス、記述があればなんてことないのだが、
それがないと敷居が高いと感じるひともいるかな。

再帰を使うってことはなにか？
いちいちfor、while相当のことをさせるのに関数を作らなきゃ
ならんってことか？
なんて不便な言語だ。

>>305
おいおい。
関数型言語なんだし、関数作らなきゃ何もはじまりませんよ。
そもそも関数つくるのなんてそんな大変じゃないだろ？
むしろfor,whileよりすっきり、早く書けることのほうが多いんじゃないかな。

>>306
いちいちfor使うたびに新しい関数の名前考えなきゃならんのか？
そんな面倒なことやら無くちゃいけないぐらいなら、forが
はじめから定義してあった方が良いに決まってる。
俺だったら結局自分でfor関数定義して使うよ。
つーか、再帰すらわからないやつがいるというのに、
再帰の説明だけでforの代用に気付けといわんばかりの説明は
敷居が高いのは明らかだろ。

>>307
一々関数を定義するじゃなくて、
map とか foldr とかのリスト上の標準関数使うだけだと思うけど。

>>308
mapやfoldrは引数に関数を取る。

Schemeでちょろっと末尾再帰するときはたいていloopという関数名にしている
おれってドキュン?

forループを関数にしたら、スコープが変わってしまうだろ。

>>311
スコープが変わるとだめですか？
なにのスコープがどう変わると、どうだめなんでしょう。
簡単な例題はないですか。

>>312
外側の変数が簡単につかえない。

>>313
純関数型なら assignment がないので問題ないような気がします。

>>314
ﾊｧ？なんで問題ないの？

外側の変数の値を内側で変更するのが問題だということかと思っていました。
私は 313 の意味を勘違いしてるみたい。
どういう意味なんでしょう。

いや、関数型言語って外側の変数を参照したり変更したりすることって
出来るの？

それだと、全部の変数がグローバルなのと同じような感じで
ものすごく使いにくいと思うけど。

>>317
Haskell なら
変数の参照については外側のスコープのものは参照可能
変数の値についてはいかなる場合も変更は不可能
です。

315は、[ごめんこの例はSchemeだけど]
(define (for min max proc) …minからmaxまでカウンタ値を変えて手続きprocを適用する…)
のような関数を使ったときにproc内のスコープがどうなるか
わかってないんだろう。「関数型言語」でひとくくりにしている
ところも痛い。

誰かstatic scopeとdynamic scopeの違いをスカっと説明してやれよ

>>302
そうそう、そういう所が本質的な議論をしているっていう感じがする。
HelloWorldから始まったりは決してしない、みたいな。

>>305 >>310-312
（もしschemeを使用してるならば、ですが。）
lisp schemeスレにforとwhileのサンプルがありますので参考にどうぞ。

>>322
関数型言語の枠組で
Hello World を説明するのはあまりに難しいからじゃないかな。

do〜whileも置いておきました。
あの様に、(マクロとしてですが)継続の部分を除けば、
C言語のfor/while/do〜whileも関数型言語の枠組みだけで実現できます。
用意されていないだけで、相当する処理は書ける事がお分かりになったでしょうか。
(break/continue/returnは継続の様な特殊な物が無いと難しいですけど。)

副作用を起こさなければ、正体不明のバグってかなり減るような気がする。
そこが関数型言語の良い所？

関数型言語ではこういうのはどうするんですか？

(defvar x 10)

(defun f (y)
(setq x (- x y)))

(f 3) => 7
(f 4) => 3

setq使ってる時点でアウト。>327
考え方が関数型になってない。
>(f 3) => 7
>(f 4) => 3
;以後、これはキモイと考えること。

Rubyのまつもとは、文字列において、副作用を起こす参照が良くて
複製を作る代入（宣言なら副作用は起こらない）はダサいとか
言ってたよ。(藁

>>320
＞ (define (for min max proc) …minからmaxまでカウンタ値を変えて手続きprocを適用する…)
＞ のような関数を使ったときにproc内のスコープがどうなるか
＞ わかってないのだろう

C言語とは違うのか？

>>324
モナドってやつですね。

MLならforやwhileもあるし、代入もできるYO!

代入があるのは逃げ道。本来意図した使い方じゃないんだよ。>332
関数型言語として使いたければ今すぐ代入の使用をやめなさい。

なんか、どっかの宗教が輸血拒否したりするのと
同じぐらい愚かだな。

信仰とはそういうものだ

じゃあ、Haskellでは代入をどうやって避けるんだ？
代入が必要になるたびに新しい名前の変数を作るのか？

自分で書いてみたら?>336

>>337
わからなかったら書けないだろ。

>>338
マニュアル読め

>>336

Haskell では計算をあまり操作的には考えないです。
プログラムは計算の手順の記述というよりは、値の関係記述の
ように書くという感じです。数学の等式を書くのに似てるかもしれません。

Haskell の変数は値についた名前という意味しかなく。値をいれるいれもので、
値の一時保管庫ではなく、値の出し入れという操作を記述するスタイルの
プログラムとは全然雰囲気の違うプログラムになります。

実行効率の上で代入(assignment)が欲しくなることはあるかも知れませんが、
なにかの値を計算するプログラムを書く上で代入が必要になることは
ないです。

使ってみないと実際の所わからないだろう。

>>340
つうか、何も情報になってねーよ。
結局の所「代入は使わないのです。」と言ってるだけだろ。
現象を説明してるだけで、全然理由になってない。

だから..問題&解法を記述するのに代入は必需品じゃ
ないのです...
なんでそんなに代入操作にこだわるかの理由を述べたほうがいいのでは

代入が良く使われてるのは常識でわ。

前の方で出てきたやつで言うと、

qsort [] = []
qsort (x:xs) = qsort [a|a<-xs,a<=x] ++ [x] ++ qsort [a|a<-xs,a>x]

このaやxって明らかに代入と一緒じゃん。
代入避けろとか言ってるけど、書き方変えてるだけじゃん。

>>345
みかけはともかくこれはλ束縛であって，いわゆる破壊的代入とはちがうよ

qsort(x:xs) = qsort (filter (\a -> a<=x) xs) ++[x]++ qsort (filter (\a -> a>x) xs)

>>342
Haskell では代入(assignment)は使わないではなくて、使えないです。
なので、代入を避ける必要はないです。
で、代入を使わなくて何故プログラムがかけるかは私には謎です。
でも、かなりの範囲(主観的ですけど)のプログラムは Haskell で書けます。
で、何故、何のために代入なしの関数型言語を作った人々がいたかですが
プログラムを実行せずにプログラムが正しいことが分かるような記述法が
欲しかったとかかなあ。

>プログラムを実行せずにプログラムが正しいことが分かるような記述法

蛇足ですが。
OOPは全然違う方向からその問題に取り組んでる、と
妄想したがってる厨房なワタクシ。

実行文脈をObjectの存在とは切り離しちゃったので、
「走れ」というメソッドを呼ばない限り
(つまりそれ以外のメソッドだけを呼ぶ限り)
非破壊に検証できる、
というObject系を作る「ことができる」はず。

まぁ言語によって強制されていなくて
セマンティックなレベルだけの話なんで、
よわよわだけど。

「実行時」ってものは、そんなに忌避されるもんなのかなあ？
どっちかというと、実行時の使いやすさを向上させる仕組みを
考えるほうが良いようなきもするんですが…

http://www.yfcbookshelf.com/ml_lisp_scheme.htm

>>346
破壊的代入というなら、Haskellの
a // [(i, v)] のような配列の更新はなんなんだ？
破壊的代入じゃないのか？

>>350
破壊的代入ではないです。

a ! 1 の評価結果を 1 であるとして
(a // [(1,2)]) ! 1 の評価結果は 2 ですが、
a ! 1 を評価すると結果は相変わらず 1 です。

let
  a = listArray (1,1) [1]
  b = a // [(1,2)]
in
  (a ! 1) + (b ! 1)

を評価すると結果は 3 です。

ふぇふぇふぇ

>>348
スレ違い。ウザいぞ。

>>351
なるほど、要するに、更新された配列が右辺に現れるが、
その変化は長期的には反映されないという感じかな。

しかし、それでは、配列を変更したくなるたびに、新たな
配列を作らなくてはならない。

配列をデータとして蓄え、ユーザーの応答に応じてデータを
更新していくようなプログラムを作る場合、同一の配列に
データを保持しておくことができないから、問題があるのでは
ないか？
少なくとも俺にはこうしたプログラムをどうやって作るのかわ
からない。
例えその問題が解決したとしても、更新するたびに配列全体の
コピーが必要になるのではないか？

>>353
別にスレ違いじゃないと思うぞ。

>>354
その通り．ナイーブにやったのではとてもじゃないが実用にならない．
そこでHaskellなどでは，あくまで意味的には参照透明性を保った上で，
「変更前の配列」に見かけ上新たにアクセスできなくなるモナド(monad)
というメカニズムがある．意味的には純粋な関数型言語のまま，コンパ
イル結果は破壊的代入になっているような，そんな処理系が作れる．
実際，HaskellのコンパイラにはHaskell自体で書かれているものがある
が，テーブルや状態の管理にはモナドを用いて効率をよくしている．

モナドは配列や状態の表現の他に，例外処理や環境にも用いることが
できる．

ちなみにモナド自体は組み込みの機構ではなく，単に型構成子 M
と2つの関数 unit, bind の組として表現される．unit, bind の
型は以下の通り（a, bは型変数）．

unit :: a -> M a
bind :: M a -> (a -> M b) -> Mb

また，unit, bind は以下を満たす．

bind m unit = m
bind (unit x) f = f x
bind (bind m f) g = bind m (\x -> bind (f x) g)

（うろおぼえなので間違ってたらビシバシ指摘しておくれ）
これと等価な定義もいくつかあって，用途によって使い分けること
ができる．

あとは P. Wadler の解説論文でも読んでおいてくれー．

>>355-356

「破壊的な代入は持たないです。しかしモナドがあるのです。」

こういうのって、従来の言語と何ら変わっちゃいないように
思えるんだよな。

言語のパラダイムにあわせて、「機能の意味」が変わってる
だけ。機能の実態は変わってない。
関数型言語のパラダイムに合わせてプログラムの仕組みを
語る上では便利なのだろうが、それ以上の意味は無いように
思える。

定性的じゃなくて定量的に見ればいいのかな。
Cに goto文もあるから構造化プログラミングになってない、って
わけでもなくて。
Haskellにモナドがあっても、それなしでもかなりの部分を
くめるわけだし。

>>357
同じことの繰り返しだけど、
単に語るだけじゃなくて厳密に解析するのに役立つの。
プログラムを厳密に解析するのに
理論的にクリアでないと困るのはわかるでしょう？
クリアでかつ従来の言語でできることを失わない
というのがまずは重要であって、モナドはその一つの解答。
もちろん従来の言語を超えることができればさらによし。
（個人的にはHaskellのモナドはわかりづらいとは思うけど）。

>>356
Moggiの元々の論文はカテゴリーの定義さえ知っていれば
結構わかりやすいと思う。例も多いし。
Wadlerの論文は理論を避けているせいでかえってわかりにくいと感じた。
Haskellのマニュアルとかではおどかし過ぎだと思うぞ。

>>359
思うんだが、やってることは従来と変わらないのならば、
モナドと言わずに破壊的代入だと言ってしまえばいい
じゃないか？

で、理論的に考える時だけ、破壊的代入と考えずに、関数型な
概念で考えればいい。

そういうやり方ならC言語だって関数型な考え方で捕らえる
ことができるわけだろ？

わざわざ理解困難にする必要はないと思うのだが。

>>360
計算機上で実行可能なものなのだから、そういう意味では従来のプログラム
とやっていることは変わらないと思います。
Haskell を使うのなら関数プログラミングの考えかたでプログラミング
するほうがいいと思いますが。。。

>>361
例えば、C言語でHaskellの考え方をすればいいんじゃないの？
破壊的代入が出てきたらHaskellのような別の概念だと考えて分析する。
モナドって良く知らないけど。

つっこみですけど、
Haskellの弱点ってありますか？
ちなみに、弱点とは関係ないですけど、
fib n = fib (n-1) + fib (n-2)
って定義してフィボナッチ数列を計算すると、fib 100くらいで
すでに遅すぎなんですね。アルゴリズムの問題ですけど。
でも、漸化式の最適化くらい処理系的には簡単に出来そうですけどねえ。
やってまずい理由無いと思うし。

>>363
どの処理系ですか？

>>364
最新のHugs (Windows)です。

あと、便乗質問ですが、対話形式で使っているとき、
プロンプトで関数定義をするにはどうすればいいのでしょうか？

Prelude> f x = x * 2

とか入力しても「unexpected =」とかでて、うまくいきません。

>>364 それはできないです。
Haskellでは実行環境も動的に変更することはできないので、
関数をHugsが立ち上がってからは追加できないのでは。

>>366
ではどうするのですか？

今調べたら
ファイルをエディタで編集して、ドロップするのが定石のようです。

質問ですが、関数型言語だと関数の微分が出来たりしませんか？
ソースを読んで解析とかじゃなくて、もっとセマンティカリー（？）
に解析することは出来ませんか？

>>363
一般論として、アルゴリズムの最適化が処理系にできるわけない。

しかし、その定義でfib 100が「すでに遅すぎ」！？
まともにやったら天文学的な時間がかかりそうですが。
ちょっとCでやってみました。

#include <stdio.h>
#include <stdlib.h>
int fib(int n)
{
return n > 1 ? fib(n - 2) + fib(n - 1) : n;
}
main(int argc, char **argv)
{
if (argc > 1)
printf("%d\n", fib(atoi(argv[1])));
}

上のプログラムを、PIII(800MHZ)+Linux+gccで実行したところ
fib 39で５秒、fib 40で８秒、fib 41で14秒かかます。
Tree Recursionは、指数的に計算時間が増えるので、少なめに
計算してもfib 100の計算には40万年以上必要なはずです。

もしfib 100が計算できたのなら、Haskellは何か最適化をしている
と言わざるをえない。ちなみにfib 100は、
354224848179261915075
です。

>>363
> fib n = fib (n-1) + fib (n-2)

この関数って終わるの？

(define (fib n)
(let iter ((a 1) (b 0) (c n))
(if (= c 0) b (iter (+ a b) a (- c 1)))
))

当然
fib 0 = 0
fib 1 = 1
が必要です。

ちなみに、Haskellを使って線形計算量でFibonacciを計算する方法
(tutorialからのコピペ)
fib 0 = 0
fib 1 = 1
fib (n+2) = flist!!(n+1) + flist!!n
where
flist = map fib [ 0.. ]

>> 373
ちなみに対数ステップで計算する方法

fib n = fib' 1 0 0 1 n

fib' _ b _ _ 0 = b
fib' a b p q c
 = if even c
    then fib' a b (p * p + q * q) (2 * p * q + q * q) (div c 2)
    else fib' (b * q + a * q + a * p) (b * p + a * q) p q (c - 1)

>>374
良かったら C で書いてくれない?
(厳密なプログラムじゃなくていいから)

対数ステップfib
(define (fib n) (fib-iter 1 0 0 1 n))
(define (even? n) (= (% n 2) 0))
(define (fib-iter a b p q count)
(cond ((= count 0) b)
((even? count)
(fib-iter a b
(+ (* q q) (* p p))
(+ (* 2 (* p q)) (* q q))
(/ count 2)))
(else (fib-iter (+ (* b q) (* a q) (* a p))
(+ (* b p) (* a q))
p q (- count 1)))))

厳密じゃないけど

integer fib(integer n) {return _fib (1,0,0,1,n);}

integer _fib(integer a, integer b, integer p, integer q, integer c)
{
if (isEven(c))
return _fib(a,b,(p*p + q*q),(2*p*q + q*q),(c/2));
else
return _fib((b*q + a*q + a*p),(b*p + a*q),p,q,(c-1));
}

>>377
サンクス!

_fib の定義のなかの先頭に終了条件をいれわすれてる。
if (c == 0) return b;

関係ないけど、fibで求めた結果って何に使うの？

>>378
だよね(^^;
long long の出力の仕方を調べてて気付かなかった。

>>380
http://www.google.com/search?q=%83t%83B%83%7B%83i%83b%83%60%90%94%97%F1&btnG=Google+%8C%9F%8D%F5&hl=ja&lr=

>>375
#include <stdio.h>
#include <stdlib.h>

int fib2(int a, int b, int p, int q, int c) {
  if (c == 0) {
    //fib' _ b _ _ 0 = b
    return b;
  } else {
    //fib' a b p q c
    // = if even c
    if ((c & 1) == 0) {
      //then fib' a b (p * p + q * q) (2 * p * q + q * q) (div c 2)
      return fib2(a, b, p * p + q * q, 2 * p * q + q * q, c / 2);
    } else {
      //else fib' (b * q + a * q + a * p) (b * p + a * q) p q (c - 1)
      return fib2(b * q + a * q + a * p, b * p + a * q, p, q, c - 1);
    }
  }
}

int fib(int n) {
  // fib n = fib' 1 0 0 1 n
  return fib2(1, 0, 0, 1, n);
}

int main(int argc, char *argv[]) {
  int n = strtoul(argv[1], NULL, 0);
  for (int i = 0; i <= n; i++) {
    int f = fib(i);
    printf("fib(%d) = %d\n", i, f);
  }
  return 0;
}

>>383
関係ないけど、半角スペースが無視されていない
(インデントが崩れていない) のは何故?

&sp;hoge

 間違った……

>>384
半角で＆nbsp;。
スレ汚してすんまそん。

>>385-387
 ス ゲ; ー 。
     サンクス!

age

   a g e

sage

age

a:g:e:[]

LISPでも勉強しようと思って購買にいったらLISPの本なんて売ってなかったヨ。
悲しいヨ。紀伊国屋にもいったけれど、数冊しかないし・・。
というわけで、「プログラミング言語 SCHEME」をかってみました。

>>394
lisp系学習すんならschemeが（・∀・）ｲｲ!ﾖ
SICPも参照してね。

ネタ切れ？

>>395
>>186で紹介されているやつですね。
とりあえずブックマークへ入れときました。
・・って、これは「計算機プログラムの構造と解釈」ですね。
買おうと思ってたよ。

文法はわかったけれど、いざプログラム書こうと思うと
大変に思える。ま、１日目だからこんなもんか。

>>397
覚えることはCやPascalよりも少ない筈。
前置記法と括弧に慣れるかがカギだな・・
処理系に寄るけど、中置記法使う方法が用意されてるかも。
括弧は慣れるしかない。(慣れても読みにくいとは思うけど。)

SchemeよりLispでしょ。多機能萌え〜

キリ番get

　　　　 　,一-、
　　　　 /￣　l |　　　／￣￣￣￣￣￣￣￣￣￣
　　　　■■-っ　＜　>>399 んなーこたーない
　　　　´∀｀/ 　　　＼＿＿＿＿＿＿＿＿＿＿
　　 ＿_／|Ｙ/＼.
　Ё|＿_　| /　　|
　 　　　| У..　　|

>>397
Lisp系のプログラムを書くなら
専用モードを持つEmacsなどのエディタを使うのが吉。
括弧が多いだけに括弧の対応や適切なインデンテーション
を自動的にやってくれるとそれだけで効率がぜんぜん違う。
というかLisp系では適切なインデントはほとんど前提。

>>398
下手に中置記法が混じると構文が崩れて
かえって読みにくいと思うけど。

>>401
(define (森田 n)
(display
"　　　　 　,一-、
　　　　 /￣　l |　　　／￣￣￣￣￣￣￣￣￣￣
　　　　■■-っ　＜　>>")
(display n)
(display " んなーこたーない
　　　　´∀｀/ 　　　＼＿＿＿＿＿＿＿＿＿＿
　　 ＿_／|Ｙ/＼.
　Ё|＿_　| /　　|
　 　　　| У..　　| ")
)

(森田 399)

>>402
こーいうのはあると便利だけど
(infix 2 * a * b * (- 1) * 4 * c + d / e * f)
=>(eval (+ (* 8 a b (- 1) c) (* (/ d e) f)))に展開
=>evalの結果
毎回実行時に前置に展開するのは遅いから、
キャッシュ持っておくとか。

初めから前置で書けばいいだろ。

向上心のかけらも無いやつだなキミは>>405

>>398
Schemeのシンプルなところは好きです。
lambdaは気持ちよさげ。(Javaのanonymous classみたいなものですね。)
ただ、まだ括弧にはなれていないれす。

>>402
emacsは好きなんでemacsつこうとります。

Meadow + DrScheme

>>406
Lisp/Schemeではinfixで書くほうが堕落だとおもうぞ

でも普段から前置で書かないと間違えそうだよ。括弧増えるし。
ちなみに
(infix-expand 〜)
みたいなの用意されてるから、必要なら前置で取り出せるけど。

演算子として扱うなら>>404の様な手段はあったほうがいいかな
(infix 〜 (prefix 〜 (infix 〜) 〜) )
とかネストできると良いかも。

だったら Haskell ？
関数も infix にできるでよ。

http://www.cl.cam.ac.uk/~ig206/guile-arith/

http://www.geocities.co.jp/SiliconValley-Oakland/1680/xyzzy_lisp/xyzzy35.html

 

postfix萌え

postfixっていうとあっちのpostfixしか思いつかないな〜

age

そういや、なぜか SIGPLAN Noticesにはほぼ
毎号 Functional Programmingと Forthの連載があるよな。
# なぜか今年は POPLも送られてきたのでラッキー

age

Haskellっていい言語だと思うけど、絶対メジャーにならないよね？
型クラスとモナドが難しい。
C++よりも理解不能な言語がメジャーになれるのか疑問。
C++はCとして使えるからまだいいけど。

どちらかというと、SMLの方がメジャーになりそう。

MLは文法が覚えにくくてなあ。

あのさあ、C++の文法って見たことある？無茶苦茶よ。
っていうかちゃんとした式で書いたC/C++の文法なんて存在しないんじゃん？

関数系の文法は綺麗よー。
まず文法デザインしてからコンパイラー書いてるから。
SMLは正式な文法の本があるはずだから興味ある方は読むべし。

でも文法の単純さと使い易さは別物ですねん。

> っていうかちゃんとした式で書いたC/C++の文法なんて存在しないんじゃん？
意味不明

>> っていうかちゃんとした式で書いたC/C++の文法なんて存在しないんじゃん？
>意味不明

言い方悪かったすか？ＴＴ
未だかつてC/C++の文法は式で書かれたことがないのでは？
ってことっす。

>>423
いや、オレはSchemerなので。C++となんか比べてない。
>>425
それも意味不明。「BNFで書かれた」ということですか?
そんならストラウストラップに載ってる。

>>425
なんか…関数型言語関連のスレって、投稿者の知識にかなりのブレが
ありますよね。とくにC/C++ネタが出てきたときの。

ありゃ、一番厨房なのは漏れだ。逝ってきまーす。

>>428
何故そうなる？

C++の文法って汚いけど、簡単に理解できるじゃん。

関数型言語の場合、モナドってなに？
ドットペアって？再帰型？
型構築子？え？え？って感じだよ。

関数型言語は綺麗かもしれないけど、難しいじゃん。

Haskell is fine and dandy for some stuff at
educational level, but build applications in
it? HARH HARH HARH! The complex functions in
Haskell are ludicrus and will never get anyone
who haven't had a course in it anywhere. The
imperative languages are so much easier for
the average programmer, and the task of learning
Haskell properly is too exhausting for it to gain
wider acceptance. The only future I see for Haskell
is as a scripting language used for CGI's -
but I'd like to see it try and compete with
Perl's popularity.

sourceは？

ブル･･･(以下略)

>>431
の機械翻訳
Haskellは教育のレベルにある材料に適しおしゃれ?しかし、その中のアプリケーションを構築してください?HARH HARH HARH!Haskellの中の複雑な機能はludicrusで、コースをそのいかなる場所にも持っていない人は誰も得ないでしょう。命令的な言語は、平均のプログラマにとって非常に容易です。また、Haskellを学習するタスクはそれがより広く認められるために適切にまた消耗しています。ただ一つの将来のIはHaskellのために見ます、スクリプトを書く言語がCGIのために使用するが、私が、それが試みて、パールの人気と競争するのを見たいとともに、あります。

そんなもんいちいち貼るな。ウゼエ。

ゼエゼエ。

431の適当に要約した訳

Haksellは教育的にはいいんだけどよ〜、実際にアプリをつくるって？
ハッハッハッ！
Haskellなんて難しすぎて、教育を受けてない奴にはわからないね。
命令的な言語の方がずっと簡単さ。
こんな言語が広まるわけが無い。
将来はCGIで使われるだけだろ。Perlと競争するのをみてみたいもんだ。

>それも意味不明。「BNFで書かれた」ということですか?
>そんならストラウストラップに載ってる。

ちゃうちゃう、BNFはsyntaxでしょーが。
ここで文法ってのはsemanticsのことですたい。
ちなみにCのsyntaxだったらK&Rに載ってるね。
っていうかsyntaxだったらコンパイラのparserパクればOK？

SMLは操作意味（operational semantics）の文法が存在するのですよ。

>なんか…関数型言語関連のスレって、投稿者の知識にかなりのブレが
>ありますよね。とくにC/C++ネタが出てきたときの。

あり？もしかしてなめられてます？一応言語は研究範囲内なんすけど（涙）

うーん、言語を勉強してるなら「文法ってのは semantics」
なんていえないだろ...
ネタじゃないから痛すぎるから出直してくれ。

うーん、言語を勉強してるなら「文法ってのは semantics」
なんていえないだろ...
ネタじゃないから痛すぎるから出直してくれ。

同意。自己流解釈はやめてほしいよな。

ここまで痛い奴は久々だな。この辺なんか特にツボ。
> SMLは操作意味（operational semantics）の文法が存在するのですよ。

ようするに、mathematical notation ってことか？

>ここまで痛い奴は久々だな。この辺なんか特にツボ。
>> SMLは操作意味（operational semantics）の文法が存在するのですよ。

へー。文法って言わないのか？わりーわりー。なんせ留学10年めだから。
日本語（特に専門用語）分からなくなってますわ。

自分もちょっと変だと思ったんだよね。誰かがHaskellの文法は難しいって
言ったからてっきりsemanticsの方かと思ったぜ。Haskellのsyntaxが
難しいってことだったのね？syntaxって難しいか?

>ようするに、mathematical notation ってことか？
ちょっと違うかも？何をmathかとするかによるけどこっち（米国）の
言語学者たちはmathematical notationだとdenotational semanticsの
方を指すことになる。

やっぱ日本の板に書き込む前にはも少し日本語専門用語習わんとな。
反省-_-

このスレに職業プログラマはいるのか？

>>431の出典を検索したら一発で見つかったわ。
http://www.google.com/search?q=Haskell+HARH+applications&btnG=Google+%8C%9F%8D%F5&hl=ja&lr=
と思ったらHaskellじゃなくMLになってるわね。
どっちがオリジナルなんでしょ？

>>438
いえ…僕もsemanticsの形式的な記述(これでいいの？)のことだと思ったんで、
>>424さんに煽りっぽく突っ込み入れてみたんですけど、424さんがBNFのことを
言ってたと>>426でわかったから、これはもう、漏れが厨房なだけだと。

留年10年目？

>>448
3年目か4年目辺りで退学です。

Haskellが難しいのは概念だろ？
つまり、ある決まった規則が、何を意味してるのか
わからないんだよ。

444はsemanticsとやらに形式的な記述が存在して綺麗だとか、
そういう学者的な超越的視点に立ってるから一般人が難しい
という意味がわからないんだろ。

とにかく俺はすごいと言うことを言いたいんだろ

>>444
痛さ100倍だな。
そうじゃないなら英語使っていいから自分の発言を説明してみれ。
>>450
単なる厨房。

確かに monadは俺もわからん!! >>450
でもそれ以外は Cなんかよりずっとわかりやすいとおもうがな..
pointerなんて architecture知らないとわからんし。
数列の合計とかも、loop変数とかぶん回さなくてもできるし。

俺は型もよくわからん。
型に引数とかあるが、あれはなんなんだ。

>>454
Generic
Template
かなあ。

>>455
素直にポリモルフィズムって言ったほうが
最近のオブジェクト指向に慣れた人には通じるかも。
ただしアドホックじゃなくてパラメトリックなポリモルフィズムだから、
C++でいえばOperator OverloadingじゃなくてTemplateみたいなもの
（のもっと一般的な奴）です。

Parametric Polymorphismは CLUで学んだぞ!!
まあ、Javaにも Genericityが入るみたいだし、マンセーって感じ?

monadってライプニッツのモナコ？＞453

型推論って他の（変数型無しデータ型有りの様な）スクリプト言語に
応用できないの？

>>459
そういう言語は実行時に型の間違いを発見し、コンパイル時には
発見しないので、型推論をする必要が無い。

>コンパイル時には
>発見しない
だから、型推論がどうかって話じゃないの？

>コンパイル時には
>発見しない
だから、型推論はどうかって話じゃないの？

>>460
実行する前に型推論行なって、MLとかと同様にエラー検出ができれば
十分意味があると思うけど。

>>463
それなら意味あるけど、そうなったらもはや型の無い言語じゃないよね。

型推論ってどんな分野の本参照すればわかりますか？
論理関係の本？

>>465
MLの解説本じゃない？

>>466
MLの本ですか。
どっちにしろ図書館ですね

型推論だけなら、webで十分じゃない？

webって Don Knuthの???
あれってそんなのあったっけ???
うーん、それ以外に webってあったか...

なぜにDon Knuth？

文芸的プログラミングか。

>>463
schemeにMLライクな型推論を実装した、
っていうレポート記事は昔見たことあるよ。(英語)
純粋に型チェックに使うのかな？

>>469
webって、インターネットってことだろ。
googleで検索しろよ。

>>473
> webって、インターネットってことだろ。
この言い方も変だなぁ……。
まあ、>>469が変な勘違いしてるようだからしゃーないか……。

プログラミング言語理論への招待 ISBN4-7561-0317-0 5800円
結構高いし、難しい本だけど、
型付きλとか推論関係の内容があった。
まあ、図書館で見掛けたら。

>>475
Mayerさんの本は悪くはないが
どちらかというと広く浅くだし、ちょっと癖が強い。
>>465
基礎理論については
プログラミング言語の基礎理論、大堀淳 著、共立出版
コンピュータサイエンス入門 --- アルゴリズムとプログラミング言語、
大堀淳、ジャック・ガリグ、西村進 著、岩波書店
あたりにはきちんと書いてある。実装まで書いてある本は
日本語ではあんまりないと思う。英語でよければ
Luca Cardelli. Basic polymorphic typechecking
Science of Computer Programming, 8(2): 147-172, 1987.
http://research.microsoft.com/Users/luca/Papers/BasicTypechecking.A4.pdf
にはModula-2だけどコードまで書いてある。
彼も今はMicrosoft Research Labにいるね。

「コンピュータサイエンス入門　アルゴリズムとプログラミング言語」
と
「プログラミング言語ML」
を借りてきました。
ML言語はともかく、型推論の部分はむずかしそうですね。

>465
型理論なら
「モデルと表現」
米沢明憲・柴山悦哉
岩波書店ソフトウェア科学17
http://www.iwanami.co.jp/.BOOKS/01/1/0103570.html
の方が初心者向けで分かりやすいよ。
内容は「コンピュータサイエンス入門」より狭いけど。

>>477
型推論のところなんかちっとも難しくない。
それよりもストラクチャの所が難しい。

MLの考え方を身につけると
JavaやDelphiなどの現実的(?)な言語の
コーディング・設計の仕方が変わってきますか？
またどのように変わりますか？
それとも特に影響される部分はないのでしょうか。

>>480
MLやHaskellに感化され、型推論などの重要性を理解できるようになる
と世界が広がったような気分を満喫できる。それでひとつ目のハードル
がクリアされる。

しかし、それらの言語に特徴的な機能を何とかコーディングで実現しようと
してどつぼにはまって自爆する。

「現実的(?)な言語」では無理してそういうことやらなくて良いんだ、
その分設計に力を入れよ、ということに気が付くようになると
次のハードルをひとつ越したことになる。

型を動的な側面と静的な側面でうまく使い分けることができるように
なれば、更につぎのハードルを越えたといえるんじゃないだろうか。

ちなみに、C++でテンプレートを駆使してどつぼにはまったことがあります。

>>480
一般的な関数型言語は、従来の手続き型言語に比べ
すっきり記述できるので、それに慣れると
ややっこしいコードが理解できなくなります。

MLのおすすめサイト教えて

CやPascalに比べればいろんな概念が取り入れられてるから、
視野はいろいろと広がると思うけど。
別の言語でそれにこだわるとかえってマイナスになるということは
あるよね。郷に入っては郷に従えってことだね。
もちろんプラスとなることもあるだろうけど。

>>483
超初級だが、
http://www.ldl.jaist.ac.jp/lecture/i217/sml-usage.html

何もわからん初心者に関数型言語を最初に教えたらどうなるのかな？

数学知ってれば、Cなんかよりは判りやすいと思う。>486

>>487
いえてるかも。

a = 4;
a = a + 1;

これって数学じゃないしね。

>>483
http://a414s1.it.nanzan-u.ac.jp/smlbook/smlwww/

http://www.gin.or.jp/users/daikoku/ml/default.htm
ここのML講座、txtで700kb近くある。
分割してhtmlにして欲しいね。
あと、MLの入門というよりプログラミングの入門だそうな。

http://www.gin.or.jp/users/daikoku/lang/func/ml.htm

>>487-488
というか、数学のやりかたとCのやりかたの
どっちが「正しい」のか？という悩みに
ぶつかってしまったのだが…。

>>490
'='この記号を先に使ったのは数学。

>>490
a = a + 1 という式から、
今の数学の公理系と同じくらい広く利用できる公理系が作れるならいいけどね。
1 = 1 + 1 も、二進数で + が AND 演算なら成り立つんだし。

まあ、Pascal のように代入記号に等号を使わなければ回避できる。
a := 4
a := a + 1

って成り立たないか。
i.a = 0
0 = 0 & 0
0 = 0 & 1

ii.a = 1
1 = 1 & 1
1 = 1 & 0 ←これがダメだ

>>488-493
安直に考えて
    i = i + 1
とかいうのは、計算のステップごとに添字をつけて、
    i_(n+1) = i_n + 1
とかいうことじゃないだろか。

プログラム上での変数というのは、数学での数列というわけ。

>>494
なるほどすっきりした。
やはり同じ記号を使うのが悪いよなあ。
a <- 4 とか a ← 4 なら見た目からも明らかに代入なのにさ。

hage

Pascalの代入は

i := i + 1

じゃなかったっけ?

>>497

>>492

>>494
でもその考えだと数列の最後の項にどんどん追加することしかできないんじゃない？

ところでConcurrent Cleanって知ってる？
Haskellのように非正格で、さらに優れているのはその名の通りコンカレントってこと。
あとIOはHaskellのモナドに対して
Concurrent Cleanでは、Uniqueness typingというのがサポートしているらしい。
速度も速いってHPには書いてあるけど。

どうよ？

コンカレントって何？

>>500
コンカレントとは並列実行されるっていうことです。

Haskellも並列実行できる気がするんですけどね。どうなんでしょう？

マルチスレッドってこと？

ようは直列されない（？）関数が同時に実行できるって事のようです。

>>500 Uniquness typingの論文読んだことある人いる？
説明してくれ

「polymorphicでUniquenessな型付け」っていったいどういうことなんでしょうかね？

>>499
単なる思いつきなので、実は全く確信をもって言ったわけではないです…。

ところで「最後の項にどんどん追加することしか」というのは
どういうことのことを言ってるんでしょうか？ よくわかりませんでした。
具体的にはどういうのをできないと言っているんでしょうか。

>>494>>508
a_2みたいにn番目にアクセスできないという意味で言いました。こちらも深い意味は無いです。

C や　Pascal みたいな手続き型言語では変数に数学的意味は無いと思います。
メモリの内容を書き換える、という程度でいいでしょう。

>>509
なるほどわかりました。
ありがとうございます。

過去の変数の値にアクセスしたい、というなら、
おっしゃるとおりそれはできないですよね。

> C や　Pascal みたいな手続き型言語では変数に数学的意味は無いと思います。
> メモリの内容を書き換える、という程度でいいでしょう。
いずれにせよ、計算モデルはチューリングマシンとか
RAMとかにいきつくわけですからね。
数学で使われる式とは、出発点が違ってる気がするし、
それとなく方向性も違ってそうなので、
意味はないというのにはなんとなく同感です。

ただ、それらはλ計算のモデルとも同等だとかいう話もあるみたいなんで、
どっかではどうにかしてつながっているでしょうけど。

http://www.sra.co.jp/people/nishis/learning/fpl/index.html

http://www.okilab.com/islisp/

>>512
>LispのISO標準規格ISLISPの処理系
って有名なの？
あと、これのソースって何処にあるかしりませんか？
(なぜかバイナリしか置いてない)

http://www.google.com/search?q=islisp&hl=ja&lr=
有名じゃないみたい。

>islisp
非常にすっきりしているけど、
ある程度ライブラリがたまってからでないとキツイかも。
教育用としては非常にいいと思われますが。

HR/HM板で生まれた最強天然電波少年のページ。
http://salami.2ch.net/test/read.cgi?bbs=hrhm&key=991394303

是非とも全部合わせてご覧あれ。

relational lispって知ってます？
言語比較の論文に出てたけど。

>>513
> あと、これのソースって何処にあるかしりませんか？

http://www.ito.ecei.tohoku.ac.jp/TISL/index_j.html
「これ」の一例、TISLのソースあり。

>>518
ありがとう！
かなり小さいですね。
日本がメインなのが良い感じです。
GUYのCommonLisp->Schemeの縮小思想と似てるかも。

>>519
SchemeはCommonlispよりもだいぶ前だよ．

age

(たしか)最初のSchemeは75年、
CommonLispは80年前半から。

a.g.e.

age

任意の言語から呼び出せる関数型言語コンポーネントがあればいいのに。
入出力等、副作用を伴う処理は関数型言語の苦手とするところだから、
そういう汚れ仕事は伝統的な言語に任せて、本質的な処理だけを担当す
るライブラリの構築を関数型言語が担当するという役割分担はできない
もんでしょうかね。

libguileがあるじゃん?

libguileか...なるほど、いいですね。ちょっと研究してみます。

何故か、少々気になっているHaskellを勉強してみようかなと
思っておりますが、何か始めるに当たってアドバイスなんぞありますか?
参考サイトURLをぺたっ、でもOKです。

>>528
Programming in Haskell(日本語)
http://www.sampou.org/haskell/

どもです。
どうでもいいのでsageますが、
Lispを書くのにvim6がいいと思っておりますがいかがでしょう?
Syntax Highlightあるし、%でカッコジャンプできるし。
まぁemacsでも実現できるのでしょうが。

>>530
vim6とemacsと両方試してみて、気に入った方を継続的に
使えば良いと思います。もっとも、僕ならLISPを書くとき
にはemacsですけどね。

Haskell専用スレがあってもいいと思う方、
挙手をお願いいたします。

はい

けど、今たててもpiza止まっちゃうので、
復旧後にでもたてましょうか。

Haskellの入門的文書で、一番分かりやすいのはこれじゃないかな？
www.teu.ac.jp/kougi/koshida/Prog6/index.html

>>532 ハイ、お願い致します。

http://piza2.2ch.net/test/read.cgi?bbs=tech&key=996131288
関数型プログラミング言語Haskell

>>535
良さそうですね。

関数型言語旋風起こるか?age

それが言われたのって５年ぐらい前だった気がする。>539

いま、ナウなヤングの間で関数型言語がひそかなブームだﾖ！

イカすね。・￥

ｲｴｲ

米国ではMITやら何やらでガンガンLisper育てているせいもあり、
Lispは実用的な土台をもっているらしいですね。
日本は手続き型言語ばかりで関数型言語を習得していない人が多いので
関数型言語は話題になりにくいし、企業でも導入事例は少ないそうで。
hmm...　慣れの問題なのかな?
それだけじゃ無いような気もするけど、よぉわからん。

簡単なlisp勉強中。
ところで、これでＦＦみたいなゲーム作ってみたいんですけど可能でしょうか？
あと、書けたとしてオブジェクト指向言語より楽になるんでしょうか？
ネタのようですがネタではないです。マジレスお願いします。
＞lisperの皆さん

ハガーか。懐かしいな。

FFXだったら動画用意すればVBでも作れそうだね。

lispだけだと遅いんじゃん？
コンパイルでネイティブコード直接吐く様な処理系なら違うだろうけど。

>545
作れるよ

わぉ。マジレスさんくすです。
>547 FFXってVBでも作れるんですか…すごいっすねVB
>548 lispは比較的遅い言語らしいですね ネックになるかな
>549 簡潔なレスサンクスです
Cでも書けそうですけどどちらが向いてるんでしょうか…。

>>550
あーいうのは言語そのものよりも、用意された環境とか
ライブラリの質／量が開発期間に影響すると思うけど。

>>550
> Cでも書けそうですけどどちらが向いてるんでしょうか…。

実行速度が要求される所は、C/C++で書いて、
ストーリーを司る所はLispなどのinterpreterで開発せよ。

少しだけ読み進みました。dotimes とか…先は長いです。
>551 そうですね。絵や音を出すにも結構苦労しています。
　　　ちょろっと書いてみてプログラムは動き出すまでが
　　　難しいと思いました。必要なものが本当に多いですよね。
>552 適材適所ですね! ありがとうございます、
　　　全体像が見えてきました。おぼろげな感じですが…。

自己レスですが、kawaを使うことに決定。javaからkawaで作ったクラスを
呼び出すことも、kawaからjavaで作ったクラスを呼び出すこともできて便
利。ポータブルだしね。

a.g.e.

>>554
javaの上にlisp(scheme)って、とても遅そうなんですけど
実際どうでしょうか。現実的ですか？

>>556
起動は遅いけど、実際の動作は別に遅くないです。
バイトコードにコンパイルもできるし。

age

参考になりました。

C言語とかも、
関数型言語みたいに、デバッガ上でいきなり関数を呼び出して
関数のテストが出来たらいいのに…

デバッグしやすさ的に、
1位：関数型言語
2位：XPのユニットテスト
3位：デバッガでちまちま

かなりボロクソに言われそうな無いようですが、意見求む。

C言語の場合、関数は副作用を持つことが多いので、関数単独で
動作テストできない場合が多いんじゃないか、と。

UnitTestは非常にテストコードを書きやすかったよ。
setup()で対象クラスを生成して、
各メソッドごとのテストコードを書く。
入力と、望むべき出力を書いて、
一致すればOK、ダメなら何処がダメかが出力される。
一度テストコードを書けば、その後が楽なあたりは
関数型言語の関数を一つ一つテストするのよりは楽かと。

UnitTestの有用さは認めるけど（俺も使ってるから）、
エラーになりそうな入力を考えないといけないし、
すべてのパターンを網羅的にチェックできるわけじゃないから、
本当の意味でエラーフリーであることは保証されない。
その点、強い型付けのある関数型言語は、かなり有利じゃないか、
と思いますが。

Smalltallkはデバッガの中でメソッドのテストも変数の中身の変更も
メソッドの定義修正もなんでもできるよ

Smalltalkって何かカコイイイメージがあるなぁ。

>>565
統合環境型Lisp - 関数型 + 手続き型 + OO → Smalltalk

Xeroxのworkstationは、同じVMの上でsmalltalkとInterlisp-Dのどちらも動きました。

>>562
判ってないね
ちみは

>>567 何だチミは。

開発手法野郎たちってすぐ揉めるよな。関数型言語の話しようぜ。

昔、論理型や関数型は機能推論によるdebugの研究が行なわれた頃があったけど、
ああいう研究って最近はどうなっているの?

// Wordアプリ
main(){ print("Debug me!\n"); }

これ自動デバッグしたらWordになっちゃうのか？

今年の ICFP Programming Contest で Haskell を使ったチームが優勝したようだ。

http://cristal.inria.fr/ICFP2001/prog-contest/

課題:
http://cristal.inria.fr/ICFP2001/prog-contest/task.html

1st prize. 使用言語 Haskell, プログラム名 LALR(5000000), チーム名 Haskell Carrot
　http://cristal.inria.fr/ICFP2001/prog-contest/entries/121.tar.gz
　http://www.digitas.harvard.edu/usemod/bin/wiki?IcfpProgrammingContest

2nd prize. 使用言語 Dylan, プログラム名 Dylan Hackers,チーム名 Dylan Hackers
　http://cristal.inria.fr/ICFP2001/prog-contest/entries/249.tgz
　http://www.hoult.org/~bruce/dylan-hackers.html

Judge's special prize.
　　　　　使用言語 Erlang, プログラム名 Erlightning, チーム名 Blue Avengers
　http://cristal.inria.fr/ICFP2001/prog-contest/entries/024.tar
　http://www.bluetail.com/~luke/icfp2001/

3rd place. 使用言語 Objective Caml, プログラム名 runme, チーム名 [B8]_clan
　http://cristal.inria.fr/ICFP2001/prog-contest/entries/140.tar.gz
　http://pauillac.inria.fr/b8/

3rd place. 使用言語 C, プログラム名 ElegantBlob, チーム名 BlobMakers
　http://cristal.inria.fr/ICFP2001/prog-contest/entries/177.tar.gz
　http://www.cse.unsw.edu.au/~kchan/icfp/

>>571
dylanのソースって読みやすそうだね

>>572
Dylanって確かsyntaxが二つあって最初はLisp風だったのが
受けが悪くて普通っぽいのも用意したのではなかったかな？

schemeとdylanの構文の対応表みたいなの見つけました
http://www.cs.indiana.edu/hyplan/jsobel/forschemers.html

俺もdylanは好きだけど、コンパイル遅すぎ。
コンパイルの早いdylanがあれば、仕事のメインをdylanにしたいけどさー。

みんなよくこんなマイナー言語知ってるよなぁ〜て
感心するね

>>571
なんでオブジェクト指向も出来ないHaskellが一位なんだ。
きっとRubyやSmalltalkのチームは出場してないんだろう。
Cごときが3位に入ってるし。きっと低レベルなコンテストに違いない。

>>577
Haskell スレにも居た人っぽいなぁ。

オブジェクト指向言語と関数型言語、
どっちが優れてるかという議論をしたいのだろうなぁ。

つーか、オブジェクト指向がどれだけ優れているかを
主張したいのだろうなぁ。

というよりなんでSMLがC言語に負けてるんだ。

>>580
だって、言語コンテストじゃないもの。

>>577
じゃあ、RubyやSmalktal使って書いみて、あまりの素晴らしさに驚かしてくれ。

ContestでHaskell使った人達はきっとラムダ計算とかモナディックスタイルだ
とかの理論を学んだ頭の良い人たちだったのでは。

>>583の意図がわからん。

http://cristal.inria.fr/ICFP2001/prog-contest/
Although the precise task chosen will not be revealed until the
contest begins, correctness, algorithmic cleverness, and performance
will matter. Programming languages that help programmers to build
complex systems quickly may allow contestants to attempt particularly
sophisticated implementations in the 72 hours allotted for
programming.

だから、頭いい方とその分だけ有利ってことじゃないかな?
"correctness, algorithmic cleverness"あたり。
Algorithmのcorrectnessの記述、普段もやる人多いし。

つーか
> ラムダ計算とかモナディックスタイルだとかの理論
などを勉強するのは頭がよい人ってのは偏見だろう。

いや、統計的に見て理論を勉強してる奴の方がしてない奴より頭が良いだろう。

>>586
俺は知らないけど、その理論が難しいんでしょ。

手続き型の発想
1. 器を用意する
2. 器に代入 ← なにか計算した結果
3. 器を引数に手続き呼び出し

関数型の発想
(手続きを呼び出す
　(引数として　計算をここでしちゃう))

非常におおざっぱだけど、こんな感じ？

>>589
君の理解だと、どこが関数型のメリットなの？

単にコードに表れるうわっつらの特徴を書いてみたんだけど。

>>591
勉強する気あるの？　それとも荒らし？

kawaはJavaによるSchemeの実現だけど、
Javaで実現されたMLとかHaskelとかってないかなあ。
SchemeはSchemeで面白いんだけど、型システムのある
関数型言語がほしい場合もあるんで。

>勉強する気あるの？

それは>>589の比較が的外れだという意味？
うわっつらの特徴を比較することで理解に近付きたいと思ってるんだけど。

>>594
勉強する気があるんだね。
だったら答えるけど、>>589の比較では関数型言語と
手続き型言語の違いが浮かび上がってこないね。

関数型言語の特徴をごくおおざっぱに言えば、
・変数の値が変化しない
・関数を引数として渡せる
ってところだよね。

(if (arashi-p situmon)
　　(houchi situmon)
　　(maji-resu situmon))

(define eval-question
　(lambda (q)
　　(cond
　　　((null? q) '())
　　　((arashi? (car q)) (eval-question (cdr q)))
(else (append (maji-resu (car q)) (eval-question (cdr q))))))))

覚えるならMathematicaがいいなと思うんだけどどうよ？

>・関数を引数として渡せる
これは違うと思うよ。Cだって関数ポインタ渡せる。
一番違うのは関数型においては関数に対していろいろな演算が出来ること。

>>599
同意。
C でも関数ポインタなら返せるが、既存の関数へのポインタだけだもんな。

>>577
このページを見てみましょう。
http://cristal.inria.fr/ICFP2001/prog-contest/results-elim/

Smalltalk, Ruby, SML, Java, Tcl, Perl, Python,
Scheme, Common Lisp, C++, Eiffel, Pascal
等を使ったチームも参加していることが分かります。

> The Pain Of C++
チーム名ワラタ

>>601
Haskellを使ったチームが11チーム。
それに対してRubyを使ったチームは1チーム。
Smalltalkは2チーム、Schemeは6チーム、SMLは7チーム。
つまり、RubyよりHaskellの方が11倍有利だったということ。
C++は19チームもいるから救いようが無いけど。

Cに関数ポインタがあるのは知っているけど、
あれって実行時性能を確保することを目的と
したトリッキーなテクニックのために存在し
ているのであって、アルゴリズムをより的確
に表現するためのものではない、と思ってい
ます（違っていたらスマン）。

関数型言語における高階関数は本質的で欠く
ことの出来ないものだと理解していますが、
おかしな理解ですかね？

>>601
しっかし、これ見るとocamlって言語が多いなあ。
そんなに人気がある言語なのかねぇ。

モロ、無修正画像サイト発見！

http://www.sex-jp.net/dh/01/
http://www.sex-jp.net/dh/02/
http://www.sex-jp.net/dh/03/
http://www.sex-jp.net/dh/04/

>>604
えー、流れ的に、>>595さんですよね？（違ってたらすまん）

あなたの理解で間違ってないだろうけど、
> ・関数を引数として渡せる
って表現が適切じゃなかっただけかと。

>>601
なんか、Shell と Python の成績がいいのか？

>>605
INRIAが主催しているからと思われ。
（CamlはINRIAが開発した言語だからね、授業で使ってるんでしょ）

>>608
成績は>>571

>>604
Cのqsort()みたいな使い方は、実効性能目的というより
高階関数的だ、というのは理解を間違っているかな？

>611
Lispのラムダ式の代わりみたいなもんか。

>>612
ん？違うだろ？

>>611
だな。

Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java
Ruby >>>>>>>>>>>>>>>> Java

問.1
>>>>>>>>>>>>>>>>は何演算子でしょう？

Rubyの人はなんでそんなに優れてることを主張したいんだろ。
言語仕様のオタクぶりが売りだけど所詮ひとりのアマチュアが作った言語仕様。
HaskellやOcamlを作った言語研究のプロのオタクぶりに勝てるわけが無い。

>>616
って、価値基準はオタク度なのか？そーなのか！？

Rubyの優位性を主張してる人なんてそんなにいるか？
JavaやC++,Cまんせーな人に比べたら遥かに数少ないでしょ。

あと、まつもと氏はRuby関係の仕事をすることで給料をもらっているので
アマチュアではないです。
まぁ、言語研究のプロではないのかもしれないけどね。

俺は関数型言語も好きだけど、
Rubyもこよなく愛しているよ。
I/O処理が多いプログラムを作ろうとすると、
慣れのせいなんだろうけど、関数型言語は疲れる。

>>619
俺も。それにrubyは関数型言語的な
処理も得意だしね。

高階関数は、引数に関数をもつ、あるいは値として関数を返す関数

ということで合ってますか？

>>621
yes.

Ruby って無名関数あるの？

>>623
あるよ。perlにもある。

>>624
じゃあ、関数合成とかできるのけ？

>>625
できるよ。

>>603
>Ruby より Haskell の方が 11 倍有利だった

Dylan チーム、Erlang チーム ( Lightning でエントリー )
も 1 チームしか参加していないが。

Ruby チームは第一ラウンドを通過していない所をみると、
メンバーに恵まれなかったのだろう。
来年あたり Ruby ユーザーに参加をけしかけるのも面白いかも。

>>605
>ocaml 多い

609 の書いているように 今回は INRIA が主催したということに加えて、
他の関数型言語に比べで実行速度が全般的に速いからじゃないだろうか。
既出だと思うが、下のページを見てみると、
仮想マシンコードでもまあまあの速度。
ネイティブコンパイルすると、随分速くなるようだ。
http://www.bagley.org/~doug/shootout/

参考までに、去年は ocaml を使ったチームが 1, 2 位。
( ただし参加チームが 38 と少ない )
http://www.cs.cornell.edu/icfp/contest_results.htm

Haskellの一番の特徴は強力な型システムと、型によるパターンマッチングで
しょう。これにより直接的な表現を可能にする。
一方Rubyは型の無い言語であって、方向性が全く違うと思う。

>>628
rubyに型はない、ってのはちょっと語弊があるんでわ？
変数に型がないので任意のオブジェクトをバインドできる
けど、オブジェクト自体はいずれかのクラスのインスタン
スだから、動的に型チェックすることはできるじゃない。

もっともHaskellの強力な型システムとは比較するべくも
ないので、それには同意。

>>620
rubyは末尾再帰展開してくれたりはしないので、
関数型とはいい難い。

>>630
rubyを関数型言語とは言い難いのは同意だけど、
末尾再起を繰り返しに展開するかどうかは関数型
言語か否かを決定する要因なの？

# 効率上、重大な問題だということは認める。

Cだってtail recursionをloopに展開するづら。
gcc -O4とかやってみれ >>630

>>629
つーか、今時はそういうのを型なしの言語というんだべ。例えばLisp。

>>632
標準仕様じゃねーだろ
ここで処理系依存の機能持ち出されてモナー

>>631
関数型はループに相当する処理を再帰で書くのが普通。
言語によってはヘタレな人の為にループ構文を専用に用意したりしてるけど。

OOPするときは、俺の場合、どうしても動的な型付けがほしくなる。
関数型言語のときは、静的な型付けの方がしっくりくる（けど、Schemeも好き）。
なぜかしらん？

>>626
知らないから検索してみたけど関数合成って
ttp://www.teu.ac.jp/kougi/koshida/Prog6/Text08/
みたいなことを言うんでしょ？
Rubyでどうやるの。無理じゃない？

>>637
なるへそ。たしかに無理ですね。結果として同じことが実現できるだけでは
不十分ですね。スマソ。

しかし、だとするとSchemeは関数型言語としてはダメダメってこと？
関数合成できないし...

>>639
え？
関数合成はできるだろ？

>>640
how?

>>637で紹介されているドキュメントによれば、
関数合成用の演算子が重要だということになる
んだが。

# もしかして、俺の理解がダメダメなだけ？

>>641
(define (comp f g)
(lambda (x) (f (g x)))

これでいかんのか？
とりあえず、Haskell でもやってることは同じだぞ。

>>637-638
Ruby 知らないのでアレなんだが…
> 結果として同じことが実現できるだけでは不十分ですね。
十分じゃないの？

>>634
さらに意味が分からん。
Semanticsにtail jumpが、あたかもschemeのように、入っていたら関数型なのか?

ループ用の構文が全く必要ないって所があるんでは＞643
schemeではループ用にdo文を用意してるけど、本当は必要ないし。
(syntax-sugarとしてもあまり意味ない。lispとの互換性？)

>>642 の comp を Ruby で書くとするとどうなるの？＞識者

def comp(f,g,x)
　f.call(g.call(x))
end

>>643
末尾再帰をループに展開するかどうかは関数型かどうかの判断基準には
ならないけど、関数型言語は再帰を多用するので末尾再帰をループに展
開しないとしたら、誉められた実装とは言えない。

# 末尾再帰になっているかどうかを判断できない処理系があるとすると、
# 関数型言語としては不満の残る実装だということ。

関数型言語ってのは、つまるところ「副作用のない言語」ってところに
尽きると思う。入出力その他のために副作用は完全にはなくせないんだ
けど、副作用を基本にしている手続き型言語とは一線を画しているのは
間違いないところだと思う。

Scheme や Ruby の comp の例って、引数や返値の静的な型チェックはできないよね。

あと複数の値を引数にとる関数同士の合成ってできるもの？
CommonLispなんかは多値を返す関数とか書けるみたいだけど。

>>648
>Scheme や Ruby の comp の例って、引数や返値の静的な型チェックはできないよね。

SchemeやRubyは静的な型チェック自体がないからねえ。

>あと複数の値を引数にとる関数同士の合成ってできるもの？

別に引数の個数は問題にならないと思うけど。

>CommonLispなんかは多値を返す関数とか書けるみたいだけど。

SchemeやRubyは多値を返す関数を書ける。

>>649
Schemeは知らんけどRubyにmultiple-valueあったっけ？

>650
多値返すにはarrayを使う。
普通arrayを多値とは言わないけど。

Rubyは関数fがあったとき、a=fとかできないのが嫌だった。

関数fをクロージャとして変数aにバインドするには、rubyでは
次のように書きます。

a = method('f')

ちょっと変だけど、使いにくいほどじゃないでしょ。

>>646
それって微妙に違わない？
合成するときに x を渡さず
保留することってできるの？

スマン、表現がまずかった。

>>654のやつは関数を返すの？

スマン、>>654じゃなくて>>646

ていうか、>>646のはそのままだと、関数を返す分けないか…。

すまん。そうか、関数を返すんだっけ。

def comp(f,g)
　lambda{|x| f.call(g.call(x))}
end

def comp(f,g)
　lambda{|x| f.call(g.call(x))}
end

f = lambda{|x| x * 2}

g = lambda{|x| x * x}

p comp(f, g)
p comp(f, g).call(1)

こんなんでどう？

どうってｲﾜﾚﾃﾓﾅｰ…

ruby使いがなんでこんなところに？

>>653
しかしそれでは関数fがオブジェクトって感じがしない。

a

>>661
オブジェクト指向言語を温めて関数型言語を知る

>>661
どうでもいいけど
sicp 読んでる人には ruby もやってる人が多い模様。
http://www.amazon.co.jp/exec/obidos/ASIN/489471163X/ref=sr_aps_d_1_1/249-0272495-6600319

どっちも言語仕様を重視してる点では一緒か。

>>666

Rubyはクソです。ゴミ箱逝きです。

いじょ
この発言をコピペしていただければ幸いです。

#! /usr/bin/env perl
## compound.pl

use strict;

my $f = sub { $_[0] * 2 };
my $g = sub { $_[0] * $_[0] };

sub compound ($$) { my ($f, $g) = @_; sub { $f->( $g->($_[0]) ) } }

my $fg = compound($f, $g);

print $fg->(5) ."\n";
print compound($f, $g)->(5) ."\n";

>>650-651
配列と別に多値はあるよ。配列の s-value は m-value に展開されるが。
もちろん m-value を配列で受けたり、配列を複数引数に展開して渡すこともできる。

―――――――――――――――――――――――
それでは次のコーナーです
＿＿　　＿＿＿＿＿_＿＿＿＿＿＿＿＿＿＿＿＿＿＿
　 　 .|／　　 ‖　　 　　 ‖　＿＿＿＿　　　
　　　　　　　 ‖　　 　　 ‖　| ON AIR.|
　　　∧ ∧　θ　　　　　‖　￣￣￣￣
　　 （,,ﾟДﾟ）__　／[]￣￣θΛ＿Λ
　　||（.　 つ_/　　　　／／（´∀｀　)／| 　
　　┗┳ ／　　　　 ￣／⊂　　　 ||_／
　　　 ┻|￣￣￣￣￣|　 （　 ━┳┛　 　　 　
　　 　　 |＿＿＿＿＿| ／ヽ｣┘┻
＿＿＿＿＿＿＿＿＿＿＿＿|＼＿＿＿＿

「Rubyはクソです。ゴミ箱逝きです。 いじょ 」
この発言をコピペしていただければ幸いです。

irb(main):001:0> def add1(arg1,arg2) return arg1+1, arg2+1 end
nil
irb(main):002:0> p add1( add1(10,10) )
ArgumentError: wrong # of arguments(1 for 2)
(irb):2:in `add1'
(irb):2:in `irb_binding'

だめじゃん。関数合成どころか…

IBMのdeveloperWorksでPythonでの関数プログラミングっていうのをやってて
http://www-6.ibm.com/jp/developerworks/linux/010615/j_l-prog.html

関数的な echo ループとか例がある

def monadic_print(x):
    print x
    return x

echo_FP = lambda: monadic_print(raw_input("FP -- "))=='quit' or echo_FP()
echo_FP()

おもろい？

今読み始めた。
訳が面白い。

> 関数が最初のクラス (オブジェクト) である。

>>671

えーとですねえ、多値を返すメソッドは、言わば「任意個」の値を返すメソッド
と同義なんですよ。ですから>>671でのメソッド定義では駄目で、

def add(*arg)
　arg.map(){|x| x += 1 }
end

みたいに定義しないと。

age

>>674
それは多値じゃないねぇ。

>>671-676
rubyでは多値は扱えない。
それでいいじゃん。
元々そんなに多用する機能でもないし。

関数が多言語age

SMLいれたけど、コンパイルのやり方がわかりません。
コマンドラインでsml、と打つと対話型インタープリタ
が立ち上がってしまうのですが。

それはインタプリタではなくインクリメンタルコンパイラです．
ソースを読み込んだらexportMLでダンプして実行可能オブジェクトを作るのです．

あ、どーも。
- exportML "dmp.obj";
stdIn:1.1-2.4 Error: unbound variable or constructor: exportML

とかなりましたが、ちょいとgoogleで調べた所、

SMLofNJ.exportML
で私の環境ではよさげでした。どうも。
これでちょこちょこ遊んでみます。

まとめあげ

新しい関数型言語って無いの？

>>683
意味わかんねぇ。
新しいって何?

小学校とかでエクセル教えるくらいなら、関数型言語のどれかを
柔らかい頭に叩き込む方がいいね。小学生に職業訓練したって
しょうがないと思うんだけど。文部省の人間はバカか？
それとも教えられる人間がいないのかな？

そもそもソロバン＝計算機と考えて、それじゃあIT革命に乗じて
そろばんの代わりにエクセルを学校で教えようとか考えてるのが、
あほくさい。やっぱり役所ってだめだな。

関数型言語を学ぶには、まず、数学における関数の知識が必須と思われ。
小学生はもちろん、高校生でも怪しいと思われ。

sagarisugi!!!

小学校で論理学の勉強するの？>686

ソロバンを電卓と同等に考えてる時点で逝ってよし＞文部省

役人はコンピュータサイエンスという学問の存在すら知らないと思われ。
暗記試験で良い点とることが勉強だと思っとるからな。

tail recursionでメモリを食うようだと…
非常に多い回数まわるループ（含無限ループ）を書くのに
goto（または同等品）＋代入が要ると思われ。
それで関数型言語って呼べるかって事では？
亀レスすまそ

>>691
MLのwhileループはtail recursionだが、
メモリを食わないことが保証されてる。

Schemeもtail recursionではメモリを
消費しない。

Haskellもtop-level CAFのような例外
を除けば同じく。

Lispはそうでない。

pure functional…Haskell, Miranda, ...
impure functional…Scheme, ML, ...
Lispはどちらでもない。

結構関数型言語に関するスレが建ったね。
ここ、Scheme, Haskell, ML, LISP＠マ板
くらいかな。
最近Haskellいぢってないなぁ…

O brave new world,
That has such people in't!

Zﾏﾝｾｰ

買った人いるかい？
http://kyoritsu-pub.topica.ne.jp/shinkan/shin0109_05.html

おお、SML97の解説が日本語で読めるんだね。うれしー。

素晴らしい！

http://www.jaist.ac.jp/~ohori/mltext.html

ML スレにもでてたね。

でも、もう一つのML本と比べてなにか違うの？

>>700
比較対象を持って書かれたということ

age

http://slashdot.jp/comments.pl?sid=01%2F10%2F27%2F1048251&cid=63&pid=63&startat=&threshold=0&mode=nested&commentsort=0&op=%CA%D1%B9%B9

プログラミング言語 ML の評判は悪いらしい。

>>703
なんか誤解されそうな文だな。
そういう題名の本が評判悪いのね。
ML自体は悪くない。

Working Programmerはなんで翻訳されないんだろう？
こんなの読む人は大抵は英語ができるからかな？

>>704
うわ、さっぱり気づかなかった…
スマソ

http://groups.google.com/groups?num=25&hl=ja&group=fj.comp.lang.functional&start=0&group=fj.comp.lang.functional
いきなり1999年…悲

Intelはsuperscalerに見切りをつけたと思ったら、
VLIWの幅を増やすのもさっさと見切って、
これからはマルチスレッドだと逝ってるみたいですね。
マルチスレッド化すると1.3倍速くなるとか（中途半端な）…

もう手続き型言語から抽出できる命令レベルの並列性は
限界に来たのかなという気がします。

関数型言語の利点に、副作用がないので並列化しやすい
というのがあると思うのですが、関数型言語で書くと
並列度はやっぱり上がるんでしょうかね？
その場合、lazyな言語よりMLとかの方が並列化しやすい
気がするんだけど…（だって、前もってやっちゃうと
lazyで無くなるから…）

>>708
lazy ってのは
評価されてない部分があっても、
それが評価されている必要が無いのなら
先に進んでよい
って話なので、別に必要が無いものを前もって計算したからって
問題はないと思うが。

これ試した人いる？
http://research.microsoft.com/projects/ilx/index.htm

>>709
そうなのかな。
例えば
myIf :: Bool->a->a->a
myIf True x y = x
myIf False x y = y

で、述語を評価する前にxやyを評価したら、
本来起きないエラーが起きたりしない?

>>710
関数型言語とどういう関係があるの？

>>686
U.S.A では12才でScheme おしえてるって知ってた？
それより若い子は、LOGOをやらせてるってしってた？

どうせ関数型も何もないような基礎の基礎やってハイ終りでしょ。

おれも小４クラスにLogo教えたことある。
Schemeは無いが、中学生たちにProlog教えたことならある。
別に問題はなかったよ。

JavaやHTMLを教える中学校の話。即戦力養成って感じだ。
思考の柔軟性を養うには関数型言語がいいと思うね。
http://www.hotwired.co.jp/news/news/culture/story/20010627204.html

>>710
これって関数言語用にILを拡張するっていうものだろ。
直接は関係ないな。

>>711
その例に関しては、Haskell ならなんの問題もないと思うが。
というか、ML なんかのほうが副作用とかあるし、並列化しにくいのでは。

数学の教科書に行番号BASICを載せてる時点でどうかと思う。
>>686
＞小学生はもちろん、高校生でも怪しいと思われ
関数はそれほど高度な概念ではないのではないかと思われ。
数学でいう関数が厳密にどういうものを指すかは知らないけど、関数型言語を使うためのものなら、
その言語を使っているうちに覚えますよ。（schemeしか知りません）
>>714
時間を多めに割かないとそうなって終わりでしょうね。
（lambdaが出ないうちに終わっちゃったりして……それはないか）

>>713
それって、ごく一部の話でしょ。
アメリカって州ごとに教育制度が全然違ってたりするし。

>>719
Little Schemerあたりが関数型言語（っちゅうか再帰処理）の入門書としては
もっとも良く書けていると思うけれど、
きっと大学生でもわからん奴
（数学的センスのない奴、抽象化が苦手な奴）は、けっこういると思う。

いわんやHaskelをや。

俺理系の大学生だけど、その分からんやつかも。
解説読むより先にソース打ち込んで実際実行するか自分で書いてみた方が分かりやすい。
そういうのやった後なら、それ関係の抽象的な話も分かるようになるんだけどなー。
(「ああ、あのこと言ってるのね」って）
数学的センスあるやつって読んだだけで分かるの？

アメリカ人の書いた本て、説明がしつこくねちっこく書いてあるよね（藁

偶像崇拝禁止の宗教を信仰している方が
なんとなく抽象的なものを理解するのが
早そうとかいってみる。

数学(基礎論)が少し分かるようになった。ｳﾚｼｰ!!

んー、じゃあペアノ算術の完全性あたりから行こうか。

おお！そんなものがあるのか？それはCOMベース？
ちなみにCMPもそこそこの性能は出るよ。巷で言われるほど悪くはない。
146はどうせ雑誌か何かで読んだ知識を鵜呑みにしているだけだろう。
そうでなければCMPに挑戦して挫折したのか？

いずれにせよスレ違いなのでsageておこう。

禿らしく提げ

>>721
＞（数学的センスのない奴、抽象化が苦手な奴）は、けっこういると思う。
やっぱり苦手な人は苦手ですよねぇ……。
それに、高校までの数学とは違うものですし（言ってみれば、必要の無いこと）。
「総合的学習」の選択科目のひとつになるのが精一杯、といったところかも。

>>722
その方法は自分にとって分かりやすい、という方法が自分でわかっているなら、
「分からんやつ」でもないのでは？
自分で何かをしたり（この場合はソースを打ち込んだり）するのは、こういったことを
理解するための効果的な方法の一つではないかと思います。
……少なくとも、本を読んで覚えようとするよりは。

（読んだだけで分かる人がうらやましい）

CommonLispでお薦めの本ってなにかありますか?
リスト遊びで終わるような本ではなく、
出来れば実用的なコンソールアプリが作れる程度まで書かれていれば
うれしいのですが。

>>730
まだ見てないけど、この本がちょっと気になる。
http://www.amazon.co.jp/exec/obidos/ASIN/4756139264/

関数型言語、密かなブーム到来ですか？ｗ
自分は業務系のJava屋ですが興味があります。

>>730
岩波のCommon Lisp入門はいいと思う。
サンプルではテキストエディタのコードが載ってた。

>>731
それMacの奴だよ。
最初のほうはlisp全般だが、
後ろのほうは、Macのlispプロセッサが必要な奴。

>>731
面白そうなんですけど、>>734さんの言うとおり
Mac用というのが微妙に気になりますね…
とりあえず、岩波の方を探してみます。

>>731のを立ち読みしてみました。
MacCommonLispがうらやましくなりました。
終わり。

密かにGCL for Winのインストールに躓いてる。
いちおうREADMEの通りにやっているつもりだけど、
WARNING: No installation directory specified.
Please try: C:\UNIX\cygwin\usr\local\lib\clisp\lisp.exe -B /usr/local/lib/clisp
が出てしまう。
まずはPlease tryとか言われているやつをやってみればいいのかな?

っていうか、やっぱプログラミングするんだったらUNIX系OSじゃないとだるいね。

/cygdrive/c/UNIX ... って指定してもだめ？

>>737
ところでGCLはバージョンいくつのつかってますか？

Cygwin経由ではなく、Winのコンソール上からだと
うまくインストールできました。
lisp.exeへのショートカットを作成し、そこのプロパティに
C:\UNIX\cygwin\usr\local\lib\clisp\lisp.exe -B /usr/local/lib/clisp -M meminit
(-M meminitは前も試した)と書いて実行すればOKでした。
けど、Cygwin経由からはうまくいかず。
ちなみに、バージョンは最新のを持ってきたはずです。

ごめん、CLISPでした。
逝ってきます。

亀レス
>>711
strictな引数だけspeculativeな計算をしてよい。
だから、strictness解析すればやっていいかどうか分かる。

f x ↑ z = ↑である時に、fの第二引数はstrictであるという。
↑は、「停止しない」式とか「副作用のある」式と思ってください。(やりたい解析による)
-- 式というか、semantic domain上のbottomと呼ばれる値。

myIfは第一引数だけstrict。

>>742
ですよね。いかにHaskellでも、本来_Lが出てこないものが_Lになるような
投機的実行をしたらまずいですよね。

ところで do if P then putChar 'A' else getChar
なんてのはどうなんでしょ？

>>737
どうもCommonLispの一番メジャーな処理系はCLispらしいですね。
gclは古いしcygwinじゃ厳しそうなので諦めました。対応はしてる
みたいだけど。

まさみさまマンセーな俺としては、GCLが portableな
なかではいいと思ってたんだが...
CLispは compilerなかったようだし。
Portabilityに欠けるなら CMU CLがよかったような。

でも win環境ならいろんなところの Lispの評価版が
もらえないか? Allegloとか。

MCLはなつかしいねえ.. あの木のアイコン...

>>737
cygwinでコンパイルできた？
おれ、コンパイルエラーが山のようにでるよ。
cygwinは1.3.3です。

>>745
> CLispは compilerなかったようだし。
あるよ。Win版でもあるかどうか知らんけど。
http://clisp.sourceforge.net/resources.html

> まさみさまマンセーな俺としては、GCLが portableな
> なかではいいと思ってたんだが...
ISLISPじゃなくていいのか?

746　自己レス
おれのはこれと同じだった
http://sources.redhat.com/ml/cygwin/2001-09/msg01333.html
とりあえず手で書き直してやるかな。

ML2000情報ｷﾎﾞｰﾝ
立ち消え？

GCLよりもCLISPの方がいいのかな?
湯淺先生ファンなので前者を使いたい気分だが。
先生はリアルタイム処理用のGCを開発(完了?)しているらしいね。

言語の意味を数学的に記述するための勉強をしたいのですが、
どんな本を読んだらいいんでしょうか？
何かお勧めの本があれば教えて下さい。

ソフトウエア科学のための論理学 萩谷昌己 岩波講座ソフトウエア科学11
計算モデルの基礎理論 井田哲雄 岩波講座ソフトウエア科学12
プログラムの基礎理論 佐藤雅彦、桜井貴文 岩波講座ソフトウエア科学13

>>752
先生！どれも在庫がないみたいです！ｗ
仕方がないので明日仕事帰りに
明倫書店に言って探してきます。
ありがとうございました。

「プログラム意味論」, 横内寛文, 共立出版, 1994
「情報科学における論理」, 小野寛晰, 日本評論社, 1994
「計算論」, 高橋正子, 近代科学社, 1991

http://www.amazon.co.jp/exec/obidos/ASIN/4588000063/

>>755
ヲイヲイ。

>>754
ありがとうございます。
この手の本って最近出版されたもので
いいものってないんですかね。
ヘルプをプリントアウトしたような
ものが今は売れるからマニアックな
本は刷らないのかもしれませんね。
図書館から借りるのがベストかな。

>>755
自然言語ではなくて計算機用の言語に
関する本が読みたいです。

数理論理学の本>757

http://pc.2ch.net/test/read.cgi/tech/996131288/118
ガンバレYO！

>>757
いいじゃないか、基礎から学ぶんだから、1990年代で十分だよ。

自然演繹とか理論関係の本

>>760
同意。

極端な例だが、幾何学や解析学を基礎から学びたいなら１０年や２０年
古くてもあまり関係ないだろう。それと同じ。

これはまだ売ってるし90年代的でもある良書。
http://www.sra.co.jp/people/katsu/review/intro_theory
この本に挙げられている参考文献は今じゃWebで読めるものも
あるから一冊と言えばこれを薦めるな。

>>763
でもこれ、説明がヘタクソで意味不明。

>>764
この本はいいよ。sraのサイトのやつは分かりにくいけど。

アマゾンにも在庫はあるみたいだから757は
これを買いなさい。年内これ一冊で楽しめると思う。

みなさんありがとうございます。
教えて頂いた本を書店で探してみます。

>>765
俺はその本を少しと、754が言ってる「プログラム意味論」, 横内寛文
を読んだことがあるけど、後者の方が説明がわかりやすい上に、内容
が深いと思った。
ただし、無味乾燥で、扱ってる内容が少々難しくなるが。

>>765
その本いい加減な集合論で定義しただけで「数学的」とか
調子こいてて全然ダメ。話にならない。
Meyerなんてしょせんタダの計算機馬鹿。

>>768
同意。あまり真面目に読む本じゃない。
独学で、かつ真面目に読もうと思っちゃうと、緩い記述に引っかかって辛いかも。

さらっと読んで、>>767に進むのが良い。

http://www.amazon.co.jp/exec/obidos/ASIN/1568811357/
これにしとけ

M$からLisp処理系出ないかなage
…俺はいらねーけど(wara

Lispじゃないけど昔Turbo Prologってのがあったね。
腐ってたが。

ありがとうございます。

>>770
それは基礎論の教科書だけどこの話とは関係ないな

「プログラム意味論」と同シリーズの、
｢プログラム言語の基礎理論｣っつーのはどうでしょうか？

>>772
TurboPascalとかと同じでボーランドから?

>>776
Borlandが売ってたけど開発元は違った。
今はVisual Prologという名前になってる。
Prologとは呼べないほど変わった言語。

TurboLispってのもあるが、Borlandとは無関係。

お久しぶりです。
とりあえず、Bertrand Meyerの
「プログラミング言語理論への招待」を買ってきました（それに
しても高かった、、、）。明日からの3連休で読み終えたいです。
教えてくださった方の話だと、どうも横内さんの本は難しそうなので、
とりあえずこれを読んでからにします。

今2章で基本的な概念とその記法を学んでいるんですが、
高校数学すらろくすっぽ覚えていないので記号に馴染むまで時間がかかりそう。
頭が悪いのでノートに書きまくって読んでます（*^o^*；

Zってどんな言語？？

http://www.zuser.org/

C って再帰使えるんだ。今、はじめて知った。
そんなわけで、Cもこのスレに入れてもいいですか？

>>781
ナニが「そんなわけで」だよ。

>>781
てゆーか、ＶＢでさえ使えるんですが。再帰。

>>775
大堀さんの？いい本だよ．
MLの基礎理論がしっかり書いてある．

>>778
あの本を３日で読み終えようなんて傲慢にして無謀。

てゆーか、いまどきFortranでさえ使えるんですが。再帰。

逆に言えば再帰を使うようなケースは大抵ライブラリとして用意されているから
そんなに必要性もないということか。。。

>>785
確かに無謀でした。じっくり読んでるので今まだ4章の初めですｗ
前にも言われたように年内楽しめそうです（苦笑
お風呂やトイレに行くときも持ち込んで読んでるのに
こんなペースか、、、正直、自分の頭に失望しました。

こういった本を読んでいるとちゃんとした人に教わりたく
なってきますね。自分は高卒なので新たに大学に行きたくなってきました。
といっても4年間の学費を払う余裕もないのでなにか教養講座のような
ものがあればいいなと。どうでしょうかね？一人で本読んでばっかりじゃ
アウトプットがなくて効率が悪いと思うんですよ。
なにかご存知であれば教えて頂けないでしょうか？

>>788
大学にはこういう人に来て欲しいよね。
実際に大学に来てる人って勉強なんてやる気なくて
働かなくてもいいから大学いってるみたいな人がたくさんいる。

>>789
そんな大したものじゃありません。恥かしくなるのでやめてください

今いろいろと検索してみたのですが教養講座みたいなものはなかなか
見当たりません。ある程度の人数が集まるようなものでないと、
授業を開くことができないのは分かりますが残念です。
むしろ一般の講義を切り売りしてるような学校ってないかな？
一単位10万ぐらいで。飛行機の空席を安く売るような感じにｗ

先生に直接交渉して現金渡すのがいいのでしょうかね？ﾜﾗ
教える人とその授業を買う人が自由に売買できるほうが
望ましいと思いますが、現実はそうでもないみたい。

こういうの仲介するのが商売として成り立つかな？とも考えてみたりｗ

スレ違い、すみませんでした。

>>790
> むしろ一般の講義を切り売りしてるような学校ってないかな？

ケンブリッジは、講義のビデオ売ってるよ。
日本の大学でもやっているところないかな？
いずれにせよ、多くの大学がやり始めると思う。

それから、多くの大学には、聴講という制度がある。
勝手にもぐり込んで授業を聞いても、誰も気づきはしないけどね。
# 某板では、思想的に偏った放言を吐く人の授業を聞きに行くツアーがあった。

>>788
>確かに無謀でした。じっくり読んでるので今まだ4章の初めですｗ

その手の本を読むのが初めてらしいので、遅いという事はないと思う。

おれが500万で数学をみっちり仕込んでやる！
どうだ、やすいだろ。これの方が大学なんてところに4年も行くよりは効率がいいぜ！

>>792
途中解約はできるのか？
お試し期間はあるのか？
月謝制か？

末尾再帰でループみたいなことが出来るのは分かったけど
結局そのソースが吐き出すコードってループになってるんですよね？
なんのために再帰にこだわるのか私には謎。

別にこだわってないんじゃない?
再帰で書いたほうがきれいにかれるときに再帰を使えばいい。
末尾再帰がないと必ずループで書かなくちゃいけない。

# 他のものとの違いを聞かれると特徴的なことをあげるだろうけど、
# 別にそれがすべてって思ってるわけではないでしょ。

>>794
結局そのソースが吐き出すコードって機械語になってるんですよね？
なんのために高級言語にこだわるのか私には謎(w

>>795
確かに。再帰に対する考え方は一応私も同じスタンスです。
字句解析とか不思議なほどすっきり書けるのは確かですし。
まあ、lispでも普通にループ使ってたらいいですね。
ただ、なんか関数型言語って変なこだわりを感じるんですね。
（変数へ代入は状態がどうのこうのとか）
この辺り馴染めません・・・

＃これも気にせず普通にコーディングしてればいいのかな。

非手続型、なかんずく関数型は、
基本的には、imperativeに対する批判から出発している。
つまり、imperativeによるアルゴリズムの記述は、
実行順序を細かく論じることに費やされてしまい、
とかく冗長・複雑なものになってしまう。
また、そのアルゴリズムの正当性を論じようとする際には、
その非数学的な記述は、いかにも厄介である。
したがって、数学的でコマンドの羅列になることのないような記述法を
模索しようと言うことから出現してきた背景がある。
従って、別にどうでもいいといわれればどうでもいいのかもしれない。
しかし、まあ一応流れと言うことで。

>>794
いや，再帰にはこだわりたい．なぜなら多くのアルゴリズムは
分割統治的な性質があるから，漸化式が導き出せる．すると
再帰はその直接的な表現になる．

逆に，ループは漸化式を開いた形に対応するので，アルゴリズム
の記述という観点からすると間接的な表現と言える．

800get!

>>790
その手の分野では日本ソフトウェア科学会が
ときどき短期の集中講座を開いてる．もちろん一般参加可能．

再帰にこだわる理由…
・ループは単なる再帰の特殊例なので、再帰さえあればループは不必要。
・ループなんてものは数学的にはあやふやな概念。ループの『意味』を
　厳密に定義するには再帰を使うしかない。
・「ループが基本」とか「ループが分かりやすい」と思うとしたらそれは、
　たまたまそういう言語を先に学んだ人の偏見にすぎない。

それと、少なくともHaskellではCのforやwhileにあたるものは
普通の関数として定義できてしまう。LispやSchemeでもマクロ
を使えば可能。基本構文に加える必要は全く無い。

ループのための構文がいらない
代入もいらない

腕立て100回に「再帰」の観念は必要かな？
ループを再帰の特殊例としてのみ捉えるのも、
たまたま数学ﾏﾝｾｰに生まれついた人の偏見に思えるけど。

そうそう、歴史的には論理性が自然言語から
切り取られた概念だという事を忘れた言い分だね。

再帰のみでfor文を作るのは
面白いけど無意味

みんなもやってみよう

手続き型言語にはループと再帰がある。ループ構文を定義する方法がないから。

関数型言語には再帰がある。ループは定義できるから。
表現能力が同じで便利さも同じなら、primitiveは少ない方が良い。

プログラミング言語は形式言語であって自然言語とは無縁のもの。
曖昧さのあるプログラミング言語なんて使いたくない（ｗ

>>808
別に関数型言語にケチつけるわけじゃないが
それは所詮個人的な美意識の問題に過ぎないと思われ。
利用局面において使いやすければそれでいいんだから。
C#なんてそういう美しさという点から言えば話にならないが(以下略)

いや、「ループを使うな」とか「ループは良くない」と言ってるわけじゃ
ないんだよ。「ループなんてライブラリで良いじゃん（ライブラリ化が可
能な言語なら）」と言ってるだけ。

CでもC++でも、「quick sort文」とか「hash table型」なんてのを
primitiveにはしないだろう、ということ。（C♭ならわからんが…）

>>811
確かに、再帰で表現できるループを言語文法にしてしまうのは良くないね
特に、数学的なものを扱う場合にはね
従わねばならない文法が増えれば増えるほど、「前提」も増えるからね

関数型言語においてはループは良くないよ。
代入が必要なんだから。

>>805

（ｌｏｏｐ 100 '腕立て)

こういう風に使える関数loopを定義することはＳｃｈｅｍｅ的にはひどくカンタンですが、それが何か？

>>813
意味不明。

たとえばSchemeの
(do ((i 0 (+ i 1))
　　 (a 0 b)
　　 (b 1 (+ a b)))
　　((> i 10) b))
というループに代入など出てこないが？

>>813
個人的にはこういうのがいいけどなぁ。
(define (udetate-ato n)
(udetate-suru)
(udetate-ato (- n 1)))
(udeate-ato 100)

>>814
(i 0 (+ i 1)) とか代入だよね。
実際には代入しない式に変換するかも知れないけど、
そんなこといったら手続き型の代入もすべて変換すればいいし。

ごめん、ずれてる。
>>814 と >>815

>>816
> (define (udetate-ato n)
> (udetate-suru)
> (udetate-ato (- n 1)))
> (udeate-ato 100)

これでは無限ループでは？

; (udetate-ato n)においてnがゼロになろうがマイナスになろうが停止しないでしょ。

>>816

代入じゃないよ。

(letrec ((loop (lambda (i a b)
　　　　　　　　 (if (> i 10)
　　　　　　　　　　 b
　　　　　　　　　　 (loop (+ i 1) b (+ a b))))))
　(loop 0 0 1))

みたいなただの再帰呼び出しになる。
これを「副作用」と感じるようだとかなり毒されてる。

>>815
それをループと呼ぶのなら、僕が間違ってます。すみません。

おおよそ「自然数」を取り扱う限り、
再帰的に定義されたものを再帰的なプログラムで記述するのが
一番忠実で簡潔な方法なのではないでせうか？

「腕立て伏せを『n回』やるように命令する」なんてまさにそうだと思われ。

「再帰的に定義された問題について」ですね。舌足らずスマソ。

>>819
forループもそういう風に展開できるよね?
再帰に展開したらループ自体の副作用がなくなるのは当然だけど無意味では?

>>821
「腕立て伏せを『ｎ回』やるように命令する」
のどこに再帰があるんだい？

>>823
意味が分からない。

「ループ自体の副作用」って？ 「ループ」という概念に副作用は含まれてい
ないと思うが。

「無意味」とは？ 別に何か凝った変形操作をしているわけではなくて、同じ
ことを（つまり、ループはすなわち再帰だから、素直に再帰で）書いている
だけなんだが、何が無意味？

forという「文法」「カタチ」の方が好きならば、それを使えば良い。全く
同じ意味だが。

あ、単純に

n回やるとは
・n>0なら(n-1)回やったあとXXXを1回やれ
・n=0なら何もしない
というふうに書けるということです


ん、関節やら筋肉やらにどういう指令を送って
腕立て伏せの一連の動作を行わせるかっていうこと？
それは関数型の話しとちゃうのでは？

>>824
「n回繰り返す」をどうモデル化しても再帰の概念が出てこざるを得ない。
たとえば「loopというラベルに続くコードからloopへジャンプする」という
のは、「loopという状態に遷移した以降の状態遷移先にまたloop自身が出てく
る」わけだから、遷移規則(オートマトンに対応する言語の導出規則)が再帰的
になる。

もっとストレートに言えば「繰り返し」はすべて「再帰」のサブセット。

>>827
同じ状態に遷移したら無限ループじゃん。816みたく。

っていうか、827は
「クロージャに1,2,...,nを引数として順次与える」
って事しか言ってないのでは？
引数を与える方法が副作用であるか再帰関数であるかには
触れていない。

>>826
君は腕立て伏せをするとき、「一回やって、あとn-1回だ」って数えてる？
俺は1,2,3,4,...,nと数え上げて、その度に腕立てするよ。
別に「一回やって、あとn-1回だ」でもいいけど、他の方法もあるってこと。
自然数を公理的に定義する場合にも
n∈Nat ⇒　n'∈Nat としても
x≠0　⇒　∃y.x=y'　としても
どっちでもいいよね。

＞俺は1,2,3,4,...,nと数え上げて、その度に腕立てするよ。
私もそうします。たまに何回目だかわからなくなって
１セット余分にやっちゃったりもします。
＞「一回やって、あとn-1回だ」
なんてやってたら、エラー：「あれえ、あと何回だっけﾊｧﾊｧ」が爆発的に発生して
ぶったおれるまで終れないかも・・・

loop(a, n)とは
・もしもa>nならば終了
・そうでなければ loop(a+1, n)へ

>>827
途中に脱出条件が入っても（当然入ることを想定してたが）再帰であることに
かわりはない。

>>828
良くわからんが副作用とループが（必ずしも）関係ないということには同意。

>>829
カウンタを減らしていっても増やしていっても再帰は再帰。>>819 では増やし
てる。

番号ずれてた。827, 828, 829はそれぞれ828, 829, 830のまちがい。

>>829
オートマトンと逝ったのが悪かったかも知れんが(それでも入力が進んでるか
ら無限ループとは限らないが)チューリングマシンなら意味は通るだろ。

またまちがえた。>>830ね。欝。

おそらくループを再帰の一種に還元することを嫌う人は、
単純に具象構文が身体感覚に合致するかどうかを問題
にしているんだと思う。

Schemer/Lisperは構文問題に頓着しないので、
ループを再帰に置き換えるし、むしろ積極的にループなど
再帰の一種に過ぎないと「抽象化」する。

しかし、構文問題に頓着する人もいるわけ。
だからSchemeやＬｉｓｐの普及は一定以上のものにならない。

よくC言語はソースコードとマシンコードのギャップが少ない、
という評価のされ方をするね。

関数型言語の場合はソースコードと本質的なアルゴリズムの
ギャップが少ないという評価でいけるんじゃないかな。で、問題
を解決するときに「この問題の本質は何か？」を追求するので
はなく、本質的かどうかは問わず、手作業でやるときの方法を
素直に機械処理化するという方法論の人もいるんだな。そうい
う方法論の人の場合、ソースコードと自分の身体感覚のギャッ
プの少ないことが重要なんだと思う。

Perlなんかは、身体感覚重視で、だから科学的な発想の人か
ら嫌われるんだと思うし、身体感覚派の人からも、身体感覚的に
合わないと嫌われるんだと思う。

>>835
なかなか鋭い洞察だと思うが身体感覚派の人もSchemeでdoループでも
forループでも使えば良いじゃん。あるいは身体感覚に合う構文を作っ
ても良いし。

> Schemer/Lisperは構文問題に頓着しないので、

それなら Haskell や ML なんて…

ところでループの定義って何?

>>833
え、チューリングマシンなら、それこそ副作用＋ジャンプじゃん。
それを再帰関数に読み替えることができるってのはその通りだよ。
つまり、
＞「n回繰り返す」をどうモデル化しても再帰の概念が出てこざるを得ない。
は「どうモデル化しても」じゃなくて「functionalなパラダイムでモデル化すれば」であって、
計算モデルとしてチューリングマシンを選べば「書き込み＋ヘッド移動の概念が出てこざるを得ない」でしょ。

繰り返し動作を実装する時に
functionalなパラダイムでは再帰が自然だし
impericalなパラダイムではループが自然だっていう
それだけの話でしょ？なんで普遍的にどっちかに統一せにゃならんの？

>>839
＞計算モデルとしてチューリングマシンを選べば「書き込み＋ヘッド移動の概念が
＞出てこざるを得ない」でしょ。
んで、そのチューリングマシンと等価な言語の導出規則はどうなるの？

＞繰り返し動作を実装する時に
＞functionalなパラダイムでは再帰が自然だし
＞impericalなパラダイムではループが自然だっていう

impericalってのはimperativeのことかな。
何でも良いが、再帰の出てこない意味論があったら教えてくれ。

＞それだけの話でしょ？なんで普遍的にどっちかに統一せにゃならんの？
別に（形を）統一しろとは言ってない（と何度も言ってる）。
forやdoが好きなら使えばよろしい。
再帰さえあればループという「形」は簡単に作れるからprimitiveからは除
いても差し支えないと言っているだけ。

Cでwhileやdo、forがなくて、末尾再帰しかなかったららかなりうっとうしい
ことになりそうなんだけど。慣れの問題か？漏れはよく分からん。

>>839
誰もチューリングマシン上でアルゴリズムの設計などしないのですが。
いろいろな計算モデルがチューリングマシンモデルと等価だというの
は正しいですが、だからといってチューリングマシンモデルが他のモ
デルと同様に有用だと考える人はいないでしょう。

だいたいそんなことを言い始めると言語を研究している人たちの立場
が...

>>840
＞　impericalってのはimperativeのことかな。
スマソ。その通りです。

＞　何でも良いが、再帰の出てこない意味論があったら教えてくれ。
操作的意味論でよければ、いくらでもあると思うが。
例えばアセンブリコードを吐くコンパイラみたいのとか。
さらにそのアセンブリでcallやretをスタック操作+jumpに展開しちゃえば
再帰というよりループに近いシロモノになるよね。

どうでもいいけど末尾再帰って再帰って言ってるけど、
別に自分自身を呼ぶ必要はなくて、
関数などの一番最後のコンテキストで他の関数を呼ぶ時に
余分なスペースを消費しないことだから、
>>843 みたいなのはまさに末尾再帰だと思うのだが。

再帰でループ？
カット無しのPrologみたいなものか、
死ぬほどスタックがいるな。くだらん

>>845
いや、末尾再帰は最適化する環境が多いんだけども。（ｗ
Schemeは言語仕様で最適化すると決まってるな。

なんかチューリングマシン以外に計算機のモデルがあるような
物言いだけど、そんなのあるの？

>>847
あるけど、そんな物言い誰もしてないと思うけど？

>>848
どんなのか少し説明お願い

>>841
Cで再帰使って記述するとなると
return文が冗長だから読みやすくはならない。
Rubyみたいに最後の評価式が関数の値となる仕様ならまだしも。

>>849
脳型計算機とか。
話がずれてないか？

確かにずれてきてるな。
>>849
ラムダ計算＋簡約規則でもいいし、ホーン節＋推論規則でもいいし。
どっちのモデルもチューリングマシンコンパチだよ。

>>836
Schemeは構文を拡張できるから、自分の身体感覚に合う構文を作れば良いってのは
ある意味正論だけど、やっぱり詭弁でしょ。アセンブラなら何でも記述できるんだから、
自分の好きなようにコンパイラを書けば良いって話と同じじゃない。（もちろん、Scheme
のマクロが強力かつ安全かつ書きやすいってことは認めるけれど。）

ある言語を評価するとき、個人的な感動の経験が影響するのは否定できないんじゃな
いかな。再帰処理の美しさに感動できれば、再帰処理が基本となっている言語の評価
は甘くなるだろうし、実行効率で感動できる人なら、実行効率に劣る言語はどうしたって
評価が辛くなる。

開発スタイルにもよるよね。上からの指示を淡々とプログラミングするだけの現場なら、
KISSが黄金律だろうし、納品先でカスタマイズしやすいことが大事だとしたらVBとかに
なりがちだろうし。

>>853
詭弁とはまた厳しいお言葉。

コンパイラを書くのとは全然レベルが違うじゃん。
Schemeでdoループを書くなんてほんの20行かそこらでできちゃうんだから。

欲しい構文がdoだけならカンタンだけどね。
forもwhileも欲しいし、Pascal風にレコード定義できるようにしたい、とか、
いろいろ始まるでしょ。
自分の身体感覚に合う構文を網羅しようとすると、大事だよね。
当然デバッグも必要なわけだし。

>>855
それでもまだコンパイラを作るのと同等に扱うのはどうかと思うよ。
そっちのほうがよっぽど詭弁ぽい。

>>855-856
きみらの会話はさっぱりわからん
何がいいたいんだ？

なんか、やけに構文とかにこだわるなぁ
重要な議題なのかな？
オブジェクト指向派なので逆に関数型にも興味はあるが…
こんなに構文にこだわる言語なの？

繰り返しにも分岐にも、特別な文法を与えていないSmalltalkの方がきれいだなぁ

英語で俳句は書けますかってのと大して変わらないような議論かも

英語で俳句は書けますし、書いている人もたくさんいますけど、それはおいといて。

その人が言語を選択するときに、あらかじめ用意されている道具（構文や関数、制御構造等）が
「しっくりくる」かどうかを気にするのは当然だと思う。道具を作るための仕掛けが十分に用意さ
れていても、自作しなければならない道具が多すぎると腰が退ける人はいるでしょう。

; あまりにも多くの道具が用意されているので尻込みすることもあるでしょうが。

Schemeが強力だってことは疑いないし、構文など些末な問題ではないってことも
疑いない。構文が身体感覚に合致しなくても、身体感覚に合う構文を定義して利用
できるというSchemeの強力さは、もっと評価されていいと思う。だから個人的には
836は支持できるんだけど。

でも、やっぱり、それが万人に通用するかと言えば無理があると思うんだ。
原理などしらずに道具を使いたい人はいるわけだし。原理が透けて見えると
息苦しい人とかいるわけだし。

>>860
×構文など些末な問題ではない
○構文など些末な問題だ

スマソ。

プロなら構文や言語機構が身体感覚（って何？）にあわなくてもセマンティクス
がわかれば使いこなせるのでは？　それができないってことは，つまりプログラ
ミング言語の基礎が理解できてないっていうことだよね．EoPLか，せめてSethi
の本でも読んで勉強してみてはどうだろうか．

>>862
プログラミング言語はプロのためだけにあるわけじゃなかろうに。
ってゆーか、862が言いたいのは
「二進数表記の機械語でも使ってろ。
セマンティクスさえ理解すれば使いこなせるはずだ。
それができないってことは基礎がダメダメってことだ。」
とも読める。

>>863
862じゃないが、関数型言語は機械語と全く逆に高水準で使いやすいんでは？
それを機械語と同一視するのはあまりにこじつけが過ぎるような。

なんで話がこじれてるのかわからん。
「Cで再帰だけで書け」と言ったヤツはいないように思うが。

関数型言語は末尾再帰がちゃんとループと同一視される。
だから再帰だけあればループも使える。Cはそうでないので、
ループ構文が(再帰と別に)必要。

だから逆だろ。「Cで再帰だけで書け」じゃなくて、「関数型言語には、
(primitiveとしての)ループ構文は不要(ライブラリで良い)。」

forを自分で定義する必要なんてない。SchemeでもMLでも最初から
(ライブラリとして)用意されてるから。それが「身体感覚」に合わなかったら
作れば？ Cではできない贅沢だろ。新しいループ構文作るなんて。

>>860
その「身体感覚」なるものを「万人に通用する」とまで一般化して語るのはどうかと思うが。

大部分の人間が手続き型からプログラミングを学んだために、
他のパラダイムの言語を覚えるのに抵抗感を感じるのは良いとして、
例えば中学で一次関数を習うと同時に関数型言語も習ったとしたら、
事態は逆になっていたと思わないかな。

「原理」で言えば、コンピュータの原理（ノイマン型/プログラム内蔵方式/逐次実行）を
知らないと ASM/C/C++ なんかは使えないと思ったり。

>>866
プログラミング知らない中学生クラスにLisp教えたことがあるが、
別に再帰呼び出しに抵抗はないようだった。

やっぱり最初に教えるべき言語は函数型言語だよね。
手続き型は妥協の産物ということで理解するほうが
望ましいと思うんだけど。

やっと、落ち着いてきたな。
OO派な私にとっては、関数型はある意味ライバル(?)なので
そのスレッドが荒れているのはライバルとしてふがいなく感じるんだよ。
だから、あんな書き方をしたんだ。
（まあ、うちのスレッドはどれも荒れまくりだがｗ）

SchemeなんかはSmalltalkからヒントを得たアクター理論を用いた
Plasmaを改良して作られたものなのに、関数型の考えになったりしてるけど、
なぜそうなったのかとか気になるしね

そういや、SmalltalkもSchemeも評価方法（インタプリタやコンパイラ）が
同一言語自身で作られているが、それが言語の柔軟性・拡張性を高めている気がする。
これは、まさに、アーキテクチャの再帰構造と言えるかもしれない。

HewittのアクターがSmalltalkからヒントを得たってのはホントなの？
本質的に非同期な並列動作だし、継承なんて概念はないし、
全然違うものだと思うが。

似てるのはメッセージ・パッシングというキーワードだけでわ。

>>869
なんで関数型とOOが対立しないといけないのかな？
LispやSchemeはもちろんOOだし、Objecitve Haskellだって
あるのに。

関数型も結局手続きで実装するんだろ

>>872
部分的にはそうなんじゃない？
それがなにか？

手続き型の方がパフォーマンス良く実装できるに決まっている。

ところで関数型っなんだ？内部状態を持たないって事か？
すると、カウンタとかどうするんだ？
外部に記憶空間を持って手続きでやり取りするのか？
大体それじゃ諸機能の実装を副作用に頼る事になるだろ、
なんというか、無駄っぽい。

>>875
ただ単に、制御文だとか、命令だとかが関数で統一的に
表現されてるってだけでは。

結局関数型というのは時間概念を無視した
中途半端な代物だということだ。そういう共時律的な概念に
基づいた言語も新しい物理学上のパラダイムシフトが無い限り
時間発展系の操作によって実装せざるを得ないのは、
時間の定義上当然であり、つまり我々の世界においては
今現在知られている限りでは手続きしかあり得ないのであって、
結局どちらが基本的手段であるかといわれれば当然手続きである。

>>877
分かっている人だと期待して聞いてみよう。
論理学に時間概念を取り入れることはできるのですか？

論理学では命題論理からファジー、様相論理などなど
様々な論理体系が見出されたが、これからも自然言語に含まれる
或は全く未知の論理体系の定式化が進むだろう。
そして時間概念取り入れの手がかりが様相論理にはある。
(今現在の研究がどの程度進んでいるのかは知らないが)

しかし、論理学におけるそのような議論は計算科学に
おいて必要不可欠ということは全く無く、
時間発展系の記述という点について言えば
数学でそれを記述する事は容易である。
確かに数学は論理以上を原理的に含むのではあるが
方法として数学を採用する事を躊躇する理由は何も無い。

実際計算科学は時間発展についてよく考察し、
さらには情報量に関するエレガントな理論を展開し、
その物理学との関連をこれもまた意味深に語っているではないか。

http://www.cr.ie.u-ryukyu.ac.jp/conference/kaoru/SOFT/yoko.html

はい、不勉強でした。
逝ってきます

>>877
関数型が時間概念を無視したってのはおかしいな。
例えば、リストがあったとしてそれには順番が
ついているのだから、時間的経過を表現してる
とも言える。
それに、あんた物理学上のパラダイムシフトが
必要とかいってるが、なんで物理学が出て来るんだよ。

「時間」はデータですか？
それともプログラムですか？
LISPやSchemeならそのどちらにでもなりますか？

>>883
そういう議論って意味がわからない。
C言語で
a=1;
a++;
という文があったら、この二つは時間的に前後が決定されてる
から、時間がプログラムってことになるのか？
それならLISPも同じだよな。LISPの場合はプログラムがリスト
だから時間がデータとも言えるってことになるのか？

とりあえず、時間がどうのこうの言いはじめた877は一体
何が言いたかったんだろう。

877はブルーバックスでも読み始めた中学生だろ。
不勉強を認める賢さは持ち合わせてるみたいだから
厨房ではないが。

いえいえデータ構造及びデータは少なくとも実在論的には
共時的に存在できるのですよ。
その操作に時間が必要なのです。それはもちろん因果律の
もとで行われるからです。この方向性のある順序尺度としての
時間の元で非可換な操作を並べたものがもちろん手続きです。
もちろん時間には間隔尺度としての側面もありますから
完全に物理概念を利用しているという訳ではありません。

ところで純粋な関数型は写像の合成で記述するという
数学的に非常に綺麗な構文をしていますが、
ここ(構文)にはもちろん時間概念はありません。
言ってみれば恒常的に成立する式を記述する形式で
プログラミングが成立します。

このような共時的実装は我々にとって為すすべも無く
結局手続きで実装する事になりますが、そこで
この形式(関数型)で時間順序を扱うには言語仕様を熟知した上で
副作用を利用する事になります。このことは
実用的プログラミングにおいて大変不利であると考えます。