12/04/07 21:26:47.61
一般的には、オブジェクト指向型言語が優勢でが
一部には関数型言語を崇拝している人もいます
どちらが上なのか、この際はっきりさせましょう
前スレ ｽﾚﾘﾝｸ(tech板)
2:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:27:35.64
オブジェクト指向 ∋ (関数型言語 VS 手続き型言語)
ｽﾚﾘﾝｸ(tech板)
3:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:29:47.00
前スレ>>1000
> それならそれでFILTERでも変更できるインターフェースを付け加えればいいだけ。
そういう変更/拡張のし易さも議論の対象
ちゃんと変更したコードを提出しないと比較にならない
負け惜しみじゃないんだろ？
4:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:35:39.48
>>3
本来はフィルタでやることではないよ。
それわかってる？
5:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:37:53.28
まあやるなら、
class Filter {
private i = 0;
private m = 0;
begin(awk) {awk.RS=';'}
filter(line) {i++; m = max(m, line.length()); }
end() {print "最大文字数は"+m+"文字でした"}
}
こんな感じだろうｗ
6:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:39:53.53
>>4
いいから「改行コードを変更する拡張をする」に対して
OOPでやるとどれくらい簡潔になるか、コードを出せって
疑似コードじゃなくて動くヤツな
7:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:41:05.68
beginの引数が変わるのが好ましくない場合は
こんな感じかな。まあこの例ならsetuupでやればいいことだけど。
class Filter {
private i = 0;
private m = 0;
private awk;
setup(awk) {this.awk = awk}
begin() {awk.RS=':'}
filter(line) {i++; m = max(m, line.length()); }
end() {print "最大文字数は"+m+"文字でした"}
teardown() {this.awk = null}
}
8:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:41:31.13
>>5
肝心の部分はどうしたんですか？
どうやってセパレートしたんですか？
そうやって誤摩化すってことは、関数型言語で一瞬で書けるコードが
OOPでは難しいってことですね？
9:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:42:07.17
>>6
OOPでやると簡潔になるんじゃなくて、
変更の範囲を極小化出来るんだよ。
該当のフィルタだけの修正で、
それ以外の場所は何も変えないで変更できる。
10:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:42:59.33
いいから代表的なコードは貼りなおせよ
使えないな
11:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:43:29.55
>>8
え？ 行フィルタなのに、ファイル全体をセパレートするのはおかしいでしょ？
ここにないのは、ここにあるべきじゃないコードだからだよ。
12:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:43:49.61
じゃあ、問題をはっきりさせよう
「標準入力から文字列を読み込んで、カンマ区切りで改行して、
各行の文字数を数えて最大文字数を標準出力に表示せよ」
これを書いて
13:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:45:14.12
設計がおかしいって指摘されて
ファビョってきたなｗ
全部関数なんかでやろうとするから
設計ができないんだ。
14:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:46:27.84
>>12
それ問題が不適切。
「標準入力」から文字列を読み込んで、「カンマ区切りで改行」して、
「各行の文字数を数えて最大文字数」を「標準出力」に表示せよ
ただし、カッコの中は一例であり
容易に変更できる設計にしておくこと
15:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:47:53.75
○から文字列を読み込んで、△で改行して、
各行に対して□を処理をして、その結果を☆に表示せよ
抽象化するとこんな感じか。
16:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:49:26.82
またこういう例題か…
ｵﾚ何度も書いたし、もういいや今日は。
17:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:50:59.80
コードが出ても議論が進まないことがはっきりしただけかｗ
18:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:51:11.25
まず、リーダーインターフェースが必要。
そのリーダーインターフェースを実装した、
標準出力リーダークラスを作る。
行セパレータインターフェースが必要
その行セパレータインターフェースの実装として、
\r\nセパレータを作る
その後フィルタインタフェースが必要で
そのフィルタインタフェース（begin、filter、end）を実装した、
「各行の文字数を数えて最大文字数」はfilterで文字数を数えて
endで結果を出力する。
あとは、同様にライタインターフェースを実装した
標準出力ライタクラス。
19:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:51:29.89
どうせなら、parottをJapaで書いたらこーんなに見通しのよいﾌﾟﾛｸﾞﾗﾑが短期間でできましたよ
とかそんくらいの成果聞いてみたいもんだわ
20:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:52:01.14
結局拡張性をもたせようとすると、
こんな感じになるわけ。
例外が悪いという意味がわかったかな？
21:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:53:56.24
能書きからして冗長までは良くわかった。
22:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:54:17.31
関数型は実装の一つを書いているだけ。
オブジェクト指向は様々な実装を書くための仕組みを
提供するもの、つまり設計の部分なので
やることの対象が違うんだよ。
オブジェクト指向で枠組み設計を行い
関数型言語でその枠組みの中身を書く
23:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:55:34.83
冗長というか、単にオブジェクト指向は、単処理よりも
広範囲な部分、処理の連携部分を記述する言語ってことなだけでしょ。
24:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:57:26.44
この程度の例題で広範も減ったくれもない気がす
25:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 21:58:48.39
>>22
> オブジェクト指向で枠組み設計を行い
> 関数型言語でその枠組みの中身を書く
こんな感じ？
{-# LANGUAGE RecordWildCards #-}
import System
import Control.Monad
data Filter a b = Filter { begin :: a, body :: a -> String -> b, end :: b -> IO () }
awkLike Filter{..} = end . body begin
countFilter = Filter {
begin = Nothing,
body = \_ -> maximum . map length . lines,
end = \p -> putStrLn $ "最大文字数は" ++ show p ++ "文字でした"}
splitBy _ [] = []
splitBy p xs = a : (splitBy p $ drop 1 b) where (a, b) = break p xs
countFilterSplitBy sep filepath = countFilter {
body = \_ -> maximum . map length . splitBy (== sep),
end = \p -> writeFile filepath $ "最大文字数は" ++ show p ++ "文字でした"
}
main' = awkLike countFilter =<< getContents -- 例1: 標準入出力使用、普通にカウント
main = mapM_ (awkLike (countFilterSplitBy ',' "test.txt") <=< readFile) =<< getArgs -- 改行コードを変えて入出力先も変更
26:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 22:00:33.04
>>25
おー、なかなか。ﾊﾟﾁﾊﾟﾁ
27:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 22:04:02.78
なんかお株奪われた?
28:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/07 22:37:31.82
>容易に変更できる設計にしておくこと
ソースにパッチを当てて変更するのは容易ではないの？
パッチが容易ではないというのは、もしかして
「CUIは容易ではない」「GUIは容易」みたいな思想と関係あるのか
29:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 00:08:18.23
> ソースにパッチを当てて変更するのは容易ではないの？
ソースにパッチ当てるといってもいろんな意味がある。
インターフェースを変更するようなソースの修正は容易ではない。
影響があちこちに波及するからだ。
30:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 04:41:56.60
OOが使えそうなところにはOOの機能を使うし、
関数型が使えそうなところには関数型の機能を使う。
両方使えそうにないところは普通の手続き型の格好に。たったそれだけのことだろ？
「関数型 vs オブジェクト指向」 からは、「if文 vs for文」並みのナンセンスさを感じるね。
OOも関数型も単なる一機能なんだから、状況に合わせて 使う/使わない すればよいじゃない。
31:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 04:57:44.26
なにも言ってないレスされても
32:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 07:15:51.37
>>30
「関数型 vs オブジェクト指向」ならその通りなんだけど、
ここは「関数型言語 vs オブジェクト指向言語」なんだわ
33:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 09:46:11.98
そういや関数型指向ってないよねｗ
34:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 09:53:06.98
>>29
パッチの意味は追加と削除の二種類しかない。
マクロな視点でいうと、最新版を出す影響と古い安定版を切り捨てる影響の二つ。
現に大きな影響が出ているが、
関数型とオブジェクト指向の人間はこの問題についてなにも言ってない。
なぜなら、古い仕様が優遇されてしまうと手続き型が圧倒的に有利だから。
35:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 09:55:37.49
>>34
具体的に言って下さい。
36:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 10:00:13.98
>>33
functional (programming)
37:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 10:35:21.46
一口にパッチと言っても
・ソースコード自体を書き換える方法
・ソースコードはそのままに静的に書き換える方法（マクロ、テンプレート）
・ソースコードはそのままに実行時に書き換える方法（モンキーパッチ）
などがあるのですが
38:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 11:01:10.34
>>37
文字列自体を操作する方法と、文字列に代わるものを操作する方法があるよね
39:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 11:13:21.18
>>33
個人的に、関数型言語は「型指向」だと思う
どう言う型受け取って、どう言う型を変えしたいのか考えると、自然と答えが出て来る
40:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 11:22:39.91
>>37
それらの区別はたいして何も変わらんｗ
41:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 11:25:46.31
個人的には、OOPLだと設計がしっかりしてないと拡張するとき困ること多いけど、関数型言語だと、設計を意識しなくても（行き当たりばったりでも)拡張しやすい感触がある
納期に迫られ、ろくに設計できる環境も、人材も無い現場では関数型言語の方が向いてると思うんだが・・・
checkPermu ns = and.concat $ check ns
where
check [] = [[]]
check (x:xs) = map (x/=) xs : check xs
allPattern 0 _ = [[]]
allPattern _ [] = [[]]
allPattern n (ns:nss) = [x:xs | x <- ns, xs <- allPattern (n-1) nss]
-- 普通に作ったpermutations(使用例：permutations [1..3])
permutations ns = permutations' (length ns) ns
where
permutations' 0 _ = [[]]
permutations' _ [] = [[]]
permutations' n ns = [x:xs | x <- ns, xs <- permutations' (n-1) ns, checkPermu (x:xs)]
-- 汎用的なallPatternを作って、それに差し替えたpermutations
permutations2 ns= filter checkPermu $ allPattern (length ns) (replicate (length ns) ns)
-- allPatternを使った拡張版permutations(使用例：permutationsEx 3 [[1..3],[1..3],[1..3]])
permutationsEx n ns= filter checkPermu $ allPattern n ns
42:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 11:45:02.42
>>40
全然違うだろアホか
43:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 12:11:04.47
>>39
節子、動的・動的…
44:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 12:22:28.84
>>18の方針でJavaで実装したら100行超えた……
やっぱOOPはウンコだわ……
45:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 12:33:46.77
でも関数型でも50歩100歩だったよ・・・
46:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 12:34:12.65
>>41
俺は
「設計を意識しないとそもそも書けない」のが関数型言語で
手続き型言語やOOPLはメチャクチャな設計でも書けるor書けてしまうが
ちゃんと意識すると関数型言語にも通ずるようなコードが出来上がる
…と感じる
47:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 12:34:19.20
じゃあRubyで実装しましょうよｗ
48:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 12:37:13.94
俺は
設計・・・オブジェクト指向
実装・・・関数型言語
って感じるな。
49:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 12:47:10.04
UMLがアップを始めました
50:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 13:16:53.33
単なる型スイッチに夢おいもとめんなって。
OOだって実装の道具にすぎん。ハンマーやカンナの類だ。
51:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 13:29:13.33
実装の道具は、OOPLだよ。
OOにはOOA（分析）やOOD（設計）があって
開発プロセス全体をカバーするものなんだ。
OOPLはOOによる開発プロセスを素直に実装するための言語
分析や設計がなぜOOなのかというと、それが一番
システム開発に適しているから。
そしてその分析、設計に一番適している実装がOOPL
関数型による分析や設計が出てこないことには
関数型は実装のみにしか適用されずに終わるよ。
52:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 13:33:38.15
OOPLが先にあって、それを生かす形でOOAやOODが生まれたわけで。
夢見ちゃったって感じだね。
53:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 13:36:27.78
>分析や設計がなぜOOなのかというと、それが一番
>システム開発に適しているから。
正しくはこうだね。
分析や設計がなぜOOなのかというと、使う言語がOOPLだから。
54:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 13:40:00.97
結局無記名で議論すると個人の感想の叫びあいなんだよね
55:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 13:51:51.24
関数型における分析と設計が出ない時点で
実装のみの技術ってことだろうね。
56:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 13:53:30.17
>>47
何を？
57:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 14:02:15.98
関数と述語による形式的仕様記述やZ言語は？
58:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 14:49:46.34
OOP より FPのほうが響きがいい よってFPの勝ち。
59:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 15:50:29.78
>>56
流れ的に>>41
60:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 16:36:57.37
>>59
今Haskell版読みながらRuby版書いてみてるんだけど、やっぱ適当に書かれてる印象はないなあ
発想自体がよく練らないと出てこないというか
「自分が手作業でやるならこう」を素直にコード化する手続き脳ではいきなりは出てこないコードだと思う
61:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 16:49:51.49
ああ、適当っつーか原文に倣えば「行き当たりばったり」か
どちらにしても行き当たりばったりにも見えないんだよ、それがサクッと出て来る時点でもう設計できてんじゃん、みたいな
62:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 17:02:45.73
>>55
そうは言っても関数型言語での記述は、仕様をそのまま記述してるだけだしな・・・
クイックソートの記述が有名だけど、マージソートはもっと仕様そのまま書いてるだけなのがハッキリする
-- ソート済みのリストの小さい方をリストに追加して、他方を元のリストに戻して、リストのどちらかが空になるまで比較とリストへの追加、他方のさし戻しを繰り返す
merge xs [] = xs
merge [] ys = ys
merge (x:xs) (y:ys) | x < y = x:merge xs (y:ys)
merge (x:xs) (y:ys) = y:merge (x:xs) ys
-- １要素または空になるまで半分に分割を繰り返してからmergeによる結合（１要素のリスト、または空リストはソート済みのリスト）
mergesort [] = []
mergesort [z] = [z]
mergesort zs = merge (mergesort xs) (mergesort ys)
where
(xs,ys) = splitAt (length zs `div` 2) zs
分析については、プログラミングHaskellの最後の方に書いてるプログラムの論証を読むと参考になると思う
>>41も、設計もへったくれも無く、こうしたいなと言う脳内仕様をそのまま書いたし、checkPermuを外に追い出して差し替えられるようにしたいな。とか、長さの異なるリストも扱えるようにしたいな。という気まぐれでどんどん変更してた
（そもそも設計が必要な規模じゃないが)
63:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 17:07:38.47
ちなみに数分で、行き当たりばったりで書いてみたRubyのコードはこんな感じ
手作業でやる場合の手順をそのままコードに書いた、非常に手続き的な思考回路だと思う
class Array
def my_permu
return [] if empty?
return [ns] if size == 1
result = []
each do |n|
without_n = reject{|x| x == n }
without_n.my_permu.each do |ary|
result.push( [n] + ary )
end
end
return result
end
end
p (1..3).to_a.my_permu
64:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 17:08:07.37
>>60-61
ruby挫折したりプログラマとしても挫折した(半年で才能無いと悟って辞職)私が褒められてる・・・
設計経験Zeroですよ＾＾；
65:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 17:08:33.41
ごめんテストしてからレスすべきだった…
66:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 17:12:31.25
>>64
手続き的なやり方が合わなかったんじゃね？
俺は逆に、そういう式的というか関数的というか…そういう発想が出てこない
まず最初に「それをやるなら、あれをやって、これをやってから…こうかな」と考えて、それをコード化してしまう
その例で言えば俺の脳内ではまず「数字の書かれたカードを並べていき、並べたらメモる」という作業が行われる
いきなりリストを組み合わせ分増やし、フィルタを掛けるなんて発想が出てこない
67:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 17:14:26.36
>>63 を修正
class Array
def my_permu
return [] if empty?
return [self] if size == 1
result = []
each do |n|
without_n = reject{|x| x == n }
without_n.my_permu.each do |ary|
result.push( [n] + ary )
end
end
return result
end
end
p (1..3).to_a.my_permu
68:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 17:55:38.95
褒められてｲｲﾅｧ…
ｵﾚのｺｰﾄﾞは誰も褒めてくれなかった。それどころかｵｾﾛの難解ｺｰﾄと同列扱いされる始末…orz
69:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 17:59:46.60
でもまあ、この程度の規模ではオブジェクト指向が
出てこないのはやっぱりって感じ
オブジェクト指向・・・設計部分の実装
関数型 or 手続き型 ・・・ 一処理の実装
といわれるのはこういうとことか
70:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 18:18:58.67
>>66
発想の基点は恐らく、リスト内包表記でしょうね
勝手に全ての組み合わせを生成してくれますし、条件で生成される組み合わせを絞り込める
それを柔軟に扱えるようにしない手は無いな。と
じつは、昔、別のスレでリスト内包表記と再帰の合わせ技は見掛けてたんですよ
発想だけ貰って、自分で自作しました
関数脳の作り方は今も昔も、どう言う関数？どう動くべき？です
このメソッドを使ってとか、ここはポインタで・・・とかの発想は無いです
最初にベタな発想があって、流用できる関数があれば、流用する
Q：lengthは何をする関数？
A：リストを受け取って、長さを返す関数
Q：lengthはどう動くべき？
A：先頭から、１ずつ足して行くべき
Q：リストが空っぽになったら？
A：足しても変わらない０を返す
length [] = 0
length (_:xs) = 1 + length xs
流用版
length xs = sum [1 | _ <- xs] -- 上のQ&Aと、要素数と同じ数だけ１が入ったリストを生成して足し合わせるのは等価
多分、手続き脳ですでにプログラミング出来てる人は、最初から抽象的に考える素養はあると思うので、仕様をそのまま書いてる感覚さえ分かれば、一気に関数脳になると思います
71:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 18:35:37.90
昔Smalltalkという言語があったけど普及しなかった。
これは局所的なコードは手続き型のほうが恩恵あることを示している。
C++やJavaが受け入れられたのは局所的でないところでは
OOの援用が有効だということを示している。
関数型と対峙するのは手続き型。
受け入れられるとしたらOOと手続き型の中間地点なんじゃないかな。
72:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 18:46:14.25
>>70
俺の場合、まず >>67 のように書いてから、それを発展させて初めて関数的コードになる感じになる
実は前スレの >>172 を書いたのも俺なんだが、同じようなコードをまず書いて、それを inject に直した
そこから更に発展させると関数型言語のコードとして成り立つようには出来ると思うが(inject→foldlの変換は難しくないし)
本当に関数型な人のアプローチとはやはり違う形になってしまうんじゃないかなと思う
73:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 19:03:33.53
>>70
関数に焦点があたってるけどさ、
それより大きな範囲のオブジェクトはどうするのさ？
74:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 19:06:22.94
>>71
昔は、手続き型とか関数型とかの選択肢より、切実にメモリやCPU速度が足りなくて、Cが選択されて、速度を損なわずOOP出来るC++が選択されてきた（OOPも最初はメモリの無駄が多いと敬遠されてきた)
PCの進化とともにLLが選択される場面が増えて来たのと同様に、関数型言語が選択される場面が増えても不思議ではない
・・・けど、C系列の言語が多く選ばれるんだろうな
do記法も、モナドが何となく分かってくると順番が重要な処理をこれまた仕様通りに書いてるだけって気付くし、手続き型を見事に矛盾無く関数型言語でエミュレートしてる事に気付いて鳥肌立つんだが
順序の無い関数の世界で順序の概念をエミュレートしてるって凄い！って
前スレの「テキストファイル読み込んで、行番号つけて表示せよ」ってのを読みやすく？書いてみた
import System.Environment
numbering xs = unlines $ map (\(x,y) -> show x ++ y) (zip [1..] (lines xs))
main = do
fnames <- getArgs
fstrings <- mapM readFile fnames
let numfstrings = map numbering fstrings
putStr $ unlines numfstrings
75:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 19:17:21.85
速度やメモリの問題はJavaやJavascriptが普及した時点で終わってる。
とくにJavascriptは関数型風にも書けるけどただの趣味の範囲で終わってる。
76:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 19:18:44.83
何を持って趣味なのかわからんけど、
ブラウザで動く言語はJavaScriptで決まりだよ。
77:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 19:22:04.44
副作用なしラムダ計算だけで記述するJavascriptって意味なんだが
78:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 19:24:17.12
順序をリストにしてるだけだと思うんだが
79:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 19:57:11.75
速度やメモリからすれば
関数型言語は無駄が多いからね。
80:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 20:42:28.52
>>71
Objective-CとC#は局所的であることを怖れないが、そういうのは受け入れられにくい
C++とJavaが受け入れられたのは、局所化でないところが実在するのではなく
漠然と、どこかそういうところに行きたいという願望があっただけだろう
81:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 20:43:30.86
何言ってるかさっぱりわからんｗ
82:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 21:27:01.14
>>73
意味が分からない
親が動物クラスで子が犬クラス・猫クラスとかのあれ？
型の性質を引き継ぐと言うのは型クラスとか有るけど・・・
ええと・・・で、そのオブジェクトで何をしたいの？どう拡張したいの？それって、オブジェクトである必要あるの？
犬か猫かに合わせて泣き声変えるんなら
data Animals = Dog | Cat deriving (Eq,Show)
voice a | a == Dog = "wan wan!"
voice a | a == Cat = "nya- nya-!"
これで十分なんだけど・・・そして、どっちもanimals型
犬は猫じゃないし、猫も犬じゃない
taroは犬で、taroという名前で、７歳
taro = (Dog,"taro",7)
miiは猫で、miiと言う名前で、３歳
mii = (Cat,"mii",3)
taroは猫じゃないし、miiは犬じゃない
let animalCategory (x,_,_) (y,_,_) = x == y
animalCategory taro mii
>False
83:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 21:30:52.01
>>80
全部受け入れられている言語だと思うが・・・
言語なんて金になるかどうかで受け入れるかどうかが決まるもんだよ
関数型言語で金になる話が無いだけ
と言うわけで関数型言語でスマフォアプリ作れる環境を（ｒｙ
84:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 21:32:33.29
>>82
犬とか猫を
どうやって関数型言語で表現するの？
85:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 21:35:40.55
>>83
これを本気でいうからなぁ
86:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 21:54:02.37
>>84
犬とか猫を
どうやってオブジェクト指向言語で表現するの？
まさか class Dog のインスタンスが犬なの？www
87:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 21:54:21.43
>>83
言いたい事は分かったが、なんでUMLで分析しないの？
金銭の概念をオブジェクト指向分析すればいいのに、なぜ犬と猫なんだ？
88:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 21:57:00.90
>>86
型と値の区別ついてるかな？
89:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 21:58:20.34
>>88
もちろん
だからクラスではなくインスタンスだって言ってるだろ
90:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 22:08:10.34
>>84
え、表現できてるでしょ？
むしろ、DogもCatもAnimalsに属してるのであって、オブジェクト指向のDogとCatがAnimalの子って言う関係の方が不自然だよ
そして、SnakeやLionが増えても、Animals型である限り、同じ関数が使えるし、せいぜい１つの機能に付き、一つの関数書き換えで済む（泣き声変えるために、いちいちクラスごとにvoiceメソッドを書く必要も無い)
OOPLでもジェネリックやテンプレートで型ごとにメソッド書くでしょ？
でもそれって、OOPLの利点じゃないと言うか、むしろ関数型言語の方が強力
voiceメソッドがAnimalクラスや、その子クラスにあるのは良いけど、animalCategoryメソッドをAnimalクラスが保持するのは不自然。そうなると、関数型では存在しない第３のクラスを作る必要が出てくる（Categoryクラスみたいな?)
関数型言語のデータはデータ。関数は関数。という関係の方が、シンプルに思える
91:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 22:08:18.46
争いは、同じレベルの者同士でしか発生しないのAA
92:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 22:12:10.32
>>90
それって、関数型言語でオブジェクト指向やってるだけですよね？
93:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 22:19:51.16
>>82
一応さ、型クラス使った方が良いと思うので貼っとくね
Animalに動物足すたびに代数データ型を変更するのはアレなんで
class Animal a where
voice :: a -> String
data Dog = Dog deriving (Eq, Show)
instance Animal Dog where
voice _ = "wan wan!"
data Cat = Cat deriving (Eq, Show)
instance Animal Cat where
voice _ = "nya- nya-!"
taro = (Dog, "taro", 7)
mii = (Cat, "mii", 3)
94:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 22:35:52.14
>>87
いや、プロじゃないんでUML触ったこと無い
名前しか知らん
プロの視点で関数型言語とオブジェクト指向言語の生産性の比較とかやって欲しいところ
素人視点（＝感覚的）では、LLとの比較でも、rubyやpythonは記憶力勝負（多くのメソッドを記憶してれば効率的。むしろ、何もメソッド知らない状態だとほぼ何も出来ない)
Haskellは少ない知識で割と素人でも何とかなる（既存の関数知ってる方が効率的なのはLLと変わらないが、何も知らない状態での開発効率に雲泥の差がある)
初学者へのモチベーション維持と言う意味では、関数型言語の方が向いてると思う
そして、最終的な生産効率はLLと変わらないか若干劣る（読みやすさ重視だとほぼ差がなくなる)
昔、length関数をrubyでどう書くの？と言う質問に対して、メソッドとクロージャ駆使して短いコードが返ってきた
素人じゃとても書けないと思った
Haskellなら基本的な再帰関数の作り方覚えるだけで作れるものが、LLだとそれなりの知識を必要とするのだと感じた瞬間だった
95:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 22:43:11.49
>>73
Haskellばかり話題に登るのでMLに触れておくと、
MLにはモジュール（関数とデータの集合）というものがあり、
さらにモジュールを引数に取ってモジュールを返す関数（Functor）がある
これはOOPでいうとクラスからクラスへの関数を定義できるようなもの
カプセル化？差分プログラミング？全部余裕ですよ
96:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 22:48:52.63
別に完全否定してるわけじゃないのにできますよって
余計なこと考えるだけのメリットが聞きたいのに
97:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 22:56:12.60
メソッドをどのクラスに入れるか迷うようなことは無くなるね
例えば文字列のリストのjoinを
",".join(strlist) とするか
strlist.join(",") にするかみたいなね
98:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 23:05:31.47
>>92
・・・・え？
オブジェクト指向設計って事？
意識したこと無いけど、これがそうなのか・・・
まあ、関数型言語は色んな角度の視点を許容する感覚はあるかな
何だろう。破壊的な代入が出来ない分、そのものの性質を見ようとする体質に自然となるような・・・
Haskell でリストの要素を swap する 9 つの方法
URLﾘﾝｸ(jutememo.blogspot.jp)
>>70のlengthも視点の角度が違うだけで等価なものだしプログラミングHaskellの付録Aに書いてるlengthの定義もまた違う視点
length = foldl (\n _ -> n + 1) 0 -- 初期値0とリストの先頭要素を受け取るが、初期値に＋１を繰り返すだけ、リストが空になったら蓄積変数(初期値0のもので、リストが空になるまでひたすら＋１されてた変数）を返す
仕様の表現の仕方に色んな表現があるけど、OOPLや手続き型は表現自体を制限されてる感じ
だから、そのまま仕様をコードに落とせないと感じるのかも・・・
99:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 23:08:49.08
OOも知らないで語ってたのかｗ
100:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 23:11:21.47
ライムゲームを関数型で設計したら間違いなく不便
101:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 23:16:53.03
すっぱそうだな
102:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 23:23:09.41
>>99
でも、ぶっちゃけOOの定義定まってないだろ、このスレで
下手すりゃデータと関数を一纏めにしたらOO、くらいの勢いだぞ
103:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 23:32:16.09
>>95
HaskellでもFancterやArrow使うと表現が広がるってのは良く見かけます
自分もMonadoやFancter・Arrowを自作できると楽しみが広がりそうで楽しみに学習続けてます
（でも現時点でさえ、Rubyでどう書くの？って処理もHaskellで書けてるのですでに関数型言語マンセーですが）
短く書けても、そもそも知識がないんじゃ書けないなら意味がない（と言うのは言い過ぎだが、学習コストが高い）
と言うのが私の持論です
104:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 23:42:25.23
>>100
んなこたー無い
そもそも、ライフゲームはプログラミングHaskellで載ってる
入門書でライフゲーム書かせるOOPLの入門書って何があるよ
ちゃんと読めばdo表記やIOモナドの洗練されてる事が分かる
105:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 23:42:42.99
最小公倍数は間違いなくあるだろ。
OOはオブジェクトを起点としたプログラミング(設計)
関数型ならλ計算を起点としたプログラミング
OO側は最小公倍数を前提してるものが多いのに対し
関数型は言語サポートでそれもできるというレスが多い(Haskeller以外のことね)
俺は関数型のメリットは副作用の排除の明示にあると思ってるから
OOベースの言語に相当の機能追加すればいいんじゃないのっていうスタンス
状態をベースにしないということはモナドで状態を表現して状態を引数
実際D言語はpureキーワードあるけどね
細部の状態を追い出すのは本末転倒(メリットが少ない)だと思うし
GUIやOSを見れば分かるように大枠から状態ベースをやめるのは直感的じゃないと思う。
状態を排除する方向じゃなくコーディングレベルで状態を追い出せる記述力を持たせる。
106:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 23:44:50.01
>>104
もちろん読んでるから知ってるし自分で書いたよ
あれ書いててあれば作りやすいというならば完全に平行線だし
おれの感想は「うそつき」だね
ちなみにライフゲームはOOで書く必要ない。
「状態」をオブジェクト分割する必要性がほぼ無いから
107:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/08 23:51:09.92
ちなみに>>104が言ってるのはこれね
URLﾘﾝｸ(www.cs.nott.ac.uk)
108:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:02:29.16
しかも「無理があると思える対話型プログラムを自然に書く」
というお題の章に乗ってるんだけどな。
つまり書けますよといっているだけでよりメリットがあるとは言っていない。
109:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:06:55.06
「無理がある」がかかってるのは「対話的プログラミング」の
部分であってライフゲームじゃない
そしてHaskellでもIO使えば無理じゃないことを学ぼう、という
内容になってるのはちゃんと読んだなら知ってるな
110:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:08:26.13
いやだからメリットが無いでしょって言ってるんだがなぜそこに触れないｗ
間違いなく手続きでシンプルにかけるんだが
111:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:11:56.68
>>105
それを言うなら、手続き型ベースに、OOと関数型が乗っかる、だ。
だって、関数型OO言語は嫌なんだろ？
112:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:13:17.49
ちなみに関数型でメリットがまったく無いとは思ってない。
状態を引数に追い出すことにより副作用がなくなるというのは
分かりやすくなる場面が必ずある。
ただ今のところD言語のpureキーワード以上のメリットはあまり感じられない。
113:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:17:31.33
>>105
オブジェクトを起点としたプログラミングって何？
ていうか、オブジェクトって何？
関数型言語では関数は第一級オブジェクトなんですが、その場合
関数を起点にしたらその時点でオブジェクト指向なんですかね？
それとも「第一級オブジェクト」でいうところのオブジェクトとは違う
別のオブジェクトの定義があるんですかね？
114:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:17:48.26
>>111
うーん別にそれでもいいが、
歴史的にはC言語のグローバル連発からC++のオブジェクト分割って流れだし
設計の面でもフローチャートよりオブジェクト指向分析のほうが大枠だし。
粒度で見ればオブジェクト指向＞手続き/関数型が自然な解釈だと思うよ。
115:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:28:37.22
>>113
そこの見分け方は「メモリ」です。
＞関数を起点にしたらその時点でオブジェクト指向なんですかね？
オブジェクト指向として捉えれば正しいとみることもできるけど
(関数オブジェクトや関数ポインタをオブジェクトとして解釈する)
それは関数型の視点ではない。
関数型特有の視点は一級オブジェクトを「引数」にできるという視点であって
ここでの関数を起点というのはそういう意味。
これが納得いかないのならOOPLにも関数型言語にも両方のフレーバーはあるねというだけ。
別にオブジェクト指向のメリットを取り入れている関数型言語を全否定しないし
関数型の考え方を利用しているOOPも否定しない。
116:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:32:33.68
>>113
あーはいはい。俺が変わりに答えるよ。
オブジェクトは日本語で「対象」とか「目的語」とかに訳されるね。
そんで何に対しての「対象/目的」かというと、それは述語、つまり、関数。
だから、
func1( a, b ); の func1 はオブジェクトとして扱われてない。
func2( func1 ); のfunc1 はオブジェクトはオブジェクトとして扱われてる。
つーわけで、引数に取れる=第一級オブジェクトってわけ。
>関数型言語では関数は第一級オブジェクトなんですが
引数に取れる訳だから、第一級オブジェクトで間違いないが、「指向」はしてない。
引数によって関数の呼び出し先がスイッチして始めてOO。
な、OOってつまらねーだろ。
117:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:38:32.38
>>116
それでは f x を x の型で（型クラスで）スイッチしたらOOなんですね
ただ型を集合で括っただけでオブジェクトを指向した記憶は無いんですが
確かにつまらないというか、ただの多態ですね
118:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:40:07.49
今北。前スレの行番号＋カンマ化のやつ、SmalltalkのリクエストがあったのでSqueakで。
| fs |
fs := {
[| n | n := 0. [:str | (n := n +1) asString, ' ', str]] value.
[:str | str, ',']
}.
FileStream fileNamed: 'text.txt' do: [:file |
[file atEnd] whileFalse: [
Transcript show: (fs inject: file nextLine into: [:line :f | f value: line])]]
119:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:41:46.80
OO＝多態のレッテル貼りで話題ずらし
120:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:43:14.06
>>117
そそ。
関数型言語でも、型システムがあったりして、
引数の型によって呼び出し先がスイッチするんなら、OOってことになるな。
だから、関数型言語のOOってのも普通にあるわな。(知ってるだろうけど)
121:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:47:13.80
>>119
違うのですか？
違うなら説明してもらわないと分かりませんよ
122:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:48:34.65
>>121
すでにループだと思うんだけど>>105
123:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:50:51.79
あ、それと f x y z で x と y と z の型でスイッチするときに
OOPで良くある x.f y z という表記は分かり難くないですか？
なんで x だけ f の前に来てるんですか？
124:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:54:44.64
>>122
だからオブジェクトを起点にしてるとだけ言われても分かりませんよ
なんとなくの気分の問題なんですか？
125:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 00:56:04.83
>>124
正直それで分からないときついと思うんだけど。
オブジェクト指向分析とかイメージできる？
126:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:01:54.50
オブジェクトを起点にしたか否かなんて
設計者の心の中にしか無いのではないですか？
設計/分析されたものだけを見てオブジェクト指向か否か判定できるのですか？
127:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:03:10.45
いや、>>92を見ると判定はできるようですね
その基準を教えてください
128:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:06:40.85
>>126
それは正しいとも言えるし正しく無いとも言える。
設計者本人がどう設計したかを１００％証明することはできないという意味では正しいが
OOPLで書かれたコードをみてどう設計したかったを推測することは可能。
正直君のレスは哲学レベルの話でソフトウェア工学の話じゃない。
129:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:09:01.03
>>128
ソフトウェア工学の話じゃないのは>>115の説明ですよ
>>116の話は分かりますよ？ソフトウェアの機能について言及してますからね
130:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:10:37.96
>>129
じゃあどこが理解できないか説明してもらえるかな
あまりに共通言語なさそうだから説明は無理かもしれないけど。
131:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:11:06.70
>正直君のレスは哲学レベルの話でソフトウェア工学の話じゃない。
お前のことだろw 自分で >>105 読み直してみろよw
132:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:11:39.42
>>131
どこがか指摘してね
133:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:18:56.56
>>130
「起点にする」を正しく定義してください
それはソフトウェアの機能として定義できますか？
プログラマの心理状態として定義するのですか？
それとも哲学的な何かとして定義するのですか？
134:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:20:45.64
>>133
えーと正直あほらしいです。
Wikipediaで気分に近い文章を引用してみます。
＞ソフトウェア工学において、ソフトウェア (システム) を相互作用するオブジェクトの集まりとしてモデル化 (オブジェクト指向モデリング) する、オブジェクト指向に基づくソフトウェア開発の方法である。
URLﾘﾝｸ(ja.wikipedia.org)
135:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:24:59.21
>>134
その定義は大分>>105や>>115と違いませんか？
それはともかく、それでは関数がオブジェクトの関数型言語では
関数が相互作用してるのでオブジェクト指向ですね
136:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:29:44.35
こう言っては何ですが、議論に負けないために
より一般的な、より抽象度の高い何かとして
オブジェクト指向を定義しようとするあまり
ナンセンスの域に到達してると思いますよ
137:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:32:10.63
主語も述語も不明なレス
138:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:33:20.29
>>137
自己言及文ですか？
139:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 01:57:40.04
結局のところオブジェクト指向で
システム開発は行われるんだよ。
たとえ関数型言語を使ったとしてもね。
だって考えるでしょ？
関数型言語で多態を実装するにはどうしようか？とか。
140:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 02:02:55.92
ルールを厳密に適用すれば何でもOOになってしまうので、
結局OOか否かは本人の胸先三寸で決まる
伊達にオブジェクト"指向"を名乗ってないな
他にないもんな"指向"なんて付いてるの
141:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 02:05:04.00
アスペクト指向さんがアップを始めました
142:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 02:17:29.46
>>139
オブジェクト指向言語で使うのは inclusion polymorphism
関数型言語でよく使うのは parametric polymorphism で、
あと Haskell なら ad-hoc polymorphism も使う(type class)
さて、parametric polymorphism や ad-hoc polymorphism を使ったところで
オブジェクト指向と言えるのかい？
143:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 02:30:41.89
JavaのGenericsやC++のtemplateやオーバーロードがOOの機能ではないって言うんならそうなんじゃね？
144:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 02:49:26.49
OOPにある機能は皆OOの機能なら
クロージャも関数も変数も条件分岐もループも再帰も
全部OOの機能だね、すげぇ
145:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 03:27:47.51
>OOPにある機能は皆OOの機能なら
そうは言ってないだろ。
GenericsやtemplateやオーバーロードをOOの機能と認めないなら、
parametric polymorphism や ad-hoc polymorphism を使ったところで
オブジェクト指向といえないし、
逆に、GenericsやtemplateやオーバーロードをOOの機能と認めるのなら、
parametric polymorphism や ad-hoc polymorphism を使ったら
オブジェクト指向といえる。
146:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 06:17:57.25
>>139
考えねぇよ
リストとかが多態なだけで、自分はあくまでリスト型を受け取って何かを返す関数作ってるだけ
147:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 08:13:50.81
>>145
JavaやC++よりもMLにparametric polymporhismが入った年のほうが早くね？
それなのにオブジェクト指向が起源になっちゃうの？
148:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 08:22:12.21
リストに対する（多相な）map
map f [] = []
map f (x:xs) = f x : map f xs
を定義しただけでOOとは、OOの範囲はすごいなぁw
149:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 08:40:02.66
lispのプログラムの特徴を「全てリスト」とするなら、OOは「全てOO」なんだよ
150:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 14:11:18.89
誰も起源なんて書いてないんじゃね？
151:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 17:38:02.23
parametric polymorphism と ad-hoc polymorphism がOOの機能なら
モナドは両方使って定義されてるからOOの機能だな
152:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 18:07:22.23
>>149
「全てobject oriented」って何だよ意味分からん
「全てオブジェクト」って言いたいのか？
だとしても、Javaのようにブロックすらオブジェクトでない言語も
OOPを名乗ってるから事実と異なる
153:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 18:25:42.02
parametric polymorphism と ad-hoc polymorphismがOOの機能なら
モナドは両方使って定義されてるから、モナドにはOOが使われている、が正解。
154:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 18:28:02.27
圏論にはOOが使われている（キリッ
155:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 18:31:10.09
>>154
あちらさんの言葉で言うところで、だよ。
156:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 19:09:26.44
JavaはGenericsが入る前からオブジェクト指向言語を名乗ってた
=> parametric polymorhism は OOPL の必要条件じゃない
オーバーロードが無いRubyがオブジェクト指向言語を名乗ってる
=> ad-hoc polymorhism は OOPL の必要条件じゃない
157:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 20:40:19.99
手続き"型"言語、関数"型"言語
そして、オブジェクト”指向”言語
名前からして比較するべきものじゃないんだよ。
オブジェクト指向は、指向って書いてあるとおり考え方。
手続き型言語を使ってオブジェクト指向が出来るように
関数型言語を使ってもオブジェクト指向が出来る。
ではオブジェクト指向言語とは何か？
答えは、オブジェクト指向を素直に表現するのに
便利な構文を持っている言語
だから必須条件なんてものは存在しない。
オブジェクト指向を代表する機能が一つでもあれば
それはオブジェクト指向言語
158:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 20:49:59.98
まあ極端な話すれば、C言語はオブジェクト指向じゃないけど、C89でもOOP自体はできるわけだし
159:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 20:55:14.86
今どきOOを手放しで絶賛する椰子は、今までｺﾝﾋﾟｭｰﾀｰｻｲｴﾝｽが発展してきた流れとか知らないんだろうな
Simula,Smalltalkから1985年ころのflavorまでの流れ、その後C++1.0がcfrontとして登場しｵﾌﾞｼﾞｪｸﾄ指向が一旦退化、
C++はその後複雑化の一途を辿っていること。
また、当初アプレットのためにC++を単純化したようなJavaが登場ししばらくはぱっとしなかったこと。
その後2000年ころのITバブルを機会にtomcat,WSDL,UDDIと合わせてWEBサービスで使われるようになり、
Java自体がが中庸のプログラマ向け言語としてソフトウエア開発分野の裾野へ普及していったこと、
素人向けの誤ったのOO本が入門者に誤解を与えいま変なOO感が普及し弊害が目に付くようになったこと、
それとは別の流れとして、haskellのparottなどでの成功を契機に関数型の利点の認識が広まってきたこと…
時代の節目かな。
160:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 20:57:58.20
>>159
OO感→OO観
161:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 20:57:59.82
基本的な流れとして手続き型も、関数型も
オブジェクト指向を取り入れる方向で進化してるよね。
162:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 20:59:11.07
>>159
parottはなかろう…
163:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 21:00:32.51
オブジェクト指向言語は
関数型言語の利点を取り入れ、
関数型言語はそれだけではアプリを作りにくと
現実的な選択肢としてオブジェクト指向を取り入れる。
164:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 21:01:15.18
>>159
最近楽しいなと思うのは10年くらい前に産声を上げたオデスキーのScalaがここ近年
実用に使われるようになってきたこととか、Clojureというもう一つの選択肢がでてきたこととかetc
165:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 21:02:41.73
>>162
あ、いや成功したのはparottでは(まだ)なく、parottの実装でhaskellが注目されたこと
166:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 21:03:54.88
絶賛というか、今のOOPは単なる常識でしかない
関数型もまた、珍しい技術から単なる常識になりつつある
ただそれだけのことだろ
167:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 21:05:12.46
メソッドをメッセージと捉えるのは、その多くの場合の使われ型から無理を感じる
168:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 21:06:16.77
なれればどうってこと無い
169:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 22:21:19.77
OOも関数型も単なる一機能なんだから、
それをもって～言語って言い張るのは無理があるんだよ。
170:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 22:52:21.84
>>169
でも、マルチスレッドや分散処理の論文は関数型や論理型の推奨する永続データモデルばかりだよ？
シングルスレッドならともかく、マルチスレッド意識したら純粋関数型や論理型じゃないと厳しい時代になってくると思うんだけど
171:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 22:53:59.95
>>170
今は普通にマルチスレッドの機能は
オブジェクト指向言語に搭載されてる。
172:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 23:20:47.45
ストラウストラップのＯＯのキモは「抽象データ型にクラスを使うアイデア」。
ref. URLﾘﾝｸ(www2.research.att.com)
ケイのＯＯのキモは「処理系のみならず、その受け皿であるナンチャッテＯＳ、工程まで
ひっくるめたあらゆることで徹底した動的性」。
ref. URLﾘﾝｸ(metatoys.org)
関数型のキモは「非破壊操作とそれがもたらす参照透明性」。
型推論とかメッセージとかパターンマッチとかはオマケです。偉い人には(ry
173:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 23:31:04.63
>>170
分散したいならデータも共有しないのが基本なので
永続データの共有を推奨するのはおかしいと思う
174:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 23:41:08.58
>>170
あんま最近は追いかけてないから知らないけど、
汎用手続き型+トランザクショナルメモリの研究はもう止めちゃったのかね。
デッドロックのみならず、例外処理もしやすくなるから期待していたんだけど。
トランザクションで思い出したけど、SQLは宣言的言語と言われてたはずだったんだけど、
今どきはストアドプロシージャとかも使うらしいね。
175:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/09 23:44:18.47
結局欲しいのは副作用の管理
176:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/10 06:49:32.37
>>161>>163
オブジェクト指向の何を取り入れたの？
Haskellのどの機能がオブジェクト指向由来なのか教えてくれ
177:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/10 06:55:00.27
OOで見るべきところがあるのはメッセージング（徹底的な動的性）とtraitsのみ
他はゴミ
178:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/10 07:27:14.51
OCaml のことを言ってるんじゃないのか？
あとジェネリックプログラミングとかは、中途半端に型があるオブジェクト指向系の
言語でやるより、がっちり型のある関数型言語でやったほうがいいし、ST モナド
使えば、本物の「状態のカプセル化」ができる。
関数型ではオブジェクト指向なんてできない、というのは初心者が陥りがちなデマ。
179:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/10 07:47:00.64
そういや、関数型でOOPLでいう継承ってどんな形になるの？
180:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/10 08:04:22.67
>>179
継承っぽいやつ>>93
プロトタイプOOっぽいやつ>>25
OCamlは普通にクラスも継承もあるので省略
181:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/10 08:24:34.70
>>179
OCamlで高階ファンクター
F はモジュール X,Y を引数にして新しいモジュールを返す
module type S = sig end
module type T = sig end
module F (X : S) (Y : T) =
struct
include X
include Y
end
182:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/10 09:21:46.15
やろうと思えばCでもできること
自然に書けるかなんだけどな
183:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/10 12:05:42.06
不自然なものを自然にしたいという需要は確かにあるね
科学的に有害か無害かは関係なく、自然か不自然かだけで商売になる
184:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/10 12:30:26.91
ただし自然かどうかはOO信者のさじ加減ひとつで決まります
185:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/10 13:06:13.85
セマンティクスとしては x の評価を 2 度する、というのは変わらんじゃないのかな。
その評価が状態に対して idempotent かどうかという違いであって。
186:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/10 13:08:03.10
（誤爆w）
187:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/10 23:37:56.20
>>183
自分はHaskellのリバース関数が自然だと感じて入門当時は感動したな
reverse [] = []
reverse (x:xs) = reverse xs ++ [x]
もちろん、組込み関数のreverseは速度重視の直感的ではないコードなんだが・・・
188:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/11 01:26:37.69
>>187
演算子とコンストラクタの違いが直感的に分からない
英単語だったら先頭が大文字かどうかで分かるんだが
189:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/11 03:24:43.28
>>188
コ、コンストラクタ!?
Haskellを例に出した私にレスされましても・・・
クラスの生成時に呼び出すメソッドと演算子に直感的な違いも何も無いと思いますが・・・
Cons演算子のことでしたら、リストという構造に対する演算子だと理解しておけば良いと思います
[1,2,3] = 1:[2.3] = 1:2:[3] = 1:2:3:[]
関数の引数にリストの全部の要素を書きたければ（要素数固定になりますが）書けますよ
sum3 (x:y:z:[]) = x+y+z
(x:xs)の部分の理解はghci上で
let (x:xs) = [1..5]
とかしてｘとｘｓの値を調べると良いです
リストを引数に取る時の表記は、Haskellの中では特別な表記法と言う訳ではないです
＋演算子もこう言う書き方は出来ま・・・廃止になったけど、ちょっと前までは出来たんです
dec (n + 1) = n
190:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/11 03:47:40.43
>>189
彼には言っても無駄な稀ｶﾞｽ…
191:営利利用に関するLR審議中＠詳細は自治スレへ
12/04/11 13:49:19.06
>クラスの生成時に呼び出すメソッドと演算子に直感的な違いも何も無いと思いますが・・・
右辺で使う演算子を左辺に書いてみれば違いが分かるよ
reverse (xs++[x]) = x : reverse xs
実際には xs++[x] というパターンマッチはできない
192:デフォルトの名無しさん
12/04/11 21:29:08.42
ユーザ定義のデータコンストラクタは頭大文字で始まるから
そんな混乱せんだろ
むしろコンストラクタを関数としても使えるのは便利だ
まあリストやタプルのコンストラクタは記号だが、それくらい覚えとけ
193:デフォルトの名無しさん
12/04/11 23:24:51.38
関数型言語ってようするに、
関数がクラスになる。
言ってみればJavaScriptからprototypeがなくなったようなもの。
prototypeがなくなっても効率が悪くなるだけで
オブジェクト指向できるでしょ？
それが関数型言語。
194:デフォルトの名無しさん
12/04/12 00:08:31.03
オブジェクト指向言語ってようするに、
オブジェクトがクロージャになる。
言ってみれば関数型言語から代数データ型やパターンマッチやカリー化が無くなったようなもの。
代数データ型やパターンマッチやカリー化が無いと効率悪いけど
関数型スタイルでプログラミングできるでしょ？
それがオブジェクト指向言語。
195:デフォルトの名無しさん
12/04/12 00:14:31.10
> 代数データ型やパターンマッチやカリー化が無いと効率悪いけど
それはないな。
196:デフォルトの名無しさん
12/04/12 00:22:10.76
>>194
それはチョット違うだろ。
ｸﾛｰｼﾞｬｰはlexical scope内にある変数をバインドして保持している関数オブジェクトで、あくまで関数オブジェクト。
ｵﾌﾞｼﾞｪｸﾄ指向のオブジェクトは、主に構造を持ったﾃﾞｰﾀｵﾌﾞｼﾞｪｸﾄ(単純スカラーでも可)またはｸﾗｽscopeにメソッドやインスタンス変数を
従属させモジュラレティーを確保する事に加え、インヘリタンス/mixin/treitなどで共有または階層関係を持たせ、データドリブンなインターフェースを提供する。
似たところもあるけれど、分けて考えるべきかと。
197:デフォルトの名無しさん
12/04/12 00:29:40.32
>>196
いや、マジレスされると困るわw
つーか、そこ突っ込むなら>>193の方が違いすぎるだろ
> 関数がクラスになる
198:デフォルトの名無しさん
12/04/12 00:39:23.32
>>197
じゃあ、関数の戻り値がオブジェクト（インスタンス）になる。でいいか？
オブジェクトを作り出すもの ＝ クラス
戻り値を作り出すもの ＝ 関数
言ってることは同じだけどなｗ
199:デフォルトの名無しさん
12/04/12 00:48:53.41
>>198
カリー化されてんだから関数の戻り値も関数だろ
クラスとインスタンスのような関係はねーよ
それともあれか？関数もオブジェクトだから
関数型言語はオブジェクト指向ってやつか？くだらねえ
200:デフォルトの名無しさん
12/04/12 00:56:44.16
気持ち悪いアナロジーで無理矢理OOに対応付けて
理解しようとしなくても
ドカタの人生で関数型言語を使う機会なんて来ないから
安心しろよ
お前にとって運悪く関数型言語が普及してしまったとしても
その頃にはお前の仕事は無くなってるよ
201:デフォルトの名無しさん
12/04/12 00:57:45.87
>>197
>>193も突っ込もうと思ってたｗ
JSがらprototype削ったらinfix notationなlispみたいなのになっちゃうから。
202:デフォルトの名無しさん
12/04/12 01:01:03.49
ドカタ以下のトイプログラマー
203:デフォルトの名無しさん
12/04/12 01:05:35.12
ｵﾚ>>169>>201だけれど、
関数をOOのｵﾌﾞｼﾞｪｸﾄとみなすところにはそれ程違和感無かった。
言語によっては、関数ｵﾌﾞｼﾞｪｸﾄにもメタ情報設定してOOのオブジェクトみたいにmethodを従属させたり、他のmethodをmixinさせることもできるものがあるから。
ただしhaskellではないが。
204:デフォルトの名無しさん
12/04/12 01:12:21.32
関数型が自己満足以上のメリットがあると感じたこと無い
205:デフォルトの名無しさん
12/04/12 01:15:35.37
>>203
うそつけ。>>169はオレの書き込みだ。
206:デフォルトの名無しさん
12/04/12 01:17:46.33
>>203
あ、でもやっぱ違うか、勘違い。
クラスは静的な物(ともかぎらないclassすらもオブジェクトという概念の言語もあるけれどちょっとおいて置いて)
オブジェクトの生成はコンストラクタってのが昨今普及している概念だから。
207:デフォルトの名無しさん
12/04/12 01:18:40.06
>>205
こめ、あんか間違えた。えーとどれがｵﾚのﾚｽだったっけｗ
208:デフォルトの名無しさん
12/04/12 01:19:35.18
ぶっちゃけいうと
関数型は今仕事がない。
将来はあると信じてる。
オブジェクト指向は今仕事がある
将来はなくなって欲しいと、関数型厨は思ってる。
>>200とかそうだなｗ
209:デフォルトの名無しさん
12/04/12 01:49:53.91
スパコン向けのプログラム書いてる人とかなら関数型を使う機会があるかもだが、
求められるのはプログラミング技術じゃなくて、対象問題の専門知識だわな。
あとは、大学教授が自分の論文に必要な計算をキャンパスのコンピュータを使って並列計算しました的な。
関数型は並列化が容易だから、実行速度が求められる分野に適していそうだが、
手続き型で並列化したほうがもっと速くなるから、結局なんだかなーな。
クラスタを電卓代わりに使う人用かと。
210:デフォルトの名無しさん
12/04/12 02:03:13.63
>>209
本気で並列化に取り組むとその考えかたは変わるよ。
関数型の並列化はタスク？データ？どっちのparallelだと思う。
スパコンは徹底的に性能重視だし。
まいいや2chでﾏｼﾞﾚｽｶｺﾜﾙｲｵﾚｗ
211:デフォルトの名無しさん
12/04/12 02:20:44.68
>>210
関数型で出来ることが手続き型で出来ないってことはないんで。
FPGAとかは別としても、主流のノイマン型は手続き型がネイティブなんで。
212:デフォルトの名無しさん
12/04/12 02:45:31.08
>>211
できるできないまで話を広げればパラダイムなぞ何でもいいんだよ。
性能を徹底的に追及するにはCPUの命令レベル並列化SIMD並列化core間ﾒﾓﾘ共有離散並列化ネットワーク分散並列化
徹底的に実効効率(≒GFLOPS)と性能を追求する。
一方の関数型で一部取りざたされる並列化は、並列化のしやすさ＝参照透過による並列依存解析の簡便さなどで
まだ止まっている段階であり性能の追求に関してはマッタク解になっていないンｼﾞｬﾏｲｶ？
だからﾃﾞｰﾀパラレルorタスクパラレルか上で訊いてみた。その答えでどのくらい深く考えている椰子かわかるから。
簡便さは無視できず大切なことかもしれないが、それで数値解析がいままでより早くなっていないのであればつかわれなくてもしょうがない。。
安易に並列化に研究成果を求めて逃げるのは愚。
で、FPGAって何の話だ？と小一時間ｗ
もしかしてハード・ソフト両面でずぶの素人さんをｵﾚは相手にしてしまった？
上のｸﾛｰｼﾞｬｰもしかりだけれど2chでﾏｼﾞﾚｽあまりしたくない。
213:デフォルトの名無しさん
12/04/12 03:06:38.71
あーわかったわかった。
関数型が並列化に向いてるって書き込みに噛み付いてたのか。そりゃ食い違うわ。
でも、参照透過性って並列化以外に上手い生かし方が無いと思うんだが。
遅延評価も言語レベルでサポートが欲しいかと言われると、別にねぇ。
214:デフォルトの名無しさん
12/04/12 03:13:37.82
>>213
参照透過性はプログラムコードの理解しやすさ、バグの入りにくさなどに少なからず貢献あるんじゃマイカ
215:デフォルトの名無しさん
12/04/12 03:20:08.01
でも、副作用のないプログラムが読みやすいのは、手続き型でも同じことだしなぁ。
言語レベルでサポートしていることの意味は、自動化、
つまりは自動遅延評価や自動並列化になるとおもうんよ。
216:デフォルトの名無しさん
12/04/12 03:27:10.53
>>215
副作用を禁止しちゃっても十分ソフトウェアは記述できるという数学的な原理に基づき
そのための仕組みを言語レベルの機能でちゃんとサポートし副作用を低減しようとする意義はあるのでは？
217:デフォルトの名無しさん
12/04/12 03:42:11.67
そんな蓮舫さんみたいなこと言われても。
218:デフォルトの名無しさん
12/04/12 06:22:33.36
副作用のある部分をコードの一部に隔離したとき、
それが他に漏れてないことを静的型検査できるのがメリット
静的型検査なんて要らないし、副作用の有無なんて
コメントにでも書いとけば分かるだろ
というプログラマにはメリット無い（批判する意図はないので注意）
219:デフォルトの名無しさん
12/04/12 06:34:07.76
ただし、>>218は特定の言語（HaskellとかD）のメリットであって
関数型言語のメリットでは無い
220:デフォルトの名無しさん
12/04/12 06:44:16.58
普及してるかどうかで使う言語を決めてる人って
TIOBEとか見て一喜一憂してるの？
URLﾘﾝｸ(www.tiobe.com)
JavaプログラマならJavaの人気が長期的に下がり続けてる
（ついに今月は2位に陥落）の見てショック受けてるの？
幾らでも他と交換可能な木っ端プログラマは大変だね
221:デフォルトの名無しさん
12/04/12 09:49:24.36
中身無いなぁ。
普及率は人気の度合い。なぜ人気があるのか考える必要がある。
誰かさんの思い込みより価値ある。
222:デフォルトの名無しさん
12/04/12 09:50:24.09
>>216
仮にIOを禁止しても、IOと殆ど同じモナドを簡単に作れる
だから禁止していいんだという解釈もあるが、禁止しても無意味だという解釈もある
Haskellが、いずれかの解釈を一方的にサポートすることはない
あくまで中立
223:デフォルトの名無しさん
12/04/12 09:55:43.85
モナドって副作用の定義を限定的にして副作用なくしたと主張してるだけで
ソフトウェア工学上で問題になる事項をすべて解消しているわけではいないと思うんだけど
どう思う？
224:デフォルトの名無しさん
12/04/12 11:16:27.37
問題を定義した本人には、自己解決しましたと主張する権利があると思う
225:デフォルトの名無しさん
12/04/12 16:43:59.37
>>221
全くもってその通り！！
中国語だって世界中で大人気だからな！！
226:デフォルトの名無しさん
12/04/12 16:51:24.45
>>223
現実のコンピュータが副作用必須の設計で、モナドは副作用解決に使えるというだけ。
モナドが副作用解決のために作られた訳じゃない。
227:デフォルトの名無しさん
12/04/12 17:45:50.95
モナドは何のために作られたの？
228:デフォルトの名無しさん
12/04/12 18:33:25.41
人工知能だけに限らず人間の知能にも起こり得るフレーム問題は、ジョン・マッカーシー
らの提案したフレーム問題と区別して一般化フレーム問題と呼ばれている。
ソースはwikipedia
>>223
限定的なフレームを選択しないと、フレーム問題に対処できない
229:デフォルトの名無しさん
12/04/12 19:54:30.42
関数型は問題資源を乱獲してあっという間に死滅させる蛮族の手法
対して従来のやり方は問題を死滅させず適宜再生産もする
農耕・牧畜をおぼえた文明人の手法
230:デフォルトの名無しさん
12/04/12 20:03:40.16
は？
単に生産性が低いものを賞賛してるだけのバカですねw
231:デフォルトの名無しさん
12/04/12 20:11:16.33
OOを使ったプロジェクトは次の二つに分類される
・プロジェクトが成功した場合 => 成功したのはOOのおかげ
・プロジェクトが失敗した場合 => 設計者やプログラマがOOに未熟だった
以上の詭弁により、OOはソフトウェア工学の全ての問題を解決した
232:デフォルトの名無しさん
12/04/12 20:12:09.57
え、関数型って生産性あったんですか。
233:デフォルトの名無しさん
12/04/12 20:15:51.90
どんな被害妄想だよ。成功も失敗も設計者の腕次第だろ。
234:デフォルトの名無しさん
12/04/12 20:41:17.18
解決はするけど生産はしない
235:デフォルトの名無しさん
12/04/12 22:36:25.45
>>232
生産性については職業プログラマの人に比較して貰うとして、少なくとも、rubyで入門書のサンプル以上のものが作れなかった自分が、haskellでは>>41,>>74のコードを書ける様になった
初心者には、rubyよりhaskellの方が自力でコード書ける様になり易いんじゃ無いかと思う
236:デフォルトの名無しさん
12/04/12 23:36:58.60
せめて一ファイル千行ぐらいのものを
数十ファイルからなるアプリを作ってから
書けるようになったといって下さい。
短い関数一つと程度、
あんなの誤差でしかない。
237:デフォルトの名無しさん
12/04/12 23:59:11.36
プログラムが書けるようになったといえる最低ラインは数万行のアプリを作れてから・・か。
238:デフォルトの名無しさん
12/04/13 00:07:17.03
URLﾘﾝｸ(gihyo.jp)
EC-CUBE 4万行らしいよ。
239:デフォルトの名無しさん
12/04/13 00:08:42.48
URLﾘﾝｸ(www.mapee.jp)
Rubyは10万行
240:デフォルトの名無しさん
12/04/13 00:12:30.38
URLﾘﾝｸ(picomu-tech.blogspot.jp)
OpenPNE2 13万行
Linuxは1500万行らしい
URLﾘﾝｸ(www.infoq.com)
解析対象のオープンソースプロジェクトは、コード行数が10万～50万のものが
ほとんど(700万行を超えるプロジェクトが2つ)で、
の合計コード行数は3,744万6,469行、平均コード行数は83万2,000行になった。
241:デフォルトの名無しさん
12/04/13 00:21:31.21
OpenDylanは処理系が80万でIDEが100万stepだったっけ、失念
gccが少し前は30~40万行あった、いまの4.6,4７はもっとだろうな
242:デフォルトの名無しさん
12/04/13 00:23:31.62
>>236
書きたいものを書ける様になったら行数関係無い気がするけど・・・
そもそも、私の場合、Rubyではどう書けばいいかすら思い浮かばない
（学習が足りないと言われればそうだけど、どっちも入門書読みかけ状態での知識でしかない)
Haskellは入門書読みかけの状態でも結構色々書けるから、入門者のモチベーション維持にも良いんじゃないかな
（少なくとも、自分のモチベーション維持には良い効果がある)
243:デフォルトの名無しさん
12/04/13 00:27:01.11
書きたいものを書けるのは
プロである以上最低限のことです。
244:デフォルトの名無しさん
12/04/13 00:27:48.64
>>241
間違えた、The compiler includes an IDE (Win32 only, sorry), CORBA, OLE, all in all 850000 lines of code. This is (nearly) all Dylan code.
245:デフォルトの名無しさん
12/04/13 00:33:06.76
>>243
書きたくない物でも金を受けとる以上書き上げるのが…（ry
246:デフォルトの名無しさん
12/04/13 00:36:02.31
>>245
あんたプロや。プログラマー（ry）や。
247:デフォルトの名無しさん
12/04/13 00:38:56.24
>>243
プロじゃないと言うか、プロの卵として就職して半年で諦めたんですが・・・
そんな奴が、Haskellでなら、ちょっとは書ける様になったですよ
それで気付いたのは、やってる事はどの言語も同じなのかもなぁー・・・と
で、関数型言語はそのやってる事は同じ。の部分を気付きやすい言語だな・・・・と
他の言語で何やってるのか分かんなくて挫折した人は、一度、関数型言語に挑戦してみてほしいかも
248:デフォルトの名無しさん
12/04/13 00:46:28.21
>>247
うん。やる気ﾏﾝﾏﾝです。
249:デフォルトの名無しさん
12/04/13 01:27:06.58
>>248
一緒に頑張りまっしい
多分、私はそもそものググルための用語を知らないのが、そもそもの才能の無さな気がする
なので、そもそもググらず自分で作っちゃえ！派な自分には関数型言語の方が性に合うっぽい
（不器用なのは自覚してる)
250:デフォルトの名無しさん
12/04/13 01:30:15.85
そういうセリフは関数型言語を作ってから言って下さい。
作らずに言語を使ってるだけのくせに
251:デフォルトの名無しさん
12/04/13 01:41:31.45
>>249
> なので、そもそもググらず自分で作っちゃえ！派な自分には関数型言語の方が性に合うっぽい
初心者なら当然のことだよ。
俺なんかだと、見ただけで簡単な処理と分かるようなもの、
自分で作れると分かっているものは、作っても時間
を浪費するだけで何の経験値にならないし、自慢にもならない。
でも初心者にとっては、そんなものでも
挑戦する価値がある課題なのだから。
自分で作ったんだって自慢げになるでしょ？
252:デフォルトの名無しさん
12/04/13 06:51:30.77
何万行とかで脅されても気にする事無いよ
ドカタ仕事で書くコードなんてAPI呼び出すだけ、コピペコード満載の
頭悪いコードなんだから
疑うなら適当なコード書く御題出してみ？Javaのコードとか出てこないから
253:252
12/04/13 06:57:36.95
多分、「そんなの意味ない」「もっと規模が大きくないと本当の事は分からない」
とかその手の言い訳を、御題のコードの10倍くらいの長さの文章で
必死に語ってくれるよ
本当は2chのレスに収まる規模のコードも書けないんだけどね
254:デフォルトの名無しさん
12/04/13 07:16:26.24
>>252
じゃあお題。
プログラマーなら「FizzBuzz問題」解けるよな？
ｽﾚﾘﾝｸ(prog板:401番)
401 ：仕様書無しさん：2012/04/09(月) 23:59:48.08
FizzBuzzクイズ
1.fizz.buzz #=> 1
3.fizz.buzz #=> "Fizz"
5.fizz.buzz #=> "Buzz"
15.fizz.buzz #=> "FizzBuzz"
となるようなメソッドfizz、buzzは定義可能か？
可能である場合、同様にgizzを追加定義し、
7.fizz.buzz.gizz #=> "Gizz"
21.fizz.buzz.gizz #=> "FizzGizz"
35.fizz.buzz.gizz #=> "BuzzGizz"
105.fizz.buzz.gizz #=> "FizzBuzzGizz"
105.fizz.gizz.buzz #=> "FizzGizzBuzz" と拡張・応用ができるか？
メソッドのコールに()が必須の言語では 3.fizz().buzz() 形式でも構わない。
オープンクラス機構やメソッドのない言語では関数（buzz(fizz(3)) #=> "Fizz" など）で。
255:デフォルトの名無しさん
12/04/13 07:48:45.37
>>252
ありがとうです
では、仕事があるので明日私は書くと思いますが(飲んで帰るので、今日は無理)
ファイルと検索したい文字列をコマンドから入れて、見つかった行と列のリストを表示すると言うのはどうでしょう？
256:デフォルトの名無しさん
12/04/13 08:18:23.98
全くなんの工夫もないが
$ cat fizzbuzz.hs
import Control.Monad (mapM_)
main = mapM_ (runFizzBuzz . gizz . buzz . fizz) [1, 3, 5, 7, 15, 21, 35, 105]
runFizzBuzz (n, s)
| s == "" = putStrLn $ show n
| otherwise = putStrLn $ show s
fizz n
| n `mod` 3 == 0 = (n, "Fizz")
| otherwise = (n, "")
buzz (n, s)
| n `mod` 5 == 0 = (n, showString s "Buzz")
| otherwise = (n, s)
gizz (n, s)
| n `mod` 7 == 0 = (n, showString s "Gizz")
| otherwise = (n, s)
$ runghc fizzbuzz.hs
1
"Fizz"
"Buzz"
"Gizz"
"FizzBuzz"
"FizzGizz"
"BuzzGizz"
"FizzBuzzGizz"
257:デフォルトの名無しさん
12/04/13 08:45:35.77
この場合の顧客がのぞむもの。
map (gizz . buzz . fizz) [1, 3, 5, 7, 15, 21, 35, 105]
-- [1, "FIzz", "Buzz", "Gizz", "FizzBuzz", "FizzGizz", "BuzzGizz", "FizzBuzzGizz"]
map (buzz . gizz . fizz) [1, 3, 5, 7, 15, 21, 35, 105]
-- [1, "FIzz", "Buzz", "Gizz", "FizzBuzz", "FizzGizz", "GizzBuzz", "FizzGizzBuzz"]
258:デフォルトの名無しさん
12/04/13 08:54:17.09
整数と文字列が同じリストにフラットに入らなきゃ嫌だという主張？
259:デフォルトの名無しさん
12/04/13 09:05:31.58
struct filter_t{ int e; const char *t; };
struct fizzbuzz_t
{
int in; std::string out;
fizzbuzz_t &operator >>( filter_t &f )
{ if( 0==in%f.e ){ out.append( f.t ); } return *this; }
operator const char *()
{ if( out.length() ) return out.c_str(); static char tmp[50]; itoa( in, tmp, 10 ); return tmp; }
};
fizzbuzz_t operator >>( int i, filter_t &f ){ fizzbuzz_t fb; fb.in = i; fb>>f; return fb; }
filter_t fizz = { 3, "Fizz", };
filter_t buzz = { 5, "Buzz", };
filter_t gizz = { 7, "Gizz", };
int main(){ 105>>fizz>buzz>>gizz>>endfb; return 0; }
260:デフォルトの名無しさん
12/04/13 09:05:55.65
fizz buzz gizz （とその合成）で完結する。
合成順が結果に反映される。
結果は標準出力ではなく関数の戻り値として欲しい。
というのが要件だろう。
関数縛りがなければマクロですぐなんだが。
261:デフォルトの名無しさん
12/04/13 09:09:14.47
ごめんごめん途中で送信してしまった。
読まなくても良いくらいC++でのスタンダードな回答。
struct filter_t{ int e; const char *t; };
struct fizzbuzz_t
{
int in; std::string out;
fizzbuzz_t &operator >>( filter_t &f )
{ if( 0==in%f.e ){ out.append( f.t ); } return *this; }
operator const char *()
{ if( out.length() ) return out.c_str();
static char tmp[50]; itoa( in, tmp, 10 ); return tmp; }
};
fizzbuzz_t operator >>( int i, filter_t &f ){ fizzbuzz_t fb; fb.in = i; fb>>f; return fb; }
filter_t fizz = { 3, "Fizz", };
filter_t buzz = { 5, "Buzz", };
filter_t gizz = { 7, "Gizz", };
int main(){ 105>>fizz>buzz>>gizz; return 0; }
262:デフォルトの名無しさん
12/04/13 09:19:13.99
スタンダードっていうより姑息だな。（←褒め言葉）
とはいえ、関係ない演算子をしれっとまぎれこませちゃったら失格じゃまいか？
263:デフォルトの名無しさん
12/04/13 09:30:20.96
>>260
マクロを使わなくても、型クラスと多値とモナドが賢い言語なら関数でも書けるんじゃね？
264:デフォルトの名無しさん
12/04/13 09:49:06.63
>>257 map でそれをやれ、というのは無理。
それに hoge を追加することを想定して、
map (hoge . gizz . buzz . fizz) [1, 3, 5, 7, 15, 21, 35, 105] について考える。
関数合成と map の性質より、
map (f . g) [...] = map f (map g [...]) であるから
map (hoge . gizz . buzz . fizz) [1, 3, 5, 7, 15, 21, 35, 105]
= map hoge (map (gizz . buzz . fizz) [1, 3, 5, 7, 15, 21, 35, 105])
= map hoge [1, "FIzz", "Buzz", "Gizz", "FizzBuzz", "FizzGizz", "BuzzGizz", "FizzBuzzGizz"]
よって hoge が書けない。===== 終 ===== 了 =====
-- という風に論破されちゃうのが嫌な自称上流には嫌われるだろうなぁ、
-- Haskell や形式手法はw
265:デフォルトの名無しさん
12/04/13 10:04:19.47
メソッドの追加は副作用よりも難しい
代入しても型は不変だがメソッドを追加したら型が変わる
266:デフォルトの名無しさん
12/04/13 10:10:13.95
マクロも型クラスも多値もモナドも無いけどSqueak Smalltalkで。
Trait named: #FizzBuzz uses: #() category: 'FizzBuzz-Trait'
FizzBuzz >> fizzBuzzPrep
self value isString ifFalse: [thisContext sender receiver: self -> ''].
FizzBuzz >> fizzBuzzReturn
| method nextByte type |
method := thisContext sender sender method.
nextByte := thisContext sender sender method at: thisContext sender sender pc.
type := nextByte // 16.
^(type = 13 and: [FizzBuzz selectors includes: (method literalAt: nextByte \\ 16 + 1)])
ifTrue: [self] ifFalse: [self value ifEmpty: [self key]]
FizzBuzz >> fizz
self fizzBuzzPrep.
(self key isDivisibleBy: 3) ifTrue: [self value: self value, 'Fizz'].
^self fizzBuzzReturn
FizzBuzz >> buzz
self fizzBuzzPrep.
(self key isDivisibleBy: 5) ifTrue: [self value: self value, 'Buzz'].
^self fizzBuzzReturn
FizzBuzz >> gizz
self fizzBuzzPrep.
(self key isDivisibleBy: 7) ifTrue: [self value: self value, 'Gizz'].
^self fizzBuzzReturn
Integer uses: FizzBuzz. Association uses: FizzBuzz.
105 fizz gizz buzz. "=> 'FizzGizzBuzz' "
267:デフォルトの名無しさん
12/04/13 10:18:03.23
>>256 は runFizzBuzz に渡す前までは文字列の蓄積で通してるから、
putStrLn を削るだけでリストになるんじゃね？
268:デフォルトの名無しさん
12/04/13 10:45:33.86
継続使える言語なら書けるんじゃね？
269:デフォルトの名無しさん
12/04/13 11:19:14.13
Scheme使いの登場を待ってるわけ？
てか継続をどう使うことを想定してるの？
270:デフォルトの名無しさん
12/04/13 12:38:39.46
join fs n = case concatMap (\f -> f n) fs of
"" -> Left n
s -> Right s
fizzT f s n | f n == 0 = s
fizzT _ _ _ | otherwise = ""
fizz = fizzT (`mod` 3) "Fizz"
buzz = fizzT (`mod` 5) "Buzz"
gizz = fizzT (`mod` 7) "Gizz"
main = print $ join [fizz, buzz, gizz] 105
271:デフォルトの名無しさん
12/04/13 12:50:09.96
こっちのほうが join を入れ子に出来て良いかも
import Data.Either
join fs n = case concat $ rights $ map (\f -> f n) fs of
"" -> Left n
s -> Right s
fizzT f s n | f n == 0 = Right s
fizzT _ _ _ | otherwise = Right ""
fizz = fizzT (`mod` 3) "Fizz"
buzz = fizzT (`mod` 5) "Buzz"
gizz = fizzT (`mod` 7) "Gizz"
main = print $ join [join [fizz, buzz], gizz] 105
272:デフォルトの名無しさん
12/04/13 13:14:50.14
join とか無しで gizz buzz fizz 105 で "FizzBuzzGizz" をさくっと返す方法はないの？
273:デフォルトの名無しさん
12/04/13 13:43:15.17
ここまでruby/python無し
LLに有利っぽいのに
274:デフォルトの名無しさん
12/04/13 13:43:49.58
gizz buzz fizz 105 という式が、ちゃんと型を持っているとする。
また、fizz 105、buzz fizz 105 という式も、同様になんらかの型を持つとする。
すると、
fizz の型は
Int -> a
buzz の型は
(Int -> a) -> Int -> b
gizz の型は
((Int -> a) -> Int -> b) -> (Int -> a) -> Int -> c
というような型でなければならない。無理。というか、どう頑張っても、
先頭に do か何かが要る。
275:デフォルトの名無しさん
12/04/13 13:56:46.55
型システムに制約を受けないパワフルな関数型言語ってのはないもんかね。
276:デフォルトの名無しさん
12/04/13 14:00:17.79
Perlしか読めないから誰かPerlで書いて
277:デフォルトの名無しさん
12/04/13 14:04:41.69
>>275 Erlang ？
278:デフォルトの名無しさん
12/04/13 14:24:54.40
>>273 つーか元出題者が Ruby だとオープンクラスやらなんやら使ってできるぜ、
って言いたいだけで作った問題なのがかなり見え見えなんだが。
279:デフォルトの名無しさん
12/04/13 15:57:16.91
書き込み行数がオーバーするんで適当に圧縮した
module FizzBuzz
SYM_HASH = {} ; def self.add_fizz sym, n ; SYM_HASH[sym] = n ; end
def self.do_it sym, n, prefix ; if m = SYM_HASH[sym]
if n % m == 0
s = sym.to_s ; s.capitalize!
if prefix.kind_of? String then s[0, 0] = prefix end
s.fizzbuzzval = n ; s
else prefix end else nil end
end
end
class Integer ; def method_missing sym
if it = FizzBuzz.do_it(sym, self, self) then it else super end
end end
class String ; attr_writer :fizzbuzzval ; def method_missing sym
if it = FizzBuzz.do_it(sym, @fizzbuzzval, self) then it else super end
end end
FizzBuzz.add_fizz :fizz, 3
FizzBuzz.add_fizz :buzz, 5
FizzBuzz.add_fizz :gizz, 7
p [1, 3, 5, 7, 15, 21, 35, 105].map{|n|n.fizz.buzz.gizz}
280:デフォルトの名無しさん
12/04/13 16:17:23.17
>>276 突貫工事だけれど…
package FizzBuzzGizz;
sub new {
my ($c, $n) = @_;
bless {n => $n, s => ''}, $c
}
sub fizz {my $t = shift; $t->{s} .= 'Fizz' if 0 == $t->{n} % 3; $t}
sub buzz {my $t = shift; $t->{s} .= 'Buzz' if 0 == $t->{n} % 5; $t}
sub gizz {my $t = shift; $t->{s} .= 'Gizz' if 0 == $t->{n} % 7; $t}
sub result {my $t = shift; $t->{s} ? $t->{s} : $t->{n}}
1;
package main;
do {
my $fbg = new FizzBuzzGizz($_);
print "$_:" . FizzBuzzGizz::result($fbg->fizz->buzz->gizz) . "\n"
# あるいは print "$_:" . $fbg->fizz->buzz->gizz->result . "\n"
} for qw{1 3 5 7 15 21 35 105};
$ perl p_fizzBuzzGizz.pl
1:1
3:Fizz
5:Buzz
7:Gizz
15:FizzBuzz
21:FizzGizz
35:BuzzGizz
105:FizzBuzzGizz
281:デフォルトの名無しさん
12/04/13 16:22:11.22
>>280
objectのmethodが返す値はまたobjectだけれど、
printで評価すると判定結果文字列を返すには、
こんな書き方くらいしかないのかな…？
多値のﾘｽﾄ返しでやってみようと思ったけれどうまい方法が思いつかなかったぜよ
282:デフォルトの名無しさん
12/04/13 17:12:42.66
>>281
package FizzBuzzGizz;
sub new {
my ($c, $n) = @_;
bless \"$n."
}
sub fizz {my $t=shift; $_=$$t; bless do { /(^\d+)/; 0 == $1 % 3 ? \"${_}Fizz": $t }}
sub buzz {my $t=shift; $_=$$t; bless do { /(^\d+)/; 0 == $1 % 5 ? \"${_}Buzz": $t }}
sub gizz {my $t=shift; $_=$$t; bless do { /(^\d+)/; 0 == $1 % 7 ? \"${_}Gizz": $t }}
1;
package main;
do {
my $fbg = new FizzBuzzGizz($_);
print ${$fbg->fizz->buzz->gizz} . "\n"
} for qw{1 3 5 7 15 21 35 105};
283:デフォルトの名無しさん
12/04/13 17:29:05.85
>>272
何縛りのゲームなのかわからんけど、関数合成演算子でも駄目かね？
import Data.Either
import Prelude hiding ((.))
(.) f g n = case concat $ rights [f n, g n] of
[] -> Left n
s -> Right s
fizzT f s n | f n == 0 = Right s
fizzT _ _ _ | otherwise = Right []
fizz = fizzT (`mod` 3) "Fizz"
buzz = fizzT (`mod` 5) "Buzz"
gizz = fizzT (`mod` 7) "Gizz"
main = print $ fizz.buzz.gizz $ 105
284:デフォルトの名無しさん
12/04/13 17:30:10.61
>>282
package FizzBuzzGizz;
sub new {
my ($c, $n) = @_;
bless \"$n."
}
sub comm { my ($t, $r, $s) = @_; $$t =~ /(^\d+)/;
0 == $1 % $r ? \"${_}$s": $t }
sub fizz {bless comm((shift), 3, 'Fizz')}
sub buzz {bless comm((shift), 5, 'Buzz')}
sub gizz {bless comm((shift), 7, 'Gizz')}
1;
package main;
for (qw(1 3 5 7 15 21 35 105)) {
print ${new FizzBuzzGizz($_)->fizz->buzz->gizz} . "\n"
}
285:デフォルトの名無しさん
12/04/13 17:31:15.65
Ruby のカオスな部分を前面に押し出して書いてみた
class String
attr_accessor :srcint
private
def f(n,s); (@srcint % n == 0) ? (self << s) : (self); end
end
class Integer
private
def f(n,s); (self % n == 0) ? (s.srcint = self; s) : (self); end
end
class Object
def fizz; f(3,'Fizz'); end
def buzz; f(5,'Buzz'); end
def gizz; f(7,'Gizz'); end
end
p [1,3,5,7,15,21,35,105].map{|n| n.fizz.buzz.gizz }
# => [1, "Fizz", "Buzz", "Gizz", "FizzBuzz", "FizzGizz", "BuzzGizz", "FizzBuzzGizz"]
p [1,3,5,7,15,21,35,105].map{|n| n.fizz.gizz.buzz }
# => [1, "Fizz", "Buzz", "Gizz", "FizzBuzz", "FizzGizz", "GizzBuzz", "FizzGizzBuzz"]
286:デフォルトの名無しさん
12/04/13 17:33:52.32
>>284 ${_}$s←ﾊﾞｸﾞ
package FizzBuzzGizz;
sub new {
my ($c, $n) = @_;
bless \"$n."
}
sub comm { my ($t, $r, $s) = @_;
0 == $$t % $r ? \"$${t}$s": $t }
sub fizz {bless comm((shift), 3, 'Fizz')}
sub buzz {bless comm((shift), 5, 'Buzz')}
sub gizz {bless comm((shift), 7, 'Gizz')}
1;
package main;
for (qw(1 3 5 7 15 21 35 105)) {
print ${new FizzBuzzGizz($_)->fizz->buzz->gizz} . "\n"
}
287:デフォルトの名無しさん
12/04/13 17:45:43.30
>>286 ｵｯﾁｬﾝ、どうせ書くならこうやろ
package FizzBuzzGizz;
sub new { my ($c, $n) = @_;
bless \"$n." }
sub com { my ($t, $m, $s) = @_;
bless 0 == $$t % $m ? \($$t.$s): $t }
sub fizz {com(shift, 3, 'Fizz')}
sub buzz {com(shift, 5, 'Buzz')}
sub gizz {com(shift, 7, 'Gizz')}
1;
package main;
for (qw(1 3 5 7 15 21 35 105)) {
print ${new FizzBuzzGizz($_)->fizz->buzz->gizz} . "\n"
}
大差ないか…
288:デフォルトの名無しさん
12/04/13 17:54:12.60
new FizzBuzzGizz($_) している時点でダメだろ。
289:デフォルトの名無しさん
12/04/13 17:58:22.56
>>288
え？なぜ？
290:デフォルトの名無しさん
12/04/13 18:10:15.39
関係ないオブジェクトにもfizz buzz gizzが継承されてしまう気持ち悪さを除けば、
ちゃんと書けているのは今のところRubyだけって感じか。
文字列オブジェクトにインスタンス変数（状態）を持たせられるのが強みだなぁ。
Smalltalkのはやってることが「独立した関数（メソッド）」と呼ぶにはどーよという内容だから失格。
関数型は型システムの制約でこういう仕様の関数モドキは書けないっていうことでＦＡ？
291:デフォルトの名無しさん
12/04/13 18:22:32.06
>>290
でも実際のところ、こんな書き方したくないけどね
実際にやるなら、何らかのコンテナにラップしてからmapして
それが終わったら、文字列や数値として取り出すと思う
原文がいきなり数値に対してメソッド呼んでるから、容赦なく組み込みクラスを弄ったが…
292:デフォルトの名無しさん
12/04/13 18:30:51.94
JSならやれそうじゃね？
293:デフォルトの名無しさん
12/04/13 18:33:45.54
>>291
まあクイズだからね。言語機能をどう使って無茶な要件をクリアするかのパズルみたいなもん。
294:デフォルトの名無しさん
12/04/13 18:35:01.97
>>292
まずコード出せ。話はそれからだ。
295:デフォルトの名無しさん
12/04/13 18:57:18.70
数値がobjectとしてmethodを持たない言語ではどうするかってお題だったのかよ…
296:デフォルトの名無しさん
12/04/13 19:00:25.49
>>290 自分の足を自分で撃ちたいなら、それに向いた言語ある、という話、でFA
297:デフォルトの名無しさん
12/04/13 19:35:12.73
>>290
RubyはメソッドチェインOKなのに
関数型言語はfizz(buzz(gizz))しか認めないんだろ？
そりゃ静的型じゃ無理っつーか制限する意味が分からん
後からgizz等を追加できる拡張性あるコードを
書けないならともかく、そうでもないしな
298:デフォルトの名無しさん
12/04/13 19:40:42.95
>文字列オブジェクトにインスタンス変数（状態）を持たせられるのが強みだなぁ。
-- String "has-a" Integer
data HasA = HasA String Integer
instance Show HasA where show (HasA s n) = if s == "" then show n else show s
fizz (HasA s n) = HasA (s ++ if mod n 3 == 0 then "Fizz" else "") n
buzz (HasA s n) = HasA (s ++ if mod n 5 == 0 then "Buzz" else "") n
gizz (HasA s n) = HasA (s ++ if mod n 7 == 0 then "Gizz" else "") n
main = print $ map (gizz . buzz . fizz . HasA "") [1,3,5,7,15,21,35,105]
299:デフォルトの名無しさん
12/04/13 19:47:44.31
>>298
似たようなコード書いてたら先に張られてた
個人的には hasA = HasA "" を定義しておくのが好み
それはともかく、.演算子使ってるからケチ付けられると思うぜ多分w
300:デフォルトの名無しさん
12/04/13 19:56:22.62
>>294 おまえはどれかのコード書いたの？
301:デフォルトの名無しさん
12/04/13 20:00:44.98
ここまでJava無し
302:デフォルトの名無しさん
12/04/13 20:30:30.61
JavaScriptできた。俺の使ってるブラウザ以外で動くかどうかはわからん。
var def_fizz = function (name, m) {
var fun = function () {
var tp = typeof this.valueOf();
var n = (tp === 'number') ? this : this.fizzbuzzval
if (n % m === 0) {
var s = name.charAt(0).toUpperCase() + name.slice(1);
if (tp === 'string') {
s = this + s;
}
s = new String(s);
s.fizzbuzzval = n;
return s;
} else {
return this;
}
} ;
Number.prototype[name] = fun;
String.prototype[name] = fun;
} ;
def_fizz('fizz', 3);
def_fizz('buzz', 5);
for (var i = 1; i <= 30; ++i) {
document.writeln(i.fizz().buzz());
}
303:デフォルトの名無しさん
12/04/13 20:36:17.98
>>301
ｽﾚﾘﾝｸ(tech板:190番)
‥‥ごめんなさい。
304:デフォルトの名無しさん
12/04/13 22:09:50.27
あるいはこうかな？
ｽﾚﾘﾝｸ(tech板:191番)
305:デフォルトの名無しさん
12/04/13 22:25:54.85
newはﾀﾞﾒらしい…>>288