新次元新発想！新しい文法を作るスレ

ifをcaseにすると便利なことがあるよね。
ただ、はじめから備わってるものでは、面白くないので新しい文法を提案してください。
あの処理がこんな風に書けたら楽だ、みたいなことです。

ちなみに私は先入観の塊と化しているので何も思い浮かびません。
頭の体操みたいな効能もあるかもしれません。

vierus
{
文
}

コードを他の実行可能ファイルに埋め込む。



って言うか何でム板に笑点スレが・・・？

２ヌル〜ズサー

ム板で２ゲットミスするなんて滅多に見られないな

敢えてネタにﾏﾁﾞﾚｽしてみようか。

Integer I = 0;
Repeat(30){
　　ConsolePrint("test%I", i);
　　I++;
}
こんな言語きぼーん。

>>5
#define Integer INT

#define Repeat( for(int _j = 0;_j <
#define ){ ;_j++){

>>1
switch case文は使用禁止
ifならifで統一しコードの可読性を下げるな。

>>7
どんな会社に行ってんだ・・・こいつは。

ぬるぽ文

1 のフリがつまらないとスレが死滅するという良例。

Subliminal(UNKO)

ウンコ画像が全画面で一瞬だけ表示される

>>8
それはそれで利点は、有るのでは？

まあ、どっちかに統一しても
そんなに意味のあることでは無いのだろうけ・・・

if(0 <= i <= 3)
exec();

おれの話も聞いてください
オブジェクト指向スクリプトを作ってるのですが

x.<(y).if({
//trueの時の処理
},{
//falseの時の処理
})

if文も演算子もすべてメソッド起動の形にしたいのですが
こういうのはありですか？　意見をききたいのですよ

>>14
judgeクラスとかを導入した方が良い予感。

judge.if(BOOL,処理,処理);

とかの方がまだ好感が持てるかなと。個人的には。

if文のみってコーディング規約ってあり！？
>>8を読んでビックらこいたよ。これって一般的な規約だったりするの？

>>15
うーん、それだとjudgeクラスには何の意味も無いような…
ifはBooleanオブジェクトのメソッドにしようとおもっていたんですが

(x.< y).if({
//trueの時の処理
},{
//falseの時の処理
})

としてくれるならまだ納得できた。whileとかはどうするの？

>>18
なるほど、実は２項演算子というかメソッド起動は
(object message parameters)とする案も自分の中であるんです。
つまり ((((x * x) + (y * y)) + (z * z)) sqrt)で3次元の距離を取得のように

while文は
obj.while( {/*ブロック*/} )
です。終わる時はobjにfalseを入れます

>14
つーかSmalltalkがそもそもif文をメソッドとして実装してるだろ。

ちょっと表現が変だな。

実装→実現

>>20
そうですね　"新次元新発想"ではなかったですね

>>22
残念だったな(ｹﾞﾗ

俺の探し方が悪いだけもしれないんだが、言語そのものが行列に対応していて、
内積とか外積とか計算できるやつない？

>>24
Mathmatica

LispのS式を順序を反対するのってどお？
(5.(4.(3.(2.(1.())))))ではなく(((((().1).2).3).4).5)
ラムダっぽくてグー？

>>26
俺は一生かかっても　LISPは覚えられないと感じた瞬間。

>25
なるほど！mathematicaで作ってみるか。ゲームだけど…

>>28
頑張れよ・・・

>>28
内積・外積程度だけなら適当に作ればいいじゃん
別に言語に関係ないじゃん

>>28
普通にCかC++でmatrixのライブラリ探したほうがいいような…

>>27
Lispはそんなに難しくない、というか規則が割と少なく簡単

>>32
カーとかクダーとか授業で習ってこんなおもしろそうな言語があるのかと感動したことがある。
これでCGIでも書いてみようか知らん。

>>33
LispじゃないけどSchemeは如何？
ttp://www.shiro.dreamhost.com/scheme/gauche/index-j.html

　　　　goto文に替わって、cometo文。

割り込みやメッセージのディスパッチに使う。
どこからともなく飛んでくる便利なラベル。

　 ∧＿∧
　（　´∀｀）＜　ぬるぽ

が

if〜 because〜構文

ぬるぽ〜ｶﾞｯ〜構文

class& CreateClass(string classname, vector<string> method);

string c = "hoge";
vector<pair<string, string>> m;
m.push_back(make_pair("print(string s)", "cout << s << endl"));
class t = CreateClass(c, m);
t.print("逝ってよし");

やっぱこっちのがいいや。

class& CreateClass(string classname, vector<string> method);

string c = "hoge";
vector<pair<string, string>> m;
m.push_back(make_pair("print(string s)", "cout << s << endl"));
class T = CreateClass(c, m);
T *abc = new T();
abc->print("逝ってよし");

>>41
ほんと、C++って読みにくくなったよな。

>>42
そうでもないよ

なれだと思うよ
慣れれば読めるよ
慣れにくいからよみにくいって言うかもしれないけど

単純に、フィールドhogeを、
.hoge
としないとアクセスできないようにすれば
_とかmとか「しらね」で揉めないし、可読性２０％UPなのに。

class Barfoo {
int hoge;
void doIt(int hoge) {
if (.hoge>0) {
return doThis(hoge);
} else {
return doThat(hoge);
}
}

>>35
COME FROM なら Intercal にあります。

>>24
APL 系の言語だな。
J 使ってみ。

schemeでこういうtranslater作って遊んでる

define append=lambda(...)=>
letrec listcat=lambda(x,tail)=>
if pair?(x)then cons(car(x),listcat(cdr(x),tail))else tail in
if pair?(...)then if pair?(cdr(...))then
listcat(car(...),apply(append,cdr(...))) else car(...) else ...;
↓
(define append
　(lambda ...
　　(letrec ((listcat (lambda (x tail) (if (pair? x) (cons (car x) (listcat (cdr x) tail)) tail))))
　　　(if (pair? ...)
　　　　(if (pair? (cdr ...)) (listcat (car ...) (apply append (cdr ...))) (car ...))
　　　　...))))

Javaとかだと

クラス → オブジェクトの雛型、変数の型
インターフェース → 変数の型

なんで、役割をすっきりさせて

クラス → オブジェクトの雛型
インターフェース → 変数の型

というようにしてしまうとどうだろうと思ったけど、
あまり利点が思いつかない…

Java に function キーワードの導入希望。
こんな風に。

public static function hoge(int a, int b) {
　　return a + b:
}

こう書いておくことで、hoge というメソッドが、そのクラスのクラス変数や、
インスタンスのインスタンス変数にアクセスしないことを言語的にはっきり
させることができる。アクセスしたらエラーにする。

このキーワードが指定されているメソッドを使うときには、マルチスレッドでの
同期などに気を使う必要が無い。

こう書くことで、このメソッドが厳密に数学の意味での「関数」（引数として
渡されたものだけによって、戻り値が決定される）だということをあらわせる。

ちなみに、「【初心者】Java質問・相談スレ19【大歓迎】」というスレの「619」
のところで、思いついた。

>>50
全然「新しい文法」じゃないじゃん

10 1 + 2
20 [10] + 3
30 [20] + 4
40 print [30]
で10が出る。
行番号が変数/メモリ配置を兼ねている。

>>53
行数が増えると大変なことになりそうだけど
俺でも作れそうでいい

10 RND(10)
20 INPUT "ｶｽﾞ ｲﾚﾃ"
30 IF [10] = [20] THEN 40 ELSE 50
40 PRINT "ｾｲｶｲ"
50 END

syntax while(expression &ex) trail statement blk {
  symbol s1, s2;
  putsyn("%s:", s1);
  putsyn("__ongoto(%e) %s;", ex, s2);
  putstatement(blk);
  putsyn("goto %s; %s", s1, s2);
}

>>53
Cに直すと
int _10 = 1 + 2;
int _20 = _10 + 3 ;
int _30 = _20 + 4 ;
int _40 = printf("%d",_30) ;

関数呼び出しを、
a(b(c(...)));
と書くのは見ずらいし、ネストが深いと括弧を数えるのが面倒なので、
'<-'という右結合の２項演算子を用意する。

a(b(c(d, e(f))));
は、
a<-b<-(d, e<-f) ;

と書ける。
デメリットは、比較演算子<と単項の-をくっつけて書けない。
(a < - bと a <- bはまったく違う)

自作言語には既に組みこんであるけど、
<-より良さそうな記号ない？

>>58
:-)

>>58
<= てのはどう?
< も = も 二項演算子だから2つが並ぶことはあり得ない。

>>58
ごめん。書き込んでから気付いたんだけど、<= だと += なんかと紛らわしいかも。

>>59
>>58の例に当てはめると
a:-)b:-)c(d, e:-)f) ;
こうなって、なんか読みにくい気がする。
:-だけの方がいいかな。
a:-b:-c(d, e:-f) ;

>>60
既に<= という割と使われる比較演算子(leq)があったりします。

>>58 ^^

>>63
a^^b^^c(d, e^^f) ;
結構良いですね。
a^^b;
bをaに適用するという意味は薄れるかな。


追加でもう一つ。
<-だけでは関数の引数が複数の場合に使えないので、
<-よりも優先度が高い、/- という補助の２項演算子を用意する。
これも右結合。

例えば、
a(b(c,d(e,f(g,h()))));
は、
a<-b/-c<-d/-e<-f/-g<-h();
の様に書ける。
この演算子の記号もちょっと微妙。


^^にならって、仮に/-を/^とすると、
a^^b/^c^^d/^e^^f/^g^^h();
慣れればokかな。

if I were a bird 構文

>>8
使える型が限定されているならわざわざ無理してswitch文を
使うまでも無い。
修正が容易な構文はsewitchよりもif-else-ifネストだ。

>>66
＞使える型が限定されているならわざわざ無理してswitch文を使うまでも無い。

？

よくわからないのでコードで示してみて。

>>64
>a<-b/-c<-d/-e<-f/-g<-h();
>a^^b/^c^^d/^e^^f/^g^^h();
慣れてもどれがどう対応するのか読みづらいような…

ML みたいに関数呼び出しに括弧をつけないようにすれば問題解決

A <--> B

AならB、BならAに

>>69
MLみたいにって…
MLには既に o という同じことをする演算子があるのに
それは指摘しないのか

>>71
MLにはそんな演算子があったんですか。
それは、引数が複数ある場合はどうなるのかな。
あ、そういやMLの関数は引数が１つだけと聞いたことがあるから、
問題ない？

>>69
呼び出しを後置演算子としての括弧で判断してるので、
今の仕様だとちょっと無理です。
関数自身の値が欲しい時や、変数との区別も必要。

今の仕様では、
func0 /- arg1 /- arg2 <-
func1 <- func2 <- func3 <- func4()
は
func0(arg1,arg2,func1(func2(func3(func4()))))
という意味で、func4()の様な引数無し関数は
voidを渡す方法が無いから、ちょっと不恰好。
確かに括弧をなくせば辻褄が合う気がするんだけど。

void SINE()
{
printf("死ね");
SINE();
}

>>73
無限ループネタを今更やられてもなぁ。

ある関数のローカル変数が、その関数から呼び出された関数からなら
参照可能になるような変数があったら便利と思うのはおれだけ？

>>75
うん、考えたこともなかった。

>75
Emacs LispのDynamic Scoping(古いLISPに多い)のこと？

Emacs LispもDynamic Scopingも知らん（恥
既にあるなら忘れてくれ。

文字列にプログラム文を格納して発動。
例：char com[16] = "sizeof(com)"; //文を格納する
int size = @com; //"@"で発動する

eval

>>75
Pascalなら関数のネストが出来るから
そんな感じのコードが書けると思うけど。
ちょっと違うか

>>81
Pascal知らん（恥
>そんな感じのコードが書けると思うけど。
>ちょっと違うか
そんな感じのコードが書けるならそれです。
だから既にあるなら忘れてくれってば。

なんで、昔っからあるようなのとか、全然文法レベルの新規性のないのしか出てこないんだ。
藻前ら、もうちょっと勉強汁!

BrainF*ckとか

なんか関数で配列返せたらいいと思う。
関数は値を返す、手続きは処理をするとキッチリ分けたい。

switch (a,b,c) {
case (3,5,2):
...
break;
case (3,4,1):
...
break;
default:
...
}

else-if でもいいんだけど。
switch {
case( 式1 ) {
}
case( 式2 ) {
}
}

>>84
javaはふつうにできますが。って言うかCでも何も考えなきゃできるでしょう。

こんなのがいいです。
if (a){
case(==b){
}
case(!=b){
}
}

>>88
文法破綻してないか？

>>72
すまん >>69 のほうが正しい。俺の読み違い。
'<-' って関数合成かと思ったら関数適用の演算子だったのね。

fun1 o fun2 は、fun1(x) と fun2(x) という二つの関数から
fun1(fun2(x)) という関数を返す演算子。

>>89
「新しい文法」ならいいんだろう。
面白みも旨みも新鮮さも感じられないが。

-*(x]
i
&&{{{}}}}}}{}{{}{};;;;;;;:
i

とかどうだろう？開発効率一気にあがりそうなんだけど。

>>92
何それ? 何に使うの?

>>92

宇宙人との交信ですか？

NetHack にしか見えません。

NULLPO（NULLPO）->NULLPO

ずっと前にこんなんあったらいいのになと思って、今も思い続けている。
画期的な制御構造だと思うがどうだろうか？

for (int i=0; i<100; i++) {
　　if (func() == NG) break;
func2()
func3()
} nomalExit {
　printf("るーぷ100回しました");
} breakExit {
　printf("途中でbreakしました。");
}

似たようなのがpythonになかったっけ

あるの！？調べてミマス

終了条件を書けるループとか便利っぽい

do {
...
while ( hoge ):
...
}
まんなかで、条件判断がしたい…

>>101
for(;;){
...
if( !( hoge)) break;
...
}

>>102
美しくない。。。。for(;;)きらい。
101は、なかにwhileがひとつだけじゃないとコンパイラに怒られる
ようにしたい。

>>103 どうなっとるんだ　お前は

>>97
無理やりやってみる。

#define loopBegin { bool loopBreaked=false;
#define loopBreak { loopBreaked=true; break; }
#define loopNormalExit if( !loopBreaked )
#define loopBreakExit if( loopBreaked )
#define loopEnd }

loopBegin
for(int i=0; i<100; i++) {
if (func() == NG) loopBreak;
　func2();
　func3();
} loopNormalExit {
printf("るーぷ100回しました");
} loopBreakExit {
printf("途中でbreakしました。");
}
loopEnd

>>103
個人の趣味と客観的必然性を混同する馬鹿が大勢いるせいで、
日本ではいらないシステムに無駄な金が大量に投資されてい
るんだが、多分お前もその一味だろ。

>>97
なぁ、forの中にiってことはC++かJavaだろ？例外使えばいいじゃん。

try
{
　for (int i=0; i<100; i++) {
　　if (func() == NG) throw new BreakException();
　func2()
　func3()
　printf("るーぷ100回しました");
} catch(BreakException) {
　printf("途中でbreakしました。");
}

}

>>107
ラベルでgotoしても同じだな。

>>108
gotoなんて飾りですよ

ループから抜ける程度のことに例外を使うな。

>>105
ネストしたらどうする？

>>107
ネタだと思うが、例外の使い道と処理負荷知ってる？

俺はこの制御構造は本当にあったら便利だと思う
これで本当にgoto分がまったくいらなくなるだろう

>>111
今でも全くいらないですが…

>>111
煽られた・・・

>>111
ループが指定した回数回らない。ってのは十分「例外」だと思うが。
その冷害が起こったときにある処理をさせたいわけだ。

何の問題がある？

>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

とりあえず今日はねる

>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

とりあえず今日はねる
>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

とりあえず今日はねる
>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

とりあえず今日はねる
>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

とりあえず今日はねる
>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

とりあえず今日はねる
>>112
すまぬ、言い方を変えよう

>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

とりあえず今日はねる
>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

とりあえず今日はねる
>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

とりあえず今日はねる
>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

とりあえず今日はねる
>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

とりあえず今日はねる
>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

とりあえず今日はねる
　　　

>>112
状態遷移を表現するのにgotoは直感的でいいですよ。
あとは、腐ったループから抜けるとき。

>>114
きっとレジスタ全部退避させるのがもったいないと思われ、、、

>>114
だったらelseも例外だなﾌﾟﾌﾟ

try {
　if (a!=0) throw new ElseException();
printf("通常処理");
} catch (ElseExcetion) {
printf("例外処理");
}

>>119
そうか？

>>118
性能が問題にならないなら、

腐ったループ→メソッドに切り出し
状態遷移→Stateパターン

にするけどね…

>>119
本質的なことを聞くけど、いくらでも解決法のある問題で、一番面倒な「そういう仕様になるまで祈る」を選択したんだい？

あと、寝るんじゃなかったのかい？ネタスレでバカな俺相手に煽るより寝た方が遙かに有意義だと思うけど。

>>122
ダメ社会人必死だな（ﾌﾟﾌﾟ

>>123
お前もな。　

>>111
ブロックで囲ってるんで、ネストしても大丈夫だと思うんですが。

blkname：block
　　　：
　　　：
　　　if xxxx then
　　　　　break blkname
　　　endif
　　　：
endblock
→ここに抜ける
：
：

新しい文法なんてやめて、みんなでvaja極めようぜ
http://www9.plala.or.jp/oomasuya/diary.html

ループ開始
　　：
　　：
　もし 〜 なら ループの最初から
　　：
　　：
ループ終わり

>>101
俺もそれ、欲しい。
ボーンシェル系の while って、そんな感じだよな。

俺ならこういう構文にする。
while {
} do( 式 ) {
} done;
いや、doneはいらないか。

int (^O^)　 a[2];
int m(_ _)m b[2];
int φ(._.)　c[2];
int σ(^_^) d[2];

a[3]=0;// 配列を広げてくれる
b[3]=0;// ごめんなさい、エラーを出す
c[3]=0;// ログを出す
d[3]=0;// そう、お前の責任だ！

printf("test\n")ｗ
scanf("%s", a)ｗｗｗ
return 0　ＷＷＷ

括弧に名前が付けられる機能。

<name>{
...

<name>}

>>126
ラベル付き break なら Java とかにある。

括弧の代わりにインデントでネストを表現するLISP

そもそもプログラムが、一直線に並んだバイト列から成ってて、
最初から終わりに向かってだらだら読まれるっていう今までの
前提を覆すってのはどうよ。

Prolog とか OPS とか

>>135
逆さに・・・

{
;c return
;a + b = c;
;c int
}
(a int,b int)hoge int

>>129
bourne shは、式と文を区別しないからそう書ける。
というか式と文の区別自体無意味で盲腸のようなもんだと思う。

C#にoverrideがあるらしいが、インターフェイス名を書けると、よりエラーを検出しやすいと思うんだけど・・
javaを↓のように拡張ｷﾎﾞﾝﾇ

public class TestClass implements Interface1,Interface2,Interface3 {
　public void go() overrided Interface1 { // <-- オーバーライドメソッド宣言
　　System.out.println("Interface1のgo実行!!");
　}
}

あと、return文は関数の最後にしか書けないようにｼﾛ
途中でreturnするのはgotoと一緒だ

>>140
そんなこと言ったら continue break はどうなんだ

>>140
反対！！　さっさと抜け出したほうが見やすい

>>140
アホか。これ以上やることのない条件を最後まで引っ張ったらインデントは増えるわ条件分岐のコストはかかるわろくなことがない。

>>141
continueは廃止
breakは1ネストの脱出だからOK

>>142
ネスト内でのreturnは制御構造を完全に無視してジャンプする行為だ
これを見やすいと言われちゃ、君には構造化プログラミングの素質がないとしか言えん
さっさと抜け出すほうが楽、もしくは>>143のような理由で反対なら話し合う余地もあるが

>>143
同じことがgoto文でも言える、goto廃止も反対なんだな？

>>144
はいはい、一生行ってなさい。

昨日辺りから歪んだ言語感覚持った輩が何人かうろついてるな。

>>145
負け惜しみ全開だな

>>146
sage覚えた方が良いですよ。

>>144
成否を判定すべき処理ごとに関数を作れってことか？
じゃないと if のネストが深くなるだけのような気が

ﾜﾗﾔ

>>148
関数をつくれという事ではない
>じゃないと if のネストが深くなるだけのような気が
本来ネストすべき処理だからネストは増えるのは当然
ただ、きっちり設計すれば問題になるほどネストが増す事にはならないと思うのだが
ネスト中のreturnを止める事によってネストが膨大になるというのは設計が甘い匂いがﾌﾟﾝﾌﾟﾝ
具体例を挙げてくれんか？

>>150
いや、いきなり言われてもコードはだせないけど、
普段はよく、
　なんかやって失敗したら return false;
　なんかやって失敗したら return false;
　・・・
　最後に return true;
みたいにするから。

返り血が複数
a,b,c,d,e = subroutine( a1,a2, obj );
これは絶対必要だな。

>>152
そんなんなら、いっそのこと返り値なしのほうがスッキリする。

>>152
同意。入力は引数、出力は返値と区別したいモノだ。

>>152
良いなそれ。

構造体とかリスト使って返せばいいだろ

>>156 めんどくさい

common lisp, scheme なら構造体やリストなしに複数の値を返せる

＞common lisp, scheme
リストを基本とした言語だな。

>>158
リストじゃねーか

values を知らないのか…

>>152
>a,b,c,d,e = subroutine( a1,a2, obj );
perl なら下のようにかけるけど、求めているのと違う？
($a,$b,$c) = &foo($x,$y,$z);

それとも、複数の返り値を宣言したいのか？
int int int subroutine(int,int,int);

>>162
>int int int subroutine(int,int,int);
複数の値を返す関数へのポインタを複数返す関数 のプロトタイプってどうなるんだ？

>>162
ええ、PerlとかPHPではできるね。

実質、このスレって

新次元新発想！C言語の新しい文法を作るスレ

っしょ。

>>162
> int int int subroutine(int,int,int);

long long int fn();
って書いてたら返値が４パターンあるのだが。
(Ｃ言語の拡張として見ることを前提にすると)

[long, long, int] proc(int, int, int);

>>複数の値を返す
C++ でもテンプレート使って頑張れば
十分実用的なものが作れるよ。

>>167
？

>>168
MType<int, int> foo()
{
　return MValue(10, 20);
}

foo() >> a >> b;

みたいなことするんだよ。

>>169
テンプレート詳しくないんだけどこのMTypeってのは2つ以上の任意の数の型で具象化できるの？

>>170
できん。
だから、一応個数ごとに用意する必要がある。
まぁ、そんなに多いのを使うことはないので
そんなに沢山用意する必要もない。
それに、少ないやつの定義を再利用できるので
実装もそれほど大変じゃない。

まぁ、じゃぁこれを使ってるのかと言われると
使ってないわけなのだが（ｗ

>>171
boost使え

で、みんなもっと新しい文法考えてくれ、将来自作スクリプトにとりいれるから

>>163
そ、想像もしたくない。

>>165
曖昧さが発生するってことかな？
関数の返り値と返り値が代入される左辺値の型が厳密な言語仕様にするとか･･･。
しかし、複数の返り値は >>152のアイディアで、私は返り値は複数なくてもよいと思う。

>>164
＞実質、このスレって
Ｃ風じゃなくて、なんか奇抜なアイディア（文法）をみてみたいな。

ttp://www.system-azure.co.jp/dance/azure0013.html
こんくらい奇抜なのもあるくらいだからなぁ。

>>174
強烈･･･。

>>174
ｸﾀﾞﾗﾈ

>>173
> 関数の返り値と返り値が代入される左辺値の型が厳密な言語仕様にするとか･･･。

long long fn();
long long a;
long b, c;
a = fn();
b, c = fn();

やっぱり曖昧な罠。
.hファイル相当だけじゃなく.cファイル相当も見ればわかるけど、それじゃ分ける意味が・・・。

>>174

BrainFuck ならスレがあるぜ！
http://pc2.2ch.net/test/read.cgi/tech/1036013915/

>>177
long intとかのintを省略できないようにすればよい

long long int => long long ひとつ
long int long int => long ふたつ

(int,long,float)fun(double,char,short);

じゃだめなの？

じゃあ、返値もオーバーロードさせてほしいな。

(void*, void*, void*, void*)foo(int, int, int, int);
void bar(char*, long*, int*, doube*);

....

bar((char*, long*, int*, double*)foo(1,2,3,4));
　　//cast from (void*, void*, void*, void*) to (char*, long*, int*, double*)

>>181
それって返値を絶対に受け取らなきゃいけない訳で。

SQLのIN演算子みたいのはサポートしてもらいたい。

fruit_t f = GetFruit();
if( f == FRUIT_RINGO || f == FRUIT_BANANA || f == FRUIT_ORANGE || f == FRUIT_MIKAN ) {
っつーのが、結構無様に見える。

if( GetFruit() in ( FRUIT_RINGO, FRUIT_BANANA, FRUIT_ORANGE, FRUIT_MIKAN ) ) {
って書きたい。

委譲の明示。
public class A {
private B b;

public void method1( int i ) delagate to b; // 委譲(同名メソッド)。引数も引き継ぐ
public void method2( int i ) delagete to b.method20( i ); // 違うメソッド。引数は明示。
};

構文を拡張できる言語ってなにかありますか？

>>186
Lisp

>>184
switch (GetFruit()) {
case FRUIT_RINGO:
case FRUIT_BANANA:
case FRUIT_ORANGE:
case FRUIT_MIKAN:
    foo();
}

じゃ駄目?

>>184
PASCAL ならできる。

せっかくだから集合論型言語。
> FRUIT = ( RINGO, BANANA, MIKAN )
> RED * FRUIT?
( RINGO )
逆に
> RINGO := RED * FRUIT
> BANANA := YELLOW * FRUIT
> MIKAN := ORANGE * FRUIT
と定義して、
> FRUIT?
( RINGO, BANANA, MIKAN )
と集合を返すこともできるとか。
・・・Prologみたいな。

>190
え、prologでできるんじゃ？

俺の大好きなLispとCを合体させた言語の仕様を考えてください。

>>192 C のどこがお好きですか?

>>192
LISPで適当なトランスレータ作るとか。
Ｓ式と違って、文法的なエラーを早い段階で検出できるから、
素で書いてくよりも効率いいし、append系を演算子にすると楽だよ。
Ｓ式自体もread使えばそのまま埋めこめるし。

define flat-tag = lambda(tag, totag, s) =>
　let loop (x=s, r='()) in
　　if pair?(x)then
　　　if tagged-list?(car(x), tag) then
　　　　loop(append(cdar(x), cdr(x)), r)
　　　else loop(cdr(x), cons(car(x), r))
　　 else　`(,totag ,@(reverse r));
define-macro +s x => flat-tag('+s, 'string-append, x);
define-macro +p x => flat-tag('+p, 'list*, x);
define-macro +l x => flat-tag('+l, 'append, x);
define fib(n)=>if n < 2 then n else fib(n - 1) * fib(n - 2);
define factorial(n)=>if n=0 then 1 else n * factorial(n - 1);
↓
(define flat-tag
　(lambda (tag totag s)
　　(let loop ((x s) (r '()))
　　　(if (pair? x)
　　　　(if (tagged-list? (car x) tag)
　　　　　(loop (append (cdar x) (cdr x)) r)
　　　　　(loop (cdr x) (cons (car x) r)))
　　　　`(,totag ,@(reverse r))))))
(define-macro (+s . x) (flat-tag '+s 'string-append x))
(define-macro (+p . x) (flat-tag '+p 'list* x))
(define-macro (+l . x) (flat-tag '+l 'append x))
(define (fib n) (if (< n 2) n (* (fib (- n 1)) (fib (- n 2)))))
(define (factorial n) (if (= n 0) 1 (* n (factorial (- n 1)))))

>>193
本当はC++が好きです
何でC++が好きかというと・・・なんでだろ？

>>194
なるほど、参考になります

陰関数が使えたらな〜

陰茎が使えたらな〜

ﾊｰﾏｲｵﾆｰたんが使えたらな〜

ﾊｰﾏｲｵﾆｰたん「使っていいのよ」
おれ「ありがとう。助かるよ。」
ｼｭｯｼｭｯ

ﾊｧﾊｧﾏｲｵﾆｨたん「やらないか？」

ウホッ、いいﾊｧﾊｧﾏｲｵﾆｨ

main()
{
　int i↓
　for(i = 0→ i < 5→ ++i)
　{
　　printf("%d\n", i)↓
　}↓
　(ﾟдﾟ)ｳﾏｰ
}

>>202
何がおもしろいのか分からない。

Cに汚染されてるな

確かに多重継承は制御がややこしいけど、
インタフェイスのみだと不便なこともあるよね。
Template Method パターンを２つ以上使う必要があるときとか。

多重継承をもっと簡単かつ安全に取り扱う文法ってできないかな？
もしくは、それに変わる新しい概念とか。

あぼーん

>>205 な貴方は Ruby の Mix-in で感動せよ

>>205
Javaのintarfaceの中でもメソッドが定義できると良いよね。
intarfaceのメソッドを継承先で、マクロ、テンプレートみたいに
コードを展開(コピペ)すれば、javaの構造を変えずに出来るのに・・・

>>208
"実装込みのインタフェース"って、あまり美しくないような気がします。
で、こういうのはどうだろう。

public interface I { // インタフェース
    void foo();
}
public class A implements I { // デフォルト実装クラス
    void foo() {
        // : perform...
    }
}

public class C implements I {
    private A a = new A();
    I implemented a; // ←これ！Iのメッセージは全部aに委譲
}

>>209

　COM っぽい。。。ATL なんかだとマクロでそういうのやってますよね。
インタフェイスを要求された時点でダイナミックに委譲先を生成したりも
できる。

>>207
一応 Mix-in は知ってるのですが、
本読んでもあまり継承との使い分け方が分かんなくて。
Mix-in の御利益とか教えていただけるとうれしいのですが。

>97
(if (let loop ((i 0))
　　　(cond ((< i 100) #t)
　　　　　　((eq? (func) 'NG) #f)
　　　　　　(else
　　　　　　 (func2)
　　　　　　 (func3)
　　　　　　 (loop))))
　　(print "normal loop end")
　　(print "loop break"))

;; bug fix

(if (let loop ((i 0))
　　　(cond ((>= i 100) #t)
　　　　　　((eq? (func) 'NG) #f)
　　　　　　(else
　　　　　　 (func2)
　　　　　　 (func3)
　　　　　　 (loop (+ i 1)))))
　　(print "normal loop end")
　　(print "loop break"))

便乗して
//sexpr->mll(>>213);

if let loop(i = 0) in
　　if i >= 100 then
　　　#t
　　else if eq?(func(), 'NG) then
　　　#f
　　else
　　{
　　　func2();
　　　func3();
　　　loop(i + 1);
　　} then
　print("normal loop end")
else
　print("loop break");

//mll->sexpr(↑);

(if (let loop ((i 0))
　　　(if (>= i 100)
　　　　#t
　　　　(if (eq? (func) 'NG) #f (begin (func2) (func3) (loop (+ i 1))))))
　(print "normal loop end")
　(print "loop break"))

>>184
(if (memq (get-fruit) '(ringo banana orange mikan))
　　'fruit
　　'unko)

age

>>209
いや、単純に
intarface a {
void foo();
void bar(){ foo(); };
};
てな感じで関数barのようにテンプレートメソッドが
インターフェイスに作れること。

ほんとの所javaでは単一継承しか許していない。それをインターフェイス
というトリッキーな方法で多重継承もどきをやっている。
お陰でメソッドコールが早い。

多重継承の概念と
インターフェイスの概念と
似てるけど
根底に流れる思想は
違うものなので
勘違いなさらない

>>211
mix-inで有名といえばruby

javaでmix-in?なMixJuce
ttp://staff.aist.go.jp/y-ichisugi/ja/mj/
ttp://cvs.m17n.org/~akr/mj/design-pattern/design-pattern.html

mix-inよりdelegete(C#)
ttp://www.asahi-net.or.jp/~dp8h-izn/delegate.html

intarfaceやmix-inでは無く集約を使おう？
ttp://www.skpl.com/or/vol3/no10/syuusyokurep1.html

>>218
思想が違うのは理解している。
大体別の思想を持っていなかれば別のプログラミング言語
なんて、でっち上げないよ。

でも思想に振り回されてはいけないね。
もちろん宗教にしてもいけない。
思想も所詮、生きるための道具だしね。

>>219
アリガ?ｫ。
Mix-in のこと、全然分かってませんでした。
やっぱ Ruby の本３日で読んで
そのまま貸しちゃったのがいけなかったか。

要するに、継承関係が２次元になったということでいいんでしょうか？
既存のクラス構造をそのままに、新しい機能を追加できる、と。
Ruby だと変数に固定された型がないので分からないのですが
（Mix-Juice の例では例が端折られ過ぎてて宣言がないですし）、
Mix-Juice では、モジュールを拡張した場合
その基底モジュールのクラスの変数に
拡張モジュールのクラスのインスタンスを入れて
ポリモーフィズムを実現することもできるのでしょうか？

module m {
　define class c {
　　define void f() { ... }
　}
}
module n extends m {
　define class c {
　　define void f() { ... }
　}
}

m.c v = n.c.new();

みたいな感じで。

文法なんてもう古い。
ttp://compsoc.dur.ac.uk/whitespace/

>>222
アホだ、すげえ笑った。

>>222
最高にﾜﾗﾀ
http://compsoc.dur.ac.uk/whitespace/count.ws

Cでもwhitespaceでも動くプログラムはすぐ作れそうだね。（ほんとか？）
作る気にもならんが。

>>225
ああ、なるほど。そういうものですか。

よくわからんが、空白文字以外は全て無視するのか？

>>227
スペースと改行とタブ以外は無視。

>>221 自己レス
いろいろ読んでると、
「今はできないが、将来やれるといいな」
みたいなことを書いてるようですね。
MixJuice は Java VM で読めるように変換してるから、
静的にじゃないとだめなんでしょか。
一方 Ruby だと動的にできるようですね。

>>222
Brainfuck スレにも出てきたアレですね。
スペースとタブと改行でプログラムするという
印刷できない言語。

書かれたものがいくつも構文解釈されうるのってなんか面白いね。

「Whitespace」とは。

最近のプログラミング言語の殆どは空白文字（スペース、タプ、改行）の文法的な意義を考慮しない。
さも、そこにはいなかったかのように単純に無視するだけである。
これは、キャラクタセットの中のとてもフレンドリーなメンバーに対して
ひどく不公平な仕打ちであると我々は考える。
果たして彼等が目に見えないという理由だけで単純に無視してしまって良いものだろうか？
「Whitespace」はこの不公平の是正を目指して作られた言語である。
空白文字以外の文字は全て無視される。
つまり「空白」、「タブ」、「改行」、これらだけが「Whitespace」の文法構成要素として認められる。

つまり、インデントが文法に組み込まれてる Python は
パーフェクトということでつか？

Haskellも、空白文字を使ったレイアウトが文法に組み込まれてる

Mix-in を読んで、結局多重継承とはあまり関係がないのでは、と思ったり。
MixJuice でも多重継承は多重継承でやってますし。
MixJuice の Mix-in はどうも C++ の namespace や
Java の package の拡張に相当するような気がしますね。

もし、拡張したコードとの間にポリモーフィズムが成り立てば、
多次元継承のようなものができることになりますね。
Ruby だと変数が型付けされてないので実現できちゃいますね。

C++ だと fstream が ifstream/ofstream と直接の継承関係にないのですが、
多次元継承ができれば直接の継承関係を持てることになりますね。
　base.istream　←　base.iostream
　　　　↑　　　　　　　　↑
　　file.istream　←　file.iostream
みたいに。

全部XMLで書く言語とか

>>235
XSL

XML->sexpr
sexpr->XML

sexp >>>> XML

>>234=205
ダイヤモンド継承問題って知ってる？

>>228
ということは、>>225が言っているのはCのソースに同じように動くwhitespaceのプログラムを埋め込むということ？Cが空白をセパレータとしか見ないのをうまく利用して。

>>239
知ってるから困ってるわけで。
>>234 なんかもモロにダイアモンドなんですけど、
そういうのが比較的安全で手軽に扱えるような仕様が欲しいんですよね。

クラスを使用しなくて、基本型を複数
かえせる関数がほしいなぁ〜

こんな感じで
(x,y) = getPoint();

goto 152;

(ﾟДﾟ)ｳｳﾞｧｰ

>>243
スマソ

let (even,odd) = partition(even?, '(1 2 3 4 5)) in

主語を書く。
Iはプログラマ。使わない。
YOUはコンピュータ。your keyboardとか。
HEは通常のユーザ。
You show Word "Hello World" by your display.
mustは必ず実行。canは気分で変わる。

> HEは通常のユーザ。
男尊女卑だとの苦情がくる。it にすべき。

> You show Word "Hello World" by your display.
syntax error.

import ソケット

私はソケットです{
　public ソケットは"google"と通信します。
public ソケットは"string"を公開します。
}

私はソケット.new

>>248
it だと物みたいだな。
he/she とか they（たとえ単数でも）とかにしる。

userとかではダメなのか？

>>251
I, youとしている以上、代名詞で揃えたいんじゃないか?

英米語圏が激しく有利ですね

i18n, m17n によって各語圏へ対応します

まったく新しい文法ではないな。　英語の文法そのままにしただけっしょ

どっちかというと古い文法だ

今の若者には古いものが新しく見えるのです

>>241=205
ダイヤモンド型からW型に変えれば？
結構知られているネタだと思うけど。

一様の説明
javaのintarface見たいな感じでstreamとinputableとoutputabe見たいに分けて
istream = stream + inputable
ostream = stream + outputable
iostream = stream + inputable + outputable
という風に継承すればよい。

× 一様
○ 一応

どうでもいいけど、案外欲しいものはそろってるってことだなぁ〜。
まいなーチェンジばっかり

こんなのどう？？？

ファイルのオープンもクローズもいらん言語
いちいち、めんどくさい

#include <system.h>
を自動でやるオプション

if( x== ( 1 | 2 | a+3 ) ){
...
}

>>259
？？？

>>257
実装を多重継承することはもう諦めるしかないんでしょうか。
アレは ios があるからダイアモンド継承が起こるわけですが、
アレは iostream で istream からも ostream からも
同じバッファを操作するために
ios にバッファを置いておく必要があるというわけですよね。
もちろん実装を継承しなければそういうことをする必要もないわけですが、
istream で実装したことと同じことを
iostream ででも実装しないといけないのは
あまりエレガントじゃないなぁ、と。

って、あ！
もしかして、そこで Mix-in が活躍するのでしょうか？
同じ実装を include する形にすれば、
実装を継承せず、かつ２度書く必要も無い、と。
これが >>207 の言いたかったことなんでしょうか？
これは感動！


ファーストクラスを持つ言語では、
多重継承をしたら必ずダイアモンド継承問題が起こるんですよね。
だからこんなにこだわってるわけで。
ファーストクラスが欲しい。でも、多重継承もしたい。
でも、Mix-in で多重継承をエレガントに回避できるのであれば、
多重継承を諦めても問題ありませんね。

用語がまずいかも？
ファーストクラスってのは違うかも。
まぁ、とにかく、
暗黙的に与えられるあらゆるクラスの基底クラスのこと。

可変個引数があると便利っす。

>>259
if( x in { 1, 2, a+3 } ){
...
}

みたく書ける言語なら、あったんじゃない？

まあ、C以外の言語触ってから文句言えってこった。

昔からある手法を語る場か？ここは（ﾜﾗ

a , b : array[0..99] of Byte;

begin

元
for i := 0 to 99 do a[i] := a[i] + b[i];
　
　新命令「全部やれ命令」
　a[0..99] + b[0..99]; //0から順にb加算　

a[0..50] * 100://a全部に100を掛ける

ここの人ってLISPのマクロで適当な構文試したりはしないの？

そもそも lisp をいじったことが無い人が多そう。

lisp自慢房発生

縦書きとか、右から左に書くとか

http://www2.leverage.jp/start/

条件演算子 and or があるのに but がないのは手落ちなので追加。

じゃあついでにローテートシフト演算子みたいなのもつくってくれんかな

まぁ、そういわずに勉強させて下さいよ。

いや、申し訳ないんだけどね。

not

>>270
lisp自慢房>>>>>>>>>>lispｼﾗﾝ房>>>>>>>>>>「lisp自慢房発生」とかｻﾌﾞｲこと言う奴
ちなみに俺はlispﾏﾀ-ｸｼﾗﾝ房

>>271
>縦書きとか、右から左に書くとか
文法とは言わない。
奇抜でもない。
メリット皆無。
そんなあなたも>>270に比べれば全然素敵です。

じゃ、縦書きで。

文法宣言がある言語。

syntax {
　expr := op expr expr
　　　　　　-> eval_expr(op, value_of(expr), value_of(expr))
　　　　| '(' expr ')'
　　　　　　-> expr
　　　　;
　
　op 　:= '+' -> ...
　　　　| '*' -> ...
　　　　;
　:
};

* (+ 1 2) (+ 3 4)

>>279
メタ言語の文法はどうするのか？
lisp のマクロと、どう違うのか？

>>280
>メタ言語
適当に作って定義を自己記述できるようにしといて
それを変更することによってメタ言語も変更可能にする。
(ことが可能かどうかは俺は知らん。)

>Lispのマクロ
よく知らんが、LispマクロはあくまでS式から離れられないんじゃ？

カレンダー指向プログラミング

４月１日 int funca(int a)
{
　a = a*2;
　return a;
}
４月２日 int funca(int a)
{
　a = a*3;
　return a;
}
４月３日 int funcb(void)
{
　int b=funca(5);//昨日のものが適用される
int c=昨日のfunca(3)*一昨日のfunca(4);
　return c;
}
※ちかい日付のものは多少スペルが違ってもＯＫ．あらかじめ納期をメモできる

じゃ、逆斜め書きで

>>282
ノイローゼですか？

>>283
>じゃ、逆斜め書きで
文法とは言わない。
奇抜でもない。
メリット皆無。
そんなあなたもノイローゼ。

そこにレスするあんたはノイローｚ（ry

（＾＾）

　　 ∧＿∧
　　（　　＾＾ ）＜ ぬるぽ（＾＾）

Lispの括弧は何故"(", ")"なのですか？
タイピングのしやすさを考えると、"[", "]"の方がよいのではないでしょうか？
エディタの補完を使うので括弧は直接打たない、というのであれば、
なおさら、"(", ")"である必要性もないと思うのですが。

[] だとカッコ悪いから。

>>289
[]でプログラミングして置換しろ

()を使うことが多いですが[]も普通に使えますけど。
カッコが多重ネストして見難い時は混ぜたりするし。

[...]にsuper-brace(超括弧)の意味が割り当てた処理系もある。
([(((((((((])
は
((((((((((()))))))))))
と同じ。

仮想関数に対するアクセス修飾 (public / protected / private) を、
オーバーライドしてもそのまま引き継がせることが出来たらなと思う。
自由に変更できてしまうのが気持ち悪くてどうにも。

class Base {
protected:
　virtual void hidden_impl() = 0;　// 公開すべきではない
};

class Derive : public Base {
protected:
　virtual void hidden_impl();　// OK
public:
　virtual void hidden_impl();　// NG: Base::hidden_impl() は protected
};

これなら、継承クラスでうっかり public に書き間違えたままという
ことも無くなっていいな。

でどうしても継承クラス側でアクセス修飾を変更したいときは __force
キーワードを使う。例えば __force public: は、public ではない仮想
関数のアクセス修飾を強制的に変更する。そうでなければ public: と
同義、ということにする…

class Derive : public Base {
__force public:
　virtual void hidden_impl();　// OK: private から public
　virtual void done();　　　　 // OK: done を公開する
};

class Derive : Base {　// 非公開継承
　virtual void hidden_impl();　// OK
protected:
　virtual void hidden_impl();　// NG: Base::hidden_impl() は private
};

キーワードやたらと増やすの良くないと思います

>>296
そういって増やす代わりに既存のキーワードに複数の意味を持たせて分かりづらくなった言語があります

>>294,295
言わんとすることは分かるが、このスレ的には面白くないな。
目新しさがない。

>>289
"(",")" である必要がないというのはもっともです。
CommonLispでは reader-macro という機構によって
"(",")" のような記号もプログラマが自由に再定義
できるようになっているところをみると、昔の人も
そう思ったのでしょうね。

ただエディタで閉じ括弧を補完することは現代の科
学力ではまだ無理だと思います。

>>297
キーワードやキーワードに持たせる意味を増やさなければいいのでは？
そういうのは極力少ないほうが言語が長持ちするとポールも言ってます。

それよりも syntax-sugar を自由に定義できるような機能を言語に備え
ておけばすむ話でしょう。

じゃーLISPやSchemeしかないじゃん。もしくはDylan？
C++とかもtemplateを構文に対して行える様にすればよかったのにね。
ていうかなんてこんな下なんだろ。

>syntax-sugar を自由に定義できるような機能

#define loop for(;;)

C#です

ループ場所指定の中断再開
while( label: a != b )
{
　while( c != d )
　{
　　break label ; // ループ指定break/continue
　}
}

最初とか最後とかの判定手段
foreachは最初の時と最後の時に特別な処理が多いから
せっかくの糖衣構文が使いにくくて・・・
foreach( label: object cur in dataSet )
{
　if( label.isFirst )
　{
　　これは最初要素のときだけ実行
　}
}

無名メソッド、クラス、その他
リテラル定数ならぬリテラル関数が欲しい
delegate double funcdDlegate( double x ) ;
....
{
　funcDelegate a = { double ( double x ) { return x * x ; } }
}

>>303
> リテラル定数ならぬリテラル関数が欲しい
で、前半との関連は不明ながら、結論はこれ?

>>303
ラムダ式ね。
「全ての関数はメソッドでなければならない」言語では
あまり導入したがらないのかもね。

まぁ、LISP でもやっとけってことかな？
Ruby でも近いことできるけど。

l = Proc.new{ |x| x * x }
p l.call(9) # 81

構文というわけではないですが
ブロック内で生成されたオブジェクトを、
ブロックから抜けた時点で確実に開放するという機能が欲しいです。

ブロックGCの例
blockgc: {
　new hoge,hage,mage;
　return hage; //
}
//hoge,mageはこの時点で必ず開放される。
//hageはreturnされるので参照が切れない。

GC 使わんで free すればよかろう。

>>307
freeのある環境ならそうしてますが。

>>303
ほしい理由は判るけど、もうちょっと
カッコいい構文にならんか？

>while( a != b ) label {

>#once{この中のコードは１度しか実行されない}
onceのアイデアは、Eiffelの構文より導入

最後の例は、いかにもラムダっていう感じだが
メソッド内で関数が定義できれば良いんじゃないんかな？
class foo {
public method:void bar ( ) {
function:double squea ( x:double ) { return x*x; }
funcDelegate a = new funcdDlegate(squea);
}
}

GC のある環境でそんなこと気にすんな。禿げる。

>>310
でも、変なタイミングでGC呼ばれると困るかも・・？
と解決できない不安要素を抱えるのも禿げる原因になるのでは？
時間コスト掛かっても良いから、
一定のタイミングを保証したい場合とか。
ちなみに俺は禿げてませんよ。

羊頭狗肉スレだな

>>310
そじゃないでしょ。
開放するタイミングをコントロールしたいというのが
導入の動機でしょ？C++では良く使われている手だし。

でもGCが働いてほしいときに「ゴミ収集.回収開始();」
と書ければ良いんじゃない？

関係ないけど、「ハゲとプログラマの因果律」ってスレ立てていい？
つーか俺のプロバイダじゃ何故か立てられないから、誰かたのむわ。

>>313
C#スレにいって愚痴れ。

>>314
最初の内容をここに書いてみて

>>316
世界にはハゲの侵攻を司る何らかの律、
運命というものが存在するのだろうか。
少なくとも人は自分の頭髪さえも自由にはできない。

>>303
あんまり制御構文を複雑にするな
どうしてもというならPython使え
Pythonの制御構文はスゴイぜ

>>317
マ板に立ててきたから逝って濃い
http://pc.2ch.net/test/read.cgi/prog/1051029981/

>>310
メモリはともかく、ファイルやソケットは自動的に閉じて欲しいよね。
まぁ、C++ とかで出来るのでこのスレでこれ以上話しても仕方が無いが。

>>319
ありがとう

ディープコーダーさんにとっては
ガベージコレクションに利点は無いでしょ？

で、本題
個人的にはオブジェクト定義言語とか欲しいね
VC++にある機能ではあるけどコード補完が簡単にできるような仕組み
各エディタに標準装備されたら楽でいいなぁとか思う

>>304 >>309
短いメソッドが多めになって、もはや何メソッド宣言書いているのかプログラムを書いているのかわからないし
メソッド名がめんどくさくなって
void m000()
void m001()
...
void m218()
なんかアホ臭くなって、で
delegateHoge a = {
{ void () { 処理いろいろ } } ,
{ void () { 処理いろいろ } } ,
{ void () { 処理いろいろ } } ,
...
}
とメソッドの配列を作りたくなってしまったんでつ

>>309
実はそれも考えたんですけれど
C系の言語は、文法が "while( 式 ) 文" だから、
for( 色々 ; 色々 ; 色々 ) label ;
例えばラベル付きで空のfor文、要するに
for( 色々 ; 色々 ; 色々 ) ;
のラベル付きを考えると気持ちの悪いことになるなと思って、括弧の中に入れてしまいました。

そういやC#にもgoto無いんだっけ。

while( a != b )
{
　while( c != d )
　{
　　break label ;
　}
} : label;
breakってループの最後に跳ぶわけだから、
ラベルはブロックの最後についた方がいいんじゃないかと
考えているのはオレだけ？
C系の構文に追加するのは無理があるとは思うが…

continue はどうなるの？

>>324
Cのfor文て、好き&良いと思っていますか？
漏れは、ダサい＆嫌いです。
いっそBASIC見たいにの"FOR()TO()STEP(){}"としたほうが
解析＆理解しやすいと漏れは思う。

でもラベルはfunction,method,classなどの名前付けの構文と
統一できたほうがさらにカッコよさげな言語になりそうな予感。
だから326さんの案も好きじゃない。

>>327
判ってると思うけど"continue label;"でイイでしょ？
while( a != b ) {
　while( c != d ) {
　　continue label; /* a!=b に飛ぶ */
　}
} : label;

どのみちラベル置くならgotoの方が判りやすい

>>328
「制御構文オブジェクト」があればいいんだと思う。
break も contine も foreach の最初や最後も、全部その「制御構文オブジェクト」にメッセージを
送るという形式で、for の中身や while の中身は、そのオブジェクトのメソッド定義の糖衣構文。
そうなれば統一されててよいと思う。

>>313
>開放するタイミングをコントロールしたいというのが
なぜ開放タイミングをコントロールしたいのか、が気になるね。

でも>>320の言うように、一時的なオブジェクトのファイナライザ(デストラクタ)の
呼び忘れを防止するような機構が欲しいね。

{
　　temporary Hoge hoge = new Hoge() finalize hoge.finalize();
　　temporary File file = new File('hoge.txt') finalize file.close();

　　while (!file.eof()) {
　　　　:
　　}
　　// ブロックの終わりで、hoge.finalize()とfile.close()が呼ばれる。
}
とか。

new使わなきゃいいじゃん

いや、C++以外でっちゅう話

(call-with-hoge (lambda (hoge) (call-with-input-file "hoge.txt" (lambda (file) ...

>>331
スコープ脱出時での各種自働処理っていうのは確かに欲しいんですが、
エグイのはそのオブジェクトをスコープ外の超寿命なオブジェクトが参照してしまったときです。
まさか勝手に消えてなくなられては困るし・・・
object に寿命に関わるなんだかの属性をつけて、特定の属性からは参照しようとするとエラーとすれぱ上手くいくかちょっと興味深深。
それができれば、ついでにガベージコレクタのオプティマイズもかなり良くなりそうな気がする。

>>335
Generational GCみたいなもんか?

>>336
目的がスコープ脱出お知らせシステムだから、もうちっと積極的。
自動的にGenerational GCインサイドになるでしょうね。

>>335
いや、ファイナライズメソッドを呼ぶだけで消さない、というほうが現実的じゃない？
Javaは、ごみあつめされたときにfinalize()が呼ばれるわけだけど、それを
もうちょっとコントロールしたい、と。gcを直接実行するよりコストが低い方法で。

で、スコープ外の超寿命なオブジェクトは、参照したオブジェクトがファイナライズ
されたあとのオブジェクトなのか、まだ使えるのかをチェックしながら使う、と。
(この辺の注意事項は、スコープ脱出時の自動処理があろうが無かろうが同じだよね)

>>338
簡易な方法もいいのですが、この手の問題は結構多い気がします。
とりあえずgcがメモリーしか見ていないのが原因の問題は多いですね、
一般的なオブジェクトはデータのようなメモリーさえあれば良いものばかりでなく、
I/Oその他のリソース量・質がメモリーと違う物を参照している物があって、それに合わせたガベコレも必要です。
この辺は考えればかなり面白い物ができそうな気はなんとなくするんですが・・・
それもかなり一般化された形でできそうな気がします。
現状でも頑張れば何とかなりますが、この辺りはまとめてシステム側が面倒みてくれれば楽チン。
ユーザーによる機能拡張可能な総合リソース管理システムみたいなのができると面白いかと。

リソース管理をするもの、それを OS という。

C#にも関数内関数がほすぃな〜
void func( double a )
{
　double b = 5 ;
　System.Console.Write( hoge( 2 ) ) ;
　void hoge( double x )
　{
　　return x * a + b ; // a b はともにこの関数のスコープ
　}
}
見たいに書けたら便利

そんなものよりclosure。

はっきりいってAlgol系の言語に属されている人ばかりですね。
もっとLisp系やProlog系にも触れた方がいいよ。

>>343
Lisp系、Prolog系の特徴を教えてください
殆どの型は知らないのですよ、そういうの。
いや煽りでなくて。

>>343
おれもそう思う。
>>344
そんなの検索しろよ。

>>345
何でこっちで調べんといかんのよｗ
このスレの発展のために言ってるんだろ？

何言ってんの？
スレの発展の話なんてしてないだろ。

LISP系はマクロとか結構柔軟だから「文法」の話なんかする必要ないじゃん。
PrologやHaskelとか出てこないのは使ってる人が少ないというだけ？
それとも、文法的な不満は無いということかな？

>>343
LISP を勉強した時は結構感動したな。
Prolog も勉強しようと思いつつ暇が無くてできない。
本は買ってるんだが。

Haskell 辺りになると、もう創造できんというか、思いついた瞬間に苦笑してしまうことが多いしね。
いまどきの言語に取り込んで欲しいネタなら山程あるって感じだね。

Prologの典型的なコードの例

die(X) :- man(X). // 規則:
man(ソクラテス). // 事実:

?- die(ソクラテス). // 問い(実行開始)
> yes. // 結果

>>351
うぉ、何か面白い。Prolog触ってみよっかな

>>348
Prologは知らんがHaskellは知っているヨ！
ttp://www.sampou.org/haskell/
で見てみ。
手続き型言語しか知らんものから見ると、まさに新次元新発想

オブジェクト指向が流行りまくって、関数という考え方がちょっと無さ過ぎるのは最近の言語の欠点だね。
こちら側もやり始めるととてつもない深さがあんるんだけど・・・
非正格関数、正格関数がいまどきの言語に欲しい今日この頃、C#つけて欲しい、template とセットで。

>>354
D言語のドラフトにはテンプレートがあるらしいよ
OOPだけどｗ

>>353
> モナド I/O システム
ﾜﾛﾀ

>354
F#は遅延評価はできるみたいよ。つーか見た感じ関数型といえる部分はそれだけのような…
（使ってはいないので、間違ってるかも。）

純粋な関数が実装できたら、それに計算コスト情報を追加して欲しいと思う。
たとえばMath.Sin() とか Math.Cos() とかを正格関数、計算コスト少々大とかに設定しておいて
while( hogehoge )
{
　y += Math.Sin( x ) * Math.Sin( x ) ;
}
このとき最初のMath.Sin( x )は実行する必要があるが、
プロシージャーではなく関数であれは一度目の実行だけで、二つ目はキャッシュしておけば良い。
可読性を上げたときにパフォーマンス低下防止に役に立つと思う。

>>358
関数型言語を知らないようだな。
同じ入力に対する同じ関数の出力は同一というのが普通。

>>359
358がいいたいのは

Math.sin(x) の計算コストが高いときは
y += Math.sin(x) * Math.sin(x); と書いても
実行時には自動的に
double sinx = Math.sin(x); y += sinx * sinx;
に置き換えてほしいという風に見えるが。

> 可読性を上げたときにパフォーマンス低下防止の役に立つと思う。
というのもパフォーマンスをあげるためにキャッシュ代わりに
一時変数をたくさん使う必要がなくなるという意味だろうし。
なぜ関数型言語を持ち出すのかがわからん。

>>358
型推論持ってる関数型言語だとその場合、
Mathに副作用がないことが証明されてれば
自動的にやってくれると思う。
実行時じゃなくて、コンパイル時だけど。

だから、一度関数型言語やってからにしてくれ・・・

>>361
全てに対して値のキャッシュをすると、それはそれで問題もあるので、有効なものだけチョイスして欲しいと思ったんです。
それにしても、なんか妙に関数型に反応する人がいますね(藁

>>360
関数型は関数型、これはこれで便利。
もしもそれがあるならば、「計算コスト少々大」とかといった情報を付加すると
効率的にパフォーマンス制御が可能になるねといいたかったんです。
パフォーマンスをあげるために関数型ではないです。

なんか誤解のタネがわかったような気がする、Math.Sin とかって書いてあるのはC# です。
スマソ

どのみちC#でもそれぐらいはやってくれると思うけど。
Mathって特別扱いしてそうだし。

終了

catch(...) {

try_lock文

使い方

try_lock(obj){
//ロックできた！
}else{
//ロックされてたのでロック出来なかった！
}

とりあえず新しい文法云々言うのは、こんくらい勉強してからですな。
LISP/Scheme, Haskell, Ruby, Python, C#, Java, C++, Delphi, Prolog

漏れは...まだまだだな...。

>>370
そんなに沢山憶えると、新しい文法を考えて実装する前に、実装できるパワーがなくなってしまう年になりそうです。
文法の構築は、見掛けよりもその背景にある思想が重要と思う。
大きく別ければ、によって駆動されももの、関数型、論理型の三つ。
さらに、プロシージャー型には、構造化プログラミング型とオブジェクト指向型が
関数型には非正格関数、正格関数があるわけですが。
この中から代表的なものだけチョイスしておけば十分と思うのですがどうでしょ。
それ以外では、
アセンブラとyacc/lexまたはJavaCC
これは判らないと、文法矛盾その他実装不可能が見えなくなって、論外の言語クレクレ小僧になってしまう。
ちなみに自分は論理型が弱いです、何とかしないと・・・

>>371
大きく別ければ、手続きによって駆動されももの、関数型、論理型の三つ
のミスでした。

OOPが何故流行ったか？　＞　ニーズに沿ってるから。
需要の少ない理論手法を持ち込んだところでそんなものは流行らない。

>>371
> そんなに沢山憶えると、新しい文法を考えて実装する前に、実装できるパワーがなくなってしまう年になりそうです。
まぁ、20代の中頃から後半くらいにはなるでしょな。
ただ、いろいろ知らないと「そんなん既にあるやん」ってことになるし、
既存の文法を知らないとその発展もできないわけで...。
LISP, Ruby, C#, Java, C++ は達成してるので、
あと最低でも Haskell, Prolog くらいは知りたいと思う所存。
Python と Delphi は時間があれば...。

> アセンブラとyacc/lexまたはJavaCC
確かに。新しい文法を考えてる時、こいつらの知識はフル稼働してますね。

>>371
> 文法の構築は、見掛けよりもその背景にある思想が重要と思う。
思想重視だと、好きじゃない機能を入れた方が良かったり、
なかなかストレスが…

> これは判らないと、文法矛盾その他実装不可能が見えなくなって、論外の言語クレクレ小僧になってしまう。
最近、意味解析で解決するような文法が多くなってる気がする。
書き易さ重視ってことなんだろうけど。

> ちなみに自分は論理型が弱いです、何とかしないと・・
論理型は正直捨ててる。
Lispはかじった程度なので、一度本格的にCommon LispというかCLOSを。
あとはEiffel。

はへ？　言語の文法自体は簡単に覚えられるっしょ？
２２歳だけど
>LISP/Scheme, Haskell, Ruby, Python, C#, Java, C++, Delphi, Prolog
のDelphi以外は勉強したよ？

>>376
別にそれで実装してる必要はないものな
概念が分ればそれでよしみたいな

どうでもいいがD言語ドラフトを日本語訳してくれないかね
個人的にOOPの最終形態だと期待してるのだが

>>376
Haskell,C++ を難なくこなせるとしたら、それは大した物だと思います。

しかも22才か・・・凄いな。

１６進数で２２歳かもしれないね。

>>376
まぁ、文法自体はね。
その意義とか理念とか理解して、さらに発展させるだけの状態になるのは
もうちょい時間がかかるのではないかと。
でもまぁ、正直
＞実装できるパワーがなくなってしまう年
になるまでには十分達成できると思うけどね。
早ければ24〜25歳程度で大丈夫っしょ。

C++のアクセス指定子にfriendがあるように
これを拡張してwifeやhusband, father, mother, brother, sister..を作る！
ドイツ語やフランス語に男性名詞・女性名詞があるように
int や longを拡張して male int や female long を作る！！
そんな文化人類学的プログラミング！！！

勝手に作れ

Whyループ

why (?) {
　　...
}

huhループ

huh (?) {
　...
}

oldコンストラクタ。
間違って破棄しちゃったオブジェクトが復活。

Object o = old Object();

fuck*関数

mother fucker() {
　return >>384;
}

always
他に usually, often, sometimes, seldom, never 構文も。

文の最後にpleaseを付けるとエラーが出にくいとか。

察してください
って感じ？

漏れは関数型と手続き型言語を学べば良いと思う。
MLやHaskellをやれば論理型プログラミングを多少は学べるし
新しい言語を作るには最低でも各言語で中級（イディオム＆パターン）程度の腕が居るだろうし
そうするには２，３年程度はかかるだろうねー
それからとなると年いくつになっているだろう？

>>373
ニーズとは？やっぱ大規模開発？
他の言語でもいけるのでは？

>>375
LispよりScheme。CLOSもあるし。
継続は覚えた方が方が良いでしょう。
ＣＰＳは言語制作者になりたければ覚えている方が吉

>>391
は？　

>LispよりScheme。CLOSもあるし。
>継続は覚えた方が方が良いでしょう。

なんかおかしい。

OOPは現実世界のものの繋がりをプログラムに表したものだから
マスターしてしまえば能動的に組めると言う利点がある
文系プログラマにとってこれほど喜ばしい手法はなかろうて

関数型言語を導入するとバグが極力少なくなる事が証明されている。
これはオブジェクト指向言語を導入するよりも極端に影響する。

>>392
フルCLOSがあるのはCommonLispでっせ。
Schemeのはそれと比べてしまうとエセっぽい。
それでも実用上十分だけど。

あ、>>392じゃなくて>>391だ

つーかCLOSはCommon Lisp Object Systemなわけですが。

>関数型言語を導入するとバグが極力少なくなる事が証明されている。
>これはオブジェクト指向言語を導入するよりも極端に影響する。
関数型言語で減るバグっていうのは
副作用の無い関数にバグがでにくいからだよね？

OOによって減るバグっていうのは
全然違うタイプのバグでしょ。

ｿﾝﾅｺﾄﾅｲ

Rubyが400げと！

ｿﾝﾅｺﾄﾅｲﾖ

>>391
MLやHaskellを論理型と言ってるのは
型推論とかパターンマッチとかそういう奴のことを指してるの？

>>375
ただ言語のエッセンスを知りたいと言うだけなのにCLOS
のフルセットって要るん？

>>398
でも関数型言語を使っている例は少ない。
なぜ？

どちらかというと型推論かな？
402さんは、どう思う?

>>404
MS が処理系を提供してないから。
悲しいけど、これ現実なのよね。

>>405
引数のパターンマッチも結局は型推論なんで
型推論と言えばそれでよかったですね。

>>406
viewというのも有るよね

>>406 自己レス
ただ、MS も F# とか言うのを出すみたいなんで、
これからどうなるかは分かりませんな。
ML/Caml + .NET とのたまってるようだけど、どうなんでしょな。

>>403
関数型言語でオブジェクト指向がどう実現されているかを知りたくて。
それなら、O'Camlって手もあるんだけど、CLOSの影響を受けてる言語って
よくみかけるんで。

F#ってCallbyValueなのか
Lazyの方が楽しいのに
CallbyNameでもいいのに・・・

マジ？＞F#ってCallbyValue
サンプルコード、チラッと見て勝手にlazyだと思い込んでた。
確かにそれだとあんま面白くないなあ。

「Lazy」って遅延評価のことだよね？
Camlって先行評価じゃなかったっけ。

>410
メリットが無かったんでしょ

ifは「もし〜なら〜の処理をする」
caseは「〜の場合〜の処理をする」
forとwhileは「〜の間中〜の処理をする」
という意味だよな。
要するに「もし〜なら、〜の場合、〜の間中」の発想から離れればいいわけだ。
だが「〜の処理をする」は不可欠だよ。処理をしないとプログラムにならんからな。
つまり「〜の処理をする」の前提の部分を他の言葉に置き換えれば新しい文法になるわけだよ。わかるかな？
たとえばnot ifというのはどうだ？
「もし〜でなかったら〜の処理をする」という新しい文法だよ！
またif andやif orというのも考えられるぞ。
「もし〜かつ〜だったら〜の処理をする」「もし〜または〜だったら〜の処理をする」という新しい文法だよ。
またnot caseは「〜でない場合〜の処理をする」
while selectＡ,Ｂ,Ｃは
「〜の間中、ＡとＢとＣの中から適当に処理を選んで実行する」だ。
これだと人口知能向きの言語だね。
おまいらよ、新しい発想というものはこうやって考えるものだよ！！

>>414
ネタにもならない長文書くな

>>414
if の中の論理式に not 付けろ、switch の中に乱数入れろ。
そんな物は新しくならなくてもいい。
専用言語ならお砂糖構文で十分。
この種の問題は前提とかではなく、選択と繰り返しが肝、従来の文法の殻を破るならこの部分だよ。
数学が得意なら、集合論とか圏論とかにネタがあるだろうに、詰め込んだそれは使用不能かよ。

新発明「ifif文」

ﾓｼﾓｼ?

>>413
はぁ？

Lazyのメリットはいっぱいあるよ
長さが無限の配列を使えたりとか
if文がパターンマッチで表現できたりとか

>>414
人口無能さん、氏ね。

>>419
413じゃないけどLazyのメリットって

>長さが無限の配列を使えたりとか
>if文がパターンマッチで表現できたりとか

これだけですか？
これら２つは全体をLazyにする程の問題とは思えませんが。

▼新次元新発想！新しい文法を作るスレ
http://pc2.2ch.net/test/read.cgi/tech/1047970129/l50

「バカめ」と言ってやれ、って感じ。
こんなことは言語製作者たちは既に考えていて、実装している。
しかも、さらにその先まで考えている。
多分C/C++プログラマは画期的な文法を提言しているつもりなのだろうが、とっくに時代遅れだ。
だから、最近のプログラマは勉強不足だっつーんだよ。
ブックフェアに行ってこい。もっと言語を覚えろ。文法を見ろ。
プログラマを名乗っていたいのならば、
C/C++以外の言語も勉強しないとダメなんじゃないの。

>>419
Lazy ねぇ。
別に無くても似たことできるしねぇ。
無限リストは別に普通に再帰で実現できるし、
if 文もどきも

(* O'Caml *)
let if_org(b, th, el) = if b then th() else el();;
let rec pow n x =
if_org(n = 0, (fun () -> 1.), (fun () -> x *. (pow (n - 1) x)));;
pow 2 3.;;

ってやればできるしなぁ。
まぁ、わざわざλ式使わなあかんのがかっこ悪いけどな。

引数使わないときに速いとかいうのも、
どこまで効いてくるのやら。

おお、最近のたらい回し関数（竹内関数）ブームをご存知ないと！？
「竹内関数」＋「たらいまわし」でぐぐると出てくるよ

たらいまわし関数って、ただのベンチマークじゃないのん？
まぁ、たらいまわし関数以外でも速くなることもあるんだろうけど。

>>424
わざとらしくRubyと比較させてるところがなんとも（ｗ
今のところ非正格が有利に働くのはごく一部の計算についてだけです。
http://www.bagley.org/~doug/shootout/lang/ocaml/
http://www.bagley.org/~doug/shootout/lang/ghc/
http://www.bagley.org/~doug/shootout/lang/ruby/

Ruby な人だから Ruby と比較してるだけかと。

Ruby でもイテレータ使ってこうすれば
遅延評価できて随分速くなるぜよ。
不恰好だけどね。
まぁ、それでも Haskell （Hugs）より遅いけど、
それはインタプリタの性能とかも効いてくるしねぇ
（Ruby のインタプリタはそんなに速くない）。

def tarai( x, y, z )
xval = x.call
yval = y.call
if x.call <= yval
then yval
else zval = z.call
tarai(Proc.new{tarai(Proc.new{xval-1}, Proc.new{yval}, Proc.new{zval})},
Proc.new{tarai(Proc.new{yval-1}, Proc.new{zval}, Proc.new{xval})},
Proc.new{tarai(Proc.new{zval-1}, Proc.new{xval}, Proc.new{yval})})
end
end

puts tarai(Proc.new{12}, Proc.new{6}, Proc.new{0})

あ、修正し忘れ。
x.call を２度書いちゃってる。
if 文の x.call は xval にしてね。

うわ、これ修正したら Haskell より速くなっちゃったよ（笑

部分的に遅延評価できるようにする文法を導入する...
というのも、文法がややこしくなるなぁ。
かといって、特別な文法を用意しないと
上のコードみたいに不恰好になってしまう。

ならば、特別な文法を用意せずとも
不恰好にならない文法ならいいわけか？

一応実測値を出しておこう。
インタプリタなんでどこまで比較できるのか知らんが。

Cygwin/Windows XP
CPU Mobile Pentium III 1.13GHz
メモリ 256MB

Haskell（runhugs：>>424のコード）
real 0m0.445s
user 0m0.220s
sys 0m0.200s

Ruby（>>424のコード）
real 0m23.077s
user 0m19.878s
sys 0m0.040s

Ruby（>>428-429のコード）
real 0m0.099s
user 0m0.060s
sys 0m0.030s

>>432
ttp://www.loveruby.net/~aamine/ja/tdiary/20030425.html#p08
好きなだけまわせ

>>433
確かにコンパイルした Haskell は速いですな。
ただ、うちは GHC を入れてないので、
うちでは比較できませんな...。

ところで、先に比較するのは反則なんでしょうかね？
随分速くなりますけど。

#include <stdio.h>

int tarai(int x, int y, int z) {
int nextx, nexty;
nextx = (--x <= y) ? y : tarai(x, y, z); ++x;
nexty = (--y <= z) ? z : tarai(y, z, x);
return (nextx <= nexty) ? nexty :
tarai(nextx, nexty, (--z <= x) ? x : tarai(z, x, ++y));
}

int main() {
printf("%d\n", tarai(768, 384, 0));
return 0;
}

実行速度を優先するならcかFortranでもやっていなさい
別の言語を使う、作るというのは別の発想をしたいからでしょ？
あんたたちが考えているより、遙かに人間の思考は言語によって左右される。
言語っていうのは、もっとスゲエもんなんだよ。

>>435
Cで普通に組むより速いから、こうして話題になってるわけで。
既存の言語にももっと目を向けなさいってこった。

>>436
言われなくても、勝手に勉強してす世。
やっぱ今の時代、実行速度より開発速度の方を優先しますよねー

ていうか、新しい文法はまだかね？

>>437
非正格が作る文法は、無限サイズのデータを取り扱うと他の言語では到達不能なまでにシンプルになんるだよ。
シンプルという事は、開発速度に効果するということなんだよ。
実行速度の特殊性だけが特徴じゃないんだ。

>>439
まちがえた、非正格は文法じゃないな・・・なんていえばいいんだろう？

意味論ですかな？
簡約戦略(実行方法)かな？

仕様です。

統語論syntax
意味論semantics

O'Caml での無限リストの実現法

type 'a seq = SeqCons of 'a * (unit -> 'a seq);;

let rec (&~) n step = SeqCons (n, (fun () -> (n + step) &~ step));;
let sqcar (SeqCons (a, _)) = a;;
let sqcdr (SeqCons (_, a)) = a ();;

let rec sum_to n sq =
　let n' = sqcar sq in
　　if n' > n then 0
　　　　　　　 else n' + (sum_to n (sqcdr sq));;

sum_to 6 (1 &~ 1);;

十分シンプルじゃね？

まぁ、通常のリストとは別扱いになっちゃうあたりが甘いか。

これなら一応両方いけるね。

type 'a seq = SeqNil | Cons of 'a * (unit -> 'a seq);;

let rec ( &~ ) n step = Cons (n, (fun () -> (n + step) &~ step));;
let rec ( ~: ) = function
　　[]　　　　　-> SeqNil
　| (n :: rest) -> Cons (n, (fun () -> ~:rest));;

let sqcar = function
　　Cons (a, _) -> a;;
let sqcdr = function
　　SeqNil　　　-> SeqNil
　| Cons (_, a) -> a ();;
let null = function
　　SeqNil　　　-> true
　| _　　　　　　 -> false;;

let rec sum_to n sq =
　if null sq then 0
　　　　　　　else let a = sqcar sq in
　　　　　　　　　　　if a > n then 0
　　　　　　　　　　　　　　　　else a + (sum_to n (sqcdr sq));;

sum_to 6 (1 &~ 1);;
sum_to 6 ~:[1;2;3;4;5;6;7;8;9];;

HaskellではLazyを基本としている所が、凄いんです。
馬鹿には、それがわからんのです。

少しの記憶力と抽象化する能力、論理的思考の持ち荷主で
あれば、オブジェクト志向が流行ったり始めた時と
幾つかの共通点（パターン）を発見できるはず。

MLに限らずLisp(delay)でも悪名高きC言語(関数ポインター)でも
遅延評価できますって。

Lazy にしかできない、というところに違和感を感じる。
Lazy にする必要のないところでも Lazy になった場合にも、
効率はいいの？

lazy じゃなくていい式を lazy に評価しても、 call-by-need ならあんまり変わんなそうな気がするけど。
逆に、 lazy にしない理由って効率だけ？

lazy の問題は副作用をどうするかってほうじゃないかと思う。

>>447
> MLに限らずLisp(delay)でも悪名高きC言語(関数ポインター)でも
> 遅延評価できますって。
例えば、Cだとどんな風になるの？
頭の悪い俺にもわかるようにサンプルきぼんぬ。

>>448
lazy の式でも実行時はlazy で無くてよい式と判別可能な式は結構あるし、
全部lazyでOKではと思うこともあるね。
ガベコレのようにこなれるといい方法も出てくるかも知れない。

>>449
副作用が必要なら、それは手続きにした方が素直じゃないかな。
関数型が効率よい理由の一つは、関数の中に全ての処理が閉じ込められていて
他に影響を与えないことが明白であると言うことだと思う。
lazy であるかどうかに関わらず、関数なら副作用は禁止したほうがよいのではと感じます。

そういや、前に2chで新言語を作ろうみたいなスレで、
副作用の無い関数の定義はfunction hoge{}で、
副作用の有る手続きの定義はprocedure hoge{}にしよう、
ってのを提案してる香具師が居たが、
Haskellだとモナドが副作用の有る手続きで、それ以外は
全部副作用が無いってことで、既に分離が実現してるんだよ、ね？

>>449 は何か読み違えてるっぽい…効率の話は lazy 側から出てたね。
とりあえず二行目撤回。
素直に書いてもそれなりに効率よく動くって、大きいと思う。


>>452-453
その場で評価される手続きと、必要になるまで評価が遅延される関数とを分離する、って形になるのかな。
lambda 式みたいなのの手続き版があると便利そう… monad がそんな感じなのかな？

副作用が多く使われそうな局面って、 I/O とかだろうけど…
手続き導入するのと、関数の枠組みで対処する方法用意するのと、どっちが使いやすいんだろ。
関数だけにしちゃうほうが言語仕様はきれいになりそうだけど、 code は似たような感じになるのかな…
それとも、手続きがあると、関数に渡した手続きが評価される時期とかで悩んだりするのかな…

>>450
447 じゃないけど、ちょっと思いついたので、
まず、関数型に手続型プログラムをトランスレートする。
トランスレートした先はlazy関数型である。
それをコンパイル実行する。
チューリングマシン万歳ってなところで。

実際C等のコンパイラのコードオプティマイズ手段として一旦関数型に落として計算の依存関係を調べて
パイプラインストール防止のための命令スケジューリングを行うというのは有りです。
これを一歩進めた形で実現可能か？
部分的ならokは間違いないと思うが全体的にはどうだ？
Cでいうところの関数越えのオプティマイズはかなり無茶があるぞ？
そもそもトランスレート先はlazyが効かない書き方にならないか？
とかとか、問題も結構多そうな予感。
やってみないことには謎ですね。

>>447
かなり興味深深です、実際の所どんな風になっているんですか？

CでLazyは簡単だよ。あまりにも簡単なので拍子抜けする人続出だと思うけど。

LispでもLazyをやるときは,lambda関数でLazyにしたい処理を
くるんで後の関数に渡す。後の関数は、それを受け取って
適切な時に実行する。ある種の意味でパターンだと思う。
delayとforceを使って遅延評価するのは、あくまでlambdaより簡単に
遅延評価使えるからだと思う。

lambdaでLazyが出来るんだから関数ポインター"typedef void* (*lambda)(void*);"でも
理屈上できる。関数型言語になれている人でないと考えずらいですし、めんどくさいで
しょうでしょうがね。

そういうことです。呆れたかな？

C なら構造体にしてパラメータと一緒に渡さないとナ。
C++ だと operator() を持ったクラスを作って渡すのがパターンだな。

作業量が多すぎて実用にならなさそうなパターンだな

>>456
よくわからんので実際にコード書いてくれ。

今度から関数といえば
　　y = f(x)
のことを表す。

>>458
STL のアルゴリズムとか使った事無い？
まぁ、個人的には作業量多くて確かにあまり使いたくないのだが。

>>461
STLの場合は限定的な使い方しかしてないから十分実用範囲じゃない？
遅延評価用に関数オブジェクトなんて使ったら気絶しそうだ

幼女を意のままに操る文法ください

>>462
関数オブジェクト？使えば良いじゃん。
なんで嫌なの？
効率？(Pool使えば良いよね？)
変？(一種のCallbalckだと思えば？)

関数オブジェクトはC#のdelegateみたいだ。
故にクソだ。

そもそも関数がオブジェクトなんてオブジェクト指向的にわらっちゃう。

可読性重視のAA文法

　 ∧＿∧ 　　
　（　´∀｀）＜　Helo World

>>464
まぁ、Ｃ＋＋だとそれで仕方が無いけど、
ラムダ式のある言語を知ってると、
やっぱそれと比べちゃうんだよね。

boost::lambda とか使った事無いけど
どんなもんなんでしょ？
使える？

>>468
ありゃ冗談にしか使えねーよ。

>>464
そういう問題ではなく、一体何百個クラス作るつもりですか？
といいたかったのですが

>>470
必要なだけ。

C++ でも Java みたいな無名クラスが使えたらねぇ。

C++でもLispみたいな無名関数(lambda)が使えたらねぇ。

#include <iostream>
#include <vector>
#include <string>
int main(){
std::vector<std::string> c;
c.push_back("Hello, ");
c.push_back("world!");
std::for_each(
c.begin(),
c.end(),
lambda<void>(int x){ std::cout << x << std::endl; });
}

$ icl --enable-lambda lambdatest.cpp
$ ./lambdatest.exe
Hello, world!

int x?
std::string x じゃなくって？

>474
何言語ですか？

Intelのコンパイラみただけど、拡張されてるのか？

http://homepage.mac.com/ayaya16/

妄想言語？

--enable-lambda
という時点でおかしいとは思わんのか。

>>479
新しい文法です。
つか、それがこのスレの趣旨じゃねーのかよ

C++ にとっては新しいが、
一般的に見れば別に新しくも無いわけだが。

G++ では動いた。
あとは知らん。

#include <iostream>
#include <vector>
using namespace std;

#define LAMBDA_NAME2(line) labmda##line
#define LAMBDA_NAME(line) LAMBDA_NAME2(line)

#define LAMBDA(algo, b, e, ret_t, param, body) \
　class LAMBDA_NAME(__LINE__) { \
　public: \
　　static ret_t labmda param { body; } \
　}; \
　algo(b, e, LAMBDA_NAME(__LINE__)::labmda);

main()
{
　vector <int> x;
　x.push_back(1);
　x.push_back(1);
　x.push_back(2);
　x.push_back(3);
　x.push_back(5);
　x.push_back(8);
　LAMBDA(for_each, x.begin(), x.end(), void, (int i), cout << i << endl);
}

一部 lambda の綴りが違うが気にするな。

お、これでもいけるな。

#include <iostream>
#include <vector>
using namespace std;

#define LAMBDA_NAME2(line) labmda##line
#define LAMBDA_NAME(line) LAMBDA_NAME2(line)

#define LAMBDA(algo, b, e, ret_t, param_body) \
　class LAMBDA_NAME(__LINE__) { \
　public: \
　　static ret_t lambda param_body \
　}; \
　algo(b, e, LAMBDA_NAME(__LINE__)::lambda);

main()
{
　vector <int> x;
　x.push_back(1);
　x.push_back(1);
　LAMBDA(for_each, x.begin(), x.end(),
　　void, (int i) { cout << i << endl; });
}

>>474,483,485
新でもなんでもない。
ttp://www.kmonos.net/alang/boost/classes/lambda.html
もっと時代は、進んでるぞ。せめてネタとして、この本でも読んどけ。
ttp://www.biwa.ne.jp/~mmura/ModernC++Design/

ハァハァハァ　a
ソコダメ　b

z = a + b

print z

実行結果

妊娠しますた

そういうネタには飽きた

int a, b, z;

z = a + b;

print z;

実行結果

最近つぶやきシロー見ないぞ

C++は穴だらけ

>>490
何を今さら。

>>490
そんな穴は自分で埋めればいい。そんなん誰でも、できるでしょ？

だいたい関数型言語や論理学や数学から見れば
手続き型言語は穴だらけ。それをみんなが避けているだけー。

森、言語を、推奨、した、いので、すが、いかが、でしょう、か？

,を、無視、する、言語でし、ょう、か？

>>493
？

失言を、使って、プログラム、する、言語、でしょう、か？

>>490
玄人ならば、ダメだダメだと言う前に使いこなして見せましょう
穴があるから使えないは素人の言い訳

>>497
そういう発想がデザインを腐ったまんまにしてしまう要因だと
ノーマン氏が言ってたス。

>>498
腐敗したまんまということにはならんでし？
これだけプログラミング言語が豊かなのに・・・

／￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣
|　やはりC++はくさっていると・・・
＼
　 ￣￣￣|／￣￣￣￣￣￣￣￣￣￣￣￣
　　∧＿∧　　　　　　　／￣￣￣￣￣￣￣￣￣￣￣￣
　 （　・∀・）　 ∧ ∧ ＜　・・・
　（　　⊃ ）　 (ﾟДﾟ；)　　＼＿＿＿＿＿＿＿＿＿＿＿＿
￣￣￣￣￣ （つ＿つ＿＿
￣￣￣日∇￣＼| BIBLO |＼
　　　 　 　￣　　　=======　　＼

>>497
http://www.namazu.org/~satoru/misc/bad-knowhow.html

>>501
バッドノウハウっつーか
「穴があることが利用される理由」の言語に「穴をなくせ」とは何だよと思うがね。
穴が有るのが困るなら、穴を潰したC++であるJavaやC#が有るのだから、素直にそれを選べば済む話。
JavaやC#だと予定の仕様が実現不可能なときには積極的にC++を使うんだよ。
それ以外には、もうすでにあるプログラムの保守、保守で利用するならこれもまた、穴も含めて上位互換でなければ意味が無い。
歴史のある言語は、その歴史を無視して言語仕様を拡張すると、ただの妄想言語となる。
それでも嫌なら新規言語にするべき。

>「奥が深い」といって喜びを見出す「奥が深い症候群」
この問題については同意したいが、「奥が深い」と感じるときには必ずその裏に重要なヒントが隠されている事が多いから
言語を作ろうっちゅー人間がバッドノウハウだから勉強不要というのはどうかね、賛成しかねるね。
これは、作る側の話ではなく使う側の話だね。

>>501
>バッドノウハウは、ソフトウェアの複雑怪奇な仕様が歴史的に引きずられ
>根本的な改善は行われないまま、そのノウハウが文書によって受け継がれ
>ることによって蓄積が進行する。Unix 上で広く使われているツールとして
>はTeX, Emacs, sendmail, bind, perl, gnuplot, procmail などは、役に
>立つツールであると同時に、その複雑怪奇な仕様によって長年に渡って
>ユーザを苦しめ続け、バッドノウハウの温床として悪名が名高い。

sendmail bind の部分では納得するが(一度デファクトスタンダードになってしまうとなー)
emacs perlは思想的にバッドノウハウがあることを前提に作っている。
そしてTexが挙げられているのは納得できない。
この文章を書いた人自身のセンスを疑う。

>「奥が深い」といって喜びを見出す「奥が深い症候群」
Schemeの継続もこの一部か？

>>502
>この問題については同意したいが、「奥が深い」と感じるときには
>必ずその裏に重要なヒントが隠されている事が多いから
禿銅

>>503
>複雑怪奇な仕様が歴史的に引きずられ
と
>emacs perlは思想的にバッドノウハウがあることを前提に作っている。
は同じ意味じゃん。

lambdaccha

>>503
> そしてTexが挙げられているのは納得できない。
> この文章を書いた人自身のセンスを疑う。

TeXの文法は相当変態的だと思うがな。
少なくとも俺の周りの人間はだいたい同じように思ってる。

TeX は汚い。
これ、定説。

>>503
> そしてTexが挙げられているのは納得できない。
> この文章を書いた人自身のセンスを疑う。

キミのセンスを疑う。
何故 TeX を wrap する LaTeX が存在するのか？
LaTeX でも十分変態的だが。

> >「奥が深い」といって喜びを見出す「奥が深い症候群」
> Schemeの継続もこの一部か？

「概念そのものが (一見) 分かりにくい」と「複雑奇怪で分かりにくい」とは全くの別物。

文法が複雑奇怪であるのには何の技術的意味も無い。

>>504
>>複雑怪奇な仕様が歴史的に引きずられ
>と
>>emacs perlは思想的にバッドノウハウがあることを前提に作っている。
>は同じ意味じゃん。
歴史的は外的要因。前提に作っているのは内的要因(主体的)。

>>507,508
どこが汚いの？漏れには綺麗に見える。
具体的に言って？

>>508
>>>「奥が深い」といって喜びを見出す「奥が深い症候群」
>> Schemeの継続もこの一部か？
>
>「概念そのものが (一見) 分かりにくい」と「複雑奇怪で分かりにくい」とは全くの別物。
漏れは継続自体に価値が無いとは思っていない。CPSなんて括弧イイと思う。
でも通称のcall-returnと継続を比べるとcall-returnの方が圧倒的に勝つともう。

>>509
> TeX
読みやすいようにと空白や改行入れるとたまに変な空白が表示されたり。
特に命令をいくつも使う場合や
マクロでいろいろプログラムしてる時に。
そのプログラムもまたシンタックスシュガーが殆どないので汚い。
スタイルファイルで使われる @ の入った命令名も分かりにくい。
引数を通し番号を使って参照しないといけないのは極悪。
...

S 式で書ける TeX きぼ。

>>510
>読みやすいようにと空白や改行入れるとたまに変な空白が表示されたり。
>スタイルファイルで使われる @ の入った命令名も分かりにくい。
>引数を通し番号を使って参照しないといけないのは極悪。
この部分は同意する。Texの悪い点だと漏れも思う。

>そのプログラムもまたシンタックスシュガーが殆どないので汚い。
この部分は漏れは好きだ、無いのにも理由がある。
紙一重だとも思う。

>>509
> でも通称のcall-returnと継続を比べるとcall-returnの方が圧倒的に勝つともう。

「勝つ」って、いつのまに競争なんかしてたんですか？

>>509=503
Texなんて書いてる輩がどれだけTeXについて知っているのか甚だ疑問

>>513
>新しい文法を作るスレ
新しい文法に何を採用するかという競争

>>514
何度か使ったときがあるだけです。Tex自体は、たいして知りません。
でも良い物だと思うんだけどなー。

>>515
> 競争
別に競争してる訳じゃないがな。
勝手に競争と後ろに付けるな、と。

> Tex/TeX
突っ込まれても気付いてないし。
というか、大して知りませんの状態で
なぜそこまで TeX が奇麗だと強く主張できるのだろうか...。
あと、別に TeX が悪い物だとも言ってないし。
文法が汚いといっただけで、利用価値は高い。

>>509
>歴史的は外的要因。前提に作っているのは内的要因(主体的)。
糞とわかってる仕様を採用するのは歴史に引きずられてる
以外の何者でもないよ。

おまいら、撒き餌をむさぼるのも程々にしないと針まで食っちゃいますYO

ｺﾞﾒｿ、プログラミング知らないけど何となく、らしいこと書いてみたかっただけだったり（ヮ

継続なんてイラネ。

ケイゾクってなにですか？

ｶﾀｶﾅで書かれるとなんかの映画みたいね。
continuation
http://www.sra.co.jp/people/aoki/SmalltalkTextbookJ/textbook27.html

2chのスレにがんがん書き込んでいけるような文法考えようよ
まず行を節約できる。インデントを使わない。

それよか全角空白を受け付けるようにした方が

>>523
PerlかLisp系が既に。

>>525
LispやPerlをインデント無しで書いて、読める?

LISPの清書は簡単

lisp は基本的にインデントなしでも、ほとんど支障はない

Lisp がインデントなしでも支障ないって、ネタですか？

LISPのインデントは全部機械がやるから
特に意識する必要がないって事では。
処理系に読みこませれば勝手に折り曲げるし。

インデントが必須な言語の方が少ないような。
俺は Python と ABC しか知らないなぁ。
Haskell は必須ではないけど、
シンタックスシュガーとしてインデントが使えるね。

a(b(c(d,e(f))));

ってのを、

e(f) and c(d,it) and b(it) and a(it);

って書くのはどう？　シェルのパイプみたいな感じで。
手続き型言語の中でつかうなら、
右結合よりこっちのほうが分かりやすいと思うんだけど。
あまり記号の種類が多いのは変態チックでイヤ。

分かりやすいような分かりにくいような...。
というか、そんなに見づらくなるほどネストするかな？

むしろ関数型言語向けだな。
つーかｶﾘｰ使えば必要無い罠。

括弧が連続してるとパッと見で分かりにくいかもね

全てをインデントだけで解決する言語。531のハスケル構文糖と同じかも
method1(method2(method3(var1, method4(var2))))を
method1
　method2
　　method3
　　　var1
　　　method4
　　　　var2

(method1
  (method2
    (method3
      var1
      (method4
        var2))))

このスレで"インデントが必須で無い"とかゆってるひとは、
自分が保守することになったコードがインデント無しでも
会社辞めたくなったりしないんでしょうか。

2chで、プログラムについて議論する時、
CやLispのコードをインデント無しでうpされても、
いやになったりしないんでしょうか。

>>523
そういうことですよね。

>>538
まるでｶﾞｷの発想だな。
>自分が保守することになったコードがインデント無しでも
>会社辞めたくなったりしないんでしょうか。
インデントすりゃいいだろ。アホか。

「インデント無しでも読めないことはない」
と
「インデントが必須でない」
とは全く意味違うんだが

インデント必須なら、きちんとインデントすることを文法レベルで強制できるから
宗教論争が起こらなくてよい。

そうある言語とそうでない言語との間で宗教戦争が起きましたが何か？

>>531
Occam

問題は、「インデント無しで吐き気もせず読める言語」が存在するかということだろ。
結論：無い。

N88-BASIC は?

ホワイトスペースを文法構造に取り込むなどとは愚の骨頂

>>546 にはこれがオススメ
http://slashdot.jp/article.pl?sid=03/04/08/0529232&topic=58&mode=thread

ネストする制御構造がある時点で駄目

文字コードをソースに含む時点で駄目

駄目な奴は何をやっても駄目

>>550
そんな自虐的にならなくても

インデントもタブとスペースで意味が変わるの？

やっぱPython, Makeにならってタブ&インデント

変数名やらに半角ｶﾅが使える。

>554
変に制限してなきゃ使えるだろ

変数名やらに朝鮮語が使える。

>>556
それは無理だな

文法を自分で定義できる。

>>559
Lispとかいうんだろ？

>>559
Lisp とか言ってるね。自分で。

Lisper は再帰好きだからな。

再帰するのは神

('A`)

おまいらよ、おれがいま研究している２方向量子ウォーク１カウンタオートマトンのアルゴリズムはだな、
出発点 (0,0,…,0), 吸収点 (1,1,…,1) の
n次元超立方体上の対称量子ウォークの
吸収時間は Tr Xn - 1 で与えられるんだよ。
ここで Xnは方程式の解となるんだよ。わかるか？
おれはいまそういう簡単な研究に取り組んでいるんだよ！！！

>>564
その問題に付いて語るベキことは多そうだ。
スレ立ててそっちで語るよろし。

>>564
それだけじゃあ、簡単すぎるのでやはり
>>565に禿同

正直、普通の日本語（標準語）でプログラムを書けるといいなぁと…

夢にも思わない

>>568
ﾜﾗﾀ

>>564
2方向量子1カウンタオートマトンと
量子ウォークの話が混ざってるぞ。

while(true)
{
　　while(true);
　　{
　　　　//2階層一気に抜ける
　　　　break(2);
　　}
}

>>571
どっちかのwhileがなくなった時点でbreakも修正が必要な罠。
しかも例の通りの２重ループならいいが、３重だったりしたら、
breakに気付かずに修正して不具合を引き起こす多重トラップ。
もうちょっと良く考えろたわけが。

というわけでラベルつき break を採用すればいいわけだ。

(call/cc
　(lambda(break)
　　(while true
　　　(while true
　　　　(break)))))

つまりbreak自体がラベル

> ラベルつき break
ダサっ

ここはCしか知らないインターネットですね

>>576
結構多くの言語に存在しますが何か。

例えば？
２種類以上書いてくれ

おまいらよ、おれはいま量子指向言語の構想を練っているよ。
ふつーの言語では演算によって結果を求めるが、量子指向言語ではすべての結果は重ねあわせの状態でそでに存在しているから、その中から求める結果を選ぶだけよ。
求める結果は重ねあわせの係数で決まるのよ。
このあたりがいままでの言語と大きく文法が異なるところだな。
つまり画期的よ！！！
おまいらよ、これからの言語といったら量子指向言語しかないぞ！！量子でない言語なんてザコだぞ！！

非決定性プログラミング言語なら
１９８２年発行の教科書にも解説載ってるけど
これとは別物でつか？

>>571
Bourne shell

　　　 　∧＿∧
ﾋﾟｭ.ｰ　(　　＾＾ ） ＜これからも僕を応援して下さいね（＾＾）。
　　＝〔~∪￣￣〕
　　＝ ◎――◎ 　　　　　　　　　　　　　　　　　　　　　山崎渉

をまいらよ、新しい文法を作ってみろ？

◎ちょっと見て見て！！◎
http://yahooo.s2.x-beat.com/linkvp/linkvp.html

>>579

Adaの名前付きループ脱出


Search: -- ループに名前をつける
for i in 1..n loop
　for j in 1..m loop --2重ループ
　　if d(i,j) = key then
　　　found := true;
　　　locX := i;
　　　locY := j;
　　　exit Search; -- exit文の後にラベルを書ける
　　end if;
　end loop;
end loop Search;
--exit後の制御はここに移る

頭悪そうな構文だね

>>581
その教科書に載ってるほうの言語の概略ｷﾎﾞﾝﾇ。
いや漏れもパソコンgoogleが壊れてて....(←謎)

Java にもあるだろ。＞ラベルつき break

ラベル付きbreakなんかイラネ

ラベル付きgotoと何が違うんだ？（w

ラベル付きgoto？
ラベルが付いてないgotoでもあるのか？

>>592
昔のベーシックは行番号で指定していたよ

ランダムワープ、いいんじゃない？新次元で。
不慮の事態で途中から始まってもある程度制御できるようなシステムが望まれると思うぞ。
りんごは半分に切ってもりんごなのにビットマップはヘッダの1ビット壊れたら何かわからなくなるのは大きな欠点だ。

ループを末尾再帰で書き直せば、条件分岐によるループ脱出は自明な形で現われる。

>>595
内部定義やnamed-letみたいな構文がないとしんどい
returnを明示的に書かせる言語だとさらにもしんどい

ラベル付きbreakがダメなら、

while(true)
{
　　while(true)
　　{
　　　　//ゴボウ抜きbreak;
　　　　unlimited break;
　　}
}
// ここまで一気に抜けてくる！

で、goto >>101;って言われる、と(w

ｲｶﾝｲｶﾝ、goto >>107;だった。
甚だ遺憾。

>>597
returnで済む罠。

>>599
そうなんだが、returnは関数で一個にしたいとか、whileの後にも処理したいとか
あるかな？って思ってサ。まぁ、基本的には要らん機能ではあるけどな(w

>>596
もちろん、そのように適切な基本的構文が備わっていることが前提だけどね

結局お前等のやってることは、関数型言語の再発明なわけだ。

結局、全てはVBに帰すっていう結論か

>>597

double break とかはいかが？

break(1);
break(2);
break(3);

で、

break == break(1);

>>604
それは>>572で欠陥が指摘されたﾖ。

おまいら、もっと他の言語を知れ
Cやその類似言語、Java、ましてや Delphi なんか使ってるとアホになるぞ

おまいら、もっと他の言語を知れ
MLやその類似言語、Haskell、ましてや Lisp なんか使ってるとアホになるぞ

斬新でもなんでもないが、

　if( 0<val<10 )

みたいな判定式が書けると便利だろうな…。

>>608
(if (< 0 val 10)
　...)

>>608
Python だと書けるよ。

if val in 0..10 {
}

Delphiでも似たようなことが出来るけれど、制限があって萎え(それでも使ってるけれど

>>611
val が実数でも大丈夫なの？

>>611
forじゃ無いの？　どういう動作なの？

>>611
ruby崩れ文法ですか？

>>574
こういう例を見てると、改めて関数型言語の偉大さがわかるな。
柔軟性が高い。

>>615
lisp (scheme) は関数型じゃないんだが

>>616
たまに「関数型とは認めない」という人が現れるのは確かだけど、
一般的には関数型とされているよ。

lisp が関数型か否かかはともかく、>>574 は関数型言語とは全く関係無いわけだが

>>618
関数型言語の「特色」と関係があるかどうかはともかくとして、
Schemeが一般的に関数型とされていて、>>574はSchemeである以上、
関数型とは関係あるわけだが。

手続き型では一般的に値とならないもの（ここでは継続）まで値となっている、
lambdaが使われている、などは関数型っぽい特色だと思うがな。

>>619
> 手続き型では一般的に値とならないもの（ここでは継続）まで値となっている、
それは関数型/手続き型とは関係無いわけだが

> lambdaが使われている、などは関数型っぽい特色だと思うがな。
それは関数型/手続き型とは関係無いわけだが

ここはひとつ、関数型言語のルーツということで。

>>620
>それは関数型/手続き型とは関係無いわけだが

関数型の大雑把な特徴としては、式を計算して値を返すことによって
プログラムが進む。ここでは、様々なものが値として表現される。

手続き型はの大雑把な特徴としては、繰り返し構造や条件分岐を用いて
手続きが適用される。ここでは、一般に繰り返し構造や条件分岐が
関数として表現されず、結果、値として表現されることも少ない。

まあ普通の言語にはこうした双方の大雑把な特徴が混じってるわけで、
このように綺麗に分かれてるわけではないが、俺としては、
関数型の特色と関係があると言いたい。

>>622
あなたの脳内定義なぞに興味はありません

whileもtail-recursionの構文糖だしね

>>623
論理的に反論してください。
定義が違うといいたいなら、あなたの思う定義と比較して
何がどのように違うのか、なぜその定義が一般的だと思うのか
そうしたことを言うのが筋だろう。
そうでなければ有効な反論にならない。

620=623
必死だな

>>624
シンタックスシュガーで表そうとするのが手続き型の特徴だよな。
そうしたものは、同等のものが関数で表せるし、さらにその関数が
値として扱えるから、関数型は柔軟なのだと思う。

>>627
なんか矛盾してないか？

手続き型言語の無駄な構文が思考の阻害になっていると思われ。
このスレがクソ文法養成所になってる事実からもそれがわかる。

>>625
端的にいうならば、「副作用」

>>629
まあ関数型言語にも一応シンタックスシュガーはあるけどね。
関数で代用することが多いな。

>>630
確かに副作用がないことは関数型の特徴の一つでもあると思うし、
その点では確かにSchemeは型に結構近い気がする。
しかし、やはり「値に関数を適用して計算する」というのも関数型の
大きな特徴であって、その意味でSchemeは関数型だと思うし、
>>574はその特徴が出ていると思う。
この後者があるからこそ前者が生きてくるという面もあるしな。

× Schemeは型に
○ Schemeは手続き型に

まあ、一般的には

副作用が無いもの（Haskell等）：純粋な関数型言語
副作用があるもの（Scheme等）：純粋でない関数型言語

と言われているんじゃないかと思う。
また脳内と言われてしまうかもしれないが。

>>574の本質は単なる long jump やん
なんで関数型とか手続き型とか出てくるわけ？

>>634
１ 継続を値として扱い、関数の引数にしている。
２ call/ccの引数が無名関数である。
３ 以上の二つの関数型に近いと思われる特徴により、機能が実現されている
４ したがって１、２により柔軟性が高まっていると考えられる
５ 関数型の特徴は有用である

実は継続呼び出しもlambdaネストの構文糖なのだが

>>633
Haskell はよく知らないけど、
流石に入出力はできるっしょ？
再代入がない、というべきでは。

継続があれば関数型かいな？

>>636
そうなのか。それは知らなかったな。
しかし、構文糖を使っていても、>>574の例が
関数型の特徴を使っていることにかわりはない
と思う。

ただ、下手に構文糖を乱用すると柔軟性が下がったり
仕様が肥大化する恐れがあるというだけだな。

>>637
入出力はあるけど、モナドという特徴によって実現されているため
副作用が出ないらしい。俺も詳しくは知らないが。

関数型言語スレ別館になりつつある様だな。

>>633
こういう見方もある。
副作用が無いもの（Haskell等）：洗練された関数型言語
副作用があるもの（Scheme等）：昔ながらの関数型言語

正確には副作用が無いわけじゃなくて、隔離してると言った方が正しい。

>>638
多分、それはあまり関係ないだろう。
ただ、継続が関数の引数に渡されているところが
関数型っぽい。

関数型は副作用を嫌うので代入を嫌うらしいけど、
継続を保持するのは代入や「状態」を持つ事にならんの？

call/ccを使った継続の抽出と呼び出しは副作用に分類されない。

継続は呼び出しても返ってこないから関数じゃないだろうに

さらに言えば、状態を保持する事自体は副作用とは関係ない

Haskelやcamlなんかも継続を持っているんですか？

呼び出しても返ってこない、のなら継続は関数型の特徴じゃないじゃん。

>>639
> ただ、下手に構文糖を乱用すると柔軟性が下がったり
> 仕様が肥大化する恐れがあるというだけだな。

構文糖衣は仕様を最小限にするためのものだよ
表現方法の多様性が増えるだけで柔軟性が下がるわけでもないし

while も関数型じゃないよな

>>640
そういう見方もあるね。

>正確には副作用が無いわけじゃなくて、隔離してると言った方が正しい。

よく見るHaskellの解説では、単なる隔離にとどまらず、
（少なくともHaskellの世界内では）完全に純粋な関数
であると主張してるように見えるが？
残念ながらこの点に関して詳しくは知らないので議論は
出来ないが。

あと、継続の中味自体が関数型であろうがなかろうが、他の部分（
継続が引数になってるところや、関数が関数の引数になってるところなど
）が関数型的だと思う。

>>648
いや、下手に乱用すると柔軟性がなくなったり、仕様が肥大化する。
今回のifやfor、switchなんかはその例。
おかげで、脱出が柔軟でなくなってるわけ。

>>644
帰ってくるし、値もあるよ

既に存在している仕様に構文糖を適用する→確かに柔軟性は失われない
言語仕様を関数でなく構文糖に頼る→下手にやると柔軟性が失われる恐れがある

帰ってくる場所が違うって

(break) という式に値はないだろ？

関数じゃないというのはそういう意味

>>574は継続の特徴であって関数型の特徴ではないのでない？
純粋な関数型なら副作用がないから式があれば関数の実行順序によらず
結果は同じになるときいたけど。
でも継続は思いっきり実行の「手続き順序」を変える仕組みに見える。

>>650
関数への引数として関数を渡すことにこだわっているけど、
手続き型の権化ともいえる C 言語にも関数ポインタという形で関数を値として持てるよ。
正確には関数の場所を示す値だし、関数型でいうところの「関数」とは意味が違うが、
副作用をもたないような関数であれば、本質的には関数型でいう「関数」と違いはない。

>>655
でも、継続が関数の引数に渡せなかったら、もしくは、
call/ccの引数が関数じゃなかったら、ああいう
実現の仕方には少なくともならないわけで、確かに
そういった関数型の特徴を使ってると思うよ。
関数型で無い特徴も使っているかもしれないけどね。

>>655
状態の保持は副作用とは繋がらない

>>656
だから、C言語のそうした特長は関数型に近いと思うよ。
手続き型と言われている言語にも関数型の特徴はあるし、
Schemeにも手続き型の特徴はある。
ほとんどの言語は手続き型的な特徴と関数型的な特徴が
混じってる。

でも、高階関数はたしかに関数型的な特徴というべきだと思う。
一般的にはそういわれている。

>>654
(break)は空リストが返る

>>574を見て判る様に、
継続を関数の形として呼び出せる。
ゆえに関数型。

くすくす

アセンブリ言語は、
アドレスを関数の形として call できる。
ゆえに関数型。

だってcall/ccのコンセプトってそうなんだもん

つまり他の言語だとアセンブラまで降りないと不可能って事か。

継続は厳密には関数ではない。
ただ、脱出プロシージャにパッケージ化されていて、
それは関数として扱える。
だから関数の形として呼べるし、値としても扱える。

脱出プロシージャを使ってるところは関数型的と言っても
良いだろう。

手続き型、関数型は同じ事象をどの観点で捉えるかの違いでしかない。
特にLispのように両者の特徴を兼ね備えた言語の場合は、どちらであるか、を議論することに意味はない。

それよりは大きな違いがあると思うな。
関数型や手続き型という分類が今日まで生き残ってる
のは、この分類にそれなりに大きな使い出がある証拠だろう。

Lisp全体がどちらかというのは、幾分か意味が少ないかもしれないが、
Lispの個々の機能については、これは関数型的であってこれは手続き
型的だと分類するのは意味のあることだろう。

今のLISPはC++の様にどっちつかずの言語になってる。
関数型、手続き型、オブジェクト指向、と入り乱れている。
歴史的理由と、保守してきた奴等のいいかげんな妥協の産物。

関数型の洗練度に順位を付けるなら、
ConcurrentCleanやHaskell>>>>ML>>Scheme>>LISP>>C
かな。
左に向かうにつれて、手続き型の考えが通用しなくなる。

継続一つで柔軟にいろんな機能が実現できるのはわかるが、
そのぶん、複雑怪奇なソースになりやすいという副作用はある。
かわりにシンタックスシュガーを追加する方法も、その副作用を
防ぐ意味では悪くないと思う。

手続型言語と関数型言語ってのは対立概念ではなく、
別に両方の性質を持っていても構わないようなものだと思う。

副作用を利用してでも手続き通りに命令を並べていくのが手続型言語で、
ラムダ式とかクロージャとか高階関数とかカリー化とか、
動的に関数を扱えて、その機能を容易かつ有効に利用できるのが関数型言語、
という分類でいいと思う。

副作用云々は確かに関数型にとって重要な話ではあるけど、
それは手続型言語か否かを測る目安であって、
関数型言語であるかを測る目安にはならないと思う。
だって、副作用云々は論理型言語にも重要だよ？

目安とかじゃなく、副作用を消したい理由は他にあると思うんだが・・。

>>672
> それは手続型言語か否かを測る目安であって、
> 関数型言語であるかを測る目安にはならないと思う。

逆でしょ
副作用があると function はありえずに procedure となってしまうが、
副作用がないと function でも procedure でも好きに呼ぶことができる。

対立概念ではない、というのは言い過ぎたかも。
両方の性質を持ちうるけど、一方を追求すればもう一方は消えてくる、と。

関数型、という名前の持つ意味としては、
副作用よりも関数を動的に扱う事を強調してると思う。
もちろん、関数型である事を追求するためには
副作用は排除する方向に行くんだろうけど。

論理型言語も副作用はなるべく避けたいわけで、
副作用だけで関数型言語か否かを測ってたら、
論理型言語と関数型言語の区別が付かなくなる。

>>635
> １ 継続を値として扱い、関数の引数にしている。
全然関数型固有の特徴じゃない。
どんな構文でも値を持つってのは、FORTHとかBoune shellでもいえる。

Functional Programming の肝って、返り値が引数にのみ依存することだと思う。
副作用頼らずに組めるとか、そういう program 最適化するとかが、 FPL に要求される点、特微になる点だと思う。

関数呼び出しの形で記述すること自体は、手続き呼び出しの形と、あんまり区別つかなそうな気がする。

高階関数は重要だと思うけど、もう珍しい機能じゃないから、あんまり特微って感じがしない…

無名関数は、便利だし C とかにはないけど、むしろ動的にいろいろできる言語の特微な気がする。
perl でも無名手続き作ったりできるけど、あんまり関数型っぽくないし…

継続を副作用とかじゃなくて引数として渡してる、って点は関数型っぽいかな…
関数との interface は引数と返り値だけ、っていう点で。
継続を global variable に保持しとく…とかのやりかたも、手続き型なら選択肢の一つになりそうだし。

なんか、えらく伸びてるが...

こういった、脂溶まっ節にうるさい奴で、いい言語書いた奴はいない。
問題は、論理的に綺麗かどうかではなく、マ達に使われるかどうかだ。

class obj unko(obj shine){
action:
add.shine=1;
response:
obj shine;
}

class obj main(obj null){
obj unko();
obj kuso=950;
obj print(obj unko(kuso));
}

int _;

for (;_;)//~~
{

}

>>676
関数型言語以外で任意の継続が値（関数オブジェクト）で
表せるものがあったら教えて欲しい。

>>677
それは、関数型プログラミングの有効性の一つではあるけれども、
一般的には関数型言語にそこまで要求されているわけではない。
言語仕様として副作用を備えている言語でも関数型言語と
呼ばれているのは事実。
だから、もっとゆるい条件であるのは確実だと思う。
やはり、高階関数や、カリー化などといったものも総合して
どれだけ関数型的な機能を備えているかだろう。
関数型的とは、究極的には「関数が式を計算して値を返す」
ということだと思う。
こうした側面を持つ言語は手続き型にも多いけど、それは、
「関数型的な側面もあわせ持っている」というだけのことだ
と思う。
FORTHは良く知らないが、あなたの言っていることから推測すると
関数型に近い側面を少しは持つ言語と思われる。

>>681
> >>676
> 関数型言語以外で任意の継続が値（関数オブジェクト）で
継続の話はしてない。

>>682
>>635は継続がファーストクラスオブジェクトであるという
話をしている。
>>676が継続の話をしていないというのであれば、>>676
の反論は的外れだと思う。

継続自体、関数型でなければならないってもんじゃないだろう。
Rubyにもあったぞ。

>>684
Rubyは関数型の特徴を大幅に取り込んでる。
オブジェクト指向の特徴の方を強調したいから作者がオブジェクト
指向型と言ってるだけだろ。

第一、継続があれば関数型だという単純な話ではなくて、
継続がオブジェクトで、「関数が式を計算して値を返す」のプロセス
に取り込まれているところが関数型だという話だ。

継続なんておもいっきし手続き型な概念やん。
gotoや、Cのsetjump/longjumpと本質は同じ。

インターフェースという表面的な部分だけ見て本質を考えずに
関数型に結び付けようとしているヒトがいるみたいだけど。

>>686
つうか、手続き型と関数型の違いって、インターフェイス（
プログラミングスタイルや、表現の仕方）の違いだと思うが？
むしろ、この違いを語るとき、インターフェイスが本質であって
実現している機能は本質ではない。

インターフェイスは本質かどうかはおいておいても、
関数型チックとも言うべきインターフェイスによって、
柔軟性がもたらされているのは事実だろう。

とりあえず SML/NJ の継続の型は関数ではない

継続の概念は思いっきり関数型だと思うが。

手続き型の最大の特徴は時系列とプログラムが一体成型だと言うことだと思う。プログラムの走行に関して時間軸が存在する(要するに上から順に実行していくのが基本になっている)のが手続き型の特徴と思う。
関数型の特徴はモノをいれると別のモノに変換する函を使ったプログラム、同じものを入れれば必ず同じものが出てくる、それ以外に機能が無いというのが特徴という普通の考え方が最もそれらしいと思う。
関数型等の非手続き型の言語は時系列が基本的に存在しない事(と思う)、少なくとも純粋に関数型を考えるならば、実行順所は決めるべきでないと思う、
当然手の込んだライブラリーを作ったりモナドとかで時系列を無理やり作り出さないと入出力等の時間的な順序が問題になる物が実現できない。
それが嫌なら、副作用を入れて妥協するしかないのだと思う。妥協しないとHaskellみたいになるんだと思う。
副作用等を持っていても、ポリシーが関数型でプログラムをしたいと考えて、その中での妥協なら
それは関数型言語といってもよいと思う。lispが関数型で無いという人はいないと思うし。

>>690
(1+1)*2と1+1*2の答えが違うように、関数型にも実行順序はあるでしょう。

>>691
実行順序どころか、それはすでに別の関数だとおもう。

>>692
計算の実行の順番が違うから別の関数なんでしょう？

>>693
ちょっと絶句しそうです(汗

順番が必要な所もあるし、必要じゃない所もある。
1*2 + 2*3は +の左右の順番は必要じゃない。

言語が関数型かどうかではなく、言語の個々の機能や、個々のプログラムが関数型かどうかを論ずべし

とりあえず、>>574 の while のところは関数型じゃないということでヨロシク

じゃあ、継続は関数型ということでヨロシク

ところで、whileのどの辺が関数型じゃないんだ？

while が意味を持つためには副作用が要るから。

begin (progn) も関数型でない。

>>699
Concurrent Cleanのwhileは関数型じゃないんだね？

Haskellですが何か？

while :: Monad m => m Bool -> m a -> m ()
while t s = do b <- t
if(b)
then do { s; while t s; return () }
else do { return () }

>>700

スマソ。知らネ。ref ぷりーづ。

スマソ、スペースが消えた。

while :: Monad m => m Bool -> m a -> m ()
while t s = do b <- t
　　　　　　　　　if(b)
　　　　　　　　　　then do { s; while t s; return () }
　　　　　　　　　　else do { return () }

>>702

http://sky.zero.ad.jp/~zaa54437/programming/clean/CleanBook/appendices/appendix-B.html
>while :: !(a -> .Bool) (a -> a) a -> a // while (p x) f (f x)

>>691
(5+6)*(7+8)

これについて
15=(7+8)
11=(5+6)
26=15+11
でも
11=(5+6)
15=(7+8)
26=15+11
でもかまわないと言うこと、整数ではなく印刷入りの関数をいれてみろ、結果が変わるのが手続き型、変わらないのが関数型。

>>704 これなら関数型っす。

>>703 モナを使えば副作用も継続もなんもかんも表現できるので世界はすべて関数型ということで。
とりあえず関数型の定義まで戻ってその定義に従ってどうかというように論じないとなんとも。

>>705
だから、その場合、11と15のどちらを先に計算するかの順番はいらないが、
15+11の前に11を計算しておかないと計算できないから、そうの順番は
いる。

>>696
必死だな（ｗ
whileは関数型

>>696 >>708
>>574のwhileが関数型だろうが、そうでなかろうが、
話の本質には関係ないと思うが。

>>707
例えば遅延評価で、11+15を使わないとしたら？
それは実行されないだろ。
無いんだよ。

>>696
>>574には副作用は出てこないが。

>>710
その時は順番は必要ないが、使うときは必要になる。
遅延評価は計算が必要になるまで計算しないというだけのことで、
計算が必要になる場合が存在する以上、順番は必要なんだよ。

>>711
そのかわり while には意味がない

574のwhileは例をわかりやすくするために便宜的に使ってるだけだろ。

>>713 while に意味があるのは副作用だけでなく、大域脱出とかがある場合も微妙に意味がある。でもかなり微妙

だから、574のwhileなんてどうでもいいだろ。
気に入らないんだったら末尾再帰にでも置き換えて考えろ。

>>574のwhile（たぶんマクロ構文）は副作用を目的とする構文だよ。
schemeでスマートに繰り返しを書くなら、
named-letなどを使う。
あそこでwhileを使ったのは>>571に対する説明としてわかりやすく
記述した程度の意味しかないと思う。

>>717
仮にあのwhileがschemeでmonadを巧妙にエミュレートして
作られたものだったら、副作用は無いと思うが、
後半は同意。
結局どうでもいい。

モナドは関係なく(while trueの場合は副作用が出ないだろ。

monadによって副作用なしにエミュレートされた副作用が、関数型には副作用がないというときの副作用を指すかどうか、それが問題だ。

>>719 副作用が出ない結果、大域脱出がなければ無限ループになる。

while は named let、つまり lambda で書けるんだが

>>720
monadによって副作用なしにエミュレートされた副作用は、関数型には
副作用がないというときの副作用とは一致しないが、意味的な概念は
同じであろう。

たとえ lambda で書けたって条件部分が参照透明性によりいつも同じ値を返したら無限ループか一回も実行されないかどっちかになっちゃうでしょ。

>>721
大域脱出は副作用じゃないよ

>>722 つまりこういうことなわけで
(define-macro (while test . body)
　(let ((loop (gensym))) ;hygienic symbol
　　`(let ,loop ()
　　　(cond
　　　　(,test ,@body (,loop))))))

lambdaで書き直せるなら関数型かよ？
ならすべてのプログラム言語の機能は関数型の機能だな。

>>727
つーか、昔Churchが既に形式化してるわけで

チューリング等価だから関数型言語はチューリングマシンです、
というぐらいナンセンス。

一晩でこんだけレスがつくってことは、みんな関数型言語に注目してるんですね

>>730
注目はね。
実用上はどうだろう。
みんな使ってる？

emacsな人は使っているかも。

ところで話題を変えて、

自作関数型スクリプト言語を作るとして、関数型プログラミングに必要な
最小限度の機能とはなんでしょうか？
教えて下さいです……。

>>732
MLやSchemeみたいな正格言語なら、
レキシカルクロージャと末尾再帰のループ展開があれば
それっぽくなると思うよ。

>>733
やっぱりクロージャと末尾再帰最適化は必要ですか。
‥‥‥‥だよな(´･ω･`)。

>>574を関数型とは全く関係ないことにしたい奴必死だな。
最後はwhileにケチを付け出したか。（ｗ

>>681
関数型でいう「関数」って、 C とかの関数より、数学の関数に近いと思うけどな。
結果は引数にのみ依存する、っていう。

>>734
あと遅延評価が入ると、ぐっと関数型っぽくなりそうな気がする。

>>735
だって、あれって FPL の柔軟性っていうより、 Lisp や Scheme の柔軟性っぽいんだもん。

>>736
確かに「純粋な」関数の定義はそうだが、その定義では
Schemeは関数型では無い。
しかし、実際はSchemeも関数型と呼ぶ。
まあ、君の脳内定義には興味ありません。（ｗ

>>574の柔軟性の特徴は
継続 ： Scheme、SML/NJ、Clean、（Ruby）
ラムダ抽象 ： Scheme、Clean、Haskellほか多数

どちらもFPL的な特徴ですな。
他の関数型には無いSchemeやLispの柔軟性というと、
プログラムをデータのように扱ったものを思い浮か
べる。
(eval (list (car '(+ 1 2)) '1 '1))

関数型言語ってのは数学的に純粋な関数をあつかうのに手厚い支援がある言語って
ことだと思うな。

関数型プログラムってのは数学的に純粋な関数だけで記述されたプログラムの
ことだと思うな。

だから、たとえ Scheme で書かれていても副作用を使っているプログラムを
関数型だと認めたくはないな。

そして、継続も while も数学的に純粋な関数ではないから、あのプログラムを
関数型だと認めたくはないな。

要するに、参照透過性だの遅延評価は、便利な概念であり、
関数プログラミング的な概念でもあるが、「それがなければ
関数型言語と呼べない」というものでもないってことだな。

ある程度それに近ければ、すなわち、インターフェースが
似ているならば、関数型言語と呼んで構わない。
その周辺機能を関数型言語的な特徴と呼んで構わないって
ことだと思う。

>>738
認めたくないのは君の勝手だけど、他人とコミニュケーション
を取る場合は一般的な呼び方に従おうや。

それから、継続もwhileも数学的に純粋だが。（ｗ

Java や Python が関数型ではない理由を教えてくれたまへ。

他にもっと前面に出したい特徴があるから。

Javaの場合は関数の呼び出しがメッセージの送信という
形になっているところなど、そうしたインターフェイスが
違うのが大きな原因かな。
おそらくラムダ抽象とかカリー化とかもないと思う。
pythonはlambdaがあったような気はするけど。

Pythonは機能的には、現在では十分関数型の機能を
備えているかもしれないが、オブジェクト指向や
スクリプト言語であることのほうを強調したいようだ。
昔は違ったということで、歴史的な理由もあるかもしれない。

「新次元新発想！新しい関数型の定義を作るスレ」
になってるな。
そういう議論はバッカスの論文くらい読んでからにしてほしい。

っていうかお前ら関数型言語スレに帰ってください。

関数型とかラムダとかオブジェクト指向とかはどうでもいいので、新しい文法について語って下さい。

>>746
ただなぁ...スレタイが
「ifをcaseにすると便利なことがあるよね。」
だからなぁ。

>>745
このスレに関数型言語スレの住人なんていないと思われ。

このスレで、新しい文法考えますた！
つっても欠陥だらけで終わってるからな。
実装して使ってから公開しろっての。

>>739
インターフェイスの意味にもよると思うな、
C言語は文法は関数みたいな形をしているがあれを関数型とかいったらどうかね、
これは違うよなって気がしないか？

>>748
part3の100あたりから活発に活動なさっていた１〜２人の素人が
こっちに移ってきたようです。
……。でもあっちに戻られるのはもっとイヤかも。

Concurrent Clean のマニュアルをダウンロードしたんだけど、
継続が見当たりません。どこにのってるんでしょうか？

俺は今は関数型言語スレにいないけど、Part1の頃にはいたよ。
しかし、Schemeが関数型言語ではないと言ってくる奴には困ったな。
自己満足なら世間とずれた定義でも結構だが、その定義で他人の使い方に
文句言うなよ。

>>745
別に、バッカスの論文なんか読まなくても、一般に関数型言語と
呼ばれている言語が関数型言語だよ。（ｗ
そうならない定義は少数派の定義だから、議論で使うべきでない。

>>752
Cleanに継続は無いかもしれないね。>>737は俺の勘違い。スマソ。

monadは副作用を隔離しただけで無くなっていないと言ってる人、
関数型には順番が一切無いと言ってる人、継続があると関数型
ではないと言ってる人など、間違えてる人は結構いたな。
まあ一人か二人の同一人物だろうけどな。
昔、Haskellスレにもこういう人はいた。

>別に、バッカスの論文なんか読まなくても、


読んでないんだ‥‥‥‥。

>>753 Clean には継続はないですか。
non-strict な言語で継続がどう動くのか興味があったのですが、残念です。

non-strict な言語で継続がどう動くのかまったく想像できないんですが、
どなたかご存知ありませんか？

まぁ、少なくとも関数肩がたいしたことないのがよく分かった

>>756
これじゃ、流行らん和なぁ〜（関数肩

>>754
読んでないよ。

>>755
継続というものをだいぶ誤解してるようだね。
たしか、「関数型プログラミング」という本では
Goferで継続がどう働くか解説していたはず。

「プログラミング言語」だったかもしれない。
記憶があやふやでスマソ。

>>753
脳内定義で話をしていることを自ら暴露してるYO

そうだな。
「世間に従った定義」という'脳内定義'を使ってるのは確かだ。（ｗ

他人と話をするときは、「世間に従った定義」を使わなくてはいけない。
例えば、世間で言う「手」を、脳内では「足」と定義している人がいたと
する。
「人間は普通、足で歩く」と言っている人に向かって「人間は普通、手で
歩いているぞ」と文句を言うのは的外れだ。
「Schemeは関数型言語じゃないぞ」と文句を言うのもその類。

× 世間で言う「手」を、脳内では「足」
○ 世間で言う「足」を、脳内では「手」

>>753
面白くないから帰っていいよ。スレ違い。

数学の世界に何故「世間」なんてものが出てくるんだろう？

「関数型プログラミング」という本は見つかりませんでした。
似た題名として、「関数プログラミング」だと、
手元に2種類(武市先生の翻訳と萩谷先生の)あったのですが、
継続についての記述は見当たりません。探し方が悪いのかもしれませんが。

「プログラミング言語」は手元になく、調べられませんでした。

Web に解説はないものでしょうか?

>>764
数学の世界ではなく、国語の世界だから。

あ、Web でなくて論文でもかまいません。
本になっているということはきっと元ネタの論文が
どこかにあるのだと思うのですが。

non-strict な言語における Scheme の call/cc のような継続について、
どなたかご存知でしたらご教示ください。

いつからプログラム、特に関数型が国語になったんだろう？

>>765
たぶんこの本じゃないの？

コンピュータ・サイエンス研究書シリーズ(17)
関数型プログラミング
PETER HENDERSON 著 杉藤芳雄・二木厚吉 訳
1985年 日本コンピュータ協会 出版

これの9章〜10章で継続使ってるみたいだけど。

巻末の継続についての参考文献
Strachey, C. and Wadsworth, C. P. (1974),
Continuations, A Mathematical Semantics for Handling Full Jumps,
Technical Monograph PRG-11, Oxford Universuty Computing Laboratory.

Raynolds, J. C.(1972),
Definitional Interpreters for Higher-Order Programming Languages,
Proc. ACM Annual Conference.

>>765、>>767、>>769
「プログラミング言語 / 竹市正人」だったようだ。
goferはhaskellと非常に良く似ているので、読む価値はあると思う。

それから、monadによる実装でよければ
http://citeseer.nj.nec.com/wadler92comprehending.html
の7.4に書いてあるようだけど。
8.2にも例がある。

これは、見た感じ、ラムダ計算っぽいnon-strictな言語だと思うが
この論文は読んでないので、的外れなこと言っていたらスマソ。

>>764
数学の話でも（数学の話をする時の）世間一般の意味に従わなくては
ならないと思うが。
プログラミングの話でも（プログラミングの話をする時の）世間一般の意味に
従うのが常識だが。

そもそも、世間一般の意味に従ったであろう発言に対して、
少数派の定義に基づいて反論したところで、意味がない。
どちらの意見も、定義を変えれば正しいという状態になるだけ。

やねうらお辺りが喜びそうな話題だな

>>771
monad による実装はその monad を使って記述された範囲内でしか使えないので
意図しているものとは違います。
monad をつかって副作用を実装しても本当は副作用が無いように、
monad をつかって継続を実装しても本当は継続ではないと理解しています。

私が意図しているのは、Scheme のようにいつでもどこでも使える
言語組み込みの本物の継続です。

Gofer というのはよく知らないのですが、
Haskell と違って言語に組み込みの継続があるのでしょうか？

あと、本のほうは手元に無いのですぐには参照できないのですが、
もし本に参考文献として論文があげられていたら教えていただけないでしょうか。

関数肩の話題、すれ違い！
専門スレでしる！

http://homepage.mac.com/yuuka20/

>>774
schemeの継続呼び出し(call/cc)はCPSの構文糖

>>777 え、そうだったんですか？　それは知りませんでした。
マクロで定義できるのならぜひやり方を教えてください。

>>778
継続についてはマクロみたいな局所的な変換じゃ無理。
継続適用部分全体をCPSへ置き換えないと。

>>774
いや、goferを使って、継続を実装しているだけ。
goferやhaskellはIOに継続のスタイルが使われていると
聞いたことがあるけど、これもあなたの意図したものとは
違うかもしれない。
ただ、調べてみる価値はあるかも。

それから、
>monad をつかって副作用を実装しても本当は副作用が無いように、
>monad をつかって継続を実装しても本当は継続ではないと理解しています。

上の論文は確かにmonadを使って継続を実装しているけど、
non-strictな言語の継続を実装していれば、もちろん
問題無いと思う。
読んでないから、その辺どうだかはわから無いけど。

あと、多分勘違いしてると思うけど、
monadをつかって副作用を実装しているように、
継続をつかって制御を実装しているわけ。
non-strictな言語の場合でも評価順序はあるわけで、
理屈としては継続があることになる。

>>780

gofer にも組み込みの継続はありませんか。残念です。

non-strict な言語の継続を実装していればというのですが、
その non-strict な言語の継続というもの自体を知りたいので、
monad ではなくて言語自体に入っているものが知りたいのです。
論文を読んでもそれが non-strict な言語の継続かどうか
わからないかもしれないですし。

理屈としては継続があるというのはそうかもしれないのですが、
私には想像できないので具体的な実装例を見たいのです。
Clean も Haskell も gofer もないということですが、
そういうものは存在しないのでしょうか？

>>781
今検索したら、
http://www.namikilab.tuat.ac.jp/~sasada/prog/rucheme.html
これが、その実装らしい。
4/30の日記に遅延評価にしたとの記述があるので。

>>782
ttp://www.namikilab.tuat.ac.jp/~sasada/prog/rucheme003.lzh
というのをダウンロードしたのですが、遅延評価は入っていないようです。

あと、ドキュメントの continuation のところに
「できないかもしれません」と書いてあってぜんぜん信用できないのですが。

>>783
>遅延評価は入っていないようです。

ほんとに？何で断言できるの？
ていうか、4/30の日記をちゃんと見た？

まあ、Schemeはdelayとforceで遅延評価実現できるので、
全ての関数にdelayとforceが使われているSchemeを想像すれば
なんとなくわかるのではないかと思う。

ダウンロードした中のファイルのタイムスタンプを見たら、
一番新しいものでも 3月21日だったので。

日本一の弟

なんでスレ違いを続けるの？　専用スレでやればいいじゃん。

つーかスレ違いじゃなかったらこんな伸びないと思われ。

スレ違いだろ。馬鹿が勝手にワメいてるだけ。

やけにむきになってスレ違いとワメいているのは人はひょっとしてC#死滅スレの「関数型からオブジェクト指向に移行する訳だから」の人？
大変だね頑張ってね(藁

non-strict な純粋関数型言語に継続プリミティブがいれられるなら
これはけっこう新しいと思うので、スレ違いというのはご容赦ください。

もし、そんなのはぜんぜん新しくないという方がいらっしゃいましたら、
ぜひ文献や実装を教えていただけるようお願いします。

>>780 だんだん疑問がはっきりしてきました。

評価順序というのは簡約戦略によって決まるわけですが、
たとえば、strict な言語ならだいたい最左最内戦略で、
これは内側から正規形にしていくわけです。
そうすると、ある時点の継続は処理が終わっていない外側の部分だと
いうのは納得できます。

でも、最左戦略で non-strict とすると、だいたい外側から試していくわけで、
継続という処理が終わっていない部分は内側のように思えますが、
そうなんでしょうか？

また、Scheme で継続を呼び出すときは値をひとつ渡すわけですが、
上記のように内側の部分を継続とすると、
継続を呼び出したときに与える値はどこにはまるんでしょうか？

Clean の簡約戦略は関数型簡約戦略だそうですが、これだとどうなんでしょう？
また、仮にランダムに redex を選ぶような戦略を想定するとどうなるんでしょう？

また、継続を呼び出したときの動作にも疑問があります。
(仮に non-strict な言語でも継続は項の外側の部分を示すとして、
継続はひとつの値をわたして呼び出せると仮定します)

継続を呼び出すと、呼び出した側が与えた継続を破棄するわけです。
たとえば、771 に出ている論文の callcc の定義では受け取った k' を
呼び出すところがありません。

これを TRS で考えてみると、ある継続を呼び出した時点での暗黙の継続、
つまり、redex として選ばれた継続呼び出しの外側の部分を
いきなり消してしまうことに対応します。
でも、こんな操作は書き換え規則では単純にはかけませんし、
仮に無理に書いたとすると、合流性が崩れて、参照透明性が壊れるように思います。

たとえば、Scheme ですが、(call/cc (lambda (k) (cons (k 1) (k 2))))
というのを考えると、これは引数の評価順序によって結果が変わるのですが、
これは上記の合流性が成り立っていない例になっています。

784 によればすべての関数に delay と force を使った Scheme を
想像すればよいとのことですが、上の例に delay と force を入れると、
Haskell や Clean のように、
合流性や参照透明性が保たれるようになるんでしょうか？

>>785 >>792-793
http://pc2.2ch.net/test/read.cgi/tech/1047970129/317-318
こっちで答えておいた。

794のリンクは間違いなので訂正。

関数型言語Part3
http://pc2.2ch.net/test/read.cgi/tech/1037527388/317-318

> non-strict な純粋関数型言語に継続プリミティブがいれられるなら
> これはけっこう新しいと思うので、スレ違いというのはご容赦ください。
新しいと思うけど、文法じゃないんだけど。スレ違いだと分かってるんだったら
関数型言語のスレに帰ってください。ネタスレなのに…。

お帰りはこちら http://pc2.2ch.net/test/read.cgi/tech/1037527388/

なんで関数型言語使う人ってウンチク好きなの？場違いな場所でやるのウザイ。

ときどき欲しいもの
関係演算子の数珠つなぎ a <= b < c == d

>>797
激しくガイシュツ。

>>797
>>608

>>609

>>796
>>574から関数型言語スレになりました

>>800
でも、 >>609 だと < と == みたいな、別の演算子の混在はできないよね。
こういうのも簡潔に書けたら便利かも。

>>802
>>610

$ python -c 'if 1<2<2: print("yes")'; python -c 'if 1<2<=2: print("YES")';
YES
$

>>796
頭悪そう。

>>802
なんか、こう、自然と顔がニヤけてくるような面白さ

ああ、こんなとこに誤爆してたのか

>>797
記述がすっきりするというのはいい事だよね。
C の bool の式として簡潔かつあいまいさや矛盾なく綺麗に拡張できる方法はないもんですかね。
そこのところだけ文法を変えるというのをやっみたが、あんまり気持ちよくないので・・・
ちなみにこんな感じ
bool flag = bool_exp{ {a} < {b} == {c} } ;
bool_expの中では < その他は区切り文字として取り扱い。
が、しかし中に式が入らなくて、苦肉の策はものすごくかっこ悪い。
考えれば考えるほど自分用のトランスレータに入れたくなってきた。

>>797
(define-syntax and<
  (syntax-rules ()
    ((_) #f)
    ((_ a) a)
    ((_ a b) (and (< a b) b))
    ((_ a b c) (and (< a b) (and< b c)))
    ((_ a b c ...) (and (< a b) (and< b c ...)))))

(define-syntax and<=
  (syntax-rules ()
    ((_) #f)
    ((_ a) a)
    ((_ a b) (and (<= a b) b))
    ((_ a b c) (and (<= a b) (and<= b c)))
    ((_ a b c ...) (and (<= a b) (and<= b c ...)))))

(define-syntax and=
  (syntax-rules ()
    ((_) #f)
    ((_ a) a)
    ((_ a b) (and (= a b) b))
    ((_ a b c) (and (= a b) (and= b c)))
    ((_ a b c ...) (and (= a b) (and= b c ...)))))

(and<= a (and< b (and= c d)))

って、よく見たらこれじゃダミだ

(define-syntax ?
(syntax-rules ()
((_ a x b) (x a b))
((_ a x1 b x2 c ...) (and (x1 a b) (: b x2 c ...)))))

(? a < b = c)

4行目の : は ? の間違いでス

2回評価される部分が出るね
副作用無ければ問題無いけど

副作用のある言語はカス。

template <typename LEFT>
class ___Comp
{
private:
const LEFT& left;
bool res;
public:
explicit ___Comp(const LEFT& left) :
left(left), res(static_cast<bool>(left)) { }
___Comp(const LEFT& left, bool res) :
left(left), res(res) { }

operator bool() {
return res;
}

template <typename RIGHT>
___Comp<RIGHT> operator==(const RIGHT& right) {
return ___Comp<RIGHT>(right, left == right);
}

template <typename RIGHT>
___Comp<RIGHT> operator!=(const RIGHT& right) {
return ___Comp<RIGHT>(right, left != right);
}

template <typename RIGHT>
___Comp<RIGHT> operator<=(const RIGHT& right) {
return ___Comp<RIGHT>(right, left <= right);
}

template <typename RIGHT>
___Comp<RIGHT> operator>=(const RIGHT& right) {
return ___Comp<RIGHT>(right, left >= right);
}

template <typename RIGHT>
___Comp<RIGHT> operator<(const RIGHT& right) {
return ___Comp<RIGHT>(right, left < right);
}

template <typename RIGHT>
___Comp<RIGHT> operator>(const RIGHT& right) {
return ___Comp<RIGHT>(right, left > right);
}
};

template <typename TYPE>
___Comp<TYPE> Comp(const TYPE& value) {
return ___Comp<TYPE>(value);
}

#include <iostream>
#include "bool.h"
using namespace std;

int main()
{
if(Comp(1) < 3 < 3) {
cout << "1 < 3 < 3" << endl;
}
if(Comp(1) < 3 <= 3) {
cout << "1 < 3 <= 3" << endl;
}
}

まだショートサーキットを組み込んでないけど、とりあえず。

あ、間違えてた。res の結果を継承しないといけない。
そして、それでショートサーキットも解決、と。
true の時だけ比較すればいい。

>>803
python にはあったんだ…知らなかった。

>>810
あ、それいい…
中置記法そのまま持ってきちゃえばよかったんだね。

>>814-817
結構いい線いけますね、それでも最初の型変換と計算中だけ型違いというのはなんとも気持ちが悪い、
テンプレートだけだとこの辺が限界かとは思うけど、新規の文法導入でもうちょっとなんとかならないかな。

>>819
>>810で解決済

>>820
あっ、私は807=919です。
C の演算子ベースで矛盾や混乱の起こりにくい記述を追及したいです。
型での記述だと、今何型になっているのかを常に意識する必要があって結構混乱の元になる。
新規文法にしても単純に < == > 等ではさむと優先順位が変になったり、
そこだけが極端に風変わりな文法になるのを防いだ書き方を追求したいです。

場当たり的な印象はするけれどもシンプルに
==. !=. <. >. <=. >=.
といった演算子を低めの優先順位で新規に設けるとか・・・

>>822
演算子の打ち間違いの問題が発生しそうなヨカン。

>>810
これ、マクロにする必要はないんでない？
=、 <、 <=、 >= も関数だし

(<, <=), (>, >=), (==, !=) でそれぞれ別のクラスにすれば綺麗になるね。
いろいろ改造したけど、ここに載せるには長いし、
実のところスレ違いなので載せるのはやめとくけど。

あんまりスレ違いを意識しすぎるのもどうかなと思うんですが・・・
糖衣にするのか、新規に作るのか、
例えばオーバーロードするときに新規に作った文法なら、これのオーバーロードはかなり頭が痛いです。
比較演算子を関数と考えて、比較要素オブジェクトと関数オブジェクトをリストにしてコンテナにいれて引き渡してみようかとか、
少なくとも僕は参考になることが多いから、スレ違いだと激しく言っている上にいる誰かの方がよっぽどウザイと感じるのは僕だけですかね。

>>826
>>814-816（の改善版）で比較演算子のオーバーロードが自由なように、
そんなに難しいことでもないと思いますよ。

やっぱりC++は不自由な言語なんですね

自由すぎるのも困る場合があるがな。

それは詭弁だね

>>830
多重継承のことだと言えば
貴方は嬉々として賛同するだろう。

あっても、必要なければ使わなければよいので困らない
無いと、必要なときに使えなくて困る

>>832
間違った使い方をしてはまるｱﾌｫ共のために、そんな自由はいらんと言うとる言語もあるが。
でも面白さが足りんよな、そういうのは。

大は小を兼ねるというやつですな

面白さが足りんが、この世にはｱﾌｫの方が多い罠。

優先順位付演算子
a +{0} b *{2} c /{3} d -{1} e
-> ( a + b ) * c / ( d - e )

>>836
優先順位を指定できるのに結合性を指定できないのは
片手落ち。あとＨａｓｋｅｌｌだと演算子ごとの指定はできるな。

　infixr 5 ++ -- 右結合で優先順位5

こんな感じで。

しかしどっちにしてもいいアイデアだとは思わない。そもそも
「括弧を使う」という万能の優先順位変更策があるわけだから、
最低でもそれより読みやすくないとだめだろ。

Prolog でも演算子を自由に定義できて、
優先順位も決めれるぞ。

S式でいいじゃん

あるいは逆ポーランド記法

Ｓ式と逆ポーランド記法は違うぞ

>>841
おまいは「あるいは」の意味を知らんのか？

新しい文法考えました

>>1

で行番号1へ飛びます

ガイシュツだと思うけど
text=RED;
back=BLUE;
colors[]={ BLACK, WHITE, … };
if((text,back)⊂colors){ … } // text及びbackがcolorsに含まれるなら

変換が大変そうだ

オートマトンの絵でそのまま機械つくってくれるやつが欲しいな。
prologみたいなのじゃなくて、Push-downもいけるようなやつ。
場当たり的な適当なコードを書くのの変わりに。

いつも思うのですが、「書き方とプログラムを分離する」ことができれば非常に
綺麗かつ便利になりそうな気がしています。

if((text,back)⊂colors){ … } なのですが、
とりわけ数学でよく考えられた記号は、そのまま持ってきたいが
実際には、そうは行かない
例えば行列計算で
D = A + B * C
とかする場合、OO系言語の場合
D.add( A , B.clone().mul( C ) ) ;
といったことにといった感じになりかねないもので、読みにくいこと極まりないです。
一部の人はこのほうが統一があって読みやすいなんていっていますが、あれは頭が変(←少し煽り)
統一されていることは正しいとは思うのですが（こうすることによる拡張性その他は捨てられない）

　　統一されている≠読みやすい

とも思うんですよね。
最近C#をやり始めて「同じ事をするのにやり方が複数個あるのは良くない」はウソだと感じる。
あくまで「統一されている」は拡張性の確保や読みやすさの確保のための手段であって目的ではないと思う。

基本的に糖衣構文を記述する構文のような物という事になるでしょうけれど、
template その他で進化した考え方で諸悪の根源とされていたプリプロセッサを再度見直したらもっと良いものになりそうな気がする。
さらに「書き方とプログラムを分離する」を一般化して考えれば、「オートマトンの絵でそのまま機械つくってくれるやつ」といった、
プリプロセッサの変換元がテキストである必要性も無いような気もします。

「書き方とプログラムを分離する」すると言うことの極端な例

テキストを二次元的に取り扱う

このプログラムは func1 → func2 → .. func4 → func5 .. func7 → return
と処理が進む
void proc()
{
　　func1() ;　　　　%% label1:
　　func2() ;　　　　%% func5() ;
　　func3() ;　　　　%% func6() ;
　　func4() ;　　　　%% func7() ;
　　goto label1 ;　　%% return ;
}

このプログラム自体には意味はないのですが、たとえば処理が対になっている処理などでは、
ミスを減らす有力な手段として使えたりとかしないかなと思っています。

要するにフローチャートとかUMLとかなんでは。

>>847
C# やってんなら、演算子のオーバーロードで
行列計算は D = A + B * C; って書けるっしょ？
まぁ、実行効率に目をつぶればね。

シンタックスシュガーを記述する構文は色んな言語に色んなものがある。
数学的な記法ということに関しては Haskell はなかなかすごい。
有名な Haskell のクイックソートプログラムを見れ。
ttp://www.teu.ac.jp/nsit/~tomoya/Prog/haskellq.html

>>850
一応知ってます、しかし今まである物のは全部場当たりなんですよね。
○○の記述方法で凄いのなら××言語って感じになってしまいます。
そうではなくて、一般的な方法が欲しいなと思ってます。

それは何も新しくないんじゃないかな。
新しい文法は別途考えないといけないわけで。

おまえらがアホなこと言ってる間に
おれは一仕事終わらせてきた。

>>851
あなたが知らないだけで、そんな言語は山ほどある

>>854
すみません、それを教えていただけますか？
少なくとも自分は今だに見たことがないです。

#define on(x,a,b) ((a)<=(x) && (x)<=(b))
#define in(x,a,b) ((a)<(x) && (x)<(b))
#define and(a) a && a

if on(x, a, b){...}
if(a< and(x) <b){...}

禿しく下らんな、鬱。

　__∧＿∧_
　|（　　＾＾ ）|　＜寝るぽ（＾＾）
　|＼⌒⌒⌒＼
　＼ |⌒⌒⌒~|　　　　　　　　　山崎渉
　　 ~￣￣￣￣

　__∧＿∧_
　|（　　＾＾ ）|　＜寝るぽ（＾＾）
　|＼⌒⌒⌒＼
　＼ |⌒⌒⌒~|　　　　　　　　　山崎渉
　　 ~￣￣￣￣

LISP scheme 向けの埋め込み構文 #let1 #let
書式
#let1 <sym> <bind> <body> ... end または
#let1 <sym> <bind> <body> ... #<EOF> または
(hoge #let1 <sym> <bind> <body> ... ) または
#let ((<sym> <bind>) ...) <body> ... end または
#let ((<sym> <bind>) ...) <body> ... #<EOF> または
(hoge #let ((<sym> <bind>) ...) <body> ... )
さらに、named-let
#let <loop-sym> ((<sym> <bind>) ...) ... 終端

束縛の有効範囲は終端記号まで。
終端記号はキーワードシンボルend、ファイルの末尾、
親関数/構文の閉じ括弧のどれか。

使い方
(pp #let1 a 1 #let1 b 2 (+ a b)) => 3

メリット：構文囲い込みの括弧を使わない。コードへの追加/削除が簡単。

昨日考えて、さっき作り終わった。想像通り便利。
この終端の判定方法は他の構文を作るときにも流用できる。
実装はreaderのsharp-hook拡張。
ppすると普通のletになる。
(pretty-print '(display #let1 a 1 #let1 b 2 (+ a b)))
==>(display (let ((a 1))(let ((b 2))(+ a b))))