5ちゃんねる ★スマホ版★ ■掲示板に戻る■ 全部 1- 最新50  

■ このスレッドは過去ログ倉庫に格納されています

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

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

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

2 :デフォルトの名無しさん:03/03/18 15:50
vierus
{

}

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



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

3 :ヌルポ〜ず:03/03/18 15:50
2ヌル〜ズサー

4 :デフォルトの名無しさん:03/03/18 15:53
ム板で2ゲットミスするなんて滅多に見られないな

5 :マヂレス:03/03/18 15:58
敢えてネタにマヂレスしてみようか。

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

6 :デフォルトの名無しさん:03/03/18 16:01
>>5
#define Integer INT

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

7 :デフォルトの名無しさん:03/03/18 16:03
>>1
switch case文は使用禁止
ifならifで統一しコードの可読性を下げるな。

8 :デフォルトの名無しさん:03/03/18 16:05
>>7
どんな会社に行ってんだ・・・こいつは。

9 :デフォルトの名無しさん:03/03/18 16:07
ぬるぽ文

10 :デフォルトの名無しさん:03/03/18 17:11
1 のフリがつまらないとスレが死滅するという良例。

11 :デフォルトの名無しさん:03/03/18 17:48
Subliminal(UNKO)

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

12 :デフォルトの名無しさん:03/03/18 20:56
>>8
それはそれで利点は、有るのでは?

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

13 :デフォルトの名無しさん:03/03/18 21:02
if(0 <= i <= 3)
exec();

14 :デフォルトの名無しさん:03/03/18 21:32
おれの話も聞いてください
オブジェクト指向スクリプトを作ってるのですが

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

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

15 :デフォルトの名無しさん:03/03/18 21:36
>>14
judgeクラスとかを導入した方が良い予感。

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

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

16 :デフォルトの名無しさん:03/03/18 21:41
if文のみってコーディング規約ってあり!?
>>8を読んでビックらこいたよ。これって一般的な規約だったりするの?

17 :デフォルトの名無しさん:03/03/18 21:46
>>15
うーん、それだとjudgeクラスには何の意味も無いような…
ifはBooleanオブジェクトのメソッドにしようとおもっていたんですが

18 :デフォルトの名無しさん:03/03/18 21:53
(x.< y).if({
//trueの時の処理
},{
//falseの時の処理
})

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

19 :デフォルトの名無しさん:03/03/18 22:02
>>18
なるほど、実は2項演算子というかメソッド起動は
(object message parameters)とする案も自分の中であるんです。
つまり ((((x * x) + (y * y)) + (z * z)) sqrt)で3次元の距離を取得のように

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

20 :デフォルトの名無しさん:03/03/18 22:03
>14
つーかSmalltalkがそもそもif文をメソッドとして実装してるだろ。


21 :20:03/03/18 22:04
ちょっと表現が変だな。

実装→実現


22 :デフォルトの名無しさん:03/03/18 22:06
>>20
そうですね "新次元新発想"ではなかったですね

23 :デフォルトの名無しさん:03/03/18 22:07
>>22
残念だったな(ゲラ

24 :デフォルトの名無しさん:03/03/18 22:20
俺の探し方が悪いだけもしれないんだが、言語そのものが行列に対応していて、
内積とか外積とか計算できるやつない?

25 :デフォルトの名無しさん:03/03/18 22:21
>>24
Mathmatica

26 :デフォルトの名無しさん:03/03/18 22:21
LispのS式を順序を反対するのってどお?
(5.(4.(3.(2.(1.())))))ではなく(((((().1).2).3).4).5)
ラムダっぽくてグー?


27 :デフォルトの名無しさん:03/03/18 22:27
>>26
俺は一生かかっても LISPは覚えられないと感じた瞬間。

28 :デフォルトの名無しさん:03/03/18 22:29
>25
なるほど!mathematicaで作ってみるか。ゲームだけど…

29 :デフォルトの名無しさん:03/03/18 22:31
>>28
頑張れよ・・・

30 :デフォルトの名無しさん:03/03/18 22:33
>>28
内積・外積程度だけなら適当に作ればいいじゃん
別に言語に関係ないじゃん

31 :デフォルトの名無しさん:03/03/18 22:33
>>28
普通にCかC++でmatrixのライブラリ探したほうがいいような…

32 :デフォルトの名無しさん:03/03/18 22:34
>>27
Lispはそんなに難しくない、というか規則が割と少なく簡単

33 :デフォルトの名無しさん:03/03/18 22:36
>>32
カーとかクダーとか授業で習ってこんなおもしろそうな言語があるのかと感動したことがある。
これでCGIでも書いてみようか知らん。

34 :デフォルトの名無しさん:03/03/18 22:38
>>33
LispじゃないけどSchemeは如何?
ttp://www.shiro.dreamhost.com/scheme/gauche/index-j.html


35 :デフォルトの名無しさん:03/03/18 22:42

    goto文に替わって、cometo文。

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

36 :デフォルトの名無しさん:03/03/18 22:46
  ∧_∧
 ( ´∀`)< ぬるぽ

37 :デフォルトの名無しさん:03/03/18 23:02


38 :デフォルトの名無しさん:03/03/18 23:09
if〜 because〜構文

39 :デフォルトの名無しさん:03/03/18 23:10
ぬるぽ〜ガッ〜構文


40 :デフォルトの名無しさん:03/03/18 23:16
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("逝ってよし");

41 :デフォルトの名無しさん:03/03/18 23:19
やっぱこっちのがいいや。

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("逝ってよし");

42 :デフォルトの名無しさん:03/03/18 23:20
>>41
ほんと、C++って読みにくくなったよな。

43 :デフォルトの名無しさん:03/03/18 23:23
>>42
そうでもないよ

44 :デフォルトの名無しさん:03/03/19 00:13
なれだと思うよ
慣れれば読めるよ
慣れにくいからよみにくいって言うかもしれないけど

45 :デフォルトの名無しさん:03/03/19 02:38
単純に、フィールドhogeを、
.hoge
としないとアクセスできないようにすれば
_とかmとか「しらね」で揉めないし、可読性20%UPなのに。

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

46 :デフォルトの名無しさん:03/03/19 02:40
>>35
COME FROM なら Intercal にあります。

47 :デフォルトの名無しさん:03/03/19 05:23
>>24
APL 系の言語だな。
J 使ってみ。

48 :デフォルトの名無しさん:03/03/19 06:19
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 ...))
    ...))))



49 :デフォルトの名無しさん:03/03/19 21:04
Javaとかだと

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

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

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

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

50 :デフォルトの名無しさん:03/03/20 00:40
Java に function キーワードの導入希望。
こんな風に。

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

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

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

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



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

52 :デフォルトの名無しさん:03/03/20 07:59
>>50
全然「新しい文法」じゃないじゃん

53 :デフォルトの名無しさん:03/03/20 23:30
10 1 + 2
20 [10] + 3
30 [20] + 4
40 print [30]
で10が出る。
行番号が変数/メモリ配置を兼ねている。

54 :デフォルトの名無しさん:03/03/20 23:56
>>53
行数が増えると大変なことになりそうだけど
俺でも作れそうでいい

55 :デフォルトの名無しさん:03/03/20 23:57
10 RND(10)
20 INPUT "カズ イレテ"
30 IF [10] = [20] THEN 40 ELSE 50
40 PRINT "セイカイ"
50 END

56 :デフォルトの名無しさん:03/03/20 23:57
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);
}

57 :デフォルトの名無しさん:03/03/21 00:04
>>53
Cに直すと
int _10 = 1 + 2;
int _20 = _10 + 3 ;
int _30 = _20 + 4 ;
int _40 = printf("%d",_30) ;

58 :デフォルトの名無しさん:03/03/21 07:05
関数呼び出しを、
a(b(c(...)));
と書くのは見ずらいし、ネストが深いと括弧を数えるのが面倒なので、
'<-'という右結合の2項演算子を用意する。

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

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

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

59 :デフォルトの名無しさん:03/03/21 07:10
>>58
:-)

60 :デフォルトの名無しさん:03/03/21 07:29
>>58
<= てのはどう?
< も = も 二項演算子だから2つが並ぶことはあり得ない。

61 :60:03/03/21 07:32
>>58
ごめん。書き込んでから気付いたんだけど、<= だと += なんかと紛らわしいかも。

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

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

63 :デフォルトの名無しさん:03/03/21 08:34
>>58 ^^

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


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

例えば、
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かな。

65 :デフォルトの名無しさん:03/03/21 09:34
if I were a bird 構文

66 :デフォルトの名無しさん:03/03/21 09:49
>>8
使える型が限定されているならわざわざ無理してswitch文を
使うまでも無い。
修正が容易な構文はsewitchよりもif-else-ifネストだ。

67 :デフォルトの名無しさん:03/03/21 10:48
>>66
>使える型が限定されているならわざわざ無理してswitch文を使うまでも無い。



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

68 :デフォルトの名無しさん:03/03/21 14:00
>>64
>a<-b/-c<-d/-e<-f/-g<-h();
>a^^b/^c^^d/^e^^f/^g^^h();
慣れてもどれがどう対応するのか読みづらいような…


69 :デフォルトの名無しさん:03/03/21 14:38
ML みたいに関数呼び出しに括弧をつけないようにすれば問題解決

70 :デフォルトの名無しさん:03/03/22 08:05
A <--> B

AならB、BならAに

71 :デフォルトの名無しさん:03/03/22 11:53
>>69
MLみたいにって…
MLには既に o という同じことをする演算子があるのに
それは指摘しないのか

72 :58:03/03/25 12:34
>>71
MLにはそんな演算子があったんですか。
それは、引数が複数ある場合はどうなるのかな。
あ、そういやMLの関数は引数が1つだけと聞いたことがあるから、
問題ない?

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

今の仕様では、
func0 /- arg1 /- arg2 <-
func1 <- func2 <- func3 <- func4()

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

73 :デフォルトの名無しさん:03/03/25 13:49
void SINE()
{
printf("死ね");
SINE();
}

74 :デフォルトの名無しさん:03/03/25 15:24
>>73
無限ループネタを今更やられてもなぁ。

75 :デフォルトの名無しさん:03/03/25 19:01
ある関数のローカル変数が、その関数から呼び出された関数からなら
参照可能になるような変数があったら便利と思うのはおれだけ?

76 :デフォルトの名無しさん:03/03/25 19:04
>>75
うん、考えたこともなかった。

77 :デフォルトの名無しさん:03/03/25 19:41
>75
Emacs LispのDynamic Scoping(古いLISPに多い)のこと?

78 :75:03/03/25 19:49
Emacs LispもDynamic Scopingも知らん(恥
既にあるなら忘れてくれ。

79 :デフォルトの名無しさん:03/03/25 20:37
文字列にプログラム文を格納して発動。
例:char com[16] = "sizeof(com)"; //文を格納する
int size = @com; //"@"で発動する

80 :デフォルトの名無しさん:03/03/25 20:41
eval

81 :デフォルトの名無しさん:03/03/26 12:53
>>75
Pascalなら関数のネストが出来るから
そんな感じのコードが書けると思うけど。
ちょっと違うか

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

83 :デフォルトの名無しさん:03/03/26 18:12
なんで、昔っからあるようなのとか、全然文法レベルの新規性のないのしか出てこないんだ。
藻前ら、もうちょっと勉強汁!

BrainF*ckとか

84 :デフォルトの名無しさん:03/03/26 18:30
なんか関数で配列返せたらいいと思う。
関数は値を返す、手続きは処理をするとキッチリ分けたい。

85 :デフォルトの名無しさん:03/03/26 18:31
switch (a,b,c) {
case (3,5,2):
...
break;
case (3,4,1):
...
break;
default:
...
}

86 :デフォルトの名無しさん:03/03/26 18:44
else-if でもいいんだけど。
switch {
case( 式1 ) {
}
case( 式2 ) {
}
}

87 :デフォルトの名無しさん:03/03/26 18:46
>>84
javaはふつうにできますが。って言うかCでも何も考えなきゃできるでしょう。

88 :デフォルトの名無しさん:03/03/26 18:48
こんなのがいいです。
if (a){
case(==b){
}
case(!=b){
}
}

89 :デフォルトの名無しさん:03/03/26 18:53
>>88
文法破綻してないか?


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

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


91 :デフォルトの名無しさん:03/03/26 22:13
>>89
「新しい文法」ならいいんだろう。
面白みも旨みも新鮮さも感じられないが。

92 :デフォルトの名無しさん:03/03/26 22:19
-*(x]
i
&&{{{}}}}}}{}{{}{};;;;;;;:
i

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


93 :デフォルトの名無しさん:03/03/26 23:23
>>92
何それ? 何に使うの?

94 :デフォルトの名無しさん:03/03/26 23:48
>>92

宇宙人との交信ですか?

95 :デフォルトの名無しさん:03/03/27 00:15
NetHack にしか見えません。

96 :デフォルトの名無しさん:03/03/27 00:38
NULLPO(NULLPO)->NULLPO

97 :デフォルトの名無しさん:03/03/27 01:19
ずっと前にこんなんあったらいいのになと思って、今も思い続けている。
画期的な制御構造だと思うがどうだろうか?

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

98 :デフォルトの名無しさん:03/03/27 01:21
似たようなのがpythonになかったっけ

99 :デフォルトの名無しさん:03/03/27 01:24
あるの!?調べてミマス

100 :デフォルトの名無しさん:03/03/27 01:26
終了条件を書けるループとか便利っぽい

101 :デフォルトの名無しさん:03/03/27 01:39
do {
...
while ( hoge ):
...
}
まんなかで、条件判断がしたい…

102 :デフォルトの名無しさん:03/03/27 01:41
>>101
for(;;){
...
if( !( hoge)) break;
...
}

103 :デフォルトの名無しさん:03/03/27 01:43
>>102
美しくない。。。。for(;;)きらい。
101は、なかにwhileがひとつだけじゃないとコンパイラに怒られる
ようにしたい。

104 :デフォルトの名無しさん:03/03/27 01:47
>>103 どうなっとるんだ お前は

105 :デフォルトの名無しさん:03/03/27 01:51
>>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


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

107 :デフォルトの名無しさん:03/03/27 01:54
>>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しました。");
}

}

108 :デフォルトの名無しさん:03/03/27 01:58
>>107
ラベルでgotoしても同じだな。

109 :デフォルトの名無しさん:03/03/27 02:00
>>108
gotoなんて飾りですよ

110 :デフォルトの名無しさん:03/03/27 02:01
ループから抜ける程度のことに例外を使うな。

111 :97:03/03/27 02:02
>>105
ネストしたらどうする?

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

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

112 :デフォルトの名無しさん:03/03/27 02:04
>>111
今でも全くいらないですが…

113 :デフォルトの名無しさん:03/03/27 02:04
>>111
煽られた・・・

114 :デフォルトの名無しさん:03/03/27 02:05
>>111
ループが指定した回数回らない。ってのは十分「例外」だと思うが。
その冷害が起こったときにある処理をさせたいわけだ。

何の問題がある?

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

とりあえず今日はねる

116 :デフォルトの名無しさん:03/03/27 02:07
>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

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

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

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

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

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


117 :デフォルトの名無しさん:03/03/27 02:08
>>112
すまぬ、言い方を変えよう
「これで本当にgotoを使いたいと思う時がまったくなるだろう」

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

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

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

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

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

とりあえず今日はねる
   

118 :デフォルトの名無しさん:03/03/27 02:10
>>112
状態遷移を表現するのにgotoは直感的でいいですよ。
あとは、腐ったループから抜けるとき。

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

119 :97:03/03/27 02:11
>>114
だったらelseも例外だなププ

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

120 :デフォルトの名無しさん:03/03/27 02:11
>>119
そうか?

121 :デフォルトの名無しさん:03/03/27 02:12
>>118
性能が問題にならないなら、

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

にするけどね…

122 :デフォルトの名無しさん:03/03/27 02:14
>>119
本質的なことを聞くけど、いくらでも解決法のある問題で、一番面倒な「そういう仕様になるまで祈る」を選択したんだい?

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

123 :97:03/03/27 02:15
>>122
ダメ社会人必死だな(ププ

124 :デフォルトの名無しさん:03/03/27 02:16
>>123
お前もな。 

125 :105:03/03/27 02:20
>>111
ブロックで囲ってるんで、ネストしても大丈夫だと思うんですが。

126 :デフォルトの名無しさん:03/03/27 05:47
blkname:block
   :
   :
   if xxxx then
     break blkname
   endif
   :
endblock
→ここに抜ける



127 :デフォルトの名無しさん:03/03/27 06:01
新しい文法なんてやめて、みんなでvaja極めようぜ
http://www9.plala.or.jp/oomasuya/diary.html

128 :デフォルトの名無しさん:03/03/27 12:22
ループ開始
  :
  :
 もし 〜 なら ループの最初から
  :
  :
ループ終わり

129 :デフォルトの名無しさん:03/03/27 13:12
>>101
俺もそれ、欲しい。
ボーンシェル系の while って、そんな感じだよな。

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


130 :デフォルトの名無しさん:03/03/27 18:06
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;// そう、お前の責任だ!


131 :デフォルトの名無しさん:03/03/27 18:43
printf("test\n")w
scanf("%s", a)www
return 0 WWW

132 :デフォルトの名無しさん:03/03/28 02:17
括弧に名前が付けられる機能。

<name>{
...

<name>}


133 :デフォルトの名無しさん:03/03/28 04:28
>>126
ラベル付き break なら Java とかにある。

134 :デフォルトの名無しさん:03/03/28 13:05
括弧の代わりにインデントでネストを表現するLISP

135 :デフォルトの名無しさん:03/03/28 14:25
そもそもプログラムが、一直線に並んだバイト列から成ってて、
最初から終わりに向かってだらだら読まれるっていう今までの
前提を覆すってのはどうよ。

136 :デフォルトの名無しさん:03/03/28 14:34
Prolog とか OPS とか

137 :デフォルトの名無しさん:03/03/28 15:18
>>135
逆さに・・・

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

138 :デフォルトの名無しさん:03/03/28 17:12
>>129
bourne shは、式と文を区別しないからそう書ける。
というか式と文の区別自体無意味で盲腸のようなもんだと思う。

139 :97:03/03/28 22:26
C#にoverrideがあるらしいが、インターフェイス名を書けると、よりエラーを検出しやすいと思うんだけど・・
javaを↓のように拡張キボンヌ

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

140 :97:03/03/28 22:31
あと、return文は関数の最後にしか書けないようにシロ
途中でreturnするのはgotoと一緒だ

141 :デフォルトの名無しさん:03/03/28 22:39
>>140
そんなこと言ったら continue break はどうなんだ

142 :デフォルトの名無しさん:03/03/28 23:53
>>140
反対!! さっさと抜け出したほうが見やすい

143 :デフォルトの名無しさん:03/03/29 00:47
>>140
アホか。これ以上やることのない条件を最後まで引っ張ったらインデントは増えるわ条件分岐のコストはかかるわろくなことがない。

144 :97:03/03/29 02:27
>>141
continueは廃止
breakは1ネストの脱出だからOK

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

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

145 :デフォルトの名無しさん:03/03/29 02:29
>>144
はいはい、一生行ってなさい。

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

146 :デフォルトの名無しさん:03/03/29 02:31
>>145
負け惜しみ全開だな

147 :デフォルトの名無しさん:03/03/29 02:31
>>146
sage覚えた方が良いですよ。

148 :デフォルトの名無しさん:03/03/29 02:34
>>144
成否を判定すべき処理ごとに関数を作れってことか?
じゃないと if のネストが深くなるだけのような気が

149 :デフォルトの名無しさん:03/03/29 02:34
ワラヤ

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

151 :デフォルトの名無しさん:03/03/29 03:02
>>150
いや、いきなり言われてもコードはだせないけど、
普段はよく、
 なんかやって失敗したら return false;
 なんかやって失敗したら return false;
 ・・・
 最後に return true;
みたいにするから。

152 :プロの逝って良しの1 ◆MvRbZL6NeQ :03/03/29 03:05
返り血が複数
a,b,c,d,e = subroutine( a1,a2, obj );
これは絶対必要だな。

153 :デフォルトの名無しさん:03/03/29 06:16
>>152
そんなんなら、いっそのこと返り値なしのほうがスッキリする。

154 :デフォルトの名無しさん:03/03/29 08:45
>>152
同意。入力は引数、出力は返値と区別したいモノだ。

155 :デフォルトの名無しさん:03/03/29 08:57
>>152
良いなそれ。

156 :デフォルトの名無しさん:03/03/29 08:58
構造体とかリスト使って返せばいいだろ

157 :デフォルトの名無しさん:03/03/29 09:00
>>156 めんどくさい

158 :デフォルトの名無しさん:03/03/29 12:54
common lisp, scheme なら構造体やリストなしに複数の値を返せる

159 :デフォルトの名無しさん:03/03/29 12:56
>common lisp, scheme
リストを基本とした言語だな。

160 :デフォルトの名無しさん:03/03/29 13:01
>>158
リストじゃねーか

161 :デフォルトの名無しさん:03/03/29 13:24
values を知らないのか…

162 :デフォルトの名無しさん:03/03/29 13:27
>>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);


163 :デフォルトの名無しさん:03/03/29 13:30
>>162
>int int int subroutine(int,int,int);
複数の値を返す関数へのポインタを複数返す関数 のプロトタイプってどうなるんだ?

164 :デフォルトの名無しさん:03/03/29 13:32
>>162
ええ、PerlとかPHPではできるね。

実質、このスレって

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

っしょ。

165 :デフォルトの名無しさん:03/03/29 19:07
>>162
> int int int subroutine(int,int,int);

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

166 :デフォルトの名無しさん:03/03/29 19:09
[long, long, int] proc(int, int, int);

167 :デフォルトの名無しさん:03/03/29 20:00
>>複数の値を返す
C++ でもテンプレート使って頑張れば
十分実用的なものが作れるよ。

168 :デフォルトの名無しさん:03/03/29 21:10
>>167


169 :167:03/03/29 21:44
>>168
MType<int, int> foo()
{
 return MValue(10, 20);
}

foo() >> a >> b;

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


170 :デフォルトの名無しさん:03/03/29 22:03
>>169
テンプレート詳しくないんだけどこのMTypeってのは2つ以上の任意の数の型で具象化できるの?

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

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

172 :デフォルトの名無しさん:03/03/29 22:42
>>171
boost使え

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

173 :162:03/03/29 22:47
>>163
そ、想像もしたくない。

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

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


174 :デフォルトの名無しさん:03/03/29 23:12
ttp://www.system-azure.co.jp/dance/azure0013.html
こんくらい奇抜なのもあるくらいだからなぁ。

175 :デフォルトの名無しさん:03/03/29 23:24
>>174
強烈・・・。


176 :デフォルトの名無しさん:03/03/30 11:35
>>174
クダラネ

177 :デフォルトの名無しさん:03/03/30 16:11
>>173
> 関数の返り値と返り値が代入される左辺値の型が厳密な言語仕様にするとか・・・。

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

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

178 :デフォルトの名無しさん:03/03/30 20:25
>>174

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


179 :デフォルトの名無しさん:03/03/30 21:27
>>177
long intとかのintを省略できないようにすればよい

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

180 :デフォルトの名無しさん:03/03/30 22:48

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

じゃだめなの?

181 :デフォルトの名無しさん:03/03/31 01:38
じゃあ、返値もオーバーロードさせてほしいな。

182 :デフォルトの名無しさん:03/03/31 03:36
(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*)

183 :デフォルトの名無しさん:03/03/31 07:52
>>181
それって返値を絶対に受け取らなきゃいけない訳で。


184 :デフォルトの名無しさん:03/03/31 09:47
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 ) ) {
って書きたい。

185 :デフォルトの名無しさん:03/03/31 09:52
委譲の明示。
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 :デフォルトの名無しさん:03/03/31 13:09
構文を拡張できる言語ってなにかありますか?

187 :デフォルトの名無しさん:03/03/31 14:09
>>186
Lisp

188 :デフォルトの名無しさん:03/03/31 14:33
>>184
switch (GetFruit()) {
case FRUIT_RINGO:
case FRUIT_BANANA:
case FRUIT_ORANGE:
case FRUIT_MIKAN:
    foo();
}

じゃ駄目?

189 :デフォルトの名無しさん:03/03/31 15:32
>>184
PASCAL ならできる。

190 :デフォルトの名無しさん:03/03/31 17:47
せっかくだから集合論型言語。
> FRUIT = ( RINGO, BANANA, MIKAN )
> RED * FRUIT?
( RINGO )
逆に
> RINGO := RED * FRUIT
> BANANA := YELLOW * FRUIT
> MIKAN := ORANGE * FRUIT
と定義して、
> FRUIT?
( RINGO, BANANA, MIKAN )
と集合を返すこともできるとか。
・・・Prologみたいな。

191 :デフォルトの名無しさん:03/03/31 18:06
>190
え、prologでできるんじゃ?

192 :デフォルトの名無しさん:03/03/31 18:53
俺の大好きなLispとCを合体させた言語の仕様を考えてください。

193 :デフォルトの名無しさん:03/03/31 19:56
>>192 C のどこがお好きですか?

194 :デフォルトの名無しさん:03/03/31 20:09
>>192
LISPで適当なトランスレータ作るとか。
S式と違って、文法的なエラーを早い段階で検出できるから、
素で書いてくよりも効率いいし、append系を演算子にすると楽だよ。
S式自体も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)))))

195 :デフォルトの名無しさん:03/03/31 20:12
>>193
本当はC++が好きです
何でC++が好きかというと・・・なんでだろ?

196 :デフォルトの名無しさん:03/03/31 20:13
>>194
なるほど、参考になります

197 :デフォルトの名無しさん:03/04/01 20:36
陰関数が使えたらな〜

198 :デフォルトの名無しさん:03/04/02 21:16
陰茎が使えたらな〜

199 :デフォルトの名無しさん:03/04/02 23:05
ハーマイオニーたんが使えたらな〜

ハーマイオニーたん「使っていいのよ」
おれ「ありがとう。助かるよ。」
シュッシュッ

200 :デフォルトの名無しさん:03/04/03 10:17
ハァハァマイオニィたん「やらないか?」

201 :デフォルトの名無しさん:03/04/03 18:42
ウホッ、いいハァハァマイオニィ

202 :デフォルトの名無しさん:03/04/04 22:35
main()
{
 int i↓
 for(i = 0→ i < 5→ ++i)
 {
  printf("%d\n", i)↓
 }↓
 (゚д゚)ウマー
}

203 :デフォルトの名無しさん:03/04/04 22:59
>>202
何がおもしろいのか分からない。

204 :vbMan:03/04/05 01:45
Cに汚染されてるな

205 :デフォルトの名無しさん:03/04/09 01:21
確かに多重継承は制御がややこしいけど、
インタフェイスのみだと不便なこともあるよね。
Template Method パターンを2つ以上使う必要があるときとか。

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

206 :あぼーん:03/04/09 01:27
あぼーん

207 :デフォルトの名無しさん:03/04/09 02:12
>>205 な貴方は Ruby の Mix-in で感動せよ

208 :デフォルトの名無しさん:03/04/09 12:28
>>205
Javaのintarfaceの中でもメソッドが定義できると良いよね。
intarfaceのメソッドを継承先で、マクロ、テンプレートみたいに
コードを展開(コピペ)すれば、javaの構造を変えずに出来るのに・・・

209 :デフォルトの名無しさん:03/04/09 12:52
>>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に委譲
}

210 :デフォルトの名無しさん:03/04/09 13:45
>>209

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

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

212 :デフォルトの名無しさん:03/04/09 15:27
>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"))

213 :212:03/04/09 15:38
;; 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"))

214 :デフォルトの名無しさん:03/04/09 15:54
便乗して
//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"))

215 :デフォルトの名無しさん:03/04/09 17:03
>>184
(if (memq (get-fruit) '(ringo banana orange mikan))
  'fruit
  'unko)

216 :デフォルトの名無しさん:03/04/09 20:10
age

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

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

218 :デフォルトの名無しさん:03/04/09 21:53
多重継承の概念と
インターフェイスの概念と
似てるけど
根底に流れる思想は
違うものなので
勘違いなさらない

219 :デフォルトの名無しさん:03/04/09 22:01
>>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

220 :デフォルトの名無しさん:03/04/09 22:11
>>218
思想が違うのは理解している。
大体別の思想を持っていなかれば別のプログラミング言語
なんて、でっち上げないよ。

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


221 :205:03/04/11 02:30
>>219
アリガォ。
Mix-in のこと、全然分かってませんでした。
やっぱ Ruby の本3日で読んで
そのまま貸しちゃったのがいけなかったか。

要するに、継承関係が2次元になったということでいいんでしょうか?
既存のクラス構造をそのままに、新しい機能を追加できる、と。
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();

みたいな感じで。

222 :デフォルトの名無しさん:03/04/11 02:34
文法なんてもう古い。
ttp://compsoc.dur.ac.uk/whitespace/

223 :デフォルトの名無しさん:03/04/11 02:43
>>222
アホだ、すげえ笑った。

224 :デフォルトの名無しさん:03/04/11 02:43
>>222
最高にワラタ
http://compsoc.dur.ac.uk/whitespace/count.ws


225 :デフォルトの名無しさん:03/04/11 02:46
Cでもwhitespaceでも動くプログラムはすぐ作れそうだね。(ほんとか?)
作る気にもならんが。

226 :デフォルトの名無しさん:03/04/11 02:52
>>225
ああ、なるほど。そういうものですか。

227 :デフォルトの名無しさん:03/04/11 02:57
よくわからんが、空白文字以外は全て無視するのか?

228 :デフォルトの名無しさん:03/04/11 03:08
>>227
スペースと改行とタブ以外は無視。

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

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

230 :デフォルトの名無しさん:03/04/11 03:15
書かれたものがいくつも構文解釈されうるのってなんか面白いね。

231 :訳してみた:03/04/11 03:52
「Whitespace」とは。

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

232 :デフォルトの名無しさん:03/04/11 04:38
つまり、インデントが文法に組み込まれてる Python は
パーフェクトということでつか?

233 :デフォルトの名無しさん:03/04/11 04:45
Haskellも、空白文字を使ったレイアウトが文法に組み込まれてる

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

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

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

235 :デフォルトの名無しさん:03/04/11 13:22
全部XMLで書く言語とか

236 :デフォルトの名無しさん:03/04/11 13:49
>>235
XSL


237 :デフォルトの名無しさん:03/04/11 14:17
XML->sexpr
sexpr->XML

238 :デフォルトの名無しさん:03/04/11 14:23
sexp >>>> XML

239 :デフォルトの名無しさん:03/04/11 17:25
>>234=205
ダイヤモンド継承問題って知ってる?


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


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

242 :デフォルトの名無しさん:03/04/12 21:10
クラスを使用しなくて、基本型を複数
かえせる関数がほしいなぁ〜

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


243 :デフォルトの名無しさん:03/04/12 21:18
goto 152;

244 :デフォルトの名無しさん:03/04/12 21:29
(゚Д゚)ウヴァー

245 :242:03/04/12 21:30
>>243
スマソ

246 :デフォルトの名無しさん:03/04/12 21:37
let (even,odd) = partition(even?, '(1 2 3 4 5)) in


247 :デフォルトの名無しさん:03/04/13 00:12
主語を書く。
Iはプログラマ。使わない。
YOUはコンピュータ。your keyboardとか。
HEは通常のユーザ。
You show Word "Hello World" by your display.
mustは必ず実行。canは気分で変わる。

248 :デフォルトの名無しさん:03/04/13 00:16
> HEは通常のユーザ。
男尊女卑だとの苦情がくる。it にすべき。

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

249 :デフォルトの名無しさん:03/04/13 00:17
import ソケット

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

私はソケット.new


250 :デフォルトの名無しさん:03/04/13 01:13
>>248
it だと物みたいだな。
he/she とか they(たとえ単数でも)とかにしる。

251 :デフォルトの名無しさん:03/04/13 15:38
userとかではダメなのか?

252 :デフォルトの名無しさん:03/04/13 15:47
>>251
I, youとしている以上、代名詞で揃えたいんじゃないか?

253 :デフォルトの名無しさん:03/04/13 16:32
英米語圏が激しく有利ですね

254 :デフォルトの名無しさん:03/04/13 22:38
i18n, m17n によって各語圏へ対応します

255 :デフォルトの名無しさん:03/04/13 22:59
まったく新しい文法ではないな。 英語の文法そのままにしただけっしょ

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

256 :デフォルトの名無しさん:03/04/13 23:04
今の若者には古いものが新しく見えるのです

257 :239:03/04/14 00:39
>>241=205
ダイヤモンド型からW型に変えれば?
結構知られているネタだと思うけど。

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

258 :デフォルトの名無しさん:03/04/14 00:53
× 一様
○ 一応

259 :デフォルトの名無しさん:03/04/14 01:16
どうでもいいけど、案外欲しいものはそろってるってことだなぁ〜。
まいなーチェンジばっかり

こんなのどう???

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

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

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


260 :デフォルトの名無しさん:03/04/14 03:02
>>259
???

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

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


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

262 :205:03/04/14 05:24
用語がまずいかも?
ファーストクラスってのは違うかも。
まぁ、とにかく、
暗黙的に与えられるあらゆるクラスの基底クラスのこと。

263 :デフォルトの名無しさん:03/04/14 05:38
可変個引数があると便利っす。

264 :デフォルトの名無しさん:03/04/14 05:53
>>259
if( x in { 1, 2, a+3 } ){
...
}

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

265 :デフォルトの名無しさん:03/04/14 06:44
まあ、C以外の言語触ってから文句言えってこった。


266 :デフォルトの名無しさん:03/04/14 07:18
昔からある手法を語る場か?ここは(ワラ

267 :デフォルトの名無しさん:03/04/14 07:52
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を掛ける


268 :デフォルトの名無しさん:03/04/14 08:15
ここの人ってLISPのマクロで適当な構文試したりはしないの?

269 :デフォルトの名無しさん:03/04/14 09:07
そもそも lisp をいじったことが無い人が多そう。

270 :デフォルトの名無しさん:03/04/14 09:25
lisp自慢房発生

271 :デフォルトの名無しさん:03/04/14 09:25
縦書きとか、右から左に書くとか

272 :bloom:03/04/14 09:31
http://www2.leverage.jp/start/

273 :デフォルトの名無しさん:03/04/14 09:38
条件演算子 and or があるのに but がないのは手落ちなので追加。


274 :デフォルトの名無しさん:03/04/14 10:02
じゃあついでにローテートシフト演算子みたいなのもつくってくれんかな

275 :デフォルトの名無しさん:03/04/14 10:04
まぁ、そういわずに勉強させて下さいよ。

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

276 :デフォルトの名無しさん:03/04/14 10:24
not

277 :デフォルトの名無しさん:03/04/14 12:19
>>270
lisp自慢房>>>>>>>>>>lispシラン房>>>>>>>>>>「lisp自慢房発生」とかサブイこと言う奴
ちなみに俺はlispマタ-クシラン房

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

278 :デフォルトの名無しさん:03/04/14 12:23
じゃ、縦書きで。

279 :デフォルトの名無しさん:03/04/14 12:33
文法宣言がある言語。

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

* (+ 1 2) (+ 3 4)




280 :デフォルトの名無しさん:03/04/14 14:06
>>279
メタ言語の文法はどうするのか?
lisp のマクロと、どう違うのか?

281 :あんまりマジレスされても困るが:03/04/14 14:42
>>280
>メタ言語
適当に作って定義を自己記述できるようにしといて
それを変更することによってメタ言語も変更可能にする。
(ことが可能かどうかは俺は知らん。)

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


282 :デフォルトの名無しさん:03/04/14 16:05
カレンダー指向プログラミング

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

283 :デフォルトの名無しさん:03/04/14 16:51
じゃ、逆斜め書きで

284 :デフォルトの名無しさん:03/04/14 16:56
>>282
ノイローゼですか?

285 :デフォルトの名無しさん:03/04/15 12:16
>>283
>じゃ、逆斜め書きで
文法とは言わない。
奇抜でもない。
メリット皆無。
そんなあなたもノイローゼ。

286 :デフォルトの名無しさん:03/04/15 16:42
そこにレスするあんたはノイローz(ry

287 :山崎渉:03/04/17 15:26
(^^)

288 :山崎渉:03/04/20 04:31
   ∧_∧
  (  ^^ )< ぬるぽ(^^)

289 :デフォルトの名無しさん:03/04/20 10:28
Lispの括弧は何故"(", ")"なのですか?
タイピングのしやすさを考えると、"[", "]"の方がよいのではないでしょうか?
エディタの補完を使うので括弧は直接打たない、というのであれば、
なおさら、"(", ")"である必要性もないと思うのですが。

290 :デフォルトの名無しさん:03/04/20 11:00
[] だとカッコ悪いから。

291 :デフォルトの名無しさん:03/04/20 11:09
>>289
[]でプログラミングして置換しろ

292 :デフォルトの名無しさん:03/04/20 15:13
()を使うことが多いですが[]も普通に使えますけど。
カッコが多重ネストして見難い時は混ぜたりするし。

293 :デフォルトの名無しさん:03/04/21 02:14
[...]にsuper-brace(超括弧)の意味が割り当てた処理系もある。
([(((((((((])

((((((((((()))))))))))
と同じ。

294 :デフォルトの名無しさん:03/04/21 04:41
仮想関数に対するアクセス修飾 (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 に書き間違えたままという
ことも無くなっていいな。

295 :デフォルトの名無しさん:03/04/21 04:42
でどうしても継承クラス側でアクセス修飾を変更したいときは __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 :デフォルトの名無しさん:03/04/21 08:54
キーワードやたらと増やすの良くないと思います

297 :デフォルトの名無しさん:03/04/21 10:31
>>296
そういって増やす代わりに既存のキーワードに複数の意味を持たせて分かりづらくなった言語があります

298 :デフォルトの名無しさん:03/04/21 15:19
>>294,295
言わんとすることは分かるが、このスレ的には面白くないな。
目新しさがない。

299 :デフォルトの名無しさん:03/04/22 00:53
>>289
"(",")" である必要がないというのはもっともです。
CommonLispでは reader-macro という機構によって
"(",")" のような記号もプログラマが自由に再定義
できるようになっているところをみると、昔の人も
そう思ったのでしょうね。

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


300 :デフォルトの名無しさん:03/04/22 01:08
>>297
キーワードやキーワードに持たせる意味を増やさなければいいのでは?
そういうのは極力少ないほうが言語が長持ちするとポールも言ってます。

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


301 :デフォルトの名無しさん:03/04/22 04:25
じゃーLISPやSchemeしかないじゃん。もしくはDylan?
C++とかもtemplateを構文に対して行える様にすればよかったのにね。
ていうかなんてこんな下なんだろ。

302 :デフォルトの名無しさん:03/04/22 20:30
>syntax-sugar を自由に定義できるような機能

#define loop for(;;)

303 :デフォルトの名無しさん:03/04/22 22:57
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 ; } }
}


304 :デフォルトの名無しさん:03/04/23 00:09
>>303
> リテラル定数ならぬリテラル関数が欲しい
で、前半との関連は不明ながら、結論はこれ?


305 :デフォルトの名無しさん:03/04/23 00:48
>>303
ラムダ式ね。
「全ての関数はメソッドでなければならない」言語では
あまり導入したがらないのかもね。

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

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

306 :デフォルトの名無しさん:03/04/23 00:59
構文というわけではないですが
ブロック内で生成されたオブジェクトを、
ブロックから抜けた時点で確実に開放するという機能が欲しいです。

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


307 :デフォルトの名無しさん:03/04/23 01:02
GC 使わんで free すればよかろう。

308 :デフォルトの名無しさん:03/04/23 01:07
>>307
freeのある環境ならそうしてますが。

309 :デフォルトの名無しさん:03/04/23 01:18
>>303
ほしい理由は判るけど、もうちょっと
カッコいい構文にならんか?

>while( a != b ) label {

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

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


310 :デフォルトの名無しさん:03/04/23 01:19
GC のある環境でそんなこと気にすんな。禿げる。

311 :デフォルトの名無しさん:03/04/23 01:24
>>310
でも、変なタイミングでGC呼ばれると困るかも・・?
と解決できない不安要素を抱えるのも禿げる原因になるのでは?
時間コスト掛かっても良いから、
一定のタイミングを保証したい場合とか。
ちなみに俺は禿げてませんよ。

312 :デフォルトの名無しさん:03/04/23 01:27
羊頭狗肉スレだな

313 :デフォルトの名無しさん:03/04/23 01:27
>>310
そじゃないでしょ。
開放するタイミングをコントロールしたいというのが
導入の動機でしょ?C++では良く使われている手だし。

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

314 :デフォルトの名無しさん:03/04/23 01:28
関係ないけど、「ハゲとプログラマの因果律」ってスレ立てていい?
つーか俺のプロバイダじゃ何故か立てられないから、誰かたのむわ。

315 :デフォルトの名無しさん:03/04/23 01:29
>>313
C#スレにいって愚痴れ。

316 :デフォルトの名無しさん:03/04/23 01:31
>>314
最初の内容をここに書いてみて

317 :デフォルトの名無しさん:03/04/23 01:37
>>316
世界にはハゲの侵攻を司る何らかの律、
運命というものが存在するのだろうか。
少なくとも人は自分の頭髪さえも自由にはできない。

318 :デフォルトの名無しさん:03/04/23 01:39
>>303
あんまり制御構文を複雑にするな
どうしてもというならPython使え
Pythonの制御構文はスゴイぜ

319 :デフォルトの名無しさん:03/04/23 01:50
>>317
マ板に立ててきたから逝って濃い
http://pc.2ch.net/test/read.cgi/prog/1051029981/

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

321 :デフォルトの名無しさん:03/04/23 01:59
>>319
ありがとう

322 :デフォルトの名無しさん:03/04/23 02:04
ディープコーダーさんにとっては
ガベージコレクションに利点は無いでしょ?

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

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

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

325 :デフォルトの名無しさん:03/04/23 11:48
そういやC#にもgoto無いんだっけ。

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

327 :デフォルトの名無しさん:03/04/23 12:24
continue はどうなるの?

328 :309:03/04/23 12:37
>>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;

329 :デフォルトの名無しさん:03/04/23 12:45
どのみちラベル置くならgotoの方が判りやすい

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

331 :デフォルトの名無しさん:03/04/23 13:11
>>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()が呼ばれる。
}
とか。

332 :デフォルトの名無しさん:03/04/23 13:47
new使わなきゃいいじゃん

333 :デフォルトの名無しさん:03/04/23 13:55
いや、C++以外でっちゅう話

334 :デフォルトの名無しさん:03/04/23 15:04
(call-with-hoge (lambda (hoge) (call-with-input-file "hoge.txt" (lambda (file) ...

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

336 :デフォルトの名無しさん:03/04/23 16:51
>>335
Generational GCみたいなもんか?

337 :デフォルトの名無しさん:03/04/23 16:57
>>336
目的がスコープ脱出お知らせシステムだから、もうちっと積極的。
自動的にGenerational GCインサイドになるでしょうね。

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

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


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

340 :デフォルトの名無しさん:03/04/23 18:31
リソース管理をするもの、それを OS という。

341 :デフォルトの名無しさん:03/04/23 19:03
C#にも関数内関数がほすぃな〜
void func( double a )
{
 double b = 5 ;
 System.Console.Write( hoge( 2 ) ) ;
 void hoge( double x )
 {
  return x * a + b ; // a b はともにこの関数のスコープ
 }
}
見たいに書けたら便利


342 :デフォルトの名無しさん:03/04/23 19:40
そんなものよりclosure。

343 :デフォルトの名無しさん:03/04/23 22:13
はっきりいってAlgol系の言語に属されている人ばかりですね。
もっとLisp系やProlog系にも触れた方がいいよ。

344 :デフォルトの名無しさん:03/04/23 22:16
>>343
Lisp系、Prolog系の特徴を教えてください
殆どの型は知らないのですよ、そういうの。
いや煽りでなくて。

345 :デフォルトの名無しさん:03/04/23 22:20
>>343
おれもそう思う。
>>344
そんなの検索しろよ。

346 :デフォルトの名無しさん:03/04/23 22:28
>>345
何でこっちで調べんといかんのよw
このスレの発展のために言ってるんだろ?

347 :デフォルトの名無しさん:03/04/23 22:40
何言ってんの?
スレの発展の話なんてしてないだろ。

348 :デフォルトの名無しさん:03/04/23 22:47
LISP系はマクロとか結構柔軟だから「文法」の話なんかする必要ないじゃん。
PrologやHaskelとか出てこないのは使ってる人が少ないというだけ?
それとも、文法的な不満は無いということかな?



349 :デフォルトの名無しさん:03/04/24 03:28
>>343
LISP を勉強した時は結構感動したな。
Prolog も勉強しようと思いつつ暇が無くてできない。
本は買ってるんだが。

350 :デフォルトの名無しさん:03/04/24 09:33
Haskell 辺りになると、もう創造できんというか、思いついた瞬間に苦笑してしまうことが多いしね。
いまどきの言語に取り込んで欲しいネタなら山程あるって感じだね。

351 :デフォルトの名無しさん:03/04/24 17:33
Prologの典型的なコードの例

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

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

352 :デフォルトの名無しさん:03/04/24 17:53
>>351
うぉ、何か面白い。Prolog触ってみよっかな


353 :デフォルトの名無しさん:03/04/24 21:08
>>348
Prologは知らんがHaskellは知っているヨ!
ttp://www.sampou.org/haskell/
で見てみ。
手続き型言語しか知らんものから見ると、まさに新次元新発想

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

355 :デフォルトの名無しさん:03/04/24 21:38
>>354
D言語のドラフトにはテンプレートがあるらしいよ
OOPだけどw

356 :デフォルトの名無しさん:03/04/24 21:40
>>353
> モナド I/O システム
ワロタ

357 :デフォルトの名無しさん:03/04/24 21:52
>354
F#は遅延評価はできるみたいよ。つーか見た感じ関数型といえる部分はそれだけのような…
(使ってはいないので、間違ってるかも。)

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


359 :デフォルトの名無しさん:03/04/25 00:20
>>358
関数型言語を知らないようだな。
同じ入力に対する同じ関数の出力は同一というのが普通。

360 :デフォルトの名無しさん:03/04/25 01:24
>>359
358がいいたいのは

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

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

361 :デフォルトの名無しさん:03/04/25 02:13
>>358
型推論持ってる関数型言語だとその場合、
Mathに副作用がないことが証明されてれば
自動的にやってくれると思う。
実行時じゃなくて、コンパイル時だけど。

362 :デフォルトの名無しさん:03/04/25 07:15
だから、一度関数型言語やってからにしてくれ・・・

363 :デフォルトの名無しさん:03/04/25 09:08
>>361
全てに対して値のキャッシュをすると、それはそれで問題もあるので、有効なものだけチョイスして欲しいと思ったんです。
それにしても、なんか妙に関数型に反応する人がいますね(藁

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

365 :デフォルトの名無しさん:03/04/25 09:30
なんか誤解のタネがわかったような気がする、Math.Sin とかって書いてあるのはC# です。
スマソ

366 :デフォルトの名無しさん:03/04/25 15:39
どのみちC#でもそれぐらいはやってくれると思うけど。
Mathって特別扱いしてそうだし。

367 :デフォルトの名無しさん:03/04/26 11:42
終了

368 :デフォルトの名無しさん:03/04/26 14:33
catch(...) {

369 :デフォルトの名無しさん:03/04/26 15:49
try_lock文

使い方

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

370 :デフォルトの名無しさん:03/04/26 16:09
とりあえず新しい文法云々言うのは、こんくらい勉強してからですな。
LISP/Scheme, Haskell, Ruby, Python, C#, Java, C++, Delphi, Prolog

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

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

372 :デフォルトの名無しさん:03/04/26 16:43
>>371
大きく別ければ、手続きによって駆動されももの、関数型、論理型の三つ
のミスでした。


373 :デフォルトの名無しさん:03/04/26 18:01
OOPが何故流行ったか? > ニーズに沿ってるから。
需要の少ない理論手法を持ち込んだところでそんなものは流行らない。


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

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

375 :デフォルトの名無しさん:03/04/26 19:26
>>371
> 文法の構築は、見掛けよりもその背景にある思想が重要と思う。
思想重視だと、好きじゃない機能を入れた方が良かったり、
なかなかストレスが…

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

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


376 :デフォルトの名無しさん:03/04/26 20:09
はへ? 言語の文法自体は簡単に覚えられるっしょ?
22歳だけど
>LISP/Scheme, Haskell, Ruby, Python, C#, Java, C++, Delphi, Prolog
のDelphi以外は勉強したよ?

377 :デフォルトの名無しさん:03/04/26 20:20
>>376
別にそれで実装してる必要はないものな
概念が分ればそれでよしみたいな

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

378 :デフォルトの名無しさん:03/04/26 20:21
>>376
Haskell,C++ を難なくこなせるとしたら、それは大した物だと思います。

379 :デフォルトの名無しさん:03/04/26 20:23
しかも22才か・・・凄いな。

380 :デフォルトの名無しさん:03/04/26 20:27
16進数で22歳かもしれないね。

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

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

383 :デフォルトの名無しさん:03/04/27 07:35
勝手に作れ

384 :デフォルトの名無しさん:03/04/27 08:20
Whyループ

why (?) {
  ...
}

385 :デフォルトの名無しさん:03/04/27 08:26
huhループ

huh (?) {
 ...
}

386 :デフォルトの名無しさん:03/04/27 08:49
oldコンストラクタ。
間違って破棄しちゃったオブジェクトが復活。

Object o = old Object();

387 :デフォルトの名無しさん:03/04/27 20:06
fuck*関数

mother fucker() {
 return >>384;
}

388 :デフォルトの名無しさん:03/04/27 20:11
always
他に usually, often, sometimes, seldom, never 構文も。

389 :デフォルトの名無しさん:03/04/27 20:57
文の最後にpleaseを付けるとエラーが出にくいとか。

390 :デフォルトの名無しさん:03/04/27 21:25
察してください
って感じ?

391 :デフォルトの名無しさん:03/04/27 21:43
漏れは関数型と手続き型言語を学べば良いと思う。
MLやHaskellをやれば論理型プログラミングを多少は学べるし
新しい言語を作るには最低でも各言語で中級(イディオム&パターン)程度の腕が居るだろうし
そうするには2,3年程度はかかるだろうねー
それからとなると年いくつになっているだろう?

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

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

392 :デフォルトの名無しさん:03/04/27 21:47
>>391
は? 

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

なんかおかしい。

393 :デフォルトの名無しさん:03/04/27 21:48
OOPは現実世界のものの繋がりをプログラムに表したものだから
マスターしてしまえば能動的に組めると言う利点がある
文系プログラマにとってこれほど喜ばしい手法はなかろうて

394 :デフォルトの名無しさん:03/04/27 21:51
関数型言語を導入するとバグが極力少なくなる事が証明されている。
これはオブジェクト指向言語を導入するよりも極端に影響する。

395 :デフォルトの名無しさん:03/04/27 21:52
>>392
フルCLOSがあるのはCommonLispでっせ。
Schemeのはそれと比べてしまうとエセっぽい。
それでも実用上十分だけど。

396 :デフォルトの名無しさん:03/04/27 21:55
あ、>>392じゃなくて>>391

397 :デフォルトの名無しさん:03/04/27 21:56
つーかCLOSはCommon Lisp Object Systemなわけですが。

398 :デフォルトの名無しさん:03/04/27 21:58
>関数型言語を導入するとバグが極力少なくなる事が証明されている。
>これはオブジェクト指向言語を導入するよりも極端に影響する。
関数型言語で減るバグっていうのは
副作用の無い関数にバグがでにくいからだよね?

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

399 :デフォルトの名無しさん:03/04/27 22:01
ソンナコトナイ

400 :デフォルトの名無しさん:03/04/27 22:03
Rubyが400げと!

401 :デフォルトの名無しさん:03/04/27 22:11
ソンナコトナイヨ

402 :デフォルトの名無しさん:03/04/27 22:46
>>391
MLやHaskellを論理型と言ってるのは
型推論とかパターンマッチとかそういう奴のことを指してるの?

403 :デフォルトの名無しさん:03/04/27 23:56
>>375
ただ言語のエッセンスを知りたいと言うだけなのにCLOS
のフルセットって要るん?

404 :デフォルトの名無しさん:03/04/27 23:58
>>398
でも関数型言語を使っている例は少ない。
なぜ?

405 :391:03/04/28 00:00
どちらかというと型推論かな?
402さんは、どう思う?


406 :デフォルトの名無しさん:03/04/28 00:27
>>404
MS が処理系を提供してないから。
悲しいけど、これ現実なのよね。

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

407 :391:03/04/28 01:33
>>406
viewというのも有るよね


408 :デフォルトの名無しさん:03/04/28 01:55
>>406 自己レス
ただ、MS も F# とか言うのを出すみたいなんで、
これからどうなるかは分かりませんな。
ML/Caml + .NET とのたまってるようだけど、どうなんでしょな。

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

410 :デフォルトの名無しさん:03/04/28 07:57
F#ってCallbyValueなのか
Lazyの方が楽しいのに
CallbyNameでもいいのに・・・

411 :デフォルトの名無しさん:03/04/28 15:03
マジ?>F#ってCallbyValue
サンプルコード、チラッと見て勝手にlazyだと思い込んでた。
確かにそれだとあんま面白くないなあ。

412 :デフォルトの名無しさん:03/04/28 15:18
「Lazy」って遅延評価のことだよね?
Camlって先行評価じゃなかったっけ。

413 :デフォルトの名無しさん:03/04/28 17:35
>410
メリットが無かったんでしょ

414 :名無し@沢村:03/04/28 18:12
ifは「もし〜なら〜の処理をする」
caseは「〜の場合〜の処理をする」
forとwhileは「〜の間中〜の処理をする」
という意味だよな。
要するに「もし〜なら、〜の場合、〜の間中」の発想から離れればいいわけだ。
だが「〜の処理をする」は不可欠だよ。処理をしないとプログラムにならんからな。
つまり「〜の処理をする」の前提の部分を他の言葉に置き換えれば新しい文法になるわけだよ。わかるかな?
たとえばnot ifというのはどうだ?
「もし〜でなかったら〜の処理をする」という新しい文法だよ!
またif andやif orというのも考えられるぞ。
「もし〜かつ〜だったら〜の処理をする」「もし〜または〜だったら〜の処理をする」という新しい文法だよ。
またnot caseは「〜でない場合〜の処理をする」
while selectA,B,Cは
「〜の間中、AとBとCの中から適当に処理を選んで実行する」だ。
これだと人口知能向きの言語だね。
おまいらよ、新しい発想というものはこうやって考えるものだよ!!

415 :デフォルトの名無しさん:03/04/28 18:15
>>414
ネタにもならない長文書くな

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

417 :デフォルトの名無しさん:03/04/28 20:33
新発明「ifif文」

418 :デフォルトの名無しさん:03/04/28 21:02
モシモシ?

419 :デフォルトの名無しさん:03/04/28 21:44
>>413
はぁ?

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

420 :デフォルトの名無しさん:03/04/28 21:47
>>414
人口無能さん、氏ね。

421 :デフォルトの名無しさん:03/04/28 22:06
>>419
413じゃないけどLazyのメリットって

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

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

422 :デフォルトの名無しさん:03/04/28 23:19
▼新次元新発想!新しい文法を作るスレ
http://pc2.2ch.net/test/read.cgi/tech/1047970129/l50

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


423 :デフォルトの名無しさん:03/04/29 00:28
>>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 :デフォルトの名無しさん:03/04/29 01:26
おお、最近のたらい回し関数(竹内関数)ブームをご存知ないと!?
「竹内関数」+「たらいまわし」でぐぐると出てくるよ

425 :デフォルトの名無しさん:03/04/29 01:48
たらいまわし関数って、ただのベンチマークじゃないのん?
まぁ、たらいまわし関数以外でも速くなることもあるんだろうけど。

426 :デフォルトの名無しさん:03/04/29 02:00
>>424
わざとらしくRubyと比較させてるところがなんとも(w
今のところ非正格が有利に働くのはごく一部の計算についてだけです。
http://www.bagley.org/~doug/shootout/lang/ocaml/
http://www.bagley.org/~doug/shootout/lang/ghc/
http://www.bagley.org/~doug/shootout/lang/ruby/

427 :デフォルトの名無しさん:03/04/29 02:26
Ruby な人だから Ruby と比較してるだけかと。

428 :デフォルトの名無しさん:03/04/29 02:34
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})

429 :デフォルトの名無しさん:03/04/29 02:35
あ、修正し忘れ。
x.call を2度書いちゃってる。
if 文の x.call は xval にしてね。

430 :デフォルトの名無しさん:03/04/29 02:36
うわ、これ修正したら Haskell より速くなっちゃったよ(笑

431 :デフォルトの名無しさん:03/04/29 02:50
部分的に遅延評価できるようにする文法を導入する...
というのも、文法がややこしくなるなぁ。
かといって、特別な文法を用意しないと
上のコードみたいに不恰好になってしまう。

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

432 :デフォルトの名無しさん:03/04/29 03:02
一応実測値を出しておこう。
インタプリタなんでどこまで比較できるのか知らんが。

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

433 :デフォルトの名無しさん:03/04/29 03:20
>>432
ttp://www.loveruby.net/~aamine/ja/tdiary/20030425.html#p08
好きなだけまわせ

434 :デフォルトの名無しさん:03/04/29 04:44
>>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;
}

435 :デフォルトの名無しさん:03/04/29 08:55
実行速度を優先するならcかFortranでもやっていなさい
別の言語を使う、作るというのは別の発想をしたいからでしょ?
あんたたちが考えているより、遙かに人間の思考は言語によって左右される。
言語っていうのは、もっとスゲエもんなんだよ。

436 :デフォルトの名無しさん:03/04/29 09:16
>>435
Cで普通に組むより速いから、こうして話題になってるわけで。
既存の言語にももっと目を向けなさいってこった。

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

438 :デフォルトの名無しさん:03/04/29 10:58
ていうか、新しい文法はまだかね?

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

440 :デフォルトの名無しさん:03/04/29 11:26
>>439
まちがえた、非正格は文法じゃないな・・・なんていえばいいんだろう?

441 :デフォルトの名無しさん:03/04/30 00:03
意味論ですかな?
簡約戦略(実行方法)かな?

442 :デフォルトの名無しさん:03/04/30 00:48
仕様です。

443 :デフォルトの名無しさん:03/04/30 01:01
統語論syntax
意味論semantics

444 :デフォルトの名無しさん:03/04/30 01:17
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);;

十分シンプルじゃね?

445 :デフォルトの名無しさん:03/04/30 01:21
まぁ、通常のリストとは別扱いになっちゃうあたりが甘いか。

446 :デフォルトの名無しさん:03/04/30 01:57
これなら一応両方いけるね。

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];;

447 :デフォルトの名無しさん:03/04/30 18:43
HaskellではLazyを基本としている所が、凄いんです。
馬鹿には、それがわからんのです。

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

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

448 :デフォルトの名無しさん:03/05/01 02:16
Lazy にしかできない、というところに違和感を感じる。
Lazy にする必要のないところでも Lazy になった場合にも、
効率はいいの?

449 :デフォルトの名無しさん:03/05/01 06:28
lazy じゃなくていい式を lazy に評価しても、 call-by-need ならあんまり変わんなそうな気がするけど。
逆に、 lazy にしない理由って効率だけ?

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

450 :デフォルトの名無しさん:03/05/01 08:38
>>447
> MLに限らずLisp(delay)でも悪名高きC言語(関数ポインター)でも
> 遅延評価できますって。
例えば、Cだとどんな風になるの?
頭の悪い俺にもわかるようにサンプルきぼんぬ。

451 :デフォルトの名無しさん:03/05/01 10:09
>>448
lazy の式でも実行時はlazy で無くてよい式と判別可能な式は結構あるし、
全部lazyでOKではと思うこともあるね。
ガベコレのようにこなれるといい方法も出てくるかも知れない。

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

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

454 :デフォルトの名無しさん:03/05/01 22:29
>>449 は何か読み違えてるっぽい…効率の話は lazy 側から出てたね。
とりあえず二行目撤回。
素直に書いてもそれなりに効率よく動くって、大きいと思う。


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

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

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

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

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

456 :デフォルトの名無しさん:03/05/02 21:15
CでLazyは簡単だよ。あまりにも簡単なので拍子抜けする人続出だと思うけど。

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

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

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

457 :デフォルトの名無しさん:03/05/05 01:25
C なら構造体にしてパラメータと一緒に渡さないとナ。
C++ だと operator() を持ったクラスを作って渡すのがパターンだな。

458 :デフォルトの名無しさん:03/05/05 08:23
作業量が多すぎて実用にならなさそうなパターンだな

459 :デフォルトの名無しさん:03/05/05 15:20
>>456
よくわからんので実際にコード書いてくれ。


460 :デフォルトの名無しさん:03/05/05 16:23
今度から関数といえば
  y = f(x)
のことを表す。




461 :デフォルトの名無しさん:03/05/05 16:36
>>458
STL のアルゴリズムとか使った事無い?
まぁ、個人的には作業量多くて確かにあまり使いたくないのだが。

462 :デフォルトの名無しさん:03/05/06 01:04
>>461
STLの場合は限定的な使い方しかしてないから十分実用範囲じゃない?
遅延評価用に関数オブジェクトなんて使ったら気絶しそうだ

463 :デフォルトの名無しさん:03/05/06 01:56
幼女を意のままに操る文法ください

464 :デフォルトの名無しさん:03/05/06 02:11
>>462
関数オブジェクト?使えば良いじゃん。
なんで嫌なの?
効率?(Pool使えば良いよね?)
変?(一種のCallbalckだと思えば?)

465 :デフォルトの名無しさん:03/05/06 02:13
関数オブジェクトはC#のdelegateみたいだ。
故にクソだ。

466 :デフォルトの名無しさん:03/05/06 02:13
そもそも関数がオブジェクトなんてオブジェクト指向的にわらっちゃう。

467 :デフォルトの名無しさん:03/05/06 02:18
可読性重視のAA文法

  ∧_∧   
 ( ´∀`)< Helo World

468 :デフォルトの名無しさん:03/05/06 02:48
>>464
まぁ、C++だとそれで仕方が無いけど、
ラムダ式のある言語を知ってると、
やっぱそれと比べちゃうんだよね。

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

469 :デフォルトの名無しさん:03/05/06 02:51
>>468
ありゃ冗談にしか使えねーよ。


470 :デフォルトの名無しさん:03/05/06 07:35
>>464
そういう問題ではなく、一体何百個クラス作るつもりですか?
といいたかったのですが

471 :デフォルトの名無しさん:03/05/06 07:59
>>470
必要なだけ。

472 :デフォルトの名無しさん:03/05/06 16:27
C++ でも Java みたいな無名クラスが使えたらねぇ。

473 :デフォルトの名無しさん:03/05/06 18:00
C++でもLispみたいな無名関数(lambda)が使えたらねぇ。


474 :デフォルトの名無しさん:03/05/06 19:02
#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!

475 :デフォルトの名無しさん:03/05/07 02:02
int x?
std::string x じゃなくって?

476 :デフォルトの名無しさん:03/05/07 06:49
>474
何言語ですか?

477 :デフォルトの名無しさん:03/05/07 06:58
Intelのコンパイラみただけど、拡張されてるのか?

478 :bloom:03/05/07 07:13
http://homepage.mac.com/ayaya16/

479 :デフォルトの名無しさん:03/05/07 07:14
妄想言語?

480 :デフォルトの名無しさん:03/05/07 07:17
--enable-lambda
という時点でおかしいとは思わんのか。

481 :デフォルトの名無しさん:03/05/07 18:26
>>479
新しい文法です。
つか、それがこのスレの趣旨じゃねーのかよ

482 :デフォルトの名無しさん:03/05/07 18:37
C++ にとっては新しいが、
一般的に見れば別に新しくも無いわけだが。

483 :デフォルトの名無しさん:03/05/07 21:24
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);
}

484 :デフォルトの名無しさん:03/05/07 21:27
一部 lambda の綴りが違うが気にするな。

485 :デフォルトの名無しさん:03/05/07 21:30
お、これでもいけるな。

#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; });
}

486 :デフォルトの名無しさん:03/05/07 21:59
>>474,483,485
新でもなんでもない。
ttp://www.kmonos.net/alang/boost/classes/lambda.html
もっと時代は、進んでるぞ。せめてネタとして、この本でも読んどけ。
ttp://www.biwa.ne.jp/~mmura/ModernC++Design/

487 :デフォルトの名無しさん:03/05/07 23:30
ハァハァハァ a
ソコダメ b

z = a + b

print z

実行結果

妊娠しますた

488 :デフォルトの名無しさん:03/05/07 23:31
そういうネタには飽きた

489 :デフォルトの名無しさん:03/05/07 23:35
int a, b, z;

z = a + b;

print z;

実行結果

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


490 :玄人:03/05/08 00:22
C++は穴だらけ

491 :デフォルトの名無しさん:03/05/08 00:25
>>490
何を今さら。

492 :デフォルトの名無しさん:03/05/08 00:35
>>490
そんな穴は自分で埋めればいい。そんなん誰でも、できるでしょ?

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

493 :デフォルトの名無しさん:03/05/08 09:05
森、言語を、推奨、した、いので、すが、いかが、でしょう、か?

494 :デフォルトの名無しさん:03/05/08 09:19
,を、無視、する、言語でし、ょう、か?

495 :デフォルトの名無しさん:03/05/08 12:58
>>493


496 :デフォルトの名無しさん:03/05/08 14:44
失言を、使って、プログラム、する、言語、でしょう、か?

497 :デフォルトの名無しさん:03/05/08 18:59
>>490
玄人ならば、ダメだダメだと言う前に使いこなして見せましょう
穴があるから使えないは素人の言い訳

498 :デフォルトの名無しさん:03/05/08 19:03
>>497
そういう発想がデザインを腐ったまんまにしてしまう要因だと
ノーマン氏が言ってたス。

499 :デフォルトの名無しさん:03/05/08 19:08
>>498
腐敗したまんまということにはならんでし?
これだけプログラミング言語が豊かなのに・・・

500 :デフォルトの名無しさん:03/05/08 19:17

/ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
| やはりC++はくさっていると・・・

   ̄ ̄ ̄|/ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
  ∧_∧       / ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
  ( ・∀・)  ∧ ∧ < ・・・
 (  ⊃ )  (゚Д゚;)  \____________
 ̄ ̄ ̄ ̄ ̄ (つ_つ__
 ̄ ̄ ̄日∇ ̄\| BIBLO |\
        ̄   =======  \


501 :デフォルトの名無しさん:03/05/08 19:26
>>497
http://www.namazu.org/~satoru/misc/bad-knowhow.html

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

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

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

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

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

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


504 :デフォルトの名無しさん:03/05/08 22:34
>>503
>複雑怪奇な仕様が歴史的に引きずられ

>emacs perlは思想的にバッドノウハウがあることを前提に作っている。
は同じ意味じゃん。

505 :デフォルトの名無しさん:03/05/08 23:43
lambdaccha

506 :デフォルトの名無しさん:03/05/08 23:45
>>503
> そしてTexが挙げられているのは納得できない。
> この文章を書いた人自身のセンスを疑う。

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

507 :デフォルトの名無しさん:03/05/09 00:38
TeX は汚い。
これ、定説。

508 :デフォルトの名無しさん:03/05/09 10:16
>>503
> そしてTexが挙げられているのは納得できない。
> この文章を書いた人自身のセンスを疑う。

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

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

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

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

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

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

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

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

511 :デフォルトの名無しさん:03/05/09 21:56
S 式で書ける TeX きぼ。

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

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

513 :デフォルトの名無しさん:03/05/10 01:08
>>509
> でも通称のcall-returnと継続を比べるとcall-returnの方が圧倒的に勝つともう。

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

514 :デフォルトの名無しさん:03/05/10 01:59
>>509=503
Texなんて書いてる輩がどれだけTeXについて知っているのか甚だ疑問

515 :デフォルトの名無しさん:03/05/10 02:18
>>513
>新しい文法を作るスレ
新しい文法に何を採用するかという競争

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


516 :デフォルトの名無しさん:03/05/10 02:26
>>515
> 競争
別に競争してる訳じゃないがな。
勝手に競争と後ろに付けるな、と。

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

517 :デフォルトの名無しさん:03/05/10 02:53
>>509
>歴史的は外的要因。前提に作っているのは内的要因(主体的)。
糞とわかってる仕様を採用するのは歴史に引きずられてる
以外の何者でもないよ。


518 :デフォルトの名無しさん:03/05/10 03:55
おまいら、撒き餌をむさぼるのも程々にしないと針まで食っちゃいますYO

519 :490:03/05/10 05:12
ゴメソ、プログラミング知らないけど何となく、らしいこと書いてみたかっただけだったり(ヮ

520 :デフォルトの名無しさん:03/05/10 16:03
継続なんてイラネ。

521 :デフォルトの名無しさん:03/05/12 20:27
ケイゾクってなにですか?

522 :デフォルトの名無しさん:03/05/12 21:09
カタカナで書かれるとなんかの映画みたいね。
continuation
http://www.sra.co.jp/people/aoki/SmalltalkTextbookJ/textbook27.html

523 :デフォルトの名無しさん:03/05/16 23:48
2chのスレにがんがん書き込んでいけるような文法考えようよ
まず行を節約できる。インデントを使わない。

524 :デフォルトの名無しさん:03/05/16 23:52
それよか全角空白を受け付けるようにした方が

525 :デフォルトの名無しさん:03/05/17 00:47
>>523
PerlかLisp系が既に。

526 :デフォルトの名無しさん:03/05/19 16:08
>>525
LispやPerlをインデント無しで書いて、読める?

527 :デフォルトの名無しさん:03/05/19 17:35
LISPの清書は簡単

528 :デフォルトの名無しさん:03/05/19 22:25
lisp は基本的にインデントなしでも、ほとんど支障はない

529 :デフォルトの名無しさん:03/05/19 23:32
Lisp がインデントなしでも支障ないって、ネタですか?

530 :デフォルトの名無しさん:03/05/20 03:34
LISPのインデントは全部機械がやるから
特に意識する必要がないって事では。
処理系に読みこませれば勝手に折り曲げるし。

531 :デフォルトの名無しさん:03/05/20 03:51
インデントが必須な言語の方が少ないような。
俺は Python と ABC しか知らないなぁ。
Haskell は必須ではないけど、
シンタックスシュガーとしてインデントが使えるね。

532 :sage:03/05/20 04:24
a(b(c(d,e(f))));

ってのを、

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

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

533 :デフォルトの名無しさん:03/05/20 05:08
分かりやすいような分かりにくいような...。
というか、そんなに見づらくなるほどネストするかな?

534 :デフォルトの名無しさん:03/05/20 05:35
むしろ関数型言語向けだな。
つーかカリー使えば必要無い罠。

535 :デフォルトの名無しさん:03/05/20 09:47
括弧が連続してるとパッと見で分かりにくいかもね

536 :デフォルトの名無しさん:03/05/20 10:07
全てをインデントだけで解決する言語。531のハスケル構文糖と同じかも
method1(method2(method3(var1, method4(var2))))を
method1
 method2
  method3
   var1
   method4
    var2


537 :デフォルトの名無しさん:03/05/20 10:15
(method1
  (method2
    (method3
      var1
      (method4
        var2))))

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

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

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

539 :デフォルトの名無しさん:03/05/20 19:51
>>538
まるでガキの発想だな。
>自分が保守することになったコードがインデント無しでも
>会社辞めたくなったりしないんでしょうか。
インデントすりゃいいだろ。アホか。

540 :デフォルトの名無しさん:03/05/20 21:44
「インデント無しでも読めないことはない」

「インデントが必須でない」
とは全く意味違うんだが

541 :デフォルトの名無しさん:03/05/20 22:07
インデント必須なら、きちんとインデントすることを文法レベルで強制できるから
宗教論争が起こらなくてよい。

542 :デフォルトの名無しさん:03/05/20 23:03
そうある言語とそうでない言語との間で宗教戦争が起きましたが何か?

543 :デフォルトの名無しさん:03/05/20 23:28
>>531
Occam

544 :デフォルトの名無しさん:03/05/20 23:32
問題は、「インデント無しで吐き気もせず読める言語」が存在するかということだろ。
結論:無い。

545 :デフォルトの名無しさん:03/05/21 00:29
N88-BASIC は?

546 :デフォルトの名無しさん:03/05/21 01:08
ホワイトスペースを文法構造に取り込むなどとは愚の骨頂

547 :デフォルトの名無しさん:03/05/21 01:23
>>546 にはこれがオススメ
http://slashdot.jp/article.pl?sid=03/04/08/0529232&topic=58&mode=thread

548 :デフォルトの名無しさん:03/05/21 04:24
ネストする制御構造がある時点で駄目

549 :デフォルトの名無しさん:03/05/21 12:49
文字コードをソースに含む時点で駄目

550 :デフォルトの名無しさん:03/05/21 14:21
駄目な奴は何をやっても駄目

551 :デフォルトの名無しさん:03/05/21 15:16
>>550
そんな自虐的にならなくても

552 :デフォルトの名無しさん:03/05/21 22:12
インデントもタブとスペースで意味が変わるの?


553 :デフォルトの名無しさん:03/05/21 22:56
やっぱPython, Makeにならってタブ&インデント


554 :デフォルトの名無しさん:03/05/22 00:13
変数名やらに半角カナが使える。


555 :デフォルトの名無しさん:03/05/22 02:19
>554
変に制限してなきゃ使えるだろ

556 :デフォルトの名無しさん:03/05/22 09:39
変数名やらに朝鮮語が使える。

557 :デフォルトの名無しさん:03/05/22 10:07
>>556
それは無理だな

558 :デフォルトの名無しさん:03/05/22 23:21
文法を自分で定義できる。


559 :デフォルトの名無しさん:03/05/22 23:49
>>559
Lispとかいうんだろ?

560 :デフォルトの名無しさん:03/05/23 00:32
>>559
Lisp とか言ってるね。自分で。

561 :デフォルトの名無しさん:03/05/23 01:01
Lisper は再帰好きだからな。

562 :デフォルトの名無しさん:03/05/23 01:17
再帰するのは神

563 :デフォルトの名無しさん:03/05/23 20:09
('A`)

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


565 :r:03/05/26 23:45
>>564
その問題に付いて語るベキことは多そうだ。
スレ立ててそっちで語るよろし。

566 :デフォルトの名無しさん:03/05/26 23:46
>>564
それだけじゃあ、簡単すぎるのでやはり
>>565に禿同

567 :デフォルトの名無しさん:03/05/27 00:00
正直、普通の日本語(標準語)でプログラムを書けるといいなぁと…

568 :デフォルトの名無しさん:03/05/27 00:05
夢にも思わない

569 :デフォルトの名無しさん:03/05/27 00:45
>>568
ワラタ

570 :デフォルトの名無しさん:03/05/27 01:11
>>564
2方向量子1カウンタオートマトンと
量子ウォークの話が混ざってるぞ。

571 :デフォルトの名無しさん:03/05/27 23:21
while(true)
{
  while(true);
  {
    //2階層一気に抜ける
    break(2);
  }
}

572 :デフォルトの名無しさん:03/05/28 00:33
>>571
どっちかのwhileがなくなった時点でbreakも修正が必要な罠。
しかも例の通りの2重ループならいいが、3重だったりしたら、
breakに気付かずに修正して不具合を引き起こす多重トラップ。
もうちょっと良く考えろたわけが。

573 :デフォルトの名無しさん:03/05/28 00:36
というわけでラベルつき break を採用すればいいわけだ。

574 :デフォルトの名無しさん:03/05/28 00:40
(call/cc
 (lambda(break)
  (while true
   (while true
    (break)))))

575 :デフォルトの名無しさん:03/05/28 00:46
つまりbreak自体がラベル

576 :デフォルトの名無しさん:03/05/28 00:49
> ラベルつき break
ダサっ


577 :デフォルトの名無しさん:03/05/28 00:53
ここはCしか知らないインターネットですね

578 :デフォルトの名無しさん:03/05/28 01:29
>>576
結構多くの言語に存在しますが何か。


579 :デフォルトの名無しさん:03/05/28 02:15
例えば?
2種類以上書いてくれ

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

581 :デフォルトの名無しさん:03/05/28 06:48
非決定性プログラミング言語なら
1982年発行の教科書にも解説載ってるけど
これとは別物でつか?


582 :デフォルトの名無しさん:03/05/28 10:04
>>571
Bourne shell

583 :山崎渉:03/05/28 12:29
     ∧_∧
ピュ.ー (  ^^ ) <これからも僕を応援して下さいね(^^)。
  =〔~∪ ̄ ̄〕
  = ◎――◎                      山崎渉

584 :名無し@沢村:03/05/28 16:02
をまいらよ、新しい文法を作ってみろ?

585 :デフォルトの名無しさん:03/05/28 16:04
◎ちょっと見て見て!!◎
http://yahooo.s2.x-beat.com/linkvp/linkvp.html

586 :578ではないが:03/05/28 17:04
>>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後の制御はここに移る

587 :デフォルトの名無しさん:03/05/28 17:41
頭悪そうな構文だね

588 :デフォルトの名無しさん:03/05/28 19:00
>>581
その教科書に載ってるほうの言語の概略キボンヌ。
いや漏れもパソコンgoogleが壊れてて....(←謎)

589 :デフォルトの名無しさん:03/05/28 20:55
Java にもあるだろ。>ラベルつき break

590 :デフォルトの名無しさん:03/05/28 21:11
ラベル付きbreakなんかイラネ


591 :デフォルトの名無しさん:03/05/28 22:43
ラベル付きgotoと何が違うんだ?(w


592 :デフォルトの名無しさん:03/05/28 22:59
ラベル付きgoto?
ラベルが付いてないgotoでもあるのか?

593 :デフォルトの名無しさん:03/05/28 23:04
>>592
昔のベーシックは行番号で指定していたよ

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

595 :デフォルトの名無しさん:03/05/28 23:16
ループを末尾再帰で書き直せば、条件分岐によるループ脱出は自明な形で現われる。

596 :デフォルトの名無しさん:03/05/29 00:27
>>595
内部定義やnamed-letみたいな構文がないとしんどい
returnを明示的に書かせる言語だとさらにもしんどい

597 :デフォルトの名無しさん:03/05/29 00:40
ラベル付きbreakがダメなら、

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

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

598 :597:03/05/29 00:42
イカンイカン、goto >>107;だった。
甚だ遺憾。

599 :デフォルトの名無しさん:03/05/29 00:44
>>597
returnで済む罠。

600 :デフォルトの名無しさん:03/05/29 00:57
>>599
そうなんだが、returnは関数で一個にしたいとか、whileの後にも処理したいとか
あるかな?って思ってサ。まぁ、基本的には要らん機能ではあるけどな(w

601 :デフォルトの名無しさん:03/05/29 01:03
>>596
もちろん、そのように適切な基本的構文が備わっていることが前提だけどね

602 :デフォルトの名無しさん:03/05/29 01:28
結局お前等のやってることは、関数型言語の再発明なわけだ。

603 :デフォルトの名無しさん:03/05/29 15:54
結局、全てはVBに帰すっていう結論か

604 :デフォルトの名無しさん:03/05/29 21:57
>>597

double break とかはいかが?

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

で、

break == break(1);


605 :デフォルトの名無しさん:03/05/29 22:46
>>604
それは>>572で欠陥が指摘されたヨ。

606 :デフォルトの名無しさん:03/05/29 23:53
おまいら、もっと他の言語を知れ
Cやその類似言語、Java、ましてや Delphi なんか使ってるとアホになるぞ

607 :デフォルトの名無しさん:03/05/30 06:56
おまいら、もっと他の言語を知れ
MLやその類似言語、Haskell、ましてや Lisp なんか使ってるとアホになるぞ

608 :デフォルトの名無しさん:03/05/30 23:45
斬新でもなんでもないが、

 if( 0<val<10 )

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

609 :デフォルトの名無しさん:03/05/31 02:38
>>608
(if (< 0 val 10)
 ...)

610 :デフォルトの名無しさん:03/05/31 03:33
>>608
Python だと書けるよ。

611 :デフォルトの名無しさん:03/05/31 09:28
if val in 0..10 {
}

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

612 :デフォルトの名無しさん:03/05/31 12:22
>>611
val が実数でも大丈夫なの?


613 :デフォルトの名無しさん:03/05/31 13:20
>>611
forじゃ無いの? どういう動作なの?

614 :デフォルトの名無しさん:03/06/01 00:50
>>611
ruby崩れ文法ですか?


615 :デフォルトの名無しさん:03/06/01 00:59
>>574
こういう例を見てると、改めて関数型言語の偉大さがわかるな。
柔軟性が高い。

616 :デフォルトの名無しさん:03/06/01 01:44
>>615
lisp (scheme) は関数型じゃないんだが

617 :デフォルトの名無しさん:03/06/01 01:57
>>616
たまに「関数型とは認めない」という人が現れるのは確かだけど、
一般的には関数型とされているよ。

618 :デフォルトの名無しさん:03/06/01 02:05
lisp が関数型か否かかはともかく、>>574 は関数型言語とは全く関係無いわけだが

619 :デフォルトの名無しさん:03/06/01 02:11
>>618
関数型言語の「特色」と関係があるかどうかはともかくとして、
Schemeが一般的に関数型とされていて、>>574はSchemeである以上、
関数型とは関係あるわけだが。

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

620 :デフォルトの名無しさん:03/06/01 02:26
>>619
> 手続き型では一般的に値とならないもの(ここでは継続)まで値となっている、
それは関数型/手続き型とは関係無いわけだが

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

621 :デフォルトの名無しさん:03/06/01 02:29
ここはひとつ、関数型言語のルーツということで。

622 :デフォルトの名無しさん:03/06/01 02:39
>>620
>それは関数型/手続き型とは関係無いわけだが

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

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

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

623 :デフォルトの名無しさん:03/06/01 02:43
>>622
あなたの脳内定義なぞに興味はありません

624 :デフォルトの名無しさん:03/06/01 02:45
whileもtail-recursionの構文糖だしね

625 :デフォルトの名無しさん:03/06/01 02:46
>>623
論理的に反論してください。
定義が違うといいたいなら、あなたの思う定義と比較して
何がどのように違うのか、なぜその定義が一般的だと思うのか
そうしたことを言うのが筋だろう。
そうでなければ有効な反論にならない。

626 :デフォルトの名無しさん:03/06/01 02:48
620=623
必死だな

627 :デフォルトの名無しさん:03/06/01 02:49
>>624
シンタックスシュガーで表そうとするのが手続き型の特徴だよな。
そうしたものは、同等のものが関数で表せるし、さらにその関数が
値として扱えるから、関数型は柔軟なのだと思う。

628 :デフォルトの名無しさん:03/06/01 03:02
>>627
なんか矛盾してないか?

629 :デフォルトの名無しさん:03/06/01 03:07
手続き型言語の無駄な構文が思考の阻害になっていると思われ。
このスレがクソ文法養成所になってる事実からもそれがわかる。


630 :デフォルトの名無しさん:03/06/01 03:24
>>625
端的にいうならば、「副作用」

631 :デフォルトの名無しさん:03/06/01 03:30
>>629
まあ関数型言語にも一応シンタックスシュガーはあるけどね。
関数で代用することが多いな。

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

632 :デフォルトの名無しさん:03/06/01 03:31
× Schemeは型に
○ Schemeは手続き型に

633 :デフォルトの名無しさん:03/06/01 03:38
まあ、一般的には

副作用が無いもの(Haskell等):純粋な関数型言語
副作用があるもの(Scheme等):純粋でない関数型言語

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

634 :デフォルトの名無しさん:03/06/01 03:39
>>574の本質は単なる long jump やん
なんで関数型とか手続き型とか出てくるわけ?

635 :デフォルトの名無しさん:03/06/01 03:44
>>634
1 継続を値として扱い、関数の引数にしている。
2 call/ccの引数が無名関数である。
3 以上の二つの関数型に近いと思われる特徴により、機能が実現されている
4 したがって1、2により柔軟性が高まっていると考えられる
5 関数型の特徴は有用である

636 :デフォルトの名無しさん:03/06/01 03:54
実は継続呼び出しもlambdaネストの構文糖なのだが

637 :デフォルトの名無しさん:03/06/01 03:54
>>633
Haskell はよく知らないけど、
流石に入出力はできるっしょ?
再代入がない、というべきでは。

638 :デフォルトの名無しさん:03/06/01 04:03
継続があれば関数型かいな?


639 :デフォルトの名無しさん:03/06/01 04:04
>>636
そうなのか。それは知らなかったな。
しかし、構文糖を使っていても、>>574の例が
関数型の特徴を使っていることにかわりはない
と思う。

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

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

640 :デフォルトの名無しさん:03/06/01 04:06
関数型言語スレ別館になりつつある様だな。

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

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

641 :デフォルトの名無しさん:03/06/01 04:07
>>638
多分、それはあまり関係ないだろう。
ただ、継続が関数の引数に渡されているところが
関数型っぽい。

642 :デフォルトの名無しさん:03/06/01 04:08
関数型は副作用を嫌うので代入を嫌うらしいけど、
継続を保持するのは代入や「状態」を持つ事にならんの?


643 :デフォルトの名無しさん:03/06/01 04:11
call/ccを使った継続の抽出と呼び出しは副作用に分類されない。


644 :デフォルトの名無しさん:03/06/01 04:13
継続は呼び出しても返ってこないから関数じゃないだろうに

645 :デフォルトの名無しさん:03/06/01 04:14
さらに言えば、状態を保持する事自体は副作用とは関係ない

646 :デフォルトの名無しさん:03/06/01 04:14
Haskelやcamlなんかも継続を持っているんですか?


647 :デフォルトの名無しさん:03/06/01 04:15
呼び出しても返ってこない、のなら継続は関数型の特徴じゃないじゃん。


648 :デフォルトの名無しさん:03/06/01 04:16
>>639
> ただ、下手に構文糖を乱用すると柔軟性が下がったり
> 仕様が肥大化する恐れがあるというだけだな。

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

649 :デフォルトの名無しさん:03/06/01 04:17
while も関数型じゃないよな

650 :デフォルトの名無しさん:03/06/01 04:18
>>640
そういう見方もあるね。

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

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

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

651 :デフォルトの名無しさん:03/06/01 04:21
>>648
いや、下手に乱用すると柔軟性がなくなったり、仕様が肥大化する。
今回のifやfor、switchなんかはその例。
おかげで、脱出が柔軟でなくなってるわけ。

652 :デフォルトの名無しさん:03/06/01 04:21
>>644
帰ってくるし、値もあるよ

653 :デフォルトの名無しさん:03/06/01 04:24
既に存在している仕様に構文糖を適用する→確かに柔軟性は失われない
言語仕様を関数でなく構文糖に頼る→下手にやると柔軟性が失われる恐れがある

654 :デフォルトの名無しさん:03/06/01 04:24
帰ってくる場所が違うって

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

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

655 :デフォルトの名無しさん:03/06/01 04:24
>>574は継続の特徴であって関数型の特徴ではないのでない?
純粋な関数型なら副作用がないから式があれば関数の実行順序によらず
結果は同じになるときいたけど。
でも継続は思いっきり実行の「手続き順序」を変える仕組みに見える。


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

657 :デフォルトの名無しさん:03/06/01 04:26
>>655
でも、継続が関数の引数に渡せなかったら、もしくは、
call/ccの引数が関数じゃなかったら、ああいう
実現の仕方には少なくともならないわけで、確かに
そういった関数型の特徴を使ってると思うよ。
関数型で無い特徴も使っているかもしれないけどね。


658 :デフォルトの名無しさん:03/06/01 04:27
>>655
状態の保持は副作用とは繋がらない

659 :デフォルトの名無しさん:03/06/01 04:29
>>656
だから、C言語のそうした特長は関数型に近いと思うよ。
手続き型と言われている言語にも関数型の特徴はあるし、
Schemeにも手続き型の特徴はある。
ほとんどの言語は手続き型的な特徴と関数型的な特徴が
混じってる。

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

660 :デフォルトの名無しさん:03/06/01 04:29
>>654
(break)は空リストが返る

661 :デフォルトの名無しさん:03/06/01 04:34
>>574を見て判る様に、
継続を関数の形として呼び出せる。
ゆえに関数型。

662 :デフォルトの名無しさん:03/06/01 04:35
くすくす

663 :デフォルトの名無しさん:03/06/01 04:38
アセンブリ言語は、
アドレスを関数の形として call できる。
ゆえに関数型。

664 :デフォルトの名無しさん:03/06/01 04:38
だってcall/ccのコンセプトってそうなんだもん

665 :デフォルトの名無しさん:03/06/01 04:39
つまり他の言語だとアセンブラまで降りないと不可能って事か。

666 :デフォルトの名無しさん:03/06/01 04:42
継続は厳密には関数ではない。
ただ、脱出プロシージャにパッケージ化されていて、
それは関数として扱える。
だから関数の形として呼べるし、値としても扱える。

667 :デフォルトの名無しさん:03/06/01 04:44
脱出プロシージャを使ってるところは関数型的と言っても
良いだろう。

668 :デフォルトの名無しさん:03/06/01 04:52
手続き型、関数型は同じ事象をどの観点で捉えるかの違いでしかない。
特にLispのように両者の特徴を兼ね備えた言語の場合は、どちらであるか、を議論することに意味はない。

669 :デフォルトの名無しさん:03/06/01 04:59
それよりは大きな違いがあると思うな。
関数型や手続き型という分類が今日まで生き残ってる
のは、この分類にそれなりに大きな使い出がある証拠だろう。

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

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

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

671 :デフォルトの名無しさん:03/06/01 05:14
継続一つで柔軟にいろんな機能が実現できるのはわかるが、
そのぶん、複雑怪奇なソースになりやすいという副作用はある。
かわりにシンタックスシュガーを追加する方法も、その副作用を
防ぐ意味では悪くないと思う。

672 :デフォルトの名無しさん:03/06/01 05:36
手続型言語と関数型言語ってのは対立概念ではなく、
別に両方の性質を持っていても構わないようなものだと思う。

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

副作用云々は確かに関数型にとって重要な話ではあるけど、
それは手続型言語か否かを測る目安であって、
関数型言語であるかを測る目安にはならないと思う。
だって、副作用云々は論理型言語にも重要だよ?

673 :デフォルトの名無しさん:03/06/01 05:44
目安とかじゃなく、副作用を消したい理由は他にあると思うんだが・・。

674 :デフォルトの名無しさん:03/06/01 05:45
>>672
> それは手続型言語か否かを測る目安であって、
> 関数型言語であるかを測る目安にはならないと思う。

逆でしょ
副作用があると function はありえずに procedure となってしまうが、
副作用がないと function でも procedure でも好きに呼ぶことができる。

675 :デフォルトの名無しさん:03/06/01 06:01
対立概念ではない、というのは言い過ぎたかも。
両方の性質を持ちうるけど、一方を追求すればもう一方は消えてくる、と。

関数型、という名前の持つ意味としては、
副作用よりも関数を動的に扱う事を強調してると思う。
もちろん、関数型である事を追求するためには
副作用は排除する方向に行くんだろうけど。

論理型言語も副作用はなるべく避けたいわけで、
副作用だけで関数型言語か否かを測ってたら、
論理型言語と関数型言語の区別が付かなくなる。

676 :デフォルトの名無しさん:03/06/01 09:23
>>635
> 1 継続を値として扱い、関数の引数にしている。
全然関数型固有の特徴じゃない。
どんな構文でも値を持つってのは、FORTHとかBoune shellでもいえる。

677 :デフォルトの名無しさん:03/06/01 10:42
Functional Programming の肝って、返り値が引数にのみ依存することだと思う。
副作用頼らずに組めるとか、そういう program 最適化するとかが、 FPL に要求される点、特微になる点だと思う。

関数呼び出しの形で記述すること自体は、手続き呼び出しの形と、あんまり区別つかなそうな気がする。

高階関数は重要だと思うけど、もう珍しい機能じゃないから、あんまり特微って感じがしない…

無名関数は、便利だし C とかにはないけど、むしろ動的にいろいろできる言語の特微な気がする。
perl でも無名手続き作ったりできるけど、あんまり関数型っぽくないし…

継続を副作用とかじゃなくて引数として渡してる、って点は関数型っぽいかな…
関数との interface は引数と返り値だけ、っていう点で。
継続を global variable に保持しとく…とかのやりかたも、手続き型なら選択肢の一つになりそうだし。

678 :デフォルトの名無しさん:03/06/01 11:23
なんか、えらく伸びてるが...

こういった、脂溶まっ節にうるさい奴で、いい言語書いた奴はいない。
問題は、論理的に綺麗かどうかではなく、マ達に使われるかどうかだ。


679 :デフォルトの名無しさん:03/06/01 12:57
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));
}


680 :デフォルトの名無しさん:03/06/01 13:13
int _;

for (;_;)//~~
{

}

681 :デフォルトの名無しさん:03/06/01 13:36
>>676
関数型言語以外で任意の継続が値(関数オブジェクト)で
表せるものがあったら教えて欲しい。

>>677
それは、関数型プログラミングの有効性の一つではあるけれども、
一般的には関数型言語にそこまで要求されているわけではない。
言語仕様として副作用を備えている言語でも関数型言語と
呼ばれているのは事実。
だから、もっとゆるい条件であるのは確実だと思う。
やはり、高階関数や、カリー化などといったものも総合して
どれだけ関数型的な機能を備えているかだろう。
関数型的とは、究極的には「関数が式を計算して値を返す」
ということだと思う。
こうした側面を持つ言語は手続き型にも多いけど、それは、
「関数型的な側面もあわせ持っている」というだけのことだ
と思う。
FORTHは良く知らないが、あなたの言っていることから推測すると
関数型に近い側面を少しは持つ言語と思われる。

682 :デフォルトの名無しさん:03/06/01 13:49
>>681
> >>676
> 関数型言語以外で任意の継続が値(関数オブジェクト)で
継続の話はしてない。

683 :デフォルトの名無しさん:03/06/01 13:52
>>682
>>635は継続がファーストクラスオブジェクトであるという
話をしている。
>>676が継続の話をしていないというのであれば、>>676
の反論は的外れだと思う。

684 :デフォルトの名無しさん:03/06/01 14:02
継続自体、関数型でなければならないってもんじゃないだろう。
Rubyにもあったぞ。

685 :デフォルトの名無しさん:03/06/01 14:10
>>684
Rubyは関数型の特徴を大幅に取り込んでる。
オブジェクト指向の特徴の方を強調したいから作者がオブジェクト
指向型と言ってるだけだろ。

第一、継続があれば関数型だという単純な話ではなくて、
継続がオブジェクトで、「関数が式を計算して値を返す」のプロセス
に取り込まれているところが関数型だという話だ。

686 :デフォルトの名無しさん:03/06/01 14:37
継続なんておもいっきし手続き型な概念やん。
gotoや、Cのsetjump/longjumpと本質は同じ。

インターフェースという表面的な部分だけ見て本質を考えずに
関数型に結び付けようとしているヒトがいるみたいだけど。

687 :デフォルトの名無しさん:03/06/01 14:58
>>686
つうか、手続き型と関数型の違いって、インターフェイス(
プログラミングスタイルや、表現の仕方)の違いだと思うが?
むしろ、この違いを語るとき、インターフェイスが本質であって
実現している機能は本質ではない。

インターフェイスは本質かどうかはおいておいても、
関数型チックとも言うべきインターフェイスによって、
柔軟性がもたらされているのは事実だろう。

688 :デフォルトの名無しさん:03/06/01 15:10
とりあえず SML/NJ の継続の型は関数ではない

689 :デフォルトの名無しさん:03/06/01 15:18
継続の概念は思いっきり関数型だと思うが。

690 :デフォルトの名無しさん:03/06/01 15:24
手続き型の最大の特徴は時系列とプログラムが一体成型だと言うことだと思う。プログラムの走行に関して時間軸が存在する(要するに上から順に実行していくのが基本になっている)のが手続き型の特徴と思う。
関数型の特徴はモノをいれると別のモノに変換する函を使ったプログラム、同じものを入れれば必ず同じものが出てくる、それ以外に機能が無いというのが特徴という普通の考え方が最もそれらしいと思う。
関数型等の非手続き型の言語は時系列が基本的に存在しない事(と思う)、少なくとも純粋に関数型を考えるならば、実行順所は決めるべきでないと思う、
当然手の込んだライブラリーを作ったりモナドとかで時系列を無理やり作り出さないと入出力等の時間的な順序が問題になる物が実現できない。
それが嫌なら、副作用を入れて妥協するしかないのだと思う。妥協しないとHaskellみたいになるんだと思う。
副作用等を持っていても、ポリシーが関数型でプログラムをしたいと考えて、その中での妥協なら
それは関数型言語といってもよいと思う。lispが関数型で無いという人はいないと思うし。


691 :デフォルトの名無しさん:03/06/01 15:27
>>690
(1+1)*2と1+1*2の答えが違うように、関数型にも実行順序はあるでしょう。

692 :デフォルトの名無しさん:03/06/01 15:28
>>691
実行順序どころか、それはすでに別の関数だとおもう。

693 :デフォルトの名無しさん:03/06/01 15:33
>>692
計算の実行の順番が違うから別の関数なんでしょう?

694 :デフォルトの名無しさん:03/06/01 15:35
>>693
ちょっと絶句しそうです(汗

695 :デフォルトの名無しさん:03/06/01 15:39
順番が必要な所もあるし、必要じゃない所もある。
1*2 + 2*3は +の左右の順番は必要じゃない。

696 :デフォルトの名無しさん:03/06/01 15:41
言語が関数型かどうかではなく、言語の個々の機能や、個々のプログラムが関数型かどうかを論ずべし

とりあえず、>>574 の while のところは関数型じゃないということでヨロシク

697 :デフォルトの名無しさん:03/06/01 15:44
じゃあ、継続は関数型ということでヨロシク

698 :デフォルトの名無しさん:03/06/01 15:46
ところで、whileのどの辺が関数型じゃないんだ?

699 :デフォルトの名無しさん:03/06/01 15:49
while が意味を持つためには副作用が要るから。

begin (progn) も関数型でない。

700 :デフォルトの名無しさん:03/06/01 15:54
>>699
Concurrent Cleanのwhileは関数型じゃないんだね?

701 :デフォルトの名無しさん:03/06/01 15:58
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 () }



702 :デフォルトの名無しさん:03/06/01 15:59
>>700

スマソ。知らネ。ref ぷりーづ。

703 :デフォルトの名無しさん:03/06/01 16:00
スマソ、スペースが消えた。

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 () }

704 :デフォルトの名無しさん:03/06/01 16:02
>>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)


705 :デフォルトの名無しさん:03/06/01 16:07
>>691
(5+6)*(7+8)

これについて
15=(7+8)
11=(5+6)
26=15+11
でも
11=(5+6)
15=(7+8)
26=15+11
でもかまわないと言うこと、整数ではなく印刷入りの関数をいれてみろ、結果が変わるのが手続き型、変わらないのが関数型。


706 :デフォルトの名無しさん:03/06/01 16:10
>>704 これなら関数型っす。

>>703 モナを使えば副作用も継続もなんもかんも表現できるので世界はすべて関数型ということで。
とりあえず関数型の定義まで戻ってその定義に従ってどうかというように論じないとなんとも。

707 :デフォルトの名無しさん:03/06/01 16:10
>>705
だから、その場合、11と15のどちらを先に計算するかの順番はいらないが、
15+11の前に11を計算しておかないと計算できないから、そうの順番は
いる。

708 :デフォルトの名無しさん:03/06/01 16:11
>>696
必死だな(w
whileは関数型

709 :デフォルトの名無しさん:03/06/01 16:12
>>696 >>708
>>574のwhileが関数型だろうが、そうでなかろうが、
話の本質には関係ないと思うが。

710 :デフォルトの名無しさん:03/06/01 16:13
>>707
例えば遅延評価で、11+15を使わないとしたら?
それは実行されないだろ。
無いんだよ。

711 :デフォルトの名無しさん:03/06/01 16:15
>>696
>>574には副作用は出てこないが。

712 :デフォルトの名無しさん:03/06/01 16:15
>>710
その時は順番は必要ないが、使うときは必要になる。
遅延評価は計算が必要になるまで計算しないというだけのことで、
計算が必要になる場合が存在する以上、順番は必要なんだよ。

713 :デフォルトの名無しさん:03/06/01 16:16
>>711
そのかわり while には意味がない

714 :デフォルトの名無しさん:03/06/01 16:19
574のwhileは例をわかりやすくするために便宜的に使ってるだけだろ。

715 :デフォルトの名無しさん:03/06/01 16:20
>>713 while に意味があるのは副作用だけでなく、大域脱出とかがある場合も微妙に意味がある。でもかなり微妙

716 :デフォルトの名無しさん:03/06/01 16:24
だから、574のwhileなんてどうでもいいだろ。
気に入らないんだったら末尾再帰にでも置き換えて考えろ。

717 :デフォルトの名無しさん:03/06/01 16:27
>>574のwhile(たぶんマクロ構文)は副作用を目的とする構文だよ。
schemeでスマートに繰り返しを書くなら、
named-letなどを使う。
あそこでwhileを使ったのは>>571に対する説明としてわかりやすく
記述した程度の意味しかないと思う。

718 :デフォルトの名無しさん:03/06/01 16:31
>>717
仮にあのwhileがschemeでmonadを巧妙にエミュレートして
作られたものだったら、副作用は無いと思うが、
後半は同意。
結局どうでもいい。

719 :デフォルトの名無しさん:03/06/01 16:34
モナドは関係なく(while trueの場合は副作用が出ないだろ。

720 :デフォルトの名無しさん:03/06/01 16:41
monadによって副作用なしにエミュレートされた副作用が、関数型には副作用がないというときの副作用を指すかどうか、それが問題だ。

721 :デフォルトの名無しさん:03/06/01 16:48
>>719 副作用が出ない結果、大域脱出がなければ無限ループになる。

722 :デフォルトの名無しさん:03/06/01 16:53
while は named let、つまり lambda で書けるんだが

723 :デフォルトの名無しさん:03/06/01 17:01
>>720
monadによって副作用なしにエミュレートされた副作用は、関数型には
副作用がないというときの副作用とは一致しないが、意味的な概念は
同じであろう。

724 :デフォルトの名無しさん:03/06/01 17:03
たとえ lambda で書けたって条件部分が参照透明性によりいつも同じ値を返したら無限ループか一回も実行されないかどっちかになっちゃうでしょ。

725 :デフォルトの名無しさん:03/06/01 17:23
>>721
大域脱出は副作用じゃないよ

726 :デフォルトの名無しさん:03/06/01 17:26
>>722 つまりこういうことなわけで
(define-macro (while test . body)
 (let ((loop (gensym))) ;hygienic symbol
  `(let ,loop ()
   (cond
    (,test ,@body (,loop))))))

727 :デフォルトの名無しさん:03/06/01 17:58
lambdaで書き直せるなら関数型かよ?
ならすべてのプログラム言語の機能は関数型の機能だな。


728 :デフォルトの名無しさん:03/06/01 18:09
>>727
つーか、昔Churchが既に形式化してるわけで

729 :デフォルトの名無しさん:03/06/01 18:13
チューリング等価だから関数型言語はチューリングマシンです、
というぐらいナンセンス。


730 :デフォルトの名無しさん:03/06/01 18:24
一晩でこんだけレスがつくってことは、みんな関数型言語に注目してるんですね

731 :デフォルトの名無しさん:03/06/01 18:37
>>730
注目はね。
実用上はどうだろう。
みんな使ってる?

732 :デフォルトの名無しさん:03/06/01 18:43
emacsな人は使っているかも。

ところで話題を変えて、

自作関数型スクリプト言語を作るとして、関数型プログラミングに必要な
最小限度の機能とはなんでしょうか?
教えて下さいです……。


733 :デフォルトの名無しさん:03/06/01 18:58
>>732
MLやSchemeみたいな正格言語なら、
レキシカルクロージャと末尾再帰のループ展開があれば
それっぽくなると思うよ。

734 :デフォルトの名無しさん:03/06/01 19:07
>>733
やっぱりクロージャと末尾再帰最適化は必要ですか。
‥‥‥‥だよな(´・ω・`)。


735 :デフォルトの名無しさん:03/06/01 19:46
>>574を関数型とは全く関係ないことにしたい奴必死だな。
最後はwhileにケチを付け出したか。(w

736 :デフォルトの名無しさん:03/06/02 05:31
>>681
関数型でいう「関数」って、 C とかの関数より、数学の関数に近いと思うけどな。
結果は引数にのみ依存する、っていう。

>>734
あと遅延評価が入ると、ぐっと関数型っぽくなりそうな気がする。

>>735
だって、あれって FPL の柔軟性っていうより、 Lisp や Scheme の柔軟性っぽいんだもん。

737 :デフォルトの名無しさん:03/06/02 08:58
>>736
確かに「純粋な」関数の定義はそうだが、その定義では
Schemeは関数型では無い。
しかし、実際はSchemeも関数型と呼ぶ。
まあ、君の脳内定義には興味ありません。(w

>>574の柔軟性の特徴は
継続 : Scheme、SML/NJ、Clean、(Ruby)
ラムダ抽象 : Scheme、Clean、Haskellほか多数

どちらもFPL的な特徴ですな。
他の関数型には無いSchemeやLispの柔軟性というと、
プログラムをデータのように扱ったものを思い浮か
べる。
(eval (list (car '(+ 1 2)) '1 '1))

738 :デフォルトの名無しさん:03/06/02 10:17
関数型言語ってのは数学的に純粋な関数をあつかうのに手厚い支援がある言語って
ことだと思うな。

関数型プログラムってのは数学的に純粋な関数だけで記述されたプログラムの
ことだと思うな。

だから、たとえ Scheme で書かれていても副作用を使っているプログラムを
関数型だと認めたくはないな。

そして、継続も while も数学的に純粋な関数ではないから、あのプログラムを
関数型だと認めたくはないな。

739 :デフォルトの名無しさん:03/06/02 10:25
要するに、参照透過性だの遅延評価は、便利な概念であり、
関数プログラミング的な概念でもあるが、「それがなければ
関数型言語と呼べない」というものでもないってことだな。

ある程度それに近ければ、すなわち、インターフェースが
似ているならば、関数型言語と呼んで構わない。
その周辺機能を関数型言語的な特徴と呼んで構わないって
ことだと思う。

740 :デフォルトの名無しさん:03/06/02 10:28
>>738
認めたくないのは君の勝手だけど、他人とコミニュケーション
を取る場合は一般的な呼び方に従おうや。

それから、継続もwhileも数学的に純粋だが。(w

741 :デフォルトの名無しさん:03/06/02 10:43
Java や Python が関数型ではない理由を教えてくれたまへ。

742 :デフォルトの名無しさん:03/06/02 10:45
他にもっと前面に出したい特徴があるから。

743 :デフォルトの名無しさん:03/06/02 10:50
Javaの場合は関数の呼び出しがメッセージの送信という
形になっているところなど、そうしたインターフェイスが
違うのが大きな原因かな。
おそらくラムダ抽象とかカリー化とかもないと思う。
pythonはlambdaがあったような気はするけど。

744 :デフォルトの名無しさん:03/06/02 10:54
Pythonは機能的には、現在では十分関数型の機能を
備えているかもしれないが、オブジェクト指向や
スクリプト言語であることのほうを強調したいようだ。
昔は違ったということで、歴史的な理由もあるかもしれない。

745 :デフォルトの名無しさん:03/06/02 11:34
「新次元新発想!新しい関数型の定義を作るスレ」
になってるな。
そういう議論はバッカスの論文くらい読んでからにしてほしい。

っていうかお前ら関数型言語スレに帰ってください。

746 :デフォルトの名無しさん:03/06/02 13:01
関数型とかラムダとかオブジェクト指向とかはどうでもいいので、新しい文法について語って下さい。

747 :r:03/06/02 13:03
>>746
ただなぁ...スレタイが
「ifをcaseにすると便利なことがあるよね。」
だからなぁ。

748 :デフォルトの名無しさん:03/06/02 17:50
>>745
このスレに関数型言語スレの住人なんていないと思われ。

749 :デフォルトの名無しさん:03/06/02 17:56
このスレで、新しい文法考えますた!
つっても欠陥だらけで終わってるからな。
実装して使ってから公開しろっての。

750 :デフォルトの名無しさん:03/06/02 19:07
>>739
インターフェイスの意味にもよると思うな、
C言語は文法は関数みたいな形をしているがあれを関数型とかいったらどうかね、
これは違うよなって気がしないか?

751 :745:03/06/02 20:00
>>748
part3の100あたりから活発に活動なさっていた1〜2人の素人が
こっちに移ってきたようです。
……。でもあっちに戻られるのはもっとイヤかも。

752 :デフォルトの名無しさん:03/06/02 21:53
Concurrent Clean のマニュアルをダウンロードしたんだけど、
継続が見当たりません。どこにのってるんでしょうか?

753 :デフォルトの名無しさん:03/06/02 23:19
俺は今は関数型言語スレにいないけど、Part1の頃にはいたよ。
しかし、Schemeが関数型言語ではないと言ってくる奴には困ったな。
自己満足なら世間とずれた定義でも結構だが、その定義で他人の使い方に
文句言うなよ。

>>745
別に、バッカスの論文なんか読まなくても、一般に関数型言語と
呼ばれている言語が関数型言語だよ。(w
そうならない定義は少数派の定義だから、議論で使うべきでない。

>>752
Cleanに継続は無いかもしれないね。>>737は俺の勘違い。スマソ。

monadは副作用を隔離しただけで無くなっていないと言ってる人、
関数型には順番が一切無いと言ってる人、継続があると関数型
ではないと言ってる人など、間違えてる人は結構いたな。
まあ一人か二人の同一人物だろうけどな。
昔、Haskellスレにもこういう人はいた。

754 :デフォルトの名無しさん:03/06/03 00:26
>別に、バッカスの論文なんか読まなくても、


読んでないんだ‥‥‥‥。


755 :デフォルトの名無しさん:03/06/03 00:27
>>753 Clean には継続はないですか。
non-strict な言語で継続がどう動くのか興味があったのですが、残念です。

non-strict な言語で継続がどう動くのかまったく想像できないんですが、
どなたかご存知ありませんか?

756 :デフォルトの名無しさん:03/06/03 00:38
まぁ、少なくとも関数肩がたいしたことないのがよく分かった


757 :デフォルトの名無しさん:03/06/03 00:39
>>756
これじゃ、流行らん和なぁ〜(関数肩


758 :753:03/06/03 00:57
>>754
読んでないよ。

>>755
継続というものをだいぶ誤解してるようだね。
たしか、「関数型プログラミング」という本では
Goferで継続がどう働くか解説していたはず。

759 :753:03/06/03 01:01
「プログラミング言語」だったかもしれない。
記憶があやふやでスマソ。

760 :デフォルトの名無しさん:03/06/03 02:35
>>753
脳内定義で話をしていることを自ら暴露してるYO

761 :753:03/06/03 04:17
そうだな。
「世間に従った定義」という'脳内定義'を使ってるのは確かだ。(w

他人と話をするときは、「世間に従った定義」を使わなくてはいけない。
例えば、世間で言う「手」を、脳内では「足」と定義している人がいたと
する。
「人間は普通、足で歩く」と言っている人に向かって「人間は普通、手で
歩いているぞ」と文句を言うのは的外れだ。
「Schemeは関数型言語じゃないぞ」と文句を言うのもその類。

762 :753:03/06/03 04:22
× 世間で言う「手」を、脳内では「足」
○ 世間で言う「足」を、脳内では「手」

763 :デフォルトの名無しさん:03/06/03 08:25
>>753
面白くないから帰っていいよ。スレ違い。

764 :デフォルトの名無しさん:03/06/03 22:22
数学の世界に何故「世間」なんてものが出てくるんだろう?

765 :デフォルトの名無しさん:03/06/03 22:35
「関数型プログラミング」という本は見つかりませんでした。
似た題名として、「関数プログラミング」だと、
手元に2種類(武市先生の翻訳と萩谷先生の)あったのですが、
継続についての記述は見当たりません。探し方が悪いのかもしれませんが。

「プログラミング言語」は手元になく、調べられませんでした。

Web に解説はないものでしょうか?

766 :デフォルトの名無しさん:03/06/03 23:55
>>764
数学の世界ではなく、国語の世界だから。

767 :デフォルトの名無しさん:03/06/04 00:38
あ、Web でなくて論文でもかまいません。
本になっているということはきっと元ネタの論文が
どこかにあるのだと思うのですが。

non-strict な言語における Scheme の call/cc のような継続について、
どなたかご存知でしたらご教示ください。

768 :デフォルトの名無しさん:03/06/04 01:42
いつからプログラム、特に関数型が国語になったんだろう?

769 :デフォルトの名無しさん:03/06/04 01:54
>>765
たぶんこの本じゃないの?

コンピュータ・サイエンス研究書シリーズ(17)
関数型プログラミング
PETER HENDERSON 著 杉藤芳雄・二木厚吉 訳
1985年 日本コンピュータ協会 出版

これの9章〜10章で継続使ってるみたいだけど。

770 :デフォルトの名無しさん:03/06/04 02:12
巻末の継続についての参考文献
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.

771 :753:03/06/04 02:39
>>765>>767>>769
「プログラミング言語 / 竹市正人」だったようだ。
goferはhaskellと非常に良く似ているので、読む価値はあると思う。

それから、monadによる実装でよければ
http://citeseer.nj.nec.com/wadler92comprehending.html
の7.4に書いてあるようだけど。
8.2にも例がある。

これは、見た感じ、ラムダ計算っぽいnon-strictな言語だと思うが
この論文は読んでないので、的外れなこと言っていたらスマソ。

772 :753:03/06/04 02:40
>>764
数学の話でも(数学の話をする時の)世間一般の意味に従わなくては
ならないと思うが。
プログラミングの話でも(プログラミングの話をする時の)世間一般の意味に
従うのが常識だが。

そもそも、世間一般の意味に従ったであろう発言に対して、
少数派の定義に基づいて反論したところで、意味がない。
どちらの意見も、定義を変えれば正しいという状態になるだけ。

773 :デフォルトの名無しさん:03/06/04 02:49
やねうらお辺りが喜びそうな話題だな

774 :デフォルトの名無しさん:03/06/04 03:05
>>771
monad による実装はその monad を使って記述された範囲内でしか使えないので
意図しているものとは違います。
monad をつかって副作用を実装しても本当は副作用が無いように、
monad をつかって継続を実装しても本当は継続ではないと理解しています。

私が意図しているのは、Scheme のようにいつでもどこでも使える
言語組み込みの本物の継続です。

Gofer というのはよく知らないのですが、
Haskell と違って言語に組み込みの継続があるのでしょうか?

あと、本のほうは手元に無いのですぐには参照できないのですが、
もし本に参考文献として論文があげられていたら教えていただけないでしょうか。

775 :デフォルトの名無しさん:03/06/04 03:09
関数肩の話題、すれ違い!
専門スレでしる!


776 :直リン:03/06/04 03:13
http://homepage.mac.com/yuuka20/

777 :デフォルトの名無しさん:03/06/04 03:13
>>774
schemeの継続呼び出し(call/cc)はCPSの構文糖

778 :デフォルトの名無しさん:03/06/04 03:25
>>777 え、そうだったんですか? それは知りませんでした。
マクロで定義できるのならぜひやり方を教えてください。


779 :デフォルトの名無しさん:03/06/04 03:33
>>778
継続についてはマクロみたいな局所的な変換じゃ無理。
継続適用部分全体をCPSへ置き換えないと。

780 :753:03/06/04 03:35
>>774
いや、goferを使って、継続を実装しているだけ。
goferやhaskellはIOに継続のスタイルが使われていると
聞いたことがあるけど、これもあなたの意図したものとは
違うかもしれない。
ただ、調べてみる価値はあるかも。

それから、
>monad をつかって副作用を実装しても本当は副作用が無いように、
>monad をつかって継続を実装しても本当は継続ではないと理解しています。

上の論文は確かにmonadを使って継続を実装しているけど、
non-strictな言語の継続を実装していれば、もちろん
問題無いと思う。
読んでないから、その辺どうだかはわから無いけど。

あと、多分勘違いしてると思うけど、
monadをつかって副作用を実装しているように、
継続をつかって制御を実装しているわけ。
non-strictな言語の場合でも評価順序はあるわけで、
理屈としては継続があることになる。

781 :デフォルトの名無しさん:03/06/04 03:43
>>780

gofer にも組み込みの継続はありませんか。残念です。

non-strict な言語の継続を実装していればというのですが、
その non-strict な言語の継続というもの自体を知りたいので、
monad ではなくて言語自体に入っているものが知りたいのです。
論文を読んでもそれが non-strict な言語の継続かどうか
わからないかもしれないですし。

理屈としては継続があるというのはそうかもしれないのですが、
私には想像できないので具体的な実装例を見たいのです。
Clean も Haskell も gofer もないということですが、
そういうものは存在しないのでしょうか?

782 :753:03/06/04 03:51
>>781
今検索したら、
http://www.namikilab.tuat.ac.jp/~sasada/prog/rucheme.html
これが、その実装らしい。
4/30の日記に遅延評価にしたとの記述があるので。

783 :デフォルトの名無しさん:03/06/04 04:13
>>782
ttp://www.namikilab.tuat.ac.jp/~sasada/prog/rucheme003.lzh
というのをダウンロードしたのですが、遅延評価は入っていないようです。

あと、ドキュメントの continuation のところに
「できないかもしれません」と書いてあってぜんぜん信用できないのですが。


784 :753:03/06/04 04:17
>>783
>遅延評価は入っていないようです。

ほんとに?何で断言できるの?
ていうか、4/30の日記をちゃんと見た?

まあ、Schemeはdelayとforceで遅延評価実現できるので、
全ての関数にdelayとforceが使われているSchemeを想像すれば
なんとなくわかるのではないかと思う。

785 :デフォルトの名無しさん:03/06/04 04:23
ダウンロードした中のファイルのタイムスタンプを見たら、
一番新しいものでも 3月21日だったので。

786 :デフォルトの名無しさん:03/06/04 04:48
日本一の弟

787 :デフォルトの名無しさん:03/06/04 08:18
なんでスレ違いを続けるの? 専用スレでやればいいじゃん。

788 :デフォルトの名無しさん:03/06/04 17:37
つーかスレ違いじゃなかったらこんな伸びないと思われ。

789 :デフォルトの名無しさん:03/06/04 17:55
スレ違いだろ。馬鹿が勝手にワメいてるだけ。

790 :デフォルトの名無しさん:03/06/04 18:22
やけにむきになってスレ違いとワメいているのは人はひょっとしてC#死滅スレの「関数型からオブジェクト指向に移行する訳だから」の人?
大変だね頑張ってね(藁

791 :デフォルトの名無しさん:03/06/04 20:55
non-strict な純粋関数型言語に継続プリミティブがいれられるなら
これはけっこう新しいと思うので、スレ違いというのはご容赦ください。

もし、そんなのはぜんぜん新しくないという方がいらっしゃいましたら、
ぜひ文献や実装を教えていただけるようお願いします。

792 :デフォルトの名無しさん:03/06/04 21:13
>>780 だんだん疑問がはっきりしてきました。

評価順序というのは簡約戦略によって決まるわけですが、
たとえば、strict な言語ならだいたい最左最内戦略で、
これは内側から正規形にしていくわけです。
そうすると、ある時点の継続は処理が終わっていない外側の部分だと
いうのは納得できます。

でも、最左戦略で non-strict とすると、だいたい外側から試していくわけで、
継続という処理が終わっていない部分は内側のように思えますが、
そうなんでしょうか?

また、Scheme で継続を呼び出すときは値をひとつ渡すわけですが、
上記のように内側の部分を継続とすると、
継続を呼び出したときに与える値はどこにはまるんでしょうか?

Clean の簡約戦略は関数型簡約戦略だそうですが、これだとどうなんでしょう?
また、仮にランダムに redex を選ぶような戦略を想定するとどうなるんでしょう?


793 :デフォルトの名無しさん:03/06/04 21:32
また、継続を呼び出したときの動作にも疑問があります。
(仮に 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 のように、
合流性や参照透明性が保たれるようになるんでしょうか?

794 :753:03/06/05 06:43
>>785 >>792-793
http://pc2.2ch.net/test/read.cgi/tech/1047970129/317-318
こっちで答えておいた。

795 :753:03/06/05 06:50
794のリンクは間違いなので訂正。

関数型言語Part3
http://pc2.2ch.net/test/read.cgi/tech/1037527388/317-318

796 :デフォルトの名無しさん:03/06/05 09:35
> non-strict な純粋関数型言語に継続プリミティブがいれられるなら
> これはけっこう新しいと思うので、スレ違いというのはご容赦ください。
新しいと思うけど、文法じゃないんだけど。スレ違いだと分かってるんだったら
関数型言語のスレに帰ってください。ネタスレなのに…。

お帰りはこちら http://pc2.2ch.net/test/read.cgi/tech/1037527388/

なんで関数型言語使う人ってウンチク好きなの?場違いな場所でやるのウザイ。


797 :デフォルトの名無しさん:03/06/05 15:08
ときどき欲しいもの
関係演算子の数珠つなぎ a <= b < c == d

798 :デフォルトの名無しさん:03/06/05 16:19
>>797
激しくガイシュツ。

799 :デフォルトの名無しさん:03/06/05 16:34
>>797
>>608

800 :デフォルトの名無しさん:03/06/05 18:15
>>609

801 :デフォルトの名無しさん:03/06/05 18:18
>>796
>>574から関数型言語スレになりました

802 :デフォルトの名無しさん:03/06/05 22:12
>>800
でも、 >>609 だと < と == みたいな、別の演算子の混在はできないよね。
こういうのも簡潔に書けたら便利かも。

803 :デフォルトの名無しさん:03/06/05 23:25
>>802
>>610

$ python -c 'if 1<2<2: print("yes")'; python -c 'if 1<2<=2: print("YES")';
YES
$

804 :デフォルトの名無しさん:03/06/05 23:49
>>796
頭悪そう。

805 :デフォルトの名無しさん:03/06/06 00:57
>>802
なんか、こう、自然と顔がニヤけてくるような面白さ

806 :デフォルトの名無しさん:03/06/06 01:40
ああ、こんなとこに誤爆してたのか

807 :デフォルトの名無しさん:03/06/06 20:13
>>797
記述がすっきりするというのはいい事だよね。
C の bool の式として簡潔かつあいまいさや矛盾なく綺麗に拡張できる方法はないもんですかね。
そこのところだけ文法を変えるというのをやっみたが、あんまり気持ちよくないので・・・
ちなみにこんな感じ
bool flag = bool_exp{ {a} < {b} == {c} } ;
bool_expの中では < その他は区切り文字として取り扱い。
が、しかし中に式が入らなくて、苦肉の策はものすごくかっこ悪い。
考えれば考えるほど自分用のトランスレータに入れたくなってきた。

808 :デフォルトの名無しさん:03/06/06 21:23
>>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)))

809 :デフォルトの名無しさん:03/06/06 21:25
って、よく見たらこれじゃダミだ

810 :デフォルトの名無しさん:03/06/06 21:55
(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)

811 :810:03/06/06 21:57
4行目の : は ? の間違いでス

812 :デフォルトの名無しさん:03/06/06 23:14
2回評価される部分が出るね
副作用無ければ問題無いけど

813 :デフォルトの名無しさん:03/06/06 23:18
副作用のある言語はカス。


814 :デフォルトの名無しさん:03/06/06 23:46
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);
}


815 :デフォルトの名無しさん:03/06/06 23:47

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);
}

816 :デフォルトの名無しさん:03/06/06 23:48
#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;
}
}

まだショートサーキットを組み込んでないけど、とりあえず。

817 :デフォルトの名無しさん:03/06/06 23:51
あ、間違えてた。res の結果を継承しないといけない。
そして、それでショートサーキットも解決、と。
true の時だけ比較すればいい。

818 :デフォルトの名無しさん:03/06/07 13:37
>>803
python にはあったんだ…知らなかった。

>>810
あ、それいい…
中置記法そのまま持ってきちゃえばよかったんだね。

819 :デフォルトの名無しさん:03/06/07 18:36
>>814-817
結構いい線いけますね、それでも最初の型変換と計算中だけ型違いというのはなんとも気持ちが悪い、
テンプレートだけだとこの辺が限界かとは思うけど、新規の文法導入でもうちょっとなんとかならないかな。


820 :デフォルトの名無しさん:03/06/07 19:25
>>819
>>810で解決済

821 :デフォルトの名無しさん:03/06/07 20:33
>>820
あっ、私は807=919です。
C の演算子ベースで矛盾や混乱の起こりにくい記述を追及したいです。
型での記述だと、今何型になっているのかを常に意識する必要があって結構混乱の元になる。
新規文法にしても単純に < == > 等ではさむと優先順位が変になったり、
そこだけが極端に風変わりな文法になるのを防いだ書き方を追求したいです。


822 :デフォルトの名無しさん:03/06/07 20:41
場当たり的な印象はするけれどもシンプルに
==. !=. <. >. <=. >=.
といった演算子を低めの優先順位で新規に設けるとか・・・


823 :デフォルトの名無しさん:03/06/07 20:44
>>822
演算子の打ち間違いの問題が発生しそうなヨカン。

824 :デフォルトの名無しさん:03/06/07 20:49
>>810
これ、マクロにする必要はないんでない?
=、 <、 <=、 >= も関数だし

825 :817:03/06/08 00:29
(<, <=), (>, >=), (==, !=) でそれぞれ別のクラスにすれば綺麗になるね。
いろいろ改造したけど、ここに載せるには長いし、
実のところスレ違いなので載せるのはやめとくけど。

826 :821:03/06/08 10:25
あんまりスレ違いを意識しすぎるのもどうかなと思うんですが・・・
糖衣にするのか、新規に作るのか、
例えばオーバーロードするときに新規に作った文法なら、これのオーバーロードはかなり頭が痛いです。
比較演算子を関数と考えて、比較要素オブジェクトと関数オブジェクトをリストにしてコンテナにいれて引き渡してみようかとか、
少なくとも僕は参考になることが多いから、スレ違いだと激しく言っている上にいる誰かの方がよっぽどウザイと感じるのは僕だけですかね。

827 :817:03/06/08 23:54
>>826
>>814-816(の改善版)で比較演算子のオーバーロードが自由なように、
そんなに難しいことでもないと思いますよ。

828 :デフォルトの名無しさん:03/06/09 00:07
やっぱりC++は不自由な言語なんですね

829 :デフォルトの名無しさん:03/06/09 00:08
自由すぎるのも困る場合があるがな。

830 :デフォルトの名無しさん:03/06/09 01:18
それは詭弁だね

831 :デフォルトの名無しさん:03/06/09 01:23
>>830
多重継承のことだと言えば
貴方は嬉々として賛同するだろう。

832 :デフォルトの名無しさん:03/06/09 02:05
あっても、必要なければ使わなければよいので困らない
無いと、必要なときに使えなくて困る

833 :デフォルトの名無しさん:03/06/09 04:05
>>832
間違った使い方をしてはまるアフォ共のために、そんな自由はいらんと言うとる言語もあるが。
でも面白さが足りんよな、そういうのは。

834 :デフォルトの名無しさん:03/06/09 22:13
大は小を兼ねるというやつですな

835 :デフォルトの名無しさん:03/06/10 02:20
面白さが足りんが、この世にはアフォの方が多い罠。

836 :デフォルトの名無しさん:03/06/12 12:55
優先順位付演算子
a +{0} b *{2} c /{3} d -{1} e
-> ( a + b ) * c / ( d - e )


837 :789:03/06/12 14:41
>>836
優先順位を指定できるのに結合性を指定できないのは
片手落ち。あとHaskellだと演算子ごとの指定はできるな。

 infixr 5 ++ -- 右結合で優先順位5

こんな感じで。

しかしどっちにしてもいいアイデアだとは思わない。そもそも
「括弧を使う」という万能の優先順位変更策があるわけだから、
最低でもそれより読みやすくないとだめだろ。

838 :デフォルトの名無しさん:03/06/12 20:42
Prolog でも演算子を自由に定義できて、
優先順位も決めれるぞ。

839 :デフォルトの名無しさん:03/06/12 21:26
S式でいいじゃん

840 :デフォルトの名無しさん:03/06/13 00:51
あるいは逆ポーランド記法

841 :デフォルトの名無しさん:03/06/14 00:41
S式と逆ポーランド記法は違うぞ

842 :デフォルトの名無しさん:03/06/14 01:13
>>841
おまいは「あるいは」の意味を知らんのか?

843 :デフォルトの名無しさん:03/06/19 23:14

新しい文法考えました

>>1

で行番号1へ飛びます

844 :デフォルトの名無しさん:03/06/19 23:59
ガイシュツだと思うけど
text=RED;
back=BLUE;
colors[]={ BLACK, WHITE, … };
if((text,back)⊂colors){ … } // text及びbackがcolorsに含まれるなら

845 :デフォルトの名無しさん:03/06/20 04:06
変換が大変そうだ


846 :デフォルトの名無しさん:03/06/20 05:02
オートマトンの絵でそのまま機械つくってくれるやつが欲しいな。
prologみたいなのじゃなくて、Push-downもいけるようなやつ。
場当たり的な適当なコードを書くのの変わりに。


847 :デフォルトの名無しさん:03/06/21 11:57
いつも思うのですが、「書き方とプログラムを分離する」ことができれば非常に
綺麗かつ便利になりそうな気がしています。

if((text,back)⊂colors){ … } なのですが、
とりわけ数学でよく考えられた記号は、そのまま持ってきたいが
実際には、そうは行かない
例えば行列計算で
D = A + B * C
とかする場合、OO系言語の場合
D.add( A , B.clone().mul( C ) ) ;
といったことにといった感じになりかねないもので、読みにくいこと極まりないです。
一部の人はこのほうが統一があって読みやすいなんていっていますが、あれは頭が変(←少し煽り)
統一されていることは正しいとは思うのですが(こうすることによる拡張性その他は捨てられない)

  統一されている≠読みやすい

とも思うんですよね。
最近C#をやり始めて「同じ事をするのにやり方が複数個あるのは良くない」はウソだと感じる。
あくまで「統一されている」は拡張性の確保や読みやすさの確保のための手段であって目的ではないと思う。

基本的に糖衣構文を記述する構文のような物という事になるでしょうけれど、
template その他で進化した考え方で諸悪の根源とされていたプリプロセッサを再度見直したらもっと良いものになりそうな気がする。
さらに「書き方とプログラムを分離する」を一般化して考えれば、「オートマトンの絵でそのまま機械つくってくれるやつ」といった、
プリプロセッサの変換元がテキストである必要性も無いような気もします。


848 :デフォルトの名無しさん:03/06/21 12:19
「書き方とプログラムを分離する」すると言うことの極端な例

テキストを二次元的に取り扱う

このプログラムは func1 → func2 → .. func4 → func5 .. func7 → return
と処理が進む
void proc()
{
  func1() ;    %% label1:
  func2() ;    %% func5() ;
  func3() ;    %% func6() ;
  func4() ;    %% func7() ;
  goto label1 ;  %% return ;
}

このプログラム自体には意味はないのですが、たとえば処理が対になっている処理などでは、
ミスを減らす有力な手段として使えたりとかしないかなと思っています。


849 :デフォルトの名無しさん:03/06/21 12:34
要するにフローチャートとかUMLとかなんでは。

850 :デフォルトの名無しさん:03/06/21 13:18
>>847
C# やってんなら、演算子のオーバーロードで
行列計算は D = A + B * C; って書けるっしょ?
まぁ、実行効率に目をつぶればね。

シンタックスシュガーを記述する構文は色んな言語に色んなものがある。
数学的な記法ということに関しては Haskell はなかなかすごい。
有名な Haskell のクイックソートプログラムを見れ。
ttp://www.teu.ac.jp/nsit/~tomoya/Prog/haskellq.html

851 :デフォルトの名無しさん:03/06/21 13:41
>>850
一応知ってます、しかし今まである物のは全部場当たりなんですよね。
○○の記述方法で凄いのなら××言語って感じになってしまいます。
そうではなくて、一般的な方法が欲しいなと思ってます。

852 :デフォルトの名無しさん:03/06/21 14:24
それは何も新しくないんじゃないかな。
新しい文法は別途考えないといけないわけで。

853 :デフォルトの名無しさん:03/06/21 17:26
おまえらがアホなこと言ってる間に
おれは一仕事終わらせてきた。

854 :デフォルトの名無しさん:03/06/21 23:29
>>851
あなたが知らないだけで、そんな言語は山ほどある

855 :デフォルトの名無しさん:03/06/22 10:50
>>854
すみません、それを教えていただけますか?
少なくとも自分は今だに見たことがないです。

856 :デフォルトの名無しさん:03/07/09 17:54
#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){...}

禿しく下らんな、鬱。

857 :山崎 渉:03/07/15 10:45

 __∧_∧_
 |(  ^^ )| <寝るぽ(^^)
 |\⌒⌒⌒\
 \ |⌒⌒⌒~|         山崎渉
   ~ ̄ ̄ ̄ ̄

858 :山崎 渉:03/07/15 14:03

 __∧_∧_
 |(  ^^ )| <寝るぽ(^^)
 |\⌒⌒⌒\
 \ |⌒⌒⌒~|         山崎渉
   ~ ̄ ̄ ̄ ̄

859 :デフォルトの名無しさん:03/07/15 18:16
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))))

860 :デフォルトの名無しさん:03/07/16 21:10
LISP scheme 向けの埋め込み構文 #n<num>
書式 #n <num> [<sexpr> ...]
<num>で指定した回数だけ後続のS式を読み込み、
1つのリストとみなす。

;#nで記述したアッカーマン
#n3 define #n3 ack m n
 #n4 if #n2 zero? m
  #n3 + n 1
  #n4 if #n2 zero? n
   #n3 ack #n3 - m 1 1
   #n3 ack #n3 - m 1 #n3 ack m #n3 - n 1

;↓と等価
(define (ack m n)
 (if (zero? m) (+ n 1)
  (if (zero? n) (ack (- m 1) 1)
   (ack (- m 1) (ack m (- n 1))))))

#n3 ack 3 8
=>2045

見ての通り、括弧が全く無い。
そのかわり、アンカーを頭に書く必要がある。

・・・どうかなあ?

861 :デフォルトの名無しさん:03/07/16 21:34
すげー分かりづらい。その状態でどうやってS式を数えるんだよ。

862 :デフォルトの名無しさん:03/07/16 22:01
>>861
うーん… python 風?
indent を固定しちゃえば、慣れれば読めそうだけど…
でも、 >>861 に同意。
内包できる Sexp の数を前置すると、最初に書くのもちょっと大変だし、
変更するときとかも複雑になりそう。
数字がずれるとわかりにくい bug になるだろうし。

863 :デフォルトの名無しさん:03/07/16 22:10
>861
考え方は非常に原始的です。
最初に個数を置く関係上、
使う段階で数え終わっている必要があります。
まあ、>>860は極端な例です。

#n〜も1つのS式なので、
#n自身も>>860の様にネストできます。
例えば固定長のテーブルを書く場合に

>#n3 define data '
#n4 ; y
#n3 a b c ;x
#n3 d e f
#n3 g h i
#n3 j k l
=>data

>data
=>((a b c) (d e f) (g h i) (j k l))
というわけです。
メリットは、
括弧の閉じ忘れを気にしなくてよい、とか。
あと、リストの長さを限定したいときに
読み込み時チェックが掛かる。

864 :デフォルトの名無しさん:03/07/16 22:12
>>862
ちなみにインデントは関係ないです。
#n3 define #n3 ack m n #n4 if #n2 zero? m #n3 + n 1
#n4 if #n2 zero? n #n3 ack #n3 - m 1 1 #n3 ack #n3 - m 1 #n3 ack m #n3 - n 1
これでもちゃんとパースされます。
慣れると1行野郎が楽に書けるかも・・。

865 :デフォルトの名無しさん:03/07/16 22:14
全部に対して無理に使う必要もないので、
好きなところで長さ制限したい場合にでも使えそうです。
(そういう局面は少ないですが。)

#3 define data '
#n4
(a b c)
(d e f)
(g h i)
(j k l)
(m n o) ;←エラー


866 :デフォルトの名無しさん:03/07/16 22:24
この拡張のソース

(define (fetch-sharp-nlist)
#let1 num (read)
(if (number? num) 'ok (error "Syntax Error : expect nuber. #n<num> [<sexpr> ...] ==>" num))
#let loop ((r '()) (n num))
(if (zero? n) (apply list (reverse r))
#let1 s (read)
(if (eof-object? s) (error "unterminated #n " num " " (reverse r)) 'ok)
(loop (cons s r) (- n 1))))

このfetch-sharp-nlistを#のディスパッチ関数から呼び出す。
readが再帰的に#フックを呼び出す仕様でないと使えません。

次の様にするとテストできます。
(fetch-sharp-nlist)3 define data '
(fetch-sharp-nlist)4
(a b c)
(d e f)
(g h i)
(j k l)

867 :デフォルトの名無しさん:03/07/16 23:18
ぶっちゃけ多量の括弧のほうがはるかによみやすい。

868 :デフォルトの名無しさん:03/07/16 23:38
わかりますわかります

869 :デフォルトの名無しさん:03/07/16 23:51
こういう気分転換ができるところも、LISPの良い所。

870 :デフォルトの名無しさん:03/07/17 00:16
>>860
数を数えるなんていう機械がやるべき単純作業を何故人間様がわざわざやらにゃならんのか

871 :デフォルトの名無しさん:03/07/17 00:40
>>870
ソース見る限り<num>自体もS式だから、計算で求める事もできるよ。


なんつったりして。

872 :デフォルトの名無しさん:03/07/17 03:19
>>871
そうだよ、リストの終りが分かるようになんかおきゃいいんだよ。




…閉じカッコとかどうよ?

873 :デフォルトの名無しさん:03/07/17 05:19
整数型・ポイント型・実数型等と比較できるBOOL型配列を作って、
さらに、関数によって異なるBOOL型を扱えるのって、どう?

int foo::bar(void)::BOOL FALSE[]={-1,0}
/* or TRUE[]={1} 等々TRUEかFALSEのどちらかを指定でき、配列は返り値と同じ型 */
{ … /* 関数の定義 */ }

使い方は

foo a,b ;
int i ;
if ( a.bar() == FALSE ) … /* 返り値が、-1か0ならば */ ;
i = b.bar() ;
if ( i == b::bar()::TRUE /* foo::bar()::TRUE 等も可 */ ) … /* iが -1及び0でなければ */ ;

874 :デフォルトの名無しさん:03/07/17 08:19
何が嬉しいのかサッパリ

875 :名無し@沢森:03/07/17 10:42
しょうがないな、おまいらよ。
俺が新文法を提示してやるよ。

・再帰用デフォルト引数
再帰関数でしか使えないデフォルト引数で、
外からはそのデフォルト引数しか使えず、
再帰呼び出しの時のみそれ以外の引数を指定できる。

例)
let pow x n (res := 1) =
 if n = 0 then
  res
 else
  pow x (n - 1) (res * x);; (* OK *)
pow 4 2;; (* OK *)
pow 4 2 5;; (* Irregal! *)

どうよ?

876 :名無し@沢森:03/07/17 10:43
sage ちまったよ。おい。

877 :デフォルトの名無しさん:03/07/17 11:52
illegal 不法な、違法な
irregal リーガル(TM)でない

878 :名無し@沢森:03/07/17 11:59
すまんよ。

879 :磯斡葦胃飲斡:03/07/17 16:48
磯斡葦胃飲斡

880 :デフォルトの名無しさん:03/07/17 19:38
>>875
再帰用関数が外から見えなきゃそれで済むやん

881 :デフォルトの名無しさん:03/07/18 00:07
>>871
その場合はnumをevalに掛けないとS式そのものが渡される気がする

882 :デフォルトの名無しさん:03/07/18 00:14
>>872
ソレダ (・∀・)

883 :デフォルトの名無しさん:03/07/18 00:37
>>859
#letは良い気がする。
一時変数作るだけで括弧のネストいるのは正直めんどいので。

884 :名無し@沢森:03/07/18 01:52
>>880
ヌヒよ。
いちいちインタフェイス関数と再帰用関数と
2つの関数を作るのは二度手間だと思わないのか?

あと、型に厳密な Objective Caml を例にしたのはまずかったやもしれんが、
再帰呼び出しだと引数を必ず指定することにすれば型推論できるな。

885 :デフォルトの名無しさん:03/07/18 02:20
>>884
> いちいちインタフェイス関数と再帰用関数と
> 2つの関数を作るのは二度手間だと思わないのか?
いいえ

例えば named let とか

886 :山崎 渉:03/08/02 02:35
(^^)

887 :山崎 渉:03/08/15 17:10
    (⌒V⌒)
   │ ^ ^ │<これからも僕を応援して下さいね(^^)。
  ⊂|    |つ
   (_)(_)                      山崎パン

219 KB
■ このスレッドは過去ログ倉庫に格納されています

★スマホ版★ 掲示板に戻る 全部 前100 次100 最新50

read.cgi ver 05.04.00 2017/10/04 Walang Kapalit ★
FOX ★ DSO(Dynamic Shared Object)