Ｃ式（Ｃ言語風汎用データ形式）を作ろう！

LispのＳ式のようなプログラムから扱いやすい、
Ｃ言語風な構文を持つデータ形式を考えています。
LispのＭ式の一種を考えるといっても良いと思います。
一人で考えていてわけがわからなくなっているので、
話し聞いてやってください。
例)
S式 (a (b (+ c d)))
C式 a[b[c+d]]]

2GETTTTTTTTTT

まったく扱いやすそうにないとこにﾜﾛﾀ

とりあえず、このデータ形式を考えるにいたった経緯を書きます。
�@言語にいろいろ追加したいと思う。
�AJavaのEPPを見つけすげ−思う。
�BＳ式は凄いけど、見難いと思う。
�CＤ言語に期待してみるけど、作るのは俺ではない。
�DNemerleマクロは凄いけど、俺がNemerleを作れるわけではない。
�EＣ言語風のデータ形式を作ってＳ式のパーサ＋αくらいでパース出来るようにしてしまえ！
っていう経緯があります。

JSON 風にしたら良いんじゃないの。C から #include 出来ればパーサ要らず。

JSONかぁ。数値、文字列、アイデンティファイア、連想配列ですよねぇ。
:が名前を表す２項演算子として考えるのかなぁ？
プログラミング言語として使うとなると、
main:[
printf:["hello wolrd"],
printf:["\n"]
]
って書くとかになると、これは連想配列ではないし、ムムムです。
[main,
[printf, "hello world\n"],
[printf, "\n"]
]
って書くなら、Ｓ式のほうがいいよってなるし。
うーむ。

あ、間違えた。
>>3
まぁ、普通のプログラマには扱い方難しそうにみえるでしょうね。
まだ、簡単に扱えないものを簡単に扱えるようにしようとしてるので、
当然の感想ですね。

dbm

>>6
それじゃ関数定義と関数適用（＝呼出）の区別がつかないじゃん。

つーか何がしたいのかわからん。
データ形式が、プログラムを表現することもできる、ってのを考えてるの？
だったらlambdaさえあればいいわけだから、あとはC言語風に書くなら、S式の
(a b c d)
を
a (b, c, d);
って書けば終わりじゃないの？

BoostPP

Lispを使いたいならそれがどこにあるのか（ｒｙ

>>1
() を [] に変えてるだけジャン。

お、無能のＳ井さん、2chでスレ立て→即逃亡ですか。
こんな屑レベルで迷ってるなんて貴方らしいｗ

>>9
ああ、そうか、まちがえました。
define:[main:[],
printf:["hello world\n"]
]
とかにしないとねぇ。

やりたいことは、
�@プログラミング言語として使える。
�Aプログラムで操作できる。
�BＣ言語風の構文をもっている。
�C演算子を優先順位付きで定義して使える。
といった汎用のデータ形式を理論的に作り出して、
それを使って、LISPライクな言語を作りたい。

a(b,c,d);
と書くのはよいのだけど、なぜ、カンマやセミコロンが必要になるのか？
明確にしておきたい。

>>10
BoostPPのデータ構造として
tuple (elem0,elem1,...,elemN-1)
array (N, (elem0,elem1,...,elemN-1))
seq (elem0)(elem1)(elem2)...(elemN-1)
list (elem0, (elem1, (elem2, (..., (elemN-1, BOOST_PP_NIL)))))
ってのがあると。へぇ。

>>11
MLispとかみたいなもんのプリプロセッサは作ってみてます。

>>12
()ではなくて、[]とかいてるのは単にＳ式と対比して書くのに[]を使っただけです。
(),[],{}等のカッコが使える言語を作りたいと考えています。

> S式 (a (b (+ c d)))
> C式 a[b[c+d]]]

C 式のほうの括弧の対応が・・・ S 式でも (a $ b $ + c d) とか
書ければいいって話じゃねーの？非S式でぐぐったらこんなんみつかった
ttp://lispuser.net/memo/lisp/2006-03-30-23-58.html

ぐぐるしか能がないのか
俺は自分で作ったぞ

冗談はObjective-Cだけにしろ

>>18
Appleの中の人に謝れ！

ObjCのどこが冗長なのかと

配列参照以外に[]を使うのがきめぇって話

なんだそりゃｗ

>>21
ならランタイムの関数を自分で呼べよ

Cに合わせる為だからしかたないよな。
でもキモいと思うのは禿同。

ObjC使ってるやつからすれば他の方がキモいだろうよ。

>>(a b c d)
>>を
>>a (b, c, d);
>>って書けば終わりじゃないの？
>a(b,c,d);
>と書くのはよいのだけど、なぜ、カンマやセミコロンが必要になるのか？
>明確にしておきたい。

バカか。
a+bを+(a b)と表すようにすればカンマもセミコロンも要らないよ。それだけの話。

C風とは言うが、どの辺がC風なんだ

>define:[main:[],
>printf:["hello world\n"]
>]

これをC風と言ったらビビルなｗ

うう、ここの1は演算子の理解すらしてない馬鹿なのか・・
C言語のセミコロンは式と文の区別。
カンマは関数引数の区切りもしくは式の中での順次実行。
C言語のリテラルと演算子はスペースで区切らずに続けて
書いても区別されるという利点がある。
a=b+c++;
これをLISPで書くと必ずスペースで区切る必要があり、
また括弧によって冗長になる。
(= a(+ b(++ c)))
演算子の利点は見ての通り。
つーか、、
こんなスレ立てる前にC言語の文法ぐらい適当な本でも買って把握してこいよ。
文法がわかればLISPなら3日あれば作れるだろ。

>printf:["hello world\n"]

間のコロンは何なの？
無意味な装飾はやめとけ。

C風のデータ形式って、JSONでもういいしね

どうせなら関数括弧を省略するロジックでも組めよ

printf fuck you butikorosuzo(gomimera) "\n";

>>30
JSON 風にしたいんじゃないのー？

>>30
Pythonにもいってやれよ

> プログラムで操作できる。
> Ｃ言語風の構文をもっている。
> 演算子を優先順位付きで定義して使える。

… >>1 よ、一つ聞いていいか？そのデータをプログラマが扱う内部表現はどう
したいんだ？

1. 内部表現は結局 S 式 → 操作は簡単だが表記と操作が異なってて不便
2. 内部表現が表記と同一 → 操作するときに演算子の優先順位をいちいち気にするのか？

>>16

あ、カッコの対応足りないよう。
Ｓ式でもどうできるってのは、分かりますが、
HaskellやらOcamlのヴァリアント型みたいなのほうがいいっしょ。

>>17
どういうのを作ったんでしょうか？

>>26

Ｓ式に、名前付きのカッコと、優先順位付きの演算子を使えるようにしたもの
を使えるようにしたものを作りたいのです。
+(a b)
とかけるのは分かります。

>>27
>>28
カッコの前にアイデンティファイアが来て、複数のカッコを使い分けるのが
Ｃ言語風なのです。アルゴル風っていったほうがいいのかしら。

>>29
Ｃ言語のセミコロンはなぜ、ターミネータだったり、セパレータ（for文）だったり
するのでしょう？というと、なんとなく見易いからとかになりますよね。

Schemeはコンティニュエーションとか難しいので作れません。(T-T)
S式のパーサは作れるけど、それは車輪の再発明にすぎないし。

>>30
いや、JSONをプログラム用に拡張したことを考えたら、
連想配列の名前と値の記述方法として:を使って書くことが出来るだろうから、
printf:["hello world\n"]と書いたのです。
:はいらないで書けるほうがいいと私も思ってますよ。

>>31
Ｃのデータ形式を考えるのではなくて、プログラミング言語として使える
Ｃ言語風のデータ形式を考えてるのです。

>>32
関数のカッコを省略する記法としては、MLやHaskellがあるのだと思います。

>>35
とにかく、できるだけプログラマが扱いやすいようにです。
S式と表記同一と２つの表現があるのがいいのかなと思っています。

２の優先順位をいちいち気にするに近いかと思います。
いちいち気にしないようにするために、Haskellの演算子を関数として
適用する方法もあったらいいかなと思ってます。
1+2 or `+`(1 2) or `+`(1,2) or (+ 1 2)
というかんじです。
優先順位付きの演算子があるから、カンマが必要になる。

さて、そのカンマは場合により省略したり、余計に書いたりが可能なはずだが、
どうあるべきなのかなと。

そういえばＣの仕様ってちゃんと読んだことがないなぁ。
Ｄ言語の仕様はしょっちゅう見てるんだけど。

>>37
>Ｃ言語のセミコロンはなぜ、ターミネータだったり、セパレータ（for文）だったり
>するのでしょう？というと、なんとなく見易いからとかになりますよね。

アホか。
for文の中の区切りを、例えばカンマにしないのは、
カンマにしたら、for(i = 0, j = 0; i<10; ++i, ++j) と書けないからってだけ。
見易いからじゃなく、他に代替手段が無いからにすぎない。

>>1
少なくとも、
・カッコが「演算子の優先順位の操作」と「関数呼び出し」を兼用
・一つの演算子が単項の場合と二項の場合の両方ある（例えば + や -）
ってのを排除しないと、余計なカンマやセミコロンは避けられないな。
もはや「C言語風」には見えなくなると思うけど。

どうでもいいけど、ECMAScriptみたいに改行部分だけ適宜セミコロン挿入、みたいな無理やり系も検討してるわけ？

プログラマが扱いやすいの目指すならS式のままでいいと思うんだけどなあ

>>40
いや、セミコロンがターミネータなら、
for(i=0,j=0;i<10;++i,++j;)ではなくて、
なぜ、;が３じゃないといけないの？
まぁ、文法がそうだからなんだけど、なんで、そんなに文法が複雑なんだと。
もっとシンプルなＨＴＭＬをＸＨＴＭＬにするようなことをやりたいのです。

ECMAScriptの改行うんぬんも、もちろん、検討しようと思ってます。
ただ、まだごちゃごちゃしてまとまらないので困ってる状態です。
Groovyとか、セミコロン無しとかですしねぇ。

>>41
そういった理由をしっかりさせた上で、カンマがありますと、
仕様書か何かの文章としてきちんと書きたいなと思ってるわけです。
他に漏れがあれば、そこも指摘してもらいたいなと。

>>42
Ｓ式で満足なら、このスレには用がないですよね。
Ｍ式はそういった理由で消えていったわけですし。
では、なぜ、Ｃ＃やＪａｖａがもてはやされてるの？
なぜ、MLやHaskellのバリアント型？のデータがC言語っぽいの？
って思うわけです。

>>43
>なぜ、;が３じゃないといけないの？

はぁ？

ちょっとかわいそうな>1のブログ

http://d.hatena.ne.jp/h_sakurai/

ようするにS式の見かけが気にいらねえから方言つくる
俺トランスレータにかければそのまま扱えるから便利だおってことでいいのか

なあ。>>1 よ。今まで黙ってきたけど、実は俺……

　a(b, c, d, e, ... )

この表記を基本にして全ての制御構造を書ける言語、知っているんだ……。

２項演算子とかは？

>>43
いや、セミコロンをターミネータだと思うな、forの中では。
forの中はセミコロンがターミネータであるということに対す（唯一といってよい）例外。

また、for内の最初の部分は、C++/C99だと変数の宣言もできる。
そして、真ん中の部分は継続するかを判断する条件式でなければならない。
そのためfor内でもセミコロンをターミネータとして扱うとしても、
forの構文は「for (式文 式文 式文) 文」のようにすっきりさせることは、どうせできないよ。

ええとなんだか誤解されそう。
「思うな」は「思ってはいけない」とでも読み替えてくれ。

> とにかく、できるだけプログラマが扱いやすいようにです。
> S式と表記同一と２つの表現があるのがいいのかなと思っています。

>>1 で提案してる形式はな，どうみてもプログラマが操作しやすいとは思えないんだがな…
ちょっとプログラムを操作する例をだしてみてくれないか？なんも考えてないって事はないよな？

yamlのようにインデントで木構造を表したほうが読みやすくないかな。
(a (b (+ c d)))
a:
　b:
　　+:
　　　c:
　　　d

uwa!

>>43
文法に気に食わない点があるなら、そこだけ修正すりゃいいだけじゃないか。
forのセミコロンとかマジでくだらなすぎ。
セミコロンが嫌なら、$ でも @ でも好きな記号使えばいいじゃん。
どうせその他のセミコロンとはセマンティクス的に別物なんだから。
（厳密な意味を除いて漠然と「区切り」である、という点しか共通してない）

もしくは文法を、
ForStmt -> for (Init ; Cond ; Iter) Stmt
の代わりに、
ForStmt -> for ( Init ) ( Cond ) ( Iter ) Stmt
にしたっていいわけだしな。
キモイけど文法に曖昧さはない。

つーか、forに「3つ目のセミコロン」をつけたい（つけてもつけなくてもよい文法にしたい）ってのがあんたの主張かい？
それこそ、ものすごい簡単な文法の修正で終わるじゃん。
ただ、3つ目のセミコロンを「つけることができてしまう」ほうがキモイと感じる人は多いと思うね。

いっそのことfor文を廃止すれば話はもっと早い。

あっそ。

そういうくだらない感想文は、キミのつまんない糞ブログにでも書いてろ。
もう来んな。

お前の感想のがよっぽどくだらないだろ。
ｷﾓｲ奴だな。

>>46
Lispのマクロ的にいろいろいじり回したいと。

>>47
おおー、それは知りたいです。
是非、教えてください。
名前だけでも教えてもらえれば嬉しいです。

>>48
２項演算子は、定義して使えることを考えてますよ。

>>51
Dylanや、Nemerleあたりのマクロみたいなのを考えてます。

まだ、説明してないのですが、たとえば、
syntax(swap(a,b)) {tmp = a;b = a;a = tmp}
等と書いておけば、
ハイジニックなマクロになるとかいった感じです。
このマクロ定義をＳ式で表すと、
(syntax (@paren (swap (@paren a , b))) (@block (= tmp a) ; (= b a) ; (= a tmp)))
となるといったことを考えてます。
ここで、カンマやセミコロンの扱い方がいろいろ考えられていじりまわしてるのですけど。
@parenが()のカッコを表していて、@blockが{}のカッコを表してます。
parenやblockと読んでるのは適当につけた名前なので変えたほうが良いかなぁとか思ってるんですが。

>>49 >>53
forにセミコロンを３つ付けたいのではなくて、
{}や()や[]内のカンマとセミコロンを全て同じように扱えるデータ形式を
考えて、プログラミング言語を作ればよいのではないか？
ということを考えているのです。
XMLの上に、XHTMLや、その他いろいろな言語を構築するように。
Ｃ式の上でプログラミング言語をいろいろ作れたらいいのではないかと。
Ｌｉｓｐの方言がいろいろあるように。
それが、Ｃ言語の後継言語に必要なんじゃないかと。

http://nekovm.org/specs
nekoはかなり、小さい気がするんだけど。

>>56
47 だけど、正確には

msg_list := msgs
    | msg_list ';' msgs
msgs :=
    | msgs msg
msg := identifier
    | identifier '(' args ')'
args :=
    | msg_list
    | args ',' msg_list

みたいな感じだから、Ｓ式よりも複雑だったり。
ttp://www.iolanguage.com/docs/grammar/bnf/


ちなみに２項演算子は構文糖として処理され、中身は↑のような形式に。

>>59
Ioですか。Luaの友達の組み込み用言語で、shinichiro_hさんがやっている。
っていう認識でした。

Ｓ式より複雑なのは仕方ないと思います。
SRUも、似たような思想の言語だったような。
http://sru.ikejisoft.com/?What's%20SRU

ソース綺麗らしいし、ちゃんと動かして遊んでみようかなぁ。

……このスレは、汎用データ記述方法を考えるスレじゃなかったの？
なんか独自言語の模索に取りかかってるみたいだけど。

データ形式だけだとjsonでいいだろ、で終わるのでそういうことにしました

自分はLispの強力なマクロと同レベルのマクロが使える独自言語を模索してます。
独自言語を作るアプローチとして、

�@汎用データ記述方式を作る。
�A汎用データ記述方式を使ってプログラミング言語を作る。

ということを考えています。

うまみは「パーサ作らないでＣ言語風な構文のプログラミング言語を
いろいろいじりまわして作れる。」
っていうことなわけで、そのうまみを理解してもらおうとしてたと
いうところだと思います。

>>63
りょーかい。そういうのなら協力するよ。ちょっと興味ある分野だから。

ところで、Ｓ式で表したＣプログラムを処理する処理系があるのは聞いたことある？
ああいうのが欲しい。

>>63
>「パーサ作らないでＣ言語風な構文のプログラミング言語を
>いろいろいじりまわして作れる。」
２項演算子を導入するとパーサが必要になると思うのだが。
x = 1を(set! x 1)と解釈すること自体がパースそのものなわけだし。

パーサが入っても、最終的に汎用になれば良い、って見方もあると思う。
それから、Ｓ式の評価の仕方から変えちゃえば (1 + 2) を直接実行することもできるだろうし、実際そういうのを作ったこともあったり。

>>64
JavaのEPPは知ってるのですが、Cのものは知りません。
教えてもらえると嬉しいです。
EPPがなぜ広まらないかなぁって考えてやっぱり、
Ｓ式は広まらんのかと思ってたりします。
協力していただけますか。ありがとうございます。
よろしくお願いします。

>>65
XMLはパーサ作らなくてもライブラリ拾ってきて利用できますよね。
同じように、Ｃ式のパーサライブラリ拾ってくれば利用できるようにしたいと。
そういった話です。２項演算子もＣ式で使えるようにしたいと考えてますので。

しばらく、Ioで遊ぼうと思います。

SQLベースじゃない理想のRDBコンテナ作ってよ。

>>67
「Ｓ式ベースＣ言語」 でぐぐると、ちらほらと詳細出てくるはず。
Ｓ式にすると多段マクロが書きやすいって論文を見たことがあるんで。

Ｓ式自体は何の変哲もない配列あるいはリストなんだから、Lisp がＣに比べて広まらないのは、
Ｓ式だけで表記するという仕様のデメリットが直に出たからだと考えていたり。


Ｓ式について深く考え、それから「じゃあＣでは」を考えるべきかなー、とか。

> ところで、Ｓ式で表したＣプログラムを処理する処理系
学部の実験で作ったな…

Ｃ式ってもともとコードのためのもので、データ構造とは関係ない。
だから、無理やり汎用データ構造にしても使いづらいと思う。
んで、Ｃ風の構文で強力なマクロが使いたかったら、そういうような言語を作ればいいだけだし、この二つの話をくっつけること自体がとてつもなく無意味なような。
コードの動的生成をするにしても、VMやCのコードを生成するのが普通だとおも

IoのWindowsへのインストール方法が消えてなくなってるみたいで、使えない。
うわーん。

>>71
まぁ、普通プログラミング言語というと、BNFをベースとした文脈自由文法で
書くわけですがそれだと、SDML上のHTMLみたいなもので、文法が複雑化します。
SDMLのパーサは誰でもかけるわけではないので、簡単にした、XMLが登場したわけです。
自分が考えているC式てのは、
プログラミング言語用のXMLのようなものを考えているわけです。
だから、一般的なプログラミング言語の開発手法とはアプローチの仕方が違います。
強力なマクロをもった言語は存在していますが(DylanやNemerle)、簡単に作れそうに見えません。

LISPがなぜ、簡単にマクロを実現できるのかというとプログラムがそのままデータでもあるからです。
強力なマクロを簡単に作るには、プログラムをデータで書くことが出来ることは重要なことなのです。

思ったんだが、C言語風の文法で、パーサがそこらに転がってて、（クロージャを含む）いかなるデータ構造も表現できる、って話ならECMAScriptを文や宣言も値として評価可能ってことにすれば、とりあえずおｋじゃないか？
データのシリアライズだけが目的ならJSONでいいし、プログラムを表現するって点に着目すればECMAScript（またはそのサブセット）でいいんじゃないかと。

とにかく全ての部分が再帰的に評価可能になっていれば、S式のマクロみたいな閉包性（マクロ適用前も適用後も元の言語の文法にフィット）も実現しやすいと思う。
逆に評価不可能な部分があったりすると、Cの#defineみたいなやっつけマクロ（なんでも置換できるが、マクロ適用後にパースエラーが出うる）にせざるをえなくなっちゃうしな。

>>72
Io のビルドは難しいよ。
ttp://www.mike-austin.com/io/　からバイナリ落とした方が早い。


そういえば OpenJava を思い出した。Java のマクロ処理系。
構文解析にも多少手を入れられるけど、『拡張』 と言えるだけの変更は難しいみたいで。

Lisp はパーサを動的に変更可能みたいだけど、Java のパーサは……難しいのかな。

＞LISP…言語設計のブラックホール
＞http://www.rubyist.net/~matz/20060914.html#p01
＞
＞Guy Steele曰く「Lispはブラックホールだ。「Lispに似た(でもLispではない)なにか」を
＞作ろうとすると、重力につかまってブラックホールに落ちてしまう。そしてそれはLispになる。

lispのマクロが強力って言うけど、Cのマクロじゃできないことって具体的にどんなの？
パターンマッチで再帰的に書けることぐらいしか思いつかない。

C式が最低限クリアしないといけないハードルを明らかにするためにも、lispのマクロの優位な点を明確にしておくことは有意義だと思う。
構文木を操作するマクロを作ったとしても、Cのマクロ程度の性能しかなかったらそんなもん誰も使わない。

パターンマッチで再帰的に書けない時点で、Cのマクロが激しく劣ってることも分からないのかお前は

>>77
それだけ？

言葉にして一行足らずとしても、それはひたすら大きい。わかるか？
それだけも糞もないことが。

日本語でおk

お前の脳味噌、それだけ？

それだけなら汎用データ形式なんでいらねーじゃん
再帰マクロを作ればいいだけ

そうだな

>>81
いいレス思いついた、と思ったら
書き込む前にまず他人に通じるかどうか考えようぜ。

C のマクロだと

for(init; condition; update) {
    // hogehoge
}

を

{
    init;
    while(condition) {
        // hogehoge
        update;
    }
}

に書き換えるみたいなことは出来ないなぁ。
構文をごちゃごちゃするのは苦手ですよ。

>>85
これは普通に通るけど、これじゃ駄目？

#define foaah(init, condition, update, hogehoge) init; while(condition){hogehoge update;}

void main(){
foaah(int i = 0, i < 10, i++, {cout << i << endl;});
}

>>74

おお、バイナリ、ありがたく使わせてもらいます。
EPP使って、Javaの文法追加して遊んだことはあります。

Ｃ言語において、
引数のカンマは演算子等の問題で明確に分離するために存在しています。
演算子を使える場合でも、他に、()を使って分離する方法もあり、
haskellやocaml等の関数型言語で使われています。

S式 (a 1 -1)
C言語 a(1,-1)
haskell a 1 (-1)
groovy a 1,-1

といった感じです。
次に考えたいのが、カンマを使って分離する場合に、どのような文法が考えられるかです。
列挙したいと思います。

１）カンマはセパレータで必ず必要なもの
　(a b (c) ()) -> a(b,c(),())
　長所．１つのデータの表現は１つ
　短所．編集する際後ろのカンマを最後に消さないといけない
２）カンマはセパレータであるが、最後に書いても良いもの
(a b (c) ()) -> a(b,c(),()) or a(b,c(),(),)
　長所．編集する際に楽
　短所．１つのデータの表現に複数の表記が存在する。
３）カンマはターミネータである。
(a b (c) ()) -> a(b,c(),(),)
　長所．編集する際に楽
　短所．余計な文字が増える。
４）カンマは名前なしカッコの前に書くもの
(a b (c) ()) -> a(b c() ,())
　長所．必要最小限のカンマですむ
　短所．a( ,( ,() ))これがみやすいとはいえない。
５）カンマはセパレータで名前なしカッコの前に書くもの
(a b (c) ()) -> a(b c() ,())
　長所．必要最小限のカンマですむ。３と比べa((()))と書ける。
　短所．カンマを分かりやすくするために使えない。
６）カンマはセパレータで名前なしカッコの前には必ず必要で他はあってもなくても良いもの
(a b (c) ()) -> a(b c(),()) or a(b, c(), ())
　長所．カンマを分かりやすくするために使える。
　短所．データを単一の表記で表せない。
７）カンマはセパレータ、あるいはターミネータで名前なしカッコの前には
必ず必要で他はあってもなくても良いもの
(a b (c) ()) -> a(b c(),()) or a(b, c(), ()) or a(b, c(), (),) or a(b c(), (),)
　長所．カンマを分かりやすくするために使える。
　短所．データを単一の表記で表せない。

>>86
そう。それは通る。
だからこそ、Ｃ式が必要なのではないか、って話になるんです。

つまり、最終的には、foaah(init, condition, update, hogehoge) のような形式で全部書けないか〜って話ですね。
もっとも、結論から言えば書けることは自明なのですが、
{ 〜 } とかで見やすくなっているのを損なわずに〜となると、また難しく。

……なんか分かりにくい文だな。
マクロに関して言えば、全ての構文要素がマクロによって書き換えられることを期待した文法が欲しいんです。

確かに Java の OpenJava とか .NET の CodeDom とかでソースコードの DOM 木を改変することは今でも出来ますけど、
Java も C# も、構文要素は Lisp に比べて遥かに多く複雑で、OpenJava も CodeDom も文法拡張に難がありますから。

ということで、>>1 の求めているものとは異なるかもしれませんが、
そういう意味で、俺は意味や可読性を損なわないレベルで簡潔な汎用文法が欲しいんです。

>>89
現状の何について不満を感じているのかが分からない。
マクロを適用した後の
foaah(int i = 0, i < 10, i++, {cout << i << endl;});が
for(int i = 0; i < 10; i++){cout << i << endl;}
と違う形になってしまっていること？

実は実際に「C風の構文で構文木をいじるマクロを実装すること」をテーマに言語（Dへのトランスレータ）を作ってて、構文は
function(int check, (int x), {
if(x < 10, {
return(2)
}, if(x < 20, {
return(3)
}))
});
というような形に行き着いたのだけど、ここまでしてもCのマクロに勝てる要素無いんだよね。
この言語でできることはCのマクロでもできる。
Schemeにある再帰マクロとかは単にマクロ自体の機能で、実装するなら構文木をいじらずともトークン列をいじくったほうが分かりやすいし多言語にも応用が利く。
実際に作ろうとした立場からは、C式はいらないという結論に達してしまったわけで。

>>91
Ｃのマクロに、処理能力的な面で勝つ必要もないんじゃないかなぁ。
むしろ >>91 の "}, if" の "," とか、"}))" をどれだけの人が受け入れてくれるのか、っていう表記的な話になるのでは。

……処理能力的な面でもＣのマクロに不満は残るけどね。
Ｃのマクロは単なるパターンマッチだから、『プログラム変換』というレベルには手が届いていないような気がするんで。



余談だけど、>>91 を Io で考えると

setSlot("check", method(check, x,
    if (x < 10, return 2)
    if (x < 20, return 3)
))

なんていう、とても素直な形になっていたり。

>>87-88
何度も言うが10回ぐらいC言語の仕様書を読め。
関数呼び出しと初期化式のカンマの扱いを混同してるんじゃないか。
Cを知ってる奴ならそんな発想は出てこない。
引数の数の扱いはもっと神聖なものだ。
そんな無知を無神経にさらけ出す奴の気持ち悪い公開オナニーを見せられる身にもなってみろ。

>>84
お前の脳味噌、それだけ？

>>93
混同しているのではなくて、
Ｃ言語において、関数呼び出しと初期化式（配列ですよね）が
違うことは知ってます。初期化式はデータをコピー＆ペースト
で書きやすくするために最後にカンマがついていても良いんですよね。
しかし、Ｃ式においては、関数呼び出しや、配列の初期化などはないのです。
あるのは、()[]{}などのカッコと名前つきのカッコなどなのです。
[]内で、最後のカンマは省略してもしなくてもよく、()内ではカンマが省略不可
等としたくないのです。Ioもそうなってるっしょ。


違うことは知っていますが、同列に扱って、
文法をより単純かつ一般的にしたいのです。

なんとなくの考えでは、最後に
カンマやセミコロンはつけても付けなくても良いとするのが
よいと思ってますが、理由がなんとなくなので、気持ち悪いんです。
全件あたって、これが良いのだという結論を出したいのです。

>>91
う、痛いところつかれたなぁ。
確かにマクロはリードマクロとして
トークン列のパターンマッチで出来ちゃうしシンプルになるんですよねぇ。
それがDylanやNemerleなわけで、、、。

しかし、文法が複雑、ウギャース、死亡ってかんじなんですよね。

�@いわゆるシンタックスシュガーは、
　全部、リードマクロにより実装するようにしてしまい、
　演算子などはまったくない言語を作ってしまう。
�Aもうちょっと考えて、演算子とカッコ、コメントまで面倒見る。
　っていう２通りの考え方があると思ってるんです。

で、�@を突き詰めるとＳ式で良くなってしまうと思うのです。

そうすると、�Aの出来るだけ標準化できるところは標準化しておく
方向性を突き詰めたほうが良いように思うわけです。

ってわけで、やっぱり、ある程度大きい汎用な文法が欲しいんです。

それを使って、開発環境のピロピロをやったりして遊びたいんです。
さらに、関数一覧作ってみたり、論理型言語に適用してみたり。
関数型言語作ってみたり。

ふと思ったんだけど、【表記または文法】 と 【内部表現】 を混同している予感がする。

>>95-96
つーかさっさとプロトタイプ作って試してみればいいじゃん。
LISPやSchemeなら30分もあればできるっしょ。
どれが使いやすいかなんて感覚的なものは試してみないとわからんし、
自分がいかに糞な物を作ろうとしてるかはっきりわかるよ。

>>96
Nemerleのマクロって複雑かな？
俺は、あまりに簡単で感動した口なんだけど
Nemerle触る前にOCamlのマクロと格闘してたせいかな

ああ、Nemerle のマクロか。
名前しか聞いたことなかったけど、今見てみると確かに強力そうだ。


んー
例えば、メソッド Bar の前に Foo が呼び出されているかどうかチェックするプログラムみたいなのって、
Nemerle のマクロで実装可能？

>>97
文章を書くことは下手だから、混同している可能性はありますね。

>>98
ここ数年、
何回も、作っては壊し、作っては壊ししてますよ。
それで、シンプルにすることがとても難しいことを実感しています。
しかしながら、完成すれば素晴らしいものが出来上がると確信しています。

>>99
Nemerleの文法が複雑ってだけで、マクロはシンプルに使えますね。
で、<[と]>でくくる、クォートの実装が結構複雑ってかんじです。
構文木を出力する構文木を作る構文ってなかんじになってて。
Lispのクォートみたいに出来るだろうって思ってます。

ああ、そうか。何もデータとして考えなきゃいけないってことはないのか。

private void function(tarai, x, y, z,
    if (x <= y,
        return y,
        tarai(tarai(x - 1, y, z), tarai(y - 1, z, x), tarai(z - 1, x, y))
    )
)

このプログラムを実行する、と。
……シンボルは扱えた方が良いな。

試行錯誤した結果、
Ｃ式では、カッコは左にくっつくことを考えています。
C式 -> S式

() -> (@paren)
[] -> (@array)
{} -> (@block)
a -> (a)
1 -> (1)
a() -> (a (@paren))
a(1) -> (a (@paren (1) ))
a(1,2,3){} -> (a (@paren (1) (2) (3)) (@block))
a(1,2,3){4,5,6} -> (a (@paren (1) (2) (3)) (@block (4) (5) (6)))
a(){}[] -> (a (@paren) (@block) (@array))

リストをそのまま内部表現として使うと無駄が多いので
内部のデータ構造はD言語で書くと

class Atom{...}
class Identifier : Atom {...}
class String : Atom {...}
class Int : Atom {...}
class Float : Atom {...}
class Tree {
Atom id;
Tree[] tree;
}
ってな感じになることを考えています。

ヲイヲイ、どっかで聞いたことあるような、と思ったら
発想がsapidやxciとかとそっくりじゃないか。
サーベイもちっとしてからの方がいいんじゃね？

こんなすれがあったのね。
いまゲームで使ってるスクリプトは、ネームスペース指向です。

with Hoge {
　with Moge {
　　Foo = 1234
　}
}

Test = Hoge.Moge.Foo = 1234

みたいな感じで使います。
参考にはならんか。

squirrelみたいに、したいんだけどな。
配列内で、名前空間使えるようにしたいんだけどなあ

> Test = Hoge.Moge.Foo = 1234
Test = Hoge.Moge.Foo
まちがった

>>105
soopy を思い出す

>>104
sapidやxciですか、ありがとうございます。調べてみます。
ああ、もういいかげん、いろんな言語、見るの飽きてきたですよ。
(;_;)うおーん

>>104
sapidってどの変で、汎用データ形式が出てくるのでしょうか？
I-model? P-model? C-model? SDB?
それともそれ以外？
xciは、cをxmlにして弄るもののようですが、、、。
なにぶん独学でやってるもので、
ちょっと見ただけだと、どこらへんが発想がそっくりなのか分かりかねます。

>>109
I-modelのことを考えてた。

発想がそっくり、というのは、
>�EＣ言語風のデータ形式を作ってＳ式のパーサ＋αくらいでパース出来るようにしてしまえ！
の部分。

データ構造として違うとか、S式とXMLは表現として違うとか、
そういうレベルで議論するなら、そんなに似てないけど。

>>110
もしよかったら、I-modelのサンプルコードを教えてください。
仕様書からだと文法がずらずらってかんじで
分かりにくいっす。

>>111
中の人じゃないけど、そろそろ特定されそうな感じなんで、チュートリアルで勘弁して。
ttp://www.sapid.org/html2/tutorial/tutorial-0.html

対象がJavaプログラムなのでちょっと違うけど、

sapidから派生した（？）Japidというのもある。こっちのチュートリアルの方がわかりやすいから、
雰囲気を知りたいだけならこっちがお勧め。
ttp://www.sapid.org/html2/Japid/Japid-Tutorial-0.html

>>112
チュートリアル見ても，残念ながらわかりずらかったです。
ＣＡＳＥツール用プラットフォームってことは分かったのですが。
こういった、ドキュメントって書くのも、読むのも、
難しいものなんだなぁと再確認した次第です。
ありがとうございました。
ＳＤＢはデータベースのデータの中身よりも、概念が重要で、
グラフを作成していろいろ利用しやすいようにしたりするもの
のようですね。

Ｃ言語やＪａｖａのパーサは用意してあるのだろうから、
とても、素晴らしく大規模なものだと思うのですが、
Ｃ式ではSapid等でやっていることを
出来るだけ小規模でやれたらっていう
感じのこと考えているのだと思います。

そうか、混乱させたかもしれんね。申し訳ない。

このスレで他の人もさんざん言ってるけど、ソースコードをいじるための
データ構造や表現を考えるのは結構難しい。心してやってください。
ツールで何をしたいかわかってないと決められんこともあるし。

・・・って当たり前のことを書いてるな俺。

とりあえずJSONよりマシなの作ってくれ

>>104
まずは、プログラミング言語を作るところを考えてます。
難しいですが、頑張って完成させようと思います。

セミコロンとカンマの扱いをどうしようか迷っています。
現在は、１つの式として扱うようにしています。
例)
Tree t1 = parse("a,b;c;d");
foreach (Tree t2; t1.split(";")) {
　foreach (Tree t3; t2.split(",")) {
　　t2.println();
　}
　printf("---\n");
}

a
b
---
c
---
d
といった感じで。
パースした段階で既に、セミコロンとカンマは分離してあったほうがいいのか、微妙です。

仕様書作成用、WIKIたててみました。
http://dokoka.sakura.ne.jp/cexp/

>>117
ちょっとまてぇぇぇぇぇ!! なんかとんでもなく退化してるじゃねぇか？？
セミコロンとかカンマって単位で要素を操作すんの？例えば↓みたいな式
から関数だけ取りだすときはどーすんの？

"x = 10; f(x,x)+g(x,x^2);"

=, f, +, g, ^ の関数（演算子）を取り出すには？ 117 の例だとしぬほどダルそうなんだけど

２項演算子が無視されている件

"x = 10; f(x,x)+g(x,x^2);"
は
(@d
　(= (x) (10))
　(;)
　(+
　　(f (@p (x) (,) (x)))
　 (g (@p (x) (,) (^ (x) (2)))))
　(;))
と扱ってるのですが、
(;
　(, (= (x) (10)))
　(, (+ (f (@p (; (, (x) (x) ))))
　　(g (@p (; (, (x) (^ (x) (2)) ))))
)
))
となるといいかなぁ？どうなのかなぁという感じです。

何故そんなにカンマだのセミコロンに拘るのかが理解けいん
C コンパイラでもパース後にカンマやセミコロンなんて残らねーぞ

これc言語風、なのか？例が特殊なだけかもしれんが

とりあえず1はCをSchemeにトランスレートするものを作ってみてはどうか
>>121を見て1に絶望した人は多いだろう

医師でありながらとかいって美容整形の時点で欲望まみれだろｗ

@array
(
"foo",
"bar",
"hoge",
@dictionary
{
( "key1" = "value1"),
( "key2" = "value2")
}
)

Cじゃなくてまた別のものみたいだ

>>124
とりあえず、Cシンタックスをもった、Schemeは作ったものがあるので
公開してみましょうか？？？
ライセンスどうするかが問題なんですけど。。。
NYSLでいいかなぁ。

一般的なデータ形式となると、
for(i=0,j=0;i<10;i++,j++)
くらいまで、扱えるようにしたいとなると、、、
２次元ですよね。
Ｃ言語はＢＮＦで意味をしっかり定義できるから、
関数呼び出しの場合はセミコロンはないとか、
for文の場合は、セミコロンは２つとか決められます。
しかし、汎用となると、そういった文法は決められません。
じゃあ、どうしたらいいのか？？？
っていうところでずっと悩んでるわけです。
どうやったら、シンプルになるのかなぁと。

>>126
["foo","bar","hoge", {key:"value1", key2:"value2"}]
が
S式だと
(@array "foo" "bar" "hoge" (@block (: key "value1") (: key2 "value2")))
として使えるイメージなのだけども、セミコロンとカンマの扱いがゴチャゴチャしてしまってる現状なので
(@array "foo" , "bar" , "hoge" , (@block (: key "value1") , (: key2 "value2")))
ってなってしまってたりするって感じです。
括弧がくっつく性質を考えると、
(@array ("foo") (,) ("bar") (,) ("hoge") (,) (@block (: (key) ("value1")) (,) (: (key2) ("value2"))))
こうすると扱いやすいのかなぁと。
ほんと、カンマとセミコロンうざいです。

@つけるのは、複数の括弧をS式とかで扱う場合の名前として使ってみたら
いいのではと思って使ってるのだけど、
とにかく、ドキュメントをしっかりしてかないとなぁ。orz...

このデータ構造に対して、簡単に扱えるようにするＡＰＩも考えないと
いかんよなとか、むずいです。

…↓でだめな理由は？
(vector "foo" "bar" "hoge" (hash :key "value1" :key2 "value2))

>>129
ベクターとハッシュだけなら、それでいいけど
for(i=0j=0;j<10;,j++,i++){a();}
こういったものまであつかえない

>>130
(for (init (i 0) (j = 0)) (cond (< j 10)) (update (++ i) (++ j)) (block (call a))

これじゃダメなの？

>>127
> とりあえず、Cシンタックスをもった、Schemeは作ったものがあるので
> 公開してみましょうか？？？

今迄の例をみてるとあんま Scheme に詳しい感じはしなかったけどね
C Hacker なのか？それ define-syntax とかどんな感じになってんの？

>>131
プログラミング言語として、文脈自由文法を定義してパースするなら
それでいいけど、

プログラミング言語を作ることができる、
Ｃ言語風の汎用データを作ろうとしてるので、
initとかとかって判定を入れる必要はないのです。

寂しくなってきたのでage

つうか1が何したいのか全然わからんし、自分でもわかってないんだろ？
一人でやってろよ。

>>135
俺もわからん、誰か解説ヨロ。

プログラミング言語用のＣ言語風の汎用言語を作って、
それを使って拡張性の高いプログラミング言語作りたくて、
そのための話をしたいのだけど、どう話を進めたらよいかわからないので、
のたうちまわってる感じです。

Ｃ言語風の汎用データ構造を作って、
プログラミング言語作って、弄りまわしたいんです。
Ｃ＃や、ＪａｖａやＤ言語よりよりよい言語を作る基盤を作って。

ただの好みの話ではない話をしたいのだけども、
どういう議論をしたらいいかがわからないんです、、、。

>>137
データの内部表現を問題にしているのか、
データの表記方法を問題にしているのか、


とりあえず、それだけでもはっきりさせてくれないか？

>>137
ついでに３つ。



１：既存の言語の何が問題で、
２：どのようなものを新しく作れば、
３：何が出来るようになるのか

答えてくれ

うーん。そこまで厳しく問い詰めなくても。

ただ、読んでていらいらするのは確かだと思う。
どこが面白いのか、どうすごいのか、何が新しいのか、
何でもいいから伝わるような説明をして欲しい。

とはいえ、そういう説明がすらすらできるようなら、
こんなところじゃなくて、お金くれる人の前で
プレゼンしたら？という気もするが。

どこが面白いのか、何が変わるのか、は分かるんだけど……。
>>138 に同感。>>1 が何に迷っているのかが分かんない……。

>>132
横からすまんけど、 131 の例なら

(setq expr '(for (init (i 0) (j 0)) (cond (< j 10)) (update (++ i) (++ j)) (block (call a)))

初期化部: (assoc 'init (cdr expr)) => (init (i 0) (j 0))
条件部: (assoc 'cond (cdr expr)) => (cond (< j 10))
更新部: (assoc 'update (cdr expr)) => (update (++ i) (++ j))
...

のように一発でアクセスできるじゃん。その C 式とやらはどんな表記でメリットは何なの？

>>141
悩んでるのは議論の進め方です。
ああだこうだ、頭の中でスパゲッティ状態なので、まとめたいのだけど
まとめられない。

迷っている点を箇条書きしたらいいんでしょうかねぇ

>>142
a(b(),c+1;d,e;;;f){g;}
たとえば、こういった式もパースできます。
文法に縛られない単なるデータとして扱えることがメリットです。

パースできるからなんなの？

パースできるってのは、Ｓ式と同じ発想だよね？

じゃ無事

−−終了−−

ってことで

>>143
まずは、議論したいことを箇条書きで書きなさいな

それから、サンプルコードを見せて欲しい。
ためしに↓をＣ式で書くとどうなる？

int tarai(int x, int y, int z) {
    if (x <= y)
        return y;
    else
        return tarai(tarai(x - 1, y, z), tarai(y - 1, z, x), tarai(z - 1, x, y));
}
void main() {
    printf("%d", tarai(20, 5, 1));
}

仕様がまとまりきっていなくても良いから、提示して欲しい。

>>144
そりゃ外部表記だろ？誰もパースできるとかできないの話はしてない。
そうじゃなくて内部表現で >>133 でいってた

> initとかとかって判定を入れる必要はないのです。

の意味がわからんって事。>>131 のほうが操作しやすいじゃん。

ttp://dokoka.sakura.ne.jp/cexp/

さりげなく壮大な計画へと発展している様に噴いた。
……まあ、がんばれ。

さて、実は自分もこっそり案を練っていましたよ、と。Ｃ式とは異なりますが。

tarai := function(x, y, z,
    if (x <= y,
        y,
        tarai(tarai(x - 1, y, z), tarai(y - 1, z, x), tarai(z - 1, x, y))
    )
)
main := function(
    printf("%d", tarai(20, 5, 1)
)

内部的には

define(tarai, function(x, y, z, if(<=(x, y), y, tarai(tarai(-(x, 1), y, z), tarai(-(y, 1), z, x), tarai(-(z, 1), x, y)))))
define(main, function(printf("%d", tarai(20, 5, 1))))

……だけど、再帰関数が上手く動くのかは不明。

もはや、C言語から大分ずれますが、こんな感じを考えています。

tarai: (x:int; y:int; z:int) {int} = {
　if (x <= y) {
　　y
　} else {
　　tarai(tarai(x - 1; y; z); tarai(y - 1; z; x); tarai(z - 1; x; y))
　}
}
main : (){} = {
　printf("%d"; tarai(20;5;1))
}

内部的には
(@disable
　(= (: (tarai) (@paren (: (x) (int)) (;) (: (y) (int)) (;) (: (z) (int)) (@block (int))))
　　(@block
　　　(else (if (@paren (<= (x) (y)) ) (@block (y)) )
　　　　　　(@block (tarai (@paren　(tarai (@paren (- x 1) (;) (y) (;) (z))) (;)
　　　　　　　　　　　　　　　　　　(tarai (@paren (- y 1) (;) (z) (;) (x))) (;)
　　　　　　　　　　　　　　　　　　(tarai (@paren (- z 1) (;) (x) (;) (y))) ))))))
　(= (: (main) (@paren) (@block)) (@block
　　　(printf (@paren ("%d") (;) (tarai (@paren (20) (;) (5) (;) (1)))))
　)))
な感じ。

C風だと、以下のような感じ。
@disable(
　@=@( @:@(tarai @paren( @:@(x int) @; @:@(y int) @; @:@(z int) @block(int)))
　　@block(
　　　@else@( if( @paren( @<=@(x y) ) @block(y) )
　　　　　　@block( tarai( @paren(　tarai( @paren( @-@(x 1) @; y @; z)) @;
　　　　　　　　　　　　　　　　　　tarai( @paren( @-@(y 1) @; z @; x)) @;
　　　　　　　　　　　　　　　　　　tarai( @paren( @-@(z 1) @; x @; y)) ))))))
　@=@( @:@(main @paren @block) @block(
　　　printf( @paren( "%d" @; tarai( @paren(20 @; 5 @; 1))))
　)))

>>149
C式を使うと、変換の２度手間が必要になったりすると思います。
BNFで定義してパースした結果を使用したほうが扱いやすいと思います。

まぁ、パースした結果をセミコロンだのカンマを基準に操作
するってのは激しく珍しいかもしれんが・・

>>152
なんじゃそれ。もう「C式」と呼べるような代物じゃないじゃん。
お前さぁ、当初の目的を見失ってるんじゃねーの？

S式がイヤなのは「Cライクじゃないから」だろ？
じゃーCとかけ離れた時点で、もはや利点が無いのは明白。
そんなの使うぐらいならS式使うわな。

悩んでいる点

・括弧が左にくっつく性質を考える前に、
名前付き括弧とカンマのみのものをきっちり考えるべきなのではないか？
・カンマとセミコロンの扱いをどうすれば単純になるのか？
・完全な可逆性を保つか保たないか。
　コメントや、行や位置を完全に復元できるようにするかどうかということ。
　どこまで復元できるようにするか。
・演算子は定義できたほうがよいのか、固定されていたほうがよいのか？
・演算子を定義できるようにする場合の優先順位はどうするか？
・リードマクロを使った場合に、元の形に自動で戻すための方法論がわからない。
・仕様作成にあたって考えたことのドキュメントと、仕様の大枠がうまく作れない。

>>151

47さんの考えているもののほうが、わかりやすいですよねぇ。
:=演算子はdefineという関数を呼び出しているだけの意味で、、、。
っていうIo言語的ですよねぇ。

例だと、引数リストが何処までか、わからない気がしますが。

演算子の定義は、確かに悩むね
出来れば、３項演算子みたいなのも定義できるようにしたいところ

    \ prmlist => expr

みたいな演算子作って

    \ x y => x + y

みたいなラムダ式作りたい

>>158
この際、表記ではなく内部表現にこだわってみては如何か。
.NET Framework の CodeDom には触ったことありますか？


ちなみに、Io では method メソッドに渡された引数の
一番最後のものが式として実行されるメッセージになってるっスね。

    method(x, y, x + y)

みたいな

>>160
>この際、表記ではなく内部表現にこだわってみては如何か。

･･･じゃあLispでいいだろ

ぱっと見で、構造がわかるけど、それなりの表現が出来ることを
考えているので、内部表現も、表記もどっちも大切なんですよねぇ。

リードマクロとか、Ioなどのシンタックスシュガー的な表記は
不可逆になりそうなので、そのへんどうなのかなと。

Schemeのシンタックスマクロ的なものを書いておけば
リードマクロ＋ライトマクロ（そんなのあるのかどうかは知らない）
が自動でうまいことできてくれるといいのかなぁ。
ＢＮＦがあれば、パーサが出来るけど、シリアライザもいっしょに出来る
って感じのものあるのかしら。

>>159
とりあえず、今までは定義は自分でするように作ってみてきてます。
問題は字句解析でどう、オペレータの字句を解析しようかっていう所だったりしてます。
３項演算子はＣだと１つしかないから無しってことにしてます。
演算子の定義を単なるリードマクロで実現できるといいんだろうなぁと
漠然と思ってます。
a(b(),c)っていう表記が出来るだけ＋
リードマクロっていう構成で言語を構築したらどうなるのかなと。
リードマクロが強力で優先順位を持った演算子の定義とかできちゃうとか。

C式の内部表現は、

名前付き可変長配列

だと、扱いやすいと経験上思います。
名前付きリストのほうがいいかもしれませんがわかりません。
ただの配列(JavaScriptのArray)だと扱いにくかったです。
関数を用意すればいいんだけど、
関数をいちいち通すってことは遅くなるって事だと思います。

名前付き配列として扱う場合にConsセグの拡張として考えると、
よくわからない、数学の世界みたいなのが広がっていってしまって困ります。

List(1,2,3 ... 4)
が
S式の(1 2 3 . 4)
に相当するように出来るんじゃとか。
List(1,2,3 ... 4)は
Cons(1, Cons(2, Cons(3, 4)))
の略だとか、何とかから始まって。
Consは２つしかデータ持たないけど
C(1,2,3)っていう風に３つ以上持てる場合も拡張して考えてくと。。。

tarai := function(x, y, z) {
    if (x <= y)
        return y;
    else
        return tarai(tarai(x - 1, y, z), tarai(y - 1, z, x), tarai(z - 1, x, y));
}
main := function() {
    printf("%d\n", tarai(20, 5, 1));
}

記法はこんな感じになった。

えーと結局C式は完成したとして、なんでプログラムから使いやすいんだ？見た目だけ？
s式みたいな単純さはどこにも見えないんだが。

>>163
>>1 よ・・・おまえ List を理解してねーじゃねーか・・・
Cons(3, 4) は正規のリストじゃねー。
(list 1 2 3 4) => (cons 1 (cons 2 (cons 3 (cons 4 ())))) だ。
悪い事はいわん。S 式をちゃんと勉強するか、 S 式の名前を出すのをやめろ。

>>164
↓下の JavaScript の代入が = から := になっただけじゃねーかそれ
tarai = function(x, y, z) {
if (x <= y)
return y;
else
return tarai(tarai(x - 1, y, z), tarai(y - 1, z, x), tarai(z - 1, x, y));
}

>>166
だけじゃないかというより、出来るだけ似せて作った。

ただ := と = は意味的に大きく異なる予定。
:= はコンパイルタイム代入だけど、= はランタイム代入のつもりだったり。

>>167
JavaScript の構文をもった別の言語をつくるって話？
1. JavaScript 構文
2. コンパイルタイムとランタイムを区別する
ここまでは理解したよ。今のところあんまりメリットがみえないが……

>>168
JavaScript には、たまたま似ただけ。厳密に合わせるつもりは無いです。
>>1 さんとは異なりますが、俺が考えているのは 『コンパイル時に CodeDom をごちゃごちゃ弄れる機構』 ですね。

構想としては、C 風の構文を持つ XML + XSLT っぽい仕様を作って 『外部からのソース改変』 と、
コンパイル時計算を使っての 『内部からのソース改変』 を実現できれば良いかな、と。

>>166
gosh> (cons 1 (cons 2 (cons 3 4)))
(1 2 3 . 4)
gosh> (cons 1 (cons 2 (cons 3 (cons 4 ()) )))
(1 2 3 4)
gosh> `(list 1 2 3 . 4)
(list 1 2 3 . 4)
gosh> `(list 1 2 3 4)
(list 1 2 3 4)
ですよね。
C言語風のシンタックスで使われる...をＳ式のドット対に対応させたら
いいんじゃないかって話をしたかったんですが。

>>165
S式ほど単純にはならないと思います。
表現力が上がれば上がるほど複雑になってしまいますから。
それを、できるだけ、単純に、見た目から構造が理解できるレベルに
落とし込もうと努力しているわけです。
どうも、S式とM式のように、
内部表現はCS式
外部表現はCM式みたいに２つ用意したらいいのかなぁとか、思ってきました。

>>164
47さんが考えてる言語の記法をパースする際には
普通にJavaScriptのBNFを書くようになるのでしょうか？
それとも違うのでしょうか？
>>169
コンパイル時に構文木を弄りたいし、
XML+XSLTみたいなものも作りたいです。

>>171
＞普通にJavaScriptのBNFを書くようになるのでしょうか？
基本的には

line = msg ";"
msg = IDENTIFIER ["(" [msg ("," msg)*] ")"] (line | "{" line* "}")

この２行。あとリテラルと演算子が入るけど。
ただ、

if (flag)
    expression01;
else
    expression02;

みたいな文では、msg が２つに分かれちゃうから……どうしようかな、とは考えていたり。

あ、間違えた……けど良いや。失礼しました。

>>172
else がmsgを結ぶ2項演算子としてうまく定義できればいいのかなぁ。
そこらへんが凄く重要だと思いますよ。
if(flag){expression01;}else{expression02;}
と書けるけど、
if(flag)expression01; else expressoin02;
は無理っていうのも1つの手かなと思いました。

ふたつに分かれるの自体はあまり問題ないんだけど、

if (flag01) if (flag02) expr01;
else expr02;

になっちゃうのが問題。できれば

if (flag01) { if(flag02) expr01; else expr02; }

にしたいところなのです。

その点、Pascal は優秀なのかもしれない。

if flag01 then expr01;
if flag01 then expr01 else expr02;
if flag01 then if flag02 then expr01 else expr02;

じゃあ、括弧が絶対必要か、、、
if(flag01){
if(flag02){expr01;}
else{expr02;}
}
あるいは、
if(flag01) expr01;
if(flag01) expr01 else expr02;
if(flag01) if(flag02) expr01 else expr02;
と書くようにするとよいのでは？

C に合わせようとせずに、else の動作が直前に実行された if に従うのならば、

if (flag01) if (flag02) expr01; 
else expr02; 

は

if (flag01 && flag02) expr01;
else expr02;

と等価だから、アリっつーちゃえばアリかもしれない。

突然ですが、JSON使ったプログラミング言語をさらっと作ってみました。
四則演算しかできませんが。
var program = {
body:{
body:["+", "x", ["/", "y", 2]],
x:["add", 1, "y"],
y:["mul", 4, 5],
add:{
args:["x","y"],
body:["+", "x", "y"]
}
},
mul:{
args:["x","y"],
body:["*", "x", "y"]
}
};
alert(eval(program, program));
以上のプログラムで、
mul = function (x, y) { return x * y; }
function body(){
add = function (x, y) { return x + y; }
y = mul(4,5);
x = add(1,y);
return x + (y/2);
}
alert(body());
と同様と

バカかコイツ

function eval(p, env) {
if (!isNaN(p))return p;
if (p instanceof Array) {// 関数適用
switch(p[0]) {
case "+": return eval(p[1], env)+eval(p[2], env);
case "-": return eval(p[1], env)-eval(p[2], env);
case "*": return eval(p[1], env)*eval(p[2], env);
case "/": return eval(p[1], env)/eval(p[2], env);
}
var envs = getEnv(p[0], env);
for(var i = 0; i < envs[0]["args"].length; i++) {
envs[0][ envs[0]["args"][i] ] = eval(p[i + 1], env);
}
envs[0]["parent"] = envs[1];
return eval(envs[0], envs[1]);
}
if (p instanceof Object) {
p["parent"] = env;
return eval(p["body"], p);
}
var envs = getEnv(p, env);
return eval(envs[0], envs[1]);
}
function getEnv(p, env) {
while (env != null) {
if (env[p] != null)
return [env[p], env];
env = env["parent"];
}
}
これが処理系です。

ぱっと見ただの劣化Lispなんだが･･･

C言語風にはとても見えない。

というか、1が何をしたいのかまたわからなくなった。

>>182
禿同。つーか1はプログラミング言語を作りたいんだっけ？
それともJSON言語は唯の思考実験？

へたな小細工をするよりもシンプルなS式の方が何倍も美しい
と、いろいろやってみて思う今日この頃

>>75

sbcl最高

もう飽きたようだ

>>183
思考実験てなかんじです。

JSONを参考にしてみたらってのがあったのと、
YAMLをプログラミング言語として作ったYAMPってのを
作ってた人いたなぁ思って。
飽きてないけど忙しくて、、、。

なんというか、自作のプログラミング言語を作る場合に、
:は命名演算子として扱うと何かとすっきりするんじゃないかなぁと
言う考えがあったのだけども、JSONのハッシュというか連想配列は
まさにそれだなぁと思ったので作ってみたのです。
JSON等の発展形として、配列あるいはリストと連想配列と演算子、名前付き括弧
というのもありなのかなと思ったので書いたけど混乱するだけでしたねぇ。

また別な仕様を考えてみました。これならいいんじゃないかなぁと。
Ｃ式の基本は;区切りで複数の式が書かれる。プログラム全体は`@file`()である。
括弧は無名の括弧 () あるいは、名前付きの括弧 name() が存在する。
[]は`[@]`、{}は`{@}`という名前の演算子として扱われる。
[]は`[@]`()であり、a{b;c}は`{@}`(b;c)である。
２項演算子の+は`@+@`という名前の演算子として扱われる。
1+2は`@+@`(1;2)である。
左再帰の２項演算子=は`@@=@`という名前の演算子として扱われる。
a=bは`@@=@`(a;b)である。
前置単項演算子の++は`++@`という名前の演算子として扱われる。
++iは`++@`(i)である。
後置単項演算子の++は`@++`という名前の演算子として扱われる。
i++は`@++`(i)である。
連続する括弧は最初に@のついた名前で扱われる。
例えば()()は(`@(@)`())であり、a[1][2][3]は`a[@]`(1, `@[@]`(2, `@[@]`(3)))
である。
Ｃ式においては、演算子の優先順位を１０段階で決めることが出来る。
例えば、２項演算子の+の優先順位を3としたいときは、priority("@+@"; 3)と書く。

C式において、区切り文字が,ではなく;となっているのは,はより優先順位の高いセパレータないし、
演算子として扱うことを出来るようにするためである。

main:function(a;b;c){
printf("hello world\n");
}
は
priority("@@:@", 3);
`@@:@`(main; function(a; b; c; `@{@}`(printf("hello world\n"))))
である。

キミの好きなようにしたらいいがな。

続きはblogで！

@ が多すぎるソースは、何となく受け付けないな

@じゃないとすると、何がいいですかねぇ？アンダーバーとか？？？

main:function(a;b;c){
printf("hello world\n");
}
は
priority("__:_", 3);
`@@:@`(main; function(a; b; c; `_{_}`(printf("hello world\n"))))
なかんじで。

こんなの見つけた
http://www.digitalmars.com/d/archives/digitalmars/D/13546.html

>>193
>>1は２年も前からこんなこといってるのに、この程度の成果しかできてないなんてw

>>193
たしかセバスチャンって人が作ってるんですよね。
>>194
悪かったね。それだけ、多くの人に納得してもらえる、
単純なものを作ることが難しいってことなんだと思ってます。
この程度の成果って言われるってことはそれだけ簡単ってことなので、
誉め言葉として取っておきますよ。

セバスチャン「sofu のパーサ作ったヨ」
>>1 「凄い言語ダヨ。Groovy 見た時 C みたいな言語良い思たヨ。
俺は C が好き。D のプリプロセッサにD を sofu 形式にして
マクロでプログラ(ry」
セバスチャン「何いってんのかよくわかんないけど sofu を勘違いしてない？
これは INI とか XML みたいな単なるデータフォーマットで
プリプロセッサなんてないよ。ほんとに sofu 形式から D の
プログラムを生成したいならおもしろいかもね。でもそゆ方向
は目指してないよ :) 」
>>1 「いや俺は sofu がデータフォーマットだってのわわかってるよ。
でもこれで D を表現してプログラ(ry」

会話が噛みあってないとことか、利点がまったく説明されてないあたりが進歩
がないといわれる所以ではないか。 「D -> なんかのデータ形式 -> マクロ処理 -> ...」
だけじゃ何がうれしいのかさっぱり見えないよ。

利点なんだヨ

s式は実際は普通の言語が内部に隠してる構文木そのものだから強力なんだよな
トレードオフとして絶対人に優しくはならないけどw
c 式？にもそういう意味付けがないと全然魅力が伝わらないと思うぞ

>>196
かみあってなかったですねぇ。
只のデータフォーマットですもんね。sofuは。
進歩ないってのはそのとおりなので困ってますよ。
どうしたものだか。orz...

利点は、Ｃ式を理解さえしていれば、見た目から構文木やS式が想像できる点です。
だから、ずっと、できるだけ想像しやすいものを考え出そうとしています。
Ｓ式でいう演算子と非演算子を分けて表記することで、人に優しい。

とかですね。ちゃんとまとめていかないとなぁ。

C式って、S式の上に実装するん？

> 見た目から構文木やS式が想像できる点
S式使えばいいんじゃね？

S式は想像したくないな。
見た目＝構文木となっていて、他のものを想像する必要が無いのがS式の利点なわけで、
C式見た目＝構文木でないと意味が無い。

構文木にした時点でS式なんじゃ・・

つーか1の考えるキチガイ仕様を見せられる度に思うことだが、
C言語まんまの方がイイだろ。
LISPのマクロやquoteの様な合理性は10年掛けても無理だ。

１．演算子と非演算子を分けて書いたほうがわかりやすい
(- (+ 1 2) 3)と書くよりは -(+(1,2),3)

２．括弧は複数使えたほうがわかりやすい
(define a (lambda (b c) (+ b c)))
よりも例えば
{define a [lambda (b c) (+ b c)]}
のほうが見た目で対応がわかりやすい。

３．演算子の優先順位を持たせてあったほうがわかりやすい
(+ 1 (* 2 3))よりも、1+2*3

これだけのものを、実現するためのものを考えているのです。
そのために、キチガイじみて見えるかもしれませんが、いろいろな
仕様を考えてみているのです。

現状のＣ言語とＳ式で不満がないなら、このスレを見る必要はないでしょう。

突っ込みどころが多いが、、
２も３も「よりよい」とは言えないだろ
単純さという強力な利点を犠牲にしてるから
１は意味不明
２は括弧が深くなったらどうすんだ？だいたいlisp書くとき括弧なんて視覚から消えてるよ

1.
ひとまとまりのものはひとまとまりに括弧でくくられてる方が自然。
リストは括られていて、関数呼び出しは括られていない、という不統一は、
構造の把握を困難にする。

S式では、その構造の分かりやすさを持ちつつも、関数呼び出しと単なるデータとしての
リストを、それの使われ方で区別していた。
C式でそれを実現するために上述の自然さを単に犠牲にするのでは、退化ではなかろうか。

2.
文法上の機能に違いがないものを異なる記号で表現されると分かりにくい。
S式の場合は、インデントを使って整形したりして対応を判別しやすくするわけだが、
どうせC式でも複雑な対応ではインデントを使うだろうから、単純に無駄で使いづらい
仕様ではないか？
(括弧の深さを一段ずらすと、すべての括弧を修正しなければならなくなったり)

3.
優先順位という追加の知識を必要とするのは、記述も実装も間違えやすい。
構造として明示されている場合は、間違えようがない。
(知識が確かな書き手にとっては、わかりやすいと思う。ただ、そのわかりやすさは
　分かりにくい前提知識を確かに把握するという前提を乗り越えて得られるもの。)


S式に不満があるかないかを別にしても、提案するアイデアに合理性が欠けている
と思う。「使いやすい」というのが思い込みではないと確認するために、自分で仮の言語で
数百行くらいのコードを試し書きしてみたらどうだろうか？
同内容のコードを、他のデータ形式と比較してみるとなおよいと思う。

C式なるものに圧倒的に有利な例、不完全でもアンフェアでもいいから見て見たい。

しばらく、優先順位付きの２項演算子、後置演算子を捨てて考えたいと思います。
また、括弧の連結などもいったん捨てましょう。
C言語でいうところの、関数呼び出しや、関数型言語のバリアント型みたいなやつ
に焦点を絞りたいと。
a(1,2,3,b(4,5,6),(7,8))といった記述ができるだけの言語を考えたいと。

１．リストには名前がつくほうが自然である。

物事の構造を理解するにあたって、
名前とそれに関連する事項を対としてリストアップするのが自然です。
例えば、ファイルや、全人類を把握する構造を考えてみましょう。
ディレクトリには名前がついているし、住所にも名前がついています。
ディレクトリ名を入れる特殊ファイルを用意してそのファイルの名前がディレクトリの名前とすることも出来たでしょう。
しかし、実際はそうなっていないのではないでしょうか？

全てを単なるリストとして理解するほうが不自然です。
単なるリストとして記述すると短く書くことが出来ますが、わかりにくくなります。
リストは"リスト"という名前があります。
より一般的な記述が出来るようにするには、名前付きの括弧と括弧の混在が可能な
言語を選択するとよいと言えると思います。

２．Ｃ式はわかりやすさと短さの両方の利点を持つ。

XMLは、名前付きの構造記述言語という意味ではS式より勝っています。
しかしＣ式に比べると、開始と終了時両方に名前を付けるため、助長です。
Ｓ式よりもＣ式、Ｃ式よりもＸＭＬがわかりやすいです。
変わりに、ＸＭＬよりも、Ｃ式が短く書け、Ｃ式とＳ式は同等の長さで記述できます。

1.
リストに識別子を割り当てることができる一方で、その場限りの構造について
いちいち特別に名づけることはせず、無名のリストで表現することは、合理的ですね。
Lispはそうなっていたと思います。

208で示すC式のように、構造の定義の途中にちょくちょく識別子の定義がなされるのは、
これは便利かもしれませんが、同時に、より複雑で分かりづらい定義になりますね。

それらの利点欠点がどう作用するか、データの具体的なコードと、その扱われ方の過程を、
見てみる必要がありそうです。

2.
Ｃ式では、識別子と要素の境界は括弧であり、要素の境界はカンマであり、それらで
要素の包含関係を示す構造が暗黙にあらわされるという形になっています。
識別子と要素の境界である括弧には閉じ括弧があり、これに名前がないことは、
XMLに比べて、冗長性が少ない代わりに、括弧の対応が分かりづらくなりがちだ
という難点があります。

Lispでは、関数名と引数の境界は空白であり、引数の境界も空白であり、構造は
括弧で無名のリストとして明示する形になっています。
Cのように、関数名と引数の境界と、引数同士の境界とで、いちいち区切りの
種類を変える必要がないですね。
(C式はデータ形式ですから、関数というか、マクロや型名などということになるん
でしょうが、同じことでしょう。)


やはり、C式にあるのは、利点だけではないです。勘だけで「利点が欠点を上回るから
あとは感性の違いだ」と言うくらいならわざわざスレを立てないでしょうから、具体例に
踏み込んで利点と欠点のバランスを示されるのが、議論として良い展開だと思います。

よくわからん、、とにかく例出してよ
c式、s式、xmlって比較対象がでてきたぽいから

>しばらく、優先順位付きの２項演算子、後置演算子を捨てて考えたいと思います。
>また、括弧の連結などもいったん捨てましょう。
これはひどい
つか、それならS式の単純置き換えでOKじゃん
何に対して悩んでいるのか分からん

「しばらく」とか「いったん」と言うあたり、そこは「その部分は置いといて、
こっちの話をしましょう」という意味で書いたんだと思うよ。話の上で
まず捨て置いて考えましょう、ということだろう。

面倒な部分は置いといて、Ｃ式そのものの利点・欠点と改良点を考えようよ。
……って流れなのか？　よく分かって無いんだが。

>>208
Ioじゃん

そろそろ1を絞め殺したくなってきたんだが。

>>215
まあ待て、今1が凄い勢いで議論しがいのある資料用意してるから

>>209
いや、実に参考になります。ありがとうございます。
頭悪いものなので、ゆっくり考えさせてください。

>>210
例）住所をツリー上に書く場合
Ｓ式
(日本国(○○県(○○市(○○区(○○ 1 2 3)))))
Ｃ式
日本国(○○県(○○市(○○区(○○(1,2,3)))))
ＸＭＬ
<日本国><○○県><○○市><○○区><○○><1/><2/><3/><○○></○○区></○○市></○○県></日本国>

Ｃ式とＳ式はほぼ同じ長さで書けます。
しかも、Ｃ式は名前と中身が分かれている分わかりやすいです。
ＸＭＬは長いけど、名前が最初と最後についているので何処が最後かもわかる。
例えばｘｘ県を新たに追加したい場合、
</○○県>の後ろに<××県>...と追加すればよい。
そういう意味で、よりわかりやすいと。

>>217
S 式に似ているのに、コンマという雑念が混入されて見難くなって無いか？

個人的には、『見て分かりやすい』 は単なる慣れの問題だと思う。
表記がガラリと変わるならともかく、１対１で対応されてる程度なら、むしろ , ない方がシンプルなのでは？

<1/><2/><3/>

こんなXMLは無い

>220
たしかに閉じタグの省略はあるけど、XMLなら属性つかうだろ、ってこと？
たしかにタグ名が数値で子要素なしは変

>>217
まず、その表現はそれでほんとに例として適切なのかな。

1-2-3という番地をあらわすなら、(1,2,3)と別々の3個の要素
にするんではなくて、ひとつの要素となってるはずだろう。

あと、県の属性値として県名を割り振るんじゃなくて、県ごとに
別々の要素になってるのがどうなんだと思う。県に限らんが。

　> しかも、Ｃ式は名前と中身が分かれている分わかりやすいです。
そもそもどんなデータを定義してるのか意味(意図？)がわからんから、
分かりやすいかどうかがさっぱりわからん。
分かりやすさはともかく、名前と中身が分かれているのは一番ネストの
深い場所に限ると思う。中間の階層の要素が増えたら、もうどこまでが
中身でどこが外かなんてさっぱりわからんだろ。
(加えて>208でのa(1,2,3,b(4,5,6),(7,8))なんて無名要素が許されたら、
もう何がなんだか、となると思う。)

よく見ると酷い例だな。。
まさかメタデータとデータの区別ついてないのか？
ついてるなら早く例を書き直したほうがいい。
それから〇〇県とか曖昧に書かず、実例なんだからちゃんと神奈川県とか宮城県とか明確に。

東京都千代田区永田町一丁目6-1（内閣官房内閣広報室）

住所についてぐぐってみたが、XMLであらわすとしたらこんな感じではないだろうか。
街区符号以下を細かく分ける必要があるかどうかは別問題。
<住所>
  <国>日本国</国>
  <都道府県>東京都</都道府県>
  <区>千代田区</区>
  <町域>永田町一丁目</町域>
  <街区符号>6</街区符号>
  <住居番号>1</住居番号>
</住所>

>>224
んじゃ等価なS式版。つかこれ例としちゃ階層がフラットでいまいちかもね。
(住所
(国 日本国)
(都道府県 東京都)
(区 千代田区)
(町域 永田町一丁目)
(街区符号 6)
(住居番号 1) )

>>225
んじゃ、ためしに C 式っぽいので記述

住所(
    国(日本国),
    都道府県(東京都),
    区(千代田区),
    町域(永田町一丁目),
    街区符号(6),
    住居番号(1)
)

フラットな S 式なら以下でもいいだろ…
(住所
:国 日本国
:都道府県 東京都
:区 千代田区
:町域 永田町一丁目
:街区符号 6
:住居番号 1)

例として住所はあんまりよくなかったですね。
ＣＳＶを実現しようとしてるわけではなくて、
地球(
　日本(北海道(), 東京() ...),
　アメリカ(ニューヨーク(), ハワイ(), ...)
　...
)
こういった風に書くとして、一番短くなる書き方の例をあげたのだけど。
これは、
住所 : 国
星 : name "(" {国 *} ")"
国 : name "(" {(都|道|府|県|州)*} ")"
都 : name "(" {区 *} ")"
...
といったような、定義が出来ますよね。
また、日本の県と中国の県は違うとか問題ありそうなのでよくない例だけど。
別に私は型だろうが、値だろうが名前は名前として扱うだけでいいと思うのだけど。
フラットにしたら
住所録(
　住所(地球,日本,北海道...),
　住所(地球,日本,東京...),
　住所(地球,アメリカ,ニューヨーク...),
　住所(地球,アメリカ,ハワイ...),
　...
)
とも書けるだろうけど。

>>228
住所 : 国
星 : "(" name {国 *} ")"
国 : "(" name {(都|道|府|県|州)*} ")"
都 : "(" name {区 *} ")"

これで良いやん

何がいいの？バカですか？

S式とC式の対応を考慮に入れて考え直してみました。
何がいいかというと、Ｃ言語風シンタックスをただの式としていじりまわせるところです。
といいたいのですけど、まだまだですねぇ。

�@a = a
�A(a . b) = (a... b)
�B(a . ()) = (a... ())
�C(a) = (a)
�D(a . (b . ())) = (a... (b... ()))
�E(a b) = (a, b)
�F(cons a b) = (cons, a, b)
�G(quote a) = (quote, a)
�H(quote (a b)) = (quote, (a, b))
�I'a = (< a >)
�J`a = [< a >]
�K`(,a) = [< {< a >} >]
�K`(,@a) = [< {> a <} >]
�L(msgs a (b c) ()) = a(b,c)()
�O(|[| b) = [b]
�P(|{| b) = {b}
�M(msgs a (|{| b)) = a{b}
�N(msgs (a) (|[| b))= (a)[b]
�O((msgs a (b)) c) = (a(b)c) = (a(b),c)

どこがどうCなんだそれ

c式ってどこにむかってんの？どーみても劣化s式じゃ…

迷走中です。
IOやらSmalltalkやらREBOLやら見てみてたりする今日この頃です。
下手にS式をいじってるだけの状態ですからねぇ。

並べるのにカンマを使ったり、{}や[]を使えばCのコードのように見えるだろうと思っているとしか思えない。

>>235
基本的にはそうですね。
しかし、どうやって式として扱えるようにするかはとても難しいんですよ。

現状、
[if, [=,[+,1,2],4],111, 222]
if[=[+[1,2],4],111,222]
if (=[+[1,2],4]) [111,222]
if (= (+[ 1, 2]) 4 []) 111 222 []
if (= (+ 1 2 []) 4 []) 111 222 []
(if (= (+ 1 2 []) 4 []) 111 222 [])

が等価な式というものを考えました。
さらに、
(if (= (+ 1 2) 4) 111 222)
と等価であるものにしようと考えています。

こういう言語が他にあったら、誰か教えてください。

>>236
Lisp

迷走にもほどがあるだろ
結局何したいのか最初から考え直したら？

>>236
S式と見間違えそうで嫌な感じ。

C言語風ならば最低限の文法はC言語を踏襲すべき。
キチガイでないならcshみたいな意味不明な命名はよせ。

いや、やりたいことはわかってる。
あとは、試行錯誤あるのみィィィィ！！
とりあえず、

[if,[=,[+,1,2],4],111,222]
if[=[+[1,2],4],111,222]
if(=[+[1,2],4])[111,222]
if(=(+[1,2])4[])111 222[]
if(=(+ 1 2[])4[])111 222[]
if(=(+ 1 2;)4;)111 222;
if(=[+[1,2],4])111 222;
これ全部等価な式ってことでいい気がしてきた。
.の扱いが微妙...。Ｓ式にあわせるべきか、HaskellやML系にあわせるべきか。。。

ああ、とうとう頭が・・

>>240
少なくとも、俺はそれを C 言語風とは認めたくない。

Ｃ式ちゃうやん

いっそメッセージ式にしたほうが

頭は、もう、狂ってる。
なので大丈夫ですよん。

リストの表現方法によっては、結構それっぽくなるんです。
ってことを言いたかっただけです。

メッセージ式って、オブジェクト指向の？
SmallTalk,Ioあたりですよねぇ。
SmallTalkとかはDylanを髣髴とさせるるるる。
Dylan駄目＝マクロいらん、いや、Nemerleがある的な。
いいんだよ、俺はきっと、言語の再発明が楽しいだけなんだから。
再発明の中で、1個くらい間違えて、素晴らしいのを思い浮かんだら
めっけもん。くらいの勢いですので。

SmallTalkとIoってどっちが小さいんでしょうねぇ？
Ioなのかな？？？

しばらく、頭痛いので、頭冷やしてきます。

とりあえず、Ioベースに議論しましょか。

何を議論するん？

うーむ。
Ioのメッセージ式に足りないと思えるものは何か？

�@自由な演算子の定義
�Aマクロの定義

もしも、定義する場合のシンタックスはどうしたらよいか等。

> 結構それっぽくなるんです。
俺にはさっぱりそれっぽく思えない。

>>248
それは 『足りない』 のではなく 『拡張したい』 ということなのでは？

あげ

諸君が愛したC式は死んだ!
何故だ!

ムーアだからさ。

ねじ式の方が上だったから。

医者はどこだっ！

眼医者しかないではないか。

Fortress
むむぅ。DSLに強い言語がまた1つ。

http://d.hatena.ne.jp/flappphys/20070117#p2

>>1 ｷﾀﾜァ*･ﾟﾟ･*:.｡..｡.:*･ﾟ(ｎ‘∀‘）ηﾟ･*:.｡. .｡.:*･ﾟﾟ･*!!!!!

なあなあ。今ごにょごにょしているんだけど、コメントの扱いはどうすればいいと思う？
Ｓ式みたいに無視するのか、XML みたいに仕様に内包するのか。

C言語に準ずればいい。

>257
仮想マシンみたいな半端な構文だな
やっぱどう見てもS式の方が美しい

このC式とやらができて何が嬉しいのかさっぱりわからん

>>178
今更だが
等価じゃないぞ

>>263
等価だよ。Ｃとは異なると断っている点に注意

いや創価だって。

なんだ、そうか

>264
Cとは異なるって意味が。わからん。
後者はflag01が偽でもelseが実行されて等価じゃないだろ。

178の
if (flag01) if (flag02) expr01; 
else expr02;
はCで書くとこういう風になるということでは？
if (flag01) {
  if (flag02) expr01; 
} else {
  expr02;
}

>>178
＞else の動作が直前に実行された if に従う

１：flag01 == false の時

if (flag01)   // if (flag01) が最後に実行された if
else expr02;    // else を実行


２：flag01 == true, flag02 == false の時

if (flag01) if (flag02)    // if (flag02) が最後に実行された if
else expr02;    // else を実行


３：flag01 == true, flag02 == true の時

if (flag01) if (flag02)    // if (flag02) が最後に実行された if
else expr02;    // else は実行されない


この動作と等価なＣのプログラムは >>178 の下。

ま、けっきょく紛らわしいから無しにしようって話です。はい。

>>268-269
何の説明にもなってないし
相変わらず等価じゃない。

>>270
何勝手にまとめようとしてんだ？

>>271
なぜ等価ではないのか説明してくれ。そっちが何を勘違いしてるのか全然わからん。

そうだなー。

bool cflag;
if (cflag = flag01) if (cflag = flag02) expr01;
if (!cflag) expr02;

こう書き換えれば >>178 の説明で分かるか？

あーこれは俺でも分かる。いちおう271の意思を尊重して、
答えだけ書いてはいおしまい、ってのはやめとく。

>>272
flag1とflag2と実行される式の真理値表を書いて、
どれがどう実行されるのか、ちゃんと確認してみなよ。

あー違う、これは271と同じ勘違いを俺もしてるのか。>>274はナシで。

>>272
「直前に実行したif」ってのがキモなんだよな？
で、>>268のように解釈するのは間違い、ってことだよな。

>>275
そうそう。
んで、こんな感じでややこしくて紛らわしいんで、止めたの。

>>258
超、遅いレスすまぬ。なんか、見るのが嫌になってたもんで。
コメントは仕様に含めたほうがいいと思います。
理由は、プログラミング言語のコメントから、
ドキュメントを生成など、利用する機会があるだろうから。
ドキュメントに限らず、htmlだと、scriptタグ内のプログラムはコメントで隠してあったりするように、
コメント内に、別な言語を内包するとかいったことが出来たらいいのではと。

http://f38.aaa.livedoor.jp/~sakurai/cexp/io.html
とりあえず、演算子無しの、パーサ作ってみました。

XBM/XPMみたいなデータのスレかと思って開いたら違った

JSONでおｋといわれてしまい
S式だとプログラムも含められるって感じにって方向にしてみたら
素直にS式にしとけとかECMAScriptでいいじゃんといわれてしまい
独自形式(言語)もそれをわざわざ作る意義も見出せないまま完全に迷走してはや数年

といったところか？

>>5が「JSON風にしたら良いんじゃないの」と言ったのは
『JSONはデータ形式だけど、JavaScriptの構文解析器でそのまま読める』
という程度の意味であって『JSON風の構文を持ったデータ形式』
という意味ではなかったのだが、>>1がそれを誤解して（？）
今のような流れになったのではないかと予想してみる。

でもCの構文解析器でそのまま読める汎用データ形式を作るとして、
CにはJavaScriptと違ってevalのようなものが無いから
データをどう扱っていいのか分からん。
結局はマクロだらけのトリッキーで気持ち悪いものになるか、
XBM/XPMみたいな特定用途向けの形式になるんだろうなあ。

的外れなこと書いてたらすまん。

どーでもいいんだけど、groovy markup に出会って、なんかすっきりしちゃいました。まる。

>>281
Ｃ言語そのままだと、パーサ書くのも大変です。
HTMLがSGMLベースであるように、CがBNFベースだとして、
XHTMLがXMLベースで、仮にXC言語というC言語の簡易バージョンがC式ベースで作れたらいいなと。
そういう考えの元で、じゃあ、どういった言語がいいのかな。
っていうところを永遠と考えてるわけです。
非常に参考になるのがHaskellだったりするわけです。
優先順位付きの演算子をユーザーが定義できたりするので。
演算子を定義できる言語とか、見てると関数型言語なんかが多いので
いろいろ見て回ってます。

JSONはJavaScriptでそのまま読めるというのもあるけど、
C言語で言うと、構造体や配列の初期化に似てますよね。
配列はＣ言語は{}ですがＤ言語では[]で初期化するようになってきています。
ハッシュと配列あるいはリストで構成される言語のほうが受け入れられるのであればと、
考えたら話題が進むならと思って考えてみたんですが、それもわけわからんそうですね。

ハッシュ＋動的配列だけで
書かれてるプログラミング言語を俺は知らなかったので、
適当に作ってみたら面白かったですよ。
これに演算子とか付け加えたらどうなるのかなぁって考えてたりもします。

>>282
groovy markupで満足なのかぁ。
括弧が左にくっつくパーサでHTML生成というか、
C式→HTMLのトランスレータは昔作ったよ。
でも、その仕組みはいまいちなんだよなぁ。
Relaxerみたいなものが作れるといいんだけど、難しくて作れないや。
というか、XMLとRelaxerは作者別なんだし仕様さえまとまってればいいと思うのだった。
XSLのようなアプローチもあるだろうし。

ぶっちゃけ、演算子を導入したいがためだけに整然としたデータフォーマットに手を入れるのは、
俺はあまり好きじゃないなぁ……。

っていうか、groovy markup をioに移植して
io markupとかってできんのかなと思った。

Ｃ言語をＣ＋＋に拡張とか、元のフォーマットに手を入れて拡張するってことは
よく行われることだと思うけど。

http://f38.aaa.livedoor.jp/~sakurai/cexp/xio.html
47氏が来てくれたので、
演算子定義可能なio風パーサをさらしてみます。
ioっぽい言語->json
みたいなこともしてます。
てきとうに、ioの拡張言語なのでxioとか言う名前にしてみたです。
=,addとsubとmulとdivが中置演算子で定義されてます。

n = 1 add 2
exp(msg(n),msg(=,arg(exp(msg(1)))),msg(add,arg(exp(msg(2)))))

なんかすごいねぇ。
asign("n", add(1, 2)) になるのかと思いきや。

> HTMLがSGMLベースであるように、CがBNFベースだとして、
> XHTMLがXMLベース
この対比は明らかにおかしいだろ。
なぜ誰も即座に突っ込まない？

ioの仕様みて作ってったらそうなってしまいました。
うわぁ、オブジェクト指向だなぁと。

=がasignって、名前になるには、
infix("=","asign",10)
とかってやれればできると思うのでそうやって見るのは手だなと思いました。

http://f38.aaa.livedoor.jp/~sakurai/cexp/xio2.html
とりあえず、=はassign、+はaddとかになるようにしてみたよ。

asign じゃないや。assign だ。
とりあえず、むやみに複雑にするんじゃなくて、WYSIWYG + Do Little な考えにするのが良いと思うんですよ。

>>288
まぁ、そうですね。BNFを拡張した言語がCなわけないんで。
なんと表現するのがベターなんすかねぇ。

>>291
このＣ式にかぎればできるだけシンプルなのがいいと思ってます。

http://f38.aaa.livedoor.jp/~sakurai/cexp/xio3.html
パーサ内部で、infixっていう関数を呼んで関数登録できるようにしてみました。
チェックとか適当ですが。
あとはinfix("+","add",2)とかいうのをパース中にみつけたら、
この関数呼ぶようにしたら良いと。
あと、xio2str関数で、そのままメッセージ式を出力してみてます。

とりあえず、
47氏が満足するものを作ってみようと思いますので協力お願いします。

http://f38.aaa.livedoor.jp/~sakurai/cexp/xio4.html
内部的に、msgってのと、argってのはなくすのと、
演算子の展開は、メッセージ風ではなくて、関数呼び出し風にしてみました。
name=a+b*c/4
length=1
parent=0
が、
assign(name,add(a,div(mul(b,c),4)))
assign(length,1)
assign(parent,0)
と表示されます。

Io のメッセージ式を改変するオブジェクトを、ちょっと実装してみようと思う。
ちょうど XML & XSLT というか、正規表現の match & replace みたいに

message(foo bar(baz)) match(bar($1))
=> $1 = baz

message(foo bar(baz)) replace(bar($1), far($1))
=> foo far(baz)

な感じに。

けど、メタ変数とかワイルドカードとかの指定が難しいんだけど、このあたりどうしようか……
ってそもそも相談できる相手がこのスレに居るのかどうか……。

おおー、やっと話が進んだようオウ（涙
むかし、schemeスレで教えてもらったんだけども、
http://www.geocities.jp/m_hiroi/xyzzy_lisp/abclisp22.html
このパターンマッチングを利用するくらいだと簡単でした。
dylan,nemerleのマクロ、schemeのマクロを参考に、
式を出力するプログラムにしようと思って実装中力尽きたってのもあったりします。