【PHP,Python】ｽｸﾘﾌﾟﾄ,ﾊﾞﾄﾙﾛﾜｲﾔﾙ37【Perl,Ruby,JS】
レス数が1000を超えています。これ以上書き込みはできません。
0001デフォルトの名無しさん
2013/08/18(日) NY:AN:NY.AN【PHP,Python】ｽｸﾘﾌﾟﾄ,ﾊﾞﾄﾙﾛﾜｲﾔﾙ36【Perl,Ruby】
http://toro.2ch.net/test/read.cgi/tech/1374371254/
0002デフォルトの名無しさん
2013/08/19(月) NY:AN:NY.AN0003デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN0004デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN0005デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.ANhttp://dictionary.goo.ne.jp/leaf/ej3/11830/m0u/
[名][U]
1 体積, 容積, 大きさ, かさ, 大きい［かさばっている］こと, 巨大；[C]巨大な人［動物, 物］；巨体；((形容詞的))大量の, 大規模な
bulk buying 大量購入
bulk production 大量生産
bulk sale （不良債権の）【【【【一括】】】】売却.
2 ((the ?))（…の）大部分, 大半((of ...))
The bulk of the work was finished. 仕事の大半は終わった.
3 [U]（船の）積荷；（船荷の）ばら荷.
4 繊維質の食べ物. break bulk
積荷を降ろし始める.
in bulk
(1) 大口で, 大量に.
(2) ばら荷で, 梱包しないで.
━━[動](自)
1 大きくなる；（数量が）増大する, かさばる, かさむ((up))；（集合して）大きくなる, （…の）かたまりになる((into, to ...)).
2 ((文))［bulk large］大きく見える；重そうである；重大そうである
The subject bulks large in his mind. その問題は彼の心に大きくのしかかっている.
3 〈紙・ボール紙などが〉かさがある.
━━(他)
1 …をかさばらせる, 重く［大きく, 分厚く］する［見せる］((out, up)).
2 …をいっしょにする, 混ぜる.
3 （太るために）たらふく食う((up)).
［スカンジナビア語. 原義は「船の荷」］
0006デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN名詞としての「bulk」のイディオムやフレーズ
break bulk in bulk
【動詞】 【自動詞】
1〔動詞(+up)〕
aかさばる.
bかたまりになる.
2〔+補語〕[通例 bulk large で] 〈大きく〉見える; 〈重要に〉思われる.
用例
The trade imbalance bulks large in our minds. 貿易不均衡が大きな問題であるように思える.
【他動詞】
1〈…を〉かさばらせる.
2〈ものを〉ひとまとめにする; 一括する.
0007デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN> >>995
> その変数が格納しているものと名前の関係を教えてくださいな
> 特に別の型の変数を代入して使いまわしている事について
>
> 俺はそういう事するのは汚いコードだと思うんだけど
> いくら言っても汚くない綺麗だって言うからさ
どこのコードが知りたいの？
0008デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN// Mutifunctional method to get and set values to a collection
// The value/s can optionally be executed if it's a function
access: function( elems, key, value, exec, fn, pass ) {
var length = elems.length;
// Setting many attributes
if ( typeof key === "object" ) {
for ( var k in key ) {
jQuery.access( elems, k, key[k], exec, fn, value );
}
return elems;
}
// Setting one attribute
if ( value !== undefined ) {
// Optionally, function values get executed if exec is true
exec = !pass && exec && jQuery.isFunction(value);
for ( var i = 0; i < length; i++ ) {
fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
}
return elems;
}
// Getting an attribute
return length ? fn( elems[0], key ) : undefined;
},
0009デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN> 特に別の型の変数を代入して使いまわしている事について
他の言語の言うところの
オーバーロードの話ですか？
引数の型によって処理を変えること。
0010デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN0011デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN0012デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.ANhttps://github.com/jquery/jquery/blob/master/src/core.js#L658
// Multifunctional method to get and set values of a collection
// The value/s can optionally be executed if it's a function
access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
var i = 0,
length = elems.length,
bulk = key == null;
// Sets many values
if ( jQuery.type( key ) === "object" ) {
chainable = true;
for ( i in key ) {
jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
}
// Sets one value
} else if ( value !== undefined ) {
chainable = true;
if ( !jQuery.isFunction( value ) ) {
raw = true;
}
0013デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN// Bulk operations run against the entire set
if ( raw ) {
fn.call( elems, value );
fn = null;
// ...except when executing function values
} else {
bulk = fn;
fn = function( elem, key, value ) {
return bulk.call( jQuery( elem ), value );
};
}
}
if ( fn ) {
for ( ; i < length; i++ ) {
fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
}
}
}
return chainable ?
elems :
// Gets
bulk ?
fn.call( elems ) :
length ? fn( elems[0], key ) : emptyGet;
},
0014デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN引数の数が違う場合に、引数の値の位置をずらすのは
型がない言語でオーバーロードを実現するテクニック。
このコードはkeyがあるかないかで、
引数の位置が変わっている。
0015デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN俺が三項演算子苦手だからとかいうアホらしい理由じゃ無しに。
そこだけかよ指摘点。
0016デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN引数ずれてないじゃん。
そもそも使いまわしてるのは局所変数だから全然関係ない。
0017デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN直してもコード可読性じゃなくて圧縮率の話をし始めて
その上の話で圧縮プログラム名出せって言っても無視
そんな奴にまともに取り合うわけ無いだろ
0018990
2013/08/22(木) NY:AN:NY.ANbulkは引数の関数fnが「要素全体（elems）」を引数に取る場合はtrue,
関数fnが「単独の要素（elem[i]）」を引数に取る場合はfalseになる。
以下のURL時点でのコードで解説するよ。
https://github.com/jquery/jquery/blob/6318ae6ab90d4b450dfadf32ab95fe52ed6331cb/src/core.js#L658
たとえば683行を見てみよう。fn.callの引数にはelemsを渡しているね。
これは680行の条件分岐を見ればわかるように、bulk==trueの場合に実行される行だ。
次に706行～708行を見てみよう。
やはりbulk==trueの場合にはfn.callの引数にはelemsを渡しているね。
そしてbulk==falseの場合にはfn.callの引数にはelems[0]を渡している。
つまりbulkはfnがelemsを受け取るタイプなのか、elems[i]を受け取るタイプなのか、ただそれだけの簡単な変数なんだ。
そしてこれはbulkとは関係ないことだけど、683行と707行を見比べてほしい。
何か気づかないかな？ヒントは673行だ。
そう、これはセッターとゲッターなんだ。
valuesが存在するときはセッターとして683行を実行し、それから707行のゲッターを実行してセット後の全要素を返す。
valuesが存在しないときはゲッターとして707行を実行だけして返す。
チェックするポイントを絞るととっても簡単なコードであることが理解していただけただろうか？
0019デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.ANそのbulkになんでかfnが代入されてるけどfnとbulkという用語の関係は？
その上で型を区別せずに一つの変数を使いまわす事について
コードが綺麗だと言える理由は？
>そしてこれはbulkとは関係ないことだけど、683行と707行を見比べてほしい。
本当に関係ないな
それにfnがgetterかどうかなんてこのコードだけじゃわからないよ
fnの動作を見なきゃ
0020デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN0021990
2013/08/22(木) NY:AN:NY.ANfnは引数の数でゲッターとセッターを区別する仕様になっていなければならない。
bulk処理の時は引数0個と1個で区別、bulk処理でない時は引数1個と2個で区別。
bulkにfnを代入しているのは引数valueが関数である時は関数の実行結果をセッターの値として渡すため。
697行を見ればわかるよ。raw==true、つまり引数valueが関数ではないときは単純な値をセッターに渡しているけど、
raw==falseのときは関数の実行結果をセッターに渡している。
それと>>18に少しだけ間違いがあったな。
些細な間違いだからコードを理解してる人にしか間違いは指摘できないだろう。
四捨五入して20文字の誤った記述があるからコードを理解した人は指摘してみてね。
0022デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.AN使いまわした後の話でなく、使いまわすことそのものの是非を聞いてる
もちろん変数宣言とコードをケチってるだけだというのはわかるが
明らかに別々の場所で異なる役割を1変数に与えてるから(俺は)汚いと言ってる
記述量が少なくなるという話でなく
そのコードが綺麗であると主張する理由だぞ
>raw==true、つまり引数valueが関数ではないときは
そのrawも指摘しようとしてた部分なんだが
rawの意味やその型がbooleanしか取らない事は
valueとの関連だと気づくまでわからない
だから可読性を考えればせめてisRawかisRawValue
そしてこうやって解説することはそれだけ理解を早めるために
別の情報がいるという事を証明している事になるがそれについてはいいのか？
0023デフォルトの名無しさん
2013/08/22(木) NY:AN:NY.ANだから、それは引数がずれているだけ。
オーバーロード的な使い方をする場合に、
関数呼び出しの際に引数の数が違うことによって、fnに関数が入っておらず
fnにオブジェクトが入っているから、bulkにfn（オブジェクト）を移動し、
fnに関数を入れることで、正しい引数に入れ替えている。
使い回しではなく、正しい引数に調整している。
0024990
2013/08/22(木) NY:AN:NY.ANもともと俺が来たのは前スレで「bulkの意味答えてみ」と言われたから。
その意味については>>18で完全に説明できたと思うから、
コードの可読性とか汚さとかにはあんまり興味がないんだ。
俺は前スレからコードの可読性については何も言ってないよ。
可読性について何か言ってたのは別の人。
0025デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANfnには常に関数が来るっつーの
> bulkにfn（オブジェクト）を移動し、
fnがオブジェクトだったら直後のbulk.callできねーだろうが
0026デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANこれの本質はthisのバインディング
ただし旧ブラウザのためにbindの代わりにクロージャを使ってる
そのクロージャとしてbulkを使いまわしてる
0027デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANああよく見りゃ本当だｗ
じゃあ話は早い。
fnもbulkも関数だ。
bulkにfnを入れているのは、
関数を別の関数でラップしているだけ。
つまり、
bulk = wrap(bulk)
これを実行しているだけじゃないか。
使い回しではなくて関数を加工しているだけだ。
0028デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANなるほど理解できた
ちなみに間違いってのはbulkのtruthy/falsy？
それともfnの引数ってところ？
いずれにしろ丁寧に答えてくれて感謝する
0029デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.AN0030デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANthisバインドしてるんじゃなくてwrapしてるだけだな
ついつい勝手にthisのクロージャのイディオムとして読んでしまった
0031デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANこのaccess関数を全く同じ動きのまま、
綺麗に書きなおして欲しいんだが
まあ汚いって書いた奴はもうでてこれないかな。
0032デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.AN汚かったって話で終わりなはずなんだけどなあ
0033デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.AN>このaccess関数を全く同じ動きのまま、
>綺麗に書きなおして欲しいんだが
でも変数宣言変えただけで別の動きだと騒ぐんでしょう？
0034デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.AN技巧的なコードであり、説明が必要だが、
シンプルで無駄がないコード。
char *strcpy(char *s1, const char *s2)
{
char *p = s1;
while (*s1++ = *s2++)
;
return (p);
}
0035デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.AN0036デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANchainable なら elems、
bulk なら fn.call( elems )、
length なら fn( elems[0], key )
それ以外なら emptyGet;
って自然に読めると思うんだけど？
0037デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANネストが問題なだけ
ネストするとtruthyとfalsyの境界がわかりにくくなる
0038デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANreturn
}
：
：処理が続く
：
っていうのは、関数の始めのほうで見なくて良いコードを
見なくて済むように、処理を打ち切るとか
インデントを深くさせないために使うけど、
関数の最後でやっても意味ないよなぁ。
0039990
2013/08/23(金) NY:AN:NY.AN> セッターとして683行を実行し、【それから707行のゲッターを実行して】セット後の全要素を返す。
↓正しくは
> セッターとして683行を実行し、セット後の全要素を返す。
セッターの時は必ずchainable = trueになるので707行に行くことはない。
0040デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANchainable ? elems : bulk ? fn.call( elems ) : length ? fn( elems[0], key ) : emptyGet;
0041デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.AN0042デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANいや、とても分かりやすい
？のところで戦いが起こって、脱落して行き、右側に行くほど
生き残ってる様子がよく分かる
0043デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANスーパースターのプレーを「この下手くそ」ってテレビの前でdisってる
バカおやじに似てる
0044デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANdisるとか言ってるのお前だけだからな？
それと自分と作者を重ねてるみたいだけど
お前はその作者じゃないっての
0045デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANバリバリのMSの社員もいるわけで、玉石混淆なのは想像に難くないな
0046デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.ANこの話の元となったblogではdisってますが何か。
0047デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.AN少なくともjQueryのソースにコミットされたコードは
スーパープログラマのレビューに通ったコードだわな
0048デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.AN適当なのがある程度許されるのはwebワールドだからこそで
MS社内で例のコード書いたらさすがに怒られるよ
0049デフォルトの名無しさん
2013/08/23(金) NY:AN:NY.AN0050デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.ANGoogle社員はMS社員より格上ですか？
0051デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.AN少なくともそういう次元をはるかに越える人たちであるのは
間違いない
0052デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.ANプログラミング能力的にはMSに遠く及ばない
プロダクトを継続して開発続けられないレベル、ウンコ
0053デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.AN( ´_ゝ`)ﾌｰﾝ
0054デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.AN長い間開発してるものは必然的に沢山あるだろうよ
まあしかし、Googleもここにいる奴らがおいそれと軽々しく叩ける
しろもんじゃないな
一般人が「レアルマドリードに比べてバルサは糞」とか、
「巨人に比べて楽天は糞」とか、
そういうこと言ってるのとだいたい同じw
0055デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.ANなった奴が次から次へと入社していくじゃん
東大のプログラミング一番できる人たちも軒並みmsじゃなくてGoogleらしいし
0056デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.ANjqueryを絶賛しているのだが
http://weblogs.asp.net/scottgu/archive/2008/09/28/jquery-and-microsoft.aspx
つか、MSは積極的にjQueryを採用してるだろw
MS教の信者がjQuery叩いてるみたいだけど、教祖様は逆に絶賛してるぞ
どうするんだ？w
0057デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.AN0058デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.ANjQuery全否定してることになってるらしい
なんかどこかで見たことある光景
0059デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.AN権威主義で所属してるわけでもない団体の権威を振りかざして中身を語る
0060デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.AN元のブログはどう見ても、「一部例として抜き出しますけど、これがjQueryですか？
助けてー」なんて
全体を否定する論調なんだが
0061デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.AN単に英語力が無いだけだよねw
0062デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.ANなんでそいつに同調してることになってるんだよ
もしかして元のブログの奴だと思ってたの？
0063デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.AN「作者といっても色々いる。ポリシーもそれぞれ」て言ってるだけだろw
0064デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.ANその辺のポリシーはある程度統一されてるよ
開発チームになるには、承認が必要だし
0065デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.ANうわぁ...
0066デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.ANどうした？ネイティブなら簡単に想像がつくコメントを
英語の苦手な日本人が勘違いして叩いたというイタイ事例だよ
0067デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.AN0068デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.AN自覚ねえのかよ
それとも盛り上げようとしてくれてるのか？
0069デフォルトの名無しさん
2013/08/24(土) NY:AN:NY.AN見てきたけどかなり自由度高いよ
GoogleやMSと比べられるような内容じゃないな
0070デフォルトの名無しさん
2013/08/25(日) NY:AN:NY.ANマジ比較にならんけどなー
あんなんで凄いと崇めてる奴マジうけるわー
0071デフォルトの名無しさん
2013/08/25(日) NY:AN:NY.AN0072前スレ367
2013/08/25(日) NY:AN:NY.AN整理、加筆してマトメた記事を公開しました
・関数型プログラミングにおけるクイックソート・アルゴリズムの実装
http://www.h6.dion.ne.jp/~machan/misc/qsort-in-fp.html
http://www.h6.dion.ne.jp/~machan/misc/qsort-in-fp.epub
記事の結論としては、Ruby/JavaScript/Pythonともに、それら言語の特徴を生かしたスタイルを貫けば、
(「式指向」を含む)「関数型プログラミングの適性度」に明らかな差異は見られず、
あとは開発者の(主観的な)「好み」で選べばいいという、平凡なものとなっています
0073デフォルトの名無しさん
2013/08/25(日) NY:AN:NY.ANこれはよくまとめたな
0074デフォルトの名無しさん
2013/08/26(月) NY:AN:NY.AN無断転載だろこれ。
0075デフォルトの名無しさん
2013/08/26(月) NY:AN:NY.AN2chまとめブログなんて腐るほどあるわい
0076デフォルトの名無しさん
2013/08/26(月) NY:AN:NY.AN開いたが問題ないだろ。
コードは2chと同じ物があるのかもしれないが、まとめサイトでない。
0077デフォルトの名無しさん
2013/08/27(火) NY:AN:NY.AN0078デフォルトの名無しさん
2013/08/27(火) NY:AN:NY.AN死ねやお前らw
0079デフォルトの名無しさん
2013/08/27(火) NY:AN:NY.ANTOEICはゲーム
英語の勉強にはならん
0080デフォルトの名無しさん
2013/08/27(火) NY:AN:NY.ANそういうことは、950点超えてから言え
0081デフォルトの名無しさん
2013/08/28(水) NY:AN:NY.ANnode.jsはイベント型で同期ではない非同期のプログラミング言語。
しかもシングルスレッド。
制限が大きく用途によっては全く使い物にはならんよ。
C言語のようなことができないのだからな。
0082デフォルトの名無しさん
2013/08/28(水) NY:AN:NY.AN>>77
Chromeのエクステンション入れて、一文字ずつマウスカーソルあてながら
よめば、栄研準2級のおれっちでも、技術文書よめるお（ ´ω｀）
0083デフォルトの名無しさん
2013/08/28(水) NY:AN:NY.AN0084デフォルトの名無しさん
2013/08/28(水) NY:AN:NY.ANgooの英和辞典のサイトとかで調べながらやってるな。
Excelの升目に単語と意味をタブで猛烈にタイプして
重要そうな単語はおぼえていります。
0085デフォルトの名無しさん
2013/08/28(水) NY:AN:NY.AN0086前スレ367
2013/08/28(水) NY:AN:NY.AN具体的には、Python/JavaScriptを「壁5. 式指向の壁」の上へ移動しました
FP
---- 壁0. 変数の壁 ----
Haskell
---- 壁1. 純粋性(副作用)の壁 ----
F#/OCaml/SML/Scala
---- 壁2. 型推論の壁 ----
=====<< 越えられない壁 >>=====
Erlang
---- 壁3. パターンマッチの壁 ----
Common Lisp/Scheme/Ruby1.9
---- 壁4. 末尾再帰最適化の壁 ----
Emacs-lisp/Closure/Smalltalk/Python/JavaScript/Ruby1.8
---- 壁5. 式指向(条件判定式)の壁 ----
(**** C++/Java/C#/Perl...etc ****[暫定]**** )
---- 壁6. ラムダ式の壁 ----
C
「暫定的」という言葉ですが、壁5. と 壁6. の間の言語グループについて、
式指向の壁を越えているか否かの判断が未確定であることを意味します
これらの言語についても、式指向の条件(前スレ#887)を満たしていれば
PythonやJavaScriptと同様に上げたいと考えています
個人的にはコードを期待しますが、特に無ければこの議論も終息するでしょう
0087デフォルトの名無しさん
2013/08/28(水) NY:AN:NY.ANC#はほぼJavaScriptのスーパーセットだ
JavaScriptが式指向()でC#がそうでないというのは意味不明
0088デフォルトの名無しさん
2013/08/28(水) NY:AN:NY.ANMLならともかくScalaの型推論は別にC#あたりに比べて威張れるレベルじゃなかった
気がするが
0089デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.ANわかると思うがorderbyはグループのソートに使ってるだけだぞ
static IEnumerable<T> QSort<T>(IEnumerable<T> xs)
where T : IComparable<T> {
var part =
from e in xs
let c = e.CompareTo(xs.First())
group e by c < 0 ? -1 : c == 0 ? 0 : 1 into p
orderby p.Key
select p.Key != 0 ? QSort(p) : p;
return xs.Count() <= 1 ? xs : from p in part from e in p select e;
}
0090デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.AN0091デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.AN動的型のスクリプト言語をテキストエディタで書くのとは比較にならない
0092デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.AN0093デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.ANCommon LispはANSI規格で末尾再帰最適化は規定されてないので、一段下にしないと。
末尾再帰最適化をするかどうかは処理系依存で、実際にstack overflow出す処理系もある。
0094デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.AN0095デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.AN【PHP,Python】ｽｸﾘﾌﾟﾄ,ﾊﾞﾄﾙﾛﾜｲﾔﾙ36【Perl,Ruby】
http://toro.2ch.net/test/read.cgi/tech/1374371254/444
> あと、Common Lispは末尾再帰最適化する処理系が多いのに、
> デフォルトで末尾再帰最適化がオフのCRubyより下に居るのも変だと思うよ
0096デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.ANreturn from p in part from e in p select e;
でいいはず
0097前スレ367
2013/08/29(木) NY:AN:NY.ANScalaの型推論がML未満なのはオブジェクト指向(部分型)との混在を
許す設計方針なのだと推測していますが、やや甘い判断なのかもしれません
あえて壁を設けるなら「パラメタ多相を完全に実現」のような感じなると思いますが、
Scalaだけを下げるだけのために壁を設けるのは、大人げないような気がします.....
>>89
他の言語のコード(>>72)では、条件分岐はソート終了判定と大小判定の２ヶ所だけです
それに対して>>89では４ヶ所ありますが、他の言語と同じように書き直せませんか？
このクイックソートというお題は、C#であれば素直に書き下せる程度のレベルですが、
LINQに無理にこだわることで、かえってコードの可読性を悪化させているように見えます
C#にとってLINQが大きな個性(特徴)であるのは理解しますが、TPOを考えませう
>>93
すでに>>95がレスされていますが、
前スレでメジャーなCL処理系では実装されてると反論があり、この位置にしています
あえて壁を設けるなら「TCOが言語仕様規定(=実装非依存)」ですが、細かすぎるかと思います
0098デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.ANwhere T : IComparable<T> {
var part = xs.Skip(1).ToLookup(e => e.CompareTo(xs.First()) < 0);
return xs.Count() <= 1 ? xs
: QSort(part[true]).Concat(xs.Take(1)).Concat(QSort(part[false]));
}
ほらよ
0099デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.ANリーナス・トーバルズ 1969年生まれ Linuxの開発者
0100デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.ANんで、>>99は何の開発者な訳？
0101デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.ANstatic IEnumerable<T> QSort<T>(IEnumerable<T> xs)
where T : IComparable<T> {
return xs
.GroupBy(e => Math.Sign(e.CompareTo(xs.First())))
.OrderBy(p => p.Key)
.Select(p => p.Key != 0 ? QSort(p) : p)
.SelectMany(p => p);
}
0102デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.ANRubyで関数型っぽく書く場合には好まれるスタイルだと思うけど
0103デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.ANその流れを組むlinqも当然ながら糞
書いてる本人が本当は気づいてると思いたい
普通に書いた方が早いということに
0104デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.AN> Rubyで関数型っぽく書く場合には好まれるスタイルだと思うけど
は？なんでRuby？
こういうスタイルを知ったときの言語がたまたまRubyだったから知ったかぶりしてみただけ？
0105前スレ367
2013/08/29(木) NY:AN:NY.ANdef quicksort(xs)
xs.group_by { |x|
x <=> xs[0]
}.sort { |(key1, _), (key2, _)|
key1 <=> key2
}.map { |key, val|
if key == 0 then val else quicksort(val) end
}.flatten
end
[ご参考]
・Matzにっき(2006-01-28)
http://www.rubyist.net/~matz/20060128.html
0106デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.ANその批判はまさにActiveRecordのことだろ。
LINQって別にSQL書くためだけに使う言語じゃないぞ。
C#にはLINQオブジェクトとして使えるインターフェイスを実装したクラスが腐るほどあるんで、
これによって静的言語なのに、VSのインテリセンスと合わさってものすごく楽に書けるというのがLINQの本質。
ただ文字列に対してもインテリセンスでLINQのメソッドが大量に出てきてたまにうぜーと思うけど。
RubyにActiveRecordがついても対して革命は起きなかったつーかむしろActiveRecord専用の記法覚える手間が増えただけだが、
C#にLINQがついたことはまさに革命。
0107前スレ367
2013/08/29(木) NY:AN:NY.AN了解です、C#が「式指向の壁」を越えたと判断し、
>>86の次回更新時に反映させることを約束します
なお、引き続き他の言語のコードも期待します
0108デフォルトの名無しさん
2013/08/29(木) NY:AN:NY.ANスレタイ読める？
0109デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN0110デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN少なくとも、Quicksortはそうじゃなかったみたいだね
0111デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.ANSQL版のQuicksortってどれですか？
0112デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.ANは？なんでSQLで手続きの記述って発想が出てくるの？
0113デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN> あえて壁を設けるなら「TCOが言語仕様規定(=実装非依存)」ですが、
それでいい。
> 細かすぎるかと
違うだろ。Rubyを壁の下に落としたくないからだろ？
0114デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.ANそんなことないだろ
例えばPythonでは和集合は単に A | B と書くし差集合は A - B と書く
select a from A union select b from B
のように書かないといけないSQLのどこが簡潔なのか
0115デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN直積は？外部結合は？
0116デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.ANこいつ何様なんだよｗ
ボクちゃんの判断はスゴイんだぞぉーってかｗ
0117デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN直積は単に [(a,b)|a<-A, b<-B] とか A.product(B) とかだろ
外部結合は一般的な集合演算ってよりは関係代数、しかも関係代数から見ても
異端の存在じゃん
0118デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.ANselectを書く必要があるのが冗長
0119デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.ANSQLでも正規表現でも
0120デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN0121デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.ANdef qsort(xs)
xs.group_by{|e| e <=> xs.first}
.sort_by{|k,v| k}
.flat_map{|k,v| k.zero? ? v : qsort(v)}
end
0122デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.ANqsortに置き換えたら良いのに
0123デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN0124前スレ367
2013/08/30(金) NY:AN:NY.AN既にTCOの壁があるのにあえて壁を細分化したいのなら、
型推論の壁も細分化しないと不平等でしょうね
結果的にはScalaを下げるために壁を設けることになりますが....
0125デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.ANもともと簡潔な記述のためにとんでもなく無駄な処理をしているのだから
今更3要素のソートくらいでガタガタ抜かすな
0126前スレ367
2013/08/30(金) NY:AN:NY.AN関数内関数宣言の代わりに「ラムダ式を入れ子にした」以下のコード:
lambda pivot = xs[0]:
(
lambda (littles, bigs) = partition(xs[1:], lambda x: x < pivot):
quicksort(littles) + [pivot] + quicksort(bigs)
)()
)()
この箇所、できるのなら以下のように書きたかったが、
(構文としては正しいけれど)実行時に変数 pivot が未定義エラーとなってしまう
これは局所変数宣言をラムダ式の仮引数のオプション式で代用している為
lambda
pivot = xs[0],
(littles, bigs) = partition(xs[1:], lambda x: x < pivot): # この行で実行時エラー
quicksort(littles) + [pivot] + quicksort(bigs)
)()
ところが>>72の記事を見ればわかるように、Python以外の言語は(ラムダ式を入れ子にせずとも)
すべて１つのラムダ式内で変数 piviot/littles/bigs を「何の苦もなく」宣言できる
>>113
もし壁の細分化にこだわるなら、「ラムダ式の壁」の細分化も賛同してくれますよね？
0127前スレ367
2013/08/30(金) NY:AN:NY.AN・各コードの最終行 ")()" は不要なので削除
・中盤にある「オプション式」を「デフォルト値の評価式」に変更
0128デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.ANこんなの翻訳しちゃう人が公正な判断なんてできるわけ無いでしょ
0129デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.ANシーケンスの遅延評価の壁も必要ですよね
0130前スレ367
2013/08/30(金) NY:AN:NY.ANRuby使いの一人から見たLINQ：
・RubyならEnumuerable(列挙可能)をメソッドチェーンで繋げば、
LINQと同じことができるよね(>>105で実証)
・LINQを初めて知った人であれば>>89,101が魔法の呪文に見えて感動するかも
しれないけど、LINQってそれほど最先端の技術という訳じゃないんだよなあ
たとえば>>105のMatzにっきは2006年だし、そこでは効率の問題が指摘されている
そして、その課題は(Ruby1.9のEnunuratorを経て)Ruby2.0のEnumuerable#lazyで解決を見た
RubyはLINQを否定する気は無く、逆に強く意識して進化しているような気がする
Ruby 2.0 メモ: Lazy と LINQ とループ融合
http://www.oki-osk.jp/esc/ruby/20-lazy.html#5
・同様に、ActiveRecordもLINQの影響を受け、LINQ風の問い合わせ式を
メソッドチェーンで記述する Arel へと進化をとげた
第43回 Rails 3を支える名脇役たち その1 - Arel -
http://gihyo.jp/dev/serial/01/ruby/0043
・どちらにしても、Rubyでは「LINQ式」のような大きい言語仕様追加は必要とされていなかった
これは、Rubyという言語の強い柔軟性(ただしLisp族には負けるが...w)を実証していると思う
・>>102は何か勘違いしているようだけど、RubyのメソッドチェーンでLINQ風の
クイックソートは「書ける」が(>>72と比較すると)「読みづらい」から好まれない
何とかとハサミは使いようという言葉があるように、
メソッドチェーンもそれが効果的な場合には積極的に使うけど、
そうでなければ無理して使うべきではないと考える
>>105は好ましくないRubyコードで、同様に>>89,101は好ましくないC#コードだろう
0131デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN・Ruby2.0, Scala, C#あたりは問題なし
・2.0未満のRubyは絶望的
・JavaScriptはリストの連結などをyieldで実装し直す必要があり
多くの実装で動作せず式指向()の条件も満たさなくなる
・Pythonはitertoolsで連結とreduceを置き換えればいけそう
こんな感じかな?
誰かコード書いてくれ
0132前スレ367
2013/08/30(金) NY:AN:NY.ANX: RubyならEnumuerable(列挙可能)をメソッドチェーンで繋げば、
O: RubyならEnumuerable(列挙可能)なオブジェクトをメソッドチェーンで繋げば、
0133前スレ367
2013/08/30(金) NY:AN:NY.ANでは、まず簡単なお題で>>128(w の「自然数の2の倍数から構成されるシーケンス」から：
以下はRub2.0のコード
(1..Float::INFINITY).lazy.map { |x| x * 2 }.take(10).to_a
=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
0134デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.ANそんなに読みづらいか?
そう不自然なことはやってるわけでもないと思うけどな
まあkey==0のときの場合分けだけはちょっとアレだが、
見た目が異質だから理解に時間が掛かるだけだろ
0135デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN式志向の話をしてるんだろ
それなら、lambdaが問題なんじゃなくてlet式が無いのが問題
let式が無いからlambdaで代用するしかない
同様にletの無いRubyのコードもJavaScriptのコードも
Lispで言ったらprogn/begin相当の、ずらずら文を並べていて
つまりそれらの文が逐次的に実行される、その順序性に依存した
手続き的なコードになってるだろ
「式志向的」とは言えないな
0136デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN0137デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN必死になって頑張ってる姿は哀れ
0138前スレ367
2013/08/30(金) NY:AN:NY.AN式指向の壁とは無関係な、別の話題だよ
式指向については、JavaScriptの三項演算子やPythonのif式であっても
クイックソートは「実装できる」という客観的な結論になって終わった、と思っている
今回は「ラムダ式(内部で局所変数宣言ができる)」という、ラムダ式の壁を細分化する些細な話
実現方法は、言語の個性に応じて最適なものを選択すればいい
たとえばHaskellならwhen節、SMLならlet式、Rubyならブロック、JSなら関数宣言がある
ところが、ナゼかPythonのラムダ式にはそれが欠けているから
「ラムダ式を入れ子にする(>>126上段)」というテクニック(魔術？)が必要になる
もし同じインデントベースなHaskell風の構文を導入すれば、以下みたくなってステキなのに....
lambda:
quicksort(littles) + [pivot] + quicksort(bigs)
where:
pivot = xs[0]
(littles, bigs) = partition(xs[1:], lambda x: x < pivot)
0139デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN0140前スレ367
2013/08/30(金) NY:AN:NY.ANC#のLINQにしてもRubyのメソッドチェーンにしても、
最初の分類操作(C#のGroupBy, Rubyのgroup_by)の返す値が、
より小さい(<)/等しい(==)/より大きい(>)を要素とする
列挙可能(enumerable)な列(sequence)であることを前提にしている
しかし、これは数学的直感では列ではなく「三つ組(triple)」を意味しているはずだ
そして組をその要素の大小関係でソートするというのは、数学的直感では有り得ない
だから、読みづらいと思う
もちろんこれは(自分の)主観であって、慣れで解決できる話かもしれないけどね....
0141デフォルトの名無しさん
2013/08/30(金) NY:AN:NY.AN論理的に喋れよ
0142前スレ367
2013/08/30(金) NY:AN:NY.ANでは、副作用のある、言い換えると破壊的代入やI/Oも受け付けるSMLに習って、
let式を導入するとか：
lambda:
let:
pivot = xs[0]
(littles, bigs) = partition(xs[1:], lambda x: x < pivot)
in:
quicksort(littles) + [pivot] + quicksort(bigs)
それともRubyに習って、ブロッ.............(以下略)
0143デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.ANそれはそれとして、そんなダラダラと長い無名関数は
関数型言語使ってても書かないけどな
読みにくいじゃん
なんか関数型言語がdisられてる印象を受けるわ
0144デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.ANしょーもない変数は名前束縛するのに関数は名前束縛しないとか、
誰得のプログラミングスタイルなんだよって感じ
Rubyってそうなの？
0145デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.ANタプルの特定位置の要素でソートするのがあり得ないと?
自分で何言ってるか分かってるの？
0146デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.ANgroup byの結果は ( (<), (=), (>) ) ではなく
( (-1, (<)), (0, (=)), (1, (>)) ) だ
(<)/(=)/(>)の要素数はそれぞれ異なるが、このような構造を単に
( (key, val), (key, val), (key, val) )の形のシーケンスと見做して
keyでソートするというようなことはプログラミングでは決して珍しくないと思うし
君のコード見てもこんな構造あるんじゃないの?
0147デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.ANいやだから、JavaScriptやRubyのように
無名関数の中でダラダラ「手続き的な」逐次実行文を記述できることが
なぜ「関数プログラミング」の適正につながるの？
相変わらずlambdaが問題なんじゃなくてletが欲しいだけにしか聞こえないんだが
0148デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.ANletの後ろとinの後ろの:は冗長だろ
lambdaの:は引数リストとbodyを区切るのに必要だけど
lambda x: let fx, gx = f(x), g(x) in ...
でいいし、Schemeのlet*みたいな順序性が欲しいときは
lambda x: let fx = f(x) and gx = g(x) in ...
とかでいい
0149デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.AN0150デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.AN同じ理由でwhile,for,break,continueも良い
この良さは関数型で説明できないから関数型はどうでもいい
式指向だろうがなんだろうがletをダラダラ並べて無駄な名前を定義したらダメ
0151デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.ANやはり反則感が否めないな
しかも本当に並び替えのところで使うわけだし
0152デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.AN無名関数じゃなくて無名オブジェクトがあればselfを使えるけど
0153デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.AN名前を定義しないスタイルならHaskellのポイントフリー最強
0154デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.ANさっきのあれをここで使うとか
ポイントフリーでは時間や場所を想像できない
0155デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.AN0156デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.AN名前を使わないだけで最強と思うのは甘い
0157デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.ANその名前で参照できるじゃん
名前を使わないどころか、名前束縛しまくりですわ
0158前スレ367
2013/08/31(土) NY:AN:NY.ANgroup byの結果が ( (-1, (<)), (0, (=)), (1, (>)) ) という対リストであるのは分かるし、
分かったからLINQのコード(>>101)をRubyへ書き換える(>>105)ことができた
そして、こういったシーケンス操作はありふれたものだ(=珍しくない)し、自分もよく使う
ただし、何度も述べている(>>97中段, >>130最下段)ように、
「クイックソートというお題に限れば」
>>98のC#コードや>>72の記事内のRubyコードのほうが、
そのアルゴリズムを素直かつ簡潔に表現しているエレガントなコードだと考える
わざわざLINQ(C#)やメソッドチェーン(Ruby)を使うまでもない
LINQやメソッドチェーンには、それを用いることでエレガントに解けるお題が数多くあると思う
しかしながら、今回の「クイックソートというお題に限れば」そうではなかった、だけのこと
また対(key, val)について、そのキーは「より小さい/等しい/より大きい」という
排他的関係を意味しているが、C#やRubyでは「たまたま」-1/0/1 という
大小関係のある(=comparableな)整数値を割り当てている
ただし、そもそもの意味としては排他的関係でしかないのだから、
データ型について厳密な言語、たとえばSMLでは以下のような直和型として定義される
datatype order = LESS | EQUAL | GREATER
当然、これら型構成子 LESS/EQUAL/GREATER に大小関係は存在しないからソート不可であり、
結果としてLINQコード(>>101)の考え方(=アルゴリズム)はSMLには適用できないことになる
つまり特定の言語(ここではC#とRuby)に依存するアルゴリズムよりも、
依存しないもののほうが、優れていると思う
0159デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.ANSMLにも適用できますがな
0160前スレ367
2013/08/31(土) NY:AN:NY.ANまず、タイポを修正しておこう
X: なぜ「関数プログラミング」の適正につながるの？
O: なぜ「関数型プログラミング」の適性につながるの？
では、本題だ
Python/JavaScript/Rubyは非関数型言語(=命令型言語, 手続き型言語)であり、
それらの代入の意味が「メモリの書き換え」であり、
これが関数型言語の代入の意味「値を名前に束縛する」とは異なることも事実
これらを理解した上で、非関数型言語でも代入操作として
「初期化は許すが、再代入(=破壊的な書き換え)は禁止」というスタイルで
関数型言語の代入を模倣しようというのが、「非関数型言語による関数型プログラミング」の発想
詳しくは、>>128の記事を参照のこと
そして、この関数型プログラミングの発想は、すでに前スレで示されていて、
その発想そのものへの批判は一切無かったと記憶しているし、
実際に様々な非関数型言語によるクイックソートのコードのどれも、そのスタイルで書かれていた
だから、たとえ
> 無名関数の中でダラダラ「手続き的な」逐次実行文を記述
していたとしても、前記の代入意味論の解釈に従っていれば、
その「関数型プログラミングへの適性」を損なうものではないと考える
0161デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.AN流石に同じ続きすぎて飽きたんだけど...
まだクイックソートの話を続けるなら、
in-placeでソートを行うコードを書いてほしいな
そっちの方が効率良いんだから
0162前スレ367
2013/08/31(土) NY:AN:NY.ANSMLの標準関数sortは、比較関数を引数に取ることになっていますよ
val sort : ('a * 'a -> order) -> 'a list -> 'a list
問題は、比較関数 order * order -> order を書くのが面倒だってこと
たとえば、こんなコードになる
fun comp LESS LESS = EQUAL
| comp LESS EQUAL = LESS
| comp LESS GREATER = GREATER
| comp EQUAL LESS = LESS
| comp EQUAL EQUAL = LESS
| comp EQUAL GREATER = GREATER
| comp GREATER LESS = GRATER
| comp GREATER EQUAL = GREATER
| comp GREATER GREATER = EQUAL
こんなコードの積み重ねであっても、>>72の記事内にあるSMLコードより美しいと思う？
0163デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.AN| key EQUAL -> 0
| key GREATER -> 1
があれば良いがな
ていうか、datatype order って型名なのに順序が定義されてないことが驚きだわ
ウンコすぎる
0164デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.AN言ってることがよくわからんなぁ
束縛ってのは値を名前に対応付けるという意味しかないから
単一代入かどうかは問わないし、再束縛とミューテーションも違う
参照型ベースの言語ではCのような言語とは値の持ち方が違って、
再束縛では紐づけが変わるだけで実体の値が書き換わる（ミューテーション）
わけじゃないし、そもそもPythonの言語仕様とかで思いっきりname bindingsという
用語を使ってるだろ
http://docs.python.org/3/reference/executionmodel.html
それに、Lisp/Schemeとか普通にsetf/set!とか使って破壊的代入できるけど
letあるじゃん
まあletがない言語でpoor man's functional programmingをしようみたいな
涙ぐましい話なのはなんとなくわかったけど
0165デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.ANintで実装すればこの問題が解決するのは事実
しかしその事実を>>158は「たまたま」だという
偶然の事実には依存しないほうが優れているという
ここで気になるのは、「優れている」という意見それ自体は偶然ではないのか
事実を偶然といい、人間の意見は偶然ではないというのか
人間はそんなにえらいのか
0166デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.AN> つまり特定の言語(ここではC#とRuby)に依存するアルゴリズムよりも、
> 依存しないもののほうが、優れていると思う
これまで散々、○○言語では（367の望む書き方で）書けないってケチつけてたくせに、
自分の贔屓する言語で書けない場合は書き方にケチつけんのかよ
本当に367はダブスタの糞野郎だな
0167前スレ367
2013/08/31(土) NY:AN:NY.AN関数型言語において、束縛ってのは「値を名前に対応付ける」という意味しかないから、
再束縛では「(新たな環境内で)別の値を同じ名前に対応付ける」だけで、
実体の値が書き換わるわけではない.... ここまではOKだと思う
そして(Pythonを含む)手続き型言語における束縛とは、(値を名前に対応付けるのではなく)
「実体(=値)への参照を名前に対応づける」ことになる
結果として、手続き型言語の再代入では(関数型言語における再束縛ではなく)参照先の実体を
書き換えることになり、それを一般には「破壊的代入」と呼ぶ
以下はPython言語リファレンスからの引用：
名前 (name) とは、オブジェクトを参照するものを指します。
同じ「束縛(binding)」という単語が関数型言語と手続き型言語とでは
別の意味(「値」と「値への参照」)を指すというだけで、何も難しい話は無いと思うがね
0168デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.AN>手続き型言語の再代入では(関数型言語における再束縛ではなく)参照先の実体を
>書き換えることになり
は？
参照先の実体を書き換えるってのは一体何のことを言ってるんだ？
PythonやRubyやJavaScriptで、
x = X
y = x
x = Y <- 再代入
とかやったとして、xが指してたX(実体）はなんも書き換えられないだろ
一体何が言いたいんだ？
シンボルテーブル上のxで紐づいているものがYに変わっただけで
破壊的更新がされたのは実体ではなくシンボルテーブル、つまり環境だ
0169前スレ367
2013/08/31(土) NY:AN:NY.AN>破壊的更新がされたのは実体ではなくシンボルテーブル、つまり環境だ
そのとおりだね
そして、その(シンボルテーブル上の)シンボルを、変数と呼ぶ
関数型言語では新たな環境上で新しい束縛が生まれるのに対して、
手続き型言語では同じ環境(シンボルテーブル)上の(名前と束縛された)参照を書き換える
0170デフォルトの名無しさん
2013/08/31(土) NY:AN:NY.AN言いたいことは分かった
環境を書き換えずに新たな環境を作り外の環境の重複した名前を隠すのと
現在の環境を書き換える差を言いたかったんなら、そう言ってくれ
letはlambdaの構文糖で、新たな環境を作るから、当然そういう動きになる
上の話に戻るが、「lambda式の壁」よりも「let式の壁」のほうが実情に
沿ってるんじゃないのか？
RubyがLispやSchemeの下になるのが気に入らないかもしれんがなｗ
0171前スレ367
2013/08/31(土) NY:AN:NY.AN>上の話に戻るが、「lambda式の壁」よりも「let式の壁」のほうが実情に
>沿ってるんじゃないのか？
では、let式だと特定しすぎるから(Haskellのwhen節でも意味論としてはlet式と同じ....)、
「局所宣言式の壁」も新たに候補として追加することを考えてみよう
>RubyがLispやSchemeの下になるのが気に入らないかもしれんがなｗ
もともとLisp族は関数型言語でRubyは手続き型言語なのだから、
その間に何らかの壁が存在する事実に関して、何ら不満はありませんよ.....
で、こちらも前の話に戻るけど、
(たとえ代入の意味が手続き型であったとしても)「ラムダ式の本体で局所変数を宣言できる壁」は
相変わらず存在し続けているのだけれど、それは了解してもらえますかね？
Pythonが同じスクリプト系言語であるRubyやJavaScriptの下になるのが、
気に入らないかもしれませんけどねｗ
0172デフォルトの名無しさん
2013/09/01(日) 00:21:00.97その壁はletが無い言語では
「lambdaのbodyにおいて手続き的な逐次実行文を許容するかどうか」の差だろ
C#あたりだと、式形式と文形式のlambdaという形で構文が分かれている
あくまで「自分は」手続き的な逐次実行のために使うんじゃなくて
letの代用に局所変数を使いたいがためにその機能が欲しいんだ、と
言いたいかもしれないが、「実際には」上のような違いだぞ
局所変数が使えない実用的な言語は存在しないが
なぜ「lambdaの中の局所変数」にそこまでこだわるのかも意味不明だな
Pythonは関数内関数を普通に提供していて、もちろんそこでは局所変数が
使える訳だが
0173デフォルトの名無しさん
2013/09/01(日) 00:26:36.07>では、let式だと特定しすぎるから(Haskellのwhen節でも意味論としてはlet式と同じ....)、
>「局所宣言式の壁」も新たに候補として追加することを考えてみよう
Haskellにletあるのにwhereもあるから他の言語でも似た文があればいいってか？
散々式傾向だの抜かしてたくせに何抜かしてるんだ？
お前の今までのクソみたいな屁理屈撤回してから言えよ
0174前スレ367
2013/09/01(日) 00:59:36.56いくら「主観的」なPython擁護の理屈を並べても、
「ラムダ式の本体で局所変数を宣言できる壁」が存在する事実は変えられないよ
他の言語では存在するのが当たり前すぎるほど当然な機能なのに、Pythonには欠けているから、
クイックソートをラムダ式で書き直そうとすれば「ラムダ式を入れ子にする」しかなかった
これは>>72の記事で示したコードで実証された(>>126,127)
もしPythonがこの壁を越えていると主張したいのなら、
(式指向の壁を越えた時と同様に)それをクイックソートのコードで示せばいい
もしもPythonで「１つのラムダ式内で変数 piviot/littles/bigs を宣言(>>126)」したコードを
示せたのなら、壁が存在しないことは「客観的」に実証されたことになる
0175デフォルトの名無しさん
2013/09/01(日) 01:14:33.40いやだから、できないのは分かってるが、そもそも
なんでそこまで「lambda内のローカル変数定義」にこだわるのか分からんというか……
そこまで重要性高いか？
そもそも>>72に関数型言語のHaskellやSMLの例でもPartitionの下請け関数に
whereやletでgとか名前つけてるじゃねーか
lambdaじゃ一般には再帰したければYコンビネータでも使うしかないし
実際問題として、関数型言語だってそんなにダラダラlambda式使わないだろ
カリー化があれば不要なこと多いしな
0176デフォルトの名無しさん
2013/09/01(日) 01:27:00.91代数データ型の壁とか、入れ子関数の壁だとか、ファーストクラス関数の壁とか
演算子＝関数の壁とか、色々ありえるわな
lambda内ローカル変数が重要だといいたいのなら、それがないことが
どれだけ重大なことであって、具体的に何ができなくて困るのか示せよって話だ
0177デフォルトの名無しさん
2013/09/01(日) 03:35:56.32束縛の意味（なぜ「束縛」なのか）わかってないな
0178デフォルトの名無しさん
2013/09/01(日) 09:46:59.80結局、クイックソートの実装に適した道具がライブラリに"たまたま"あるかどうかの勝負になってたもんな
今更ライブラリのたまたまな仕様に依存するなとか頭おかしい
0179前スレ367
2013/09/01(日) 10:51:48.71>そこまで重要性高いか？
いや、重要性は低いと(個人的には)考えているよ
「lambda内のローカル変数定義」という壁が存在することは事実であり、
それは>>86へ追加する壁(=評価基準)の候補となることを意味する
ただし、(個人的には)他の壁候補と同様に、些細な事柄のように思う
>>176
>要は、壁なんてのはいくらでも恣意的に作れるのであって、
まったく、そのとおりだね
そして、そんな数ある壁候補から「関数型プログラミングへの適性」という観点で
(恣意的に)取捨選択したものを>>86に反映させている
で、上でも書いたように、(個人的には)他の壁候補と同様、
「lambda内ローカル変数」は採用に値しない(=捨てられる)些細な事柄だと思っている
0180デフォルトの名無しさん
2013/09/01(日) 12:00:05.31発狂して色んな言語の重箱の隅を突き出したのか
まじでカスだな
0181デフォルトの名無しさん
2013/09/01(日) 12:02:41.57「俺の都合のいいように基準を選んでます」って最初っから公言してるじゃん
気に入らなければ構うな
0182デフォルトの名無しさん
2013/09/01(日) 12:10:46.290183デフォルトの名無しさん
2013/09/01(日) 13:08:18.98「lambda内のローカル変数定義」とで
本質的に何が違うと367が勘違いしてるのかがよく分からない。
0184デフォルトの名無しさん
2013/09/01(日) 13:25:49.27相手にするべきじゃない
なんだかんだ言って、結局のところ
自分好みの記述が可能かどうかを基準に
優劣を云々してRuby厨として優越に浸りたいだけだから
ついでに、けなした言語のファン心理を煽って、
自分が使えそうな情報を引き出そうと
画策しているのがさらにむかつく
0185デフォルトの名無しさん
2013/09/01(日) 19:07:14.70その話題を必死に避けようとしてるのが逆に生々しい
0186デフォルトの名無しさん
2013/09/01(日) 19:52:58.89lambdaの引数でほぼそのまま代用できるよな
その上ローカルスコープに拘る意味もわからない
lambdaなんて書くときは外部のをキャプチャする事のが多いのに
0187デフォルトの名無しさん
2013/09/01(日) 21:44:41.38は
(lambda x: ～ )(1)
で代用できるけど、そもそもPythonでは関数内で関数が出来るのだから
後者のような読みにくい書き方をしてまでlambdaを使う意味は全くない
0188デフォルトの名無しさん
2013/09/01(日) 22:41:47.530189デフォルトの名無しさん
2013/09/01(日) 22:44:28.01ゴミじゃない言語を挙げない時点でｗ
話についていけないからって負け惜しみ言ってんじゃねえよダッセー
0190デフォルトの名無しさん
2013/09/01(日) 22:44:57.30callfun(1, lambda x:
callfun(2, lambda y:
～
))
変数名は適当だが並べ方を変えるだけで読みやすいという例
0191デフォルトの名無しさん
2013/09/01(日) 22:50:17.64なにそれキモイ
0192前スレ367
2013/09/01(日) 23:00:01.53>let x = 1 in ～
>は
>(lambda x: ～ )(1)
>で代用できるけど、
代用できるから何の問題も無いと主張したいのなら、
>>72の記事にあるラムダ式版のPythonコードについて、
「ラムダ式を入れ子にせず」書き直したコードを示せばいいのではないかな？
そのコードを示すことが「ラムダ式の本体で局所変数を宣言できる壁」を越えたことの
実証であると、>>174でも書いているんだけどね.....
論よりコードだよ
0193デフォルトの名無しさん
2013/09/01(日) 23:01:28.44F#のパイプライン演算子とかは、まさに順序ひっくりかえすだけだよな
定義も
let (|>) x f = f x
とかだけ
0194デフォルトの名無しさん
2013/09/01(日) 23:16:01.33> 代用できるから何の問題も無いと主張したいのなら、
いや、そんなこと言ってないけど……
lambdaで無理やり代用しても「読みにくい」って書いたじゃん
日本語に不自由してるのか、藁人形論法か
0195デフォルトの名無しさん
2013/09/01(日) 23:36:03.23>>86の階層の一番上のFPはどうなるの？
0196前スレ367
2013/09/01(日) 23:44:33.08本当に「読みにくい」だけなの？
もしも「読みにくても書ける」のなら壁越えに問題無いと考えているけど、本当のところは
Pyhtonではラムダ式を入れ子にしなければ、クイックソートは「書けない」
というのが、真実なのでは？
もし書けるのなら、書いて示せばそれが客観性のある実証であると何度も言ってるのに....
他の言語では(少なくとも>>72の記事で挙げた言語すべてでは)何の苦もなく「書ける」んだけどなぁ
繰り返すけど、「論よりコード」だよ
0197デフォルトの名無しさん
2013/09/01(日) 23:49:21.70ねーねー、>>195にも答えてよー
0198前スレ367
2013/09/02(月) 00:07:43.44そもそもFPには変数が存在しないから、壁自体が存在しない
だからFPは究極の関数型言語だと言われている
ただし、普通のプログラマがFPで実際にプログラミングができるのか？という点には
疑問があって、少なくとも自分にはFPでクイックソートを書ける自信が無い(=書けない)
究極という言葉で示されるように、FPが>>86の最上位に位置しているのは
「関数型言語の象徴」としての意味合いがある
だから、もしFPが>>86にとってふさわしくないという意見があれば、
FPを>>86から外すことを検討したいと考えている
0199デフォルトの名無しさん
2013/09/02(月) 00:29:02.89壁を追加して矛盾が出てくるたびに弄ってたらキリが無いよ
0200デフォルトの名無しさん
2013/09/02(月) 00:31:36.960201デフォルトの名無しさん
2013/09/02(月) 00:45:51.13意味が分からんな
読みにくくても書ければ問題ないなら、なぜラムダの入れ子はダメなんだ？
ラムダを入れ子にしてはいけない、とでもいう謎の自分ルールがあるのか？
def partition(xs, p):
return reduce(lambda ys, y: p(y) and (ys[0]+[y],ys[1]) or (ys[0],ys[1]+[y]), xs, ([],[]))
def quicksort(xs):
return xs if len(xs) <= 1 else (lambda x, ls, bs: quicksort(ls) + [x] + quicksort(bs))(xs[0], *partition(xs[1:], lambda x: x < xs[0]))
0202デフォルトの名無しさん
2013/09/02(月) 00:50:48.52367にとってラムダの入れ子は関数型プログラミングに相応しくないんだろ
書いてて意味わからんが
0203デフォルトの名無しさん
2013/09/02(月) 00:54:39.050204デフォルトの名無しさん
2013/09/02(月) 01:01:58.69> そもそもFPには変数が存在しないから、壁自体が存在しない
この論法に従うなら、
Cにはラムダ式が存在しないから、ラムダ式の壁自体が存在しない
ってことになるんじゃないですかねぇ...？
0205デフォルトの名無しさん
2013/09/02(月) 08:20:24.72簡約モデルより環境モデルが便利でしかも手続き型と異常に相性が良い
ふざけた壁をぶちこわすくらいの異常さ
0206デフォルトの名無しさん
2013/09/02(月) 14:44:29.15いろんな数値型、型固定(guards)、演算子オーバーロード、真の非同期関数
などなどもろもろがバッサバッサ導入されていく方向だけど、それらについてどう思う？
www.slideshare.net/BrendanEich/value-objects
0207デフォルトの名無しさん
2013/09/02(月) 16:20:21.74jsはシンプルで柔軟なままにしておいて、大規模開発用に別言語を用意すればいいのにって思う
まあDartのコケっぷりを見るにそれは大変なことなんだろうけど
0208デフォルトの名無しさん
2013/09/02(月) 16:57:26.46ES6のスクリプト言語的進化はPythonとRuby、大規模開発向けはJAVAやC#が参考にされてるね。
ES7のそういうメタ的拡張はCやC++の名前がよく挙がってる。
ほかにもライブラリやフレームワーク的仕組みを標準に組み込んだり、必死に温故知新を勤めてるようだ。
互換性を残したまま言語をリフォームしたいみたいだね。
0209デフォルトの名無しさん
2013/09/02(月) 19:27:34.89平気で互換性切り捨てた言語で、これすごいよねって言われても、言語の長所としてパッとしないんだよね。
未だに論争抱えてる言語もあるし、他の言語と比較する前に、自分自身をどうにかしろよと思う。
0210デフォルトの名無しさん
2013/09/02(月) 19:30:46.860211デフォルトの名無しさん
2013/09/02(月) 19:36:19.030212デフォルトの名無しさん
2013/09/02(月) 19:39:03.87生き残った言語スレに乾杯！！
0213デフォルトの名無しさん
2013/09/02(月) 20:00:58.77鯖の移転してるんだよ
DAT落ちした過去ログは消して、aliveなスレだけ残して移転だとさ
0214デフォルトの名無しさん
2013/09/02(月) 20:07:52.33どんだけ過疎ってんですか…。
0215デフォルトの名無しさん
2013/09/02(月) 20:11:04.48現状はスレ一覧に、書き込みがあったスレだけ反映されてるから。
そのうち（運営が仕事すれば）、存在してたスレは全部戻るはず。
0216デフォルトの名無しさん
2013/09/02(月) 20:16:21.810217デフォルトの名無しさん
2013/09/02(月) 20:27:47.240218デフォルトの名無しさん
2013/09/02(月) 20:32:22.160219デフォルトの名無しさん
2013/09/02(月) 20:54:36.40どの言語もヘボいんだけど…
0220デフォルトの名無しさん
2013/09/02(月) 20:58:49.170221デフォルトの名無しさん
2013/09/02(月) 21:00:59.930222デフォルトの名無しさん
2013/09/02(月) 21:04:42.350223デフォルトの名無しさん
2013/09/02(月) 21:18:29.53意味が違うぞよ
過去ログは一旦全部消すんだそうだ
そして今残ってたスレはそのまま移転
しばらく●ビューアの機能はスレ立て専用みたいになっちゃう
0224デフォルトの名無しさん
2013/09/02(月) 21:54:36.80括弧の省略？
それを言うならせめてキーワードの省略や自動returnだろ
使ったこと無いのがバレバレだぞ
0225デフォルトの名無しさん
2013/09/02(月) 22:04:06.95キーワードの省略や自動return？
それを言うならアロー関数だろ
使ったこと無いのがバレバレだぞ
それにそれはES6にあるから言語としてのアドバンテージにならないし
それならCSじゃなくてTranspiler使ったほうが保守性も高くていいよねってことになる
0226デフォルトの名無しさん
2013/09/02(月) 22:08:08.87なんで急にES6の話をしだしたんだ？
普及もしてないのに
0227デフォルトの名無しさん
2013/09/02(月) 22:08:18.60劣化Schemeから劣化C++へダウングレードしてると思う
0228デフォルトの名無しさん
2013/09/02(月) 22:09:05.32ネットで聞き齧ったんだろ
2chがソースかもしれんな
0229デフォルトの名無しさん
2013/09/02(月) 22:25:31.42普及してないって、CSだってそのままでは動かないではないか。
急にというがこっちはそういうコンパイルの面とか無視して、最初から言語仕様のアドバンテージの話をしてるんだぞ。
それに多くの環境が対応しないと言語機能として認めないなんて言う方が急に変な話だと思うが。
実際現状FFの拡張なんかですごく便利に使えてるし、CSのアドバンテージにはならないよ。
0230デフォルトの名無しさん
2013/09/02(月) 22:34:53.16JavaScriptとCoffeeの比較の話をしてるのに
ES6の話をしだしてるからおかしいぞと
ES6がJavaScriptであるという話なら形は合うけど
JavaScriptとして普及はしてないから通じないぞと
わかった？
0231デフォルトの名無しさん
2013/09/02(月) 22:38:48.61知識やコードが共有できるかどうかのが遥かに重要
じゃなきゃElmやってるわ
0232デフォルトの名無しさん
2013/09/02(月) 22:43:32.14わかったわかった。
『ECMAScript』と書かなかったコチラが大変悪うございました。
0233デフォルトの名無しさん
2013/09/02(月) 22:46:55.96お前は自分の主張を聞いてもらいたくて、他人に食いついてるだけだぞ。
0234デフォルトの名無しさん
2013/09/02(月) 22:49:17.81聞いてもらえないとわかったから引いた。
もういいだろｗ？
0235デフォルトの名無しさん
2013/09/02(月) 22:49:34.30そうだな
最初からES6と書かなかったお前が悪い
0236デフォルトの名無しさん
2013/09/02(月) 22:57:57.99最低を考えて発現するのは大人の常識だよ
0237デフォルトの名無しさん
2013/09/02(月) 23:00:59.70やっぱり規制解除は良くないね
0238デフォルトの名無しさん
2013/09/03(火) 07:51:08.330239デフォルトの名無しさん
2013/09/03(火) 08:02:53.970240デフォルトの名無しさん
2013/09/03(火) 08:04:41.42Pythonなんて触りもしないので
気持ち悪くても問題無い
0241デフォルトの名無しさん
2013/09/03(火) 08:13:00.07気持ち悪いのが問題なんだろ、実際廃止するか揉めたんだし
0242デフォルトの名無しさん
2013/09/03(火) 08:16:20.84そんな電卓使えるわけ無いだろ
0243デフォルトの名無しさん
2013/09/03(火) 08:20:43.62まあ、デコレータとかあるし、廃止するの無理そうではある
0244デフォルトの名無しさん
2013/09/03(火) 08:24:26.46selfのおかげで常にオブジェクトの振る舞いを意識せざるをえなくなるので
手続きドカタが学習するのには向いてる
0245デフォルトの名無しさん
2013/09/03(火) 08:31:03.52ドカタにはオブジェクトなど意識させないのが正しい
どうせ理解できないのだから
0246デフォルトの名無しさん
2013/09/03(火) 08:41:01.18ここで言う∞も浮動小数点型では厳密に無限大ではないから問題ない
0247デフォルトの名無しさん
2013/09/03(火) 08:43:36.600248デフォルトの名無しさん
2013/09/03(火) 08:44:28.82糞なところは糞だと認めたほうが成長できると思うよ
0249デフォルトの名無しさん
2013/09/03(火) 08:56:43.39「浮動小数点表現は厳密じゃない病」だなw
まぁ0.0の他に-0.0もある、というあたりで普通じゃないことは確かだが。
0250デフォルトの名無しさん
2013/09/03(火) 09:09:48.64Infinity返してくれた方がデバッグするときのヒントにはなる
ただし例外の無いC限定
0251デフォルトの名無しさん
2013/09/03(火) 09:14:14.810252デフォルトの名無しさん
2013/09/03(火) 09:21:52.94問題は例外を送出させるという選択がないこと
やるにしても全て手動で実装する羽目になる
0253デフォルトの名無しさん
2013/09/03(火) 09:21:58.120は厳密に0ではないのですべてBoolean(0)もtureを返す！
0254デフォルトの名無しさん
2013/09/03(火) 09:38:17.230255デフォルトの名無しさん
2013/09/03(火) 10:00:46.24嫌なら整数型を使えばいいだけだし。
0256デフォルトの名無しさん
2013/09/03(火) 10:16:17.090257デフォルトの名無しさん
2013/09/03(火) 10:22:18.32feenableexcept使え
0258デフォルトの名無しさん
2013/09/03(火) 10:26:08.94スクリプトだとレイヤが違うから結局自分でハンドリングすることになる
0259デフォルトの名無しさん
2013/09/03(火) 10:40:28.63浮動少数だとソフトウェアで実装しなきゃならんからあまりにもオーバーヘッドが大きい。
これに文句をいうのは１言語の枠を超えてる。
0260デフォルトの名無しさん
2013/09/03(火) 10:43:46.150261デフォルトの名無しさん
2013/09/03(火) 10:57:43.66パフォーマンスの都合上、一言語にはどうしようもないということだろう。
それを議論するのは愚の骨頂……
0262デフォルトの名無しさん
2013/09/03(火) 11:01:12.890263デフォルトの名無しさん
2013/09/03(火) 11:13:54.13論理がおかしい
0264デフォルトの名無しさん
2013/09/03(火) 11:16:44.97問題あるなら何十年も変えられないはずがないし。
ひょっとすると>>206みたいな感じでそう遠くないうちに解決するんじゃね。
0265デフォルトの名無しさん
2013/09/03(火) 11:26:29.47まとめて例外を拾って対処するという考え方がLLっぽくないと思う
動的型付け言語では入出力時に値をできる限り正規化するのが合ってて、
すぐすぐ例外という事にはしない方がいいんじゃないかな
それがクソだと思うのは文化の違いだと思うよ
そういう人の好きな言語とその好きな点を聞いてみたいね
0266デフォルトの名無しさん
2013/09/03(火) 11:32:47.920267デフォルトの名無しさん
2013/09/03(火) 11:33:59.94実数の除算と整数の除算を別の記号にするのも珍しくない
型を増やさなくても記号を増やすだけで解決するよ
0268デフォルトの名無しさん
2013/09/03(火) 11:36:04.66引数のチェックは静的型でもするよ。
それともまさか暗黙の変換するほうが良いって発言？
0269デフォルトの名無しさん
2013/09/03(火) 11:43:17.81どの場合でも0除算でInfinityになる方がいいと思ってる頭おかしいのがいるのか
0270デフォルトの名無しさん
2013/09/03(火) 11:47:00.880271デフォルトの名無しさん
2013/09/03(火) 11:50:20.71また例外が出る手段は要るのか
要るのならフラグがいいのか、ちゃんと型を整備するのがいいのか、演算子を増やすのがいいのか
っていう議論だよね？
0272デフォルトの名無しさん
2013/09/03(火) 12:00:25.57スクリプト言語は糞か否か、それだけだ。
細かいことはどうでもいい。
0273デフォルトの名無しさん
2013/09/03(火) 12:06:20.610274デフォルトの名無しさん
2013/09/03(火) 12:08:45.070275デフォルトの名無しさん
2013/09/03(火) 12:15:52.63何かが得られるならそれで十分
0276デフォルトの名無しさん
2013/09/03(火) 13:07:24.38浮動小数点型ではNaNやInfinityとして表現出来るんだからわざわざエラーにする必要がない
0277デフォルトの名無しさん
2013/09/03(火) 13:18:01.830278デフォルトの名無しさん
2013/09/03(火) 13:22:31.910279デフォルトの名無しさん
2013/09/03(火) 13:22:56.07現にLLでは例外処理構文は発達してないし、合ってない
0280デフォルトの名無しさん
2013/09/03(火) 13:25:15.530281デフォルトの名無しさん
2013/09/03(火) 13:27:45.080282デフォルトの名無しさん
2013/09/03(火) 13:31:42.97どんな言語でもIEEEの浮動小数点型採用してるのは吐かないというか、仕様的に吐いちゃいけないだろ。
スクリプト言語にまともな整数型を導入すべきかという議論にしよう。
0283デフォルトの名無しさん
2013/09/03(火) 13:33:44.030284デフォルトの名無しさん
2013/09/03(火) 13:34:04.910285デフォルトの名無しさん
2013/09/03(火) 13:43:13.95>現にLLでは例外処理構文は発達してないし、合ってない
何を血迷ったことを言ってるんだ・・・
0286デフォルトの名無しさん
2013/09/03(火) 13:45:16.240287デフォルトの名無しさん
2013/09/03(火) 13:45:17.32食わず嫌いなのかな
0288デフォルトの名無しさん
2013/09/03(火) 13:47:54.80内容に突っ込むべきだろう
0289デフォルトの名無しさん
2013/09/03(火) 13:50:06.97内容も例外投げちゃいけないわけじゃないよね
投げない場合はそう表現するってだけで
0290デフォルトの名無しさん
2013/09/03(火) 13:52:21.96Javaの検査例外は失敗、というのがほぼ定評だろ。
それはそれとして、例外は最近の言語ならたいていある。
0291デフォルトの名無しさん
2013/09/03(火) 13:53:01.600292デフォルトの名無しさん
2013/09/03(火) 13:54:31.650293デフォルトの名無しさん
2013/09/03(火) 13:55:25.000294デフォルトの名無しさん
2013/09/03(火) 13:57:39.820295デフォルトの名無しさん
2013/09/03(火) 13:58:48.62そもそもそんな頻繁に例外投げるのが時代遅れって言うことで
話の根底が矛盾してるな
0296デフォルトの名無しさん
2013/09/03(火) 13:59:12.17Webページにスタックトレース画面を垂れ流して平気でいる奴のセンスだ
0297デフォルトの名無しさん
2013/09/03(火) 14:01:06.70これで普段使ってないんだろうなと思った
0298デフォルトの名無しさん
2013/09/03(火) 14:02:12.08catchするとこまで考える投げる、受け取るの方が良くて、
そうじゃないのなら吐くで良いと思う。
0299デフォルトの名無しさん
2013/09/03(火) 14:05:04.41むしろそういうとこから喧嘩になるから荒らしと同じ
0300デフォルトの名無しさん
2013/09/03(火) 14:07:22.04JavaScriptも最低でもparse系やJSONは使うし特に最新のAPIは投げまくる
PerlやRubyは知らない
>>299
すまない気をつける
0301デフォルトの名無しさん
2013/09/03(火) 14:07:59.900302デフォルトの名無しさん
2013/09/03(火) 14:13:35.040303デフォルトの名無しさん
2013/09/03(火) 14:18:53.83JSはそうは思わないな
例えばindexOfなんかで-1の代わりに例外投げられちゃたまらんでしょ？
最近で大きい仕様だと、イテレーターが値を返して、
例外が投げられて終了だと判断する方式から
終了状態を含むオブジェクトを返す方式になったし
その他にも、多くのAPIで例外よりも失敗コールバックを採用してる
非同期と例外が合わないってのも大きい
Node.jsではそれに対応できるAPIがあって、
標準の例外キャッチはもうかなり限定的にしか使わない
0304デフォルトの名無しさん
2013/09/03(火) 14:23:31.20取り返しの付かなくてキャッチしても仕方ない時だと思う
逆にAPIでそうでもないエラーを出したい時は、コールバックの仕組みが良いと思う。
もしくは近いけどPromiseみたいなのとか、最近はそういう流れ
0305デフォルトの名無しさん
2013/09/03(火) 14:28:31.520306デフォルトの名無しさん
2013/09/03(火) 14:32:13.24indexOfはちょっと意味がわからないからスルーしよう
Javaですらそういう仕様だ
最近のは少なくともブラウザのストレージ関係のAPIは平気で例外投げる
ただ確かに非同期コールバックと例外に関しては相性は悪いと思う
でもそれで例外を全てを否定する理由にはならない
domainだって必要だから対応してるんだし
0307デフォルトの名無しさん
2013/09/03(火) 14:36:03.17> 例えばindexOfなんかで-1の代わりに例外投げられちゃたまらんでしょ？
それは例えのレベルが低すぎる。
「検索結果が0だったこと」は業務フローで想定されている機能の一つなんだから、
そんなものを例外で投げるのは言語に限らず設計上の禁止事項だとあらゆる文献に書いてある。
例外設計の初歩的なレベルで口を酸っぱくなるほど注意されることだ。
> 最近で大きい仕様だと、イテレーターが値を返して、
> 例外が投げられて終了だと判断する方式から
これも例外設計の分野では有名すぎる「間違った例外の使い方」の一つ。
イテレータの終了判断に例外を使ってはいけません、というのは色々な文献が避けるべき例として取り上げてる。
つまり君が挙げた二例はいずれも例外設計の分野では既に「禁止事項」として有名すぎる話であり、
ゆえに「例外は使いにくいから例外は可能な限り使うな」という主張の根拠足りえない事例ということだ。
0308デフォルトの名無しさん
2013/09/03(火) 14:42:52.13例えばリスト構造を扱うクラスを作った時に、
インデックスで渡された数がリストの要素数をオーバーしてたらどうすんの？
例外吐かないで何を返すんだ？nullでも返すのか？
0309デフォルトの名無しさん
2013/09/03(火) 14:44:10.35そういう例外は扱いづらいし、スクリプト言語に合わないんじゃないかと言いたい
それにストレージ関係APIも普通にコールバックだよ
0310デフォルトの名無しさん
2013/09/03(火) 14:47:00.24>ストレージ関係APIも普通にコールバックだよ
いやいやいやいや
容量オーバーとかクオータ拡張とかdbアクセスとかの例外全部無視してるのか？
localStorageですら例外飛ばしてくるのに
0311デフォルトの名無しさん
2013/09/03(火) 14:50:18.24返り値をチェックして自分の想定外の値だったら「事実上の例外報告」として処理することはできる。
そうすれば例外を全て無視することもできなくはない。
そういう人からすると「例外なんて邪魔。いらない」って考えになるんだろう。哀れなり
0312デフォルトの名無しさん
2013/09/03(火) 14:56:53.51全部無視なんかしてないって
もしかして例外を撲滅しようみたいに聞こえた？
それで気分を悪くしたのなら謝るけど、つっかかりすぎじゃない？
localStorageの容量オーバーは例外投げられるけど他は無いはずだよ
IndexedDBとFileSystemでは無いはず
0313デフォルトの名無しさん
2013/09/03(火) 15:00:56.46だから、デフォルトで0除算例外なんて起きなくていいんだってこと
例外で終了を判定するのは内部の例えばfor-ofとかの実装がそうなっていたから挙げただけで
実際にどうのとは言ってないよ
0314デフォルトの名無しさん
2013/09/03(火) 15:02:09.08http://www.w3.org/TR/file-system-api/#errors-and-exceptions
http://www.w3.org/TR/IndexedDB/#exceptions
これ以上はコード書く羽目になるのでこれで許して
0315デフォルトの名無しさん
2013/09/03(火) 15:05:45.26> だから、デフォルトで0除算例外なんて起きなくていいんだってこと
0除算は「不可能」。続行不能な計算なんだぜ？
それで例外吐かなくていいってのは、数値と文字列を足し算しても例外吐かなくていいってのと同義
どちらも続行不可能で数学的には未定義な処理なんだからさ
0316デフォルトの名無しさん
2013/09/03(火) 15:06:35.40>>314それはコールバックにエラーオブジェクトが渡される
さっきも言ったけど、throwがあってそれをtry-catch構文で受け取ることに否定的なんだよ
否定的ってだけで撲滅しようとは言ってない
念のためもう一度ね
0317デフォルトの名無しさん
2013/09/03(火) 15:09:30.930除算が例外なのは、定義されてないから
もっと言えば、整数データのビット配列にはいい結果の状態を定義できないからだよ
浮動小数なら定義されてるからそれでいい
数学的にとは別の話だと思う
0318デフォルトの名無しさん
2013/09/03(火) 15:17:16.78その意味で、数学的な文脈と関連はあるよ。
0319デフォルトの名無しさん
2013/09/03(火) 15:18:54.16ゼロ除算を「定義」することはできるけど？
整数を表現するクラスにゼロ除算を表現する値を突っ込めばいいだけで
それをしないのは、数学にゼロ除算を持ち込むメリットがないからそうしないだけ
0320デフォルトの名無しさん
2013/09/03(火) 15:22:55.500321デフォルトの名無しさん
2013/09/03(火) 15:24:15.34確かにlocalStorage以外は規格上全部ありそう
これはこちらの不勉強だったようなので謝ります
0322デフォルトの名無しさん
2013/09/03(火) 15:27:06.820323デフォルトの名無しさん
2013/09/03(火) 15:33:28.48そんな屁理屈言ってないよ
現実的な話をしてる
宇宙はこうであるのが一番正しいと言っているのではなく
今の宇宙ではこうであった方が都合がいいのではと言いたい
>>321
まだ出たてのものだから仕方がない
>>322
それはメリットとして当然分かる
でもそういうのは数値型の種類とか、動的型付け言語の話まで関係してきて
結局「スクリプト言語」であるならば、言語の出来方や文化的に合わないんじゃないかと思う
0324デフォルトの名無しさん
2013/09/03(火) 15:33:32.300325デフォルトの名無しさん
2013/09/03(火) 15:37:05.56parseInt
eval
0326デフォルトの名無しさん
2013/09/03(火) 15:42:14.36なにそれ使ったことないんだけど
0327デフォルトの名無しさん
2013/09/03(火) 16:15:47.890328デフォルトの名無しさん
2013/09/03(火) 17:19:08.910329デフォルトの名無しさん
2013/09/03(火) 18:15:20.770330デフォルトの名無しさん
2013/09/03(火) 18:26:26.13いわゆるフレームワークはreturnでデータを受け渡しするスタイルを避けるよね
returnが駄目ならthrowも駄目じゃないか
0331デフォルトの名無しさん
2013/09/03(火) 18:44:24.750332前スレ367
2013/09/03(火) 20:52:39.99>読みにくくても書ければ問題ないなら、なぜラムダの入れ子はダメなんだ？
>ラムダを入れ子にしてはいけない、とでもいう謎の自分ルールがあるのか？
ラムダ式の入れ子が好ましくない理由：
・おおざっぱな「関数宣言とはラムダ式を変数に代入したもの」という定義の元で、
書き換え元(>>72)にある１つの関数宣言に対して２つのラムダ式を必要とし、複雑さが増す
（厳密には関数再帰があるので上記は正しくないが、ここでは枝葉な事柄）
・一般にインデントは分岐や反復といったプログラムの制御構造を読みやすくするものだが、
書き換え元にある変数 pivot と (littles, bigs) への代入文のインデントが揃わない
どちらの問題点も、Python以外の言語、少なくとも>>72で挙げた言語すべてでは、
「関数宣言とラムダ式を１対１に対応させ」、「代入文のインデントを揃える」ことは
何の苦もなく実践できる(JavaScriptについては、すでに>>72でコードを示している)
ただし、>>179で書いたように、これは主観的な意見であり、
>>86に追加する壁候補として採用するには、些細な根拠だと考えている
0333デフォルトの名無しさん
2013/09/03(火) 21:09:02.190334前スレ367
2013/09/03(火) 21:15:41.10「ラムダ式を１つにする」という要望にコードで応えてくれてありがとう
まず、可読性を考慮して>>72のインデントスタイルと変数への命名を書き換えたものを以下に示す
def partition(xs, f):
return reduce(
lambda pair, x:
f(x) and (pair[0] + [x], pair[1]) or (pair[0], pair[1] + [x]),
xs, ([], [])
)
def quicksort(xs):
return xs if len(xs) <= 1 else (
lambda pivot, littles, bigs:
quicksort(littles) + [pivot] + quicksort(bigs)
)(xs[0], *partition(xs[1:], lambda x: x < xs[0]))
次に、要望を示す
・関数 partition について、条件分岐が(and と or の)２度使われている
他の言語と同様に、１回の条件分岐で書き換えできないだろうか？(これは容易なはず)
・関数 partition について、>>72のアルゴリズム定義では部分リストを変数 Ys と Zs で表現している
他の言語と同様に、変数 ys, zs を残したコードに書き換えできないだろうか？
・関数 quicksort について、入力リストの先頭要素 xs[0] へのアクセスが２度行われている
他の言語と同様に、変数 ys, zs を残したコードに書き換えできないだろうか？
0335前スレ367
2013/09/03(火) 21:18:42.65X: 他の言語と同様に、変数 ys, zs を残したコードに書き換えできないだろうか？
O: 他の言語と同様に、先頭要素へのアクセスを１度だけとするコードへ書き換えできないだろうか？
0336デフォルトの名無しさん
2013/09/03(火) 21:57:22.45サクサク書けるし、開発環境もブラウザだけで下手なIDEより機能充実してるからお手軽。
undefinedとnullと0以外はtrueというのも好きだ。
ただ強いて言えば、一つのHTMLに多数の.jsを埋め込んで全て同じ階層で実行されるというのが嫌。
せめて名前空間みたいなものがあって、グローバルオブジェクトは基本的に名前空間.オブジェクトという書式でしか呼び出せないとかあれば。
あとはいまだにfor (var i=0; ....)のループを使うしかなかったりとかも難。
個人的には、Perl、Java、Objective-Cよりは全然好きだわ。
0337デフォルトの名無しさん
2013/09/03(火) 21:59:09.86いまさら
0338デフォルトの名無しさん
2013/09/03(火) 22:01:07.18・Rubyでは、整数(Integerクラス)でゼロ除算があると例外 ZeroDivisionError を投げるが、
浮動小数点(Float)でゼロ除算があると定数 Float::INFINITY を返す
・浮動小数点の振る舞いは、標準規格である IEEE 754 に従った実装によるもの
Ruby 2.0.0 リファレンスマニュアル > ライブラリ一覧 > 組み込みライブラリ > Floatクラス
http://doc.ruby-lang.org/ja/2.0.0/class/Float.html
・IEEE 754 実装は、もしIEEE 754に従う厳密な数式処理/数値計算システムを開発するのなら好ましい
また、Ruby2.0では>>133のコードで示したように無限(無限数/無限シーケンス)を扱う方向で
開発が進められており、この流れに沿った適切な判断だと思う(真実はRubyの中の人しか知らない....)
・もし整数と同じ振る舞いを望むのであれば、以下のようにメソッド Float#(y) をオーバライドするだけ
class Float
def /(y)
if y == 0.0 then raise ZeroDivisionError else self / y end
end
end
結論：ことRubyに限れば、熱く論争するほどのトピックではない
0339デフォルトの名無しさん
2013/09/03(火) 22:03:10.97X: メソッド Float#(y) をオーバライドするだけ
O: メソッド Float#/(y) をオーバライドするだけ
0340デフォルトの名無しさん
2013/09/03(火) 22:09:34.94>あとはいまだにfor (var i=0; ....)のループを使うしかなかったりとかも難。
Array.forEach や Array.map ではダメなの？
あと、グローバルオブジェクトによる汚染問題については同感で、
(Java風の？)階層的な名前空間を構文として導入し、今のまちまちな記述が統一化されると嬉しい
0341前スレ367
2013/09/03(火) 22:14:40.76def partition(xs, f):
return reduce(
lambda pair, x:
f(x) and (pair[0] + [x], pair[1]) or (pair[0], pair[1] + [x]),
xs, ([], [])
)
def quicksort(xs):
return xs if len(xs) <= 1 else (
lambda pivot, littles, bigs:
quicksort(littles) + [pivot] + quicksort(bigs)
)(xs[0], *partition(xs[1:], lambda x: x < xs[0]))
0342デフォルトの名無しさん
2013/09/03(火) 22:54:03.63配列内包の気持ち悪さって、具体的には何？
0343デフォルトの名無しさん
2013/09/03(火) 23:34:36.19言語としては別に普通レベルに良い
0344デフォルトの名無しさん
2013/09/03(火) 23:36:12.89日本人には語順が意味不明だし表現力もあまり高くないから嫌われるのはわかる
0345デフォルトの名無しさん
2013/09/03(火) 23:44:49.50本来文のforやifをまるで式のように使えるのは変だな
0346デフォルトの名無しさん
2013/09/04(水) 00:16:16.070347デフォルトの名無しさん
2013/09/04(水) 00:29:04.79ちゃんと前スレ367って付けろよ。非表示にならないじゃないか！
0348デフォルトの名無しさん
2013/09/04(水) 00:52:02.71こういうのってどこで決まるんだろう。
既発スタッフの技術力？
0349デフォルトの名無しさん
2013/09/04(水) 00:57:46.40注文の多いやっちゃな、それぐらい自分で書け
def partition(xs, f):
return reduce(lambda (ys,zs), x: (ys + [x], zs) if f(x) else (ys, zs + [x]), xs, ([], []))
def quicksort(xs):
return xs if len(xs)<=1 else (lambda pivot: (lambda littles, bigs: quicksort(littles) + [pivot] + quicksort(bigs))(*partition(xs[1:], lambda x: x < pivot)))(xs[0])
0350デフォルトの名無しさん
2013/09/04(水) 02:30:30.570351デフォルトの名無しさん
2013/09/04(水) 11:07:40.390352デフォルトの名無しさん
2013/09/04(水) 12:29:42.100353デフォルトの名無しさん
2013/09/04(水) 15:38:01.650354デフォルトの名無しさん
2013/09/04(水) 17:28:20.000355デフォルトの名無しさん
2013/09/04(水) 17:54:55.720356デフォルトの名無しさん
2013/09/04(水) 18:07:24.47JavaScriptでメモリ内容を直接書き換える方法を教えてくれや
0357デフォルトの名無しさん
2013/09/04(水) 18:37:03.14インタプリタの中からJSが命令して外でCが実行する
Cが実行できることなら何でも命令できる
0358デフォルトの名無しさん
2013/09/04(水) 18:40:58.15「外」の処理系をJavaScriptで作りたいんやが
どうすればええんや？
0359デフォルトの名無しさん
2013/09/04(水) 19:45:42.810360デフォルトの名無しさん
2013/09/04(水) 19:49:12.70最凶仕様のCより早くできないのはおかしいとでも？馬鹿すぎる
全知全能のプログラマにバグの管理を任せることで高速化してるだけ
0361デフォルトの名無しさん
2013/09/04(水) 20:21:42.190362デフォルトの名無しさん
2013/09/04(水) 20:23:53.42より最適化のためのヒントを付加できる言語がずっと遅いって、甘えだろ
0363前スレ367
2013/09/04(水) 21:17:33.68コードありがとう
>>334と同様、可読性を考慮してインデントを書き直した：
def partition(xs, f):
return reduce(
lambda (ys,zs), x: (ys + [x], zs) if f(x) else (ys, zs + [x]),
xs, ([], [])
)
def quicksort(xs):
return xs if len(xs)<=1 else (
lambda pivot: (
lambda littles, bigs: quicksort(littles) + [pivot] + quicksort(bigs)
)(*partition(xs[1:], lambda x: x < pivot))
)(xs[0])
次に要望：
・関数 quicksort について、「ラムダ式が入れ子」になっている
他の言語と同様に、１つのラムダ式で書き換えできないだろうか？
・なお、他の言語と同様、>>334(>>335)の要望も満たすコードを考えてもらいたく
0364デフォルトの名無しさん
2013/09/04(水) 22:32:28.12って結論で良くね？
ここまで粘着してるの見るとキモ過ぎて怖いわ
0365デフォルトの名無しさん
2013/09/04(水) 22:37:13.72でもそれを言ってる奴は変数定義できると
関数型プログラミングに適さないとも言ってるぜ？
相手がPythonかどうかなんて関係ないんだよ
0366デフォルトの名無しさん
2013/09/04(水) 22:47:21.55（変数を宣言しない）純粋な関数型プログラミングに近いと言えるが、
そもそも関数型プログラミングの可読性が低いので、ラムダの入れ子も可読性が低い
0367デフォルトの名無しさん
2013/09/04(水) 22:50:39.60あれは関数型に慣れてる頭じゃないと読めないと思う
0368デフォルトの名無しさん
2013/09/04(水) 23:08:13.27Pythonでreduce使ったコードより
手続き型でループ回したコードの方が読みやすいよね？
0369前スレ367
2013/09/04(水) 23:24:11.82>「lambdaを入れ子にしないと変数定義が書けないPythonは関数型プログラミングに適さない」
>って結論で良くね？
その結論には反対する
とりえあえずは、
「式指向であるPythonは関数型プログラミングに適している(>>72で実証済み)。
ただし、ラムダ式の本体部で局所宣言できないので、RubyやJavaScriptに劣る一面がある」
くらいだろな
もし「劣る」という言葉が厳しすぎるなら、「表現の制約が強い」と言い換えてもいい
それよりも、>>349(または別のPythonプログラマ)がコードを書いてくるのを待つことにしようぜ
>>365
え、えっ！！
まったく正反対に解釈してるみたいだね
困ったものだ.....
0370デフォルトの名無しさん
2013/09/04(水) 23:32:49.85表現の制約が強いことを劣ってるというなら、関数型言語は劣ってるってことだな
0371デフォルトの名無しさん
2013/09/04(水) 23:34:56.09制約というか縛りプレイだよ
0372デフォルトの名無しさん
2013/09/04(水) 23:39:41.69Lisp系はマクロが強力なので、
これらは縛りプレイしてまで使う価値があるのかもしれんが、
LLで関数型縛りしても何の意味もないよね
0373デフォルトの名無しさん
2013/09/04(水) 23:45:57.72それがなければ大した意味は無いとおもう。
0374デフォルトの名無しさん
2013/09/04(水) 23:47:13.03スレタイの言語で関数型を誇ってもしかたない気もする……
0375デフォルトの名無しさん
2013/09/04(水) 23:52:20.78(defun partition (f xs)
(reduce (lambda (cons x)
(destructuring-bind (ys . zs) cons
(if (funcall f x)
(cons (cons x ys) zs)
(cons ys (cons x zs)))))
xs
:initial-value (cons nil nil)))
(defun quicksort (list)
(when list
(destructuring-bind (pivot . xs) list
(destructuring-bind (littles . bigs)
(partition (lambda (x) (< x pivot)) xs)
(append (quicksort littles) (list pivot) (quicksort bigs))))))
ちなみに自分はreduceはあまり使わず、loopをよく使う。
0376デフォルトの名無しさん
2013/09/04(水) 23:53:29.79メモリバスと競合のオーバーヘッドの関係で全コア使って２倍になったらかなりいい方
それだけのことする価値はないと思う
マルチスレッドはマルチスレッドとしてプログラム組まないと現状仕方ない
0377前スレ367
2013/09/04(水) 23:54:14.57>関数型で書かなくちゃいけないってのがもう次元が違うよな
そういう「お題」なんだから、しかたないのではないかと....
>制約というか縛りプレイだよ
Pythonの一人縛りプレイ状態？
>>372
X: LLで関数型縛りしても何の意味もないよね
O: Pythonで関数型縛りしても何の意味もないよね
0378デフォルトの名無しさん
2013/09/04(水) 23:55:42.160379デフォルトの名無しさん
2013/09/04(水) 23:56:29.65どこが関数型よ、と言いたいw
0380デフォルトの名無しさん
2013/09/04(水) 23:56:52.82判定してる奴が恣意的だからまともな収束なんてしない
0381デフォルトの名無しさん
2013/09/04(水) 23:57:07.45そろそろ飽きないか？
0382デフォルトの名無しさん
2013/09/04(水) 23:58:18.690383デフォルトの名無しさん
2013/09/04(水) 23:59:42.88それが言えるようなお題にしてくれ
恣意的に判定するんじゃなくてさ
0384デフォルトの名無しさん
2013/09/05(木) 00:01:32.050385デフォルトの名無しさん
2013/09/05(木) 00:05:57.06Lispならletがなければlambdaからつくればいいじゃないって世界だわな
>>384
低レベルってどういう意味で使ってる？
0386デフォルトの名無しさん
2013/09/05(木) 00:14:42.86関数型なら条件分岐とかのマルチスレッド化投機が容易なんだよね。
でもそれって絶対に副作用のない真の関数型言語じゃないと厳しいと思う。
0387デフォルトの名無しさん
2013/09/05(木) 00:16:52.70なんで関数型っぽさをかなり取り入れたんだろう
不思議
0388デフォルトの名無しさん
2013/09/05(木) 00:17:40.72現状でさえマルチスレッドプログラミングは開発の困難さが指摘されている分野である｡
同時並列的に動作するプログラムがモデルデータやゲーム内状態などの共有情報にアクセスしようとするとき､
そこには必ずデータ競合によるバグの発生や､デッドロックによるプログラムの停止というリスクがつきものである｡
しかも､それを効率的にデバッグすることは非常に難しく､開発規模の拡大や期間の長大化を招いているのだ｡
Sweeney氏は､この問題を解決するためには､ゲーム開発言語として純粋関数型の言語が必要になるだろうと言う｡
各関数のアトミック性が構造的に保証されており､安全に並列実行できるのだ｡
しかも､コンパイラが対応さえすれば､関数を自動的に多数のコアに分散処理させることができるというスケーラブルな実行バイナリを作り出せる｡
Sweeney氏は純粋関数型言語のもつ並列処理安全性に着目しており､将来的にゲームプログラミングはそういった処理系に移行していくべきだとした｡
その抜本的解決になりそうな言語は純粋関数型の言語特性を持たなければならないが､現在のところゲーム開発に使えるレベルの処理系は存在しない｡
Sweeney氏は将来､ゲーム開発に使える純粋関数型言語が開発されることを期待している｡
http://game.watch.impress.co.jp/docs/20080911/epic.htm
コンピュータサイエンス史上最大の課題｢並列処理による性能向上｣
現在のソフトウェアは､ここで必要とされるような並列化を提供していません｡性能を向上するにはソフトウェアの並列化に向かわなければなりませんが､それは提供できていない｡これが現在のジレンマです｡
ハードウェアレベルでは､今後10年から12年後にはチップに15ビリオン(150億)のトランジスタが乗ることが現実となります｡
こうした新しい並列化のためのコードをユーザーは書くことができるのでしょうか? どうすれば15ビリオンのトランジスタが乗っているチップを､私たちは使いこなすことができるのでしょうか?
とりわけ言語に課題があると考えています｡現在プログラミングによく使われているCやC++､Javaといった言語はハードウェアに近いものであり､言語としてローレベルです｡
http://www.publickey1.jp/blog/10/50.html
0389デフォルトの名無しさん
2013/09/05(木) 00:30:35.71メインメモリとの転送能力がCPUの処理能力に対して100倍レベルで不足しているのは変わらないわけで
結局そこがボトルネックになってる処理はどうしようもなくないか
コア数が２桁になってくると安全性が強く活きてくるかもしれんが
0390デフォルトの名無しさん
2013/09/05(木) 00:37:53.34ハードウェアとソフトウェアは別。
1コアでも1万コアでも同一ソースで動いて
人間が手動でマルチコアに最適化させたものに匹敵するものはない。
0391デフォルトの名無しさん
2013/09/05(木) 00:52:12.20コアを使わせやすい関数型が活きるかもしれないね
そこまでくると人の手（非関数型言語）で最適化は限界があるって話
問題は数コアとかで勝手に振り分けて貰うべきかってこと
沢山のサブプロセッサに処理を分担するのは向いてるけど、
現状全部メインだよねって感じ
0392デフォルトの名無しさん
2013/09/05(木) 00:58:49.28ファミコンじゃないんだから……
0393デフォルトの名無しさん
2013/09/05(木) 01:04:14.180394デフォルトの名無しさん
2013/09/05(木) 01:04:56.84プログラマの指示なしには1スレッド動作。
OSが空きリソースに割り振るかもしれないが、自動で最大限の性能を出せるようになってない。
0395デフォルトの名無しさん
2013/09/05(木) 01:15:05.95手続き型でいいところは手続き型で書けばいいと思う。
0396デフォルトの名無しさん
2013/09/05(木) 01:15:38.85まあ使い物になるレベルのものは確かに現存してないが
0397デフォルトの名無しさん
2013/09/05(木) 01:16:55.970398デフォルトの名無しさん
2013/09/05(木) 01:19:28.36そういうのは100コアとかになってこないと流行らないと思う。
そもそも現状のアーキテクチャじゃバス幅がボトルネックで特殊な場合じゃないとパフォーマンス上がらないし。
0399デフォルトの名無しさん
2013/09/05(木) 01:21:19.160400デフォルトの名無しさん
2013/09/05(木) 01:25:45.87Parallels.jsみたいに配列の各要素に比較的重い処理をかける時明示的にパラレルにしてもらうくらいが関の山
0401デフォルトの名無しさん
2013/09/05(木) 01:30:47.73クロージャはオブジェクトと同じだから
ラムダの外側にインスタンス変数のようなものがあるのがクロージャ
読みにくいのはデザインパターンと同じ
でもデザパタじゃなくて数学やりたいと思ったら
ラムダの外側の変数とか考えたくないだろ？
0402デフォルトの名無しさん
2013/09/05(木) 01:31:52.09お得意のコールバックで頑張ればいいのにと思うんだけど
そうもいかないのかな
0403デフォルトの名無しさん
2013/09/05(木) 01:39:18.24気軽に関数単位でマルチスレッド化できる事じゃないかな
それで十分な気もするけどどう思う？
0404デフォルトの名無しさん
2013/09/05(木) 01:45:34.17ネイティブと複雑なデータやりとりすんの面倒くさくね
辞書だの木だの受け渡しとか吐き気がする
>>403
C++だとg++のparallel mode、MSVCのPPLみたいなの昔から考えるとすげー楽だわな
std::foreach -> __gnu_parallel::foreachとか書き換えるだけ、みたいな
.NETもそんな感じだし、Javaも8でそういうの来るみたいだな
0405デフォルトの名無しさん
2013/09/05(木) 01:46:27.150406デフォルトの名無しさん
2013/09/05(木) 01:50:10.500407デフォルトの名無しさん
2013/09/05(木) 02:05:36.45この辺か
http://wiki.ecmascript.org/doku.php?id=strawman:data_parallelism
http://wiki.ecmascript.org/doku.php?id=strawman:async_functions
0408デフォルトの名無しさん
2013/09/05(木) 02:13:49.200409デフォルトの名無しさん
2013/09/05(木) 02:33:46.70ヘタすると言語崩壊するな
0410デフォルトの名無しさん
2013/09/05(木) 02:41:21.91コンバーターがあればどうとでもなると思う。
0411デフォルトの名無しさん
2013/09/05(木) 02:41:56.91で問題解決だ！
0412デフォルトの名無しさん
2013/09/05(木) 03:24:57.25逆でしょ
古いコンテンツへの互換を切れないから大変ってこと
0413デフォルトの名無しさん
2013/09/05(木) 15:02:00.51他の言語もAPIスタイルの流行ってあるの？
0414デフォルトの名無しさん
2013/09/05(木) 16:46:16.590415デフォルトの名無しさん
2013/09/05(木) 18:32:50.06なんで昔も言語によっちゃ流行ってたの？
0416デフォルトの名無しさん
2013/09/05(木) 19:12:00.670417前スレ367
2013/09/05(木) 19:52:12.90partition(F, Xs) ->
lists:foldr(
fun(X, {Ys, Zs}) ->
case F(X) of
true -> {Ys ++ [X], Zs};
false -> {Ys, Zs ++ [X]}
end
end,
{[], []}, Xs
).
quicksort2([]) -> [];
quicksort2([Pivot|Xs]) ->
{Littles, Bigs} = partition(fun(X) -> X < Pivot end, Xs),
lists:append([quicksort2(Littles), [Pivot], quicksort2(Bigs)]).
0418前スレ367
2013/09/05(木) 20:11:18.37反復処理をコルーチンで記述する手法は昔から存在したが、
「反復の抽象化としてのイテレータ(反復子)」を言語の要素に取り込んだのは、
おそらく手続き型言語 CLU が最初
図書館でbitの連載記事を見た記憶を辿ると、1970年代になる
で、ほぼ同じ時期、最初のオブジェクト指向言語Smalltalkでも
イテレータに相当する仕掛けが導入された
ただし、これら言語のイテレータという概念は
専門家(研究者)の間では知られていたのかもしれないが、
一般のプログラマにとっては雲の上の話でしかなかった
とはいえ、たとえばC言語でコレクションを扱う時に
xxx_get_first(&iterator, &collection) と xxx_get_next(&iterator) という関数を
介してアクセスする技法(テクニック)は、一部では実践されていた
これがブームになったのは、GoF本でIteratorパターンが登場してからだろう
1980年代の中盤になる
さらに、イテレータを言語の基本設計レベルで取り込んだスクリプト言語、
Rubyが1990年代に登場して現在に到る、という流れかな
0419デフォルトの名無しさん
2013/09/05(木) 20:38:40.15Rubyにいわゆる普通のイテレータ(外部イテレータ)が導入されたのは結構最近だぞ
メジャーな言語に組み込まれたのはPythonやC#が先だ
Rubyワールドでは、コードブロックを使った旧来の列挙方式を内部イテレータ、
カーソル的なオブジェクトを使った新しい方式を外部イテレータと呼んで区別するが、
前者は実体がないからイテレータと呼ぶのは苦しいし実装が単純なだけで非常に制限の多い方法
0420デフォルトの名無しさん
2013/09/05(木) 20:43:21.51それまではイテレーターとか自分でインターフェイス定義するしかなかった
0421デフォルトの名無しさん
2013/09/05(木) 20:52:34.36Rubyの内部イテレータって>>105みたいなのは原理的に遅延評価では実現できないからね
クソみたいな方法
0422デフォルトの名無しさん
2013/09/05(木) 20:54:24.860423前スレ367
2013/09/05(木) 21:16:14.06CLUのイテレータは、いわゆる内部イテレータだよ
Rubyは、CLUのアイデアをほぼそのままパクって導入した
内部イテレータが外部イテレータと比較して表現力に劣るのは事実だけど、
その代わり反復(イテレーション)を簡潔に記述できる利点があるし、
有限コレクションを扱う多くのケースでは内部イテレータで十分
おまけに外部イテレータもRuby1.9から、無限イテレーションもRuby2.0でサポートされた
これで、イテレータに関しては、全方位で対応ができるから問題ナシじゃね？
>>421
クイックソートをC#のLINQでは>>101で、Rubyのメソッドチェーンを介した
内部イテレータでは>>105でコードが示された
さて、Pythonの外部イテレータでは、どんなコードになるの？
>>105の内部イテレータを「クソ」と言うからには、外部イテレータでも書けるんだよね？
あと、>>133は無限コレクションに対応したRuby2.0のコードだけど、
これはPythonの外部イテレータではどうなるんだろなあ....？
ところで、>>363の要望へのレス(Pythonコード)を待っているんだけど、まだかなあ.....
0424デフォルトの名無しさん
2013/09/05(木) 21:27:38.22rubyの内部イテレータのようにあんまり基礎的なところに据えると失敗するんだよね
SAXとプルパーサの関係に通じる
>>423
lazyは外部イテレータだよw
結局不便だから外部イテレータに乗り換えたの
0425デフォルトの名無しさん
2013/09/05(木) 21:28:20.37[1,2,3,4].each {|x| puts x; break} #=> 1
って感じでブロック内でbreakすると何故かeachの実行が途中で止まったり、
def f()
puts 'begin'
[1,2,3,4].each {|x| puts x; return}
puts 'end'
end
って感じでブロック内でreturnすると何故かfの実行が途中で止まったりするのでビックリした
ブロックはクロージャじゃなく、もっとおぞましい何かだよね
0426デフォルトの名無しさん
2013/09/05(木) 21:39:01.80勉強になる
0427デフォルトの名無しさん
2013/09/05(木) 21:47:50.95C#のLINQも外部イテレータ
list.Where(x => x < 3).Select(x => x * 2) はリストを操作しているのではなくて
要素をフィルタリングして射影する外部イテレータを定義している
そのイテレータを使って要素を取得しようとするときになって、はじめて実際に評価が行われる
それに対し、>>105のコードはメソッドを呼ぶたびにリストができる
それを改善するためにまんまC#と同じ仕組を導入したのがRubyのlazyだ
0428デフォルトの名無しさん
2013/09/05(木) 21:50:40.13なんてどうでも良くて、コードの見た目が全てなんだよ
0429デフォルトの名無しさん
2013/09/05(木) 21:53:27.06本物の関数型言語から見ると>>133はウンコすぎるので
Rubyでドヤ顔やめてね恥ずかしいから
take 10 [x * 2 | x <- [1..]]
0430前スレ367
2013/09/05(木) 21:56:08.53・Rubyist Magazine - Rubyist のための他言語探訪 【第 2 回】 CLU
http://magazine.rubyist.net/?0009-Legwork
・Rubyチュートリアル：6. イテレータ … ブロック付きメソッド
http://www.oki-osk.jp/esc/ruby/tut-06.html
・岩波講座 情報科学〈12〉算法表現論 (1982年): 木村 泉, 米澤 明憲
http://www.amazon.co.jp/dp/B000J7P0KY/
最後の「算法表現論」という古書だけど、「制御構造の抽象化」という節の中で、
CLU風の言語を使ってイテレータや例外(exception)を簡潔に解説している
他にも、この板でたびたび出てくる(手続き型言語と関数型言語の統合計算モデルとしての)
アクター理論、(型推論が登場する以前の)関数型言語、証明論の基礎など、
プログラミング言語設計技術に関する幅広い分野を扱っているのでオススメする
0432デフォルトの名無しさん
2013/09/05(木) 21:58:16.040433デフォルトの名無しさん
2013/09/05(木) 21:59:38.29さすがに>>423は酷すぎる
0434デフォルトの名無しさん
2013/09/05(木) 21:59:50.810435前スレ367
2013/09/05(木) 22:01:25.88>lazyは外部イテレータだよw
いや、正確に言えばファイバー(Fiberクラス)だよ
そして、lazyが従来の内部イテレータと組み合わせてチェーンを構成できること、
それがプログラマにとっては大切だと思う
0437デフォルトの名無しさん
2013/09/05(木) 22:02:43.53> 外部イテレータとしての機能は Fiber を用いて実装されているため Fiber と同じ制限があります。
0438デフォルトの名無しさん
2013/09/05(木) 22:03:04.59いつまでquicksortやってんだよこのアスペは
0439デフォルトの名無しさん
2013/09/05(木) 22:06:45.810440デフォルトの名無しさん
2013/09/05(木) 22:06:55.54Pythonだと
from itertools import *
islice((x * 2 for x in count()), 10)
かな
なんだRubyって2.0になるまで>>133程度の機能もなかったのか？
0441デフォルトの名無しさん
2013/09/05(木) 22:07:14.34C#がコルーチンでyieldを実装した時にはヘルスバーグの頭がおかしくなったのかと思ったが
難しい説明をしないだけでなんだかんだ言って妥当で理論的背景のある設計だったんだね
0442前スレ367
2013/09/05(木) 22:10:57.79Erlang で
partition(F, Xs) ->
lists:foldr(
fun(X, {Ys, Zs}) ->
case F(X) of
true -> {Ys ++ [X], Zs};
false -> {Ys, Zs ++ [X]}
end
end,
{[], []}, Xs
).
quicksort([]) -> [];
quicksort([Pivot|Xs]) ->
{Littles, Bigs} = partition(fun(X) -> X < Pivot end, Xs),
lists:append([quicksort(Littles), [Pivot], quicksort2(Bigs)]).
0443デフォルトの名無しさん
2013/09/05(木) 22:11:40.72実際はライブラリや開発環境の充実度、エコシステムの活発さの方が大事だけど
0444前スレ367
2013/09/05(木) 22:28:28.91>なんだRubyって2.0になるまで>>133程度の機能もなかったのか？
必要性が無かった、あるいは優先度が低かったのではないかと思う
実際、数学的なモデリングを日常的に行う人達を除けば、
日常的なプログラミング活動で無限を扱うことってほとんど無いよね
たとえばfizzbuzzやエラトステネスの篩といった「お題」は、
プログラミングとしては興味深いけど、その実用性を問われれば返答に困る
あと、>>429のHaskellみたいに内包表記では書けないの？
islice([x * 2 for x in count(1)], 10)
こんな感じで
0445デフォルトの名無しさん
2013/09/05(木) 22:32:38.390446デフォルトの名無しさん
2013/09/05(木) 22:39:47.58関数型っぽくかけるのは一部の処理を「簡潔に書く」ためであって
多重ネストのラムダ式とか関数型の精神や設計を模倣しようとするのは無茶だよ
そこまで考えて言語も作られてない
もっと普通のコードで戦おうぜ
0447デフォルトの名無しさん
2013/09/05(木) 22:44:36.61ばっかじゃねーの
ジェネレータ式も内包表記だろうが
0448デフォルトの名無しさん
2013/09/05(木) 22:46:46.86関数型スタイルの真の恩恵はスタイルを貫き通さないと得られないんだから、
そこまで張り合うのなら最初から関数型言語使えばいいじゃん？ってことにならない？
0449デフォルトの名無しさん
2013/09/05(木) 22:47:23.73同意
0450デフォルトの名無しさん
2013/09/05(木) 22:50:45.35知ってるよ
0451デフォルトの名無しさん
2013/09/05(木) 22:51:33.24> 日常的なプログラミング活動で無限を扱うことってほとんど無いよね
え？全然そんなことないぞ
ストリームの一番典型的な例はファイルやネットワーク等の入出力だし
import sys
from itertools import *
stream = iter(lambda: sys.stdin.readline().rstrip(), '')
doubled = imap(lambda x: x + x, stream)
for x in doubled:
print x
0452デフォルトの名無しさん
2013/09/05(木) 22:54:46.58その辺ってもっと抽象化されるべきじゃないの？
逆に扱いづらいわ
0453デフォルトの名無しさん
2013/09/05(木) 22:59:33.62別にソートはどうとでも書けるしね
なんとしてでも１、２行で書かないといけないわけでもないし
0454デフォルトの名無しさん
2013/09/05(木) 23:01:48.79こうじゃね？
stream = (x.rstrip() for x in sys.stdin)
0455デフォルトの名無しさん
2013/09/05(木) 23:05:36.330456デフォルトの名無しさん
2013/09/05(木) 23:07:27.550457デフォルトの名無しさん
2013/09/05(木) 23:09:43.81端末から実際に入力してみると違いがわかるよ
そう書きたいが、そう書くと期待した動作にならない
0458前スレ367
2013/09/05(木) 23:10:15.04そうかなあ？
自分は関数型プログラミングには不慣れだから、
I/O処理は普通に手続き型プログラミングのスタイルで書くよ
import sys
def get_line():
return sys.stdin.readline().rstrip()
def compute(string):
return string + string
line = get_line()
while line != '':
print compute(line)
line = get_line()
もしも、このコードの関数 compute の定義が複雑になった時には、
はじめて(副作用の無い)式を関数型プログラミングのスタイルで書くことを考えるなあ....
それとも、Pythonコミュニティでは、>>451のほうが「ふつう」のコードなの？
0459457
2013/09/05(木) 23:11:03.62Python知らない人にはimapのほうが分かりやすいかと思って
0460デフォルトの名無しさん
2013/09/05(木) 23:12:23.05キャメルケースにならんかな
0461デフォルトの名無しさん
2013/09/05(木) 23:13:19.02手続き型言語の分際で関数型ゴッコやってんじゃなかったのか？
不得意分野は逃げるだけっすか
0462デフォルトの名無しさん
2013/09/05(木) 23:15:31.82石頭か？
0463デフォルトの名無しさん
2013/09/05(木) 23:16:31.83勿論関数型方面から来てる話だけど、MicrosoftもReactive Extension(Rx)とか
出してたりする（イベントのストリームにLINQ適用したりとかそういうの）
0464デフォルトの名無しさん
2013/09/05(木) 23:17:55.51あ、imap使ってるしPython2か
間違えたよスマン
0465デフォルトの名無しさん
2013/09/05(木) 23:18:41.02imapもそうだけどprint文なので……
こっちこそすみませんすみません
0466デフォルトの名無しさん
2013/09/05(木) 23:21:20.800467デフォルトの名無しさん
2013/09/05(木) 23:25:26.84関数型と手続き型で優劣の差がなかったクイックソートに比べると
> line = get_line()
> while line != '':
> print compute(line)
>
> line = get_line()
これは明らかに関数型スタイルに比べて劣ってないか？まあ主観だけど
0468デフォルトの名無しさん
2013/09/05(木) 23:29:35.400469デフォルトの名無しさん
2013/09/05(木) 23:31:29.350470デフォルトの名無しさん
2013/09/05(木) 23:32:45.26毎回手動でEOF判定するより、無限ストリームとして扱えた方が
良いに決まってる
0471デフォルトの名無しさん
2013/09/05(木) 23:37:44.20非同期や遅延評価じゃないと駄目だし、そうだとしたら処理の流れが分かりにくい気がする
0472前スレ367
2013/09/05(木) 23:38:42.29そこは臨機応変にw
というか、Haskellに代表される純粋関数型パラダイムは、
学術的な価値や貢献はあっても、現状では実用性に問題があると考えている
だから、もし静的型付けな関数型言語であればML族(F#/OCaml/SML)を推す
Rubyも動的型付けであるけれど、ML族と同じ非純粋関数型パラダイムで
関数型プログラミングを楽しめばいいと思っている
たとえば、ここの過去スレであった「RPN計算機」というお題では、
多くのコードは関数型プログラミングで書いているけど、メインループの
I/O処理部分(コードの一番最後)だけは、手続き型の until ... end 構文で書いていた
http://play.island.ac/codepaste/code?id=27
ただし、最近はRuby1.9で導入されたEnumeratorクラス(外部イテレータというかジェネレータ)を
使い始めているけどね
http://play.island.ac/codepaste/code?id=1553 -- 内部イテレータ版
http://play.island.ac/codepaste/code?id=1554 -- 外部イテレータ版
0473デフォルトの名無しさん
2013/09/05(木) 23:38:46.77stream = (x.strip() for x in sys.stdin)
joined = (x + y for x, y in zip(stream, stream))
for x in joined: print(x)
0474デフォルトの名無しさん
2013/09/05(木) 23:41:13.430475デフォルトの名無しさん
2013/09/05(木) 23:41:23.89do記法も使ってるので、手続き型風味
import Control.Applicative
main = do
stream <- lines <$> getContents
mapM_ (putStrLn . doubled) stream
where
doubled x = x ++ x
0476デフォルトの名無しさん
2013/09/05(木) 23:42:29.39気になる
IO処理でブロッキングは実アプリケーションじゃご法度だと思うし
0477デフォルトの名無しさん
2013/09/05(木) 23:46:10.37勿論eagerにしか処理できない言語だと、全部リストに読み込んでからじゃないと
mapとかできないので非実用的
今の例は遅延で動いてる
0478前スレ367
2013/09/05(木) 23:47:23.10確かに>>456の手続き型コードよりも、
>>451(Python)や以下(Ruby)のコードのほうがエレガントに見えるねえ....
STDIN.each_line.lazy.map { |input_line|
line = input_line.chop
line + line
}.each do |line|
puts line
end
0480前スレ367
2013/09/05(木) 23:57:01.13そのとおりだね
実際、>>478のコードは改行するたびに結果が返されるけど、
メソッド lazy を外してしまうと
EOF(コントロール+D)が入力されるまで計算結果が出力されなくなる
0481デフォルトの名無しさん
2013/09/05(木) 23:59:16.01import sys
stream = (x.rstrip() for x in sys.stdin)
for x in map(lambda x: x + x, stream):
print(x)
0482デフォルトの名無しさん
2013/09/06(金) 00:03:00.14print(double(readline())って感じに関数合成するだけでいいよ
0483デフォルトの名無しさん
2013/09/06(金) 00:07:23.41それで遅延ストリームが動くの？すげえぇ！
で、どの言語の話？
0484デフォルトの名無しさん
2013/09/06(金) 00:11:05.000485デフォルトの名無しさん
2013/09/06(金) 00:17:32.34今の例はたまたまそれでいいけど、mapじゃなくてfilterだとそれじゃだめだし
0486デフォルトの名無しさん
2013/09/06(金) 00:54:41.50RubyのEnemerator::Lazyは外部イテレーターそのものというわけではない
結果を配列で返すのではなく
手続きをラッピングしたオブジェクト(Enemerator::Lazy)で返すことにしただけのもの
外部イテレーターとしての機能もあるけど
（EnumeratorもLazyも)外部イテレーターとして使われることは少なく
内部イテレーターをラッピングして、遅延させたものとしてしか使われない
Fiberつかってるのは実装しやすいからで
(EnumeratorのためにFiberが実装されたのだが)
1.8では継続を使ってたし
1.9開発初期にはThreadを使ってたことがある
0487デフォルトの名無しさん
2013/09/06(金) 01:15:11.690488デフォルトの名無しさん
2013/09/06(金) 01:17:23.73やり直し
0489デフォルトの名無しさん
2013/09/06(金) 01:29:14.420490デフォルトの名無しさん
2013/09/06(金) 01:41:14.610491デフォルトの名無しさん
2013/09/06(金) 05:46:16.56r'￣ヽ 打 祗園精舎の鐘の声、（ぎおんしょうじゃのかねのこえ）
'心゛ゎｊ | 諸行無常の響きあり。（しょぎょうむじょうのひびきあり）
／にソﾉそ`ヽ、 娑羅双樹の花の色、（しゃらそうじゅのはなのいろ）
/ ｿ V / |||｀ヽﾉlヽ 盛者必衰の理をあらはす。（じょうしゃひっすいのことわりをあらわす）
{. ＼∨ ||| |V 丿おごれる人も久しからず、（おごれるひともひさしからず）
jヽ(巛＜!巾 ,! く 唯春の夜の夢のごとし。（ただはるのよのゆめのごとし）
（´￣￣ ヽ== へ ＼ たけき者も遂にはほろびぬ、（たけきものもついにはほろびぬ）
ムニ二{ミｽ二二人＿ﾉ 偏に風の前の塵に同じ。（ひとえにかぜのまえのちりにおなじ）
0492デフォルトの名無しさん
2013/09/06(金) 06:41:53.440493デフォルトの名無しさん
2013/09/06(金) 07:28:35.06状態を持つ列挙子の実体があって外部に返すんだから外部イテレータの方が近いだろ
しかもその実装方法、列挙子の構造やマイクロスレッド使ってるところまでC#とまんま同じなんだけど
0494デフォルトの名無しさん
2013/09/06(金) 07:40:07.010495デフォルトの名無しさん
2013/09/06(金) 07:46:26.74スクリプト言語が嫌いになるスレ
0496デフォルトの名無しさん
2013/09/06(金) 11:11:48.550497デフォルトの名無しさん
2013/09/06(金) 12:04:07.180498デフォルトの名無しさん
2013/09/06(金) 12:33:11.251.8でgenerator expression(Pythonと同じ奴)が導入されてるみたい
EcmaScriptだと策定中の6で入る予定じゃね
0499デフォルトの名無しさん
2013/09/06(金) 12:34:38.12| double |
double := [:x | x, x].
1 to: FloatD infinity do: [:each |
Transcript cr; show: (double value: stdin nextLine)]
0500デフォルトの名無しさん
2013/09/06(金) 13:05:03.54それぞれのイテレータはかなり違う
http://d.hatena.ne.jp/teramako/20130831/p1#c
0501デフォルトの名無しさん
2013/09/06(金) 13:12:28.58ES6が実際的にも標準と認められるまでは駄目だなこりゃ。
0502デフォルトの名無しさん
2013/09/06(金) 13:45:50.66構文を１つずつ準備出来たのから実装できるほど容易くない
だから当分はどうしてもでっち上げになってしまう
forofなんかはまだ良いほうで実装側は大変だと思う
0503デフォルトの名無しさん
2013/09/06(金) 14:07:41.83Haskellの圧勝じゃん
0504デフォルトの名無しさん
2013/09/06(金) 14:11:13.49短く書いた方が勝ちなの？
0505デフォルトの名無しさん
2013/09/06(金) 15:21:39.16ダサい
0506デフォルトの名無しさん
2013/09/06(金) 15:26:06.68そんなモナドつかわなあかん以前でHaskellつーか関数型は負けてる
0507デフォルトの名無しさん
2013/09/06(金) 15:31:20.11LLとコーディングスタイルで競う事自体がおかしな事なんだよ
0508デフォルトの名無しさん
2013/09/06(金) 15:33:00.14import Control.Arrow
main = getContents >>= (lines >>> map (\x -> x ++ x) >>> unlines >>> putStrLn)
0509デフォルトの名無しさん
2013/09/06(金) 16:14:31.56import sys
from itertools import chain
from functools import reduce
flatten = chain.from_iterable
each = lambda f, xs: reduce(lambda acc, x: f(x), xs, 0)
def uniq(xs):
seen = set()
return (seen.add(x) or x for x in xs if x not in seen)
each(print, uniq(flatten(x.split() for x in sys.stdin)))
0510デフォルトの名無しさん
2013/09/06(金) 16:23:52.69１トークンずつ解説してくれ。
0511デフォルトの名無しさん
2013/09/06(金) 16:32:52.84flatten: シークエンスのネストを一段はぎとる
[1,2,3],[4,5],[6,7,8],... -> 1,2,3,4,5,6,7,8....
each: 単にforeach的な関数。これはlazyではなく、ここでストリームが消費される
uniq: 重複を取り除いたシークエンスを返す
最後:
sys.stdinから各行を読み込んで、各行を単語に割って、
結果が単語のリストの列になるので単語の列にして、
重複を取り除く、ここまでlazyなストリーム
最後にeachがドライバとなって、ストリームから要素を一つずつ呼んで印字
0512デフォルトの名無しさん
2013/09/06(金) 16:44:29.660513デフォルトの名無しさん
2013/09/06(金) 16:54:43.750514デフォルトの名無しさん
2013/09/06(金) 18:04:35.13外部イテレーターとして使わないのであれば
内部でFiberが生成されることもなく
列挙途中の内部状態が外部に露出したりすることはない
基本、コールバック関数(ブロック)を記憶しておいて
列挙ごとにネストしたコールバック関数を呼んでるだけ
複数コレクションを平行イテレートするためにEnumerator(旧Generator)ができて
イテレーターを遅延させるためにそのEnumeratorを利用して
って流れで実装されたんで、外部イテレータ機能をも含んではいるが
イテレートを遅延させるだけなら外部イレテータとは無関係
0515デフォルトの名無しさん
2013/09/06(金) 18:10:15.46| uniq words |
uniq := [:xs | Generator on: [:g |
| seen |
seen := OrderedCollection new.
xs do: [:x | (seen includes: x) ifFalse: [g yield: (seen add: x)]]]].
words := [:xs | Generator on: [:g |
[xs nextLine subStrings do: [:x | g yield: x]] repeat]].
(uniq value: (words value: stdin)) do: [:x | Transcript showCr: x]
0516デフォルトの名無しさん
2013/09/06(金) 19:42:21.06RubyやPythonだったら大変なことになってた
0517デフォルトの名無しさん
2013/09/06(金) 19:48:51.27[:x | g yield: x]
[:x | Transcript showCr: x]
この [:x | ... x] と value: の件さえなければSmalltalk最強だったと思う
0518前スレ367
2013/09/06(金) 19:51:17.19http://play.island.ac/codepaste/code?id=1556
現状のRuby2.0には、ストリーム(=遅延シーケンス)に対応したメソッドが
(かなり)不足しているので、組込みクラス Enumerable::Lazy へいくつか追加せざるをえなかった
・Enumerator::Lazy#transduce(init) { |acc, x| ... }
・Enumerable#reduce の遅延バージョンであり、入力ストリームから出力ストリームを再構成する
・引数 init は累積値 acc の初期値
・ブロック(=ラムダ式)のSML風型式は 'acc * 'x -> 'acc * 'y list であり、これは
事前累積値 'acc と入力ストリームの要素 x から 事後累積値 'acc と 出力ストリームの要素 y への
写像を意味し、1つの入力要素が0 個以上の出力要素に対応できる
言い換えると、累積値を状態とするFSM(finite state machine, 有限状態機械)の関数型表現である
・Enumerator::Lazy#scan
・1文字(Stringクラス)を要素とする入力ストリームから、空白文字(/¥s/)を区切りとした
単語((Stringクラス)を要素とする出力ストリームを再構成する
・内部状態 state は、:init - 初期状態、:between_word - 単語間、:in_word - 単語内を意味し、
この状態と(入力)文字に応じて次の状態と(出力)単語が決定する
・Enumerator::Lazy#uniq
・入力ストリームの各要素について、重複を排除した出力ストリームを再構成する
あとは、>>478と同様に、
・生産者 STDIN.each_char.lazy を始点、
・上記のストリーム演算子 scan および uniq、そして
・消費者 each do ... end を終点
とするストリーム計算式を組立てている
0519デフォルトの名無しさん
2013/09/06(金) 20:03:22.15適切な使い方ができずに機能に溺れるだけになってしまうという良い見本
0520デフォルトの名無しさん
2013/09/06(金) 20:10:35.39思うけど、そうする必要はないっすよ
uniq()は手続き型としてはこれでいい気がするけど
lazyなcar, cons, filterと再帰で実現したほうがpureだと思う
Pythonでいいやりかたは思いつかなかったのでこうなったけど
書ける人は書いてください
0521デフォルトの名無しさん
2013/09/06(金) 20:18:05.11http://developers.slashdot.org/story/13/09/03/2032248/open-source-python-code-shows-lowest-defect-density
0522デフォルトの名無しさん
2013/09/06(金) 20:36:26.32でもこのスレではしつこいクソPythonerのせいで泥が付いてきてる。
0523デフォルトの名無しさん
2013/09/06(金) 20:37:45.220524デフォルトの名無しさん
2013/09/06(金) 20:41:21.020525デフォルトの名無しさん
2013/09/06(金) 20:43:28.22Haskellには及ばないけど
0526デフォルトの名無しさん
2013/09/06(金) 20:49:15.00本部に戻れ
0527デフォルトの名無しさん
2013/09/06(金) 20:50:43.100528デフォルトの名無しさん
2013/09/06(金) 20:55:03.860529デフォルトの名無しさん
2013/09/06(金) 20:59:21.44あとはアッカーマン関数で時間つぶしてる
0530デフォルトの名無しさん
2013/09/06(金) 21:03:08.33悦に入ってるよ
0531デフォルトの名無しさん
2013/09/06(金) 21:07:05.68Pythonの場合、Pythonistaじゃなかったっけ？と思ってぐぐったら
Pythonerも意外と多いのな
0532デフォルトの名無しさん
2013/09/06(金) 21:21:29.14これ原理的にループ最適化はできないのか。
0533デフォルトの名無しさん
2013/09/06(金) 21:24:29.510534デフォルトの名無しさん
2013/09/06(金) 21:27:00.050535デフォルトの名無しさん
2013/09/06(金) 21:30:33.15己自身だっ……
0536前スレ367
2013/09/06(金) 21:44:34.75>おまけに外部イテレータもRuby1.9から、無限イテレーションもRuby2.0でサポートされた
Ruby1.8の外部イテレータ対応について、間違いがあったので自己レスで訂正
実はRuby1.8にも(Rubyで書かれた)添付ライブラリ generator.rb で外部イテレータが提供されていた
ただし、遅延評価には対応していないので、
>>133,478,518のようなストリーム(=遅延シーケンス)処理は実現できない
それでも、もしRuby1.8でもRuby2.0と同様なストリーム機能を利用したいのなら、
(反則技になるが)サードパーティ製のgemsライブラリ backports と enumerable-lazy を
利用することで実現できる
具体的には、これらgemライブラリをインストール後、コードの先頭に以下の行を追加するだけ：
require 'rubygems'
require 'backports'
require 'enumerable/lazy'
backports は、Ruby1.8にRuby1.9の機能追加を移植(バックポート)したもの
enumerable/lazy がRuby1.9向けにストリーム機能を提供するライブラリで、
Rubyで書かれたシンプルなコードなので、>>518のプログラミングでは参考にさせてもらった
0537デフォルトの名無しさん
2013/09/06(金) 21:49:20.32import Control.Arrow
uniq [] = []
uniq (x:xs) = x : uniq (filter (/=x) xs)
main = getContents >>= (lines >>> uniqWords >>> unlines >>> putStrLn)
where
uniqWords = map (words >>> uniq >>> unwords)
0538デフォルトの名無しさん
2013/09/06(金) 21:55:39.250539デフォルトの名無しさん
2013/09/06(金) 22:09:48.44Always use a def statement instead of an assignment statement that binds
a lambda expression directly to a name.
0540デフォルトの名無しさん
2013/09/06(金) 22:19:34.57・遅延評価する
これは純粋関数型言語のストライクゾーンど真ん中
Haskellで書きやすいのは当たり前
0541デフォルトの名無しさん
2013/09/06(金) 22:27:13.56クイックソートよりはマシだな
どうやらRubyは不得意のようだけど
0542デフォルトの名無しさん
2013/09/06(金) 22:31:43.47そんな頻繁に更新されてる規約追いかけ続けてるなんてPython使いは大変だな
真面目に守ってるやついるのか？
今年6月時点ではなかった条項なのに
http://hg.python.org/peps/file/c6a5738d5eb3/pep-0008.txt
今年8月に追加されてるのな
http://hg.python.org/peps/file/fb24c80e9afb/pep-0008.txt
0543デフォルトの名無しさん
2013/09/06(金) 22:50:33.85uq = Hash.new
$stdin.each_line.lazy
.flat_map{|e| e.split(/\s+/)}
.select{|e| uq[e] ? nil : uq[e]=true }
.each{|e| puts e}
全列挙せずに、最初の数個だけを得て残りを打ち切るような場合等は
遅延ストリームのほうがスマートに記述できるが
通常は無理に遅延ストリームなど使わずとも
普通に配列を生成すればいいし、そのほうが速い
メモリを多く消費するけれども
$stdin.each_line
.flat_map(&:split)
.uniq
.each{|e| puts e}
そもそもメモリに収まらないようなデータを扱うのはスクリプト言語には荷が重い
C#やHaskellやScala等だと、巨大なデータを扱うこともあるかもしれないが
0544デフォルトの名無しさん
2013/09/06(金) 22:59:21.510545デフォルトの名無しさん
2013/09/06(金) 23:03:35.610546前スレ367
2013/09/06(金) 23:11:52.85イイネ！！
flat_map を使えば、単語への切り出しは簡単だったんだ....
るりまでLazyのメソッドを読み直してきます
ただし、遅延ストリームの目的は大量データ処理もあるけど、
>>451が言うように入出力処理があって、それが今回の「お題」なんだ
後半の有限シーケンスでは「お題」に対する「答え」になっていないと思う
0547デフォルトの名無しさん
2013/09/06(金) 23:28:09.81データの量ではなくタイミングの問題
0548デフォルトの名無しさん
2013/09/06(金) 23:29:30.07配列一括処理の欠点は、メモリを多く消費するだけじゃない
入力が完了してして処理が終わるまで出力が始まらないし
その間完全にブロックしてしまい逐次的に処理できない
ttyから入力を打ち込んでみれば違いは明らかで
その方法は少なくとも対話的なプログラムでは全く使えないことが分かるし
パイプラインで使うようなソフトとしても使い勝手が悪い
パイプラインの下流やユーザが「必要な分だけ出力を見て残りを打ち切る」ことは
よくあるが、それを考慮してないわけだしな
0549デフォルトの名無しさん
2013/09/06(金) 23:43:15.77でもわざわざ配列として扱ってまでイテレータ使うのは割にあわない
0550デフォルトの名無しさん
2013/09/06(金) 23:45:51.49イテレータが泣いてるよ
0551デフォルトの名無しさん
2013/09/07(土) 05:57:10.22cmd /c type con | % { $_ + $_ }
$a=@{}
cmd /c type con | ? { !$a.Contains($_) } | % { ($a[$_]=$_) }
0552デフォルトの名無しさん
2013/09/07(土) 08:13:05.59$a=@{}
cmd /c type con | ? { !$a.$_ } | % { ($a.$_=$_) }
ハッシュの代わりに配列使って無理矢理一行にするとこんな感じ
cmd /c type con | ? { $_ -notin $a } | % { ($a+=,$_)[-1] }
0553デフォルトの名無しさん
2013/09/07(土) 09:28:36.43Stream extend [
words [
^Generator on: [:g | self linesDo: [:line | line subStrings do: [:str | g yield: str]]]
]
uniq [
^Generator on: [:g |
| seen |
seen := OrderedCollection new.
self do: [:each | (seen includes: each) ifFalse: [g yield: (seen add: each)]]]
]
]
Symbol extend [value: obj [^obj perform: self]]
stdin words uniq do: #displayNl
0554デフォルトの名無しさん
2013/09/07(土) 10:03:25.86import Control.Arrow
uniq [] = []
uniq (x:xs) = x : uniq (filter (/=x) xs)
main = getContents >>= (words >>> uniq >>> mapM_ putStrLn)
0555デフォルトの名無しさん
2013/09/07(土) 10:16:31.76何やってるか全然分からない
0556デフォルトの名無しさん
2013/09/07(土) 10:18:48.52お題を勘違いしているような気がする
0557デフォルトの名無しさん
2013/09/07(土) 10:57:32.70yieldがないから仕方なくリスト使ってるだけ
0558デフォルトの名無しさん
2013/09/07(土) 10:58:37.39perl -ane 'for (@F) {print $_, "\n" unless $a{$_}++}'
>>555
ただ短けりゃいいんならこんなのでもいいけど
uniqという汎用的な処理を関数として切り出せていないのが
抽象化が十分でない証拠
このお題の例では単純すぎてどうでもいいけどな
0559デフォルトの名無しさん
2013/09/07(土) 10:59:22.190560デフォルトの名無しさん
2013/09/07(土) 11:01:47.14ありゃ、勘違いしてるかな
１つ目は標準入力が改行される度に最新行を２つ繋げてエコー
２つ目は標準入力が改行される度に最新行が履歴になければエコー
って意味かと思ってた
0561デフォルトの名無しさん
2013/09/07(土) 11:03:42.802つめはそれだとUnixのuniqコマンドと同じだけど
単語に割って、履歴に単語がなければそれぞれの単語を一行ずつ出力のがお題
0562デフォルトの名無しさん
2013/09/07(土) 11:05:07.54履歴にない単語をそれぞれ一行ずつ出力
0563デフォルトの名無しさん
2013/09/07(土) 11:12:11.41㌧
こういうことね
$a=@{}
cmd /c type con | % { $_ -split "\s" } | ? { !$a.$_ } | % { ($a.$_=$_) }
フィルタは関数かした方がよかったかー
0564デフォルトの名無しさん
2013/09/07(土) 11:54:28.650565デフォルトの名無しさん
2013/09/07(土) 12:21:04.070566デフォルトの名無しさん
2013/09/07(土) 12:45:47.52Haskellは論外
0567デフォルトの名無しさん
2013/09/07(土) 12:46:20.25スクリプト言語じゃないから無効票
0568デフォルトの名無しさん
2013/09/07(土) 12:47:22.700569デフォルトの名無しさん
2013/09/07(土) 12:48:54.980570デフォルトの名無しさん
2013/09/07(土) 12:49:23.660571デフォルトの名無しさん
2013/09/07(土) 12:50:29.20ここまで出たコードの大半がマイナス点、平均してもマイナス点だと思う。
0572デフォルトの名無しさん
2013/09/07(土) 12:53:03.741万行の現実のアプリケーションを書くとなるとまた随分話が変わってくるのでは？
住む世界が違うからまたいろいろと比較は難しいだろうし。
0573デフォルトの名無しさん
2013/09/07(土) 12:53:11.32でもJS厨がうんこだとしても、言語の評価とは別だから
0574デフォルトの名無しさん
2013/09/07(土) 12:54:06.96他所でフィボってろ
0575デフォルトの名無しさん
2013/09/07(土) 12:54:10.140576デフォルトの名無しさん
2013/09/07(土) 12:55:58.37すまんがお題に興味が無いから書かない。
いいお台なら当然書いてる。
正直この流れ乗れないわ。
0577デフォルトの名無しさん
2013/09/07(土) 12:57:14.38たかが数行のコードすら一瞬で書けないって言語も書き手もゴミすぎ
そんな奴が批評とか失笑
0578デフォルトの名無しさん
2013/09/07(土) 12:57:23.970579デフォルトの名無しさん
2013/09/07(土) 12:57:50.190580デフォルトの名無しさん
2013/09/07(土) 13:01:59.62お前さんはプログラミングの前に道徳の勉強した方がいいよ。
その性格反省した方がいい。自分も他人も不幸にする。
0581デフォルトの名無しさん
2013/09/07(土) 13:03:28.79その行数打ち込む時間があったら
コード書けたねw
0582デフォルトの名無しさん
2013/09/07(土) 13:04:55.830583デフォルトの名無しさん
2013/09/07(土) 13:06:10.90見苦しいぞ
0584デフォルトの名無しさん
2013/09/07(土) 13:07:18.890585デフォルトの名無しさん
2013/09/07(土) 13:08:30.19で、お前はHaskellでどんなアプリケーション作ったの？って訊ねると黙る
0586デフォルトの名無しさん
2013/09/07(土) 13:10:38.530587デフォルトの名無しさん
2013/09/07(土) 13:11:40.60じゃあ、お前はどんなアプリケーション作ったの？
言語はなんでもいいよ。
お前が黙るかそれ以外の何をするかを
見たいだけｗ
0588デフォルトの名無しさん
2013/09/07(土) 13:12:13.21スレが伸びるよ！
0589デフォルトの名無しさん
2013/09/07(土) 13:12:34.66汎用言語と同じ土俵で語るのはよくない
0590デフォルトの名無しさん
2013/09/07(土) 13:15:03.95どんなアプリケーション作ったの？って
尋ねると黙るなｗｗｗ
0591デフォルトの名無しさん
2013/09/07(土) 13:15:14.470592デフォルトの名無しさん
2013/09/07(土) 13:17:06.020593デフォルトの名無しさん
2013/09/07(土) 13:18:38.84訊く方も、実名バレできねーだろって読んだ上で
訊いてるからな
0594デフォルトの名無しさん
2013/09/07(土) 13:19:02.06各言語のラムダ式導入の参考にもなってるし、その部分を語るのも悪く無い。
でもあまりに他の言語を意識することは自分の長所を捨てて、
結局相手の長所もそんなには得られないし、良くはないと思う。
関数型スタイルは関数型言語に敵うはずがないし、
その代わりもっと豊かなスタイルで書けるんだから、住み分けたらいい。
ストリームを関数型スタイルでバリバリ書けますよーとは言うけど、
実際バリバリ関数型よりのスタイルでアプリ書かないでしょと言いたい。
使えるものは有効活用すべきだけど、溺れちゃってるだけになってるね今。
0595デフォルトの名無しさん
2013/09/07(土) 13:19:35.670596デフォルトの名無しさん
2013/09/07(土) 13:25:14.08じゃあ答えにくいよね
所謂ウィンドウ型、もしくはスマホ用みたいいな「アプリ」という話なら
自分はJS+HTMLで、作りにくくは無かったけど
Haskellとかは作りにくそうなイメージ持ってるけど
各言語使いの方、実際はどうなの？
0597デフォルトの名無しさん
2013/09/07(土) 13:25:50.670598デフォルトの名無しさん
2013/09/07(土) 13:28:44.09あの書き方はする必要がないというか、全然あわないんじゃない？
書いても他と全く違うものになるから、関数型、イテレータで盛り上がってる所には入りずらいかと
0599デフォルトの名無しさん
2013/09/07(土) 13:36:46.990600デフォルトの名無しさん
2013/09/07(土) 13:38:02.68現状Haskellっぽく書く文化が全くないと思う
こういうのがES6に間に合えばまた変わってくるかもしれないけど
http://wiki.ecmascript.org/doku.php?id=harmony:generator_expressions
同時にDOM側からは抽象度の高いフレームワーク的機能が沢山提供されるし
JSerは中々Haskellっぽく書きたくならないだろうな
0601デフォルトの名無しさん
2013/09/07(土) 13:38:20.69JSでそれと同じ書き方ができれば問題無いだろ？
0602デフォルトの名無しさん
2013/09/07(土) 13:39:38.12Haskellっぽいのが最高なものという訳じゃないし、
クソコード＝Haskellっぽいって可能性もあるんだが。
つまりHaskellっぽく書くのは
悪いコーディングスタイル。
0603デフォルトの名無しさん
2013/09/07(土) 13:39:57.74スクリプトは静的型を捨てた
静的型の夢を諦め切れない奴が多すぎるのも異常だよ
0604デフォルトの名無しさん
2013/09/07(土) 13:41:03.120605デフォルトの名無しさん
2013/09/07(土) 13:42:26.36ってことだろ
0606デフォルトの名無しさん
2013/09/07(土) 13:42:34.13「つまり」より前の文章が後の文章の帰結になってない
論理的に思考できないお前はプログラマに向いてないよ
0607デフォルトの名無しさん
2013/09/07(土) 13:45:12.49パターンマッチ導入してくれ
0608デフォルトの名無しさん
2013/09/07(土) 13:45:41.29要するに、コンパイラや処理系などによる
静的解析を諦めたということ。
静的解析ができれば、コードの問題点を素早く見つけ出すことが出来る。
またプログラムに必要な作業にたいしてコンピュータからサポートが出来る。
スクリプト言語はこれらを捨てたということ。
これは欠点ではない。
問題点が見渡せる程度、サポートがなくても人間が頑張れる程度
その程度の小さいコードを作ることを前提にして、
宣言的なコードをなくしているのだ。
だから大規模ソフトを作らなくて、CLIの延長でプログラム言語を使う
インフラ技術者において、スクリプト言語は人気がある。
0609デフォルトの名無しさん
2013/09/07(土) 13:47:25.790610デフォルトの名無しさん
2013/09/07(土) 13:48:25.05そんなことは全員の共通認識
なにその今さらな長文
0611デフォルトの名無しさん
2013/09/07(土) 13:49:06.55○静的解析を一部諦めたということ
0612デフォルトの名無しさん
2013/09/07(土) 13:50:35.59コマンドなら叩けるという意味でインフラ技術者は、
プログラミング技術的にはアプリプログラマよりも技術力は下である。
そのインフラ技術者が、コンピュータ使ってるんだから仕事なんて一緒だろ？
みたいな感覚で、アプリの開発をさせられると火を噴く。
言語が開発に適しているかどうかなんて考えずに
自分の使える言語（＝スクリプト言語）を使って大規模なアプリを作り出す。
そしてスクリプト言語を使う感覚で、その場しのぎのコードを
積み重ねてアプリを作るのだ。
全体の整合性なんて考えちゃいない。
動けばいい。そういう考えで作る。
0613デフォルトの名無しさん
2013/09/07(土) 13:51:17.67> 大規模ソフト = GUIかよ、
あれ？ どこにGUIって書いてあんの？
ヤクでもやってる？
0614デフォルトの名無しさん
2013/09/07(土) 13:51:22.57最近になってスクリプト言語で書かれる種と量はうなぎのぼりだし
常に言語開発の問題として挙がってる
0615デフォルトの名無しさん
2013/09/07(土) 13:52:23.750616デフォルトの名無しさん
2013/09/07(土) 13:54:13.23捨てたり諦めたわけでない。スクリプト言語のほうが複雑。
かりにアセンブラ言語が静的解析を諦めたら、スクリプト言語になるか?
0617デフォルトの名無しさん
2013/09/07(土) 13:55:32.570618デフォルトの名無しさん
2013/09/07(土) 13:55:35.48静的解析を諦めたらスクリプト言語になるのではない
スクリプト言語になるには、静的解析を諦めないといけないのだ。
一部は出来るというが、それ以外は諦めるということだからな。
0619デフォルトの名無しさん
2013/09/07(土) 13:56:08.330620デフォルトの名無しさん
2013/09/07(土) 13:57:28.90C系だって一部諦める代わりに利便性を取ってるぞ
0621デフォルトの名無しさん
2013/09/07(土) 13:59:55.07程度のもんだだよ。
スクリプト言語は実行時にならないとわからないことが多すぎる。
実行時にならないとわからないことがデフォルトになってる。
0622デフォルトの名無しさん
2013/09/07(土) 14:02:57.23作ってるとこがそう言えばそうってことでしかないんじゃね
0623デフォルトの名無しさん
2013/09/07(土) 14:05:36.93と
a < b && b < c
が等価である
≒
スクリプト言語
0624デフォルトの名無しさん
2013/09/07(土) 14:11:56.48C#やJavaもスクリプトか?
0625デフォルトの名無しさん
2013/09/07(土) 14:14:50.99ソフトの目的は、ハード設計時にわからないことを先送りすること
むやみに予想したり賭けたりしないことだ
0626デフォルトの名無しさん
2013/09/07(土) 14:16:42.74テキストエディタで修正可能なものが
スクリプト言語
0627デフォルトの名無しさん
2013/09/07(土) 14:17:56.25誰もソフトウェア外部のハードの話なんかしていません。
外部が予測不可能なのはあたりまえじゃないですか。
ソフトウェア内部の話です。
馬鹿なんですか？
0628デフォルトの名無しさん
2013/09/07(土) 14:29:34.54設計時に全てを決めるのは難しい
Javaなどで標準GUIライブラリが何度も作り直されて
それでもウンコなのをみても明らか
0629デフォルトの名無しさん
2013/09/07(土) 14:29:35.59http://esdiscuss.org/topic/everything-is-an-expression
http://esdiscuss.org/topic/chained-comparisons-from-python-and-coffeescript
前者はまだどうにかできるが後者は難しい
将来的にスイッチを導入してまで変えるかもしれない
一応ES7で演算子オーバーロードやValueProxiesが入ると無理やりエミュレートはできるかもしれない
http://wiki.ecmascript.org/doku.php?id=strawman:operator_overloading_with_double_dispatch
http://wiki.ecmascript.org/doku.php?id=strawman:value_proxies
0630デフォルトの名無しさん
2013/09/07(土) 14:35:51.45本当に馬鹿なのかな？
外部が予測不可能なのは当たり前てて書いたよね？
ライブラリやフレームワークの外部だって
予測不可能なのは当たり前。
内部の話だよ。ばーかｗ
0631デフォルトの名無しさん
2013/09/07(土) 14:36:44.11ES7は早くてあと５年はかかりそうだな
0632デフォルトの名無しさん
2013/09/07(土) 14:39:16.610633デフォルトの名無しさん
2013/09/07(土) 14:39:26.15全て決まってるのかもな
0634デフォルトの名無しさん
2013/09/07(土) 14:40:49.98他と全然ノリが違うPowerShellやPerlの例すら挙がってるのに
そんなこと気にする意味ないような
ブラウザにはstdinなんてないかもしれないけれども
別にnodeでもRhinoでもSpiderMonkeyでもWSHでもいいのよ？
0635デフォルトの名無しさん
2013/09/07(土) 14:46:30.280636デフォルトの名無しさん
2013/09/07(土) 14:46:54.580637デフォルトの名無しさん
2013/09/07(土) 14:48:37.010638デフォルトの名無しさん
2013/09/07(土) 14:52:44.900639デフォルトの名無しさん
2013/09/07(土) 14:56:34.59絶対ちゃんと書くことは書くから
0640デフォルトの名無しさん
2013/09/07(土) 14:58:34.960641デフォルトの名無しさん
2013/09/07(土) 15:01:07.35その程度も自分で考えられない奴が書くコードなんてたかが知れてる
0642デフォルトの名無しさん
2013/09/07(土) 15:06:03.05イメージがしにくいのよ
すまんな
0643デフォルトの名無しさん
2013/09/07(土) 15:10:12.14それ結構衝撃的発言なんだが、俺もおっさんになったということだなぁ
0644デフォルトの名無しさん
2013/09/07(土) 15:15:27.05（数値なんかの）入力機能としてならよく使うけど
入力されたものを整形して出力しようなんて考えたこともない
0645デフォルトの名無しさん
2013/09/07(土) 15:22:29.55標準入力からの入力を待って
単語ごとに分割し
既出の単語を除いて単語ごと改行して出力
というのをループではなく遅延ストリームで行う
って直近のお題をよろしく
0646デフォルトの名無しさん
2013/09/07(土) 15:32:38.39いままで出てる遅延実装＝レイテンシゼロ
最後まで読んでから処理＝レイテンシが無限大
上の仕様を守りつつuniqを独立した関数として実装可能かどうかという点に
言語の抽象化能力が問われる
uniqを関数にできずにループに埋め込まれてしまうなら、抽象度が低いという
ことになる
0647デフォルトの名無しさん
2013/09/07(土) 15:42:45.520648デフォルトの名無しさん
2013/09/07(土) 15:58:03.94無駄な言葉を使うと問題が難しくなる見本
0649デフォルトの名無しさん
2013/09/07(土) 16:00:20.08「最後まで読んでから処理」ってなんのことだ
0650デフォルトの名無しさん
2013/09/07(土) 16:01:29.340651デフォルトの名無しさん
2013/09/07(土) 16:03:45.37>>649
入力を1行読む度にすぐ出力される→レイテンシゼロ
入力を最後の行まで読まないと出力が始まらない→「最後」はいつになるか分からないなのでレイテンシが無限大
ファイルにリダイレクトせずに標準入力から手で入力すれば違いはすぐ分かる
0652デフォルトの名無しさん
2013/09/07(土) 16:05:40.150653デフォルトの名無しさん
2013/09/07(土) 16:21:48.82かつ順序を保って非同期に出力すればいいの？
それと重複の判断は行単位だよね？
0654デフォルトの名無しさん
2013/09/07(土) 16:47:48.30process.stdin.on('data', function(buf) {
var arrItr = (buf.toString().match(/\S+/g)||[]).values()
var set = new Set
function itrFunc() {
var nextObj = arrItr.next()
var done = nextObj.done
if (done) return
var value = nextObj.value
if (!set.has(value)){
console.log(value)
set.add(value)
}
process.nextTick(itrFunc)
}
itrFunc()
})
0655デフォルトの名無しさん
2013/09/07(土) 16:50:11.51え、いやあの、>>563のPowerShellスクリプトは
ほとんど>>543を直訳しただけよ・・・？
たまたま遅延評価っぽくなってるだけで、実際は遅延評価してるわけじゃないけど
0656デフォルトの名無しさん
2013/09/07(土) 16:58:09.91function itrFunc() {
var {done, value} = arrItr.next()
if (done) return
set.has(value) && set.add(value) || console.log(value)
process.nextTick(itrFunc)
}
0657デフォルトの名無しさん
2013/09/07(土) 17:13:03.41V8のES6対応が中途半端だからキツイ
process.stdin.on('data', function(buf) {
for (let v of new Set(buf.toString().match(/\S+/g) || [])) console.log(v)
})
0658デフォルトの名無しさん
2013/09/07(土) 17:16:14.51values()のところでエラーになるのはうちのV8が古いから？
0659デフォルトの名無しさん
2013/09/07(土) 17:31:28.05uniqの抽象化も出来てないしループもＣ言語を彷彿とさせる
いままで出た中でブッチギリのワースト
0660デフォルトの名無しさん
2013/09/07(土) 17:32:15.65V8 3.20.5辺り以降かNode 0.11系でharmonyフラグを付けて起動する
0661デフォルトの名無しさん
2013/09/07(土) 17:38:33.85ありがとう
うちのDebianで入るやつはv0.10.15だから古いんだな
0662デフォルトの名無しさん
2013/09/07(土) 17:39:42.25もっとSetに頼れればuniqとやらも随分良くなるんだけど
まだ実装不足だからなぁ
0663デフォルトの名無しさん
2013/09/07(土) 17:41:39.83それが本当に一番良かった
お題を教えてくれた人ありがとね
JSでも提案はあるみたいだから実装されるといいね
0664デフォルトの名無しさん
2013/09/07(土) 18:46:24.74Python、Smalltalk、Haskellだけかー
0665デフォルトの名無しさん
2013/09/07(土) 18:57:39.98ダサくなる例って無いの？
例えば、ウェブサーバーを書いてみるとかさ。
ちょっとお題が一方に都合が良すぎる感じがする。
0666デフォルトの名無しさん
2013/09/07(土) 19:02:11.01これがああ書けたからなんだって話だし。
元々意味のないお題なんだからWebサーバーを引き合いに出すのはちょっと違うよ
0667デフォルトの名無しさん
2013/09/07(土) 19:03:50.65uniqをストリーム対応で定義できると何があんの？
0668デフォルトの名無しさん
2013/09/07(土) 19:04:12.37過去にさかのぼって履歴に単語があれば、その単語は出力してはいけない
そのコードだと現在行の重複を取り除いているだけでは？
0669デフォルトの名無しさん
2013/09/07(土) 19:04:43.46元々意味のないお題って二度も言わせるなｗ
0670デフォルトの名無しさん
2013/09/07(土) 19:05:11.40どういうお題が相応しいか考えるのにも
知識とセンスが要るんだなー
Webサーバだってw
0671デフォルトの名無しさん
2013/09/07(土) 19:07:36.45uniqはただの例で、GUI、対話的アプリケーション、ネットワークプログラム、
デジタルフィルタ等、応答性が重要なケースでの抽象化能力をはかる一つの目安になる
こんな単純な例でプロセスを切り出せずにループに紛れ込んでしまうのでは
スパゲッティになってしまうか複雑なステートマシンを管理することになるのが
目に見えてる
0672デフォルトの名無しさん
2013/09/07(土) 19:08:03.46こういうのは取り合わなくていいよ
0673デフォルトの名無しさん
2013/09/07(土) 19:08:41.69> 元々意味のないお題なんだからWebサーバーを引き合いに出すのはちょっと違うよ
いや、その理屈がわからん。
意味が無いお題じゃないといかんのか？
別にウェブサーバーを引き合いに出してもいいじゃないか。
そもそもストリーム対応のuniqは意味のないお題なのか？
どういう点が意味があって、uniqには何がないから
意味が無いお題なんだ？
0674デフォルトの名無しさん
2013/09/07(土) 19:10:12.23単純な例だからこそ切り分ける必要なんてないのでは？
0675デフォルトの名無しさん
2013/09/07(土) 19:10:18.80だから、言語の抽象化能力を比較するのに
uniqが適切とは限らないってことでしょ。
そこまで必死になってるのはなぜなんだ？
0676デフォルトの名無しさん
2013/09/07(土) 19:11:15.68uniqは元々意味のないお題って言ったよね？
無理やり意味を見出そうとするなアホ
0677デフォルトの名無しさん
2013/09/07(土) 19:11:32.49言語の良さじゃなくて変態度を競ってる
といえば分かる？
0678デフォルトの名無しさん
2013/09/07(土) 19:12:54.10俺は俺の基準による変態度を競っている。
誰がお前のフィールドに上がるか（笑）
0679デフォルトの名無しさん
2013/09/07(土) 19:13:05.18つまり、単純だからやらなかっただけで、
その気になれば切り分けれたの？
0680デフォルトの名無しさん
2013/09/07(土) 19:14:12.45だがやらないけどなｗ
0681デフォルトの名無しさん
2013/09/07(土) 19:14:40.91なりすまし錯乱荒らしが来たぞーー
0683デフォルトの名無しさん
2013/09/07(土) 19:15:28.18>>671は割と納得がいく理由を書いてると思うよ？
0685デフォルトの名無しさん
2013/09/07(土) 19:16:23.89なりすまし錯乱荒らしが来たぞーー
0686デフォルトの名無しさん
2013/09/07(土) 19:17:55.94できてないよ。
0687デフォルトの名無しさん
2013/09/07(土) 19:18:29.93>>670へのレスだよ
0688デフォルトの名無しさん
2013/09/07(土) 19:20:10.51ソッチの方が重病だと思うけど
0689デフォルトの名無しさん
2013/09/07(土) 19:24:41.16自作すればいいだろばーかｗ
0690デフォルトの名無しさん
2013/09/07(土) 19:26:12.160691デフォルトの名無しさん
2013/09/07(土) 19:27:02.243行ぐらいあるコードを
何十回も書くのやめてください。
スクリプト言語使っている人に多いです。
0692デフォルトの名無しさん
2013/09/07(土) 19:28:07.61bash。
uniqという関数で出来る。
0693デフォルトの名無しさん
2013/09/07(土) 19:32:33.58コマンド履歴に残しておけばいいんじゃないすかー
0694デフォルトの名無しさん
2013/09/07(土) 19:33:09.99あれは入力がソートされてることが前提で、「連続した」重複しか取り除けない
勿論そうじゃないと、重複を記憶するためにメモリをバカ食いするか
dbmみたいなものを使うはめになるから
0695デフォルトの名無しさん
2013/09/07(土) 19:34:35.150696デフォルトの名無しさん
2013/09/07(土) 19:35:34.28ウェブサーバーに移ろうぜ。
0697デフォルトの名無しさん
2013/09/07(土) 19:39:09.81ステキ→重複を省く汎用的な関数に通せるよう入力ストリームを変形する
0698デフォルトの名無しさん
2013/09/07(土) 19:40:11.83python3 -m http.sever 8888
とかで立ち上がるやつだよな？
0699デフォルトの名無しさん
2013/09/07(土) 19:40:35.96言語の上のフレームワークの問題でもある
0700デフォルトの名無しさん
2013/09/07(土) 19:41:08.400701デフォルトの名無しさん
2013/09/07(土) 19:43:15.12確かに後者の方がステキだ
0702デフォルトの名無しさん
2013/09/07(土) 19:43:24.88他の言語で使う時どうなるの？
0703デフォルトの名無しさん
2013/09/07(土) 19:45:34.93どちらが良いかっていうのは置いといて
前者がいいって思う人は何かに毒されてると思う
0704デフォルトの名無しさん
2013/09/07(土) 19:50:07.12後者で実現できるんなら後者でいいよな
ただ後者の「汎用的な関数」が仮にeagerに全入力を読んでしまうものなら
今回の要求仕様を達成できないのだから、使えない
こうしたケースでは使用できない「汎用的な関数」は使用条件が限られるわけで
実は汎用的ではなかったわけだ
0705デフォルトの名無しさん
2013/09/07(土) 19:53:51.06そこだけ抽象化してもそもそも履歴がグローバル変数だしなー
複数回ストリーム流しても保持できるようにしてるんだけど、
これをローカルスコープで、前回の履歴を引数にしたりせずにってなるとちょっとしんどい
そういうとこHaskellは楽そうでいいね
0706デフォルトの名無しさん
2013/09/07(土) 19:53:52.96Pythonでは無理。
0707デフォルトの名無しさん
2013/09/07(土) 19:55:07.94別にストリーム専用とかじゃなく、ただのリストも食えるし形式も問わない
>>> for x in uniq([1,3,2,4,5,2,6,1]): print(x)
1
3
2
4
5
6
0708デフォルトの名無しさん
2013/09/07(土) 20:00:17.88後者の分類でしょう
前者は文字列とすら見ないで、データが届いた端からバイナリ列で走査していく感じが適当だと思うけど
標準入力だと一気にデータが来るから仕方ないけど、ストリーム汎用と見たらそういう実装でしょう
0709デフォルトの名無しさん
2013/09/07(土) 20:01:55.35なるほど、言わんとしてることが分かったわ
ありがとう
0710デフォルトの名無しさん
2013/09/07(土) 20:08:59.25process.stdin.on('data', buf => for (let v of new Set(buf.toString().split(' ')) console.log(v) )
0711デフォルトの名無しさん
2013/09/07(土) 20:10:56.00言語名で決める（笑）
0712デフォルトの名無しさん
2013/09/07(土) 20:14:41.15>>668
0713デフォルトの名無しさん
2013/09/07(土) 20:24:45.85let set = new Set
process.stdin.on('data', buf => for (let v of [v for (v of buf.toString().split(' ')) if (set.add(v) || !set.has(v))] ) console.log())
0714デフォルトの名無しさん
2013/09/07(土) 20:27:11.25let set = new Set
process.stdin.on('data', buf => {
let data = [v for (v of buf.toString().split(' ')) if (set.add(v) || !set.has(v))]
for (let v of data) console.log(v)
})
0715デフォルトの名無しさん
2013/09/07(土) 20:42:52.080716デフォルトの名無しさん
2013/09/07(土) 20:48:50.930717デフォルトの名無しさん
2013/09/07(土) 20:53:51.37>>697の後者は遠いな
0718デフォルトの名無しさん
2013/09/07(土) 20:53:51.24a b c
d e f
と入力が合った時に
a
b
d
c
e
f
のようになる可能性が無いってこと
0719デフォルトの名無しさん
2013/09/07(土) 20:58:15.590720デフォルトの名無しさん
2013/09/07(土) 20:58:28.070721デフォルトの名無しさん
2013/09/07(土) 20:58:29.19バージョンによっても違うし、あまり深く使いたくない
0722デフォルトの名無しさん
2013/09/07(土) 20:59:28.140723デフォルトの名無しさん
2013/09/07(土) 21:01:14.720724デフォルトの名無しさん
2013/09/07(土) 21:03:05.83書き込みもそれぞれノンブロッキングだから
ロジックによっては絡む可能性もある
0725デフォルトの名無しさん
2013/09/07(土) 21:19:43.09デフォルトがノンブロッキングIOなのもめんどくせーな
0726デフォルトの名無しさん
2013/09/07(土) 21:24:15.630727デフォルトの名無しさん
2013/09/07(土) 21:28:40.26書き込みがノンブロッキングというのはロジックの話で
標準入力は特別にブロッキングタイプのIO
だから２重非同期なわけではない
0728デフォルトの名無しさん
2013/09/07(土) 21:46:17.460729デフォルトの名無しさん
2013/09/07(土) 21:49:10.220730デフォルトの名無しさん
2013/09/07(土) 21:50:46.58そもそも対応してないだろ
0731デフォルトの名無しさん
2013/09/07(土) 21:54:30.610732デフォルトの名無しさん
2013/09/07(土) 21:56:07.98アプリケーションサーバは書かないの？
書きたいケース増えてきたでしょ？
0733デフォルトの名無しさん
2013/09/07(土) 21:58:03.480734デフォルトの名無しさん
2013/09/07(土) 22:02:01.66http://ideone.com/j8ScZa
非同期コールバックだからprocess.stdin.on()に行単位でわたってくるとは
限らんし（入力がttyのときは普通そうなるみたいだけど）
0735デフォルトの名無しさん
2013/09/07(土) 22:04:20.97考え方の順序が違うよ
アプリケーションサーバーが建てたい、近頃必要な機会が増えてきた
でも現状のやり方じゃ問題が多い
その問題の原因の代表が１ソケット１プロセス方式ってだけでしょ
別にC10K問題がいつも付きまとうわけじゃないよ
0736デフォルトの名無しさん
2013/09/07(土) 22:07:02.19ttyだから行単位で渡ってくると思って問題ない。
0737デフォルトの名無しさん
2013/09/07(土) 22:13:05.80うざいから
0738デフォルトの名無しさん
2013/09/07(土) 22:15:48.02仕様では明記されてないけど、それってリダイレクトされたりパイプとつなぐと
ちゃんと動かないってことだよね
他の言語の例だと動くけど
0739デフォルトの名無しさん
2013/09/07(土) 22:19:33.660740デフォルトの名無しさん
2013/09/07(土) 22:20:39.95つまりchunkが単語の境界に沿ってないときがあるので、単語やマルチバイト文字の
途中で分割されるわけでしょ
手当てをしないと
0741デフォルトの名無しさん
2013/09/07(土) 22:29:16.55ああ意味分かった
昔は内部バッファがいっぱいになるほど送られてきた時や時間が合いた場合にそういうこと起きてたけど
Stream3のFlowingModeのときはどうなってるのかね
できる限り\nまで待ってくれるはずだけど、ストリームに内部実装変わってきてるから
実験してみないとどんなものかわからん
0742デフォルトの名無しさん
2013/09/07(土) 22:32:22.05http://domenic.me/2013/09/06/es6-iterators-generators-and-iterables/
0743デフォルトの名無しさん
2013/09/07(土) 22:34:02.05どのみちnodeでコード書くの初めてなので、Bufferをデリミタで分割する方法が
よくわからなかったのだけれど、↓の恐ろしいコードを見たらいやになった
http://stackoverflow.com/questions/8920293/split-binary-data-into-array-or-classes-in-node-js
0744デフォルトの名無しさん
2013/09/07(土) 23:01:41.36それこそ>>708的実装を考えないといけなくなるんじゃないか？
0745デフォルトの名無しさん
2013/09/07(土) 23:01:59.71JavaScriptにはLINQのメソッドチェイン方式のほうが馴染むと思う
内包表記よりはyieldやイテレータがまともに使える環境が整うほうがだいぶ早いだろうから、
内包表記が使えるようになる前に既にLINQ的なスタイルが普及してて結局なかったことになる予感
0746デフォルトの名無しさん
2013/09/07(土) 23:03:59.02サロゲートペアの一部が\nの文字コードと等しくなるケースはあるんだろうか？
0747デフォルトの名無しさん
2013/09/07(土) 23:10:16.86お遊びのコードのあら探ししてもしかたないだろ
0748デフォルトの名無しさん
2013/09/07(土) 23:12:26.90まあ配列内包があるのならこれも合っていいんじゃない？
自分もそんなに使われないとは思うけど、
遅延for-ofとかできたら化けるかもよ
0749前スレ367
2013/09/07(土) 23:16:49.92・単語の切り出しは、複雑なステートマシン(>>671)を使う>>543よりも、
組込みメソッドを組み合わせた >>543 が好ましい
・重複の排除は、ストリーム計算式内で共通変数 uq を更新する >>543 よりも、
同じことをメソッド uniq として抽象化(>>659)した >>518 が好ましい
class Enumerator::Lazy
def uniq
hash = {}
self.class.new(self) do |yielder, x|
yielder << x unless hash[x]
hash[x] = true
end
end
end
STDIN.each_line.lazy.flat_map { |line| line.split(/¥s+/) }.uniq.each { |token| puts token }
>>688が言うように、uniq は汎用的なストリーム操作だと思うから、Rubyでも
本来は Enumerator::Lazy の組み込みメソッドとして定義されるのが望ましいだろう
0750デフォルトの名無しさん
2013/09/07(土) 23:17:10.48http://www.aozora.gr.jp/cards/000148/files/794_14946.html
この辺のわりと大きめなテキストを
iconv -f cp932 -t utf8 | node foo.js
とかやって、↓みたいなコードに流しこんでみるとわかるよ
process.stdin.on('data', function(chunk) {
console.log('[[[' + chunk.toString() + ']]]')
})
こういう手当をしなければいけないのが非同期コールバックの面倒なところ
0751デフォルトの名無しさん
2013/09/07(土) 23:17:29.11Promiseとかもその手のものだし
0752デフォルトの名無しさん
2013/09/07(土) 23:18:17.10そこはさすがにUTF-8を仮定する、とかはしてもいいでしょ
そうじゃないと標準ではテキスト処理できない処理系もあるだろう
0753前スレ367
2013/09/07(土) 23:18:27.51X: ・単語の切り出しは、複雑なステートマシン(>>671)を使う>>543よりも、
O: ・単語の切り出しは、複雑なステートマシン(>>671)を使う>>518よりも、
0754デフォルトの名無しさん
2013/09/07(土) 23:21:55.820755デフォルトの名無しさん
2013/09/07(土) 23:27:58.86そういう場合はreadline使ってみたら？
0756デフォルトの名無しさん
2013/09/07(土) 23:32:06.66え、普通にstreamをブロッキングモード、pull modelでも読めるの？
ならどう考えてもそっちのが楽だな
GUIやネットワークアプリでもないのに非同期コードを書くのは馬鹿らしい
0757デフォルトの名無しさん
2013/09/07(土) 23:45:27.07よく分からんけど
netソケットでも試してみたけど特に問題なかったよ
0758デフォルトの名無しさん
2013/09/07(土) 23:47:55.46ただ「\n」が来たらハンドラを呼ぶだけ
0759デフォルトの名無しさん
2013/09/07(土) 23:48:50.30教えてくれてありがとう
0760デフォルトの名無しさん
2013/09/08(日) 00:09:38.160761デフォルトの名無しさん
2013/09/08(日) 00:13:22.240762デフォルトの名無しさん
2013/09/08(日) 00:14:31.65でreadline使わなかったのはコマンドプロンプトでペーストが効かなくなったから
0763デフォルトの名無しさん
2013/09/08(日) 00:16:52.59それ、コマンドライン実行の話じゃなくて？
0764デフォルトの名無しさん
2013/09/08(日) 00:20:10.33http://ideone.com/XsSW6r
0765デフォルトの名無しさん
2013/09/08(日) 00:33:11.760766デフォルトの名無しさん
2013/09/08(日) 00:34:33.230767デフォルトの名無しさん
2013/09/08(日) 00:35:49.960768デフォルトの名無しさん
2013/09/08(日) 00:40:47.420769デフォルトの名無しさん
2013/09/08(日) 00:44:03.22それをどう処理するかの部分が書けてれば、
標準入力の表現自体はどうでもいいように思う
0770デフォルトの名無しさん
2013/09/08(日) 00:51:51.700771デフォルトの名無しさん
2013/09/08(日) 00:58:43.300772デフォルトの名無しさん
2013/09/08(日) 02:05:44.29なんか、JSだとJITでその辺は最適化されるし、RubyのDarwinではLLVMの最適化が得られる。
Pythonの実行系はPyPyでよくわかってないけどやっぱり再帰処理を内部で高速に暗黙処理してる。
スクリプト言語でHaskellの実装系に似せようとしてるだけ無駄な議論。
0773デフォルトの名無しさん
2013/09/08(日) 02:11:03.65> 実は>>734はマルチバイト文字泣き別れまでは考慮してない
UTF8でマルチバイト泣き別れって何いってんの？
ASCIIと互換性がある（ASCIIとして処理してもほとんど問題がない）
のがUTF8なのに
0774デフォルトの名無しさん
2013/09/08(日) 02:14:26.96えーと、たとえば4096バイト毎にチャンクで入力が切られて送られてくるとすると、
文字「あ」を構成する3バイト(0xe3, 0x81, 0x82)の途中で切られることが
普通にあり得る
切られた前半と後半をそれぞれ文字列として別途デコードしようとすると、
切られてしまった「あ」は当然復元できない
ステートフルなストリーミングデコーダを用いて続けて入力を与えるなら
大丈夫だけど
0775デフォルトの名無しさん
2013/09/08(日) 02:15:05.24そうじゃない場合ももっと汎用的に考えてるんでしょ
0776デフォルトの名無しさん
2013/09/08(日) 02:15:57.57いや、>>774を見てもらえれば分かると思うのだけれどUTF8だろうがダメ
0777デフォルトの名無しさん
2013/09/08(日) 02:18:26.49普通に泣き別れするだろ。Python2.Xでは処理系がASCIIだからUTF8の文字が
2～3文字のASCIIに分割される。この時点で何らかの破壊的処理加えれれば
もう戻せなくなる。
逆はないのでPython3,Xからは処理系がUTF8になったから大丈夫だったはず。
JSなんざ詳しくしらんがそういうことはある。
0778デフォルトの名無しさん
2013/09/08(日) 02:18:52.88今回の例題の場合はASCII文字を暗黙のうちに想定してるでしょ
というか英単語の話でしょ
今まで誰も日本語を分割しようとしてないし、屁理屈乙
0779デフォルトの名無しさん
2013/09/08(日) 02:21:00.47ちょっと神経質すぎるんじゃありません？
0780デフォルトの名無しさん
2013/09/08(日) 02:21:05.52ASCIIしか考えていないといいたいのならそれでもいいけど、
>>773が何も分かっていないのは変わらない
0781デフォルトの名無しさん
2013/09/08(日) 02:22:16.48バイトレベルで切るというかそういう処理をしてるのは文字列処理として不適切。
0782デフォルトの名無しさん
2013/09/08(日) 02:22:43.32あぁ、そういう話か。
センスねぇな。
そういう場合はな、バイト単位で扱うんじゃなくて
行単位に整形して呼び出す形に先に整形するんだよ。
で、そういう関数が普通にあるんじゃねぇの？って発想する。
0783デフォルトの名無しさん
2013/09/08(日) 02:25:05.50node.jsのような処理系が低水準のIOでバイト単位で切るのはむしろ当たり前
ストリームの中身は文字とは限らず、バイナリの可能性がある
バイトストリームでしかないのだから
そして低水準のIOを使う限りはユーザに渡ってくる時点で「切られてしまっている」
0784デフォルトの名無しさん
2013/09/08(日) 02:25:40.77ストリームはさすがにUTF8が破壊されない形で入力を受けることはリスキーすぎる。
0785デフォルトの名無しさん
2013/09/08(日) 02:29:00.98文字列処理をやるんじゃないんですか？ワンライン（\n or \r or \n\r）までをバイナリとして取り出してUTF8の処理系に
持ち込むのが普通だと思います。Haskellのように副作用がない状態では実現できないことですが。
バイト処理で画像でも加工するのですか？だったらそれでいいですけど。
0786デフォルトの名無しさん
2013/09/08(日) 02:32:44.78バイナリかもしれないし、本当のエンコーディングなんてのも分からんから
汎用的なストリームAPIでそうなってるのは当たり前
0787デフォルトの名無しさん
2013/09/08(日) 02:34:19.950788デフォルトの名無しさん
2013/09/08(日) 02:35:33.26何か誤解してない？
>>734って別に好き好んでバイトレベルで処理したかったわけじゃないんだよ
node.js使うの今日が初めてだし上の方の例でみな勝手にバイト単位で切ってくる
低水準のIOを使ってたので、それに従って行単位に切るように
ある程度頑張ったけれども、泣き別れ対策までは完全でないって言ったのが>>743
もっと高水準なreadlineを使って楽になったのが>>764
0789デフォルトの名無しさん
2013/09/08(日) 02:37:29.91https://github.com/joyent/node/blob/master/lib/readline.js
0790デフォルトの名無しさん
2013/09/08(日) 02:39:29.19㌧
流れ把握できました。
文字列処理はFAはreadlineでとりましょうですかね。
0791デフォルトの名無しさん
2013/09/08(日) 02:42:02.68そんなの常識だろ…
文字列を扱う際にバイト単位の低レベルな操作を行うのはただのバカ
0792デフォルトの名無しさん
2013/09/08(日) 02:48:19.31普通と違う感じがいい
何だこの感覚
0793デフォルトの名無しさん
2013/09/08(日) 02:56:22.44その下に更にクラス実装層があって……ってなってる、アレでも抽象化されてる方
http://www.slideshare.net/shigeki_ohtsu/stream2-kihon
今はStream3でこれは2の話だけど基本は同じ
0794デフォルトの名無しさん
2013/09/08(日) 03:02:41.10こいつの290行目にバイト処理をregexでどうにかしようとしてる正規表現が見受けられますね。
ワンラインまでまとめてとりましょう感が伝わってきます。
>>791
バカはひどいっすね。C++でapache module作ってるとそこんとこガチになるんですよ。
0795デフォルトの名無しさん
2013/09/08(日) 03:05:19.09ほら、書きなおしてやったよ。
http://ideone.com/bQJ04f
0796デフォルトの名無しさん
2013/09/08(日) 03:06:16.79apache moduleはC言語で書けよ
0797デフォルトの名無しさん
2013/09/08(日) 03:07:29.98えらい変なことしてますね
0798デフォルトの名無しさん
2013/09/08(日) 03:08:25.24いやそこよりも、
http://nodejs.org/api/string_decoder.html
これを使ってる点が重要かな
まさに>>774が最後に言ってる「ステートフルなストリーミングデコーダ」
バイトベースの低水準IOをラップして高水準なテキストストリームを構築するには
必ずこの手のものが必要になる
0799デフォルトの名無しさん
2013/09/08(日) 03:11:36.07確かにバイトベースが基本でStringDecoderが強く分離して表に現れてるのは
Node設計上の特徴かも知れないが、
0800デフォルトの名無しさん
2013/09/08(日) 03:12:57.43そのuniqWord()関数は、よけいなことをしすぎているせいで
>>764が書いたuniqFilter()関数に比べて用途が限定されてて、
「その用途」にしか使えない関数になってるようだが
一体何がしたかったんだい？
0801デフォルトの名無しさん
2013/09/08(日) 03:14:05.38バイトから「文字列」を構築できてしまえば以後は泣き別れの心配もないし
行に割るのも簡単でしょ
0802795
2013/09/08(日) 03:14:27.86http://ideone.com/yFKY88
createInterfaceの引数部分は合わせた。
俺のコーディングスタイルじゃないんけどな。
0803デフォルトの名無しさん
2013/09/08(日) 03:14:36.620804デフォルトの名無しさん
2013/09/08(日) 03:16:23.26単に全ての入力を受け取って
初めてでる単語であればコールバックを返す
クラス（のようなもの）ですが？
0805デフォルトの名無しさん
2013/09/08(日) 03:16:51.680806デフォルトの名無しさん
2013/09/08(日) 03:17:41.26うーん
リンク先の使い方をみるにバイトでとってUTF8に変換してるけど、
これをラップして使ってるんだよね？この仕組みがあるってことが重要なのね。
UTF8は2 or 3byteだからこれを直に叩こうとすると死ぬわ。
UTF8の企画書とにらめっこしながら、PerlでUTF8を検知するためのくそみたいな
正規表現を書いたのはいい思い出。あれは透過的に使うべきで、エンジニアに
強いていいものじゃない。
0807デフォルトの名無しさん
2013/09/08(日) 03:17:42.96は？
バイトから文字列を構築する手段で泣き別れが起こるんだが
別にStringDecoderは半端な部分を教えてくれたり、バッファとして返してくれるわけじゃないぞ
見捨てるかデコード不能になるだけ
それを回避するのは結局自力でやらんといかん
0808795
2013/09/08(日) 03:20:39.75なんなら、もっと汎用的に単語に区切るだけ版もありますが？
http://ideone.com/1iiCwi
これだとuniqという単語の関数すら必要なくて
寂しかったんだよｗ
0809デフォルトの名無しさん
2013/09/08(日) 03:20:59.64でいいのに
0810デフォルトの名無しさん
2013/09/08(日) 03:23:07.97俺はSetちゃんを待つ
仕様には超絶楽な方法が書かれているのに
自分で書く気なんて起るか！！
0811795
2013/09/08(日) 03:23:19.06出さないってだけなので文字にさえ分割してしまえば
すごく単純なコードになっておもしろみがないんだよな。
一番簡単なキャッシュに仕組みと同じ。
0813デフォルトの名無しさん
2013/09/08(日) 03:25:10.73うわホントだ。ウソいってごめん
これじゃ単にtoString()するのと違いなくね？
0814デフォルトの名無しさん
2013/09/08(日) 03:25:29.570815デフォルトの名無しさん
2013/09/08(日) 03:25:37.16ダメ出しされてますけど、意味の無い再帰を使うより何倍もましになりましたね。
今は英語しか使えないスタイルですけど、形態素解析エンジン入れれば日本語も
充分なんじゃないですか。
0816デフォルトの名無しさん
2013/09/08(日) 03:28:04.97readline使ってるんだから改行区切りでコールバックでしょ？
（改行含めたASCII文字が文字の2バイト目以降に現れることがないのがUTF8）
0817デフォルトの名無しさん
2013/09/08(日) 03:28:14.47入れ子関数の間違い、か？
元々再帰は使っていないように見える
0818795
2013/09/08(日) 03:32:36.45で、まとめ
単語単位のuniq関数版
http://ideone.com/bQJ04f
関数使わない版（その分行数は一番短い）
http://ideone.com/yFKY88
汎用的に単語区切りでコールバックする関数だけを作った版
http://ideone.com/1iiCwi
あとは実際の使用目的で決めるもんだが、
ここでやってるのはただのサンプル作りなので
どれがいいかは決められん。
0819デフォルトの名無しさん
2013/09/08(日) 03:32:52.97ただの副作用もった関数の間違いだｗｗ
まぁ、副作用もたせないで書くことを前求めててくそコードになってたんでいいんじゃないですか。
JSでatomicな関数オブジェクト作れればもういいですよ。
atomic無理ならC++でエクステ書くか、再帰かければいいです。
0820デフォルトの名無しさん
2013/09/08(日) 03:36:01.970821デフォルトの名無しさん
2013/09/08(日) 03:39:40.40> uniq(words).forEach(function(x, _, _) { console.log(x) })
この部分ってnodeの思想とあわない気がするんだよね。
このコードではwordsの中から重複しない単語リストを求めてからforEachで処理してる。
つまり重複しないとわかった時点で出力するよりも、
レスポンスは悪いわけ。
wordsの数はたかが知れてるから問題無いだろうけど、
nodeはレスポンスを重視した実行環境だから。
0822デフォルトの名無しさん
2013/09/08(日) 03:42:34.24なるほど、そう説明されると意図が分かった
0823デフォルトの名無しさん
2013/09/08(日) 03:46:10.82ジェネレータなしでやるとコールバックになりますよってことかね
0824デフォルトの名無しさん
2013/09/08(日) 03:49:33.84まとめる（モジュール化というか・・・）もんでしょ？
0825デフォルトの名無しさん
2013/09/08(日) 03:58:22.73なんにせよどっかに様態を持たせないと前に現れたものなのかどうなのか
わからくないですかね。
もっと低レイヤーで処理しようとしても、関数型言語をfeatureしても無理、なきがします。
0826デフォルトの名無しさん
2013/09/08(日) 04:02:55.25いや君の考え方で合ってるよ
余ったバッファend()で返してくれる機能がある
でもそもそもそれを使わなくてもいいし、readlineはこれに頼ってない
何故なら泣き別れが起こるバイト列が渡された時は
正常にパースできるとこまでが返されて
半端に残ったバイト列は保持され、次writeした時に結合されるから
これがないとかなり大変だね
0827デフォルトの名無しさん
2013/09/08(日) 04:07:59.61思ったより随分簡潔
https://github.com/joyent/node/blob/master/lib/string_decoder.js
0828デフォルトの名無しさん
2013/09/08(日) 04:08:32.87すいませんが、何に対して意見しているのかわかりません。
関数型言語でも状態は持っています。
状態が変数に再代入が出来ないだけです。
0829デフォルトの名無しさん
2013/09/08(日) 04:13:55.110830デフォルトの名無しさん
2013/09/08(日) 04:18:56.85すみません。関数型云々は忘れましょう。
言いたいのは、応答速度あげようとしてもどっかに様態を持たないと
前に現れた単語を判別するすべがなくないですか。
nodeやjsは詳しくないですがリアルタイムに単語をユニークにしようとしている
と見受けられたのでそう言いました。
0831デフォルトの名無しさん
2013/09/08(日) 04:23:27.97リアルタイムに文字列を単語に切り分けるのもダメだな
そこはバイトバッファを少しずつ走査してもらわないと
0832デフォルトの名無しさん
2013/09/08(日) 04:28:27.38自分はC++,Python, Cを使いますけど、いずれでも実現できない芸当だと思います。
0833デフォルトの名無しさん
2013/09/08(日) 04:31:36.78splitとかのネイティブ実装もそれと近いことやってんだろうし
0834デフォルトの名無しさん
2013/09/08(日) 04:39:58.32あと、なんでエンコーディングがわかったらできるんです？
0835デフォルトの名無しさん
2013/09/08(日) 04:41:34.99そこで気になるのは受け渡しのオーバーヘッドだけど
JSのWorkerはオブジェクトの委譲ができるけど
他の言語ってそういうのできるの？
0836デフォルトの名無しさん
2013/09/08(日) 04:46:12.26速い遅いの問題じゃないよ
速さ重視ならそもそも分割する必要なんて無い
重い処理をする時にある程度分割してノンブロッキングにした方がいいねってことでしょ
エンコーディングがわかったらそのコーディングのルールの中で
目的の文字に当たるバイト列見つけられるでしょ
0837デフォルトの名無しさん
2013/09/08(日) 04:46:37.33nodeだとC++でエクステンション書くのが早いそうですよ。
スクリプト言語の限界をここでは感じますね。
0838デフォルトの名無しさん
2013/09/08(日) 04:48:24.780839デフォルトの名無しさん
2013/09/08(日) 04:49:09.99CやC++の話はしてないよ
0840デフォルトの名無しさん
2013/09/08(日) 04:57:34.28ノンブロッキングですかーnginxのコードをいじってますけど、nodeできるのかな。
そこはわかんないので、詳しい方に投げたいです。
分割送信をしてノンブロッキングで適当に送信しても内容が保障されるには、確かに
文字コードをIFレベルで知ってる必要がありますね。nodeのファイルストリームはasciiで
受け取ってるみたいなので、そこかえないと難しいのではないでしょうか。
0841デフォルトの名無しさん
2013/09/08(日) 05:02:06.200842デフォルトの名無しさん
2013/09/08(日) 05:03:31.74それに>>838でいいじゃん
0843デフォルトの名無しさん
2013/09/08(日) 05:03:33.98じゃあこの下り全体がスレ違いだな
バトルしてないし
0844デフォルトの名無しさん
2013/09/08(日) 05:12:30.390845デフォルトの名無しさん
2013/09/08(日) 05:36:29.36プロセス間通信とメモリ空間の安全な委譲じゃ次元が違うと思う
あと必ずしもネイティブで書いたのがスクリプトを上回るとは言えないよ
こういう例もあるし
tech.a-listers.jp/2012/10/10/faster-than-c/
これは動的に最適化された関数を作ってevalするみたいな
スクリプト言語のポテンシャルを上手く引き出してる
将来的にはもっとJITのサンプリングに期待できるしね
0846デフォルトの名無しさん
2013/09/08(日) 07:19:37.54それって、コードこれだろ？
https://github.com/felixge/node-mysql
evalなんて一つも使ってないんだが？
evalはevilっていってな、
どうしても使わなければ出来ない時以外
使うべきではないんだよ。
遅いし使うことなんてめったにないし。
0847デフォルトの名無しさん
2013/09/08(日) 07:28:41.79スクリプト言語のポテンシャルを引き出したというよりも、
動的言語は静的に比べてパフォーマンスは悪い。
しかしV8エンジンは頑張っていて、特定の書き方に限って
最適化がうまく出来る場合がいくつかある。
そのV8エンジン特有の最適な書き方を見つけ出し、
スクリプト言語で自由に書くという発想ではなく、
V8エンジンに依存した制限された書き方をすることで
パフォーマンスを上げているようにしか思えない。
0848デフォルトの名無しさん
2013/09/08(日) 07:34:50.01Cのエクステンション書くのに使ったら
もっと楽に高速な実装が出来てた気がする
0849デフォルトの名無しさん
2013/09/08(日) 08:04:55.05>>697については前者止まりって結論でOK？
0850デフォルトの名無しさん
2013/09/08(日) 08:29:37.43言語仕様は反証不可能
0851デフォルトの名無しさん
2013/09/08(日) 09:03:11.74速いと言われてるJavaScriptですらJavaより遅いのが現実なんだから
0852デフォルトの名無しさん
2013/09/08(日) 09:06:57.320853デフォルトの名無しさん
2013/09/08(日) 09:48:42.58動的型だからね
0854デフォルトの名無しさん
2013/09/08(日) 10:30:03.70SmalltalkとJavascriptで同じなのに、
あっさりと完璧に解いてみせたSmalltalkに対して、
グダグダと議論した上にしょぼい解答のJavascript……
どこで差がついたのか
0855デフォルトの名無しさん
2013/09/08(日) 11:19:39.39nodeならsync系の関数もあるからジェネレータ作ればできるんじゃないのか？
なんでわざわざコールバックで実装してるのか知らんが
0856デフォルトの名無しさん
2013/09/08(日) 11:53:01.06どうしてちゃんと仕様どおり動くの？
もしLazy使わなくていいなら、
RubyでもLazy使わずに後者で書けるのか？
それともRubyはLazyが入るつい最近まで
Smalltalkなんかに負けてたの？
教えてエロい人！
0857デフォルトの名無しさん
2013/09/08(日) 11:55:02.44その通り。
ほんと、JSの事わかってないよな
アホどもは。
0858デフォルトの名無しさん
2013/09/08(日) 11:55:47.21完璧に解いたってどれ？
大差ないだろ。
ほんの少しライブラリが有るかどうかの差。
0859デフォルトの名無しさん
2013/09/08(日) 12:02:37.78process.stdin.resume();
process.stdin.setEncoding('utf8');
var readline = require("readline");
var rl = readline.createInterface(process.stdin, process.stdout);
var seen = {};
rl.on('line', function (line) {
var words = line.match(/\S+/g) || [];
words.forEach(function(word) {
if (word in seen) {;
seen[word] = true;
console.log(word);
}
});
});
0860デフォルトの名無しさん
2013/09/08(日) 12:02:42.75イケてるライブラリを作れるかどうかの差なんだなぁ
0861デフォルトの名無しさん
2013/09/08(日) 12:03:12.26words [
^Generator on: [:g | self linesDo: [:line | line subStrings do: [:str | g yield: str]]]
]
uniq [
^Generator on: [:g |
| seen |
seen := OrderedCollection new.
self do: [:each | (seen includes: each) ifFalse: [g yield: (seen add: each)]]]
]
]
0862デフォルトの名無しさん
2013/09/08(日) 12:03:43.67違うぞ？
0863デフォルトの名無しさん
2013/09/08(日) 12:04:42.470864デフォルトの名無しさん
2013/09/08(日) 12:06:51.54var seen = {};
rl.on('line', function (line) {
var words = line.match(/\S+/g) || [];
words.forEach(function(word) {
if (word in seen) {;
seen[word] = true;
console.log(word);
}
});
});
0865デフォルトの名無しさん
2013/09/08(日) 12:07:33.46違わないぞ？JSがうんこすぎてイケてないからって目を背けるな
0866デフォルトの名無しさん
2013/09/08(日) 12:08:43.21その後でコードを読んで判断しよう
0867デフォルトの名無しさん
2013/09/08(日) 12:09:19.99var seen = {};
rl.on('line', function (line) {
line.words.forEach(function(word) {
if (word in seen) {;
seen[word] = true;
console.log(word);
}
});
});
0868デフォルトの名無しさん
2013/09/08(日) 12:15:08.33var seen = {};
rl.on('line', function (line) {
line.words.forEach(function(w) { if (w in seen) { seen[w] = true; console.log(w); }});
});
そして関数部分を分離して、更に一行につないでみる。
var seen = {};
function words(w) { if (w in seen) { seen[w] = true; console.log(w) }}
rl.on('line', function (line) { line.words.forEach(); });
0869デフォルトの名無しさん
2013/09/08(日) 12:15:29.71Smalltalkまであと一歩！
0870デフォルトの名無しさん
2013/09/08(日) 12:17:00.88var seen = {};
function words(w) { if (w in seen) { seen[w] = true; console.log(w) }}
function lines(line) { line.words.forEach(word) }
rl.on('line', lines);
結論としては、ただの書き方の違いなのである。
0871デフォルトの名無しさん
2013/09/08(日) 12:18:28.45おい、どうせ動かないコードだからって検証もしてないテキトーなコード載せんな
0872デフォルトの名無しさん
2013/09/08(日) 12:19:20.840873デフォルトの名無しさん
2013/09/08(日) 12:20:37.29seenを閉じ込めればいいの？ くくるだけだけど。
var words = (function() {
var seen = {};
return function (w) { if (w in seen) { seen[w] = true; console.log(w) }}
})());
0874デフォルトの名無しさん
2013/09/08(日) 12:23:34.83その関数をwords.forEach内で使うと
各行毎の重複しか判定できなくない？
0875デフォルトの名無しさん
2013/09/08(日) 12:29:31.85その点では利用者側から見て>>872が綺麗に実現できる方がずっと重要だ
まさかuniqが必要になるたびにコピペするつもりか?
0876デフォルトの名無しさん
2013/09/08(日) 12:57:48.31長々と書いたけど結局出来てないみたいだし
0877デフォルトの名無しさん
2013/09/08(日) 13:11:14.78まあまあ、慌てなさんなｗ 書き方次第だよっていう考え方を示したまでだよ。
http://ideone.com/tgfO5H
・11行（7行 ・・・ 標準入出力の初期化と、改行だけの行を除いた場合）
process.stdin.resume()
process.stdin.setEncoding('utf8')
var rl = require("readline").createInterface(process.stdin, process.stdout)
String.prototype.words = function() { return this.match(/\S+/g) || [] }
function words(f) { return function (l) { l.words().forEach(f) } }
function uniq(f) {
var seen = {}
return function (w) { if (!(w in seen)) { seen[w] = true; f(w) } }
}
rl.on('line', words(uniq(function(w) { console.log(w) })))
-----------------------------------------------------------------------------------------------
・11行
Stream extend [
words [
^Generator on: [:g | self linesDo: [:line | line subStrings do: [:str | g yield: str]]]
]
uniq [
^Generator on: [:g |
| seen |
seen := OrderedCollection new.
self do: [:each | (seen includes: each) ifFalse: [g yield: (seen add: each)]]]
]
]
0878デフォルトの名無しさん
2013/09/08(日) 13:41:50.14お前の目は節穴か、new Function使ってんだろ
それにevalが遅い？何言ってんだか
evalで作った関数はJITも効くし、最適化の１手法なんだよ
github.com/felixge/faster-than-c
eval is awesomeと言ってるじゃねえか
>>847,848
現実を認めようね
負け惜しみの希望論はいらない
0879デフォルトの名無しさん
2013/09/08(日) 13:45:32.33反応がない。new Functionも使われてないようだｗ
0880デフォルトの名無しさん
2013/09/08(日) 13:49:22.84process.stdin.setEncoding('utf8')
は要らない。
0881デフォルトの名無しさん
2013/09/08(日) 13:55:25.08一見Pythonのコードと同じで、フローが逆になってるのが面白いな
継続渡しスタイルっぽい感じ
>>880
その2行はそのサイト(ideone.com)が最初にデフォルトで挿入するみたい
0882デフォルトの名無しさん
2013/09/08(日) 13:56:11.31本当に節穴だったか
github.com/felixge/faster-than-c/blob/master/figures/mysql2-vs-new-parser/benchmark/new-parser/Protocol.js
0883デフォルトの名無しさん
2013/09/08(日) 13:56:34.29うん。ideoneが勝手に入れるから、
ideone特有の何かが有るんじゃないの？って
思ってそのままにしただけ。
0884デフォルトの名無しさん
2013/09/08(日) 13:57:43.01実際のライブラリの方でお願いしますｗｗｗ
なんで使ってないんですか？ｗ
0885デフォルトの名無しさん
2013/09/08(日) 14:10:11.81カウンターパートのasyncも入れればいいのに
プッシュ地獄のJavaScriptにこそ必要だろ
0886デフォルトの名無しさん
2013/09/08(日) 14:13:04.19このスタイルで、例えば途中で読み込みやめたい場合ってどうするの？
>>509の例だと、
stream = uniq(flatten(x.split() for x in sys.stdin)
としたとき、
for i, x in stream:
if i > 2:
break
とか書いたり、streamをtakewhileに渡したりできる
0887886
2013/09/08(日) 14:13:49.00+ for i, x in enumerate(stream):
0888デフォルトの名無しさん
2013/09/08(日) 14:16:09.30例外投げる
0889デフォルトの名無しさん
2013/09/08(日) 14:16:24.92まあRubyでLazy使わんでも>>553を書けんことはない。
require "set"
class IO
def words
Enumerator.new do |e|
each_line{ |line| line.split(/\s+/).each{ |str| e.yield(str) } }
end
end
end
class Enumerator
def uniq
Enumerator.new do |e|
seen = Set.new
each{ |x| e.yield(x) if seen.add?(x) }
end
end
end
$stdin.words.uniq.each{ |x| puts x }
0890デフォルトの名無しさん
2013/09/08(日) 14:17:44.87なるほど、ありがとう
0891デフォルトの名無しさん
2013/09/08(日) 14:19:38.64なにそれどんなの？
0892デフォルトの名無しさん
2013/09/08(日) 14:38:05.09#ロジックはちゃんと切り分けたいよ派（整理整頓主義）
filter uniq { begin { $seen = @{} } process { if (!$seen.Contains($_)) { ($seen.($_)=$_) } } }
cmd /c type con | % { -split $_ } | uniq
#いや面倒だからワンライナーがいいよ派、変数名も適当フィルタも文字列前提でいいよ派（やっつけ仕事主義）
cmd /c type con | % { -split $_ } | % { $a=@{} } { if (!$a.$_) { ($a.$_=$_) } }
#ワンライナーはいいけどseenはちゃんと閉じ込めたいよ派（コマンド長すぎ本末転倒主義）
cmd /c type con | % { -split $_ } | & { begin { $seen=@{} } process { if (!$seen.Contains($_)) { ($seen.($_)=$_) } } }
0893デフォルトの名無しさん
2013/09/08(日) 14:41:10.710894デフォルトの名無しさん
2013/09/08(日) 14:41:53.46// C#5.0
button.Click += async (object sender, EventArgs e) => {
button.IsEnabled = false;
using (var reader = File.OpenRead("file.txt")) {
string line;
while ((line = await reader.ReadLine()) != null) { // 一行非同期に読み込む
dialog.Content = line;
await dialog.ShowAsync(); // 非同期にユーザーの応答を待つ
}
}
button.IsEnabled = true;
};
継続渡しパターンを言語に組み込んだものだよ
awaitするたびにいったん処理が戻り、非同期操作が終わったらその後から再開する
yieldと似てるけど動作が真逆でしょ?
0895デフォルトの名無しさん
2013/09/08(日) 14:44:37.25訂正
ReadLine -> ReadLineAsync
0896デフォルトの名無しさん
2013/09/08(日) 14:47:31.58JSはエラーは握りつぶす一方で、フロー制御には例外を使うんだね
0897デフォルトの名無しさん
2013/09/08(日) 14:52:55.31うーんと、非同期処理が終わったら帰ってくるんだよね？
終わったっていうのはどういうところで判断してるの？
returnされたら？
それだったら非同期処理から非同期処理呼びたい時は全部await使うことになって
コールバックの仕組みと共存できないってことになるのかな？
0898デフォルトの名無しさん
2013/09/08(日) 14:55:26.79？？？
0899デフォルトの名無しさん
2013/09/08(日) 15:02:12.13この辺はやっぱよく使う言語の習性と個人の性格が出るねぇ
自分だとこのくらいの関数定義なら一行の方が読みやすい、くらいの勢いだから
filter uniq {
begin { $seen = @{} }
process {
if (!$seen.Contains($_)) { ($seen.($_)=$_) }
}
}
cmd /c type con | % { -split $_ } | uniq
0900デフォルトの名無しさん
2013/09/08(日) 15:04:10.89そう。returnされたら完了。
いわゆるFutureオブジェクト(C#ではTask)を使うので、コールバックを受け取るメソッドはそのままawaitできない。
その場合は専用のクラス(Promise相当ね)を使ってラップすることで簡単にawaitableにできる。
0901デフォルトの名無しさん
2013/09/08(日) 15:05:11.40なら他のスタイルにいらんイチャモンつけんでよかろ
全ては機械のためじゃなくて人が理解しやすいようにスタイルというもんはあるんだからさ
0902デフォルトの名無しさん
2013/09/08(日) 15:06:36.29エラーにならないのは、握りつぶしてるんじゃなくて
それがJavascriptでは正しい動作という文化だから
0903デフォルトの名無しさん
2013/09/08(日) 15:10:49.13単にそういう解釈をするって
定義されているだけの話だね。
0904デフォルトの名無しさん
2013/09/08(日) 15:11:08.22あ、ごめんあんまりいちゃんもん付けてる自覚はなかった
ネタ風味にはしてたけど
0905デフォルトの名無しさん
2013/09/08(日) 15:11:36.09これどういう基準で速いって言ってるんだ？
parseRowだけ速いってオチじゃないよな？
0906デフォルトの名無しさん
2013/09/08(日) 15:14:48.56JSでは逆にyieldベースで似たことやろうとしてると思う
ここのCOの例みたいなのがいくつかある
tech.nitoyon.com/ja/blog/2013/06/27/node-yield/
要はyieldで呼びたい関数を返して、返された側（CO）で適切なコールバックにフックを登録して
それが呼ばれたら適切な値を渡してイテレーターを１つ進めるというようなことをやってると思う
0907906
2013/09/08(日) 15:17:44.50呼び出された先が更にコールバック式でも、擬似await式でも気にする必要ないと思う
0908デフォルトの名無しさん
2013/09/08(日) 15:21:55.36手段じゃないからな。
0909デフォルトの名無しさん
2013/09/08(日) 15:24:34.410910デフォルトの名無しさん
2013/09/08(日) 15:27:17.20仕事じゃない場合はそうかもねｗ
0911デフォルトの名無しさん
2013/09/08(日) 15:36:39.49ライブラリのほうが圧倒的に差が出る。
0912デフォルトの名無しさん
2013/09/08(日) 15:41:03.23というかそのうちすべての言語は近づいていって
３種類くらいに落ち着くんじゃないか？
0913デフォルトの名無しさん
2013/09/08(日) 15:41:57.230914デフォルトの名無しさん
2013/09/08(日) 15:43:31.660915デフォルトの名無しさん
2013/09/08(日) 15:44:24.63論理型は孤高のまま
0916デフォルトの名無しさん
2013/09/08(日) 16:13:16.95言語に差は無いと言いたがる
0917デフォルトの名無しさん
2013/09/08(日) 16:17:56.77必死だね
0918デフォルトの名無しさん
2013/09/08(日) 16:19:56.01これだけやって得手不得手が見えてる状況でまだ言うんだから笑えるｗ
0919デフォルトの名無しさん
2013/09/08(日) 16:23:47.48・11行（7行 ・・・ 標準入出力の初期化と、改行だけの行を除いた場合）
process.stdin.resume()
process.stdin.setEncoding('utf8')
var rl = require("readline").createInterface(process.stdin, process.stdout)
String.prototype.words = function() { return this.match(/\S+/g) || [] }
function words(f) { return function (l) { l.words().forEach(f) } }
function uniq(f) {
var seen = {}
return function (w) { if (!(w in seen)) { seen[w] = true; f(w) } }
}
rl.on('line', words(uniq(function(w) { console.log(w) })))
-----------------------------------------------------------------------------------------------
・11行
Stream extend [
words [
^Generator on: [:g | self linesDo: [:line | line subStrings do: [:str | g yield: str]]]
]
uniq [
^Generator on: [:g |
| seen |
seen := OrderedCollection new.
self do: [:each | (seen includes: each) ifFalse: [g yield: (seen add: each)]]]
]
]
0920デフォルトの名無しさん
2013/09/08(日) 16:25:30.99無理やりギュウギュウに詰め込んでるだけやん。普通に書けばこうなる。
process.stdin.resume()
process.stdin.setEncoding('utf8')
var rl = require("readline").createInterface(process.stdin, process.stdout)
String.prototype.words = function() {
return this.match(/\S+/g) || [];
}
function words(f) {
return function (l) { l.words().forEach(f) }
}
function uniq(f) {
var seen = {}
return function (w) { if (!(w in seen)) { seen[w] = true; f(w) } }
}
rl.on('line', words(uniq(function(w) { console.log(w) })))
0921デフォルトの名無しさん
2013/09/08(日) 16:35:36.53言語仕様の差じゃねぇもん。
言語の部分だけで、10行が1行ぐらいになったら
大差あると思うけどさ。
0922デフォルトの名無しさん
2013/09/08(日) 16:47:19.01普段から全部CPS(継続渡しスタイル)で書きたいか？と考えると
使い勝手に如実に差がある感じはする
まあnodeのスタイルがCPSだというのなら仕方がないけれども
上で誰かが話してた内部イタレータと外部イタレータの違いみたいな話じゃないか？
0923デフォルトの名無しさん
2013/09/08(日) 16:59:55.99V8がES6サポートしたら
>713,714
みたいなんで書けばいいと思いますよ
0924デフォルトの名無しさん
2013/09/08(日) 17:03:22.84出てきたコードがこれなのでガッカリだ
0925デフォルトの名無しさん
2013/09/08(日) 17:04:25.65言い返せないお前にがっかりだｗ
0926デフォルトの名無しさん
2013/09/08(日) 17:05:57.34いま丁度JSは言語が10年ぶりに大きく変わる微妙な時期に差し掛かってる
今年の11月がラストコールの予定だから
来年実装が一気に進むとは思うが
0927デフォルトの名無しさん
2013/09/08(日) 17:06:08.80その例だとIOは相変わらずコールバック（プッシュ型）だけど、
そこが上で出てたasync/awaitみたいな方法で普通のプル型にできるんなら
文句はなさそうかな……
その辺、今はまだ発展途上って感じがするね
0928デフォルトの名無しさん
2013/09/08(日) 17:08:32.80どうとでも書けることにはどうとでも書けるから
正直言っていかに簡潔なコードを書くかみたいな探究心がJSerには足りんのかもしれん
すくなくとも自分は見合ってないと思う
言語が悪いんじゃないから言語に申し訳がない
0929デフォルトの名無しさん
2013/09/08(日) 17:09:26.36RubyやPythonやSmalltalkに比べて
どこが優れてるの？
いいとこイーブンじゃない？
0930デフォルトの名無しさん
2013/09/08(日) 17:10:17.90だから十分簡潔だろ。
頭大丈夫か？
0931デフォルトの名無しさん
2013/09/08(日) 17:11:14.71ライブラリによる所が大きい。
0932デフォルトの名無しさん
2013/09/08(日) 17:11:50.20何が嫌なのか分からんな
IOの話しならreadline使えば差異は無いんじゃないか？
0933デフォルトの名無しさん
2013/09/08(日) 17:14:06.20ここでいう十分とは、ここにいる人を満足させられるということだと思ってる
そっちの面での戦いは厳しいわ
実アプリがどうのとかじゃなくて
0934デフォルトの名無しさん
2013/09/08(日) 17:16:08.45プル型はconsumerが主体になってproducerからデータをひっぱる(pull)
プッシュ型はproducerが主体になってconsumerにデータを渡す(push)
主体の違い
普通のGUIプログラミングのコールバックとか
SAXのようなコールバック式のストリームパーサみたいなのがpush型
while ((c = getchar()) != EOF)
みたいなのがpull型
0935デフォルトの名無しさん
2013/09/08(日) 17:19:01.69データを必要としてる側が「必要に応じて」ドライブするほうが
明らかに楽かつ制御しやすいから
普通はみんなそうだと思うのだけれど
0936デフォルトの名無しさん
2013/09/08(日) 17:23:26.67必要に応じてって、どこが終わりかわからないソケットで今回のケースは
定期的に調べてバッファを貯めて１行分溜まったと判断出来たら切り出して処理をするよりも、
内部的にそれをやってもらって、行単位でプッシュしてくれることにこしたことないんじゃない？
例の「レイテンシ」の話もあるしさ
間違ってる？
0937デフォルトの名無しさん
2013/09/08(日) 17:36:11.120938デフォルトの名無しさん
2013/09/08(日) 17:38:28.62何か勘違いしてるみたいだけど、プル型だからといって
別にポーリングになる訳じゃないよ
0939デフォルトの名無しさん
2013/09/08(日) 17:44:01.800940デフォルトの名無しさん
2013/09/08(日) 17:46:12.72Nodeも.read(size)で好きな時に好きなだけプルできるけど
それやるとめんどくさくなるだけだと思うんだけど。
0941デフォルトの名無しさん
2013/09/08(日) 17:51:02.060942デフォルトの名無しさん
2013/09/08(日) 17:55:24.17producerにデータがあるか尋ねる→あるかないかが即座に回答が返ってくる
これを定期的に繰り返して、データがあったら受け取る
割り込み：
producerからデータがある場合にconsumerにイベントで通知するので無駄がない
一般的なブロッキングIO：
consumerはデータが欲しいと要求する。データが来るまでconsumerの制御は
そこでブロックする。データが来た時点で即座にconsumerに制御が戻り、
consumerの処理が中断していたところから再開される。
内部的にはトランポリンと呼ばれる仕組みが使われる。producerからの
イベントをトリガとしているので、やはり無駄がない。
非同期のプル型：
consumerにはブロッキングIOと同じように見える。ただし実際には
「consumerは」そこで止まっているけれどもプロセスはブロックしていない。
プロセス内で自前でコンテキストを管理しているコントローラに制御が戻るだけで
そっちは動いている。データが来た時点で、コントローラがconsumerの仕事を
再開させる。
0943デフォルトの名無しさん
2013/09/08(日) 18:02:50.60ノンブロッキングI/O 【 non-blocking I/O 】 非同期I/O / asynchronous I/O
コンピュータ内部のCPUと周辺装置のデータ入出力(I/O)において、
データの送受信の完了を待たずに他の処理を開始する方式。並列処理の一種。
ノンブロッキングI/Oでは、I/O処理と並列に、データの送受信が完了していなくても
可能な処理を進め、送受信が済まないと進められない処理にたどりついた場合に、
そこで送受信の完了を待つ。これに対し、正常に送受信が完了したかどうかの結果を待ち、
送受信処理に完了してから残りの処理を行う方式を同期I/O(ブロッキングI/O)という。
0944デフォルトの名無しさん
2013/09/08(日) 18:06:28.84ブロッキングI/Oが優れているように見えるけど、
他にやれることがあったとしても、ブロックして止まるから
効率は悪いんだよな。
0945デフォルトの名無しさん
2013/09/08(日) 18:07:53.82そうそう、なので非同期のプル型では同期のブロッキングI/Oと同様に
consumerが止まっていても、プロセス自身は他の仕事ができる(並列処理)
kernelがやっている仕事（コンテキストスイッチ）を処理系がプロセス内でやるイメージ
0946デフォルトの名無しさん
2013/09/08(日) 18:10:48.770947デフォルトの名無しさん
2013/09/08(日) 18:11:06.17プロセス自体はそこで停止してしまう。
それを避けるためにforkしたりスレッドを作ったりするが、
そうするとメモリ使用効率が悪くなる。
そこでブロックするような処理を全部非同期で行えば、
メモリ使用量も控えられパフォーマンスをあげられるという考えがでてきた。
0948デフォルトの名無しさん
2013/09/08(日) 18:17:28.07こういうのがpullってことでいいんだよね？
http://ideone.com/G9aqFo
0949デフォルトの名無しさん
2013/09/08(日) 18:22:56.23nodeは知らんからよくわからん
イメージだけで言えば
while ((line = stdin.readline()) != null)
console.log(line)
とか
for (line <- stdin)
console.log(line)
みたいな形で書けるのがpull
0950デフォルトの名無しさん
2013/09/08(日) 18:25:13.67Nodeの思想的にもアウトでしょう
0951デフォルトの名無しさん
2013/09/08(日) 18:29:58.92ビジーループじゃないよ
stdin.readline()
を呼ぶと、readline()を呼んだタスクなりコルーチンなりはそこで止まって
待ちに入る
止まっているのだからビジーではない
かといって、非同期モデルであれば、プロセス自体が停止してしまうのでもなく
他の仕事はできる
一方readline()を呼んだタスクは貰える入力に「依存」しているから、
入力が届くまでここで待たされるのが正しい
0952デフォルトの名無しさん
2013/09/08(日) 18:30:53.02http://ideone.com/G9aqFo pull
http://ideone.com/6NDxyd push+pull
http://ideone.com/q9wenL push
だと思ったんだけど
0953デフォルトの名無しさん
2013/09/08(日) 18:36:45.81> console.log(line)
これをビジーループと思う人が
どういうプログラミング言語を使って来たのか興味ある
煽り成分0で
0954デフォルトの名無しさん
2013/09/08(日) 18:37:39.72いや、Nodeだとビジーループになるって話
それにそのタイプだと登録したいくつもの同じ関数が処理途中のまま存在する状況が容易く起きるから
副作用を使う場合だと、マルチスレッドのときの競合を
１関数の中でも考えなくちゃいけなくなって大変じゃない？
それは副作用のない関数型の考え方だと思う
0955デフォルトの名無しさん
2013/09/08(日) 18:46:16.59プッシュ型だったのを、async/awaitの導入でプル型の非同期処理を可能にした
経緯があるわけで、その心配は的外れと言わざるを得ない
「現状の」nodeの処理系では、それを適切な形でサポートしていないというだけの話
0956デフォルトの名無しさん
2013/09/08(日) 18:52:00.12puts "Hello"
puts line
puts "World"
これを実行したときに、「"Hello"出力 => 標準入力待ち => line出力 => "World"出力」
って順番で実行される非同期処理ってあるっけ？
入力はputs lineまで使わないから、それまでに進められる処理は進めとく、みたいな。
これってスゲー効率良くない？
0957デフォルトの名無しさん
2013/09/08(日) 18:54:17.12func アクセスがあったら{
配列の長さ＝ログイン者ID一覧の配列の長さ
「配列の長さ＋"人がログイン中"」と返答する （ここで待機）
配列の長さのインデックスに新しいIDを登録
}
みたいな関数は厳禁になるでしょ
>>951の話通りのもので適切にってのはありえないと思うよ
だからNodeではそういう文化のないJSとコールバック式が積極的に選ばれたんでしょ
0958デフォルトの名無しさん
2013/09/08(日) 19:01:25.07ここで待機って、何を待ってるの？
0959デフォルトの名無しさん
2013/09/08(日) 19:09:29.11例だよ例
データを読むのでもいいし、ファイルに書き込むのでもいいし、何でもいい
関数が中断して他の関数が始まるような設計だと副作用がおいそれとはできないでしょ
0960デフォルトの名無しさん
2013/09/08(日) 19:13:08.46それがデフォルトだとコールバック地獄以上に頭が痛くなると思うわ
0961デフォルトの名無しさん
2013/09/08(日) 19:17:44.490962デフォルトの名無しさん
2013/09/08(日) 19:26:50.66言語システムから上のフレームワークまでどちらかに絞った設計じゃないと破綻しそう
0963デフォルトの名無しさん
2013/09/08(日) 19:26:55.94要は、待機時に他に制御が移るなら、プログラムのグローバルな状態が
待機の前後で変わる可能性があると言いたいわけな
一方nodeの単純なコールバック式では関数が終了するまで他に制御が
渡らない（よってその間状態は書き換わらない）と確信が持てると
それはその通りで、もしグローバルな状態を扱っている場合は、
制御が戻った後で、再度取り出すように書かないとダメ
そこは要注意だけど、nodeでは上の例だと待機の後の仕事をコールバックとして
書くだろうから、コールバックがつらなるよりは書きやすいことが一般には多い
グローバルな状態でなければ、上のような心配もないしね
0964デフォルトの名無しさん
2013/09/08(日) 19:37:31.17でもJSとは水と油なんじゃないか？
Node.haskellとかなら有りだと思う
0965デフォルトの名無しさん
2013/09/08(日) 19:38:30.17無理
0966デフォルトの名無しさん
2013/09/08(日) 19:39:58.13結局関数型スタイルで書く事になるんじゃないか？
0967デフォルトの名無しさん
2013/09/08(日) 19:58:39.86どっちも一緒じゃないか？
関数A:
グローバル状態Aでの仕事
何かを待つ
グローバル状態A'での仕事
と、
関数A:
グローバル状態Aでの仕事
待機後の仕事をする関数A'を登録
関数A':
グローバル状態A'での仕事
の違い
どっちも待機後にグローバルな状態が変わっている可能性は変わらなくて、
できることも変わらない
前者のプログラミングスタイルではそれを失念しやすいというだけ
0968デフォルトの名無しさん
2013/09/08(日) 20:03:30.25グローバル状態A'で使うと困るんじゃないの？という話かな
それは困るだろうな
0969デフォルトの名無しさん
2013/09/08(日) 20:13:52.48グローバル変数を触るのは元々あんまり良いことじゃないとされてるけど
１つ上のスコープの変数扱うことは日常茶飯事で
特に扱いも注意しないし大胆に使う事が一般的だから
そういうスタイルとは水と油ってことでは？
0970デフォルトの名無しさん
2013/09/08(日) 20:19:50.69困るケースはとりあえず2つ思いつくんだが、どっちもグローバル絡みだな
・グローバルな状態をキャプチャしているので、書き換わってしまう
・クロージャインスタンスをグローバルな場所に置いてあるので、
クロージャが他のコンテキストから呼ばれて、キャプチャ変数が書き換わってしまう
普通のクロージャの用途では、外のスコープのローカル変数をキャプチャすることが
多く、クロージャインスタンスを他のコンテキストから可視な場所に置かなければ
困ることはないはず
0971デフォルトの名無しさん
2013/09/08(日) 20:41:16.28http://toro.2ch.net/test/read.cgi/tech/1378640419/
0972デフォルトの名無しさん
2013/09/08(日) 20:49:49.650973デフォルトの名無しさん
2013/09/08(日) 21:00:06.55>
> stdin.readline()
> を呼ぶと、readline()を呼んだタスクなりコルーチンなりはそこで止まって
> 待ちに入る
そういうこと。止まってしまうね。何もできなくなってしまうね。
> 止まっているのだからビジーではない
> かといって、非同期モデルであれば、プロセス自体が停止してしまうのでもなく
> 他の仕事はできる
うん、その場合、forkしたりスレッドを使う必要がある。
でもそうすると、メモリを食うわけよ。
nodeができたのは、その問題点を解決するには
どうするかってのが出発点なわけ。
俺からすればドヤ顔で欠点を言ってるようにしか見えないんだよ。
0974デフォルトの名無しさん
2013/09/08(日) 21:00:47.23１つの参照型のオブジェクトを多くの関数から参照している干渉問題と
いくつかのクロージャ（スコープ）が外の同じ変数を参照している干渉問題は
同時に起こることも多いけど違う問題だと思う
0975デフォルトの名無しさん
2013/09/08(日) 21:03:20.780976デフォルトの名無しさん
2013/09/08(日) 21:07:09.88> うん、その場合、forkしたりスレッドを使う必要がある。
> でもそうすると、メモリを食うわけよ。
fork()したりスレッドを使う必要があるのは、あくまで同期(ブロッキング)I/Oの場合
それが嫌なので、非同期I/Oとコルーチンやファイバ、自前のスケジューラを使って
同期と同じようなプルモデルを実現したのが上で言っているやり方
0977デフォルトの名無しさん
2013/09/08(日) 21:09:11.26銀の弾丸は存在しない
0978デフォルトの名無しさん
2013/09/08(日) 21:12:10.410979デフォルトの名無しさん
2013/09/08(日) 21:15:49.19JSerとしては泣けばいいんですかねぇ
0980デフォルトの名無しさん
2013/09/08(日) 21:17:33.25そんなこと知ってるよ。
nodeの作者のRyan DahlはJavaScriptが好きだったからnodeを作ったのではない。
C10K問題を解決するのにどうするか？って問題に取り組んでいた。
コルーチンやスレッドを使った方法ではC10K問題が起きていたのだ。
そしてあるとき非同期が有効であると気づいた。
C10K問題を解決するために、非同期メインで全てのライブラリを構築しなければならない。
だが既存の言語、ライブラリは、同期メインで作られていた。
標準入出力といった基本的な部分が、同期ライブラリとして既に言語に組み込まれていた。
JavaScriptはブラウザで動かすがゆえに標準入出力を含めた機能が言語になかった。
そしてブラウザではsetTimeoutなどの非同期を使ったプログラミングが主流だった。
それがC10K問題を解決するため、非同期ライブラリで世界を構築するという目的に見事に当てはまった。
JavaScriptを使ったサーバーサイド実行環境はnode以外にも存在する。
それらは既存の言語と同じように同期ライブラリも多数ある。
だがnodeといった時、それはコルーチンやスレッドは害であり
非同期で作ったほうがパフォーマンスが高いというのが根底にある。
そこにブロッキングI/Oとか持ちだしても、そもそもそのやり方がダメだから
避けようという話だったよね。ということにしかならないのである。
0981デフォルトの名無しさん
2013/09/08(日) 21:20:09.20なあに、次スレの次スレではJSが復活するさ
0982デフォルトの名無しさん
2013/09/08(日) 21:22:07.820983デフォルトの名無しさん
2013/09/08(日) 21:23:48.920984デフォルトの名無しさん
2013/09/08(日) 21:23:52.52なんでコルーチンでC10K問題が起きるの？
よく知りもしない事を適当に書いてない？
0985デフォルトの名無しさん
2013/09/08(日) 21:23:59.56意図的に排除してるんだよね。
0986デフォルトの名無しさん
2013/09/08(日) 21:30:36.190987デフォルトの名無しさん
2013/09/08(日) 21:31:45.170988デフォルトの名無しさん
2013/09/08(日) 21:33:24.25いや普通に同期IOも使えるよ
nodeが開発用のツールを作るのにも使われてるのは同期IOがあるおかげ
0989デフォルトの名無しさん
2013/09/08(日) 21:36:09.03http://bostinno.streetwise.co/2011/01/31/node-js-interview-4-questions-with-creator-ryan-dahl/
> BostInno: Why did you originally choose javascript for node?
> Dahl: Originally I didn't. I had several failed private projects doing the same on C, Lua, and Haskell.
> Haskell is pretty ideal but I'm not smart enough to hack the GHC.
> Lua is less ideal but a lovely language - I did not like that it already had a lot of libraries written with blocking code.
> No matter what I did, someone was going to load an existing blocking Lua library in and ruin it.
> C has similar problems as Lua and is not as widely accessible.
> There is room for a Node.js-like libc at some point - I would like to work on that some day.
> V8 came out around the same time I was working on these things and I had a rather sudden epiphany that
> JavaScript was actually the perfect language for what I wanted: single threaded,
> without preconceived notions of "server-side" I/O, without existing libraries.
0990デフォルトの名無しさん
2013/09/08(日) 21:36:34.27至る所、終了待たず実行されてしまうと、プログラマの手間が増える。
0991デフォルトの名無しさん
2013/09/08(日) 21:36:35.52同期APIを「使ってしまう」ことはない
そこがポイントだと思う
httpなんかも標準では同期ないし、使ってしまわないように徹底的に排除されてる
0992デフォルトの名無しさん
2013/09/08(日) 21:38:14.42なるほどNode.jsにJSが選ばれるのにも色んな経緯があったんだねぇ
0993デフォルトの名無しさん
2013/09/08(日) 21:41:51.19言語とネイティブを繋ぐ部分も非常にうまく出来てる。
0994デフォルトの名無しさん
2013/09/08(日) 21:44:43.630995デフォルトの名無しさん
2013/09/08(日) 21:52:43.28> いや普通に同期IOも使えるよ
数はものすごく少ない。
> nodeが開発用のツールを作るのにも使われてるのは同期IOがあるおかげ
非同期I/Oでできないことなんてないよ。
だから同期I/Oのお陰ではない。
0996デフォルトの名無しさん
2013/09/08(日) 21:52:45.140997デフォルトの名無しさん
2013/09/08(日) 21:54:03.06はいはい。それがハックです。
スマートなあなたがハックしてください。
0998デフォルトの名無しさん
2013/09/08(日) 21:55:14.85そうなったら鬼に金棒だろう。
0999デフォルトの名無しさん
2013/09/08(日) 21:55:19.13ツールとかでは普通に同期使う
起動時の設定ファイル読み込みとかも非同期でやる価値ないし
1000デフォルトの名無しさん
2013/09/08(日) 21:56:19.43>>971
1001１００１
Over 1000Threadもう書けないので、新しいスレッドを立ててくださいです。。。
レス数が1000を超えています。これ以上書き込みはできません。