関数型プログラミング言語Haskell Part22

haskell.org
ttp://www.haskell.org/

日本語サイト
ttp://www.sampou.org/cgi-bin/haskell.cgi
ttp://www.shido.info/hs/

過去ログ
関数型プログラミング言語Haskell
Part1 ttp://pc.2ch.net/tech/kako/996/996131288.html
Part2 ttp://pc2.2ch.net/test/read.cgi/tech/1013846140/
Part3 ttp://pc8.2ch.net/test/read.cgi/tech/1076418993/
Part4 ttp://pc8.2ch.net/test/read.cgi/tech/1140717775/
Part5 ttp://pc8.2ch.net/test/read.cgi/tech/1149263630/
Part6 ttp://pc11.2ch.net/test/read.cgi/tech/1162902266/
Part7 ttp://pc11.2ch.net/test/read.cgi/tech/1174211797/
Part8 ttp://pc11.2ch.net/test/read.cgi/tech/1193743693/
Part9 ttp://pc11.2ch.net/test/read.cgi/tech/1211010089/
Part10 ttp://pc12.2ch.net/test/read.cgi/tech/1231861873/
Part11 ttp://pc12.2ch.net/test/read.cgi/tech/1252382593/
Part12 ttp://hibari.2ch.net/test/read.cgi/tech/1272536128/
Part13 ttp://hibari.2ch.net/test/read.cgi/tech/1286706874/
Part14 ttp://hibari.2ch.net/test/read.cgi/tech/1299385928/
Part15 ttp://hibari.2ch.net/test/read.cgi/tech/1310199414/
Part16 ttp://toro.2ch.net/test/read.cgi/tech/1317958045/
Part17 ttp://toro.2ch.net/test/read.cgi/tech/1325510368/
Part18 ttp://toro.2ch.net/test/read.cgi/tech/1331902463/
Part19 ttp://toro.2ch.net/test/read.cgi/tech/1340760070/
Part20 ttp://toro.2ch.net/test/read.cgi/tech/1350428908/
Part21 ttp://toro.2ch.net/test/read.cgi/tech/1358702176/

関連書籍
・Introduction to Functional Programming Using Haskell (2nd ed.)
　ttp://www.amazon.co.jp/exec/obidos/ASIN/0134843460/

・Haskell: The Craft of Functional Programming
　ttp://www.amazon.co.jp/exec/obidos/ASIN/0201342758/

・The Fun of Programming
　ttp://www.amazon.co.jp/exec/obidos/ASIN/0333992857/

・The Haskell School of Expression: Learning Functional Programming Through Multimedia
　ttp://www.amazon.co.jp/exec/obidos/ASIN/0521644089/

・入門Haskell
　ttp://www.amazon.co.jp/exec/obidos/ASIN/4839919623/

・ふつうのHaskellプログラミング
　ttp://item.rakuten.co.jp/book/4052963/

・Programming in Haskell
　ttp://www.amazon.co.jp/exec/obidos/ASIN/0521692695/

・Real World Haskell
　ttp://www.amazon.co.jp/exec/obidos/ASIN/0596514980

・関数プログラミングの楽しみ
　ttp://www.amazon.co.jp/exec/obidos/ASIN/4274068056

・すごいHaskellたのしく学ぼう!
　ttp://www.amazon.co.jp/dp/4274068854

関連リンク
・GHC Wiki
　ttp://hackage.haskell.org/trac/ghc/wiki/TitleIndex

・A History of Haskell
　ttp://research.microsoft.com/en-us/um/people/simonpj/papers/history-of-haskell/

・関数型関連の用語集
　ttp://sky.zero.ad.jp/~zaa54437/programming/concepts/

・本物のプログラマはHaskellを使う
　ttp://itpro.nikkeibp.co.jp/article/COLUMN/20060915/248215/?ST=ittrend

・Haskell API search Engine
　ttp://www.haskell.org/hoogle/

　【簡単な使い方】
　１．検索バーに関数名を入れて検索
　　例　map
　２．検索バーに型名を入れて検索
　　例　(a -> b) -> [a] -> [b]

・Real World Haskell
　ttp://book.realworldhaskell.org/read/

・Learn You a Haskell for Great Good!
　ttp://learnyouahaskell.com/chapters

　
私がこの世界に求める優しさのすべて―
　　それがHaskellなんだと。

あぁ　この世界の女性がみんなHaskellになったら
　　なんてすてきな世界なんだろうと考えました。


レトルトカレーしか作れぬお前がHaskellになったところで

　　　そ　れ　は　H　a　s　k　e　l　l　で　は　な　い　!

さすがキチガイだな
Haskellにはチンポ入れる穴がないだろ

チンコ入らないこともなさそう http://hackage.haskell.org/trac/ghc/wiki/Holes

927 デフォルトの名無しさん [] 2013/03/24(日) 13:57:24.26 ID: Be:
    15分で始めるScala
    http://xerial.org/scala-cookbook/recipes/2012/11/29/scala-in-15-minutes/


    ↑
    東大の先生は、Scala使ってDNA解析をガンガンぶん回しているというのに、
    おまえらみたいな低脳は、いつまでもたっても、言語がどーのこーので、ちっとも前に進まないな。

928 デフォルトの名無しさん [sage] 2013/03/24(日) 15:33:58.26 ID: Be:
    そういうレスはHaskellスレに書いたほうがウケる

このスレッドは天才チンパンジー「アイちゃん」が
言語訓練のために立てたものです。

アイと研究員とのやり取りに利用するスレッドなので、
関係者以外は書きこまないで下さい。

　　　　　　　　　　　　　　　　　　京都大学霊長類研究所

いくらクソ言語のクソスレだからってあんまりだ……

http://d.hatena.ne.jp/nushio/touch/20120517
http://th.nao.ac.jp/meeting/rironkon11/oral-files/muranushi.pdf
御使い乙、代わりにこれをあげよう

>>7
scalaなんかで解析してるから進みが遅いんだな・・・

貴様は一生機械語でカイてろ

Haskellって遅延評価じゃん？
この言語で作ったGUIも遅延評価になるの？

GUIが遅延評価になるってのが自分で言っててよくわかんないんだけど

2chブラウザなんか作ったとして、スレッドを読み込んだ時点で
先の方のレスはまだ表示させる必要ないから
データの解釈とレンダリングは必要になる(実際にそのレス番に着く)までしないとかさ
そういう、特に工夫しなくてもデフォルトで遅延評価になってることを類推するじゃん？

>>13
特殊な裏ワザを使わなければ遅延評価
ただし、評価生成されるのは、「表示」じゃなくて「表示するプロセス」

>>13
gtkとか使う場合、描画タイミングとかはwidgetにお任せだよ。

むむむ

誰も使わない

>>12
君はいつもそういう極論しか言えないよね

ただの報告だけど、いまHaskell使ってGPU用のCのコードを自動生成してる
並列計算

突然どうした

>>18
>>11 の暴論っぷりはスルーかいw

　　　　　参照は透ける――Haskell！

よし

Haskellって言語としての出来はともかく標準ライブラリは変だよね
なんでApplicativeのpureとMonadのreturnが分かれてるんだ
歴史的経緯は分かるんだけど、Applicativeを導入するときにpureじゃなくてreturnって名前にすりゃよかったじゃん

(」・ω・)」はぁ〜

(/・ω・)/　透けるぅー！

>>23
return の方がおかしいと思うのは俺だけか？

>>23
歴史的経緯が分かってて、その提案なの？

MonadとClannadの違いについて教えてください

>>27
違いについて質問しようと思った経緯を教えて欲しい。
それによって返答が違う。

たとえば、＊＊や〜〜などの共通項を見つけたが、
あまりにも似すぎているために、逆に違いがあるのか気になった、とか。

スレチだったりバカな理由なら以後は無視する。

Monadは隠蔽でClannadは人生

クラナッハはハウスバルドゥンクの師匠に当たるのかな。

レーベンシュタイン距離……？

モナドは文脈依存

Keyは登場人物がキチガイだらけの糞

Haskell頭文字がHだからってエロゲの話しなくていいから
今ホットなライブラリの話でもしててくれ

ホットというか、新しいプラットホーム入れたらライブラリがけっこう移動しててビビッた

>>30
ハンス・バルドゥンクだろう。グリーンの使い方の名手として
知られたらしいが、あまり発色の良いものは残っていないらしい。

美術をテーマにしたHaskellプログラムは見たことがないな。Prologだと、
1980年代前半から古典主義建築のオーダーだとか、ファサードの研究に
結構利用されていたのだが。

なにそれ詳しく知りたいです

>>38
84-5年頃だから前半ではなくて中頃だった。建設省建築研究所での
Prolog-KABAを使った研究が有名。浮動小数点数も扱えない処理系で
何ができたかは疑問ですが。
それとは全く別の話だが、こちらは海外でPrologのプログラミングで
黄金分割の研究をしたものもあった。

>>37
GitHubにはあると思うけど。

綺麗に書かれたコードはそれ自体が美術です

クヌースは文芸と言っていた

"The Art of ~" シリーズがベストセラーを連発していてすっかり世俗化した。

hoge :: a -> Maybe b とするべきか
hoge :: a -> b として境界条件外はundefinedするべきか
よく迷うけど指針ってありますか？ (b自体はMaybe型じゃないとして)

それは、戻り値が境界条件外だった場合に「何がしたいか」によると思うんだが

すまん、戻り値がじゃなくて引数が、ね

境界条件外だった場合に、その事を何かに伝達したいのなら Maybe b の方が良いだろうし

Nothingってどのくらいメモリ食うの？
Left "" はその何倍食うの？

>>44
数学の関数として考えるとき、定義域(domain)に未定義はあり得ない
引数が定義域の範囲の外にあるなら、それは例外として処理すべき

そう言う実コードの役に立たない知識はどうでもいいです

Types And Programming Languages って、ついに翻訳されたんだな
http://www.amazon.co.jp/dp/4274069117/

くっそ高いけど

>>50
ですよねぇ。価値ある情報が無料じゃないのは許されないと思います。

>>49はモデル化できないks

>>48
有理関数（分母と分子が多項式になってる分数で定義される関数）なんかは、
分母がゼロになるところを定義域から外すようにすると、有理関数
を定義するのに先立って分母がゼロになるところを求めておいてそれを
除外したところを定義域とするようにしないといけないのであり得ませんね

TaPL立ち読みしたけど、クソむずそうで興味持てなかったわ

>>50
英語版買ったばかりなのに........

オーム社の関数型言語への入れこみっぷりはちょっとおかしい
ラムダ社に社名変更すべき

>>50
まじで。偉業だな。
大学一年の推薦図書決定だなw

>>52
そんなに気に障ったの？

Haskeller様はコードなんて書かないからいいんだよ

たまには書くわ！ばかにするな！

>>53
高次多項式の零点を求めることになるから、それは一般に計算不可能
関数の計算が問題にする時点で正則関数に限定されており、つまり、分母に零になった時点で例外にしなければならない

特異点を例外にしないのは、高階関数や数式処理をする場合だけにすべき

「高階関数や数式処理」ってなんだよ……

>>62
高階関数＝積分
数式処理＝通分

TaPL日本語、期待してたんだが、ちょっと訳が直訳気味だな。
これだと原語のほうが読みやすいぞ。
超訳よりはマシだが、もうちょいこなれた日本語にできんかったんかね？

>>61はこの前暴れてたやつだろ

数式が全部文字に置き換えられたモノから数式に戻して計算する関数を作りたいと思います。
例えば、[ Kazu 0.1, Tasu, Kazu 2.1, Hiku, Kazu 3.0, Kake, Kazu 2.9, Waru, Kazu 0.9]があって、
これを戻すと 0.1 + 2.1 - 3.0 * 2.9 / 0.9 -> -7.46　みたいに結果をだしたい。

"0.1 + 2.1 - 3.0 * 2.9 / 0.9" という文字列を作ったとして、それをどうやって計算するつもりなのよさ

引くは "-"に、足すは”＋”にしてどうにかできない？
KazuとかHikuなど data Keisan = [Moji]みたいにして？

>>68
Prologだと以下のような定義となる。Haskellだってあるでしょ。

数式が全部文字に置き換えられたモノから数式に戻して計算する(_リスト,_式,結果) :-
　　　　演算子を置換する(_リスト,_演算子を置換されたリスト),
　　　　atomic_list_concat(_演算子を置換されたリスト,' ',_式文字列),
　　　　atom_to_term(_式文字列,_式,_),
　　　　_結果 is _式.

ごめん間違えた。
数式が全部文字に置き換えられたモノから数式に戻して計算する(_リスト,_式,_結果) :-

結果の前のアンダースコアが落ちていました。これだとfailしてしまいます。

ParsecのtokenPrim使おう

結果を出すのはこんな感じかな
ttp://pastebin.com/200nZjPm

マセマティカみたいに文字式のままとか、対数関数を
log 6　を　log 2　+　log 3みたいにちゃんと扱ってくれるライブラリないの？

logで猛烈に四則演算繰り返すと絶対非負であることが証明できる演算が負になっちゃったりして困るの

エントロピー関連の計算でさもありなんでしょ？

これかな。
ttp://www.haskell.org/haskellwiki/Libraries_and_tools/Mathematics#Computer_Algebra
あんまないのか？

それっぽいキーワードで検索すると他にも出てくるけど、これでキマリ、みたいなのはないっぽい。

フリーかつ言語ライブラリとしてまともに使える
数式処理システムはpythonのsympyぐらいでは
他言語じゃhaskell含めて寡聞にして聞かないわ

NumPyとかSymPyとかそのへんはやたら定評があるのなPython。

Pythonさんが最強の言語だな

MissingPyで成果だけ横取りしたらええんや！

数式処理は作る過程が目的だからな…
昔は演習の時間にschemeで数式処理システムを作らされてた
Haskellだとスマートに作れそうな気がするんだけどな

みんな、>>79が作るってよー

schemeなら和田本に数式処理の微分まで載ってる

その分野は最強はMathematicaだろ。
作ってる奴の頭が良すぎる。

Maximaとか？

グラフで表示するために特異点求める研究してて、論文で特異点の説明でその特異点を図示するためにMathematica使ってたのは良い思い出

79氏の伝説が今、爆誕！

モナド戦争しようぜ

Functor〜モナド考えたやつ誰だよ頭いいな
1日経ってもまだ理解できない

>>87
一日で理解できたら相当頭いい。

あと、いろんなものがモナドになってるけど、「いろいろなものが経験的にモナドで表せる」だけで
モナド最強無敵完璧究極とかは明確に間違い。

モナドで不足するところを補うためにあとから色々アイデアが出てる。
圏論的な意味でモナドはかなり良い抽象化であるにもかかわらず
関数型言語ではなぜそれが不十分な抽象化であり得るか：
Hask圏が「ふつうの圏」ではなく豊穣圏の一種だから、だと思われる。

寝ぼけていい加減な事書いてしまった。

いい加減なことだったのかよ読んじゃったよ！

いやさ、「豊穣圏だから」って言い方がなんか投げやりだなって。

先に現象があるのであって、「豊穣圏だから」って言い方だと先に理論が
あるみたいな言い方で極めて質が悪い。

それに、Haskは豊穣圏ではあるけど豊穣圏の中でも最も単純なタイプだ。
だれか夏コミで書いてたけど。豊穣圏などという大砲を持ちだして雀を撃つような
真似は良くない。

自分もいまApplicative Functorやってるんだけどよくわからないな
多少手を動かして「普通の型を関手の世界に持ち上げる」とか「文脈を注入する」
という言葉の上での感覚は掴んだけど
例えばこのへんhttp://d.hatena.ne.jp/shunsuk/20101215/1292414064で関数合成
(fmap f g) == f ・ g
できることすら気づいていなかった自分の頭の硬さにおののく

よーわからんから:tに頼りまくって試してみてる

GoFのデコレーションパターン見たいなものなのかなとか思いつつおやすみ

ぼくはこんな概念を覚えたよ自慢、うざっ

>>72
初心者なので考えてもまだ理解できない。
今はなんとかこれで出来ないかと苦戦中。
type Keisan = [Moji]
data Moji = Kazu Double | Tasu | Hiku
deriving (show)

-- only Tasu or Hiku in a list [Kazu 0.0, Tasu, Kazu 1.0, Hiku, Hiku, Kazu 0.5]
-- == [0.0 + 1.0 - -0.5] -> [Kazu 0.5]
tokenizer :: Keisan -> Moji
tokenizer shiki = Kazu (convMoji shiki)

convMoji :: (Ord a) => Moji -> a
convMoji moji
| moji == Tasu = +
| moji == Hiku = -
| moji == (Kazu x) = x

>>97
プログラミング以前に、まず問題を分けて。

1.
[Kazu 0.1,Tasu,Kazu 2.1,Hiku,Kazu 3.0,Kake,Kazu 2.9,Waru,Kazu 0.9] というデータから、
"0.1 + 2.1 - 3.0 * 2.9 / 0.9" という文字列を作ること。

2.
[Kazu 0.1,Tasu,Kazu 2.1,Hiku,Kazu 3.0,Kake,Kazu 2.9,Waru,Kazu 0.9] というデータから、
-7.466666666666666 という値を求めること。

3.
"0.1 + 2.1 - 3.0 * 2.9 / 0.9" という文字列から、
-7.466666666666666 という値を求める、というのがやりたいことなの？

ええ、そうです。

>ぼくはこんな概念を覚えたよ自慢、うざっ
ぼくはこんな嫌味を覚えたよ自慢、うざっ

そこまでムカついたのか

場外乱闘がはじまるですか？

クズ共食いつきいいな

おいおい、落ち着いてhaskellの話しようぜ

Haskellのコードリーディングって難しくない？

たとえばFRPライブラリ reactivce の特徴である
Sink と Event の仕組みや実際の振る舞いについて調べたいとする。

というのも、makeEvent 関数でタプル (sink, event) を作ると、
あたかも、プログラム内のある場所で sink を評価すると、
全く別の場所にある event が反応したかのように表面上は振る舞って、
なかなか興味深い。

だが、とりあえず Sink a の型を見ても a -> Action としか分からない。
makeEvent 関数のソースを見ても、いきなり (fmap.fmap) が出てくるし。

こういう場合は、adaptE 関数から順に自分で簡約しながら見ていく方が良いのかな。
（reactive のチュートリアルでは皆 adaptE 関数から実際の計算が始まる）

C/C++ だと比較的大きな機能がまとまって書かれているけど、
Haskell だと非常に細かい機能が関数呼び出しという数珠繋ぎで表現されていて、
それらがソース中のバラバラの場所に書かれていたりするから、
なかなか C/C++ と同じ要領ではコードリーディングしにくい。
Haskell としてコードが洗練されているほど、振る舞いが追いにくい印象。

もしかしたら、同じようにできるのかも知れんが、何かコツでもあるのかな。

使って不便だと思うなら、それは無価値だということだ。
わざわざ取り組む必要もない。

>>106
なぜそのようなことを言うのでしょうか。

不便なんて思っていません。

使いたいから使っています。
仕組みを理解したいからコードリーディングに挑戦しています。

>>105
出たなうんこ野郎

こいつは屁理屈こねるために質問してくる
相手するだけ無駄

屁理屈やら討論やらまったり会話が何でもありの掲示板で屁理屈批判とか。
それに105が屁理屈とも思わんし。言ってることが理解できないけどさ。

悔しかったの？ｗ

単芝で煽ったつもりになってるとか君も青いな

>>92
コミケでHaskellの本売ってるの？

>>105
それ、Haskellの問題つーより宣言型の問題な

>>112
いわゆる技術系サークルってのはあって電子工作やらプログラミングやら扱ってる本
書いてるね。Haskellはあったかなぁ？？

簡約λカ娘のことじゃねーの
思い出しついでにちょっとサイト見に行ったら新刊イカ娘と関係なくなってるじゃねえか

g :: [Int] -> [Int] -> Int
g (x:xs) (y:ys)
| (x:xs) == [] && (y:ys) == [] = 1
| otherwise = x*y + g xs ys
処理終わらない。助けて

>>116
それだと、空リストら適用した時点で例外が起きるんだが

「処理終わらない」の意味をもう少し明確に述べてみ

Non-exhaustiveになるんです。
多分間違い : (x:xs) == [] && (y;ys) == [] = 0?
g [1,2,3:[]] [4,5,6:[]] -> (1*4 + 2*5 + 3*6 + []* [] ) -> 32になるはず

g _[]=0
g[]_=0
g(x;xs)(y:ys)=x*y+g xs ys

ありがとうございます。けど、なんで上のガードが出来なかったのだろうか？

[]は(x;xs)にマッチしない

ああ、本当だ。
(x:xs)はすでに何かあるから[]ではないと言うことですね。
納得しました。

ttp://akiradeveloper.hatenadiary.com/

>>118＝122
[1,2,3:[]]
こんなリストはねえ。1:2:3:[]か、[1,2,3]だボケ
んで、後者は前者の糖衣構文

(xs)であれば[]もマッチする
(x:xs)に[]がマッチしない理由は、「何かあるから」ではなく、[]が値コンストラクタ ":" を使ってないから。

質問、
ave関数でなぜかIntが返されます。[1.0, 2.0, 3.0]ならばsumはで、lengthは3なので戻りは1.0のはずなのですが。
value :: [Float] -> Float
value list = case (list) of
(x:xs) -> (x/(ave list)) : value xs
[] -> 0
ave :: [Float] -> Float
ave (x:xs) = ( sum (x:xs) / (length (x:xs) ))

型あわせろボケ

ラムダの記号が円マークでかっこ悪いのは日本への嫌がらせなの？
Haskell作者しぬの？

どっちかというと問題があるのはREVERSE SOLIDUSがYEN SIGNに見える日本人の方では

>>128
バックスラッシュの方が使ってはいけない領域を
制御記号として使用したのだから非があるのでは。

使ってはいけない領域とはいったい

では
では

あたし、むしろバックスラッシュより￥マークの方がカッコイイと思う

バックスラッシュってパールみたいで嫌い

>>130
ローカルに自由に使用するべき文字領域を。

λという字はλとλが……合って……

人使えば解決

>>129
ラムダを制するものは稼げるエンジニアになれる、ということ。

>>132
おっさんプログラミング板くんだりまでやって来てネカマすることないだろ

既定とは異なる順序で比較したい時ってどうする？
data Ordered a = Ordered (a->a->Ordering) a
instance Ord (Ordered a) where
compare (Ordered compare' x) (Ordered _ y) = compare' x y
って型を新しく作る？

>>126
value :: [Float] -> [Float]
この型でいいの？

諸君、議論したまえ

>>138
既定とは異なる順序で比較というのが今ひとつ分かりません。

データ型の定義時に Ord クラスを deriving するのが、
既定の順序で比較することに当たるのでしょうか。

そうであれば、既定とは異なる順序で比較するのは、
単に Ord クラスのインスタンスを自身で定義する事に当たると思いますが、
質問の例をみると、どうもそのような単純な話ではなさそうですね。

まず、どのような時に既定とは異なる順序で比較したくなるのか、
そのケースを例示していただけると、応えてくれる方が増えると思います。


あと、余計なお世話ですが、直感に反した不自然な計算（比較）を定義すると、
やっかいなバグに繋がりやすいので、注意が必要です。

>>139
除算の型は　(/) :: Fractional a => a -> a -> a　です。

length :: [a] -> Int
は、IntがFractionalのインスタンスではありません
fromIntegralを使うなどして型を合わせましょう

どこの学生さんだろう。ひどい教え方されてんなあ。

>>141
あるアルゴリズムがあって
有限個のデータ(具体的には関数記号)に適切な順序構造を与えたときに停止して適切な結果を返してくれるのですが
その順序構造を探すためにプログラム中で順序を動的に変えたいです
http://ja.wikipedia.org/wiki/%E3%82%AF%E3%83%8C%E3%83%BC%E3%82%B9%E3%83%BB%E3%83%99%E3%83%B3%E3%83%87%E3%82%A3%E3%83%83%E3%82%AF%E3%82%B9%E5%AE%8C%E5%82%99%E5%8C%96%E3%82%A2%E3%83%AB%E3%82%B4%E3%83%AA%E3%82%BA%E3%83%A0

>>143
これじゃだめなの？
http://www.wdic.org/w/TECH/%E3%82%B7%E3%83%A5%E3%83%AF%E3%83%AB%E3%83%84%E5%A4%89%E6%8F%9B

>>143
データと、それに付随する優先順位をペアにして持つ、
という単純な方法ではやりにくい、あるいはマズイですか？

>>145
data Ordered a = Ordered [a] a　　　-- [a]は優先順位を表現したリスト
ということですね？
同じく今はこれで行こうと思っています

>>146
いや、本当は違う事を言ったんだけど・・・

私は Data.IntMap a でキーを優先順位に、
a 型をそのデータにしたものを想像してました。
>>143 の状況がよく分からなかったので、
たぶん私トンチンカンな事言ってます。

あ、それか (優先順位 :: Int, データ) というタプルを想像してました。

>> 142
ありがとうございます。出来ました。
つまり、除算の時はFractionalクラスじゃなきゃダメでその為に適切な数値に解釈してあげる必要があると。

>>148は>>144だな

>>149
すみません。どういうコードになったのか、差し支えなかったら、
もう一度載せてください。

>>151
ave :: [Float] -> Float
ave (x:xs) = (sum (x:xs)) / (fromIntegral (length (x:xs))) -- length -> Int, which is not fractional
このようになりました

λをつかったら無駄が無い

>>152
ちゃんと､思った通りに動いているか、確認した？
特にvalueの方

GHCじゃないのかな使ってるの

>>154
なんとか動いてます。
value :: [Float] -> [Float]
value [] = []
value (x:xs) = case (ave (x:xs) /= 0) of
True -> (x/ave (x:xs)) : value xs
False -> []

ave :: [Float] -> Float
ave (x:xs) = (sum (x:xs)) / (fromIntegral (length (x:xs)))
ave [] = 0

>>156
いつの間にか全然違うではないかw

なにその強引すぎるパターンマッチ　禿げるわ

最近は初めてのプログラミング言語にHaskell選ぶのが流行ってるのか

普通にまずJavaでもやっとけば良いのに
初心者ほど最強言語とか訳分からん理由で選ぶからな
挫折する姿が目に浮かぶようだ

>>156
ありがとうございます。

>>159
はい。それが王道となりつつあります。

やっとHaskellも上に出てるようなクソコード製造機になれるのか。胸熱だな

C言語の某定番教科書はポインタと構造体の解説が延々と続く。

正直、あんなもの勉強するくらいなら最初からHaskellでリスト処理を学ぶ方が良い。

>>157
そこは勘弁。
>>158
華麗なコード書きたいけど、どうしても無理。
ラムダに行く前にまだまだ練習が必要だと思う。

>>164
まあ、C の言語仕様はシンプルだからな
はっきり言って、知的好奇心をそそるものではないよね
C++ の template は、そこそこ面白いんだけど、実践言語であれは無いだろとも思う

Haskellでスペースリークを潰して廻るのは
Cでメモリリークを潰して廻るより苦痛だけどな

まあトイプログラムで遊んでるレベルじゃ関係ないけど

value xs = map (/ ave xs) xs
ave xs = sum xs / fromIntegral (length xs)

えっ、Haskellでトイプログラムじゃないプログラムを書いてる人なんて居るの？

>>168
残りリスト要素の平均じゃなかったの。

>>170
そうだったな、すまん
value xs = zipWith (/) xs (map ave (tails xs))

>>164
>C言語の某定番教科書はポインタと構造体の解説が延々と続く。
どれ？

ポインターを考えなくてすむ代わりに別の追加の概念注意しなきゃならないなら
俺はよりコンピュータの本質に近い方を選ぶ

let ! や $! や $!! でサンクを潰して廻るのは
コンピュータの本質に近く無いと申すか


確かにそうですね

>>173
そのコンピュータというのがハードの事なら、より近いのはC言語だな
もし計算を意味するのならHaskellの方が近いな

ほう、ループよりも再帰の方が計算の本質にちかいと申すか？
たんなる理論的なからくりだろう＞再帰

本質なんて言葉を使ったらダメだよ。

チューリングマシンとラムダ計算のどちらが本質か、だなんて誰にも決められない。

本質言うならCPUと密接なCに決まってる

CPUが本質だってんならループでも再帰でもなく条件ジャンプが本質だw

>>176
そもそも自然数が再帰の構造なんだから

ペアノの公理も単なる理論上のからくりというか‥‥実用上でなにかうれしいことでもあるのか？

>>181
自動定理証明に応用できる

お前らってアセンブラやったことないの？

アセンブラみたいな具体的さが本質なのか、抽象が本質なのか、誰にも決められん。

最近流行ってるのは抽象による形式手法だけど、C言語ベースでの形式手法も研究されてるし。

抽象の方が変更に強いからな。
実践では抽象しないと開発が間に合わないんだよね。

ソースが紛失して2000年問題のときに機械語編集してた思い出

>>186
マジで？！

それはSys/370（互換機）の機械語かな？

プログラミングをコンピュータと人間との通信と考えると、言語列の長さとその通信の平均誤り率いう視点から機械語と高級言語に本質的な違いが出てくる

>>184
本物の形式手法は抽象度の高い仕様から
Adaサブセットやアセンブリまでをカバーして
それぞれのレベルでテストや証明をした上で
相互にトレーサブルにする。

つまり、どっちも本質。

コンパイラやリンカのテストや証明もつくのかそれは本格的
C/C++等の抽象度が低い、というのが今ひとつ理解できないのだが、この場合の抽象度とは何を意味するのだろうか？
言い換えるとC/C++でも抽象度が高い記述があるのだろうか？

抽象度が高い＝ての込んだ複雑な「からくり」がついただけ、という史観はそろそろカビが生えてきたようだ‥‥

C言語だと、式の世界は比較的に抽象度が高い。
副作用のない関数と式の組み合わせで書けるものはそう書いたほうが良いね。

>>192
fortranの設計者（バッカス先生）はチューリング賞講演で、
fortranの中で意味があるのは代入文の右辺だけだと言ってた。

抽象度が高いってのはそれだけレイヤ踏んでるんだからハードウェアの本質から遠ざかってるだろ

レイヤ？それは計算モデルではなく実装の話だろうが。
計算モデルにはレイヤなんて概念は存在しないw

だから実装の話だよ何聞いてんだ
実装に実装を重ねてハード寄りの泥臭さから遠ざかったところに高級言語があるんだから
ハードウェアの本質がそこにあるはずがないって話

ハードは泥臭くない
ゲーデル数が数学の定理に比べて泥臭くないのと同じ

むしろ洗練されている

例えばI/Oポートにアクセスしたあとnop並べないといけないじゃない
そういうのが洗練されてるって言うつもりでいる？

>>198
高水準言語で見ればnop並んでる
最も低水準の機械語で見ればコードの端から端まで2進数というたった一種類に抽象化された数が並んでるだけ

それは屁理屈だよ

Haskellスレはマ板に移った方がいいな

アホを構う大馬鹿がいるからな。

↑

コンピュータが人間だったら、機械語こそがもっととも抽象化されてて自然言語にもっとも近い言語なんだよね？

自然言語が上手く抽象化されてるとは限らなくね
最強の俺言語として生まれたハングルを指して言ってるならあれだけど

コンピュータ人間にとっては、自然言語(機械語)こそが最高に抽象化された言語
語の列を元と同じ動作をする範囲で抽象化して再び提示しても元の語の列になるという意味で

語の列が抽象化という作用により不動になるプログラミング言語を完成させたとき、その言語は機械語と同型である

誰か>>206を翻訳してくれ
日本語で書いてあるはずなのに、意味が分からないんだ

あるプログラミング言語の任意のソースコードを同じ動作をするように抽象化したら、元のソースコードと変わらない
そのプログラミング言語は機械語である
ゆえに機械語こそが最高に抽象化された言語である

機械語は抽象されてるよ
実際、機械語の操作的意味論の美しさといったら…

言葉遊びと拡大解釈はファウルだよ

>>208
はっきり言って、なにを言っているのかわからない。

また始まるのか

いつもの人かな？

いつもの人というのは俺の事なんで、そいつは別人だ

>>214
匿名とはいえ、失礼いたしました。(_O_)

>>214
何とかしてくれよ

拡大解釈＝抽象化
言葉遊び＝プログラミング

ほらつまんないレスするからスレ止まったじゃん

Monadのインスタンスにしたら自動的にFunctorやApplicativeのインスタンスにしてくれる機構ってある
無いよね？

【議題】
Monad ⊂ Functor みたいにサブクラス宣言があればいいのに

そんな宣言が有ったらreturnが要らない子になるだろ！

要らないなのはどう見てもfailの方なんだが
なんだそれふざけてるの

return はいらない子
むしろ有害

ﾎﾟｶｰﾝ

*Main> (\m -> m (++"z")) . runCont $ do { x<- Cont $ \f -> f . f $ "a"; y<- Cont
$ \g -> g . g $ "b"; return $ x++y; }
"aabzzaabzzbzz"
色々実験してるけどContモナドが継続の意味も含めさっぱり分からない…

ttp://pllab.is.ocha.ac.jp/~asai/cw2011tutorial/
これのHaskellの部分は見た？

ありがとうございます
良さそうなpdfをリンクから見つけたので読んできます
http://pllab.is.ocha.ac.jp/~asai/cw2011tutorial/main-j.pdf

リワハ以上専門家未満のライブラリ教えろ

うっさい

>>228
リワハのライブラリって何？

リアルワールドハスケルのことだろう

いや、だからリアルワールドハスケルの「ライブラリ」って何よ

Bloom filterより複雑めなアルゴリズムとかじゃね（適当
まあ接続詞が1つしかない文章にこれ以上突っ込んでも仕方ない気がするけど

ごめんなさい

なんで謝る？もっと謝って

／⌒ヽ　　　　ごめんなさい
く/･�� ⌒ヽ
| 3 (∪￣]
く､･�� (∩￣]

可愛らしい顔文字だというのは分かるが
2ちんこ1金玉だな

　／⌒ヽ　　　　ごめんなさい
く/･�� ⌒ヽ
　| 3 (∪￣]
く､･�� (∩￣]

Prelude> let f a b c = (a,b,c)
Prelude> f 1 2 3
(1,2,3)
Prelude> (1 `f`) 2 3
(1,2,3)
Prelude> (`f` 2) 1 3
(1,2,3)
Prelude> let g = (`f` 2)
Prelude> 1 `g` 3
(1,2,3)
Prelude> let h = (`g` 3)
Prelude> h 1
(1,2,3)

(`f` y) x === x `f` y === f x y
ったりめえだとしか言い様がないんですが
あと、
f = (,,)

何を主張したかったのかがわからない

HaskellやっててCategoryの勉強し始めた奴っている？

-- n ^ 2 steps
rev :: [a] -> [a]
rev (x:xs) = rev xs ++ [x]
rev [] = []

-- n steps
reverse' :: [a] -> [a]
reverse' = foldl prefix []
where prefix xs x = x : xs

foldr, flodlの働きがいまいちわからない。

チラシの裏に自分の手で簡約の様子を書くことを面倒くさがると何も理解できん

わかった。やってみる.

foldlをfoldrで書けたら単位認定

効率を考えなければreverseやって引数の順番変えればOK

foldrの末尾再帰放棄してまで欲しいものって短絡？

アキュムレータ使いたがるのは駄目なのか。
haskellの人は賢くてポイントフリーや既存の関数を使いまわすのが得意な人が多いせいか、
他人のコードはperlのワンライナーに似た難読性がある。

遅延評価だから、リストを受け取って、その先頭を見て目的のリストの先頭だけ作って、
残りは自分自身に再帰、みたいな構造にしたほうがいいよ、という仕掛け。

でも慣れるまでは気にせずLispやMLでやるみたいに補助変数に溜め込むコードを
書いてればいいんじゃないかと思うけど。

foldrなら短絡とアキュムレータ両方同時に使えるよ

原始再帰関数とfoldrとの関係を答えられたら単位認定

ぱらもるふぃずむ

Windows2000に対応してますか？

まず Windows2000 を探してきます

まてよ、Windows2000を定義するほうが先だろ

Windows2000，副作用なしで定義できるもんかね？

致命的なバグがなくならなかったという意味でWindows2000はまだ完成していない

Haskellに限った話じゃないけど
HaswellでTSX実装されたらソフトウェアトランザクショナルメモリは要らん子になるの？

http://www.isus.jp/article/transactional-synchronization-in-haswell/
手始めにSTMに組み込まれるんじゃね？

intelさんは両方やってるみたい。
http://csl.stanford.edu/~christos/publications/2007.tm_tutorial.pact.pdf

http://software.intel.com/en-us/articles/intel-c-stm-compiler-prototype-edition

>>259
TSXでSTMも速くなりますけど?

でもそのネタGHCのproposalにあがってないんでしょ？
予定は未定で予定ですらないのは当分実現しないって事だ

話題は？

>>264
そんなの待ってても来ないよ
自分で探せ

探す気がないんなら、これでも解読してろ
Wormholes: Introducing Effects to FRP
http://haskell.cs.yale.edu/?post_type=publication&p=802

学生に実装を手伝って欲しいリスト(GSoC)
http://hackage.haskell.org/trac/summer-of-code/report/1

何このリスト

アイデア閃いだけど実装面倒いからお前らやってくんない?
あ、でも閃いたのは俺だから、そこ忘れずに

ってやつか

閃いたとかどうでもいい。

大学って、誰が最初に閃いた(と発表して認められる)かでもめる所じゃないの?

閃きだけの研究なんて皆無に等しい。

聞いてくてださい、質問です。

未だに Arrow がよく分からないのです。
再帰を表現するために ArrowLoop クラスがあるそうなのですが、
具体的にはどのようにして再帰を作るのでしょうか。

例えば階乗を計算する Int -> Int 型の関数を loop 関数を使って作るとしたら、
どのような式になるでしょうか。

>>271
>再帰を表現するために ArrowLoop クラスがあるそうなのですが、
再帰というより、ループのある回路を実現する
モナドでいうMonadFixみたいなもの

>例えば階乗を計算する Int -> Int 型の関数を loop 関数を使って作るとしたら、
それは例題がおかしい。やろうとしてることがArrowと関係ない
一応、関数アローを無理矢理使って書けなくもないけど

fac :: Int -> Integer
fac n = loop f n
　where
　　f (k, g) = (g k, \x -> if x <= 0 then 1 else fromIntegral x * g (x-1))

>>272
> 再帰というより、ループのある回路を実現する

それが主なんですか。

私が勉強して感じたところでは、Arrow というのは Monad と同様に
「計算」というものを抽象化して捉える見方のひとつ、こちらが本質だと思ってました。
ループというのは、再帰でループも表現できる、という感じで二次的なもの、だと。
(直感では Haskell にループという概念は似合わないような気がしてならないのですが)

> それは例題がおかしい。やろうとしてることがArrowと関係ない

私は何か重大な思い違いをしているっぽいので、
今のうちに頭をリセットして勉強しなおしてみます。

ありがとうございました。

java にsyntax シュガーを追加した言語を追加したいんです。
コンパイラ書くなら　パターンマッチがある　ocaml, f#, scala, haskellだよね、と思って検討中なのですが
haskellで書くのはヤメテおいたほうがいいでしょうかね？

>>274
> haskellで書くのはヤメテおいたほうがいいでしょうかね？

そのように思ったのは、何か不安材料でもあったから？
ghc だって Haskell で書かれているから、理論的にはなんの問題も無い。
あとは慣れとか、コンパイラ作成の参考資料の充実さの問題だと思うよ。
その点で言えば、挙げられた4言語は資料あまりないね。
どれも似たりよったりだ。

不特定多数が気軽にいじれるようにしたいんで
I/Oの形見が狭そうなのは避けるのが無難かな、と思いまして

>>276
Haskellをメインで使って楽しんでいる立場の俺には、
IOの形見が狭いなどとは全く感じられないのだがな。

そもそもだ、コンパイラにおいてIOが必要なのはどこだ？
外部からコンパイルするソースや設定ファイルを読み取る部分と、
コンパイルされたオブジェクトコードを外部に出力する部分、
全体の処理のうちこの両端の部分しか思いつかない。

不特定多数が気軽にいじれるようにしたいのは、
IOではなく、その間の処理の部分ではないのか？

>>277
Haskellをメインで使ってるってパフォーマンスは満足いく？
haskellで使ってないはずのメモリ使用量が徐々に増えていかないサーバって書ける？
モナディウスもメモリ使用量の増加が止まらないわけだけど

monadiusは古い
今はmonaris

>>278
なにか勘違いをしている感じを受けるのだが・・・
別に仕事でメイン使っているわけではなく、
趣味で幾種類かの言語でプログラムを楽しんでいて、
その中でHaskellが一番面白いからメインで使っているだけだよ。

> Haskellをメインで使ってるってパフォーマンスは満足いく？

はじめ満足いかなくて、時間かけて根気よく改善していったことは度々ある。
その時の自分の力ではどうにもできないレベルまでいったと感じたら、
「今回はけっこう勉強になったな」と前向きに考えて、
そのテーマでは活動停止、あるいは休止する。

> haskellで使ってないはずのメモリ使用量が徐々に増えていかないサーバって書ける？

知らん、サーバーは興味ない。
サーバー上で動くWebアプリのフレームワークには多少興味あるが。

> モナディウスもメモリ使用量の増加が止まらないわけだけど

んなこと言われてもな。

モナディウスはなぜメモリ使用量の増加が止まらないんだ？
現時点で分かっている範囲で原因をリストアップしてみて、
その原因に関係有りそうな技術資料を ACM なんかで漁ってみてはどうだ。

あと、ゲームの実装なら、最新のFRPライブラリを使ってみてはどうだ。
『FRPの話』(http://maoe.hatenadiary.jp/entry/2012/12/24/011414)
ここの話だと、最近のはリークもかなら改善されているらしい。

>>278
横からすまん

>Haskellをメインで使ってるってパフォーマンスは満足いく？
それなりに。俺の経験だと、Cと張り合おうと思うと苦しい
(やってできないことはないと思うけど)
Cより2〜3倍遅い速度なら、ちょっとパフォーマンスに気を付けるだけで達成できることが多い

>haskellで使ってないはずのメモリ使用量が徐々に増えていかないサーバって書ける？
もちろん

>モナディウスもメモリ使用量の増加が止まらないわけだけど
それはバグ。Haskellは遅延評価のせいでうっかりspace leakを仕込みやすい
直せないspace leakはない。もちろん直すのも手間がかかるのでトレードオフだけど

>>280
原因不明のspace leakを直すのならまずプロファイルを取るのがいいよ
頭で考えたり論文を漁ったりしても滅多に役に立たない

space leakってどういう状況で発生するの？

>>283
http://itpro.nikkeibp.co.jp/article/COLUMN/20070403/267180/?ST=develop
（ライフラリの話は古くなってるけど）

直せないバグはない！

>>282
すまん、俺(>>280)の
> モナディウスはなぜメモリ使用量の増加が止まらないんだ？

これは、自分で理由を調べてみてくれと >>278 に促す意味なのだが・・・

そもそも、使ってないはずのメモリ使用量が徐々に増えていかないサーバは書けるかどうか、
という質問に添えられているからには、モナディウスでは増えていくのだが、
増えていかないようにはできるのか、それはサーバー作りでもできるのか、という問だろ。

だったら、まずモナディウスではなぜ増えるのかを調べるのが先だろ。
(そして、その原因と解決はサーバー作りに関係するのかを調べる)

で、それは他人に任せず、まずは自分で調べるべきだと思うぞ。
他人の疑問じゃなく自分の疑問なんだから。

>>286
>だったら、まずモナディウスではなぜ増えるのかを調べるのが先だろ。
その通りだけど、
>現時点で分かっている範囲で原因をリストアップしてみて、
>その原因に関係有りそうな技術資料を ACM なんかで漁ってみてはどうだ。
こういうアドバイスが的外れだと言いたかった

287は質問の意図を明確に伝えた方がいい
286がハスケルでどの程度の事ができるのか知りたいだけの質問じゃないのか？

Perl忍者最近みないな

>>288
俺(287,282)は質問してないよ

>>287
的外れだと分かるのなら、的は何なのか具体的に説明してみてくれ。

>>291
>>282に書いた

>>278 の聞きたいことって、モナディウスの原因不明のspace leakを直す方法じゃなくて、
space leakが起こる仕組みじゃないの？

モナディウス「も」と言ってるわけだし、モナディウスを例に出したのは、
そう言えば確かモナディウスもスペースリーク起こしてたよね、ってニュアンスじゃね

プログラムには二種類の時間がある

実行開始してから結果が出るまでの時間
プログラムが出来上がるまでの時間

役に立つか確信の持てないものを創る場合は後者を重視し
確信が持てたら前者を重視する

確信の度合いの変化に応じて最適化に注ぐ情熱の量を切り替える

この切り替えはときに道具を変えることも含まれる

確信を持つ主体はなにか？
プログラマか？所属組織か？社会か？
そして俺は何を言いたいのか？

またいつものキモいやつか

ライブラリをオフラインのスタンドアロンマシンにインストールする方法の解説ってどこかにありますでしょうか？

Real World Haskell のP80で詰まった。
concatを定義を使ってある関数を作ろうとしたんだけどエラー出てワケワカメ。たすけて
concatenate :: [[a]] -> [a]
concatenate list = case (list) of
[] -> []
(x:xs) -> x ++ concatenate xs

concatenate' :: [[[a]]] -> [a]
concatenate' list = case (list) of
[] -> []
(x:xs) -> concatenate x ++ concatenate' (concatenate xs)

>>297
> (x:xs) -> concatenate x ++ concatenate' (concatenate xs)
(x:xs) -> concatenate x ++ concatenate' xs

じゃない？

>>298
ありがとう！何でconcatenate関数を使ったんだろう？
気を付けます。

名前が一々長いとワーキングメモリを圧迫するから

haskell は名前にハイフン使えないのが不満なんだけど、どうにかならない？キャメルノーテーシヨンだと名前が長ったらしく見えるんだけど。

アンダースコアじゃなくてハイフン？普通使わないと思うが……

LISP組の人はハイフン使う

「普通使わない」ってすごいな
「使えないのが不満」に対して何も答えてない

解決になってないだけで答えてるじゃん

Agdaも割りとハイフン使う

演算子間に空白を開ける必要性とのトレードオフ

>>307
おれは演算子間のスペースは空けとかないと不安でしかたない

アンダースコア使えばいいじゃん

アンダースコアはハイフンが使えないから仕方なく使うものだよ。英文でアンダースコアなんてめったに使わないでしょ。
do-something
doSomething
do_something
明らかにハイフンが自然。異論は認める。

>>310
スペースの代わりだと思っていた。

でも x:xs って書きたいでしょう？
x : xs はマヌケ

マイナスとハイフンをいっしょくたにしたASCIIが悪い

外国人もときどき ! と 1 の区別がつかなくなるからそれは仕方ない

それより、単項マイナス演算子が普通には使えない仕様をどうにかしてほしいのだが

無理じゃね？
単項演算子と二項演算子のどちらの可能性もあって
しかもカリー化もあるんだから

SMLみたいな、~を単項マイナスにすればおk、というのが多分機械可読テキストとしては
一番エレガントな解決法だけど、HMI的には微妙。

AgdaのmixfixをHaskellにもくれ

>>312
おれはスペース空けたい派。x:xs って書くと窮屈。

わかる　目が寄る

>>310
うん。
けど海外でdoSomethingの書き方が嫌いな人はdo_something使ってる。

Haskellはアンダースコアの関数とか殆どないし、他の記法と揃えるようにしてるな

ハイフンは減法演算子にとっておく。
アンダースコアはスペースの代わり。
記号前後のスペースは必要。バグが極端に減る。入れない奴は自己中の証拠と知れ。

(x:xs) を ( x : xs ) と書くことで「バグが極端に減る」証拠があるなら見せてくれ。

↑
ぱっと見、x:xsとxxsの違いがわからない
スペースあけないのはバカかゴミだけ

標準ライブラリ書いてるのはバカかゴミ

ソースを見る時、たいていは記号と識別子の色は分けて表示されるから、
実際のところ、ぱっと見x:xsとxxsの違いが分からないなんて事は無いな。
(見やすい等幅フォント使ってるし)

でも、言いたいことは分かる。
Haskellで使う全ての記号についてというのは言い過ぎだが、
記号と識別の間を開けた方が見やすい場合は少なくないね。

あと、バカとかゴミとか、なに興奮してるのか知らんけど、もう少し落ち着いて

ものによるな
x:xsはもうひと固まりとして認識できるレベルで頻出だから空けない

>>328
良いこと言うね、同意。

>>326
ひどい（ひどいよぉ）

>>331
>>326 は皮肉だろ

標準ライブラリをざっと見てみると、パターンとして現れる場合は (x:xs) とくっつけて、
式として現れる場合は x : xs と離している傾向があるような気がする。

好きにすりゃええがな

>>332
>>331 はアニソンの歌詞だろ

>>334
すまん、それは知らなかった

いいってことよ

Haskellでキーボードの←→キーが押されたらその方向にキャラが歩いてすばやく2回同じキーが押されたらその方向に走って
↑キーが押されたら押され続けた時間に応じてキャラが小ジャンプ、大ジャンプするサンプルください
GHC platformのみインストールされた環境で動くもので
画面描画のバックエンドはopengl+glutでお願いします

Grahpics.UI.GLUT の KeybordMouseCallback のサンプルとドキュメントが入ってたはず

x :xs

Q:-P

The Glorious Glasgow Haskell Compilation System, version 7.4.2を使っています。
uniq :: Eq a => [a] -> [a]
uniq [] = []
uniq [x] = [x]
uniq (x1:xs@(x2:_)) | x1 == x2 = uniq xs
| x1 /= x2 = x1 : uniq xs
というコードを書いてコンパイルすると、
retu.hs:27:1:
Warning: Pattern match(es) are non-exhaustive
In an equation for `uniq': Patterns not matched: _ : (_ : _)
と言われます。
このuniqの定義は自分にはexhaustiveに思えるのですが、
何か見落としているのでしょうか。

GHCだと問題ないけど

>>341
こちらも、ghc 7.6.2 で問題なかった。

>>341
パターンじゃなくて、ガードに問題がある
== と /= ですべての状態をカバーしてると思われてない

uniq :: Eq a => [a] -> [a]
uniq [] = []
uniq [x] = [x]
uniq (x1:xs@(x2:_))
| x1 == x2 = uniq xs
| otherwise = x1 : uniq xs

でok

あるいは /= の実装で otherwise を使えばokかと

せやな

なるほど、ありがとうございます
確かに==と/=だと、それぞれの演算子の意味を解析しないと
exhaustiveかどうか分からないですからね

/=の実装がotherwiseとおっしゃっているのは、
f x | hoge x = True
　　| otherwise = false
notF x = not $ f x
のような実装をすればパターンマッチで判定が出来るから、
という事ですか?

Grahpics.UI.GLUT の KeybordMouseCallback のサンプルとドキュメントがどこにあるのかみつかりまふぇん（；-；）

>>347
ドキュメント
http://www.haskell.org/haskellwiki/OpenGLTutorial1
http://www.haskell.org/haskellwiki/OpenGLTutorial2
http://www.cs.hs-rm.de/~panitz/hopengl/skript.html
http://www.renci.org/wp-content/pub/tutorials/BeautifulCode.pdf
http://www.cin.ufpe.br/~haskell/hopengl/

サンプルは
The OpenGL Programming Guide: The Official Guide to Learning OpenGL
と
The OpenGL Shading Language
の中の例題の一部に対応するサンプルがGLUT-2.4.x.xのexamplesフォルダの中に入ってる

わーいありがと

(3::Int16) ← 一々括弧付けなきゃならないのがウザい

Int16を値に降格できて
asTypeOf 3 Int16
とかできたらいいのにな

前スレッド http://tech.log2.me/1358702176_900.html >>961
に書いたパルズ解答ソフトについて。
Haskellに慣れるための習作として作っているけれども。
計算時間は、目標…2秒以内に到達。C++版より多少遅い程度まで改善させた。

ソースコードサイズ(未参照コード含む)
C++版 167kB
Haskell版 54kB(3月中旬版)
Haskell版 68kB(5月前半版)

計算時間
C++版 1.77秒
Haskell版 38.2秒(3月中旬版)
Haskell版 1.93秒(5月前半版)

プロファイル機能は役にたった。
予想外に演算負荷を使っていたところがあった。

これで、Haskell に慣れたと言っていいかな。
次に本番…ゲーム作成に取り掛かりたいと思う。

haskell始めようと思ったもののGHC.exeが開かないんだけど
バイナリパッケージをダウンロードするだけだよね
もしかして他に何か必要なファイルとか他にあるの？

ない

ありがとう
もう一回ダウンロードしてみる

.exeってことはWindowsでやろうとしてるのか。
単純にGHCをインストールするよりHaskell Platformをインストールしろと公式が推奨してるだろ

というかそもそもGHC.exeを開くってなんだ？　何がしたいんだ？　訳がわからんぞ

バイナリパッケージってPlatformのことじゃなかったのか・・・
それならだめだ

入力した名前に対してイニシャルを返す関数
initials :: String -> String -> String
initials firstname lastname = [f] ++ ". " ++ [l] ++ ". "
where (f:_) = firstname
(l:_) = lastname
ってソースをコンパイルして実行
ghci> initials hoge poyo
って入力すると,
Not in scope: `hoge'
Not in scope: `poyo'
と出て詰んでます...すごいH本通りの記述ですし見る限りwhereのスコープ内だと思うのですが...

ghci> initials "hoge" "poyo"
だろ

プログラミングなんてやめて別のことした方がいいよ

>>359 ありがとうございます>< お恥ずかしい限りです

初めての言語がHaskellなのか？
高度な変態だな

下手に他の言語の知識ないほうが覚えやすいという可能性も

始めての言語が haskell って凄いhaskell モンスターに育ちそう。頑張れ！

C++とかやらせたらすごい富豪PGやらかしそう
てかまず一流のメモリリーカーになりそう

もうそろそろプログラマにメモリのことを考えさせる時代が終わってもいいはずだ

ノイマン型が続く限りメモリ関連の悩みは尽きることはない

いつから非ノイマン型でメモリ関連の悩みが消えるかもしれないと錯覚していた？

クラウドベースになればjavascriptあたりがCに取って代わるからとりあえず自前のメモリ管理は不要になるかと

別にクラウドベースにしなくてもガベージコレクションがある言語を使えば同じことじゃん
例えばHaskellとか

俺ならせめてerlang薦めるな

クラウトベース（）

圏XのT代数X^Tと
圏Xのクライスリ圏X_Tは
互いに圏論的双対？

定期的に再起動で解決

メモリも管理できないような奴が優れたプログラム書けるわけなかろう

優れたプログラムを書く必要はない
優れたアイデアをスマートに表現したいだけだ

型システムに頼るような奴が優れたプログラム書けるわけなかろう

え？

>>376
機械語で書くのが一番スマートな表現だと思うぞ。

>>377
一発完動的な意味でかな？

もう一度言うぞ。
型システムに頼るのはダメな奴。
あと、エディタとかコンパイラ使う奴もな。

バイナリエディタも使わないのか

どうせならコンピュータも使うなよなw

お前は機械語でプログラミングするとき
インダイレクトアドレッシングモードは決して使わずに
プログラム自己書き換えとダイレクトアドレッシングモードで対応してるのかよ
機械語命令セットにインダイレクトアドレッシングモードを導入するのはある種の抽象化なんだよ
Haskellの場合はその抽象化の度合いが常人には理解できないレベルまで昇華してるだけ

フィールド名とか構造体とか、型システムに頼り過ぎだ。

あれだな、サブルーチンも、callとreturnを使わずに、レジスタで帰り番地を渡して
ジャンプ命令のオペランド自己書き換えで戻るんだよな。

本物のプログラマはコアダンプを読める

俺は飲み会のあとよくコアダンプするよ。

型システムがデバッグに役に立つなんて懐疑的だった。
ところが、不思議なほど、型がチェックして問題を弾いてくれる。めんどくさい、と最初は思ってたけど、慣れると実にいいね。
少なくとも型に関しては人間だと見逃す矛盾を確実に防げる道具、としてはオレは型システムに頼ってる。

>>387
コアファイルはちゃんと調べるのか？

>>388 みたいなことをいう人の90%は
強型に懐疑的だったことなんてなくて
最初から強型を使っている信者さんだよ

>>389
えー、おれのよく使う言語ってperlとCommon Lisp なんだけど。型信者じゃないよ。
それに型検査がめんどくさいなぁ、とは思ってる。うまく言えないが、自分がプログラム書いてるというより、書かされてるような感じはある。

zipやzipWith のかっこいい応用方法を教えてください。

型は書き方を強制するためのものだからね。

カタカタ言ってないで早くコード書けや

カタカタ

forall の指定がどのような場合に必要なのか、未だによく分かりません。
役割や使い所などが詳しく書かれたWebページはありますか。
英語でも構いません。

ちなみに「本物のプログラマはHaskellを使う」の説明は難しくて理解出来ませんでした。
http://itpro.nikkeibp.co.jp/article/COLUMN/20080603/305833/?P=2

型の一番外側や内側という表現がまず分かりません。
例えば f :: a -> b -> c という関数の場合、a は外側でしょうか、c は内側でしょうか。
また、applyTupleのfにおける多相性がapplyTuple自身に成り立つという表現も分かりませんでした。

分からない部分はとりあえず無視して読み進めましたが、分からない部分が次々と増えていくだけでした。

>>395
f :: a -> b -> c
と書いたら、
f :: forall a b c. （a -> b -> c）
という意味になる。つまりforallが型全体にかかる。これが「一番外側」の意味
これ以外の場所にforallが必要なら、明示しないといけない。例えば、
f :: forall a c. (a -> (forall b. b) -> c)

>>396
すいません、違いが分かりません。

f :: forall a b c. （a -> b -> c）
f :: forall a c. (a -> (forall b. b) -> c)

前者では認められる定義（関数の内容）が、後者では認められない定義やその逆など、
具体例を出していただけると嬉しいです。

>>397
このばあい、どっちにしてもまともな定義は与えられないから、
使う側で比較した方が分かりやすいと思う
(f True True)は、前者ならOK、後者なら型エラー(Trueはforall b.bでないので)
(f True undefined)なら、前者でも後者でもOK

>>398
せっかく例を説明していただいたのに、申し訳ないです。
よく分かりません。

> Trueはforall b.bでないので

前者の関数も b について forall なのに何故？　と疑問に思ってしまいます。
(b だけではないのですが)

forall は全称量化で、全ての〜について、という意味ですよね。
後者の関数で、全ての〜について、と言っているのは a も b も（c も） だと思うのですが、
なぜ a に対する「全ての〜について」の「全て」の中には True が含まれていて、
b に対する「全ての〜について」の「全て」の中には True が含まれないのでしょうか。

>>399
(forall a. a -> a)という型を持つ値があったとすると、その値は
(Int -> Int)としても、(Bool -> Bool)としても、([[Int]] -> [[Int]])としても、使えないといけない
だから、例えばidはこの値を持てるけど、notは持てない

つまり、
f :: (forall a. a -> a) -> Int
というfがあったら、fにidを渡すことはできるけど、notを渡すことはできない

一方、
f :: forall a. ((a -> a) -> Int)
なら、fを((Int -> Int) -> Int)としても、((Bool -> Bool) -> Int)としても、…使えることになるので、
fにnotを渡せる(もちろんidも)

クラスがいまいちよくわからない。Fractional は　Numのサブで、EqはNumの親でいいの？
f :: (Num a) => a -> a -> a
f x y = sqrt (fromIntegral (x +y))
でNumでもEqでもダメ。

そこはIntegralかと

forall：『（型の）特定は許さない』ルール

f :: (forall a. a -> a) -> Int
a -> a の特定は許さない
だからnotのようなTrueしか扱えないような特定したものをfへとるのは許さない

f :: forall a. ((a -> a) -> Int)
(a -> a) -> Int の特定は許さない

利根川「ここでnotを使う」

カイジ「ちょっと待て！　notはTrueに特定しているじゃねぇか！」

利根川「くくく……確かに。a -> a に関してはTrueで特定している。
　　　　だが今一度確認して欲しい……。a -> a は確定したかも知れないが、
　　　　今回私は (a -> a) -> Int までは決して特定していないということを……」

カイジ「……な！？　て、てめぇ！　汚ねぇぞ！　同じことじゃあねえか！」

利根川「浅い。……浅いなぁ、カイジ君。
　　　　君はこのゲームのルールをまるでわかっちゃあいない」

カイジ「」ざわ……ざわ……

>>403
すいません、これでも、まるでわかっちゃいない状態です。

> a -> a は確定したかも知れないが、
> 今回私は (a -> a) -> Int までは決して特定していないということを……

型変数 a に True を入れることで、(a -> a) -> Int の a -> a までは特定しているのですよね。
しかし、それでもなお (a -> a) -> Int までは決して特定していないという理由が
いまひとつ分かりません。


それと、確認なのですが、

> だからnotのようなTrueしか扱えないような特定したものをfへとるのは許さない
> くくく……確かに。a -> a に関してはTrueで特定している。

これらは、TrueではなくBool型の値ではないでしょうか。
つまり、TrueだけではなくFalseも、ということではないかと。
もし私の考えの方が間違っているのなら、私は根本から大きく勘違いをしているかもしれません。

>>395 あたりから読むと、
Haskellって難しいですね・・・
ということになる。

f :: forall a . (a -> a) -> Bool
f a = True

g :: (forall a . (a -> a)) -> Bool
g a = True

どちらの関数も、第一引数に関数を受け取り、Bool値を返す関数。
ただし、第一引数の解釈が異なる。

f の場合は、「どのような型の関数を渡しても良い」という意味。
それは (Bool -> Bool) でも (Int -> Int) でも。
だから f not は動く。　（なぜなら f は、「どのような型の関数でも受け取れる」、という定義だから）

一方 g の場合は、「”どのような関数でも受け取れる関数”、しか受け取りません」という意味。
「どのような関数でも受け取れる関数」とは、すなわち ∀ a => a -> a のみ。
それ以外の (Integral a => a -> a) や (Floating a => a -> a) などでは要求に合わない。
だから g not は動かない。　（なぜなら g は、「”どのような関数でも受け取れる関数”しか受け取れない」、という定義だから）

g not は動かないが、 g (\x -> x) ならば動く。
なぜなら (\x -> x) は、「どのような型も受け取れる関数」という型だから。 g が求めてる型に合致してる。
このラムダ関数に型を付けてしまうと、 g (\x -> x :: Int) 動かない。 「Int型しか受け取れない関数」を渡すことになってしまうので。

f の場合は、「どのうような型の関数でも受け取れる」という意味なので、 f not でも f (\x -> x) でも受け取ってくれる。
これが f と g の動作の違い。これが何に役立つかは知りません。

�@∀a
××× a => 〜


�A∃a
Num a => 〜
Ord a => 〜
　　　：

こゆこと？

∀←自由だ！　やった！

ではなく寧ろ

∀←自由で な く ち ゃ い け な いという 不 自由

的な？

制限することを制限する的な？

>>406
> 一方 g の場合は、「”どのような関数でも受け取れる関数”、しか受け取りません」という意味。

とても分かりやすい説明で、こんな私でも理解出来ました。

f の forall はこの関数全体に言及していて、
g の forall は第１引数として適用する関数のことのみ言及しているのですね。
これで内側や外側という言い回しも分かり、すっきりしました。

ありがとうございました。
今まで説明してくださった方も、ありがとうございました。
理解出来なくて申し訳なかったです。

>>406
> これが f と g の動作の違い。これが何に役立つかは知りません。

fの方は適用されている文脈によってaが限定されることがある。
gはそれを許さない。

>>402
Integral もダメなんだ。
Haskellのクラスややこしいな。
ところで、パターンマッチとガードの違いって、パターンマッチはタイプをチェックして、ガードは値をチェックの認識でいいの？

いいよそれで

>>408
述語論理で使う∀も同じ意味だと思うが

TSX命令が使えるようになったらSTMは単にTMと呼ばれるようになるのだろうか？ o(^-^)o

>>412
ありがと。

>>411
全然違う

あれ？違うの？
data Hoge = True | False

f :: Int -> Hoge
f x = if (x=2) then True else False
みたいにHogeタイプを確定してくれるものだと思ってた。

それパターンマッチかガードと何の関係あんの

>>417

412,416の意見に惑わされるな
他人の意見に惑わされるな



お前がどうするかだ！　お前がどう動くかだ！
お前がどうするかだ！　お前がどう動くかだ！！

決めるのは誰だ？　やるのは誰だ？　行くのは誰だ？
そう　お前だ！　お前が舵を取れ！
お前が行け！　お前が走れ！　お前が行くから道になる
前へ　前へ　前へ　前へ　ただただひたすら前へ突き進めばいい
わかるか！　わかるか！　お前が決めろ　お前がしっかり舵を取れ

舵取りはお前にまかせたぞ！

長渕かよ

手続き型は文系・バカ
関数型は理系・知的

という書き込みをみたらバカはなんて思うか
知的に憧れ関数型をやるに１万円

布教するための一例

・本物のプログラマはHaskellを使う
自信が無いプログラマや社会事情を知らない独学者の心のスキをついたキャッチフレーズ

・手続き型言語はオワコン、関数型言語の時代
IT特有の最先端の物を取り入れるという美徳心理をついたこと

・手続き型言語＝一般人　関数型言語＝変態
人と違うように思われたいという選民意識を釣ったこと

本物のプログラマはJavaで量り売り

>>420
お前が消えて喜ぶ奴にお前のオールを任せるな

手続き型と関数型の二択だと思ってる>>422がバカ

闇のProlog一族はどうぞ安らかにお眠りください

プログラムが組めないのですが誰か教えてください
2枚目を参考にしながら
よろしくお願いします
http://i.imgur.com/pqa6Bk4.jpg
http://i.imgur.com/R8FsYBJ.jpg

追記:(1)だけでいいです

>>417
パターンマッチは値コンストラクタをマッチさせる。その例だと
f 2 = True
f x = False
みたいに書くのがパターンマッチ
f x | x == 2 = True
| otherwise = False
みたいに引数の性質によって場合分けするのがガード
型を確定どうのは型推論の話だと初学者がマジレスしてみるテスト

アスペクト志向だかサブジェクト志向だかプログラミングってどうなったの？

たぶん純粋関数型よりは普及している

AOPはもうあって当たり前の技術

>>433
「あって」とは？

その辺のプロジェクトに

>>430
fって値コンストラクターなん？

違う

パターンマッチの例に2を使ってるのがイマイチなんじゃ。

comb :: Maybe a -> (a -> Maybe b) -> Maybe b
comb Nothing _ = Nothing
comb (Just x) f = f x

safeSqrt x
| x >= 0 = Just (sqrt x)
| otherwise = Nothing

こんな使い分け。

>>427
Prologと関数型言語は持ちつ持たれつ進んでいくのが一番いいよ。

AOP研究者は最近Feature Oriented Programming(FOP)に鞍替えしてると聞く

　　　　　　☆ ﾁﾝ　　　　　ﾏﾁｸﾀﾋﾞﾚﾀ〜
　　　　　　　　　　　　　　　　　　　　　　　　ﾏﾁｸﾀﾋﾞﾚﾀ〜
　　 　 　 ☆　ﾁﾝ　　〃　 ∧＿∧　　　／￣￣￣￣￣￣￣￣￣￣￣￣￣
　 　 　 　　ヽ　＿＿_＼（＼・∀・）　＜　Haskell Platform 2013.2.0.0 まだ〜？
　 　 　 　 　 　 ＼＿／⊂　⊂＿ )　　 ＼＿＿＿＿＿＿＿＿＿＿＿＿＿
　 　 　 　 　 ／￣￣￣￣￣￣ ／|
　　　　　　　|￣￣￣￣￣￣￣|　 |
　　　　　　　|　　愛媛みかん　|／

話題は？

オヌヌメの開発環境を教えて下さい

>>443
Emacs + haskell-mode

>>443
vim + hdevtools

hdevtoolsのウリは？

>>446
http://hackage.haskell.org/package/hdevtools

最近は何でもsublime text使っときゃ間違いないみたいになりつつあるから、
sublime textがいいかもな

>何でもsublime text使っときゃ間違いないみたいになりつつある
初耳だな

俺も初めて聞いた。
何でもかんでもvim使えとかemacs使えという人ならいっぱいいるけどｗｗ

sublime用のhaskellプラグインはemacsのhaskell-modeより開発が活発
hoogleとかghs-modには大分前から対応してる

haskell-modeはシンプルだから活発に開発する段階はとうに過ぎてるねぇｗ

haskell-modeはお世辞にも使いやすいとか、かゆいところに手が届くってわけではないが、
Emacs 自体が使いやすいから、haskell-mode の開発が止まっても、仕方なく使い続けてる。

Haskell で C# や Java みたいに GUI パーツをペタペタ貼ったり、
ロジックをグラフィカルに定義できる様になれば、専用の開発環境に移るかもしれん。
さすがに、そういうのが Emacs で気持よくできるようになるとは思えないからね。

マクロがhaskellで記述できるエディタってあったりするの？

義ってどうなったの？

>>455
http://hackage.haskell.org/package/yi-0.6.5.0
最終アップデートが2012年3月
それまでだいたい半年に1回くらいのペースで定期的にアップデートしてきたのに・・・

と思ったが、GitHub ではちょくちょく更新されてるから、開発は続いているみたい

俺は Linux だからいいけと、Windows で簡単にインストールできるようにならんと、流行らんな

話題は？

質問でも良かな?

>>459
どぞ

ありがとう。最近haskellを始めた。
haskell99の1~10をやっているのだが、9の問題で詰まった。

duplicateSet :: (Eq a) => [a] -> [a]
duplicateSet list = case (list) of
[] -> []
(x:y:xs)
| x == y -> y : duplicateSet (x:xs)
| otherwise -> [x]

deleteSet :: (Eq a) => [a] -> [a] -> [a]
deleteSet originaList set = case (originaList) of
(x:xs) -> case (set) of
(y:ys)
| x == y -> deleteSet xs ys
| otherwise -> error"Something wrong"
[] -> (x:xs)
_ -> error"Need at least one element"

pack :: (Eq a) => [a] -> [[a]]
pack list = case (list) of
[] -> [[]]
(x:xs) -> (duplicateSet list) : pack (deleteSet list (duplicateSet list))

どう詰まったのかとか、そういうのは」ないのかね

失敬。例えば、
*Main> pack [1,1,1,2,2,3,4,4]
[[1,1,1],[2,2],[3],[4,4],[]]
があったとき、どうすれば最後の[]を消せるのだろうか？
元をちょこっと書き足してみたのだが。
duplicateSet :: (Eq a) => [a] -> [a]
duplicateSet list = case (list) of
[] -> []
[x] -> [x]
(x:y:xs)
| x == y -> y : duplicateSet (x:xs)
| otherwise -> [x]

deleteSet :: (Eq a) => [a] -> [a] -> [a]
deleteSet originaList set = case (originaList) of
[] -> []
(x:xs) -> case (set) of
(y:ys)
| x == y -> deleteSet xs ys
| otherwise -> error"Something wrong"
[] -> (x:xs)
-- _ -> error"Need at least one element"

initを使う

>>463
[] -> [[]] を[] -> []
とするんだよ。

なぜ、[[]]が[]なのだろう？
[a] : [[]] -> [[a], ... []]にならないのだろうか？
[a]:[]はエラーな気がするのだが。

>>466
なぜ、[a]:[]がエラーだと思うの？

”:”の最初は”：”の後の要素でなければならないから。
例えば、[1]:[2] -> error. しかし、1:[2] -> ok　見たいな？
間違ってました。
[1]:[]は[[1]]になるんだね。(1:[]) -> [1]の延長見たいなものか。
ありがとうございます。

data [] a = [] | a : [a]

*Main> compress "aaabbbbvvvcccaaaddd"
"abvcad*** Exception: Documents/Haskell/excercise.hs:(15,56)-(19,59): Non-exhaustive patterns in case
何がたりなんだろうか。
compress :: (Eq a) => [a] -> [a]
compress list = case (list) of
[] -> []
(_:_) -> (findDuplicate list) : (compress (deleteDuplicate list (findDuplicate list)))
where
findDuplicate :: (Eq a) => [a] -> a
findDuplicate list = case (list) of
[] -> error""
[x]->x
(x:y:xs)
| x==y-> findDuplicate (y:xs)
| otherwise -> x

deleteDuplicate :: (Eq a) => [a] -> a -> [a]
deleteDuplicate list element = case (list) of
[] -> []
(x:y:xs)
| x == element -> deleteDuplicate (y:xs) element
| otherwise -> list

>>470
エラーメッセージ読めよ。

compress [] = []
compress (x:xs) = reverse $ foldl (\a y -> if head a == y then a else (y:a)) [x] xs

どうもすっきりしない…
[]を特別扱いしない方法はないでしょうか？

if head a == y then a else (y:a) だって、
head a と y が等しい場合を特別扱いしてるくせに・・・

ポイントフリーの達人の出番か

deleteDuplicateが list=[]の時、終了しないからNonexhaustiveになるんだと思う。
終了させるにはどうすれば良いかな。
試しに[x]->[x]入れたら無限に津尽くし。

yがいらんだろ。

compress&amp;#160;::&amp;#160;(Eq&amp;#160;a)&amp;#160;=>&amp;#160;[a]&amp;#160;->&amp;#160;[a]
compress&amp;#160;list&amp;#160;=&amp;#160;case&amp;#160;(list)&amp;#160;of
&amp;#160;[]&amp;#160;->&amp;#160;[]
&amp;#160;(_:_)&amp;#160;->&amp;#160;(findDuplicate&amp;#160;list)
&amp;#160;&amp;#160;where
&amp;#160;&amp;#160;&amp;#160;&amp;#160;findDuplicate&amp;#160;::&amp;#160;(Eq&amp;#160;a)&amp;#160;=>&amp;#160;[a]&amp;#160;->&amp;#160;[a]
&amp;#160;&amp;#160;&amp;#160;&amp;#160;findDuplicate&amp;#160;list&amp;#160;=&amp;#160;case&amp;#160;(list)&amp;#160;of
&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;[x]->[x]
&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;(x:y:xs)
&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;|&amp;#160;x==y->&amp;#160;findDuplicate&amp;#160;(y:xs)
&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;|&amp;#160;otherwise&amp;#160;->&amp;#160;x&amp;#160;:&amp;#160;compress&amp;#160;(y:xs)

------------------------------------
comp2&amp;#160;[]=[]
comp2&amp;#160;[x]=[x]
comp2&amp;#160;(x:y:xs)|x==y&amp;#160;=&amp;#160;comp2(y:xs)
&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;&amp;#160;|otherwise&amp;#160;=&amp;#160;x:comp2(y:xs)

ごめん、失敗した。

もうcompress のlistに[x]->[]で強制的に終わらせることにした。
できればcompress "f" > "f"みたにしたかったけど、いいか。
ありがとう。

(>>=take 1) . Data.List.group

deleteDuplicate :: (Eq a) => [a] -> a -> [a]
deleteDuplicate list element = case (list) of
[] -> []
(x:xs)
| x == element -> deleteDuplicate (xs) element
| otherwise -> list

質問。
getnameに入れる値の構造は(c,name,age)じゃダメなのでしょうか？
[Haskellで学ぶ原理と技法」の5章で躓いた。
data Person = Person {c :: Class , name :: String , age :: Int}deriving (Show)
data Class = Student | Teacher
deriving (Show)

type Name = String
type Age = Int
--data List = [Person]
getname :: Person -> Name
getname (_ ,name ,_) = name
getage :: Person -> Age
getage (_ , _ ,age) = age

後ほど[Person]を使って多くのデータを処理したいと思っています。
下のは動くけど、[Person]出来ないし、[（class, name, age)]だけにしたいし。
data Person = Person (Class, Name , Age)
deriving (Show)

data Class = Student | Teacher
deriving (Show)

type Name = String
type Age = Int

--data List = [Person]
name :: Person -> Name
name (Person (_,name, _)) = name

age :: Person -> Age
age (Person (_ ,_,age)) = age

>>482
> getnameに入れる値の構造は(c,name,age)じゃダメなのでしょうか？
> getname :: Person -> Name
> getname (_ ,name ,_) = name
型シグネチャの引数が代数データ型Personなのに、
パターンマッチしてるのがClass,Name,Ageからなるトリプルなので矛盾してる
正しくパターンマッチさせるには(Person _ name _)にする必要がある
またはtype Person = (Class, Name, Age) という定義にすればよい
でもそもそもレコード構文を使っているので
getname という関数を作らなくても name :: Person -> Nameという関数でNameを取り出せる

>>483
getname :: Person -> Name
getname (Person _ ,name ,_) = name
は最初に試したのですが、エラーを吐かれたので。
>正しくパターンマッチさせるには(Person _ name _)にする必要がある
確かに引数？としては(Person c, name, age)が正しいと思うのですが、
getname (Person _ ,name ,_) = name -> なぜかコンパイラーが通らない。

data Person = Person (Class, Name , Age)はname (Person (_,name, _)) = nameで動きました。
>getname という関数を作らなくても name :: Person -> Nameという関数でNameを取り出せる
確かにそうですね。
それと、ちょっと訂正。
data Person = Person {c :: Class , name :: Name , age :: Age}deriving (Show)

>>484
(Person _ ,name ,_) と (Person _ name _) は違うよ
()を,で区切ってあるのはタプルというPersonとは異なる型（リストみたいなやつ）だから

>>485
おお！出来た。有難うございます。
data Person = Person {c :: Class , name :: Name , age :: Age}deriving (Show)に
"," があったので引数のほうにも入れないといけないと思っていました。

関数の引数にカンマは要らんよ

data T = T {a :: A, b :: B, c :: C}
上は下の糖衣構文
data T = T A B C
a (T x _ _) = x
b (T _ y _) = y
c (T _ _ z) = z
ですが、上の定義にするとこんなことも出来る
f t@(T {b = y}) = t {b = g y}
-- f (T x y z) = T x (g y) z

エラーメッセージなんて英語なんだから
読みようが無いってのが実際だろうな
知ってる事が英語ならまだしも
知らない事を英語で書かれても
意味がわかるわけない

っ辞書

パスカルの三角形とか４次元モデル（立方体の中に立方体）をイメージしたら
なんとなく繋がりが分かってきた

カルノー図っての描ければ
なんとなく平面上で繋がりはイメージできた

>>487,488
なるほど。
data T = T {a::A, b::B, c::C}の時は引数にカンマがいらなくて、data T = T (A,B,C)の時は要るのか。
砂糖構文調べてみる。

>>493
勘違いをしていなければいいのだが・・・

data TT = T (A,B,C)と定義されたデータ型があるときに、
let a = T (1, 2, 3) みたいに括弧とカンマを使って記述することになるのは、
「関数（データコンストラクタ T）の引数がひとつのタプルだから」だよ

>>494
何か勘違いをしていたみたい。ありがとうございます。
もう一つ質問してもいいでしょうか？？
例えば、
data Person = Person (Occupation, ID, Name, Age)deriving (Eq, Show)
data Occupation = Student | Teacher deriving (Eq, Show)
type ID = Int
type Name = String
type Age = Int
type List = [Person]

record :: List
record = [Person (Student, 23281, "A", 20), Person (Teacher, 12037, "B", 29),Person (Student, 37823, "C", 18),
Person (Student, 24932, "D", 19),Person (Teacher, 12917, "E", 33)]
があって、recordのデータをageの若いもん順にした。
sort :: [Int]
sort (x:xs) = sort [x | x<-xs, x <= x] ++ [x] ++ sort [x | x<-xs, x > x]を参考にしたのですが”＿”のエラーがいっぱい。
別の方法もあるんでしょうか？
youngSort :: List -> List
youngSort list = case (list) of
[] -> []
((Person (_, _, _, age)):xs) -> youngSort [(Person (_, _, _, younger)) | (Person (_, _, _, younger)) <- xs, younger <= age] ++ [(Person (_, _, _, age))] ++ youngSort [(Person (_, _, _, age)) | (Person (_, _, _, older)) <- xs, older > age]

youngSort :: [Person] -> [Person]
youngSort list = case (list) of
[] -> []
((Person (a, b, c, age)):xs) -> youngSort [(Person (a, b, c, younger)) | (Person (a, b, c, younger)) <- xs, younger <= age]
++ [(Person (a, b, c, age))] ++ youngSort [(Person (a, b, c, older)) | (Person (a, b, c, older)) <- xs, older > age]

>>496
ありがとうございます。
何となく関数型が分かってきた感じがします。
頑張ってモナドまで行こっと。

,
◆じゃあのさん来た！◆
744:カミカゼ[]
2013/06/04(火) 21:38:46.58 ID:gQxj8a/C0
コングラッチュレーションｗｗｗｗｗｗ
ヒャッハーｗｗｗｗｗ
ようおまいらｗｗｗ俺だｗｗｗｗ
いいニュースだなあｗｗワールドカップ出場ｗｗｗ
本当にいいニュースだ
ただ、悪いニュースがある聞きてえかおまいら？

--- 以下スレ情報 ---
高岡さんがフジ韓流ゴリ押し批判したら干されたのでウジテレビ凸
http://hayabusa.2ch.net/test/read.cgi/news4vip/1370194661/

トリプルのコンストラクタ関数は(,,)です。
(x, y, z) == (,,) x y z
3つの引数を受けます。
data T = K (A, B, C)
K (x, y, z)
K ((,,) x y z)
このT型のKというコンストラクタ関数は一つの引数しか受けません。引数の型は(A,B,C)です。
このトリプルは別にいらない。なくして内容をKの引数にすればいい
data T = K A B C
K x y z
K (x, y, z) -- エラー。Kの一番目の引数は(A,B,C)型じゃなくてA型であるべきですから

僕は母語が日本語じゃないから変な文は許してね

>>499
どこの国の人？

Land of LISP

>>500
プログラミングスレであまり語るものにならないと思うんですけど
(まあそれを言っちゃったら最初からわざわざ日本人じゃないよーとは言うべきじゃないんですけどね)
と、ごちゃごちゃ言っといて
アメリカ人です

Haskell楽しいお

>>502
日本語上手すぎるだろ
日本に何年住んでいるの？

>>501
ご近所さんだな

木をリストから作りたいです。
data Tree a = Empty | Node a (Tree a) (Tree a) deriving (Show, Eq)
singleton :: a -> Tree a
singleton element = Node element Empty Empty

insert :: (Ord a) => a -> Tree a -> Tree a
insert element tree = case (tree) of
Empty -> singleton element
(Node x ltree rtree)
| x > element -> Node x (insert element ltree) rtree
| x == element -> Node element ltree rtree
| otherwise -> Node x ltree (insert element rtree)
mkTree :: (Ord a) => [a] -> Tree a
mkTree list = case (list) of
[] -> Empty
(x:xs) -> -- do not use any prelude functions
最初のxをinsertに渡したらNode x E Eになるから、残りのxsを"insert x”で出来た木に同じようにしたい。
リストの最初の値と取ってinsertに渡していくようなループってそうすればいいでしょうか？
出来ればpreludeの関数は使わない方向でおねがいしたいのですが。

こういうこと？
mkTree :: (Ord a) => [a] -> Tree a
mkTree list = case (list) of
[] -> Empty
(x:xs) -> insert x $ mkTree xs

>>505
ありがとうございます。
これを元にバランス木を作ってみたいと思います。

何故、map (3:) []は[]?
3:[]の[3]じゃなくて？

>>507
map f xs はリストxsの各要素に対して関数fを適用した結果をリストとして返す
(map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn])
要素数0のリスト[]に対しては適用するリストの中身がないので[]を返す
map は f :: a -> b という関数 を 受け取って
g :: [a] -> [b] という関数を返す関数と考えるとよいかも
関数gの引数が[]のとき、返り値として最もふさわしい値は[]以外には考えにくいでしょう？

tail []も[]にしてほしかったね

>>508
なるほど。
[]に(3:)しても、[]に要素がないから[]を返される訳なのか。
ありがとうございます。


所で、だれかHaskell99　やってる人いないかな。62Bむずかしい。

>>509
自分で tail をそのように再定義すれば済む話ではないか？

標準ライブラリの機能にあれが欲しいっていうよくある話だろ
自分で書くより標準ライブラリ使う方が保守性は格段に上がるんだから

>>510
Haskell99か元はprolog向けなんだな。

こういうのはだいたい、１の時を考える。
N-1が成り立つとしてNを考える。
あとは、再帰で書けばいいんだよ。

>>512
保守性というのは、これ以降あなたが作るプログラムの保守の話でしょ？
あなたが tail [] == [] の仕様が欲しいと言っているのだから。

自分のプログラムに tail [] == [] である関数を組み込む程度で
保守性が下がる理由が分からない
自分でユーティリティ関数を集めたモジュールを作るのと同じだと思うけど。

一人で書いてるならその通りだな。

lispだとcdr nil = nilなんだっけ

>508的な考えも一理ある
> g :: [a] -> [b] という関数を返す関数と考えるとよいかも
> 関数gの引数が[]のとき、返り値として最もふさわしい値は[]以外には考えにくいでしょう？

>>515
チームでプログラムしているのなら、
チーム用のユーティリティモジュールに自作 tail を入れればいいのでは？

俺はdrop 1を良く使う

>>513
なるほど。
Haskellでもインベーダーみたいなの作りたいけど、言語自体自分には難しいから夢のまた夢。
ま〜まずはモナドなど勉強します。
なにかオススメのサイトとかありますか？

なんで入門者の間でモナドがひとつの壁、理解の目標みたいな風潮になってるんだろ。

今Haskellで日常的にプログラムしている人の中でも、
モナドをまとまった一つの項目として学んではいない人は多いと思う。
よく分からんが使っているうちになんとなく少し分かったという体験を、
知らず知らずの間に塵のように積み重ねてきたんじゃないかな。

>>520
そりゃIOを使ったプログラムを自分なりにコピペ改変しながらやろうとして
上手くいかなくて、この do 記法はモナドの操作のシンタックスシュガーであり
みたいな解説があったからそうかではIOちゃんと使えるようになるためには
モナド知らんといかんなぁと思ったんだろ。

んでもって、冷静になってIOぐらいだったら do 記法の使い方の
例からなんとなく使えるようになるじゃんか…という真実にたどり着いた
あと、「ところで、なんでIOみたいな普通の言語が普通に持ってる機能を
モナドなどというケッタイなもので実装したのか、そのデザインには
なにか神秘的な力があるのではないだろうか。ゼノブレイドでもモナドが
スゴイって言ってたし…」　と気になってやっぱりモナド知りたいぞーとなった人がいても
不思議じゃないし。

>>521
ごめん、変な話で割り込んだ俺が悪かった。

>>520 は無視して続けてくれ。

>>516
Common Lisp だと cdr nil = nil だけど、
Scheme だと cdr nil = error だね。
どっちが正しいかは、信じる教義に依る。

head []がerrorだからtail []もそうなのかなと思った
でもたいていパターンマッチすれば済むしtailSafeやtailDefあるからそれほど気にならない

木とリストを勉強し終えた。
何か、”これしてみろ”って問題ない？出来れば木やリスト関連で初学者にも出来るグライ簡単なの。
現在、完全木をリストから作ることには成功した。
リストは好きはピザをテーマに簡単なレコード構文を作って遊んでる程度。
おねがいします。

勉強の仕方が義務教育時代と同じだね。
とりあえず体系的に順に学んで、理解の程度をテストした後は、
いつか実戦で使う時まで忘れている、と。

ひと通り基礎文法を理解して入門を終えたのなら、逆にしてみたらどう？
とりあえず何か作ってみたいアプリを考えて、それを作っていくうちに、
このデータは木構造にするといいかもと思いつき、木構造を勉強する、と。

なるほど、他の言語を勉強するときに使わせてもらいます。
出来れば簡単なゲーム（スペースインベーダー）なんか作りたいけど. Haskellでのゲーム作成方法ないからな〜。
もう木から特定の要素を抽出しろとか、リストを使っての計算とかちょっと飽きてしまったので、
何か皆さんが”初心者はこれが出来たらいいぞ〜”的な問題があったらうれしい。
javaならのんびりと簡単なゲーム作るのに。

>>526
そういう方法は勧められない。

HaskellのSDLライブラリを使ってLazy FooのSDL Tutorialsをやってみるとかだな
やってるうちに「これならCの方が楽」って絶対思うから
そこでFRPとかFreeMonadとか調べるとどんどん世界が広がる

>やってるうちに「これならCの方が楽」って絶対思うから
さすがにそれはない

>>527
> Haskellでのゲーム作成方法ないからな〜

それが義務教育時代の勉強みたいと言っているのだが・・・

スペースインベーダーを作ってみたいのなら、それを作るのに必要なものは何か考えようよ。
グラフィックスをスクリーンに描く事、コントローラーからの入力を処理する事、
時間の経過に伴ってキャラクタを生んだり消したりする事、などなど。

で、それをするのに今自分に不足している知識は何か考えてみればいいじゃん。

そして、こういう事をやりたくて、こういう事をする必要があるんだけど、
Haskell ではどうやってやるの？　こういう方法を考えてみたけどうまくいかない、
とか質問すればいいんだよ。

最初は個々の事柄に対してそれぞれバラバラに集めた方法やテクニックを継ぎ接ぎするんだから、
きっとHaskell熟練者みたいな綺麗な形にはまとめられないと思う。
でも、そこから少しずつブラッシュアップしたり、時には一から作り直したりするんだよ。

俺はそうやって勉強していくのをお勧めする。
質問時には、俺の持っている知識が役に立ちそうならアドバイスするし。
(他の人もアドバイスしてくれるでしょう)


> 何か皆さんが”初心者はこれが出来たらいいぞ〜”的な問題があったらうれしい。

言っておくけど、君はもうとっくに初心者じゃないんだよ。
いつになったら初心者気分が抜けるのかな。
誰かに、これができたら初心者卒業だと認めてもらわないと不安かな。

(ちなみに、Haskellでインベーダーゲームを作る方法の一つを紹介した
[The Yampa Archade] という論文がフリーで読めるが、いきなりこれはお勧めしない)

>>531
お勧めはしないとは言え、論文のタイトルを間違えたらアカンな

[The Yampa Arcade] でした

>>531
甘い考えだと分かり反省します。
同時に、提案ありがとうございます。
ゲーム作りの前にまずは基礎を固めることにします。
論文は面白そうなのですが、如何せん知識が無いので基礎が出来たらにします。

>>533
甘いかどうかは知らんし、反省してもらわんでもいいよ。
俺の方法が正しいという確証は全くない。

単に経験上良かったんでお勧めの方法だから、一度断られても２度くらいは勧める。

安心してくれ、３度は勧めん。
現に >>528 のように反対してる人もいるわけだし。

では、まず質問ですが、Haskellでスクリーンに絵を描くにはどうしたらいいですか？

まず服を脱ぎます

>>535
PostScriptを勉強する。

>>535
私の知っている限りでは、大きく3つの方法がある。

OpenGL や DirectX などを使う方法。
OS の描画用 API を直に使う方法。
GTK などの SDK にある描画機能（要はAPIのラッパーだが）を使う方法。

何が適しているかは目的によると思う。
ゲームを作るのであれば OpenGL などを使うほうが良いし、
GUI の一部として描くのであれば API や GTK などを使うほうが良いだろう。

まずは目的を一つに絞り、「Haskell OpenGL」や「Haskell GTK」などでググってみてはどうだろうか。
これらは絵を描く常套手段などで、解説サイトも他の話題に比べれば比較的充実している。

その上で、更に細かい部分で分からなければ、質問すればいいと思う。

>>538

誤) これらは絵を描く常套手段などで、

正) これらは絵を描く常套手段なので、

質問ばっかでｺﾞﾒﾝﾅｻｲ。
[1..4] ＞ [(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)]
みたいに出力したい。
pairUp :: [a] -> [(a, a)]
pairUp list = case (list) of
[] -> []
[x, y] -> [(x, y)]
(x:y:xs) -> (x, y) : pairUp (x:xs)だと
[(1,2),(1,3),(1,4)]までしか出ない。
(x:y:xs) -> (x, y) : pairUp (x:xs) ++ pairUp (y:xs)
やると出力カオス。

pairUp :: [a] -> [(a, a)]
pairUp [] = []
pairUp (x:xs) = map ((,) x) xs ++ pairUp xs

pairUp xs=[(x,y)|x<-xs,y<-[x..last xs],x/=y]

Haskellでグラフィックスをやりたいならglossかfree-gameを使おう

>>541
ありがとうございます。
mapは理解しているのですが、((,)x)はどう言う風に動くのでしょうか？
結果から見れば明白なのですが、preludeの関数を使わずにしたいので。
p [1..4]++p[2..4]++p[3..4]みたいにループで出来たらいいなと思ってます。

>>544
(,)はタプルを作る関数
(,) 1 2は(1,2)と同じ
((,) x)は、これにxを部分適用したもの

なるほど。色々な関数があるんですね。
勉強になりました。

>>544
541はまさにそういうループになっているけど。
mapを使わずになら、
p _ [] = []
p x (y:ys) = (x,y):(p x ys)

pairUp :: [a] -> [(a, a)]
pairUp [] = []
pairUp (x:xs) = p x xs ++ pairUp xs

(++)もPreludeだからこうでなければ

import Prelude ()

map f [] = []
map f (x:xs) = f x : map f xs

[] ++ ys = ys
(x:xs) ++ ys = x : (xs ++ ys)

pairUp [] = []
pairUp (x:xs) = map ((,) x) xs ++ pairUp xs

つまり、素直にPreludeを使えってことだ
使わない理由がわからない

これはなんでこうなの？

四の五の言わずに黙ってやれ！

武術の修行中に一々この型のこの動作は何故こんな風にするのですか
なんて訊く奴があるか！

体得すれば自ずと解る！

会得して尚一家言あればそのとき初めて口を開け！

励まぬ者に文句垂れる資格なし！

修行するぞ修行するぞ修行するぞ

一、清く正しく美しく、散歩に読書にニコニコ貯金、週末は釣り、ゴルフ、写経

二、世のため人のため社会のため

三、Love & Peace & Togetherness

四、ごめんなさい、ひとこと言えるその勇気

五、味の乱れは心の乱れ、心の乱れは家庭の乱れ、家庭の乱れは社会の乱れ、
　　 社会の乱れは国の乱れ、国の乱れは宇宙の乱れ

六、ニンニク入れますか?

(show a) ++ " " ++ (show b)
\x y -> compare (snd x) (snd y)
みたいに2引数関数の引数を同じ関数を適用してから〜の流れを
sndとかshowとかを1回書くだけでよい方法はありますか

Data.Function.on

(++) `on` show
compare `on` snd

(*ゝω・)ﾉ ｱﾘｶﾞ�d♪

>>549
言葉が悪かったな、本当に済まなかった。
言いたかったことはこれ
初心者はPrelude禁止とか変な縛りはせず、
Preludeの中の関数の定義を読むか、
自分から書きなおした方がいいんじゃないか、勉強的に

関数型プログラミングをするのは、難しい問題を分解して
多くの簡単で小さな問題を解く関数を書くことではないか。
だからmapを使え。mapがなにしてるかわからないのなら
書きなおして身につける方がいい

僕は上の母語の日本語じゃない奴なので
変な文＆正しくないマナーは許してくれ（汗

>> 547, 548
ありがとうございます。
出きるだけprelude関数を使いたくなかった理由はjavaやってる時に、
ずっとライブラリーを貼って付けるみたいな作業を感じたので。
それにしても、Haskell意外と面白いな。これからもっと勉強します。

Javaは全然知らんが、mapやfoldは
関数型の基本だから覚えるべし。

>>556
foldlって無限のリストでも使用できるんですよね。
ま〜take, drop, map, zip, filter位は何とか覚えるようにしてます。
Haskell覚えること多いな。
algbraic type は自分でdata使って独自の型を作れるのは分かったノですが,abstract data typeが理解できない。
既存のIntやBool型などブラックボックス化されてるのがそうなのですか？

>>554
purelude は弾けても fuga は死にそうです‥‥

>>557
本一冊読破すればそのような基本的な疑問はすべて解消すると思う
（まあ抽象データ型は関数型に限った話じゃないと思うが）
Prelude関数を自分で書いてみるのはHaskellの基本的なテクニックを学べる点では良い
ただプログラム書くのにいちいち定義してたら面倒だからライブラリがあるんでないのかね
これはどんな言語でも同じだと思うけど。さらにいえばファイル入出力とかのコードはどの言語でも
似たようなつまらないコードを書かざるをえない。こういう作業感はやることに依存すると思う。

君達に許された時間は有限なんだ
車輪の再発明にかまけてる時間があるのか

>>559
「ふつうの・・・」では無理ね。

>>560
再発明しかお金がもらえないんです

習作から入る事前提のプログラミング教育も問題だけどな。

>>542
pairUp [1,3,5]
はどういう結果になるのが正しいと思ってる？

>>557
抽象データ型は代数とみなせるから代数データ型とも言う事があるというだけで２つは同じもの。

構造化プログラミングはプログラムの連続分解というものを導入する事で大規模ソフトウェアの
開発を可能にしたけれど、データ構造の変更とデータ構造を操作する手続きの変更に弱かった。
抽象データ型を導入することでその欠点を補いつつ構造化プログラミングが可能になった。
（プログラムの連続分解をするにあたって有害だったのがgoto文）

Haskellでは例えば昔話題になったオードリー・タンのperl6は構造化プログラミングを実践してた。
ただ、抽象データ型はあんまつかってなかったと思う。

いやー構成要素の並びが外部に影響する代数データ型を抽象データ型とはとても言えない

せやね

並びについては知らないな。ゴーゲン以降出てきたのか？そんな話。

あとついでに、今思えば、オードリー・タンのpugsはHaskellだからというよりも
Haskellで構造化プログラミングをやったから大規模開発ができたというのが正しいと思う。

僕は数学オリンピックで上位ですがC言語しか使ってません
知り合いの人は中学数学すらおぼつかないバカなのにHaskell使ってることを自慢してきます
どうすればいいでしょうか？

算数はすごいけど数学はすごくない

>>570
くだらないことを質問するな

Haskell使ってみたいけど作りたいものがない

だから何だ？

カレーでも作ってろ

>>573
ナンプレパズルを解くプログラム

>>557
> ま〜take, drop, map, zip, filter位は何とか覚えるようにしてます。
> Haskell覚えること多いな。

いや、その辺は現代的なLispの影響を受けた言語の基本かと。

>>573
解説サイト作れ

確かに入門向けの解説がないから、初心者向けのが、作者の理解と共に読めるサイトがあったらいいな。

>>575
おれは評価する

haskellでeval男の人って…

>>580
お前575だろ

>>575
俺も評価する

俺は遅延評価する

あぶねえ
こんな微妙なネタで被るところだった

Haskellを使うために必要な知識を得たくて勉強してるのに、「モナド」という単語のせいで、Haskellプログラムを表現するためだけに必要な本来の目的とは関係ない特殊な知識へ労力がミスリードされてる気がする

ttp://www.haskell.org/haskellwiki/OpenGLTutorial1
の下の方に、四色で彩られた四角形の描写があります。
color $ (Color3 (1.0::GLfloat) 0 0)
vertex $ (Vertex3 (0::GLfloat) 0 0)のColor3やVertex3はメソッドだと分かったノですが、
parse error on input `color' とでました。
何がいけないのでしょうか？

import Graphics.Rendering.OpenGL
import Graphics.UI.GLUT

main :: IO ()
main = do
(progname, _) <- getArgsAndInitialize
createWindow "Display a screen"
displayCallback $= display
mainLoop
display :: IO ()
display = do
clear [ColorBuffer]
renderPrimitive Quads $ do
color $ (Color3 (1.0::GLfloat) 0 0)
vertex $ (Vertex3 (0::GLfloat) 0 0)
vertex $ (Vertex3 (0::GLfloat) 0.2 0)
vertex $ (Vertex3 (0.2::GLfloat) 0.2 0)
vertex $ (Vertex3 (0.2::GLfloat) 0 0)
color $ (Color3 (0::GLfloat) 1 0)
vertex $ (Vertex3 (0::GLfloat) 0 0)
vertex $ (Vertex3 (0::GLfloat) (-0.2) 0)
~~~
flush

>>587
コピペしてimportとmainを追加したらコンパイル通ったよ
(実行したらウィンドウシステムが落ちたけどたぶん俺の環境の問題)
コピペミスじゃないか？

>>588
多分何処かにミスがあったのだと思います。コンパイーラーは通ったのですが、どうやってmainを呼べばいいんでしょうか？
今まではghciからmainを呼んでいたのですが。
Haskell ? ghc -package GLUT game.hs -o game. ?
[1 of 1] Compiling Main ( game.hs, game.o )
Linking game. ...
Haskell ? main
zsh: correct main to man [nyae]? n
zsh: command not found: main

./game

>>584
言い得て妙だな
（必要になるまで575の評価をしない）

>>590
おお、ありがとうございます。

>>586
叙述トリックだ

モナドモナドしたいからhaskell勉強するんだよ

最小完全定義の説明ってちょっと分かりづらくないですかね
具体的には、Eqのインスタンスを宣言するときに(==), (/=)のどちらかを実装するって話（すごH本、wikibooksで確認）
いきなりEqクラスのデフォルト実装が循環定義になってるのを見せられると一瞬面食らう
学習上であまり直感的じゃない部分だと思うんだけど
ググってもあまり悲鳴が上がってないのが不思議
（ブログを見ると「らしい」という曖昧に理解してる感がある文章に出会える）

>モナドモナドしたいからhaskell勉強するんだよ
上からのフェロモンで動いてる昆虫そのもの

>>595
(==)だけ実装してる場合
x /= y を簡約化すると
not (x == y) -- x /= y の定義
not False -- (==は実装済みなので) x == y = False だとして
True -- not の定義
というふうになる
(/=)だけ実装してる場合も同様
普通(デフォルト)は==の否定(not)は/=と定義されるよね（逆もまた然り）という
実装が与えられてるだけで、そんなの関係ねえと思う人は(==)も(/=)も定義すればよい
data Human = Human { age :: Int, sex :: Int }
instance Eq Human where
x == y = sex x == sex y -- 左辺と右辺の(==)は違う
x /= y = age x /= age y
Q. John(19)はMary(19)は同じ(==)人物か
A. いいえ
Q. じゃあ二人は違う(/=)人なのね
A. いいえ
Q. ぐぬぬ
ってなるけど(最小完全定義の説明にはなってないかな

循環定義になってるから、どっちかをオーバーライドして使ってね、という
意図ということでいいと思うけどな。

で、排中律が成立しているか、みたいなチェックの枠組は言語にはないよ、と。

いや595はもう理解してるんでしょ
最初見たときは戸惑った
これじゃあ無限に巡回するじゃないか、と
ただそこで深く悩むことはなく
そのあとに出てきた信号をインスタンスにする例で
すぐに理解できた

>>586
ミスリードで思い出したけど
このリードって導くの意味のリードだったってつい最近まで知らんかったの思い出した
読むの方だと思ってたｗｗｗｗｗｗｗ

今、英和辞典で misslead を探してどこにも無いと焦ったバカが日本に数万人は居るな

Haskellプログラマが数万人も居るなら日本は安泰だな。

モナドが云々は、純粋関数型のIOを歴史的にみるといいんでないかい。
http://www2.gssm.otsuka.tsukuba.ac.jp/staff/kuno/lectures/12/2012-04-TopicsPL6.pdf
といっても、そうなると焦点がそこに絞られちゃうからこんな感じでよいのでは？
http://www.sampou.org/haskell/tutorial-j/io.html

IOモナドはC言語の世界でいうとyaccに近い
という理解でよろしいでしょうか？

ヤックル！ヤックル！

>>604
なぜ？

なんでpipeとかもっと適切なのを思わないんだろ

>>602
本当にそうなら、作ればいいだけではないか。

質問です

これがOKで
Prelude> product [x | x <- [1..10000] , mod x 10 /= 0 , mod x 10 /= 2 , mod x 10 /= 5]

これがNGなのは何故ですか？
Prelude> product [x | x <- [1..10000] , not $ (mod x 10) <- [0,2,5] ]
<interactive>:15:36: Parse error in pattern: mod

>>609

[x | x <- [1..1000] , y <- [0,2,5], not $ (mod x 10 == y) ]

product $ filter (\x -> (and (map (\y -> (not $ mod x 10 == y)) [0,2,5]))) [1..100]

>>609
・mod の構文が間違っている
・(mod ...) が Int 型とマッチングしない
・[x| x <- ...., y <- ....] は (x,y) の全組み合わせを生成して、重複を削除せずにxだけ並べる

ん？GHCiだと通ったけど
Prelude> product [x | x <- [1..10000], mod x 10 /= 0, mod x 10 /= 2, mod x 10 /= 5]

>>613
代名詞が分かり辛かったですが、"これ"は上を指しています

>>612
:t mod で確かめましたが、mod での行き先(?)は Int とは限らないのですか…
では、
Prelude> :i Integral で
instance Integral Integer
instance Integral Int
とあるのにも関わらず、(mod ...) が [0,2,5] :: [Int]
の要素である Int 型として推論されないのはなぜですか?

ググる際のキーワードも教えていただけると有難いです

>>614 下を指しています

>>614
リスト内包表記 [ x | x <- hoge ] の正体は hoge >>= \x -> [x]
だから<-の左辺でパターンマッチ例えば(x:xs)とか(x,y)を使える
だけど普通の関数と同様に(mod x 10)というパターンマッチは使えない

説明がかみ合ってないので
モナド難しい！と思われた初心者をまた逃したな

fact n = fact-tail n 1
　　　　where fact-tail 1 acc = 1
　　　　　　　 fact-tail n acc = fact-tail (n - 1) (acc * n)

みたいに素直に再帰で書き下せるところをいちいち末尾再帰に書き換えるように
なってしまいました。

こういうのってプログラム見にくいんじゃないかなぁと思いますが、
どうでしょうか?

好きにしろって言われるかもしれませんが

>>618
見にくくなるかなぁと思いながら、それでもわざわざ末尾再帰にするくらいだから、
パフォーマンスの向上を狙っているのだと思う。

それが、「どれほどの」向上に繋がっているのか正しく理解しているのなら、
それでいいんでないか？
トレードオフでパフォーマンス側をとったというだけのことだから。

どれほどの向上なんだろ？ という状態だったら、直ちに調査してみることを勧める。

がんばれ〜

おれは逆に、何でも末尾再帰で書いてたのが、Haskell 勉強してからはfold系が使えないか考えるようになったなぁ。

何でもかんでも末尾再帰で書く理由は自動プログラミング
出力されるコードが末尾再帰になるようにプログラムを帰納するテクニックがある

別の言い方をすると、出力の一覧を見てコードを書くときに、頭を使わずに同じ手順でコードを書くときは、末尾再帰の方が楽な場合がある
(手は猛烈に動かすが、頭は使わないという意味で)

お、おう

狐憑き Haskell kita-

代数データ型の値に関する次の2つの更新方法は、
実行効率で違いはあるのでしょうか。

data D = D { x :: Int, y :: Int, z :: Int }
d = D 1 2 3

{方法1} d' = D 5 6 7
{方法2} d' = d { x = 5, y = 6, z = 7}

部分的に更新するのではなく、全てのフィールドの値を更新するとして、です。


GHC のバージョンは 7.6.3 です。

>>625
違いはない。
コンパイルの途中で同じコードになる。

>>626
ありがとうございました。

>>625
不安なら、中間コードを生成して中を覗けばいいと思う

>>618のコードってどういう意図なの？

スタックを消費しない

なんか遅延評価だと末尾再帰の効果はあんまりないみたいな話なかったっけ
うろ覚え

素朴な実装だと再帰の深さ分だけサンクをヒープに作るので
メモリ消費量的には余り変わらないという話じゃない？

なんか「末尾再帰化はあんま気にすんな」みたいな結論だけ見た記憶がある
実際バリバリ使ってる人達はその辺どうしてるんでしょ

末尾再帰最適化はちゃんと効果あるし再帰が深くなるなら重要だよ

>>632
>素朴な実装だと再帰の深さ分だけサンクをヒープに作るので
それは末尾再帰とは直交した問題
末尾再帰にした上で、サンクを作らないようにseqや!を使えばいいだけ

しかしあの当時は21世紀になっても末尾再帰化を人手でやる羽目になるとは思いもよらなんだ…
思ったより進化してないなあ

末尾再帰ってどうやったら自動化できるの？

>>619
>>621
>>622

見難くないならまぁいいかな。

ご指摘の点を読み返してみて、自分はその関数がどういうものかという定義で
考えているのではなく、CやJavaのforループでカウンタと累積変数を動かしているのを
頭を使わず末尾再帰に書き下しているのだと思う。

できるだけfoldを使えるように精進するよ。

>>629
factだと自明すぎて例として不適切だったでしょうか

いちおう繰り返しを行う関数を作るときは、必要な引数を受ける名前を定義して、
内部で末尾再帰のカウンタと累積変数をもちいた定義を行うということを示したつもりでした。

これでは動かんというのならごめんなさい。
Haskell慣れてないんです。
特にwhereのかかる範囲とか。
lisp、schemeの括弧が懐かしいです。

末尾再帰という言葉で十分かと

末尾再帰って Wikipedia とか見てもよく分からなかったんだけど、
この間の放送大学の「データ構造とプログラミング 9 再帰」見てようやく理解した。

>>639
Prologなんかだと、末尾再帰ができていない処理系は使い物にならないし、
末尾再帰を意識して書かないと、動かないこともある。Prologの場合は、
末尾以前の全てのサブゴールの決定性が問われるとか、特殊な条件が付くが、
Haskellだとどうなのか、とかの理解は必要だと思う。

必ずしも再帰に限られないから、その言葉は良くない

放送大学そんなコースもあるのか

末尾再帰の最適化ができていない処理系は使い物にならない。ですね。

末尾呼び出し、tail callだな

私は、tail callがjumpになる、という言い方を説明のためには使うけど

>>646
shemeの継続？

Haskell において、ある関数の定義が末尾再帰になっているかどうかをどうやって確かめる？
別の言い方をすれば、何を以って末尾再帰だと断定できる？

最後に自分自身を「呼び出す」ような形になっている、という言い方はできないよね。
関数を呼ぶのは評価が行われる時だから、引数の方が後に呼び出されるかもしれないし。

Haskellはどんなプログラムを作るのに向いているのでしょうか？
C#とHaskellの使い分けの方針とかありますか？

ageながら宗教色のある質問を投げ込むスタイル

>>649
C# と同様に、極限まで処理速度を求められる分野以外なら何でもいい。
「言語」として向いている分野というのは特に無い。

使い分ける必要はなく、使い慣れたものを使えばいい。

>>648
f x = f ...
みたいに、右辺の一番外側が自分自身を呼んでいればいい
ただし、caseとlet(や、構文糖であるifとwhere)が挟まっていてもok
f x = case x of [] -> 1; hd:tl -> f tl
みたいに

この形でなくても末尾再帰になることもあって、例えば
f x = putStrLn x >> f
だと、一番外側の呼び出しは(>>)だけど、IOモナドの(>>)ならfを一番外側で呼ぶので、
間接的に末尾再帰になる

>>652
ついでに整理してください。
末尾再帰だと何が起こるのですか。

呼び出しが、行ったきりのジャンプに最適化される

よく考えたらこっちから行くのになんで呼び出しっていうんだろう

callの直訳

電話掛けるもの、スパイ活動を指令するのもcall

関係ないけど、コールドゲームはcoldじゃなくてcalled game。
試合終了が宣言されたゲームだから。

>>656
なぜ call なのか、という質問ではないのか？

なぜ 呼び出す なのか、という質問だ。

returnが戻るだから、本来対になる言葉はgo？

もともとサブルーチンはjumpするものだった
誰かがcallの方がいいと考えたんだと思う

捉え方の違いじゃね
ハードウェアを意識するか　しないか

お前ら、冷静になってよく考えろ

どーでもいい質問じゃね？

どーでもいい質問をスルーしたらこのスレで話すこと無くなるだろ……

東洋哲学的な精神やな

>>661
EDSACの用語で言うなら、インライン展開で使うもの（呼ぶわけでもジャンプするわけでもない）は
オープンサブルーチン、ジャンプして使うものはクローズドサブルーチンと言ったけど、
後者の場合、戻り番地をレジスタで渡して、自己書き換えして戻ってたから、事実上callと言える。
スタック的なものが無かったから再帰呼び出しは（簡単には）できなかったけど。

EDSACに行って戻るサブルーチンがあったのはその通りだけど
戻る仕組みを含めて（Wheeler）jumpと呼んでいたわけで、
やはりcallになったのはきっかけが別にあったんじゃないの

呼び方にこだわるんなら、68kでもJSRだからジャンプだし、それにこだわる意味は無いんじゃない？

すごくどうでもいい話だな。

haskellには関数呼び出しなどという命令的な概念はない。
あるのは関数適用式とその評価のみ

なんかのセリフみたい

>>670
>>655の疑問はHaskellに対して言っているのではなくて
それを実装しているレイヤーに対して言っているんだよ。

マクロアセンブラの calling sequence の CALL だろう。

>>672
>>670 は暗に「スレチだ馬鹿」というニュアンスを込めているのかもしれん。

我々の間にはチームプレイなどという都合のよい言い訳は存在せん。
あるとすればスタンドプレーから生じるチームワークだけだ。

知的ぶってるけど何も生産性のない
そして芸術としてもゴミに等しい無価値なやつら
哀れ

微生物以下

>>676
久しぶり！元気してた？

パール忍者最近見ないな

召喚するなよ

自分で自分を召還したんですか？

あとAransk

random-1.0.1.1 パッケージの System.Random モジュール内の関数に関して質問です。

左閉半開区間 [0, 1) のランダムな浮動小数点のリストを確実に得るには、
random 関数を使って自分でリストを作るしかないでしょうか。

randomR 関数は直接リストを得られますが、閉区間 [lo, hi] なんですよね。
しかも、次の説明も何やら怪しいですし。

For continuous types there is no requirement that the values
lo and hi are ever produced, but they may be, depending on
the implementation and the interval.

しかし、randomR の実装を見てみると、結局 random 関数を使っています。
正確には、random 関数の戻り値の乱数の方を v とすると、
2.0 * (0.5 * lo + v * (0.5 * hi - 0.5 * lo)) です。
random 関数が左閉半開区間なので、randomR も左閉半開区間になりますよね。
（もちろん、浮動小数点の場合の話です）

説明と違うような気がしますが、この違いを説明したのが上記の英文の部分でしょうか。

randomsは？

>>683
あぁそうか、randoms 関数を使えばいいのか。
馬鹿だったわ、ありがと。

でもそれとは別に、randomR 関数の説明って、
なんであんな変な条件みたいなのがあるんだろ。

連続だと閉区間でも上限下限は絶対に出力しないというのは一種の制約だから。
[lo, hi]なのに(lo, hi)と同じ実装を許容するなら但し書きを書くのが適切。

>>685
でも、>>682 の作り方なら下限は出力されるんじゃない？

「絶対」ではなく「実装依存」ってこと？

>>684
足下は初めは平身低頭に知恵を乞いておきながら、用が済めば急にタメ口になるとは何としたことか

死ぬほどどうでもいい

>>687
ホントごめん。

初めは質問者専用の口調で書いたのだけど、2回目の時にそれを忘れてて、
3回目で、なんかもういいや、ってなってしまった。

かまへん、かまへん

書いてる途中で自分の口調が分からなくなるのはたまにある
まあ自分はやらかしたことないけど（梯子外し）

せやな

wikipediaとは違うwikibooksに項目があった
ttp://ja.wikibooks.org/wiki/Haskell/%E5%9C%8F%E8%AB%96
あと英文のmonadの項目誰か訳してくれい（泣

人に頼ってないで英語の勉強を始めろ！

英語が俺の勉強をすべき

>>695
勉強したが、こいつは無理って諦められたんだよ

>>695
思考の柵が吹き飛んだ

>>693
まってろよ、今大熊さんの本を読んでるところなんだ

Lispがある程度わかってる人（SICP半分ぐらいまで読んだ）向けの
Haskell入門書ってないでしょうか

シクプってなに？そんなに凄いの？
読んでないとモグリなの？

>>700
読み終わるころにはlisp処理系の自作ができる

>>699
結論から言えば、Lisp が分かる人をターゲットにした Haskell の入門書はありません。

Haskell を学ぶに当たって、Lisp が分かっている事そのものはたいして役に立たちません。
強いて言えば、Lisp で参照透過性を意識したプログラミングに慣れていれば、
Haskell のその部分で躓くことはないだろうという程度です。
なので、そのような入門書を出版する動機がないのでしょう。

しかし、Haskell の Haskell らしさが出る部分はそれだけではありません。
どのような入門書にも、参照透過性を含め他の Haskell らしさの部分は解説してあります。


ちなみに、SICP で学んだ事は他のどのような言語でプログラムする際にも活きます。

過去スレにこんなのがあった。
http://ja.wikibooks.org/wiki/48時間でSchemeを書こう

> このチュートリアルの対象読者は主に以下の2種類です。

LispかSchemeを知っていて、Haskellを学びたい人
プログラミング言語を何も知らないけれども、一定の背景知識を持っていてコンピュータに詳しい人

>>703
それを入門書の代わりに使うのなら、
素直に普通の入門書を読んだ方が良いような気がするなぁ

まぁターゲットとしては >>699 にドンピシャだけど

lispもCも経由せずに、はじめてのコンピュータ言語でいきなりhaskellを教えるカリキュラムがあってもいいはず

IFPHは学部初年度向けと書いてあるしプログラミングの事前知識も必要なかったはず

皆んなHaskellを何に使ってる？
俺は趣味で、ゲートICの立体構造をアルゴリズムと見なして、どんな構造なら性能を上げられそうかのシミュレーションに使ってるけど。

はあ、そうですか

事務処理のスクリプト最強

クイックソート

世界平和のために使ってる

>>710
それは本物のクイックソートか？

>>712
1) クイックソートって、列から適当な要素を選択して、
2) それよりも小さい要素を集めた列と、大きい要素を集めた列を作り、
3) 作られた2つの列に対して 1)、2) を施し、列を連結する、ものだよね。

このアルゴリズムの骨組みを守りつつ、
平均・最良の計算量が O(n log n) で、最悪が O(n^2) になっていれば、
どれほど馬鹿な実装方法を使おうが、どれほど処理に時間かかろうが、
どれもみんなクイックソートを名乗っていいと思う。

Haskell の稚拙なクイックソートの例は入門サイトや入門書にはたいてい載ってるし、
どんなバカでも理解できるだろうし実装できる。

だから >>710 のは、いくら何でも偽物ってことはないだろ。
というか Haskell の偽物のクイックソートの例を見てみたい。


と思ったのだが、どうだろう？

至高のクイックソートを用意しました

このクイックソートを実装したのは誰だあっ！

俺のクイックソートは一味違うぜ

でもHaskellも悪いんですよ

実はHaskellとクイックソートって相性悪いよね

Haskellerは
zipperの説明を読むだけでエクスタシーに達します

なんで大元の論文を引きもしないんだろうか

面倒だから

都合の悪いものはモナドにしてネイティブで実装すればよい

わずか2ページってクイックソートの論文だったっけ？

>>713
>>712じゃないけど、Haskellのよくあるクイックソートは、
空間計算量が最悪O(n^2)になるという点で普通のクイックソートと違って怪しい

>>724
量子コンピュータが実現した世界で何言ってんだ？

またHaskellのクイックソートが偽物とか言う奴が現れたか…

twitterでも今年に入ってからこの話題で盛り上がったようだ
まとめのタイトルが笑える
http://togetter.com/li/445854

>>724
怪しいというのが曖昧でよく分からないのですが、
「空間計算量が最悪でもO(nlogn)である」というのは、
クイックソートである事の必要条件なのでしょうか。

>>727
俺にも分からん

名前のとおり速けりゃいいんだよ

そうやってフザケる話の流れではないような気がする

とりあえず、よくあるもっとも簡単な実装はこれかな。

qs :: (Ord a) => [a] -> [a]
qs [] = []
qs (x:xs) = qs (filter (< x) xs) ++ [x] ++ qs (filter (> x) xs)

空間計算量が最悪O(n^2)になるケースってのは、どういうリストに適用した時？

>>713で正しいよ

なんかwikipediaのクイックソートのページにも実用性が云々と書かれているけど、そもそもリストという
データ構造自体がソートと相性が悪いんだから、そんなこと言っても仕方ないと思うけどね

大量のデータを扱うなら他のデータ構造を使うべきだし、ごく少量のデータなら入門書の実装の
方がむしろ実用的だろう

>>731
それだと重複した要素が消えることないかな？

なんかの入門書でHaskellにはクイックソートよりよいソートがあるって書いたあったんだけど何ソート？

>>733
データモデルとデータの追加でよいソートは異なる

>>731
>空間計算量が最悪O(n^2)になるケースってのは、どういうリストに適用した時？
入力が既に正順か逆順にソートされている場合。O(n^2)になるのは正順か逆順のどちらか
だけなんだけど忘れた。この板のHaskell関係の過去スレの一つに議論があったはず
(ちょっと探したけど見つからなかった、曖昧でごめん)

見つけた。Part 7の881から

>>715
コーディングの合間に喫煙していたと何故判ったのですか！？

Cで作ってHaskellから呼び出すだけのライブラリ

Haskellで一から作ったライブラリ

どっちが幸せになれるの

*Main> :type (+) (-)
(+) (-)
:: (Num (a -> a -> a), Num a) => (a -> a -> a) -> a -> a -> a

これを解説してください。(+) を数ではない (-) に適用できる?

>>715で笑ってしまった
恥ずかしい

>>739
ヒント：カリー

f :: Num (a -> a -> a) => (a -> a -> a)
x :: Num a => a
y :: Num a => a
（+）（-） f x yのかたちで呼び出すんだろうけど
Num (a -> a -> a)が意味不明すぎる
自然数をラムダ関数で表現するやつかな

型クラスNumのインスタンスとして
Numとして解釈できるラムダ関数を定義すれば良いんだよな
えーとどんなだっけ

(ﾟдﾟ)

>>739
(-)はデフォルトでは「数」じゃないけど、インスタンスを定義すれば数になる
たとえばNumInstancesパッケージのData.NumInstances.Function
http://hackage.haskell.org/packages/archive/NumInstances/1.3/doc/html/src/Data-NumInstances-Function.html
をインポートすると、
instance (Num b) => Num (a -> b)
が定義されるので、例えば(Int -> Int -> Int)を加減乗除できるようになる

>>732
すまんすまん、= を書き忘れてた。
< か > のどちらかに = を追加して考えて。

>>735 >>736
モリタポ使っても、なぜか Part 7 が見れない。

>>731 のような感じのクイックソートの実装だと、
A ++ B ++ C という形の式が大枠であるよね。

これを順に弱頭部正規形にして評価していくとき、最悪の場合、
左側の ++ 演算子が評価可能になるまで（++の左辺が x:xs の形になるまで）ずっと、
(((・・・((A'' ++ B '' ++ C'') ++ B' ++ C'))・・・))) ++ B ++ C
というような再帰的な形で左側が伸びていくと思う。

未評価の A'' や B' などが何個作られるかというと、
qs 関数が適用するリストの長さを n とすると、ざっと見積もって
3 + 2 * (n - 1) 個かな。
（最初の 3 は一番深い所の A++B++C で、2 は ()++B++C の B と C）

最悪ここまで式が伸びきるので、空間計算量は O(n) ではないか、
と俺は思ったんだが、どこで勘違いをしているのか分からない。

過去ログ Part 7 が見られるようになったら調べてみるけど、
今の所自分の頭ではこう考えた。

>>739

> (+) を数ではない (-) に適用できる?
できない。

*Main> :type (+) (-)
(+) (-) :: (Num (a -> a -> a), Num a) => (a -> a -> a) -> a -> a -> a

これが言っているのは、ざっくりいえば「もし、(-)が数であれば、(-)に(+)を適用できますよ」ということ。

まず、プログラマが何らかの方法で(-)を数(Numのインスタンスの値)になるようにしてあげなければならない。
首尾よくそれが実現できたら、晴れて(+)を(-)に適用できる。

>>747 >>745
ありがとうございます。
> プログラマが何らかの方法で(-)を数(Numのインスタンスの値)になるように
これが実際できてしまう、というのが、Data.NumInstances なのか。

Haskellはすごいのでがんばれば何でもできる
Wikipediaのラムダ計算の自然数と算術の項目に
http://ja.wikipedia.org/wiki/%E3%83%A9%E3%83%A0%E3%83%80%E8%A8%88%E7%AE%97#.E8.87.AA.E7.84.B6.E6.95.B0.E3.81.A8.E7.AE.97.E8.A1.93

0 := \f->\x->x
1 := \f->\x->f x
2 := \f->\x->f (f x)
3 := \f->\x->f (f (f x))
(+) = \m->\n->\f->\x-> m (f (n f x))

としてラムダ関数で自然数の計算をシミュレートする方法が載ってる

>>749
それだと自然数の型が(forall a. (a -> a) -> a)みたいになって、
>>739で要求されてる(a -> a -> a)とは別物

ごめん、forall a. a -> (a -> a) -> aね

>>749
(+) が間違ってるな。
(+) := \m->\n->\f->\x-> m f (n f x)

haskellが他の言語と違うのはside effect freeだから！
と本に書いてあるのですが、他の言語でも出来そうな気がするのですが？
nibai :: Int ->Int
nibai n = 2*n

void nibai(int n){
value = 2*n;}

ホントだ！すごい！

>>753
「haskellが他の言語と違うのはside effect freeだから！」
と書かれていた本のタイトル名を教えてください。

整数を受けとり二倍して何も返さずシカトする
そんな関数に私もなりたい

いやな奴だな

副作用はツンデレ

参照透過性は甘え

>>753
ああ、全ての行が見てるとムズムズする

ヤンデレと病んでるは似ている。

質問です。
Not in scope: `GLFW.defaultDisplayOptions'
Not in scope: `GLFW.setWindowPosition'
とエラーが出ました。
参照しているttp://www.youtube.com/watch?v=LIlBvBT6dIcでは使えていますが何がいけないのでしょうか？
import qualified Graphics.UI.GLFW as GLFW
import Graphics.Rendering.OpenGL.Raw

main = do
GLFW.initialize
GLFW.openWindow
GLFW.defaultDisplayOptions
GLFW.setWindowPosition $ 110
clear Colour{red = 0, green = 0, blue = 1, alpha = 0.1}
GLFW.swapBuffers
GLFW.sleep 5
data Colour = Colour {red, green, blue, alpha :: GLclampf}

clear :: Colour -> IO()
clear (Colour(red, green, blue, alpha)) = do
glClearColor red green blue alpha
(glClear . fromIntegral) gl_COLOR_BUFFER_BIT

javaでもside effect free できるってhttp://masuda220.jugem.jp/?eid=335
に書いてあったけどクラスの価値をほとんど捨ててる設計じゃん。

手続き型の本質は副作用にあり

　　　　　／/
　　　　／ /ﾊﾟｶ
　　　 /　/
　　　/　/ﾊ,,ﾊ
　　 / ヽ(=ﾟωﾟ)ﾉ__ぉはぃょぅ
　　/／ （ 　x ） ／
　　"￣￣￣￣

>>762
パッケージが違う
動画で使ってるのはGLFWでなくてGLFW-bの方

>>762
GLFW-b パッケージにはその関数はあるけど、GLFW パッケージにはないよ。

ありがとうございます。GLFW-bですか。
どうやって使うのか調べてきます。
けど、動画を見る限りじゃGLFW-bが見当たらないのですが。

>>733
マージ

>>769
それマージで言ったん？ソートすんならすぐ出せ
マージなら２ちゃんねらソート力を挙げて列べるが

原始再帰関数(primitive recursion)とは一体なんなのでしょうか？
ttp://stackoverflow.com/questions/1712237/how-does-primitive-recursion-differ-from-normal-recursionの回答に、
「原始再帰関数とは他の原始再帰関数で定義されいて自然数の構造の再帰である。」とありますが、
イマイチ分かりません。
例えば、自然数を使った
fac::Int->Int
fac x
| x > 0 = x*fac(x-1)
|x==0 = 1
は原始再帰関数で、
inverse::String->String
inverse value = case (value) of
[]->[]
(x:xs)-> inverse xs ++ [x]
は原始再帰関数では無い。
ということでしょうか？
base caseにヒットして関数が終了するのであればそうなのかな〜と思っていたのですが。

>>771
その関数の性質を帰納法で証明できる関数だと理解していたが、違うだろうか

ゲーデル数化すればinverseも自然数上の原始帰納関数にできる。
もちろん文字列上の原始帰納関数ということで問題ないが。

チューリングマシンの意味で計算可能な関数は原始帰納関数で表現できる

いや出来ない。
チューリング機械計算可能関数には一般帰納関数も含まれるから。

あっ、帰納法でか？

ん？では普通の帰納関数とはなんでしょうか？
上の方に一般帰納関数というのがありますが。

その辺はwikipediaで調べてからまた質問して。
Haskellの話題じゃないし。

>>777
確かにスレチだ。すみませんでした。

今ホットなライブラリは？

C や Java、OCaml や Lisp などではこんな質問はまず無いのに、
なんで Haskell だと「今一番熱い漫画は？」みたいなノリで頻繁に投げかけられるんだろ。

Haskell の最新事情を追いたかったら、こんな所で質問するより、
メーリングリストにでも登録して議論してた方が何倍も良いと思う。

Haskell界にくると頭のいい人が一杯いて何か新しい、面白いことをやっている

そう考えていた時期が私にもありました

ライブラリのインストールがめんどくさいです

バージョンに関係なく、ライブラリのzipファイルをコピーするだけでOKにしてほしいです

Haskellは数学を知る者が数学の言葉でコンピューティングしたいという要求から存在する言語
数学を知らないものには猫に小判
かく言う俺は数学の記述法自体が過去の遺産を引きずって不合理極まりないと思っているが

言語処理が文系科目に分類されている日本では理解されないでしょう

自然言語処理は機械翻訳から始まってるし、文系に分類してる所はまずないと思うぞ。
計算言語学は計量言語学から来てて、元々言語学だから文系になってると思うが。

いずれにしろ、理系と文系を分ける発想（多分、旧制の時代の理科と文科から
来てると思うが）に縛られているうちは、生成文法みたいな革新的な発展が
生まれてくることは望めないだろうねぇw

>>783-785
そんな的外れな話をHaskellスレでして恥かしくない？

>>785
＞生成文法
この前古本屋にいったら生成文法がらみの古書が山積み‥‥‥
よっぽどはやったんですねえ、チョムスキー御大あいもかわらず大気炎をあげてらっしゃる「テロ、テロと皆はいうがアメリカが最大のテロ国家」‥‥

あー、当たり前のものになったもの（たとえば「構造化プログラミング」）を、
昔流行っただけで廃れたもの、と勘違いするパターンねw

>>788
regular grammar あるいは regular expression って生成文法全体からすると生成規則はかなり制限されていると思う
いや、それはいいとして、DFA と「文法」をリンクさせる、とかもチョムスキー以降なの？
今の計算機言語の特に文法の考え方はチョムスキー以降の産物なの？

>>782
ライブラリのzipファイルをコピーするだけでOKの場合、いつコンパイルするの？

そのライブラリが依存している別のライブラリは自分で調べてダウンロードするの？

>>789
自分で調べろよ、スレ違いだよ。

>>790
いろんなバージョンのバイナリがzipで固まってて、実行するときに選ぶようにするんだよ
プラットフォームだけで実行できるように、依存してるのも全部zipに入れておくんだよ

>>783
俺も同じ事を感じてる。しかし多分全然違う視点なんだろうね。
ｽﾚﾁｽﾏｿ

論文に書くそのままの表現でプログラミングしたいという欲求でできたのがHaskellだと認識してる

>>789
チョムスキー階層
http://ja.wikipedia.org/wiki/%E3%83%81%E3%83%A7%E3%83%A0%E3%82%B9%E3%82%AD%E3%83%BC%E9%9A%8E%E5%B1%A4
> チョムスキー階層（-かいそう、Chomsky Hierarchy）とは、
> 形式言語を生成する形式文法のクラスの包含階層である。
> これは「句構造文法」（Phrase Structure Grammars）の階層とも呼ばれ、
> 1956年にノーム・チョムスキーが発表した。

>>794
わたしは初耳ですけど、あなたの予想ではなく委員会メンバーの発言？

論文に書くそのままの表現、とはどういったものなのでしょうか。
論文に「何を」書く際の表現方法の事なのでしょうか。

論文に書くそのままの表現という事において、
Haskell 以前の言語では何が不満だったのでしょうか。

[A History of Haskell] によると、Haskell の主な目的は
バラバラだった既存の関数型言語の統合と、実用的なアプリも作れる関数型言語を作る事、
この2点だとわたしは感じたのですが、どうでしょうか。

>>796
その実用的じゃないから統合する必要すらなかった関数型言語群を、わざわざ統合したいという欲求の源は何だったのか？
私は、論文に書くそのままの表現でプログラミングしたいという欲求だと思う

具体的には、論文の中の、帰納的証明で使われる表記と概念の数学的表現とDSLの仕様で使われる表現そのままをソースコードに書きたいという欲求

>>796
最後の段落は、英国関数型言語界の統一言語プロジェクトを立ち上げた趣旨だな。

>>797
それは(事実かどうかは別として)言語仕様の設計趣旨じゃないかな。

素朴な質問なんだけど
'$'より'.'で関数を結合させた方がいいみたいな風潮があるようだけれど
なんで?

cabalだっけ、ライプラリのインストール、失敗率が高い。
haskell platformに初めから付いているライブラリ以外、結局・・使い物にならないのでは？

規制で書けなかったのが誤操作で投稿されてしまった。

流れぶち切ってすまん

ちなみにHaskell以前は論文にアルゴリズム書く時はBurnさん風が多数派だった。
Miranda的というか。

>>799
(1) 打鍵数が減る
(2) ($)よりも(.)を使ったほうが解かりやすいことがまれにある
(3) 宗教的理由

>>800
例えばfree-gameはインストール失敗する。
glossはglossとHaskell platform 特定のバージョンの組み合わせでインストール成功。

インストール失敗する度にcabalによってインストールしたファイルをすべて削除して、
haskell platformをアンインストールして再インストール。
再インストールする時、バージョンを1つ前にしたり。

試行錯誤してインストールに成功することもあれば、
結局どうやってもインストール失敗することがある。
　
　正直、うんざり・・。

インストールみたいな状態変化は苦手なのさ

Haskell Platform なんて使わずに GHC + Cabal を使っておけば
ライブラリのインストールは多少マシになる。

更に、Windows なんて使わずに Linux 系を使っておけばもう少しだけマシになる。

インストールは破壊的挿入なのか？

更に、Haskellなんて使わなければもう少しだけマシになる。

>>804
お前がどういう環境を使っていてインストールがどうやって失敗するかを書かないとどうしようもない
ここで質問しても良いけど、ユーザ数がすごく多いパッケージじゃないなら
パッケージのバグトラッカやメーリングリストで直接報告した方が解決が早いと思う
とりあえずcabal install free-gameを実行してみたけど普通に成功した(Linux, amd64, GHC 7.6.3)

セックスは破壊的挿入

>>781
:(；ﾞﾟ'ωﾟ'）:やってないのか……？

>>810
この前挿入しようとしたら例外が起きてボトムが返された

どうなってんだよアイツ

俺もfree-gameインストールしようとして失敗したところなので
ネタじゃなく自分いつレスしたのかと思った
cabal-dev使えばいいんじゃね？ 使い方良くわからないんでゆっくり調べてる最中だけど

free-gameは、GLFW-bが最新だと動かないね。
GLFW-b-0.1.0.5を入れなおしたらインストールできたよ。

その辺はcabalが勝手に管理してくれてるけどねえ。
自分でインストールしたりもしてるわけ?

色々調べてhsenvがいいかなと思ったけどwindowsではどうしてもインストールできなさそう（cygwinでもだめ)
なので悔しくて枕を濡らしている

Windowsは諦めてLinuxの仮想環境で。

動かなかったら自分でなんとかするさ。
free-gameがupdateされて、GLFW-bのバージョン指定が修正されてるね。

>>809
一応こっちの状況を書くと。

free-gameインストール失敗　(0.9.3, 0.9.3.1, 0.9.3.2, 0.9.3.3全部失敗)
Windows7 Haskell platform 2013.2.0.0 (GHC 7.6.3)
Windows8 Haskell platform 2013.2.0.0 (GHC 7.6.3)
Windows7 Haskell platform 2012.4.0.0 (GHC 7.4.2)
Windows8 Haskell platform 2012.4.0.0 (GHC 7.4.2)

glossインストール失敗
Windows7 Haskell platform 2013.2.0.0 (GHC 7.6.3) gloss最新
Windows8 Haskell platform 2013.2.0.0 (GHC 7.6.3) gloss最新
Windows7 Haskell platform 2012.4.0.0 (GHC 7.4.2) gloss最新
Windows8 Haskell platform 2012.4.0.0 (GHC 7.4.2) gloss最新

glossインストール成功
Windows7 Haskell platform 2013.2.0.0 (GHC 7.6.3) ?gloss-1.7.7.201204.1. ※コンパイル後ファイル実行時に暴走
Windows8 Haskell platform 2013.2.0.0 (GHC 7.6.3) ?gloss-1.7.7.201204.1.

>>819 glossインストール成功の部分訂正
glossインストール成功
Windows7 Haskell platform 2012.4.0.0 (GHC 7.4.2) ?gloss-1.7.7.201204.1. ※コンパイル後ファイル実行時に暴走
Windows8 Haskell platform 2012.4.0.0 (GHC 7.4.2) ?gloss-1.7.7.201204.1.

他のパッケージもインストールの失敗が多い。
文字コードのライブラリをインストールしようとして上手くイカず・・。

UTF-16とShiftJISの相互変換、結局自作したよ・・。
単なる対応表があればいいので、文字コードライブラリ不要だった。

Windows版か、、、
Windows版は、作者が全く対応を考慮していなくてどうやっても
動かない場合があるから諦めが肝心。

でもゲームって言ったらWindowsで動くもの作りたいですよね
Haskellをそこまでして使うのかという意見は置いておいて

じゃあ頑張って。

free-game 再度インストールしたら成功。
0.9.3.3→0.9.3.4のupdateによるものかな。

free-gameインストール成功　( 0.9.3.4)
Windows7 Haskell platform 2013.2.0.0 (GHC 7.6.3)

>>822
そこで諦めるなよ！作者に文句言ったりパッチ送ったりしろよ！

でもインストールのエラーメッセージにExitFailure 1が出るとログ見る気力とか出ないよね（クズ）

作者に文句言っていいもんなの？
HakageDBがよく出来てるから、ソース見て調べればある程度
見当がつく場合も多いけど、全くこりゃお手上げって場合も
あるわけで。

なんだぁHaskellアプリって思ったより暴走するんだね(´・ω・｀)

でも純粋だから、たとえ誤ってHDD消去しても安心

純粋な悪

>>830
まずはIOモナドを消し去らないと……

消去自体がモナドなのに

何でhoogleすぐ死んでしまうん？

自然数を扱った原始帰納関数は多分こうだと思うのですが、
fac :: Int -> Int
fac n
|n==0 = 1
|n > 0 = n * fac(n-1)
| otherwise = error"No neg num" --ベースケースを０とし、nが０以上ならnー１とす。

代数的データ型でいい例はあるでしょうか？コンストラクターとつかったやつがあればいいのですが。

foldrで書ける関数は原子再帰的である

むしろ原子帰納的でない関数を考える方が難しい
ackermannくらいか

futumorphism

何故か規制喰らった。
原始でコンストラクタ使った例は
data Tree a = Null | Node (Tree a) (Tree a)

size :: Tree a -> Int
size tree = case (tree) of
Null -> 0
Node lt rt -> 1 + size lt + size rt
でいいのかな？
関数は最終的にNullにパタンマッチして０を返すから演算が終了する。
n-1ないけど
f :: Int -> Int
f n
| n == 0 = 1
| n < 0 = f (n+1)
も原始帰納になるでしょうか？
自然数を扱うときはn-1が必要だからこれは違う（普通の帰納）？

>>839
安心しろ
君レベルの人が作る関数はすべて原始帰納だから

>>840
分かりました。ありがとうございます。
原始帰納ってベースケースにヒットして演算が終了すると思っているのですが,
そうじゃない帰納ってどんなのがあるでしょうか？
色々あると思うのですが。原始帰納の数の方が少ない気がする。

ふつうの関数は全部 原始帰納的でしょ

(+) :: Nat->Nat->Nat
(*) :: Nat->Nat->Nat
fact :: Nat->Nat

とか
それでアッカーマン関数は原始帰納ではない有名な例であると

f(m.n)が原始帰納的でないとf(m.n)の上限を見積もるような
f(m.n) < f(m+g(n),n-1)となるようなg(n)が定義可能だけど計算不可能になったりする

なんでcabalはアンインストールの面倒を見てくれないんですか？

なるほど、普通の関数は全部原始帰納ですか。
説明ありがとうございました。

数学、特に整数論はほとんど原始帰納関数だけど、
コンピュータではそうでもない。

?
>>839など、
プログラムである関数があったとして、ベースケースにマッチしてその関数が終了するのであれば、それは帰納関数だと思うのですが。
間違っていたらすみません。

包含関係だろ。

ほとんどいたるところで原始帰納関数

高々可算無限個にすぎない

投票行けよ

投票に行くと、公約を破った政治家を暗殺する義務が発生するしな…

投票に行くと、結果を全て受け入れる義務が発生するしな…
滅亡へ向けひた走る関数実行中

>>852,853
場違いの話題でスレを汚したのでHaskellに関する話題を提供する義務が発生しました

じゃあミカサ・アッカーマンをhaskellで記述してください

自民党圧勝！
本当にうれしいわ
お前らゴミクズみたいな中途半端なインテリゲンチャ気取りが悔しがる顔を想像するとな！！

スレチな上にポルポト派か

Perl忍者最近見ないな

ポルポトは間違っていない
純粋に理論を追及した結果が大虐殺なだけ
理論が間違ってたことを指摘しないと、いつまでたってもデバッグは終了しない

スレチだ
他所でやってくれ

Haskellスレにスレチという言葉は無い

スレチの意味も分からんのか？

haskellとhaswellの違いについて教えてくだされ

どちらもトランザクション機能が期待されている

About Haskell and Haswell.
http://www.h-online.com/newsticker/news/item/Processor-Whispers-About-Haskell-and-Haswell-1389507.html

もっと抽象的にわかりやすく

乱暴に書いた筆記体のkとwは似てる。

違いを答えろよお前ら

授業のときは何も知らない純粋な顔をして受けてあげなよ・・・。

[不純関数型言語とは ][検索]

もしかして: すごいH本

[不純異性交遊とは ][検索]

もしかして: すごいH本

モナドの中では少女は奔放になります
というえろげ

諸君、議論したまえ

スレチとは何だったのか

もっと盛り上げてよ
Haskellたんが蛹のまま何ヶ月も動かないの！

使う必要なければ無理に使うこともない

桶 蛸 蚕 蛹

「Ant Farming」（実験ばかりして実りのない学者タイプ）

お前らまさにこれだよな

お前等ゴミクズはこういう誰も使わなさそうな単語が大好きだもんな
見つけておいたことに感謝しろよ

「Ant Farming」（実験ばかりして実りのない学者タイプ）

スレチ

Perl忍者最近見ないな

Haskellって(Schemeも結構そうだけど)
RubyやJava、Cと比べて
プログラムが横に長くなると思うんだけど
(インデントが深くなるから?)

エディタ上で見るときは横に広げればいいんだけど
印刷すると見難くならない ?

みんなどうしてるの?

印刷横向きにして
A4の縦に2P表示

縮小して印刷すればええがな。
あまり長すぎる行は折り返せばいいし。
幅は印刷する前に分かるんだから自動化は可能。

わざわざ紙という劣化メディアを選択する理由って、やっぱ老害レビューワー？

紙いいじゃん　温もりがあって

紙には、「簡単に」手書きメモや書き込みができるという利点もある。

は？ 寧ろHaskellでコーディングするようになって一行80文字以内を徹底するようになったんだけど？

Vimで窓区切ってそのスペースで見渡せるコーディング身に付いたんだけど？

唐突威圧おじさんやめろ

威圧のこころは母ごころ

は？？

押せば命の泉湧く
はーっはっはっは

マクロ使ってもいいんだってPreludeが教えてくれた
ifdefの嵐にくじけない心を貰った

いまどきIDE使わずにVim使う情弱がいるとは…

それは言語による

IDEが必要なのってJavaみたいな糞言語だけでしょ？

それはIDEの出来による

論理が破綻している

APIがたくさんあればどんな言語だって必要なんじゃね？

>>899
なぜ？

IDE って「統合開発環境」だよね。
APIがたくさんある事で、何と何を統合する必要が出てくるの？

（笑）

すごいどうでもいい

>>900
コードスニペット程度の使い方をしているとエスパー。

その程度の使い方ならそれこそVimで十分じゃないか……

>>902
すごいどうでもいい事だが、本来は「すごくどうでもいい」な

言語の乱れは生活の乱れ

スペック低すぎてIDE動かないんだろどうせ
作者すら恥じたvi系のエディタを使うのは素人の遊びくらいだ

学習レベルだけど、とりあえずvim使っている。
vi系はどのOSでも動くし、vi使えれば実用上問題が発生しないことも実証されている。

だいたい Haskell の IDE ってまともなのあるか？

>作者すら恥じたvi系のエディタ
あの化石発言いまだに引っ張るやついるけど、
いい加減今のVimと当時のvi一緒にすんなよ

平和だなぁ

のどかに銃弾が飛び交ってますわね

>>907
上でAPIがどうこう言ってた人？

そんなことよりモナドのえろげはまだですか？

unsafePerformIOしたらダメなの〜

>>909
俺も知りたい。
eclipseFP とか使っているひといないかな？

小手先の技術しか学ばない無能（その場しのぎで、将来を見通した深い考えのないこと

どこもこんなのばっか

おい随分抽象的だな
ﾊｽｹﾙらしい

いつ消えるかもわからんものに記憶力を割く気がしない

>>918
なあ？ゴミクズは抽象的なのがすきなんだろ？
だから抽象的にバカにしてやったんだがね

お、おう……

抽象的と聞いて、「複雑化」「単純化」のどちらを連想するかで、プログラミング適正が診断出来る。

プログラマなら「具体化」と言わないと…

難解になるかわりに単純になる
という印象

概念・実用両方面で、どこまでモナドを理解できているかを測るテストはないでしょうか。

なんとなく頭では分かっているような気がしますが、人にわかりやすく説明できるかと言われると、
何からどのような順で説明したらいいかとか含めて自信がなく、自分の理解度がよく分からない。

クイズやテストみたいな形で出題されると、理解度を客観的に測れるのではないかと思うのですが・・・

数学の一般人向けの本を立ち読みしてて、最後の20ページくらいでいきなりモナドとプログラミングの話が出てきてビビった
非決定性計算から説明してたから物凄く分かりやすかったけど、タイトル見るの忘れた

モナドグランプリ

>>926
その本知りたい。お願いだから思い出して。

>>923
それは既にプログラマ。

>>927
せーがー

>>928
本屋に行ったけどもうなかった
今年の4月に数学の新刊コーナーにあったと思う

非決定性計算演算子Pと確率計算演算子Dの似ている部分を抽象化して取り出したモノがモナドTだという説明は今まで読んだ中で一番分かりやすかった

他はどういう内容なの?
そっちから探したほうが早い気がする。

>>932
単行本だけど章ごとのアンソロジーみたいになってて、全部で5章くらいあって、最後の章にいきなりモナドが出てきた
他の章は応用数学だけどモナドとは無関係で独立した内容だった気がする

離散数学系?

是非特定求む

数学関連新刊一覧
http://www.roy.hi-ho.ne.jp/shomoku/ntb/4/a01.htm

たぶんこれ
http://www.amazon.co.jp/%E8%B6%8A%E5%A2%83%E3%81%99%E3%82%8B%E6%95%B0%E5%AD%A6-%E8%A5%BF%E6%B5%A6-%E5%BB%89%E6%94%BF/dp/4000050958/ref=sr_1_1?s=books&ie=UTF8&qid=1375793177&sr=1-1

最後の方の章を立ち読みすれば分かると思われ

論集みたいなものか
蓮尾一郎という人がそれっぽいね
ttp://www.iwanami.co.jp/moreinfo/0050950/top.html

数学できないゴミクズほど数学の重要性をわめきはじめるよな
なんでだろう？
戒めてるのかな
苦労したからほざいてるのかな？

そういうゴミクズは穀すべきだね

スレチ

何か嫌なことがあったんだろうけどファビョりすぎ

スレチというより鼬

喚いているのが>>938だけな件について

>>936
ありがとう

えさをあたえないでください

お前ら本当にモナドが好きなんだな・・・

モナドはお菓子のホームラン王ですから

最中？

スレチというより、うちはイタチ

モナド　コモナド　マゴモナド

上で出てた本を本屋で立ち読みしてきた
モナドそのものの説明は分かりやすいけど、型とモナドの関係はあんまり分からなかった

>>947
ナボナ知らない世代？
哀しいなぁ

最近いじり始めたんだけど
もう統合開発環境に慣れてるから
テキストエディタとコマンド辛い

また、そっちに話戻すのかよ！

>>952
大丈夫、エディタもすぐ慣れる

いつまでも慣れなければ歳のせいだから諦めろ

むしろ、IDEは、いちいちキーボードから手をはなしてマウスをさわるのが嫌になる

どんだけしょぼいIDE使ってるんだよ……

早くﾊｽｹﾙでIDE創れよ

Haskellでできたエディタとかあるの？

cabal install yi

emacs とターミナルで十分なのは俺だけか…
逆に、何を求めてIDEを使うのかが分からない

haskellならsublimetextとvimで良い

>>960
・コードと連動したウィジェットのペタ貼りによるGUIアプリの開発
・Cabal を用いたパッケージ化やテストなどの支援
・弱頭部正規化の様子やサンクなどコンパイラ内部の挙動も晒したデバッガ
・コード解析
・プロファイリングの支援

この辺りを一つに統合した、見た目や操作がシンプルな IDE を求む。

>>962
コードと連動したウィジェットの
というところで既にわからん(笑)

ん、俺はGUIだけは欲しいと思ったな
他は統合されてなくてもいい

>>963
どこが面白かったのかよく分からんが、要するにWIZIWIGなGUI開発ツールだ。
（WIZIWIG ももう死語かもしれんが）

ここでいうウィジェットというのは、Win32APIでいうところのウィンドウクラスが定義されたパーツだ。
wxやGTKなどではほぼ同じものをウィジェットと呼んでいる。
それらをWIZIWIGなGUI開発ツール上で仮想的なウィンドウにペタペタ貼っていくことで、
各ウィジェットのウィンドウ上の位置やサイズ、挙動などを直感的に定義していく。
これがよくあるIDEの機能の一つだ。

コードと連動したというのは、WIZIWIGなGUI開発ツール上でウィジェットを貼った際に、
実行時にそのウィジェットが表示されるようにプログラムコードも自動的に変更される機能だ。
逆、つまりコードを改変することでGUI開発ツール上のウィジェットが変更される機能もある。
VisualStudioのC#用にはそんな機能もあったはず（他の言語はしらん、あるかもしれん）。
ウィジェットの主だった定義をプログラムコードではなくXMLなどのファイルに分離させる場合は、
もちろんそのXMLファイルも連動する。

そのような機能を持ったGUI開発ツールがHaskell用のIDEに統合されているといいな、という話だ。


既に分からんということは、その先も分からんのか？
だったら面倒だが説明してやるぞ。

まずライブラリのリンク機能を用意しなくっちゃね

>>965
WYSIWYGな

>>967
そうだったけ

まぁいいや

>>965
> 既に分からんということは、その先も分からんのか？
> だったら面倒だが説明してやるぞ。

ふつーは自分で調べろってながれかと思えば
説明してくれるとはありがたい。

963ではないけれど説明してくれると幸いです。

Visual Studio とXCodeとEmacsの補完してくれるやつ(AC?)
使ったことあるんだけれど、選択候補が現れるたびに、
メニューが開いたり、(上下)キーを奪われたりでいまいちいらっとした。

なんかのWebページ見たんだけど、IntelliSenseがあると
ドキュメントを見なくて済むそうな。
でも、そんなの危なっかしくない ?

>968
What You See Is What You Get のアクロニムなんだから
まぁいいやはいかんでしょ

>>969
よし、至極面倒だが説明しよう。

・Cabal を用いたパッケージ化やテストなどの支援
HackageDBにアップ時に Cabal でパッケージ化したり、
Cabal で自動テストを書く際に *.cabal ファイルを書かなきゃならんが、
http://itpro.nikkeibp.co.jp/article/COLUMN/20121106/435201/?ST=ittrend
http://itpro.nikkeibp.co.jp/article/COLUMN/20121205/442042/?ST=ittrend
これをみると分かるように、手書きでこれをするのはちょっと死ねる。
GUIでダイアグラムやプロパティシートをちょちょっといじって設定できると便利。

・弱頭部正規形の様子やサンクなどコンパイラ内部の挙動も晒したデバッガ
（>>962 では正規化と書いたが正規形の間違いだ）
トレースしたり、printf デバッグをして変数の値を調べても、
「なんでこんな値になってんだよ」と思うことはしばしばある。
GHC が関数を評価（弱頭部正規形にまで簡約）している様子や、
その瞬間のサンク（未評価の関数）が何かわかると超便利だ。
たとえば、本当にメモ化されているのか、わざわざ処理時間を測らなくても分かるわけだ。
ガベージコレクトの様子も分かると尚良い、スペースリークの原因が容易に分かるかもしれん。

・コード解析
コードの静的な解析だ。

・プロファイリングの支援
複数のプロファイリング結果（普通のコード、最適化を施したコード、もっと最適化を施したコードなど）
を比較検討するための支援があるといい。
計算効率が改善されたのはこのコードのこの部分のおかげだという事をコードにメモ書きできたり、
そこにプロファイリング結果のグラフを貼り付けたりできると便利だろ。

こういうことが、Emacs から個々の機能を呼び出して個別にインタラクトするのではなく、
IDE として統合されていて、全ての機能が情報を共有していて有機的に機能すれば素晴らしい。

個別にインタラクト以上に何が必要なのか全くわからんのだが

そもそもEmacsから呼べる必要性すら感じない機能ばっかりなんだけど……

効率がまったく違うんだけど
給料泥棒すぎる

ああ、説明できないのね。理解した

理解早いな

ソースの編集だけはemacsでやりたい

IDEの利点って、コード解析と補完を統合したIntelliSenceとか、コード解析と編集を統合したリファクタリング機能とかじゃないの
>>971は何と何を統合してどんな機能を実現したいんだ？

IDEの利点は、たとえどんなに使いにくくて効率が悪くても、同じ方法同じスクリーンショットで開発手順を教育できるという点です

使い分けりゃいいだけなのに
無能はすぐ否定するんだから

IDE厨は低能揃いだなぁ

機能詰め込めば解決すると思ってるからな
IDE使ってない人間は単に個々の機能使い分けてるだけなのに

IDE使わない人は関数の呼び出し階層どうやって調査してるの？

ん？遥か昔からtagジャンプと呼ばれてるアレ？

統合環境を馬鹿にしてる奴は、つまり自分のことしか考えていない。
統合環境を使いたくない奴は使わなければいいだけのこと。
haskellが広く普及するためには避けられないことだ。

Haskellなんて趣味でしか使わんからw

大規模システムに使われている例はすでにある。
一年ほど前の日経コンピュータ？に載ってる。

つまり、趣味でしか使わんからと言ってる奴は、ただの世間知らず。

haskellがもっと広く普及するためには統合環境は不可欠。
使いたくない奴は使わなければいいだけのこと。

>>984
タグジャンプじゃなくて目的の関数を呼び出してる関数を再帰的に全部列挙する機能
もちろん列挙した関数へジャンプできる
この機能がないと中規模以上のプロジェクトでは仕事にならない気がする
市場トラブルで即日対応が求められるような場合もちんたらemacsとかやってるのかっていう素朴な疑問

統合環境を馬鹿にしてるんじゃなくて
統合環境がないと不便だなんて言ってる似非プログラマを馬鹿にしている

日経コンピュータｗ
まあそれでなくては困るなｗ

便利なツールを使わない玄人思考の似非プログラマっているよね…
趣味ならテクニックに溺れるのは勝手だけど人生は短いよ？

統合環境を馬鹿にしてないのに、ないと不便だと言ったら似非？
統合環境のどこに価値を見出してるのか意味不明

使い分けだって言ってるのにまだ理解できてないんだな
自分の希望を自分で叶えず長文で垂れ流すだけの奴に言っても無駄かな

まあ関数の呼び出し機能でタグジャンプなんて出てくる時点で
化石みたいな環境から改善する努力を怠ってる人間だと言うのは想像できる

それ具体的にどう使い分けてんのか言わないと説得力ないで
まあ挙げられんだろうが

>>995
具体的に使う頻度が高いのはGUIデザイナとリファクタぐらい
設計は今のところ単体のが効率いいから触ってないし
どうだ？統合環境だから何もかも便利とは限らないだろう

一行消えてたぜ
エディタは使ってない奴多いんじゃないかなと書いた

おまいら次スレがですね

そろそろ消え

>>985
Haskellが広く普及なんて永遠にしないのに、なんでそんなこと気にするんだ？

このスレッドは１０００を超えました。
もう書けないので、新しいスレッドを立ててくださいです。。。