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

haskell.org
http://www.haskell.org/

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

過去ログ
関数型プログラミング言語Haskell
Part1 http://pc.2ch.net/tech/kako/996/996131288.html
Part2 http://pc2.2ch.net/test/read.cgi/tech/1013846140/
Part3 http://pc8.2ch.net/test/read.cgi/tech/1076418993/
Part4 http://pc8.2ch.net/test/read.cgi/tech/1140717775/
Part5 http://pc8.2ch.net/test/read.cgi/tech/1149263630/
Part6 http://pc11.2ch.net/test/read.cgi/tech/1162902266/
Part7 http://pc11.2ch.net/test/read.cgi/tech/1174211797/
Part8 http://pc11.2ch.net/test/read.cgi/tech/1193743693/
Part9 http://pc11.2ch.net/test/read.cgi/tech/1211010089/
Part10 http://pc12.2ch.net/test/read.cgi/tech/1231861873/
・2chの仕様により、行頭の半角スペースは表示されません。
　コードをインデントしたいときは、代わりに または全角スペースを使うことができます。

関連書籍
・Introduction to Functional Programming Using Haskell
　http://www.amazon.co.jp/exec/obidos/ASIN/0134843460/
・Haskell: The Craft of Functional Programming
　http://www.amazon.co.jp/exec/obidos/ASIN/0201342758/
・The Fun of Programming
　http://www.amazon.co.jp/exec/obidos/ASIN/1403907722/
・The Haskell School of Expression: Learning Functional Programming Through Multimedia
　http://www.amazon.co.jp/exec/obidos/ASIN/0521644089/
・入門Haskell
　http://item.rakuten.co.jp/book/1794880/
・ふつうのHaskellプログラミング
　http://item.rakuten.co.jp/book/4052963/
・Programming in Haskell
　http://www.amazon.co.jp/exec/obidos/ASIN/0521692695/
・Real World Haskell
　http://www.amazon.co.jp/exec/obidos/ASIN/0596514980

関連スレ
・関数型言語Part IV
　http://pc11.2ch.net/test/read.cgi/tech/1083649982/
・【数学者】Haskellはクソ言語【オナニー】
　http://pc11.2ch.net/test/read.cgi/tech/1128011645/
・純粋関数型言語Concurent Clean
　http://pc11.2ch.net/test/read.cgi/tech/1075629340/
・関数型言語ML (SML, OCaml, etc.), Part 6
　http://pc11.2ch.net/test/read.cgi/tech/1245017721/
・Lisp Scheme Part27
　http://pc12.2ch.net/test/read.cgi/tech/1248657331/
・【入門】Common Lisp その６【質問よろず】
　http://pc12.2ch.net/test/read.cgi/tech/1234884136/
・Emacs Lisp 3
　http://pc11.2ch.net/test/read.cgi/tech/1191875993/

GHC 6.6 の日本語の取り扱い
1. ソース中の文字列 hello = "こんにちは" :: String は UTF-8
2. これを ghci で表示することは可能：(ただし、環境変数 LANG を UTF-8 にしておくこと、
また、ターミナルも UTF-8 で入出力できるようにしておくこと)
Main> print hello
こんにちは
Main>
3. 入出力 IO は Latin-1 だが、
package utf8-string (http://code.haskell.org/utf8-string/)
を導入することにより、入出力を UTF-8 にすることができる
4. その他の文字列エンコード(ShiftJIS, JIS, EUC-JP など) は、
package iconv (http://hackage.haskell.org/cgi-bin/hackage-scripts/package/iconv)
で UTF-8 な文字列にする
とまあ、こういうことで、日本語表示できるわけだ。iconv package は MacOSX と *BSD では
cabal を少しいじらなければいけないことに注意しろよ(iconv.cabal のコメントに書いてある)

・そのほかの日本語の扱い

Haskell98によると、Charは一つのUnicode文字を表す(6.1.2)。
これに従って、比較的新しいHugsやGHC(6.4系を含む)ではCharは32ビット整数になっている。
ただし、どちらも入出力に際しての変換が完全でない。具体的には、
・ソースコード中の文字列リテラル
・System.IOライブラリでの入出力
が問題になる。

1. GHC6.4.2以前
ソースコード・入出力ともLatin-1を仮定する。Latin-1ではバイト値と
コードポイントが一致するので、入力時には外部エンコードの各バイトがそのままCharに
入り、出力時にはCharの下位8ビットのみが出力されるような実装になっている。
このため、あるエンコーディング(Latin-1とは限らない)の入力をgetLineで受け取り、
それをそのままputStrで表示すれば、入力時とおなじエンコードにおいて正しく表示される。
これを利用して、[Char]を、本来のコードポイントの列としてではなく、特定のエンコードの下での
バイト列として使うことができる。ただし文字列リテラルについては、GHCはLatin-1として
不正な文字を受け付けないので、EUC-JPのような例外を除くと、単純にリテラルを使うことはできない。

3.最近のHugs(非WindowsかつCのwchar_tがUnicodeの環境、というかLinux)
ソースコード・入出力ともロケールのエンコードを利用する。

4.最近のHugs(Windows)
ソースコード・入出力ともLatin-1を仮定する。ただし文字列リテラルにShift-JISを使ってもエラーにならない。

5.最近のHugs(それ以外)
未調査。

・結局どうするか。
規格どおりにCharにUnicodeを入れるか、Charを単なるバイトとして扱うかの二択。

i. CharをUnicodeとして扱う
(3)以外の場合入出力で変換が必要。(2)または(3)以外の場合文字列リテラルでは
明示的なエスケープ(たとえば"\22234")が必要。

ii. Charをバイトとして扱う
(3)ではファイルをバイナリモードで開くなどの対策が必要。(1)でEUC-JPを使う場合と(4)
を除き文字列リテラルでは明示的なエスケープ(たとえば"\143\153")が必要。
lengthやisAlphaのような関数、およびwin32パッケージの関数(win32API)が正しく動作しない。

　　　　　　　　　　　　　　　　　　　　　　　　　 刀、　　　　　　　　 　 , ヘ
　　　　　　　　　　　　　　　　　　／´￣｀ヽ ／: : : ＼＿＿＿＿＿／: : : : ヽ、
　　　　　　　　　　　　　　,.　-‐┴─‐- ＜＾ヽ、: : : : : : : : : : : : : : : : : : : : : : }
　　　　　　 　 　 　 　 ／: : : : : : : : : : : : : :｀.ヽl____: : : : : : : : : : : : : : : : : : ／
　　　　　,.　-──「｀: : : : : : : : :　:ヽ: : : : : : : : :＼ ｀ヽ￣￣￣ フ: : : : :／
　　 　／: :.,.-ｧ: : : |: : : : : : : : :　　　 :＼: : : : :: : : :ヽ　 ＼ 　 ／: : : :／
　　　￣￣／: : : : ヽ: : : . . . . . . . . . . .､ ＼=--: : : :.i　 ／　/: : : : :/
　　　　 ／: : 　　　 ∧: ＼: : : : : : : : : : ヽ: :＼: : : 〃}/　　/: : : : :/　　　　　　　　 、
.　　　 /: : /　　. : : :! ヽ: : l＼_＼／: : : : :＼: ヽ彡: : |　　/: : : : :/　　　 　 　 　 　 |＼
　　　/: : ｨ: : : : :.i: : | 　 ＼!___／ ヽ:: : : : : : :＼|:.:.:.:/:!　 ,': : : : /　 　 　 　 　 　 　 |: : ＼
　　 / ／ !: : : : :.ト‐|-　 　 ヽ　　　　＼: : : : : l::::__:' :/　 i: : : : :{　　　 　 　 　 　 　 |: : : :.ヽ
　　 l/ 　 |: : :!: : .ｌ: :|　　　　　　　 　 　 ＼: : : l´r. Y　　 {: : : : :丶＿＿＿＿＿__.ノ: : : : : :}
　　　　　 l: : :ｌ: : :ﾄ､|　　　　 　 　 ､＿__,ィ ヽ: :| ゝ ﾉ　 　 '.: : : : : : : : : : : : : : : : : : : : : : ／
　　　　　 |: : :ﾄ､: |: :ヽ ___,彡 　 　 ´￣´　　 ヽl-‐'　　　　 ＼: : : : : : : : : : : : : : : : : : イ
　 　 　 　 !: :从ヽ!ヽ.ﾊ=≠'　, /////　///u /　　　　　　　 　 ￣￣￣￣￣￣￣￣
　　　　　　V　 ヽ|　 　 }///　 r‐'⌒ヽ　　イ〉、
　　　　　　　　　　　 　 ヽ､______ｰ‐‐' ィ´　/:/:7rt‐---､　　　　　　　こ、これは>>1乙じゃなくて
　　　　　　　　　　　　　　　　　　ィ幵ﾉ　./:/:./:.! !: : : : :!｀ヽ　　　　　ポニーテールなんだから
　　　　　　　　　　　　　　r‐'T¨「 |: | !:.∨:/:./: :| |: : : : .l: : : :＼　　　変な勘違いしないでよね！
　　　　　　　　　　 　 　 /: : .|: :|　!:.!ィ¨¨ヾ、:.:/　!: : : : l: : : : : :.＼

>>1乙じゃない。もう建てなくていいスレ

乙一

実践 Haskell (real world haskell 和訳本)

今月の予定らしいけどオライリーの近刊に出てないねー

質問していい？
以下のモナドのなかで、union は Ord a であるところの Set a にしか使えません、と怒られるんだが、どこで制約課したらいいの？

---------------------------------------------------------------------------
import qualified Data.Set as S

data Distribution a =
Dist { sample :: a, support :: (S.Set a), expectation :: ((a -> Double) -> Double) }

always :: a -> Distribution a
always x = Dist { sample = x, support = S.singleton x, expectation = \f -> f x }

newtype Probability a = Prob { runProbability :: Distribution a }

instance Monad Probability where

　　p >>= f =

　　　　let x = runProbability p in

　　　　Prob $ Dist { sample = sample $ runProbability $ f (sample x),

　　　　　　　　　　　　 support = S.fold (\d -> S.union $ support (runProbability $ f d)) (S.empty) (support x),

　　　　　　　　　 　　　expectation = \g -> (expectation x) (\x -> (expectation (runProbability $ f x)) g) }

　　return a = Prob $ always a

----------------------------------------------------------------------------
Could not deduce (Ord b) from the context ()
arising from a use of `S.union'
Possible fix:　　add (Ord b) to the context of the type signature for `>>='

>>10

今月じゃないって聞いてるよ。
近刊に出てきてないのはそのせいじゃないの?

>>11
標準のモナドは要素の型に制約を掛けられない
逆に言うと、Probabilityは要素の型に制約があるのでMonadになっていない
だからどういう注釈をつけても無理

>>13
ありがとう
ってことはリフレクションつかって自分で union 関数つくるしかないってことですね

しかし

Prelude Data.Set Data.Typeable> typeOf (empty :: Set Int)
>Set Int

はいいとして

Prelude Data.Set Data.Typeable> typeOf (empty :: (Ord a) => Set a)
>Set ()

これは納得いかねぇ…

http://www.haskell.org/ghc/docs/latest/html/users_guide/interactive-evaluation.html#extended-default-rules
これだな
プロンプトじゃなくてファイルに書けばこの規則は適用されないから、ちゃんと曖昧エラーになるはず

デアゴスティーニなんかが
「週間Haskellコンパイラ」
なんて出してくれたら面白いのに

付録なんだよ？

余り物の福袋

>>17
んなもんはライブラリの解説がついた小冊子や小さなポスターでいいだろ。
トイレに貼って覚えるんだ。

>>11
モナド構造わかってないけど、Distributionって超関数の意味？
ということは、Probabilityは確率測度ってこと？

Haskellでσ-集合体クラスを定義して下さい

「The haskell School of Expression」を読んでいて、172 ページで躓きました。
lifting というものの考え方がいまいちよく分かりません。
頭が混乱しています。

このページの例で言えば、lifting の考え方を使って
Picture でできる事を Animation でもできるようにしているんですよね。

では、先の章で定義した containsR 関数や containsS 関数は、
Resion から Shape への、あるいは Shape から Region への lifting ではないのですか。
Region できる contain の演算を Shape でもできるようにする、
あるいはその逆が実現されているような気がするのですが。

>>10
10月に出るみたいだね

Books: 新刊・近刊情報
http://www.oreilly.co.jp/catalog/soon.html

Programming in Haskell さ、作者さまのページ見ると

A Japanese version will be published around October 2009.

と、なってるよ。

第二次 haskell 本ブーム？

２冊でブームってのも悲しいな。

千里の途も一歩から

あれ、入門書が２冊あるから３冊目では？
あと岩波からもGofer本が出ていたから、それを入れると４冊目か

今年の十月に予定されてるのが二冊ってことでしょ。

あ、そういふことですたか。吊ってきます

4冊でブームってのも悲しいな。

Gofer本って、岩波講座ソフトウェア科学 4 のこと？

型 A に対して可能な演算と同類の演算を型 B に対してもできるようにする、
という事が既に Lifting になっているのでしょうか。

型 A に対して可能な演算と型 B に対して可能な同類の演算の名前が違っていても、
それは Lifting には変わりなく、ただ同じ名前の演算が定義されていた方が
より洗練された Lifting だということなのでしょうか。

lift,liftってよく聞くけど、なんかあるの？
普通出会わないだろ。liftMぐらいじゃね？
なんなのliftって？

処理系の設計に足をつっこむと
しょっぱなで出くわすのがlambda lifting

lambda liftなんてあるのか。
でもいまの話ってtype lift（型持ち上げ）の話だろ。

>>32
Payton JonesのImplementation of Functional Programming Languages
がどこかにpdfであったはず
13章を読むといいよ

>>32じゃなくて>>35だった

>>35
私が質問しているのは恐らく type lift の事だと思います。

もし type lift がどういうものか知っているのでしたら、
是非教えて頂きたいです。
172 ページを付近を飛ばしてとりあえず先に読み進んでみましたが、
やはり意味が分からず、内容が頭に入ってきません。
はっきりさせたいです。

なんかすげー面白そうだな

Liftingというコンセプトを理解したければ、
俺が知りたいのはtype liftingだ、lambda liftingなんて関係ない、
なんて言ってないで、関係あるものはさっさと読んだほうがいいぜ？

PJの説明はそう悪くないし。

>>38
あんまり参考にならないだろうけど、型持ち上げはゲーデル（もしくはPM）にはじまる。
不完全性定理の証明に出てくる。
定義としては、
ある論理式aと別の論理式bがあるとして、
bがaの型持ち上げであるとは、bの全ての型のタイプ数を同じ数だけ
増加させると、bがaになることを指す。

というもの。PMがベースなのでそのままは適用できないけど、liftMを
使ってほぼ同じだと思われることは一応出来る。
a -> b => [a] -> [b]
みたいなの。

実は、自分もおなじことずっと調べていて、情報が欲しい。
そっちでなんか分かったら教えてくれると嬉しいかも。>>36も読んでみる。

>a -> b => [a] -> [b]
じゃなかった。
a -> b -> (a,b) => [a] -> [b] -> [(a,b)]
だった。

タプルを作る関数を型持ち上げ＝＞直積を作る関数。
p x y = (x,y)
directProduct :: [a] -> [b] -> [(a,b)]
directProduct = liftM2 p

>>40
ちょっと待って、飛躍しないで欲しい。
lambda liftingなんて関係ないなんて一言も言ってないし思ってもない。
そもそも、type lift と lambda lifting の違いすら今は全く分からない。

ただ、>>35 の言い方から、lambda lift は今回の話には繋がらないのか、
と推測しただけです（あの言い方ならそう推測してもおかしくないと思うが）。

で、私も「Implementation of Functional Programming Languages」を落としたので、
読んでみます。

実際、全然関係ないぞ

>>44
そうなんですか。
でも、やっぱりよく分かんないので、
とりあえず紹介された文献を読んでます。

まだ2章5節なんですけど、これはおもしろいですね。
ここまででもすごく勉強になります。
以前「Lambda-Calculus and Combinators an Introduction」を読んでいて、
p34 の不動点定理のところで意味が分からず挫折していたのですが、
ようやく意味が分かり、思わぬ収穫です。

13章にはほど遠いので、
lifting の意味はまだ全く分かんないですけど。
おもしろい文献の紹介、ありがとうございます。

10年前にmonadと出会って以来、何千回と挫折してきた俺がついに悟った！

これは

単なる

イディオムだ

最中どう？どうもなか？最中どう？どうもなか？最中どう？どうもなか？最中ど
う？どうもなか？最中どう？どうもなか？最中どう？どうもなか？最中どう？ど
うもなか？最中どう？どうもなか？もなかどう？どうもなか？もなかどう？どう
もなか？もなかどう？どうもなか？もなかどう？どうもなか？もなかどう？どう
もなか？もなかどう？どうもなか？もなかどう？どうもなか？もなどどう？どう
もなど？もなかどう？どうもなか？もなかどう？どうもなか？もなかどう？どう
もなか？もなかどう？どうもなか？もなかどう？どうもなか？もなかどう？どう
もなか？もなかどう？どうもなか？最中どう？どうもなか？最中どう？どうもな
か？最中どう？どうもなか？最中どう？どうもなか？最中どう？どうもなか？最
中どう？どうもなか？最中どう？どうもなか？最中どう？どうもなか？最中どう？

WINDOWS VISTA 環境に以下を参考にghcを導入した。

http://d.hatena.ne.jp/coppieee/20090416/1239903149
導入したEclipse SDKはVersion: 3.3.2
Eclips用のHaskell モジュールが最新のEclips 3.5に未対応な為
リンク先の
>> 5. Windw -> Preferences -> Functional Programming -> Haskell -> Compiler -> GHC compiler -> Browseボタンでインストールしたghcのコンパイラ選択。
に有るように、正確にGHCの場所を指定しなくても動作する
ただし、インタープリタGHCiの場所を認識しないので、ghcの場所は正確に指定し
インタープリタghciの接待タブでghcの場所設定を利用するにチェックを入れる。

Eclipsの日本語化はhttp://mergedoc.sourceforge.jp/　を参考にどうぞ

少し疲れたｗ

>>32
元の構造は保たないと。
ファンクタなんで。

函手じゃなくて自然変換じゃないか。
一意に決定しないと使い物にならない。

函手って見ると
ハルヒの射手座の日を思いだす

理由はよくわからない

slashdotのコメント欄はわかってないヤツが多いな。
http://slashdot.jp/developers/09/09/24/039226.shtml

こういう連中がいる会社は最悪だろうな。まさに老害。

どういう連中か目に浮かぶようだ

Agdaって今世界でもっとも難しい言語の１つだよね？
極めれば即仙人になれる難しさだよね？

俺写像定義するだけで投げたレベルだからあれだけど

ほんとか！ちょっとAgda勉強しにいってくる。

魔法使い卒業検定には使えますか?

卒業なんてない。
死ぬまで学徒。

real world agda が出てから勉強する！

>>54
別に難しくないじゃん。
数学系ならさほど障害は無いと思う。

>>54
Coqよりだいぶマシ

darcsからbzrに乗り換えるか悩む

darcsって正直Haskell製以外にメリットなくない？不安定でたまにプロセスが止まったり、パフォーマンスもあんまよくないし。
git/bzrメインに乗りかえたらすごい快適になった。Haskell製ってことで期待しすぎたのかもしれないが、
正直最近はdarcsなリポジトリみるとウンザリする。

darcs 2.0.2だと実行ファイル単品で動いてたからインストールとか楽だったんだけど、
それ以降の奴ってdllが増えててやだなぁと思って使ってない。

git/bzr使おうかなぁとか思ったりもするけどmsysやらなんやら周辺のファイルの多さが気に入らない。

All About Monadsの原文のページが
例のおねーちゃんに乗っ取られてる

sampou.orgにあるから別にいいんだけど
なかのひとがどうしているのか気になる

GHC-6.12.1からSystem.IOが内部エンコーディング<->ローカルエンコーディングと
改行コードの自動変換をするらしい。

ttp://ghcmutterings.wordpress.com/2009/09/30/heads-up-what-you-need-to-know-about-unicode-io-in-ghc-6-12-1/

Haskell のカーネルって基本的にLispと同じだよね？
ガベージコレクタがあって
8ビットCPUの時代Lispのインタープリタは4kbyteほどしかなかった気がする
Haskellのフロントはhaskellのカーネルに食わせるために単純な演算塊に展開してやると
で、Haskellの基本的部分はかなりコンパクトに実装できるのかな？と思った。

>>66
> Haskell のカーネルって基本的にLispと同じだよね？

違う

チューリング完(ry

http://haskell.g.hatena.ne.jp/taninsw/の

qsort[]=[]
qsort(x:xs)=qsort larger ++ [x]++ qsort smaller
where
smaller = [a|a<-xs,a <=x]
larger = [b|b<-xs,b>x]

What would be the effect of replacing <= by < in the definiton of qsort? Hint:consider the example qsort[2,2,3,1]
改変されたqsortをqsort'だと仮定する

qsort[2,2,3,1]=qsort [2,1] ++[2]++qsort [3]=(qsort[1]++[2]++qsort[])++[2]++(qsort[]++[3]++qsort[])
=((qsort[]++[1]++qsort[])++[2]++[])++[2]++([]++[3]++[])
=[]+[1]+[]+[2]+[]+[]+[2]+[]+[3]+[]=[1,2,2,3]

qsort'[2,2,3,1]=qsort [1] ++ [2] ++ qsort[3]=qsort[]++[1]++qsort[]++[2]++qsort[]++[3]++qsort[]
=[]++[1]++[]++[2]++[]++[3]++[]

つまり、同じ値が複数あるときは、ひとつを残して消えてしまう。
−−−−−−−−−
で、値が消えないんだけど文意を取り違えているのかどうなんだろう
消える様に改変しろなのかな？
smaller = [a|a<-xs,a <=x]をsmaller = [a|a<-xs,a <x]すると消えるけど

>>69
「改変したらどうなるか？」ってのが問いで、「値が消える」が答え

What would be the effect of replacing <= by < in the definiton of qsort? Hint:consider the example qsort[2,2,3,1]
qsortの定義の中の<=を<に変えたとすると、何が起きるだろうか。ヒント　qsort[2,2,3,1]という例で考えてみよ

晒しているのか、まじ質問なのか、判断できん。

前者なら死ね。
後者ならどんだけ自分に自信がないんだ。君はできる子だよ。

>>67
どう違うのか簡潔な説明が欲しいけど
”違う”の一言で終わりそうな感じなのであきらめます。

Lisp系の場合はほんのわずかな特殊なものを除いて、
インタープリタ込みの構造になってる。
そして動的型付け。

いや、元Lisperなんでスレ違いだがおもわず。
それSchemeじゃない？Lispだと大抵コンパイラ込みで、宣言型型付けだろ。

実装による。
しかし、コンパイラでもマクロ展開を考えたら実質的にはインタプリタみたいなものは入ってなきゃだめだろう。
(CommonLisp でも Scheme でも。)
型については CommonLisp では型宣言できるけど、最適化のヒントでしかない。
型に応じて言語が何かしてくれるということはぜんぜん無い。
まぁ、「Lisp系」ってのは幅が広いので、ひとまとめで語るのが無茶だよ。

> 型に応じて言語が何かしてくれるということはぜんぜん無い。
型が宣言できるなら実装がなにかしてくれるかもしれないのでは？

しまった、Haskellスレか。関数型言語スレかとおもった。ごめん無視して。

言葉足らずですまないです。
Haskellをインタープリタだけ実装した場合lispに似てるのかな思ったので
言語仕様上は短精度、倍精度実数とか文字列とかあるけど
中身はリストさえclassとして実装している面白そうな物だなとか

a (n+1) = n で
a 1 を実行すると　0
a 2 を実行すると　1
a 0 を実行するとエラーになって思わず仰け反ったり、油断ならね〜

GHCのガベージコレクタは優秀とか言われているけどどうやっているのか興味が沸いたり
プログラムが関数の定義塊なのに、ｃ系統のつもりで読んでパニック起こしたり
快感と言うかグッ来るものがある

やっぱりなにが言いたいのかよく分からない

>>78
Yhcのソースでも読んで見りゃいいんじゃない？
http://www.haskell.org/haskellwiki/Yhc

>>74
Haskellとの比較だから、コンパイラあるのは違う点に入らない。
実行時に型宣言ないlambda式生成できるので、
動的型付け必須で、データをunboxing出来ない。

Implementing lazy functional languages on stock hardware: the Spineless Tagless G-machine でも読んだら？

実際は Lisp でも型宣言したら静的型付けと同じように、
その型に応じた演算がされるから SBCL とか結構速い

>>83 >>82を読め

>>82
ps落としてきたんだけど、gvでエラーになっちゃう

>>85
GhostScript を使って読むとか ps2pdf ってコマンドが同梱されているから pdf に変換するとかすればいいと思うよ

>>86
�d

>>84
え、何で俺?

Lispの型宣言と違い、Haskellの型宣言は、Haskellで書かれたコード全てに
強く強制されるから、コンパイラは、型的に正しいコードしか存在しないことを
仮定してコード生成ができる。

構造化プログラミングのAlgol
オブジェクト指向プログラミングのSmalltalk
そして関数型プログラミングのHaskell

10年後くらいにはこんな感じの認識になってるんじゃないかと思う

そしてC++のポジションにはScalaが座っていると

C++のポジション → みんなから罵詈雑言を浴びせられ続ける……ってこと？

>>89
Lispは逆のアプローチじゃなかったかなあ
最適化に必要な型や仮定をプログラマが与える
コードが適切な振る舞いをすることは、型システムでなくてプログラマが保証する

オライリージャパン早くしろよ

RWH待ち遠しいな

kazuさんのブログ面白いよね

cabal-installってユーザ単位の環境の作成管理がデフォだったっけ？
前は普通に/usr/local以下を管理してくれたと思ったが

userとglobalでprefixが$HOMEと/usr/localでなんちゃら

ttp://shootout.alioth.debian.org/
なんか前よりhaskellのランクが落ちてるような。他が良くなったのか。

Haskellの.NET実装ってある？

IronHaskellとかH#みたいな。

Haskell.NETってのが…計画倒れ？
http://php.cin.ufpe.br/~haskell/haskelldotnet/

F#「椅子はひとつよ♡」

F#はHaskellじゃないし

正格なんだっけ？

Programming in Haskellの翻訳はいつ出ますか？

どこからでるんだろね

http://shootout.alioth.debian.org/u32/shapes.php

Ocamlに圧倒的に負けてるね。とくに簡潔さで。
Haskellの記述力が弱いのか？

http://shootout.alioth.debian.org/u32/benchmark.php?test=all&lang=ghc&lang2=ocaml

によると、source sizeで一番Ocamlに差をつけられているのがregex-dnaというプログラム

Haskell GHCのコード
http://shootout.alioth.debian.org/u32/benchmark.php?test=regexdna&lang=ghc

Ocamlのコード
http://shootout.alioth.debian.org/u32/benchmark.php?test=regexdna&lang=ocaml

詳しい人解説プリーズ、と思ったらそもそもOcamlのコード動いてねえ！

>>106
人が何に対して、何を基準にして簡潔さを感じるか、の違いだと思う。

私が感じる簡潔さはあのグラフでは表現されない。
私には Haskell は Ocaml に対して簡潔さにおいて圧倒的に負けてるとは思えない。

くやしいのうｗｗｗｗｗｗｗくやしいのうｗｗｗｗｗｗｗｗｗ

>>107
ﾜﾛﾀｗ

オライリージャパンの近刊情報にRealWorldHaskellがあるけど
組み込みLinux〜とかとちがって発売日不明だし、十月は無理くさいね
ttp://www.oreilly.co.jp/catalog/soon.html

関数言語系の日本語の本は誤字脱字とかミスがひどいのが多いから
きっとRWHもそれで必死に校正してるんだろうな

>>107

> Fatal error: exception Failure("Buffer.add: cannot grow buffer")

バッファオーバーフローみたいなもの？
N=500,000（オリジナルの1/10）では動くらしい
Ocamlはメモリマネジメントがあまりうまくないのかな

質問なのですが、型変換ってどうやったらいいのでしょうか？
Word8 -> Word みたいなことをやりたいのですが

fromIntegral :: (Integral a, Num b) => a -> b
fromIntegral = fromInteger . toInteger
でいいんじゃないか。

>>114
それでいけました
質問にお答え頂きありがとうございました

>>89
何かレベルの低い話っぽかったから見てなかったわ…

>型的に正しいコードしか存在しないことを
>仮定してコード生成ができる。

Lisp でも (declaim (optimize (safety 0) ... )) とかすれば、
型的に正しいコードしか存在しないことを仮定してコード
生成が出来るんだぜ。

それって正しい型宣言をするのはプログラマの責任で、型チェックはあっても処理系依存じゃん。
ミスがあったら実行時にエラーになっちゃう。Haskellのように安全かつ完全な型検査はできるわけじゃない。
そもそもスレ違い。

そりゃ、違う言語なんだから違う部分を探せば幾らでもあるさ。
そんなことを言って何が面白いのか知らんが。

>>118
いや、おまえは型検査がまるでわかっていない。

そうやって妄想するのは良いけど勝手に決めつけるなよ。
自分だけが知った気になってる奴が一番面倒くさいんだよな。

そもそも俺はこれ↓が間違いだと言ってるだけなんだがなあ。

>>81
>実行時に型宣言ないlambda式生成できるので、
>動的型付け必須で、データをunboxing出来ない。

Haskell のスレだが、Lisp について間違った認識をしている
人が居たから訂正したまでだよ。

>>121
言い訳はそれで終わりか？
学部の授業受けなおしたらどうだ？

どちらが正しいか俺にはわからんが、
>>121と>>122なら>>121の方に分があるように見える。

>>122のように無意味な誹謗を始めたら負けだ。

そういう煽り切ったら勝ちみたいなのは下らないから止めた方が良いと思うぜ。
>>121に異論が無いなら終わりだよ。

あ、ｽﾏｿ。>>124は>>122向けです。

型安全に関する理解が浅いのを
話題を煽り論争にスリ替えようとしているのが
あまりにもミエミエで笑った！

そもそも、最適化した Lisp の型に関する安全性を主張している訳じゃないことを
理解できてないだけでしょう。

単に煽りたいだけなのはミエミエだけどなあ。煽ればレスが貰えるみたいな、
レス乞食は面倒くさいから勘弁ね。ずっと笑ってなよ。

λ < スレ違いはもうやめて

オライリージャパン早くしろよ！

6.12.1-rc1ｷﾀｰ

realWorld、24日発売みたいですね。
で、Tシャツって４ｋ以上だから、もう一冊買わないとダメなんですかね。
やるなー、オライリー

宣伝はやめください

>>131
ktkr

ハスケル始まったな

しかしなんでWindows7の発売直後にぶつけるんだ？
金なくなってるから買えないよ

Windows7 と Haskell で Windows7 を取っちゃう人なの？

普通の人はそうでしょ？ｗ

普通の人はそうかもしれないが、このスレ住人が？って意味だろ

俺はどっちも買うよ

つーか、ド素人以外で、まだWindows7入手してない奴なんているの？

何このスルー検定w

windowsでHaskellなんて…

HaskellはLINUXでやるのが一番かっこいいんだぞ

(ｷﾘｯ

は？Linux？　遊びじゃねーんだよ

本気の人キター！

そう、HaskellやるならやっぱりWindows7だよね。
Vista、XPは糞。Haskellとの親和性が最高なのはWindows7。

どこがいいって？そんなのやってみりゃすぐ分かるだろこれだらド素人は。。。。

つうかWindows 7自体大部分がHaskellで書かれてるからまあ当然だが。

そもそも、MSの社員食堂のメニューがHaskellで書かれてたくらいだし。
むしろVista、XPがHaskell的に糞だった事が異常だったわけで。

Windows 7ってこれ？

http://programatica.cs.pdx.edu/House/

>>148
ないだろｗ

Vista はC#でほとんどが書かれてたみたいだね

そんなくだらないネタ会話しか話題がないのか。

ソース出せよ！

>>153
少なくとも>>150はネタじゃなかったりする。漏れも開いてみて驚いた。

realwoldhaskellはやくもきたー
ざっとみると、ghc6.10.1で動作確認してあるみたい？

6.10.4て書いてあった…

え？もうジュンク堂にあるの？

公式で通販しました
原著よりも一回り小さいので文字も小さいｗ　電車で読みやすそうだからいいけど

今日もseqを挟む作業だお……のAA下さい！

なんで $ は infixr なのに <$> は infixl なの

$ は数学の記法に合わせてあるんじゃないか。f(g(h(x))) -> f $ g $ h $ x
だから右結合。

<$> は部分適用みたいな使い方をよくするから、
左結合のほうが便利なのでは。
f <$> fx <*> fy <*> fz
で、<$>や<*>が右結合だと意味がおかしい。

あーなんか論理的じゃないな。

最近Coqなどの証明系が流行ってると聞きました。これはポストHaskellと言うべき言語なんでしょうか。
それとも、別種の、実用言語ではなくて理論を突き詰めるためのものなんでしょうか。

アホな質問ですみません、Coqのサイトを少し見たのですがさっぱり分からなかったので。
よろしくお願いします。

Haskell の型システムはそういった証明系ほど厳密ではない。
Haskell は証明系の理論をベースにしてはいるけど、用途としては汎用。
Coq は定理証明のために特化されているから立場が違うよ。

Coqは実用言語じゃないし、
実用言語しか興味のない人には何の関わりもない証明系。

証明支援系でもCoqはマイナーな存在ｗ

なるほど。Coqを学ぶとHaskellの型システムの理解が深まる感じですか。

>>167
ないないｗ

ここで言われている「証明」ってBirdのHaskell教科書に出てくるようなのですか？

>>169
ここ行け

コンピューターによる定理の自動証明
http://science6.2ch.net/test/read.cgi/math/1126017312/

ちゃんと買いましたか？おまいら

web公開版を印刷しました(^^;
カラーレーザープリンタ便利です

>>163
CoqやAgdaなどの証明支援器はHaskellやOCamlなどと連携する機能があるから、むしろ一緒に使うのが実用的だね。
大部分はHaskellで作って、一部の関数だけ証明器で開発し、信頼性をよりよくするという使い方だね。
Agdaは日本の研究機関(AIST)が開発しているから、官公庁系の業務で将来的に積極的に使われるかも。
今はAgdaは不安定すぎてだめだね。もう少し枯れる必要があるね。

一部だけに使ってもたいした信頼性が得られるとは思いにくいな。
全体の整合性があるかどうかが信頼性の根拠なんじゃないの？

コメントありがとうございました。なるほど、証明に特化してるんですね。

いや、次世代は「バグが無いことが証明されたコード」が可能になるのかと
勘違いしてました。少し安心です。

証明を通過できるだけの厳密な制約を記述してたら使えるコードが出来るまでどれだけかかるかわかったもんじゃねーよ。

完璧なプログラムを書け絶対だぞ。なんて縛りがあるなら、lisp+マクロが最強っぽいね
知識の集積と普及に問題がありそうだけど。
入門書買って読んだ、目からうろがこぽろぽろ

正しいプログラムを書こうというのなら
動的型のLISPより静的型のHaskellだろJK。

Real World Haskell の日本語訳の正誤表って出てる？
もう充分な品質かな？ 次の刷まで待った方がいいかな？

>>177
Lisp は運用と開発の境界を曖昧にした。
運用の中で問題があればすぐに改善できるのがウリ。
だから使い続けていくうちに品質が向上していくという性質がある。
現実の問題ってのは最初から完全な制約が与えられるものではないし、
制約が変更されることもあるし、プログラマがミスをすることもある
という前提から出発している。
逆に言えば運用開始前にはバグがあって当然ということでもある。

つまり、「完璧」だとか「正しい」とは何かという問題なんだ。
完璧な制約を書けないなら、制約を完全に満たす出力があっても無意味だし、
全体の型整合が完全ってだけで完璧なプログラムなわけじゃないという点では
Haskell が常に最良じゃないのは確かにそうなんだけど…
最強を論じるのはナンセンスだ。
ある条件に対してよりマッチするかどうかってものがあるだけ。

ちょw 豆蔵ww
> 関数脳のつくり方　Second Season　〜モナドで悟りをひらく〜
ttp://itpro.nikkeibp.co.jp/article/COLUMN/20091023/339329/?ST=develop

>>179
現時点での正誤表、680ページ前後有るのでまだ増えると思う
http://hop.timedia.co.jp/show/book/Real%20World%20Haskell
正誤表
p.444 上から6行目(コードを含む)
誤： ReaderTとWriterTの順番はどちらでも構いません。

正： ReaderTとStateTの順番はどちらでも構いません。

p.446 練習問題 1
誤： ..を変更してReaderTとWriterTの順序を入れ換えなさい。

正： ..を変更してReaderTとStateTの順序を入れ換えなさい。

p.447 ghciセッションの直前のパラグラフ，最初の文
誤： ..と働いているということに当てにせず、..

正： ..と働いているということを当てにせず、..

p.453 18.8節の手前3行目
誤： ..記録されだけということがわかります。

正： ..記録されるだけということがわかります。

p.464 19.2節 ヒント 下から2行目
誤： ..標準的なGHCライブラリから外され可能性があります

正： ..標準的なGHCライブラリから外される可能性があります

>>182
売れ行きはどんな感じだろ。
次の刷はすぐに出そう？

子飼様が書評されておられます

http://blog.livedoor.jp/dankogai/archives/51314062.html

>>184
dankogaiはhate対象

11月なんだね

プログラミングHaskell
http://www.amazon.co.jp/dp/4274067815/

>>186
これって、入門者が主なターゲット？

違うよ。

>>188
え、違わないでしょ。むしろプログラミング入門者向けって書かれてたと記憶してる。

たとえば、haskell.org などで自分で必要な情報を仕入れ、
整理し、（自分用に）まとめられる力がある人にとっては、
もう目新しいトピックや目から鱗的なトピックは無いですか？

4章まで読んだ。foldrのところで早くも挫折しそう…。

>>190
全部が全部知っていること・理解していることってことはなかろう。
ひとつやふたつは何か新しい発見もあるだろうさ。

hackageにつなげなくなって幾星霜。
wxHaskellをビルドしようとしてようやく気づいたけど、もしかしてこの頃からずっと？

Real World Haskell の日本語訳って、誤字大杉じゃない？
まだ、217p までしか読んでないけど、明らかに誤字だと分かるものでも7個見つけた。
（流し読みしたところもあるから、見逃してるのもあるかも）
700p 近くある翻訳本なら、これが普通なの？

まぁ、意味が正反対になったり、理解に苦しむレベルの誤字ではないから、
今のところいいけど。

1ページあたりの文字数多いし、むしろ優秀な方

>>194
出版社に言え。誤字に訳本とか関係ないから。

>>196
はい、全部読み切って、誤字をリストアップしたら
まとめて出版社の方に報告するつもりです。

内容はやはり素晴らしいですね。
まだ1/3も読んでませんが、ここまてでもかなり勉強になります。
JSONのプリティプリンティングの辺りからは、
小さいけど実用的なアプリを一から完成まで作り上げていく工程を
まるまる学べますね。

http://homepage1.nifty.com/kurubushi/card52640.html
ライプニッツの時代は原子論がまだ確立していなかった。
物の根源が原子であるということに確証がなかった。
だが、錬金術師としては最小単位があると記号的にも便利だよね。

存在する化学的対象物を表す最小単位が原子。では、
存在する数学的対象物を表す最小単位は？

くだらないからやめろ。

最小単位は量子じゃないの

クォークより最小のものってあるの？

還元主義の一方だけではだめでちゃんと統合しないと
分解して小さなもので置き換えるだけではなく、むしろ還元とは小さなもので置き換えたときのそれぞれの関係について論じられるべき
関係が明らかになれば無駄に分解していく必要も無い
ってことでモナドの勝利

ちょっとスレがひっそりしてくると通俗書で仕入れた単語で自問自答を始めるプログラムって停止しないよな

しかしお前等朝早いな

>>202
あるよ

>>206
何？

>>207
粒子という概念で物質を考えると粒子は無限に小さくなる。

？

クォークはモナドでできているんだぜ？

ghc で hackage のシステムを使ってあるライブラリをインストールする時、
依存関係のために先にインストールしておかなければならないものを
自動的に全てインストールする仕組みは無いでしょうか。

今は、ライブラリＡを runhaskell Setup configure した時、
ライブラリＢ（の ver x.x.x）を先にインストールしておけと言われたら、
ライブラリＡのインストール作業を一時中断し、
ライブラリＢをダウンロードしてインストールしてから
先ほどのライブラリＡのインストール作業を再開してます。

この先にライブラリＢをダウンロードしてインストールする
という再帰的な作業を全自動で行ってほしいのですが、何か方法は無いですか。

>>211
cabal-install

>>212
すごい、素晴らしい。
めちゃくちゃ楽になった。

ありがと。

先ず無限に続く素数列

primes::Integral i=> i -> [i]
primes = 2:sieve [3,5..]
　where
　　sieve (p:xs) = p : sieve [x| x<-xs, x `mod` p /= 0]

そして primes を使用した, 素因数分解

rpf::Integral i=> i -> [i]
rpf n = _rpf n primes
　where
　　_rpf m ps | pfs == [] = [m]
　　　　　　　| otherwise = head pfs : _rpf (m `div` (head pfs)) pfs
　　　where
　　　　pfs = dropWhile (\x -> m `mod` x /= 0) $ takeWhile (<=upb) ps
　　　　　where
　　　　　　upb = floor . sqrt $ fromIntegral m

そしてこの素因数分解関数を利用して実装した素数判定

isPrime::Integral i=> i -> Bool
isPrime n = rpf n == [n]

2から1000個の素数列を作る事を考えると

take 1000 primes
が簡単です
[2,3,…,7907,7919]

この処理に，自分の環境で33秒を要しました

別の実現方法として，
take 1000 $ filter isPrime [2..]
もすぐ思いつきます。

ここで悩ましいのは，isPrimeはrpfで実装されており，
rpfはprimesで実装されている所です。
つまりisPrimeはprimesを使って実装されているのです。
にも関わらず，後者の方法で要した時間は
6.79秒なのです
なんでですか？

>>214-215
後者はたしかにprimesを使いますが
使うのは(takeWhile (<=upb) primes)だけですよね
これは(take 1000 primes)よりずっと短い

ああそうか
primesは新しい数にぶつかる度にこれまでに
判明した素数で割れやしないかとテストするが
本来テストする数の二乗根までしかテストしなくて良いのだから
無駄な事をしていると
isPrime版ではこの事を考慮しているというわけですね

ではprimes自体最適化する必要があるわけですね

>>197
RWHの誤りなどを報告するページができたもよう
http://www.sampou.org/cgi-bin/haskell.cgi?Books%3aRWH%3aBugReport
全部読み切ってからと言わずすぐに報告する方がいいぞ。

>>218
今いくつか追加しといた

Writerモナドのtellは、ログを「追加する」と書いてありますが、
これは、tellの引数 (Monoidのインスタンス) の
mappendを呼び出していると考えていいのでしょうか?
(そうだとするとmappendの引数は現在のログとtellの引数?)

以下のWriterのソースコードを読んだのですが、
tellはデフォルト実装が書かれていないようなので、
普段はどの処理を呼び出しているのか分かりませんでした。

ttp://www.haskell.org/ghc/docs/latest/html/libraries/mtl/src/Control-Monad-Writer-Class.html#tell

例えば、Data.Setや (a -> a) やリストの場合、
tellに渡すと呼ばれる処理がどこに書かれているのか、
ヒントだけでもいただけないでしょうか。

>>220
>mappendを呼び出していると考えていいのでしょうか?
それで合ってる

そのソースは「Writer的モナド」のクラスを定義してるだけで、実装はこっち
http://www.haskell.org/ghc/docs/latest/html/libraries/mtl/src/Control-Monad-Writer-Lazy.html
厳密にはtellじゃなくて(>>=)がmappendを呼んでる

>>221
最後に「Lazy」と「Strict」が付くリンクが、
それぞれ非正格と正格の場合の実装なんですね。
ついでにドキュメントの見方も理解できました。
ありがとうございました。

明日俺もリアルワールドハスケル買うよ
ぐふふ バイトして金が用意できる

>>223
RWHを買ったら覚えたHaskellで稼げば
その金をまたHaskellにつぎこめる
ぐふふふふ

Typeclassopediaについて現在チャットやってる。
http://d.hatena.ne.jp/kazu-yamamoto/20091113/1258075565

Haskell'はいつ出ますか？

参加しますか？

関数型プログラミングにどっぷり浸れる特別イベント「Haskellナイト」、今週末に開催
http://codezine.jp/article/detail/4615

Cで書かれたHaskellの1000行程度の小さい処理系ってないのか
無いなら作る魂発揮できれば良いんだけど

schemeでも2000行程は掛かるから、
演算子が色々あるhaskellはその十数倍は見積もらないと。
haskellの最小コア命令セットってどうなるんだろ？
schemeだとapply evalに、if set! define lambda beginだったか。(マクロもあるけど)

>>228
Haskellの教育向け実装処理系であるGoferはいかが？
ソースの合計行数(wc -l *.[chy])は、27110行だった。
作者によるユーザガイドと実装に関する論文も公開されている(ただし英語)。

>>228
作れるの？

I wish I were a bird.

Sure, you aren't a bird.

You had better to perspect realism.

いっそhaskell--とか言うサブセットでも定義して実装するとか
なんか色々なものがclassで実装出来そうな気がする
つまり標準的な仕様から除外出来そうな。互換性には目を瞑るって事で

>>235
良く分からんけどがんばれ

皆さん、仕事でHaskell使ってます？
事例があれば知りたい……

Windows で Gtk2Hs 0.10.1 のインストーラーを起動させましたが、
次の様に書かれたダイアログが表示されました。

----------------------
GHC does not seem to be working.

GHC does not appear to be installed correctly, try reinstalling GHC version 6.10.3

Setup found what appears to be a non-working installation of GHC in the folder:
C:\Program Files\Haskell Platform\2009.2.0.2

□ Continue anyway. (You wil have to fix the DLL search path problem yourself later.)
----------------------

GHC 6.10.4 はインストールされています（Haskell Platform 2009.2.0.2 を使用）。
これは Gtk2Hs のインストーラーからは GHC が見えていないという事でしょうか。

また、DLL のサーチパスを自分で修正できるならそのままインストールしていいよ、
と言われていると思いますが、どこの設定をどのように変えればいいのでしょうか。

>>237
仕事で使ってるけど何か？
ちなみに俺の仕事は大学の卒論を書くこと。

Haskellを使う人は他の言語もよく使えるだろうと思って
このご時勢でもパスさせてきたけど
落としたほうがよさそうな気がしてきた。

と社会人経験０のニートが申しております

HaskellはLispのマクロみたいなものはありますか？

>>238
そのgtk2hsのバイナリはghc 6.10.3でコンパイルされてるとかじゃね？

文字コードの変換ってどうするんですか？
今は\from to-> readProcess "iconv" ["-f", from, "-t", to]
みたいなもの使って無理矢理やってますが、これはどうかと思うんで

ttp://hackage.haskell.org/cgi-bin/hackage-scripts/package/iconv

なるほど、ありがとうございました

ふつうのHaskell
プログラミングHaskell
Real World Haskell
どれ買うのがいい？

>>247
どれも買え。

Real Worldだけでいい

プログラミングHaskellとRWHは翻訳を買うべき
原本より安い
RWHは原本の間違いが50箇所以上修正されている

RWHはウェブで読め

>>250
代わりに日本語の間違いが同じくらいあるけどね。

>>252
つttp://www.sampou.org/cgi-bin/haskell.cgi?Books%3aRWH%3aBugReport
これから買う俺のために報告しておいてくれ

「ふつうの」本の作者なんて、報告しても梨の礫だし、サポートページも放置プレイなんだぜ

>>253
とりあえず俺が今まで気づいたところは報告済み

>>253
重版かかるのはいつごろになりそうなんだろうな
修正された版を買おうと待ってるんだけど

　　　　　　　　　　　　　　　　　　　　　　　　 刀、　　　　　　　　 　 , ヘ
　　　　　　　　　　　　　　　　　　／´￣｀ヽ ／: : : ＼＿＿＿＿＿／: : : : ヽ、
　　　　　　　　　　　　　　,.　-‐┴─‐- ＜＾ヽ、: : : : : : : : : : : : : : : : : : : : : : }
　　　　　　 　 　 　 　 ／: : : : : : : : : : : : : :｀.ヽl____: : : : : : : : : : : : : : : : : : ／
　　　　　,.　-──「｀: : : : : : : : :　:ヽ: : : : : : : : :＼ ｀ヽ￣￣￣ フ: : : : :／
　　 　／: :.,.-ｧ: : : |: : : : : : : : :　　　 :＼: : : : :: : : :ヽ　 ＼ 　 ／: : : :／
　　　￣￣／: : : : ヽ: : : . . . . . . . . . . .､ ＼=--: : : :.i　 ／　/: : : : :/
　　　　 ／: : 　　　 ∧: ＼: : : : : : : : : : ヽ: :＼: : : 〃}/　　/: : : : :/　　　　　　　　 、
.　　　 /: : /　　. : : :! ヽ: : l＼_＼／: : : : :＼: ヽ彡: : |　　/: : : : :/　　　 　 　 　 　 |＼
　　　/: : ｨ: : : : :.i: : | 　 ＼!___／ ヽ:: : : : : : :＼|:.:.:.:/:!　 ,': : : : /　 　 　 　 　 　 　 |: : ＼
　　 / ／ !: : : : :.ト‐|-　 　 ヽ　　　　＼: : : : : l::::__:' :/　 i: : : : :{　　　 　 　 　 　 　 |: : : :.ヽ
　　 l/ 　 |: : :!: : .ｌ: :|　　　　　　　 　 　 ＼: : : l´r. Y　　 {: : : : :丶＿＿＿＿＿__.ノ: : : : : :}
　　　　　 l: : :ｌ: : :ﾄ､|　　　　 　 　 ､＿__,ィ ヽ: :| ゝ ﾉ　 　 '.: : : : : : : : : : : : : : : : : : : : : : ／
　　　　　 |: : :ﾄ､: |: :ヽ ___,彡 　 　 ´￣´　　 ヽl-‐'　　　　 ＼: : : : : : : : : : : : : : : : : : イ
　 　 　 　 !: :从ヽ!ヽ.ﾊ=≠'　, /////　///u /　　　　　　　 　 ￣￣￣￣￣￣￣￣
　　　　　　V　 ヽ|　 　 }///　 r‐'⌒ヽ　　イ〉、
　　　　　　　　　　　 　 ヽ､______ｰ‐‐' ィ´　/:/:7rt‐---､　　　　　　　こ、これは>>254乙じゃなくて
　　　　　　　　　　　　　　　　　　ィ幵ﾉ　./:/:./:.! !: : : : :!｀ヽ　　　　　ポニーテールなんだから
　　　　　　　　　　　　　　r‐'T¨「 |: | !:.∨:/:./: :| |: : : : .l: : : :＼　　　変な勘違いしないでよね！
　　　　　　　　　　 　 　 /: : .|: :|　!:.!ィ¨¨ヾ、:.:/　!: : : : l: : : : : :.＼

>>243
なるほどと思って、MinGW + MSYS 入れてコンパイルしてみようとしたが、
色々やっても make で失敗する原因が掴めん。
（GHC のバージョンをひとつ下げれば良いだけの話だが、なんか気持ち悪い）

vmplayer + ubuntu 上でコンパイルしたら、すんなりできた。

せっかくのアドバイスにすまんが、
とりあえず諦めてこっちでプログラムすることにした。

>>255
正誤表は表紙の裏に貼っておいて
修正箇所にはマーカーで線を引いておくといい
版が上がるのを待っていると購買意欲が薄れてゆく
本は勢いで買うものだ

ネットでリアルタイムに正誤表が入手できるようになったのは
多大な進歩だと思うけど、紙とシリコンに情報が分散する点が不便だ
表紙の裏に貼るくらいの大きさでプリンタブルなフォーマットを
用意してくれるとすごい助かる
wikiやblogのプラグインでそういうのないかな

>>255
Gauche本なんかはすぐに第二刷が出たよね。
ところで、「刷」ってのは内容に変更なしで追加で刷った場合に使うもんだと
思ってたけど、Gauche本では結構修正されてたよね。
誤植訂正は変更の内には入らないのかね。

んな細けぇこたぁいいんだよ。

授業でHaskellの課題が出た
難しい…

はじける、んだ！

>>259
> ところで、「刷」ってのは内容に変更なしで追加で刷った場合に使うもんだと

いや。改訂版、増補版などの場合に第２版とかになる。誤植の修正程度では
刷数が上がるだけ。

昔は、版を作り直す必要がある修正か、版はそのままでできる修正か、で
区別されたわけだけど、電子化でそういう区別はなくなっちゃったけどな。

おそらく定番の質問だとおもいますがよろしくお願いいたします。

do {
putStr "input >";
s <- getLine;
}

というような場合，コンパイルすると書いた順に実行されません。
インタプリタで実行したり改行の入るprint やputStrなどを使うと
ちゃんとできるようです。
書いた順に実行させるにはどうしたらいいのでしょうか。

do {
putStrLn "input >";
s <- getLine;
}

「prompt だから、改行したくなかったのか。」って気付いたからこっちで

do {
putStr "input >";
hFlush stdout;
s <- getLine;
}

>>265
バッファリングされてるからフラッシュする

import IO

main = do{
putStr "input >";
hFlush stdout;
s <- getLine;
putStrLn s;
}

かぶった…orz

簡単な問題だと食いつきいいな、お前ら。

>>268
いや、俺、import 書き忘れたから、
君の勝ちだ。

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

簡単な問題の対義語は難しい問題じゃなな
難解な問題

るみちゃんとふたりっきりで忘年会したいお

天王洲あいる

留美yかわいいよ留美y

Haskellで書ける幸せ。

liftIOってコードの見た目がすごく汚くなるね
もうちょいマシな仕組みはなかったんだろうか

Haskellはきれいだけど

たまにliftだらけになって見た目汚くなっちゃうよねwwwwwww

>>279
関数分けろよ。
関数的スパゲッティまずい

((,) a)がfunctorのインスタンスの時の
fmapの定義はどのようなものなのでしょうか？

X -> (A×) X
↓　　　↓
f 　　fmap f
↓　　　↓
Y → (A×) Y

だからControl.Arrow.Arrow.secondかな

"the fun of programming" の exercise の解答（解答例）はどこかにありませんか

下の問題のProblem G、私には難しすぎます
Haskell大好きな人助けてください
http://icpc.baylor.edu/past/icpc98/Finals/Report/Problems/Problems98.pdf

難しい問題だから面白い。特にhaskellの場合は

みんなGUIアプリとか作るときliftがちょっと多くなっちゃったりしません？
みなさんどうしてます？

1 / 100
と計算すると
1.0e-2
と表示されてしまうんですが、これを
0.01
と表示したい場合、どうするのでしょうか

hugsを使う。

import Text.Printf
printf "%2f" $ 1/100

>>286
ReaderT,StateTなんかを使うグローバル変数的なものはunsafePerformIO (newIORef hoge)で代用
MaybeT,ErrorTは Monad m => m (Maybe a) -> (a -> m (Maybe b)) -> m (Maybe b)等の
バインド関数を用意してIOモナドの中でやる

IOのほうが少ない場合は変換子のほうが綺麗に書けるけど
GUIだとどうしてもね…

>>289
thx

ttp://itpro.nikkeibp.co.jp/article/COLUMN/20091023/339329/?ST=develop&P=9
> (1) Scalaでのモナドは，「map，flatMap，filter，unitコンストラクタ」を実装し，モナド則を満たしたクラスのことです。

Scalaのモナドってfilterが必要なの？どういうこと？　Scalaはクソ仕様ってこと？
それとも単に豆蔵がアホってこと？

"the fun of programming" の正誤表（errata）はどこかにありませんか。

Exercise 1.5 の問題がどうしても誤植に思えてしまいます。

Real World Haskell 第2刷が来るか?
ttp://hop.timedia.co.jp/show/book/Real%20World%20Haskell

もうちょっとか。
第3刷まで待とうかな。

刷りじゃ改訂されないんだよね？
版を重ねないと駄目だよね

>>296
増刷時に訂正が入ることもある。翔泳社のサイトでは自社出版物に関して
そういう情報を公開している。オライリーがどういう基準なのかは知らん
が、昔に買った sed & awk の本だと訂正されていたこともあった。

>>297
2刷の締切までに発見済みの誤りは訂正されるはず。

>>298
うん、その通り「はず」だよ。いつも保証は無い。なので、第３刷までは待っている。
それまでの間に品切（＝絶版）になったら、そのとき考える。

その間にちょっとでも英語の勉強しなよ

>>294のリンク先に、第2刷で修正される内容が明記されているんだが。

>>299
三版でも直ってる「保証」はない。

不毛なスレだ

>>302
無いヨ。勝手に期待してるだけ。そもそも出る保証すら無いんだから。

しかし原著のサンプルコードのミスに気がつかなかったケースもある
みたいだけど、翻訳時に検証ってしてないんかね？


>>303
ゴメンね。

haskellからはす☆ける、もしくははすける！に名前を変えれば人気急上昇だと思うんだ

人気急上昇した暁には
もれなく人力によるFAQのDDOS攻撃が付いてきます

VIPからき☆すた、でスレが埋まるとかな。

今晩は HIMA3 開催だす。
http://d.hatena.ne.jp/nobsun/20091211/1260541003

はじまた

わぁい

Haskellでリストの先頭に要素を追加していくのは速いけど末尾に追加していくと遅いとかって話あるじゃん？
どんな言語を受理するアルゴリズムでも手続き型言語とHaskellで
同じオーダーの使用メモリと速度で書けるって証明はあるのん？

>>311
リストを使うアルゴリズムと、リストを使わないけど同じアルゴリズムを仮定して
両者は同じではないので矛盾するということを証明すれば？

え、俺に証明しろと？ｗ
相当難しいと思うんだが。
でもHaskellにとってそこを保障しとくのは大事だろうから
偉い人がもう証明してくれてるかな〜とおもってた。

GHC 6.12.1リリース
http://haskell.org/ghc/docs/6.12.1/html/users_guide/release-6-12-1.html

>>311-313 の会話が何を言いたいんだかさっぱりわからん。
「どんな言語を受理するアルゴリズムでも」ってどういう意味だよ？
おまえら本当に自分が書いてることの意味わかってて会話してんの？

そんなに特殊な言葉ではないとおもうんだが。
計算理論では割と一般的な言葉では？

haskelｌはリストだけなの？
OCamlみたく配列やmutableコレクションをサポートしてると、
そっちに逃げることも多いな。

>>317
好きなのをどうぞ
ttp://hackage.haskell.org/packages/archive/pkg-list.html#cat:data

http://www.google.co.jp/search?&q="どんな言語を受理するアルゴリズムでも"
とりあえずgoogle先生では引っかからなかった

まあそんなことよりも重要なのは「同じ」ってどういう意味だ？ってことだな。
同じアルゴリズムを異なる言語で書くと、それらは何をもって同じだというのか。

>>320
なんとなく話がかみ合ってないが。
この場合の言語てのはHaskellとかJavaとかのプログラム言語のことじゃないよ。
大雑把に言うと解きたい問題のこと。
計算理論だとそういう言い方したりする。

>>317
配列もあればタプルもあるしハッシュもある。
ろくに調べもせずそういうこと言わない。

異なる言語を「同じ」ベンチマークで比較するとか、よくある問題だな

「言語を受理する」ときたら、それを受けるのは「オートマトン」じゃないかな。
まぁアルゴリズムでも意味は通るが。

手続き型言語と比較ってのは、要するに定数時間で読み書きできる配列のある言語と比較ってことだろ？
なら答えは「Haskellにも定数時間で読み書きできる配列があるから同じ」
詳しくはIOArrayあたりを調べればいい

>>314
dynamic loadingってあるけど
これで糞長いLinking..から開放されるってこと？

>>325
けっきょくモナドなん？
つかモナドってよくわかってないんだけども。
Haskellは副作用がないから純粋でいいんだ〜ってよくきくよね？
でも副作用を使うためにモナドが用意されてて、
モナドは使わないに越したことはないんだけども、
モナドを使ってもHaskellは純粋なままなんだ〜とか。
さっぱりわからんｗ。

"."と">>="の違いは何？
"+++"は一体何のために作られたのか？
説明よろ。

>>325
311じゃないんだが、横から質問させてください。

たとえば整数の二次元配列の１要素に書き込む処理を考えると、
手続き型言語であれば、機械語のレベルで数ステップから十数ステップ程度の
オーバーヘッドで実行できる。１要素の読み出しと大差は無いし、処理時間も定数的です。

で、HaskellのIOArrayへの書き込み処理というのも、「１要素の読み出しと大差の無い時間で
実行できる」ものなのでしょうか？もしＹｅｓなら「手続き型言語と同じ」と言えるでしょう。

でも個人的には、おそらくIOArrayの実装とは、書き込んだ状態変化を差分として保持し、
それをハッシュで管理することでオーバヘッドを最小限に押さえているのだと想像しています。
だとすれば、とても読み出し処理と同じオーバヘッドで実行できるはずはありません。
それともHaskellのIOArrayは、素人の想像を超えた(魔法のような)ロジックで
実装されているのでしょうか？それがモナド・マジックとやらなのかなぁ.....。

なんだなんだ、最近Haskellはやってんの？
俺が昔書いたHaskellのライブラリ、今日のダウンロード数0だよ。乙ですｗ

>>328
何見て勉強してるんだ？
いくつかネットで読めるチュートリアルを最初から読めば
そんな質問はしないはずだが

ちんこだけは構わないでください

>>327
Haskellでは「いかにも関数的」な書き方もできるし、IOモナドを使えば手続き的にも書ける
関数的に綺麗に書ける場合はそれに越したことはないが、
IOモナドを使って手続き的に書いた場合でも参照透明性は損われない、ってだけのこと

>>329
実装は読んでないけど、IOArrayの実体はポインタの配列で、
IOArrayへの書き込みは(ポインタの)破壊的代入で実装されてるはず
GC関係でもうちょっと追加の作業をやってるかもしれんが、
少くとも差分を管理するような複雑なことはやってない

IOモナドを使えば順序立った入出力ができるんだから、
メモリを外部の装置と思えば入出力と同じ要領で破壊的書き換えができる
どこにも魔法はないよ

>>333
遅くなりましたが、レスありがとうございました。

「メモリを外部の装置と思えば」という比喩で理解できました。
Haskellからすれば添字でアクセス可能な外部データベースに見えるわけですね。

というか、IO-という接頭辞でそれに気付けなかった自分がおバカでした。

どんなにがんばってもO(n*log(n))のソートが書けないプログラミング言語とか嫌だよね

STモナドでがんばればできるんじゃないか？

モナドまんせ〜というのは分かるけど、遅延処理っていらなくない？

遅延評価＊

>>337
ん、どうして？
遅延評価があるから無限リストができるのに。

ところで、無限リストをIOに変換したいときってどうするの？
[a] -> IO a

>>340
たとえば
hoge :: [a] -> IO a
hoge = return . head

>>341
できれば、無限リストを、と言ってるのを無視しないで・・・
それだと有限でも無限でも関係ないから

無視しないでとか関係ないから、じゃなくて、中身が次々と取れるようなものが
ほしいということでしょ？

リストが有限か無限かを知る方法ってなんかうまいやり方あったっけ？

>>344
それは証明できないことだと思うよ。

リストが有限か無限かで区別できたらおかしいｗ

>>344
手続き型言語的には、ループになってるリストを検出するとか。

Haskellだと関数呼び出しが単純な何もしない無限ループになってると処理系で検出するよね...
と思ったらghciだとダメだったorz

>>345-347
だよなwww

>>340
こういうの？
有限リストを渡すと突然死ぬ

import Control.Concurrent

listToGenerator :: [a] -> IO (IO a)
listToGenerator list = do
  m <- newMVar list
  return $ modifyMVar m $ \(x:xs) -> return (xs, x)

main = do
  g <- listToGenerator [1..]
  print =<< g
  print =<< g

>>349
内容は理解してないけど動作確認した。ありがとう。
型は [a] -> IO (IO a) にしないとだめなの？

>>350
do
  g1 <- listToGenerator [1..]
  g2 <- listToGenerator [1..]

としたら、g1とg2は相互に独立した、系列の違うジェネレータにならないと困るだろ？
つまり、listToGeneratorは呼ばれるたびに別のものを返さないといけないので、
普通の関数じゃなくてIO動作としてしか定義できない

>>351
それは分かったけど、
IO aを返すにしても、IO (IO a)を返すにしても、IOであることには変わりない。
型を見る限りでは「Generatorを返す関数」である可能性はぜんぜん否定できてない。

型レベルでは
「普通の関数が、呼ばれるたびに別のものを返す」可能性を否定できないの？

何を言いたいんだかわかんない。
Generatorって何、普通の関数って何？

ジェネレータを返す関数は、呼ばれるたびに、
相互に独立した、系列の違うジェネレータを返さないといけない。

IOはジェネレータである。

ゆえに、IOを返す関数は、呼ばれるたびに、別のものを返す。

まず言葉をはっきりさせる

繰り返して実行することで、ある型の値を次々と取り出せるモノのことをジェネレータと呼びたい
>>351でいうg1やg2のこと。具体的に定義するなら
type Generator a = IO a

問題は、ある型Tのリスト[T]が与えられたとき、これに対応するジェネレータGenerator Tを得たい、というもの
この変換を直接行う関数[a] -> Generator aはうまく定義できず、
IOアクションを返す関数[a] -> IO (Generator a)を書くしかない、というのが>>351の主張

>>352
>「普通の関数が、呼ばれるたびに別のものを返す」可能性を否定できないの？
Haskellの関数は、同じ引数で呼ばれたら同じものを返すと決まってる。参照透明性ってやつ
[a] -> IO aという型を持つ関数は、同じ[a]を与えられたらいつも同じIO aを返さないといけない
（一方、IO aを実行するとa型の値が結果として得られるけど、この結果は毎回異なる可能性がある）

>>355
b = Generator aとすると

IO (Generator a)
= IO b
= Generator b

[a] -> Generator a は困ると>>351は言ってるのに
[a] -> Generator b を作って何とも思わないの？

>>356
それはその通りだけど、何が言いたい？

>>358
・ジェネレータを返す関数（≠アクション）が存在する
・その関数は参照透明にならないかもしれない
・ちゃんと参照透明になっているかどうか、型推論では推論できない

>・ジェネレータを返す関数（≠アクション）が存在する
うん
listToGeneratorの結果のGenerator (Generator T)は毎回異なる必要がないので、関数でおｋ

>・その関数は参照透明にならないかもしれない
Haskellの関数は基本的に全部参照透明だよ。もちろんlistToGeneratorも参照透明
参照透明じゃない関数はunsafePerformIOを直接間接に使うくらいしか書く方法がないし、滅多に書かない
特に理由がなければ関数は参照透明だと仮定して議論しても問題ないと思う

>>355でもほとんど同じことを言ってるけど、listToGenerator :: [a] -> IO (IO a)は同じ[a]を与えられたら常に同じIO (IO a)を返す

>・ちゃんと参照透明になっているかどうか、型推論では推論できない
「型推論では推論できない」ってのは、「型を見ただけでは判定できない」って意味？
それなら上で答えたとおり、特に理由がなければ参照透明とみなす

ついでに言うと、「型推論」ってのは、明示的に型が書かれていない式や変数の型を計算することね

>>360
>特に理由がなければ関数は参照透明だと仮定

ジェネレータがからむと参照透明じゃなくなる場合があるって言ってるのに
なんで「特に理由がない」ってことにするわけ？
それと「仮定」ってあいまいな言い方をするのも、どうかと思う

ところで最近のHaskell界隈で一番話題になってることって何？おしえて

>>361
>ジェネレータがからむと参照透明じゃなくなる場合があるって言ってるのに
俺はそんなこと言ってない。もしそういう場合があると主張するなら根拠を示してくれ

>それと「仮定」ってあいまいな言い方をするのも、どうかと思う
それはすまん。「とりあえず正しいと信じる」って意味で使った

クリスマスはHaskellで遊んでたら気付いたら過ぎ去ってた
みたいにしたい

クリスマスは彼女と一緒にHaskellで遊ぶんだが、何か注意点ある？

>>365
スレ違い

女性に質問！マジレスしてくれ part579
http://hideyoshi.2ch.net/test/read.cgi/lovesaloon/1261474477/

Haskell Platformとghcは何が違うの？

>>365
遅延評価するにしても結局は必要になるんだぞ？

普通は23日にイチャついて、24日はセックスだけして、
25日は家族と何事も無かったかのようにクリスマスパーティだろ。

彼女も居る事にして取り敢えず遅延評価ですねわかります

賞味期限
16…予約はじまる
22…予約最盛期
23…我慢できない
24…最盛期
25…ロスタイム
26…半額
27…更に半額
28…返品
29…廃棄処分
30…廃棄処分逃れてもカビ



　 　　　　 　　　＿＿＿_
　　　　　　　 ／_ノ 　ヽ､_＼　　　　　　　　　　　　　　　　　　　
　ﾐ　ﾐ　ﾐ　　oﾟ(（●）) (（●）)ﾟo　　　　　　ﾐ　ﾐ　ﾐ 　　　　　クリスマスケーキのことだお
/⌒)⌒)⌒. ::::::⌒（__人__）⌒:::＼　　　/⌒)⌒)⌒)　　　　　自分の年齢当てはめてんじゃねぇおｗｗ
|　/　/　/　　　　　|r┬-|　　　　|　(⌒)/　/ / /／　　　バ
|　:::::::::::(⌒)　　　　|　|　 |　　 ／ 　ゝ　　:::::::::::/　　　　　　ン
|　　　　　ノ　　 　　|　|　 |　 　＼　　/　　）　　/ 　　 バ
ヽ　　　　/　　　　　`ー'´ 　 　 　ヽ /　　　　／　 　　　ン
　|　　　　|　　 l||l　从人 l||l 　　　　 l||l 从人 l||l
　ヽ　　　 -一''''''"~~｀`'ー--､　　　-一'''''''ー-､　　　　
　　ヽ ＿＿＿＿(⌒)(⌒)⌒)　)　　(⌒＿(⌒)⌒)⌒))

>>367
Haskell Platform = GHC + ライブラリパッケージ

>>372
ライブラリパッケージだけじゃなく、
Cabal とか便利なツールも最初からいくつか入ってるよ。

>>373
そうだな。正確には

Haskell PlatformはwindowsとかOSX用のは便利かもしれないけどLinux向けのには何かメリットあるの？
インストールするにはGHCやCabalが必要となっているし。

>>375
外出中にネットを利用できないときに、基本的なライブラリが既にインストールされているとコードのコンパイルに失敗しない場合がある。

>>370
それで本当に必要になったときに現れるのでしょうか?

>>377
遅延できるのは彼女の作り方にパラメータを入れて計算する作業だ
彼女の作り方が定義されていなければ必要な時に答えを出すことはできない
遅延評価は魔法ではない

仮に必要ないことが判明したら、捨ててもノーコストで済みますか?
勝手に投機計算が始まっても困るのですが?

>>379
きみの処理系はどのように実装されているんだ？

Haskell Platformに先だってghcの最新版がリリースされた時は
どうすれば良いのですか？
黙殺してPlatformの更新を待てば良いのですか？
それともghcだけすげ替える事が可能なのですか？

ghc-6.12.1で-dynamicを試してみた
当たり前だが実行ファイルサイズは激減した
非標準パッケージはdyn.hiを同梱していないものが現状では多いので
今後に期待

>>381
Platform使ってるの？あれって普及用だろ。インサイダーは個別にインストールが原則

良く分からないけど分かりました

http://www.sampou.org/cgi-bin/w3ml.cgi/haskell-jp/msg/480

>今回のリリースから GHC は開発者向けのリリースになり、一般ユーザー向けのリリース
>は Haskell Platform で行われるよう変更されたので気をつけてください。

要するに自分でどうにか出来る奴だけが自己責任で使えってことだな。

haskell を script 的に使うのは、起動が遅くて実用的じゃないと思っていたけど、
6.12で日本語文字列を試す為に、文字数を数える簡単なプログラムを　
#!/usr/bin/runhaskell を使って書いてみたら、速くなっているように感じた。

計ってみたら、
0.8s (6.10.4) -> 0.4s (6.12.1) と半減してたよ。

C言語で、あるデータ構造を持つデータのバイト列を、
そのデータ構造をあらわす構造体にコピーするのは簡単ですが、
Haskellではバイト列が与えられたとき、Haskell内部のデータ構造として扱うにはどうすればいいですか？

>>387
データ型を定義して、ByteStringを入力とする関数を定義するしかないんじゃない？
強い型付けだから暗黙キャストは無理

>>387
SerTH

>>389
アクセスできませんが

Haskell から COM にアクセスしてみたく、
Cabal で com-1.2.3 をインストールしようとしたのですが、エラーが出ました。

Missing header file: include/WideStringSrc.h
Missing C libraries: kernel32, user32, ole32, oleaut32, advapi32

調べてみたところ、これらのファイルがあるパスを
config ファイルの extra-include-dirs と extra-lib-dirs の項に
書き込んでコメントを外せばいいのではないかと思いました。

しかし、kernel32.lib らのライブラリ ファイルはあるのですが、
WideStringSrc.h ファイルがストレージ内に見あたりません。
Windows7 sdk をフルインストールしているのですが、ありませんでした。
（インデックス作成機能を切った状態で、
エクスプローラでストレージ内に検索をかけて探しました）

このファイルはどこからかダウンロードしてくるのでしょうか。

com-1.2.3の中にあるでしょ?

今、http://hackage.haskell.org/cgi-bin/hackage-scripts/package/com から
com-1.2.3.tar.gz を落としてきて中を見てみました。
たしかにありますね。

cabal\config ファイルに次の行を書いてみました。

extra-include-dirs: C:\Users\*名前*\Desktop\com-1.2.3.tar\com-1.2.3
extra-lib-dirs: C:\Program Files\Microsoft SDKs\Windows\v7.0\Lib

そして "cabal install com" を実行してみましたが、全く同じエラーが出ます。
kernel32.lib らも include/WideStringSrc.h も全てそのパスにあるのですが、
cabal は見てくれないのでしょうか。

ライブラリは gcc が使うやつじゃないといけないのかと思い、
extra-lib-dirs に指定するパスを下記のものに変えてみましたが、
結果は同じでした。

C:\Program Files\Haskell Platform\2009.2.0.2\gcc-lib

そのエラーはメッセージ通りじゃないケースが多いよ（↓参照）
http://article.gmane.org/gmane.comp.lang.haskell.cafe/68204

cabal のオプションに -v3 とかつけると原因が分かると思う

>>392,395 アドバイスありがとうございました。
おかげさまで原因がわかり、ネット上の情報も参考にして、
無事インストールできました。

"cabal install com" でダウンロード＋インストールはあきらめ、
com-1.2.3.tar.gz を展開して、その中で "cabal install" しました。

そのとき、com.cabal ファイルを２ヶ所修正しました。
[１つ目]
 Ld-options: --enable-stdcall-fixup --disable-stdcall-fixup
これはコメントアウトしました。
同じフラグの enable と disable を同時にすることに意味はないと判断しました。

[２つ目]
Includes: の StdTypes.h を WideStringSrc.h の前に移動させました。
そういえばC言語のインクルードは順番が大事だったので。

１つ目の修正が何となく気持ち悪いですが、とりあえずインストールはできました。
これから実際に使ってみます。

FFI について質問です。

C言語で次のような定義の関数があるとします。
int mkData (int** ppData)
これは引数でポインタのポインタを取り、内部でメモリ領域をいくらか確保し、
その先頭アドレスを *ppData に入れてます。
そして、エラーコードを戻り値で示します。

このような関数を haskell から使いたい場合、
foreign import 宣言はどのように書いたらいいのでしょうか。
つまり、引数に値を入れて返してくるタイプの関数の呼び方です。

>>397
import Foreign.Ptr
import Foreign.C.Types

foreign import ccall "mkData" mkData :: Ptr (Ptr CInt) -> IO CInt

>>398
ありがとうございます。
コンパイルは通りました。

ただ、実行時にアクセス違反らしきエラーが出ます。
こちらの問題はもう少し自分で考えてみます。

>>398 のようにして定義した mkData 関数を呼ぶ方法なんですが、
haskell 側でたとえば a = nullPtr :: Ptr CInt として a を定義し、
「これのポインタ」を mkData 関数に渡す必要があるのですよね。

この a のポインタはどのように得るのでしょうか。

もしかして全く見当外れでしょうか。

mkDataの戻り値が>=0の場合はデータの個数と仮定するとこんな感じで良いんじゃないかと思う。

import Foreign.Ptr
import Foreign.C.Types
import Foreign.Marshal.Alloc
import Foreign.Marshal.Array
import Foreign.Storable

foreign import ccall "mkData" mkData :: Ptr (Ptr CInt) -> IO CInt

makeData :: IO (Maybe [CInt])
makeData = alloca $ \ a -> do { num <- mkData a; if num < 0 then return Nothing else (peek a >>= peekArray (fromIntegral num) >>= return . Just) }

>>401
ありがとうございました。
おかげさまで、mkData の引数を使って値を得ることができました。

ついでに確認なんですが、
C言語の方で malloc を使ってメモリ領域を確保しているのなら、
プロセス終了時に自動的に全て解放してくれると思います。

しかし、たとえば同じような方法で COM のインスタンスを得ている場合は、
最後の return . Just の前で COM を Release しておかないと、
参照カウンタがいつまでたっても減らずにメモリリークしますよね？

どうしてそう思ったの？

>>403
あ、peek か peekArray の結果も一緒にタプルなんかでまとめて返せば、
後でいつでも解放はできますね。

Haskell のプログラムが終了する前に Release しておかないとダメですよね、
という確認です。

> どうしてそう思ったの？
いろんなプロセスで共有している COM は、
参照カウンタがゼロにならない限り、解放されない作りになっていると
学んだ記憶があるからです。

型シグネチャ宣言の文脈指定の部分にクエスチョンマーク ? があるのは、
どういった意味なのでしょうか。

具体的には、encoding-0.6.2 というパッケージの中に
次ようなのシグネチャの関数がありました。

System.IO.Encoding.print :: (Data.Encoding.Base.Encoding e, Show a, ?enc::e) => a IO

=> 以降に型変数 e が現れていないのも不思議です。
併せて教えていただけないでしょうか。

>>405
おっと、間違えました。

System.IO.Encoding.print :: (Data.Encoding.Base.Encoding e, Show a, ?enc::e) => a -> IO ()

です。

>>405,406
分かりました。
Implisit Parameter（暗黙パラメータ）なんですね。
使い方も理解できました。

一人で騒いですいませんでした。

>>407
うぁぁ、Implicit Parameter でした。
ほんとすいません

MacOS(10.6.2)にhaskell-platform-2009.2.0.2-i386.dmgをインストール
しようとしているのですが、GHC-6.10.4-i386.pkgのインストール中、
「インストールの種類」までいったところで右下の「インストール」ボタン
がグレーになってて押せず途方に暮れています。どうすればいいのでしょう？

Foreign.Marshal.Utils.with によるメモリ領域確保＆ポインタ取得ですが、
次のように複数個のメモリ領域を続けて確保したい場合、
もっと入れ子を減らして短縮できる書き方は無いでしょうか。

with (1::Int) (\pi -> do
  with (2.0::Double) (\pd -> do
    with ...

駄目もとで次のようにタプルにしてみましたが、
そのタプル自体（各要素ではなく）が Storable のインスタンスではないため、
peek の所でエラーになります。
当然、let の所でもエラーです。

with ((1::Int), (2.0::Double), ...) (\p -> do
  (i, d, ...) <- peek p
  let (pi, pd, ...) = p

複数個同時に確保できる関数を自作するしか無いでしょうか。

>>410
($)を使うといいよ。それにdoも必要ない

with (1::Int) $ \pi ->
with (2.0::Double) $ \pd ->
with ...

>>410
↓を参考にして((1::Int), (2.0::Double), ...)に相当する代数型を作ってStorableのインスタンスにしてやれば良いんじゃないかと。
http://www.unkar.org/read/pc12.2ch.net/tech/1231861873#l589

あと、3個組(x,y,z)までなら↓これを使えば良いのかも。
storable-tuple: Storable instance for pairs and triples: http://hackage.haskell.org/package/storable-tuple-0.0.1

>>411
すいません、自分のプログラムをコピペしないで、
あたまで急いで考えたスニペットを深く考えずにそのまま載せてしまいました。
実際のプログラムでは ($) を使って、かつ do も無いです。

with の入れ子を減らすのに使えそうな関数を
標準ライブラリ内で色々探してみましたが無さそうです。
仕方なく自作しました。

with2 d1 d2 f = with d1 $ \pd1 ->
                  with d2 $ \pd2 ->
                    f pd1 pd2

withN は withN-1 を使って作りました。

>>412
リロードし忘れました。

とりあえず自前ので問題は解決しましたが、
おもしろそうなので調べてみます。

[Real World Haskell] の日本語版で質問があります。

125 ページに、text、double、string の各関数は
Prettify モジュールに書くと言っています。
また、早めのコンパイルのために、とりあえず型と何もしない内容を書いた
スタブ（PrettyStub）モジュールを作るとも言っています。

にもかかわらず、次のページで早くも string 関数が
「PrettyJSON モジュール」に実装されています。
後の方のページをざっと見てみますと、text 関数や double 関数らは
ちゃんと Prettify モジュールで定義されているようです。

これは誤字の類なんでしょうか。
それとも何らかの意図があってそうしているのでしょうか。
誤字なら報告しておきたいのですが。

[Haskell Platform 2009.2.0.2] をインストールしているのですが、
index ページの Search: 欄に "const" を入れて [Search] ボタンを押しても、
"No results found, displaying all" と表示されます。

しかし、同じページでブラウザのページ内検索機能を使って
同じ文字列を検索すると、ちゃんとヒットします。

こういうものですか？ それともインストール失敗？

>>415
原文確認してみたら
ttp://book.realworldhaskell.org/read/writing-a-library-working-with-json-data.html

>>417
原文とコメントを読んでみましたが、
Kevin の「何で string が PrettyJSON.hs にあるんだよ」的なコメントと、
gmaths の「俺もそう思う」的なコメントしか得られないんですけど・・・

結局、間違いなのか意図があるのか、分からないです。

なにか見落としてますでしょうか。

>>409
ちょうど同じところで引っかかってた。
たぶんXcodeが入ってないか、正しくインストールできてない。
自分の場合は一応入ってたんだけど、AppleのDeveleper Centerから
最新のXcodeを落としてきて入れ直したら先に進めたよ。

haskellは身を助ける （＾∇＾ﾟ*. ｷﾞｬﾊﾊ

>>420
むしろlispじゃないか？簡単に実装できるし。

>>419
それでした。Xcodeでかいので昨夜はダウンロードしかけて寝ちゃいましたが
今試してばっちりインストールできました。しょうがないのでvmware上の
ubuntsuで遊んでたんですが、メモリ2Gしかないとやっぱりきびしいので、
ネイティブで動くのは助かります。

思ったことが直ぐ書けるのっていいよな
思ったことを直ぐ作れるかどうかはライブラリによるけど

自分のブログに書いたら？

>>424
念のため言っておくが、>>423は私ではないし、私はブログを持っていない

お前は誰だよｗｗｗ

俺は俺だよ

俺は一体誰なんだ

System.Directory

safeGetDirectoryContents path
| doseDirectoryExist path = getDirectoryContents path
| otherwise = return []

上のような関数作りたいのですけど、
existDirectory pathがIO Boolでどうしようもできん。
どう書いたらいいの？

へっぽこな俺が、試しに書いてみよう。

safeGetDirectoryContents path = do b <- doesDirectoryExist path
if b
then getDirectoryContents path
else return []

safeGetDirectoryContents path = catch (getDirectoryContents path) (const (return []))

safeGetDirectoryContents path = do
exist <- doesDirectoryExist path
ifM exist (liftM Just $ getDirectoryContents path) (return Nothing)

ifM True a _ = a
ifM False _ b = b

>> 430
>> 431
thanks!

なぜかガードにこだわってたのが敗因だわ。

[Real World Haskell 日本語] で分からないところがあります。
p.267 からの [11.2.1 テストデータを生成する] を読んでいますが、
ファイル構成からコンパイルの仕方まで、さっぱりです。

p.268 で Arbitrary クラスを自作してますが、
これは Test.Quicktest.Arbitrary ではなく「自作」なんですよね。
でも、Gen 型構成子は Test.Quicktest.Gen のものなんですよね。

すぐ下にある elements、choose、oneof の３関数は、
当然先ほど自作した Arbitrary クラスのものだと思います。
p.269 でさっそく Ternary 型を自作 Arbitrary クラスのインスタンスに定義し、
arbitrary 関数を定義していますが、elements 関数の定義は無いですよね。
自作 Arbitrary クラスにデフォルトの定義があるわけでもない。
どうやって実行するんですか。
それとも、これは「こういう使い方だよ」という単なる例示でしょうか。

しかし、Doc 型を自作 Arbitrary クラスのインスタンスに定義する時も、
oneof 関数を定義無しで使用しているにも関わらず、
今度は実際に ghci で実行を試していますが、どうやって？

haskellやOcamelの系統で
lispのstalinに相当する
処理速度が早いコンパイラはありませんか？

>>434
http://mlton.org/

Haskellなら、
生成されるコードの性能なら普及率とかまで考えたら今のとこGHC。

だいぶ前に論文ではもっと高性能だという話だったGRINってのがあって、
それを使ったコンパイラUHCというのがちょっと前のハカソンでリリースに
なってるようだ。

GHCという言語もあるんだがなぁ
名前変えろよボケ
GlasgowやめたんならGlasgow Haskell Compilerなんて名前は変えればいいのに。

死んだ言語のことなんて一々気にしてられない

>>438
カチンとくる書き込みするなぁ。並列処理の記述に関しては
HaskellはGHCの足元にも及ばないよ。

他言語のことなんてどうでもいいがね。
まずボクシングが思い浮かぶ俺もどうかと思うけどｗ

論理言語スレとかならともかく、このスレで言っても意味ないこと言わんでくれ。

>>440
プロレスだろ。ノアの至宝だ

そもそもHaskellって並列処理を必ず明示的に記述する言語ではないしな
関数型言語であって、直列とか並列とかは言語レベルの問題ではない

「死んだ」に対する反論が「並列処理の記述」なんだから
察してやれよ

言語に関して死んだとかそういうもの言いをする奴もロクな奴じゃないけどな

ケント大学大学院在籍中の俺に何か質問は？

>>446
では質問するが、>>433 についてはどう思う？
君の見解が聞きたい。
他の者らは私の質問にちっとも相手してくれないんだ。

GHC
提供: フリー百科事典『ウィキペディア（Wikipedia）』

GHC
ガーナの通貨単位セディをあらわす通貨コード(ISO 4217)
グローバル・オナード・クラウン - 日本のプロレス団体プロレスリング・ノアの管理する選手権
グローバル・ハードコア・クラウン - 同団体の秋山準がタイトル管理委員長を務めるハードコア王座
Guarded Horn Clauses - 並行論理型プログラミング言語
ガード付きホーン節 (Guarded Horn Clause)
Glasgow Haskell Compiler - プログラミング言語Haskellの主要なコンパイラ

このページは曖昧さ回避のためのページです。
一つの言葉や名前が二つ以上の意味や物に用いられている場合の水先案内のために、
異なる用法を一覧にしてあります。お探しの用語に一番近い記事を選んで下さい。
このページへリンクしているページを見つけたら、リンクを適切な項目に張り替えて下さい。

カテゴリ: 曖昧さ回避

GHC
From Wikipedia, the free encyclopedia

GHC can stand for more than one thing:
Galway Hockey Club (in Galway, Ireland)
Geography History Civics
Georgia Highlands College (in Rome, Georgia)
Ghanaian cedi, the ISO 4217 code for the currency of Ghana
Glasgow Haskell Compiler
Global Hybrid Cooperation is a set of hybrid vehicle technologies jointly developed by General Motors and Daimler AG, with BMW joining in 2005.
Gorkha Hill Council in India
Grace Hopper Celebration, a conference for women in computing. The full name is the Grace Hopper Celebration of Women in Computing
Grays Harbor College (in Aberdeen, Washington)
Group Health Cooperative (in Seattle, Washington)
Guarded Horn Clauses (a concurrent logic programming language)
Guitar Hero Carabiner, a handheld portable gaming device
Glasgow Hardcore - hardcore music from the city of Glasgow, Scotland.
Global Honored Crown, the names of championships in the Japanese promotion Pro Wrestling Noah

This disambiguation page lists articles associated with the same title.
If an internal link led you here, you may wish to change the link to point directly to the intended article.

Categories: Disambiguation pages

地縛霊でもいるのか

おっぱいがはじけるhaskell ごろがいいね。

[Real World Haskell 日本語] の P.378 - P.379 に
Supply モナドを乱数の発生源として利用する方法が書かれていますが、
このように Supply モナドを利用する意義が分かりません。
（もう少し言えば、この目的で State モナドを利用する意義）

評価するたびに違う乱数がほしいだけなら、次のようなものでもいいはず。

rand :: IO Int
rand = liftM fst (getStdRandom $ \g ->
         let (a, b) = split g
         in (random a, b))

あるいは、次ページにあるように Control.Arrow の first を使用して、

rand = fst `liftM` getStdRandom (first random . split)

でもいい。

Real World Haskell の解説において、
random ではなく、わざわざ randoms を使用して乱数リストを得るのは、
Supply モナドの利用方法を例示するために無理矢理そうしたとしか思えないのですが、
ちゃんとした意義はあるのでしょうか。

>>452
IOを使わないためでしょう。確か本にはそう書かれていたはずです。
あやふやな私の記憶なので間違っていたらごめんなさい。

>>453
改めて前のページを読み返してみたところ、
State モナドで乱数を得る仕組みや意義は分かりました。
しかし、Supply で乱数を得る意義は未だに分かりません。

P.360 で、C 言語の rand 関数に相当する関数の定義例が載っていました。

rand :: IO Int
rand = getStdRandom (randomR (0, maxBound))

その後で、今まで IO モナドをできるだけ使うなと言ってきたのに、
ちょっと乱数を生成するためだけに IO モナドに引き戻されるのは残念と言い、
State モナドで乱数を生成する例が載っています。

正確に言えば、IO モナドを伴う getStdRandom 関数の代わりに、
IO モナドを伴わない random 関数を使うのですが、
この関数は乱数生成器（RandomGen）を持ち回らなければならず、
そのために State モナドを利用するという話です。

これで、IO モナドを使わずに乱数を取得できる仕組みや意義は分かりました。

しかし、Suplly モナドを利用した乱数の取得では、
その心臓部で getStdRandom 関数を使用しています。
しっかりと IO モナドに捕らえられています。
IOを使わないためというのは理由にならないような気がします。

>>454
Supplyを使うのは実装の隠蔽です。Supply型を使うことで、イテレータ的なインタフェースで乱数を取得できます。
後で型クラスを使った例が出てきます。

timeパッケージがバージョンによって中身変わりまくりで
もうにっちもさっちもブルドッグ状態

違う、にっちもさっちも「どうにも」ブルドッグだ（語呂は悪いがな）

最後に「ワォ！」をつけるとなお良い

Cabal結構エラるよな。

<｀∀´>

>>最後に「ワォ！」をつけるとなお良い
ますだおかだの岡田かと思った。

mac ではすける
にはどうしたらいいですかごはん

xcode と emacs 以外でシンタックスカラーで
コード読みたいです

gnuのkompiler korekusyonは使えないの？

なぜ中途半端に英語？

GHC で -threaded オプション付きでコンパイルしたが、
RTSオプションで -N1 より -N2 を指定して実行した方が圧倒的に遅い。
CPU のコア数は2個なのにも関わらず。

参考にしたのは [本物のプログラマはHaskellを使う] のページの
[第10回　Haskellで学ぶ並列プログラミング（その1）] のトピック。
http://itpro.nikkeibp.co.jp/article/COLUMN/20070501/269948/?ST=ittrend

記事の Parallel.hs ファイルと ParallelTest.hs ファイルをコピペした。
ghc -threaded --make ParallelTest.hs -cpp -O でコンパイルし、
ParallelTest +RTS -N1 と ParallelTest +RTS -N2 でテストしてみた。

-N1 の方は 2.5 秒程度、-N2 の方は 10 秒程度で処理が完了した。
どちらも目覚まし時計の秒針を見て比べたので正確ではないが、
これだけ差が開けば多少の誤差はどうでもいいと思う。
それより -N2 の方が遅いのが納得いかない。
何が原因なんだろう。

[環境]
GHC : version 6.10.4
CPU : Intel(R) Core(TM)2 Duo CPU  P8600 (2.40GHz)
メモリ : 2.0GB

>>464
環境を一つ書き忘れました。

OS : Windows 7 HomePremium

unix環境で出直してこい

>>466
そりゃ答えになってないでしょ。
俺も同じ問題にぶち当たったから真相が知りたい。

>>464
試してないけど、GHCは6.12.1で並列性能がずいぶん向上したと言ってる
最新版でも-N2で遅くなるなら、GHCの開発者に報告したら喜ばれると思う

>>464
http://book.realworldhaskell.org/read/concurrent-and-multicore-programming.html#id675076

Real World Haskell 日本語版 P.115に
> (1+2):(3+4):[]という値を考えましょう。seqをこの式に適用すると、
> サンク(1+2)は評価されます。最初の(:)構成子に到達したところで止まりますので、
> 2つ目のサンクには影響を与えません。
とありますが、(:)構成子の中に(1+2)と(3+4):[]があるわけで、サンク(1+2)は評価されないはずですよね。
let x = undefined:[] in x `seq` 2
としてもエラーにならないし。

>>464
同じコードを同バージョンGHCでFedora12でやってみたけど、同じ状況ですね。
並列プログラミングと銘打ちながら、「並列化のための…多くの機能がまだ実装されていません」と言うw

>>469
興味深い記事を紹介してくれたのはありがたいのだが、
その意図が全く分からない。
記事を読めばその理由が分かるのか、
それとも記事の通りにすれば -N2 の方が速くなるのか。

その記事の parSort2 関数を使い、閾値を色々変えて実験してみたが、
どれも -N1 より -N2 の方が圧倒的に遅かった。
記事には、デュアルコアでは 25% スピードアップすると書かれているが、
どうやったらそうなるのか知りたい。

ちなみに、>>469 の環境ではどうだったのかも教えてくれないだろうか。

>>472
>>469 のページは、このスレで何度か話がか出ている「Real World Haskell」の英語版なんで、
英語が苦手なら日本語版の書籍に頼ればいいと思う。

なんとなくだが、>>464 は、[0..10000]のようなソート済みのリストをソートしようとしている気がする。
>>469 にある SortMain.hs を計測に使えば、-N1 より -N2 の方が圧倒的に遅いなんてことはないと思う。
少なくとも、こちらで試した感じでは、"parSort2 2"で要素数700000のリストのソートが -N1 と -N2 で同程度の時間だった。

>>473
いや、>>464 が紹介してくれた英語は問題なく読めた。
言葉が少なくて誤解を与えたが、parSort2 関数を使って実験したというのは、
あの記事に載っている SortMain.hs ももちろん使っての話。

あの記事に載っている sort 関数と parSort2 2 関数で試してみた。
どちらも "ghc -threaded -O2 --make SortMain" でコンパイルし、
意味は無さそうだが sort の方でも -N1 と -N2 で実験してみた。
リストの要素数は 200000 だ（700000 では -N2 で固まる）。

下記は４パターンそれぞれを５回試した時の処理時間の平均値だ。
 （小数点第２位で四捨五入した）
ちなみに、タスクマネージャで目測した２つのCPUの使用率において、
片方を１とした場合の２つの割合を CPU 1:y と記した。

sort        -N1 [1.0s] [CPU 1:0.5] / -N2 [20.6s] [CPU 1:0.8]
parSort2 2  -N1 [1.0s] [CPU 1:0.3] / -N2 [20.8s] [CPU 1:0.7]

-N2 の方は何故かどちらも４秒程度で完了したり、
10秒程度で完了したりした時もあり、あまり安定しない。
そういうものは平均値の測定から省いた。
本当は20回くらい実験しているが、その中の比較的安定している５回の平均だ。

まったくもって、さっぱりだ。
原因が何処にありそうなのかも見当がつかない。


> 少なくとも、こちらで試した感じでは、"parSort2 2"で要素数700000のリストのソートが -N1 と -N2 で同程度の時間だった。
同程度ではまずいのではないか？

>>474

> sort        -N1 [1.0s] [CPU 1:0.5] / -N2 [20.6s] [CPU 1:0.8]
> parSort2 2  -N1 [1.0s] [CPU 1:0.3] / -N2 [20.8s] [CPU 1:0.7]

sort でも paraSort2 でも -N2 を指定した時の速度が変わらないとなると、並列GCのせいじゃないかね?
たしか、6.10から並列GCが導入されて、-N で指定した数のプロセッサをGCに使うようになったらしいし。

↓の"-gthreads"の説明にいろいろ書いてあるから試してみたら?
http://www.haskell.org/ghc/docs/6.10.4/html/users_guide/runtime-control.html

あと、こっちの環境(書くの忘れてたが Mac OS X)では、-N1 と -N2 とでこんなに差が出ないので、
Windows 版特有の問題もあるんじゃないかね?

> 同程度ではまずいのではないか？
まずいとは思うが、>>469 のGHCのバージョンが6.8なので、バージョンが違うせいだと思い放置した。
上の結果のようなあからさまな差はない、ということだけ伝えたかった。

>>475
以下が parSort2 2 を３つのパターンで実験してみた結果だ。
パターン番号 : 指定オプション : 処理時間
1 : -g1 -N1 :  1.0s
2 : -g1 -N2 : 20.0s
3 : -g2 -N2 : 20.0s

-N2 においては、-g1 でも -g2 でも処理時間的にはほとんど違いはなかった。
十数回程度の繰り返したが、結果は変わらず。

次レスに、-S オプションをつけて出力された統計データの一部の概略を示す。

>>475,476
下記が -S オプションをつけて出力された統計データ（の一部の概略）だ。
--------------------
パターン 1 では、Alloc bytes は最初から最後まで
520424 〜 524288 でほぼ一定だった（最後だけガクっと落ちるが）。

Copied bytes の前半は 180000 付近でほぼ一定、後半から 20000 〜 330000 付近で波を繰り返す。
たまに 7300000 付近までスパイク状に跳ね上がる時があるが、その時は第２世代までGCしている。
それ以外の時は第１世代までのGCで済んでる。

Live bytes は 184680 で始まって前半は上昇し、しばらく波を緩やかに繰り返した後、下降する。
--------------------
パターン 2 の Alloc bytes の前半はパターン 1 と同じ傾向だが、
後半から 600000 〜 1000000 付近で波繰り返してる。

Copied bytes の形状はパターン 1 と似ているが、上限が倍近くに上がっている。
スパイク状になるのはパターン 1 と同じ。

Live bytes も形状はパターン 1 と似てるが、上限が 150000000 付近まで上がる。
--------------------
パターン 3 の Alloc bytes はパターン 2 とほぼ同じ。
若干、波が穏やかなような気がする。

Copied bytes もパターン 2 とほぼ同で、スパイク状になるのも同じ。

Live bytes はパターン 1 や 2 と違い、細かな上下はするが、最後まで上昇が続く。
ただし、上限（最後付近）は 134000000 付近で、パターン 2 よりは若干低い。
--------------------
パターン 1 が他の２つと明らかに傾向が違うのは、Alloc bytes がほぼ一定である事。

私は GC の仕組みをよく理解していなく、ここから有益な情報を得ることができないのだが、
処理時間が大幅にかかる原因と思われるものは何か分かるだろうか。

>>476
そんなもんわからん。
> 2 : -g1 -N2 : 20.0s
> 3 : -g2 -N2 : 20.0s
これの時間が変わらん時点で並列GCのせいという予想が誤りだとわかる。

念のため、Windows XP Professional、GHC 6.10.4 で試してみたが、
"parSort2 2"で要素数700000のリストのソートが -N1 と -N2 で同程度の時間だった。
(CPU: Core2Duo 2.83GHz、メモリ: 4GB)
これで、Windows版固有の問題というのも間違いだということがわかる。

あとは正直、そちらのコードにミスがある可能性ぐらいしか思いつかない。
(疑うようで悪いが、万が一ということもあるので)
試しに、以下のコンパイルオプションでビルド・実行して、
SortMain.prof に parSort2 が含まれているか確認してもらえないだろうか。

ghc -prof -auto-all --make SortMain.hs
SortMain +RTS -p -RTS 200000

あと念のため確認だが、sort 関数は >>469 のページからとってきたものを
そのまま使用しているだろうか。

>>478
> そんなもんわからん。
何か気に障ることを言ってしまっただろうか。
であれば、すまん。

もっとすまないのは、最初は素直にコピペしてきたのだが、
関数名をわかりやすくするために変更している時に、
触ってはいけない部分まで変えてしまっていた。

もう一度コピペし直してきたら、貴殿のように -N1 と -N2 で「似たような」結果になった。
お騒がせして本当に申し訳ない。

ただ、やはり -N2 の方が遅い。
例えば parSort2 2 で、リスト数 300000 で実行すると、
-N1 で 1.51s、-N2 で 1.57s、-g1 -N2 で 1.82s。

parSort2 n の n を増やせば増やすほど -N1 と -N2 の差が開く。
逆転したことが一度もない。

もう少し落ち着いて、自分で調べてみる。
つきあってくれてありがとう、申し訳なかった。

>>479
まず、前提として、>>464 が遅い理由は、>>469 を読めば理解できると思っている。
parSort2 が遅いことが理解を妨げていると思ってここまで付き合ってきたが、
それが解消しても理解が進んでないと思われることが悔しい。

>>468 によると、GHC 6.12.1 で並列性能が上がったらしいが、
それを逆に考えると、それ以前のバージョンは並列性能がそれほど期待できないということになる。
そのようなバージョンで高速化できないことに拘泥するのは無意味だと気づいて欲しい。

これ以上スレを汚すのは申し訳ないので、ここで消える。
スレを私物化する形になってしまい、申し訳なかった。

>>480
> そのようなバージョンで高速化できない ことに拘泥するのは無意味だと気づいて 欲しい

他にも興味深いトピックがあったから日本語版を買ってみたが、
翻訳者はバージョン6.10.4で動作を検証してるそうじゃないか。
であれば、このバージョンでの25%の速度向上も確認してるはず。

数%しか向上しないのなら環境の違いで納得できるが、
-N2の方が遅いというのは、やはり何処かに問題があると考える方が自然ではないか。

zipとunzipをパターンマッチを使って自分で定義したいんだが、
上手くいかない。良かったら教えてください。

>>482
アホすぎ。死ね

Introduction To Functional Programming Using Haskellの4.4を読むといいよ

>>484
ヒントを与えるのやめろよ
自立しないだろ

自立するしない以下のレベルではないだろうか

プログラマって鬱病が多いんだね。仕事がハードで心に余裕がないからか。
ネタにマジレスは注意信号です、気軽にお近くの（ｒｙ

そもそも本業のプログラマがここにいるの？

platform マダー？

>>483
すみません、
zip,unzipのプログラムを書こうとするとなぜアホということになるのですか？

不覚にもﾜﾗﾀ

>>489
なに、近々バージョンアップする予定なの？

>>490
うまくいかないのがアホ。

>>493
Haskellってやはり凄いんですね。zipやunzipの関数を書くのは
結構難しい課題だと思い込んでいました。

zipくれって書き込むと捕まるんだっけ？

>>494
それは Haskell というより関数型言語に慣れてないだけだと思うよ

>>494
そういう（zip、unzip自作の基になる）基礎知識は
ここで中途半端に得るより、本を一冊買ってじっくり学んだ方がいい。
「Haskell: The Craft of Functional Programming」を薦める。

func x = (x,x)になる関数funcを関数合成だけでやる事ってできないよね？
idとかを組み合わせて。

途中に名前を使う関数(\x -> (x,x))等を使用するのは無しで。

>>498
少々汚いやり方だがこんなのはどうだ？
まあPreludeの関数がパターンマッチングを使っているから美学的な意味しかないが

import Control.Arrow (first ,second)

makeTuple = second head . first head . splitAt 1 . repeat

main = print . makeTuple $ "You can do it!"

>>499
なるほど目から鱗だわありがと。

first f = \(x,y) -> (f x, y)

だからsplitAtしちゃえばいけるな。

id &&& idじゃ駄目かにゃ？

>>501
そのほうがいいな

>>501
ありがと。

Arrow人気すぎﾜﾛﾀ

そんな事もあろう

タプルを作るにはarrowしかないんだもの

>>461
同じくmac portsのghcが壊れてて入らない
darcs使いたいだけなのになんでこんなに苦労するんだろう

>>490
私もHaskell勉強中だが触発されてzip関数書いて見たら
普通に出来たけど？

パターンを網羅してないのかも

ソースコードは自立してもらう為非公開が良いのかな

次はunzipに挑戦だ！

507ですがunzip出来ました

myunzip [] = ([],[])
myunzip ((x,y):ns) = ((x:(fst (myunzip ns))), (y:(snd (myunzip ns))))

最初 fst snd使ってなくて型が違うと怒られた

もっとこうするとスマートに再帰で書けるとか有ったら教えてください

http://www.haskell.org/ghc/docs/latest/html/libraries/base-4.2.0.0/src/GHC-List.html#unzip

myunzip ((x,y):ns) = let (xs,ys) = myunzip ns in (x:xs,y:ys)
どうどす？

foldr (uncurry (***).((:)***(:))) ([],[])

>>509,510,511
勉強になりました
ありがとう御座いました！！

とくに510は再帰と言うのにも拘ってスマートに書かれてて感動です
511もまだ知らない演算子(***)が使われてて勉強になりました

>>506
http://www.haskell.org/ghc/download_ghc_6_12_1.html#macosxintel
今は、バイナリをインストールするか
ソースコードからビルドするしかないんじゃないかな

まだportでghcインスコできないのか

>>511をよく見ると、unzipがAAに見えてくる…

２つの同じ要素数のリスト (Num a) => [a] を、
片方を１要素分横にずらして和を取りたいです。
たとえば [1, 2, 3] と [7, 8, 9] であれば
[1, 2, 3, 0] と [0, 7, 8, 9] の和です。

今は定義を素直に実装して次のようにやってます。
shearAdd :: (Num a) => [a] -> [a] -> [a]
shearAdd as bs = zipWith (+) (as ++ [0]) (0 : bs)

もっと洗練された方法はあるでしょうか。
たとえば (++) 演算子は左辺のリストの要素数が大きいと不利なので、
これを改善できるとか。

すいません、age てました。

zipWith使ってる時点で既に線形時間だから気にすることないような気が

パスカルの三角形か？
その定義でも遅延評価のおかげで非効率にならないと思う。

>>518,519
あ、なるほど。
zipWith 関数でリストの分解->再構築が行われる時、
(as ++ [0]) の「先頭から順に」要素を取ってくるから、
++ 演算子によるリストの分解->再構築は処理されませんね。
盲点でした。

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

>>516
zipWithと(++)はどちらもfoldrで書ける関数だから
最適化がかかって一つの再帰関数の置き換えられると期待。
そのままで大丈夫だと思う。
遅延評価のおかげではなく、最適化のおかげで非効率にならない。

見た目通りに処理されるなら
(as ++ [0]) の先頭要素を取ってくるときに
毎回 (x:xs ++ [0]) -> x:(xs ++ [0]) というパターンマッチが入るから、
結局リストの分解・再構築の分の処理はされちゃうよ。

効率といったのは、先に(xs ++ [0])を評価して
次にzipWithを評価するというような、二度手間のリスト走査には
ならないという意味だったんだ。

GHCではzipWithはbuildを使うようになっているから、最適化も
されるんだろう。

あ、522は私です。

Real World Haskell ってそろそろ第2刷出た？

「ふつうの Haskell プログラミング」について質問です。
次の cat プログラムの例が載っているのですが、

main = do cs <- getContents
putStr cs

これを実行すると、標準入力への入力が出力されるのですが、
これが何度も繰り返される仕組みがよくわかりません。

% ./cat
aaa # 入力
aaa # 出力、入力待ち
bbb # 入力
bbb # 出力、入力待ち
...

本には遅延評価って説明がありましたが、
ループが無いのに何度も入力/出力されるのが不思議です。
なぜこうなるんでしょう？

>>525
本の説明で理解できないなら、それ以上にわかりやすく説明するのは難しいな。
データフロー言語的な考え方が出来れば疑問に感じることはないと思うんだが…

>>525
>ループが無いのに何度も入力/出力されるのが不思議です。
ループはputStrの実装の中にある
getContentsアクションは標準入力の内容を一切読まずに、未評価の文字列を返す
putStrは、その文字列の中身を先頭から調べて、順番に表示していく
文字列の中身を調べる(つまり評価する)ときに初めて、標準入力からの読み込みが必要に応じて発生する

論理的にはユーザが一文字入力するたびにputStrが一文字出力するような動作と考えてもいい
実際はOSの行バッファが間に入るから、一行入力するたびに一行出力、になってる

あと、getContentsみたいな遅延IOはHaskellの振る舞いとしてはかなり例外的なものだから、
初心者ならあまり気にしないで先に進んでいいと思うs

>>525
cs は遅延評価されるから、

getContents - プロミスだけ渡すお
↓
putStr - プロミス評価するよー
↓
getContents - まだ入力ないから評価できないお
↓
getContents - 入力あったから、あった分だけ評価するお
↓
putStr - 評価きたから表示したよ。でも、まだ続きが評価できないよー
↓
getContents - まだ入力ないから(r
↓
getContents - 入力あったから(r
↓
putStr - 評価きたから(r まだ続きが(r
↓
・
・
・

無限ループ

ファイルとかはEOFが有るのでgetContentsで与えられるのは有限のリスト
一方、標準入力は事実上の無限リスト
putStrは続きの要素が表示できるようになったら表示してるだけ

データ構造と、そのデータ構造上の演算を定義したい。
その演算を頻繁に使うので効率性を高めたいが、
同時にプログラムの堅牢性も可能な限り高めたい。

たとえば２次元ベクトルをたまたま２要素のタプルで表現し、
その上の演算として加算 add を定義するとする。

データ構造と演算の間に抽象の壁を設けずにプログラムするとこうなる。
newtype Vec2 a = Vec2 (a, a)
(Vec2 x0, y0) `add` (Vec2 x1, y1) = Vec2 (x0+x1, y0+y1)

抽象の壁を設けて堅牢性を高めるとこうなる。
newtype Vec2 a = Vec2 (a, a)
newVec2 x y = Vec2 (x, y)
getX (Vec2 x, _) = x; getY (Vec2 _, y) = y
v0 `add` v1 = newVec2 (getX v0 + getX v1) (getY v0 + getY v1)

前者の場合、add のパターンマッチでデータ構造を２回分解し、
右辺で１回再構築して演算している。
後者の場合、４回分解して１回再構築している。
データ構造によってはもっと差が開く場合もありうる。

当然前者の方が効率はいいだろうが、演算の数が多く、
もっと良いデータ表現方法があればデータ構造を変えたい場合もあるので、
後者の堅牢性もほしい。

前者の効率性を重視しながら後者の堅牢性に近づける方法、あるいは
後者の堅牢性を重視しながら前者の効率性に近づける方法はないだろうか。

もしかしたら、データ構造に依るところが大きく、
一般的に解決する方法はないのだろうか。

その場合、コンパイラが最適化はしてくれないんだろうか

あえて単純な例を選んだからだろうけど、
単純すぎて、どう堅牢性が上がっているのかも分からないし、
コンパイラが十分賢ければ、同じコードがでるんでは、という気が。

あと後者のほうは、
newVec2 x y = (x, y)
getX = fst
getY = snd
v0 `add` v1 = newVec2 (getX v0 + getX v1) (getY v0 + getY v1)
で十分だよね。

>>532
> 単純すぎて、どう堅牢性が上がっているのかも分からないし、
それは申し訳ない。

後者は、抽象データ構造にしてモジュールを分ければ、
プログラムの堅牢性が高まる。
module Vector (Vec2, newVec2, getX, getY) where
newtype Vec2 a = Vec2 (a, a)
newVec2 x y = Vec2 (x, y)
getX (Vec2 x, _) = x; getY (Vec2 _, y) = y
---
module Operation where
import Vector
v0 `add` v1 = newVec2 (getX v0 + getX v1) (getY v0 + getY v1)

とすれば、たとえば何らかの理由で２元ベクトルの表現方法を
２要素のタプルから２要素のリストに変えることになっても、
Vector モジュールの定義だけを変えるだけでよく、
Operation モジュールの定義には影響を与えない。
つまり、add の定義はそのまま使える。
これを私は「堅牢性が高い」と表現している。

>>530 の前者のように抽象の壁を設けないと、
データ構造の表現を変えた場合に、
そのデータ構造上の全ての演算の定義を変えなければならない。

で、私も >>531 や >>532 のように
>> 530 の後者でも最適化でほぼ同等の効率性を維持できると期待したいが、
「最適化で同じコードが出力された事を確かめる術」はあるのだろうか。

今はコンパイラとして GHC を使っているので
GHC のドキュメントをいろいろ眺めている最中なのだが、
この辺りの最適化の仕組みがあるのかどうかもまだ分からない状態だ。

とりあえず走らせて比較してみては

>>535
やっぱり、結局はそうなるのか。
いや、ダメってわけじゃないし、当然実際に測って比較はする。
誠にごもっともなんだが・・・

何というか、もっと理詰めで論理的に推論したいなぁと思う。
こういう最適化の仕組みがあって、今回この部分にこのような適用できるから、
このように最適化されることが期待できる、みたいな。

>>536
GHCのソースでも読むしかないんじゃね？

抽象データ型のコストは、そりゃ当然あるだろうが
どのように実装しているかの議論は軽く本一冊にはなるしね

>>530の例のように静的に決まるものはかなり期待していいんじゃなかろうか
関数型に限った話じゃないけど

GHC って C に変換して出力する機能とかってなかったっけ？
人が読むのはつらいかもしれんが、小規模なものならなんとかなるだろ。

Core言語というものがありましてね

私も >>534 で最適化に期待したいと言ってしまったので悪いが、
なんだか話がちょっと飛躍しそうなんで戻す。

そもそもの質問はどのように最適化されるかではなくて、
>>530 の最後の方の文をくりかえすと、

> 前者の効率性を重視しながら後者の堅牢性に近づける方法、あるいは
> 後者の堅牢性を重視しながら前者の効率性に近づける方法はないだろうか。

なんだが、答えは「無い ==> 最適化を期待しろ」 という理解でいいんだろうか。

この答えがまだ得られていない。
この理解が正しいと確定してから、GHC のソースを読むなり、
C 言語に変換するなりして最適化の仕組みを調べる作業に入りたい。

やはり、安易に最適化に期待するよりは、
プログラムで何とかするよう努力したほうがいいような気がする。

抽象データ型は、それを構成している型の関係に矛盾がないかコンパイル時に静的に調べられる、
というのがたぶん530の言いたい「堅牢化」であって、実現によって効率に差があることとは別の話だろう。

で、その点で>>530は「堅牢化」の利点がない。

たとえばaddなら、全然種類の違うものを足してないかチェックするとかｗ
足し算に期待する制約を表現すべきであって、それだとほんとに壁を作っただけになってないか？

>>542
本質的に同じフローであれば同じになる。 少なくともそれを目指しているはず。
小手先のテクニックで変形しても処理系のフロー解析を邪魔するだけになるのがオチだよ。
オーダーが変わらない範囲での変形はあまり意味がない。
自分の脳味噌が処理系以上の解析能力がある自信があるかい？

>>543
違う。
プログラムの局所的な変化が他の広い部分に影響を及ぼさないとき、
私はそれを「堅牢性が高い」状態と言う、と >>533 で伝えたつもり。

あなたと同じ事を言っているのであれば申し訳ない。
私の理解力がまだ足りないせいだ。

Hugs 使ってみようと思ったら、もうずっと更新されてないんだね…

>>545
> 本質的に同じフローであれば同じになる

この場合の「フロー」とは何だろうか、詳しく訊きたい。

私が示した例の場合に限れば、同じフローだということだろうか。

>>544
言っている意味がよく分からないし、笑われている意味はもっと分からない。

壁を作っただけになってないかと言うが、
壁を作ることそのものに意味があるのではないだろうか。
（もちろん、その壁で仕切った高レベル側の関数を使わないと意味が無いが）

私が示した「例」に限ったとしても、
もしベクトルを配列で表現することに変えたとしたらどうなるか。
抽象の壁を設けないと、add に代表される「そのデータ構造上の関数」は、
データ構造の構造に依存しているため、「全て」書き直しになる。

>>530

newtype Vec2 a = Vec2 {toTuple: (a, a)}
v1 `add` v2 = Vec2 (x0+x1, y0+y1)
where
(x0, y0) = toTuple v1
(x1, y1) = toTuple v2

Vec2の定義を変えた場合はtoTupleの定義を変える。

もう少し複雑なデータ構造の場合:
・(>>550のように)タプルやリストなどの単純なデータ構造に変換する関数を定義し、アプリケーション側ではそちらを使う
・例えばfmap, fold, traverseなどや、データの(論理的な)構造に合わせてデータを走査する高階関数を定義し、(ry
・Zipperを定義し、(ry

>>550,551
getX や getY などのようにデータ構築に使う材料をひとつずつ得るのではなく、
タプルやリストなどの形で「一度に全部」得ることで余計なパターンマッチを防ぐ
ということだと理解したが、合ってる？

うまくいきそうな気がするので検討してみる。

テンバヤン mp 過ぎるwwww
して完璧で太郎!!!
位置かこちらへ向こう岸だろ。
いいかげんカンペ見たらええのに。

そしてまた一つ車輪の再発明

すでにある用語の曖昧な再定義をしちゃうあたりからして勉強不足ってことよ

>>540
コンパイルオプションで、C経由でコンパイルを指定すればできるけど、
相当小さなソースからでも、普通は読めたもんじゃないシロモノが出てくるよ。

>>530 の抽象の壁を設けない方法 [1] と設けた方法 [2]、
>>550 の取得系関数をタプルで一度に得るようにする方法 [3]、
併せて３つの方法で処理速度を測ってみた。
意外な結果が出て戸惑っている。

[実験方法]
ランダムな値の２次元ベクトルを 500000 個作ってリストにする。
そのリストに対して foldl1' add で総和を計算して結果を表示する {*}。
この処理 {*} の前後に Data.Time.Clock.getCurrentTime を置いて時間の差を測る。
同じ実験を３回行って平均を出す。
GHC 6.10.4 で -O2 オプションのみを付けてコンパイルした。

また、[1] や [3] にも取得関数 newVec2 を３者同じ形で作り、
それぞれの add 関数の右辺で使った。
つまり、それぞれの add 関数において、newVec2 に渡す２つの引数の
作り方による処理時間の差だけを計った（つもり）。

[結果]
[1] : 17.3s
[2] : 10.2s
[3] : 10.2s

処理速度だけなら抽象の壁を設けない [1] が最も速いだろうと思っていたが、
意外にも他の２つより1.5倍以上遅かった。
[1] において newtype Vec2 a = Vec2 (a, a) ではなく type Vec2 a = (a, a) のように
データ構築子を作らずにやっても同じ 17 秒だった。

どうしてこうなるのか、今のところ推論できずにいる。
CソースやCore言語なるものを出力して調べるしかないんだろうか。

データの抽象化ってSICPの2章にあるAbstraction Barriersのことでしょ？
ttp://mitpress.mit.edu/sicp/full-text/book/book-Z-H-14.html#%_sec_2.1
実際のデータがどのように実装されているかに関わらず、
データを生成する関数、各要素にアクセスする関数さえ定義できれば
それよりも「高度な」関数(2次元ベクトルだったらaddとかmulとか)は
アクセッサ、生成子を用いて定義できるっていう話で合ってるよね？

>>557
ソース見せて欲しいです。メモリの使用率はどれが良かった？
一応、Wikiにこんなページがあることを。
http://www.haskell.org/haskellwiki/Performance

data-accessor使えよ

>>558
それのこと。

なるほど、メモリの使用率は考慮してなかった。
これから解析してみる。

が、その前に実験に使ったソースをさらす。
"Real World Haskell" に載ってた処理時間を測るプログラムをほぼそのまま流用した。
http://book.realworldhaskell.org/read/concurrent-and-multicore-programming.html#id675679

モジュールは２次元ベクトル型とその演算を定義する Vec.hs と、
処理時間を計るメインの Test.hs に分けた。
文字数を減らすために型宣言やコマンドライン引数のエラーチェックは省いた。
行間も詰めたので見にくいが、コピペすればそのまま動くはず。

以下、ソースを載せるために立て続けにレスするがご諒承願う。

module Vec where

newtype Vec2_1 a = Vec2_1 (a, a)
newVec2_1 x y = Vec2_1 (x, y)
(Vec2_1 (x1, y1)) `add1` (Vec2_1 (x2, y2)) = newVec2_1 (x1 + x2) (y1 + y2)

instance (Show a) => Show (Vec2_1 a) where
  show (Vec2_1 (x, y)) = '[' : show x ++ ", " ++ show y ++ "]"
----------------------------------------------------------------------

newtype Vec2_2 a = Vec2_2 (a, a)
newVec2_2 x y = Vec2_2 (x, y)
getX (Vec2_2 (x, _)) = x
getY (Vec2_2 (_, y)) = y
v1 `add2` v2 = newVec2_2 (getX v1 + getX v2) (getY v1 + getY v2)

instance (Show a) => Show (Vec2_2 a) where
  show v = '[' : (show . getX) v ++ ", " ++ (show . getY) v ++ "]"
----------------------------------------------------------------------

newtype Vec2_3 a = Vec2_3 {getV :: (a, a)}
newVec2_3 x y = Vec2_3 (x, y)
v1 `add3` v2 = newVec2_3 (x1 + x2) (y1 + y2)
  where (x1, y1) = getV v1
        (x2, y2) = getV v2

instance (Show a) => Show (Vec2_3 a) where
  show v = '[' : show x ++ ", " ++ show y ++ "]"
    where (x, y) = getV v

module Main where

import Data.Time.Clock (diffUTCTime, getCurrentTime)
import System.Environment (getArgs)
import System.Random (StdGen, getStdGen, randoms, split)
import Control.Parallel (par, pseq)
import Data.List (foldl1')
import Vec

type Vec2 = Vec2_1 Int
newVec = newVec2_1
add = add1

randomInts k g = let (g1, g2) = split g
                     med1 = take k (randoms g1)
                     med2 = take k (randoms g2)
                     res = (zipWith newVec med1 med2) :: [Vec2]
                 in force res `seq` res

force xs = go xs `pseq` ()
  where go (_:xs) = go xs
        go [] = 1

-- 続く

-- 続き

main = do
  args <- getArgs
  let count = read (head args)
  input <- randomInts count `fmap` getStdGen
  putStrLn $ "We have " ++ show (length input) ++ " elements to sum."
  start <- getCurrentTime
  let res = foldl1' add input
  putStrLn $ "sum is " ++ show res
  end <- getCurrentTime
  putStrLn $ show (end `diffUTCTime` start) ++ " elapsed."

うぜぇからhpaste使ってくれ
http://hpaste.org/

Test.hs の 10 行目から 12 行目の Vec2_1、newVec2_1、add1 を
それぞれ _2 や _3 に変えて実験する。

コンパイルは以下の通り。
ghc --make -O2 Test.hs


-- 以上

本当に迷惑だな

>>564
すまない、そんな便利なものがあるとは知らなかった。
次回から利用させてもらう。


>>558
実行時に RTS オプションで -S を与えてメモリ状況を見てみたが、
1.5倍以上の時間差が開くほどの違いがあるとは私には分からなかった。
[1] は [2] や [3] の状況をそのまま時間軸に拡大したような感じだ。

GC の稼働率は [1]=90%、[2],[3]=83% で、[1] が他に比べて若干高いなとは感じるが、
時間差の原因となるような違いには思えないんだが。

ちなみに、最適化オプションを省くと [1] が最も速くなる（他の1/2）。
単純に、生成したコードの効率の違いではないかと思ってる。


ただ、迷惑そうなので、しばらくレスは控えることにする。

HDBC-postgresqlが最新のghcでビルドできないお
(。＾ω＾゜)ｵﾛﾛｰﾝ
Windows2000 SP4
HDBC-2.2.2はインストールできたのに

これかな？
ttp://software.complete.org/software/issues/show/164

ghc 6.10.4 のときにHDBC-sqlite3がビルドできなかったけど、
これでできるようになった。

timeいい加減にしろ

hmatrix ライブラリを "cabal install hmatrix" でインストールしようとしたら、
次のエラーが出た。

Resolving dependencies...
Configuring old-time-1.0.0.2...
cabal: Error: some packages failed to install:
directory-1.0.0.3 depends on old-time-1.0.0.2 which failed to install.
haskell98-1.0.1.0 depends on old-time-1.0.0.2 which failed to install.
hmatrix-0.8.3.1 depends on old-time-1.0.0.2 which failed to install.
old-time-1.0.0.2 failed during the configure step. The exception was:
sh: runGenProcess: does not exist (No such file or directory)
process-1.0.1.1 depends on old-time-1.0.0.2 which failed to install.

いろんなもんが old-time-1.0.0.2 に依存してるけど
old-time-1.0.0.2 がインストールに失敗するってメッセージだと思うけど、
"cabal info old-time" で調べると、このバージョンは既にインストールされている。

これはどういうことなの？

shが見つからないって言ってるの
windows上でやるならmingwとか入れる必要がある

既出だったらごめんよ

Haskell: The Craft of Functional Programming (International Computer Science Series)
Simon Thompson (ペーパーバック - 2011/4/19)
出版社: Addison-Wesley Educational Publishers Inc; 3rd Revised edition版 (2011/4/19)
http://www.amazon.co.jp/Haskell-Functional-Programming-International-Computer/dp/0201882957/

今年か! と思ったら来年じゃねぇかｗｗｗ

>>574
俺も今年だと思って貼った
吊ってくる

>>572
試しに cabal-install を "cabal install cabal-install" で更新してみようとしたら、
こちらも "depends on old-time-1.0.0.2 which failed to install." って言われる。
その他に、一昨日まで cabal でインストールできていたライブラリが、
昨日から old-time-1.0.0.2 のせいでインストール（更新）できない。
ちなみに、なぜか最新の old-time-1.0.0.3 も同じ理由でインストールできない。

これも、mingw とかに関係してる？
それとも GHC 自体を一度再インストールした方がいい？
それだと今までインストールしたライブラリも再インストールしなきゃならないから、
正直ちょっとしんどいが。

言われたこと試せや

>>577
mingw と msys 入れて、msys のコンソール上で同じ事を試したけど、
全く同じエラーだった。

newtypeはコストゼロだよ

>>578
どっちのパッケージで試したんだよ
同じエラーってどこの部分のことを言ってるんだよ
言葉足らずにもほどがある

>>580
mingw と msys 入れて、msys のコンソール上で
"cabal install hmatrix" を実行したら
>>571 と同じメッセージが表示されて、インストールできなかった。

また同コンソール上で、>>576 のように
"cabal install cabal-install" を実行しても同様に
old-time-1.0.0.2 パッケージのインストールに失敗し、
これに依存している全てのパッケージがインストールできない。

さらに同コンソール上でも、>>576 のように
old-time-1.0.0.3 すらも old-time-1.0.0.2 のせいでインストールできない。

cabel が sh を見付けられないのかもしれない。
sh があるパスを環境変数 path に追加してみたら？

>>582
sh というのは msys にある sh だよね。
（C ドライブ内を検索したら、そこにしか無かった）

Windows の環境変数の PATH に追加して同じ事を試してみたけど、
変わりなかった（同じメッセージのエラーが出ていろんなパッケージがインストールできない）。

しかし、>>576 でも言ったけど、
ついこの前まで cabal でインストールできていたライブラリが
昨日から old-time-1.0.0.2 のせいでインストールできなくなったから、
sh が原因とも思えないんだけど。
気を悪くしたらごめん。

今日はもう寝て、仕事が終わってからまた調べてみるけど、
それで駄目だったら、アドバイスくれた人たちには申し訳ないけど、
諦めて再インストールします。

$ ghc-pkg unregister old-time-1.0.0.2 --force

一応書いておくが皆が突っ込んでるのは
>sh: runGenProcess: does not exist (No such file or directory)
ここの部分な

>>585
これって
sh が「runGenProcess がねぇよ」って言ってるの？
それとも sh の runGenProcess が「〜はねぇよ」って言ってるの？
（〜の部分に何が入るかは読み取れない）

どっちにしても、ないのは sh じゃない何か別なもののように見えるんだけど

runGenProcessが「shがねぇよ」って言ってる
readFileあたりに存在しないファイルを開かせて、例外を掴まえて表示してみれば分かる

只の揚げ足だが、
> runGenProcessが「shがねぇよ」って言ってる
runGenProcess を実行しようとしてるのは sh じゃねえの？

>>586
"shが無い"でないのはそうなのだが、MSYS+MinGWをちゃんとインストールすれば回避できる。
shだけにパスが通ってるんじゃねえの？

runGenProcessがどうのって出るのはここいら(createProcess,runGenProcess_)のせいだと思う
http://www.haskell.org/ghc/dist/stable/docs/libraries/process/src/System-Process.html

>>588
違うよ
runGenProcessがshを実行しようとして、見つからなかったというエラー

shとrunGenPrecessが逆ならわかりやすいのに。

sh「runGenProcess「does not exist (No such file or directory)」」

http://darcs.haskell.org/libraries/base/GHC/IO/Exception.hs
これのShow IOExceptionのところを見れば分かるけど、最初の部分(この例だとsh)は対象のファイル名で、
エラーの発生場所(runGenProcess)はその次にくる

>>589
自分ではちゃんとインストールしたつもりなんだけど・・・

最初に "MinGW-5.1.6.exe" をインストールした。
ダイアログで "Select components to install:" と訊いてくるので、
デフォルトのまま [Next ボタン] を押してインストール。

次に "MSYS-1.0.11.exe" インストールした。
インストール後に、MinGW があるか、
あるならそのパスを訊いてきたから入力した。

そして最後に >>582 の指摘を参考に、
Windows の環境変数 "path" に "C:\msys\1.0\bin" を追加した。

これでも駄目だったんだけど、何か足りない作業がある？

あかん、ネットで情報探したり、
MinGW + MSYS を再インストールしてみたりしたけど、駄目だった。
もう限界。

アドバイスしてくれた方々には良い結果を出せなくて申し訳ないけど、
GHC を再インストールするわ。

板汚しただけになってすまなかった。

VirtualBoxとかVMWare上でLinuxがそこそこ快適に動くなら
その上で使う方が遥かに楽だからな

>>596
だよな
俺はエミュレータ上でほとんどの開発をしている。コードをバージョン管理していれば同期できる

Arrow表記について調べているのですが、
Ross Paterson の論文 [A New Notation for Arrows] を読んでも、
rec の構文がよく分かりません。

たとえば、loop 関数でリスト [n, n-1 .. 0] を作る Arrow (->) を定義しました。
（http://d.hatena.ne.jp/mzsms/20091119/1258657366 を参考にした）

let f (a, g) = (g a, \n -> if n == 0 then [n] else n : g (n-1))
let af = loop f

これを Arrow 表記で rec を使って表現するには、どう書くのでしょうか。

すいません、例の let は無視してください。

{-# LANGUAGE Arrows #-}
af1 :: Num a => a -> [a]
af1 = proc x -> do
  rec
    g <- returnA -< \n -> if n == 0 then [n] else n : g (n-1)
  returnA -< g x

こんなんか？

>>600
なるほど、再帰的に呼ぶ必要がある式のみを rec でマーキングすれば十分なんですね。

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

こういうｷﾓｲarrow loopを使ったコードの解説をする記事をいくつか教えてください
どこかでcircular programmingとか言うキーワードを見た気もしますがそれも含めて

[WxHaskell/Quick start] のページ
http://haskell.org/haskellwiki/WxHaskell/Quick_start
の最初のサンプルをそのままコピペして動かしてみたんだけど、
ウィンドウタイトルとボタンの文字がそれぞれ "H" と "Q" しか表示されない。
つまり最初の一文字だけ。

これってうちだけ？

ちなみに環境は
wx-0.12.1.2
wxcore- 0.12.1.2
wxWidgets 2.8.10
OS : Windows7
GHC 6.10.4

haskellでOS全体のキー入力を取得したんだけどどうしたらいい？
gtkhsやqthaskellとかを見たんだけど、それらしきものが見つかりません。

>>604
HaskellではなくOSの勉強をしたほうがいい

なんでみんなghc最新版使ってないの？

えっ
みんな最新版じゃないの？

質問みてたら結構6.12じゃない人がいる
気のせいか

Haskell Platform に含まれてるのが 6.10.4 だからだろ。
Haskell.org でも Platform の方を薦めてるし。

Merge Request: LLVM Code Generator for GHC
ttp://www.haskell.org/pipermail/cvs-ghc/2010-February/052606.html
反応は・・・

早めに追加出来れば、llvmがバージョンアップする時も
エラー箇所の報告も上がるだろうし、パッチの問題も減るからマージしたいんだろうな。

ただ、メンテナー確保しつづけれるのか？

HOpenGLでクローズコールバック使えないんだけど、なんで？
何かそれに同機能・似た機能を実現する方法ってないの？

GHC って、次のような型を定義したとして、

date TypeA = TypeA {getInt :: Int, getFloat :: Float, getStr :: String}

次のように、型の一部だけ値を変えた変数を作ったら、

t1 = TypeA 1 0.2 "foo"
t2 = t1 {getFloat = 0.3}

全体がコピーされるんじゃなくて、
getFloat だけコピーされて後は t1 も t2 も同じものを参照する
というように処理されることは期待できるの？

できるよ

>>613
ありがと

Windows+GHC-6.12.1 wxHaskell, gtk2hs 苦労してインストールしたけど
GUIの開発は wxHaskell,gtk2hs どちらがの方が多数派なの？

Haskell.org のサイトで紹介されているGUIライブラリを見る限りでは、
gtk2hsを基盤としたものの方が多い様に思われる。

伝統的なGUIはHaskellでは書きにくい
Haskellの意味論とよく合うのはFRPだが、ライブラリはどれも実験的でろくにメンテナンスされていない

>>617
> Haskellの意味論とよく合うのはFRPだが、ライブラリはどれも実験的でろくにメンテナンスされていない

FRPやAFRPによる各GUIライブラリの使い方を学ぶんじゃなく、
GUIライブラリという例を通してFRPやAFRP自体を学ぶ姿勢の方がいいかもしれんね。

>> 604
thx。ふんぎりついた。勉強するわ。

>>618
そう。だからFRPの論文を読んでみたんだが、まず数学をやる必要があると思った。

Haskell 系の雑誌や機関誌は何かあるでしょうか。
英語でも構いません。

apt-getでGHCをインストールしてcabal-installをソースからビルドしました。
GHC6.12にアップグレードする場合にはGHCとcabal-installをアンインストールしてからGHC6.12をインストールする必要があるのでしょうか？
ubuntuやcabalで管理している依存関係が壊れたりしないか不安です。

>>622
正確に覚えていませんが、ubuntuのGHCと自分でインストールしたGHCで、
GHCのパッケージ管理が競合したか何かですごく苦労しました。

私は、結局ubuntuの用意しているものに一本化に落ち着きましたが、
それ以外のGHCを入れるなら完全にアンインストールしたほうが良いと思います。

>>622
Debian系のghcパッケージはバージョンが古いので、バイナリのtarballのほうがいいんじゃないか。

俺は結局Arch Linuxに移行したがね。
Arch Linuxのパッケージは新しいし、ヘッダーも一緒(-devに分離されていない）なので、
Xを自分でセットアップする覚悟があるならおすすめ。

型推論について質問です。

次の型の関数があるとします。
one :: x -> Int
one n = 1

rev :: String -> String
rev = reverse

このとき、次の式の型が String -> Int になる理由が分かりません。
fmap one rev

fmap の型は (a -> b) -> f a -> f b ですよね。
自分では、まず (a -> b) を one の型より (x -> Int) と推論したのですが、
すると b は Int となって、ここで既に結果の型と違い、躓きました。
それとも、これで合ってるのでしょうか。

どなたか a は〜から〜と推論できるなどと、
詳しく演繹の様子を示していただけないでしょうか。

>>625
> このとき、次の式の型が String -> Int になる理由が分かりません。
> fmap one rev

ならなくね？
(fmap one) . rev なら、 String -> [Int]になる。

>>625
fmap :: (Functor f) => (a -> b) -> f a -> f b
one :: x -> Int
rev :: String -> String
だから、
a = String
b = Int
f = (->) String
よって、結果の型は、
f b = (->) String Int = String -> Int

ポイントは、一つの型rからの関数が一つのFunctorであること
instance Functor ((->) r)

あ、ごめん。Control.Arrow をインポートしたらなるね。

>>627
理解できました。
はじめ f が Functor で、f a の a が (->) String だと思っていました。
それが頭にあったので、one から b を推論した時点で訳が分からなくなっていました。
f は Functor f という文脈上の f なので (->) r になるんですね（関数ファンクタの場合）。

おかげさまで解決しました、ありがとうございました。


>>626,628
よくわかりませんが、私が実験した時は Prelude しかロードしていません。

モジュール名を指定すると、
そのモジュールが公開しているもの（関数や data、typeなど）の名前と
その型シグネチャを表す文字列とのペアのリストを返す関数、
といったものは作れるのでしょうか。

たとえば以下のモジュールの場合、
module Sample (T1, f1) where
data T1 = T Int String
f1 :: T1
f1 = T 1 "one"

getExpList "*.hs あるいは *.hi へのパス" を評価すると、
リスト [("data T1", "T Int String"), ("f1", "T1")] が帰ってくるような。

>>623
レス有り難うございます。
>>624
見るのが遅れてしまいました。
サイトで確認したところソースからビルドするにはGHCが使われると書いて在りましたので、ソースからビルドすれば矛盾は生じないと思いコンパイルを始めたのですが、今日一日コンパイルをしていても未だ終わりません。
電源が落とせなくて困ってます。（笑）

Arch Linuxは良いですね。
ubuntuを入れているマシンに入れた事がありますが、グラフィックスのドライバが合わなくマシンの調子が悪くなったので諦めました。

最近は無用なトラブルは嫌なのでubuntuにXmonadで使ってます。

関数型プログラミングのベストプラクティスみたいなものないかな

ライブラリを作っているのですが、
ある型クラスのインスタンスを定義している時、
その型クラスが持つ複数の関数の一部だけを実装し、
残りの関数は何らかの理由で未実装のままライブラリを公開したいとします。
（それを実装するのはまだ難しく、とりあえず試用版として公開するとか）

この場合、その関数の実装を undefined 関数で代用しても、
コンパイルは一応問題なく通ってしまい、ライブラリのユーザーは
実行時に例外が起きて初めて未実装に気づきます。
（気づければまだいい方で、メッセージも分かりやすいとはとても言えない）

それを実行時ではなく、
その関数を使用しているモジュールをコンパイルしている時に、
何かメッセージを生じさせてコンパイルエラーを起こし、
未実装であることを知らせたいです。

しかし、そのインスタンスの実装済みの関数だけを使用している場合は、
問題なくコンパイルを通らせたいです。

何かいい方法は無いでしょうか。
（使用コンパイラ：GHC）

>>633
無理だと思う

class X a where -- 問題の型クラス
  methodA :: a -> Int
  methodB :: a -> String

instance X YourType where -- >>633のライブラリ内で
  methodA = ...
  methodB = error "X YourType: methodB is not implemented"

foo :: (X a) => a -> IO () -- 第三者(>>633のライブラリの存在を知らない)のライブラリ内で
foo x = ... -- ここでmethodBを使う

たとえばこういう状況で、>>633のライブラリのユーザが、
YourType型の値にfooを適用したとする
でも、この時点ではfooはコンパイル済みなので、fooがmethodBを使っていることがGHCには分からない
fooをコンパイルする時点では、YourTypeのことをGHCが知らないので、やはり警告できない

型クラスを定義するのも自分なら、メソッドにDEPRECATEDプラグマを付けるという選択肢があるけど、
その場合どのインスタンスについても警告が出る

一般論としては、undefinedじゃなくてerrorを使ってなるべく分かり易いメッセージで例外飛ばすのがいいんじゃないか

>>634
やはり方法は無さそうですか。

> 一般論としては、
そうですね、error で分かりやすいメッセージを出して、
かつライブラリのリファレンスにも
それと分かるように書いておくことで対処します。

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

Regexどこいったの？？

俺の隣で寝てるよ

>>622
俺はGHC6.12.1のバイナリをhaskell.orgから取ってきて、個別のディレクトリ(/opt/lang/haskell/ghc/ghc-6.12.1)にインストールしている。
一方で、apt-getでインストールしたghcはアンインストールしていない。

/opt/…下のGHC6.12.1と、apt-getでインストールしたGHCは、下記みたいにして使い分けている。おバカだけど。

(1) 環境変数PATHの先頭の方に、使いたい方のGHCのパスを設定する。
(2) ~/.cabal/と~/.ghc/を、「/opt下GHC6.12.1用」のものと「apt-getのGHC用」のものとで、差し替えて使う。

emacsのflymakeで使うのは、/opt下のGHC6.12.1だけだな。

本当におバカ。でも良いんだ不便ではないし。

>>620
難しい論文を読む前に、"The Haskell School of Expression" を読んでおくと
イメージがつかみやすい。

難しい論文読んでるみなさんカッコいいです

いい歳こいて電子辞書片手じゃないとまともに読めない俺カッコワルス・・・。

読まないよりはいいよ

空気も読もうね

オマエガナーｗ

wxHaskellのサンプル動かすと、ちゃんと動作するけどエラーダイアログが出る。
どなたか理由わかる人がおりましたら、ご教授をいただきたく。

エラーメッセージ：
Failed to load shared library 'comctl32.dll' error 126 指定されたモジュールが見つかりません

++環境++
Haskell 6.10.4
wx 0.11.1.2
wxcore 0.11.1.2
windows7

適当にネットでcomctl32.dllを落してきてC:\Windows\System32に放り込む

ごめん説明漏れ。

C:\Windows\System32\comctl32.dll

はすでに存在していた。にも関わらずエラーが出て困る、ということです。こちらの不手際で、申し訳ない。

seqって
今すぐ計算する事がサンクを作る事より安上がりな時に使うの？

つfoldl'

seqのキラーケース挙げてみて

>>650
僕は、遅延IOのデータをファイルをクローズするまえに評価するために使っている。

あり＾＾

翻訳版 Real Word Haskell の正誤レポートを印刷して表紙の裏に挟んだぞい＾＾ｖ
あとはマーカーでチェックだ

増刷の予定はまだ無いの？

>>654
第2刷は昨年末ぐらいに出てるみたいだけど(有楽町ビックにて確認)、
それ以降の増刷ってこと?

>>655
お、出てたんだ。 いや、うちの近所じゃ見掛けないもんで。
四国は東京から見れば辺境だしな。
でも! 宮脇カルチャースペースがある! 宮脇なら! 宮脇ならきっとやってくれる!
次の休みに高松まで言ってみるわー

宮脇ﾜﾛﾀ
田舎は大変だよなぁ

田舎は大変だよ。
理工学系の中古書店がないから通販で買うにも高いし、
公的な図書館に行っても資料が蔵書扱いで一般の手に触れられない所に置いてあったり、そもそも置いてなかったり。
専門的な勉強してる人はみんな街に出て行っちゃうから生活能力のない内はそういうのに触れられないし、
生活能力が付く頃には学術知識に大きな開きが出て無縁な生活送っちゃうはめになるし。

> 蔵書扱い

図書館にある本はみんな「蔵書」。

利用者が入れない書庫は「閉架」、館外に借り出せない本は「禁貸出」（辞書とか）。

「禁帯出」ね。

公務員並に暇だといいなぁ

ghc-6.12.1が出て何ヶ月も経つのに
gtk2hsはdarcs版にパッチを当てないと使えない有様
足引っ張りすぎだわ

gtk2hs は 6.10.4 ですら使えなかった

6.10.4では使える

そうか、使えたのか。

俺は色々ゴニョゴニョやってもインストールできなかったから諦めた。
代わりに wxWidgets + wsFruit に挑戦したらインストールできたんで、
今はこっちっで遊んでる。

７並べを自動で処理して順位を決めるプログラム書いてるのだけど
53枚のカード(1..13x4+JOKER)[1..53]のリストを人間がシャッフルするみたいにかき混ぜる処理で躓いた
乱数の発生も分からないけど、何処かで読んだ気がする
l = [1..53]
リストｌの中を抜いて後ろにつなげる処理をランダム回繰り返して
ううう、普通の処理系と勝手がすこし違うよね
スマートな処理をと考えると、データ構造にも頭使うし

もっといい方法があるかもしれないが
ランダムな数のリストを作って
ランダムな数のリストと zip してランダムな数の方でソート
んで、カードの方を残す

1,-1をランダムに返す関数を使ってsortByすればよくね
やったことないけど

import System.Random

f [] = return []
f l = do
i <- randomRIO (0, length l - 1)
ns <- f ((take i l) ++ (drop (i+1) l))
return $ (l!!i) : ns

乱数で sortBy するのって偏りは出ないんだっけ
どこかで議論を読んだ気がするんだけど忘れちゃった

>>670
乱数の範囲が十分広くて、値の重複が起こらないようなら大丈夫そう。

>>668のコードを書いてみたけど、偏りがあるのかどうかは分からんかった。

import System.Random
import System.IO.Unsafe
import Data.List

g a b = unsafePerformIO $ do {i <- randomRIO (0, 1); case (i::Int) of {0 -> return GT; 1 -> return LT}}
test l = sortBy g l

GHC6.12.1のリリースノートに
> The I/O libraries are now Unicode-aware, so your Haskell programs should now handle text
> files containing non-ascii characters, without special effort

って書いてあるんだけど、これって、ghciで、

Prelude> ["あああ","いいい"]
["あああ","いいい"]
Prelude>

みたいに、エスケープされていない文字列で出力されるっていうこと？

>>673
違う。putStr "あああ"みたいなのが期待通りに動くようになるってこと
エスケープはShow Stringの実装の話

windows ghc-6.12.1 + gtkhs-0.10.1
windows ghc-6.10.4 + gtkhs-0.10.1
web 上　gtk2hs*split-objs　で検索して設定ファイルを手で修正して
　ソースパッケージから　MinGW+msys環境　でインストールした。

　一応ほとんどのdemo プログラムはコンパイル、実行できた。

>>674
おお、サンクス。でも、ってことは、それほどうれしくないなぁ。

data SimpleString = S String
instance Show SimpleString where
　show (S s) = "\"" ++ s ++ "\""

みたいなのを作れば良いんだとは思うんだけど。

でも、その一歩前進で、Show Stringの実装が変わることを期待しよう。

暫定的に書いてみた、乱数は放置でリストの分割位置が正しいかどうかも未検証
あと、カードは53枚固定なので頭四行は蛇足

cardSet = zip [1..53] ([(a,b)|a<-["SPD","DIA","CLV","HRT"],b<-[1..13]]++[("JKR",0)])
tbls = [[1,a]|a<-[1..13]] ++ [[2,a]|a<-[14..26]] ++ [[3,a]|a<-[27..39]] ++ [[4,a]|a<-[40..52]]
cardlist = [1..53]

shuffle [] = []
shuffle [a,b] = [b,a]
shuffle [a,b,c] = [a,c,b]
shuffle [a,b,c,d] = [a,d,b,c]
shuffle l = retl
where
len = length l
thed = 1 + (rnd len) `div` 2
tbody = rnd (len - thed)
retl = take thed l : drop (thed + tbody) l : take tbody (drop thed l)

GHC 6.10.4 のライブラリ リファレンスの Prelude のページにある
Functor 型クラスのインスタンス一覧に Functor ((,) a)　があるのですが、
このインスタンスの fmap はどのように使うのでしょうか。

ghci で :t (`fmap` (1,2)) を調べてみたら

(`fmap` (1,2)) :: (Num t, Num a, Functor ((,) t)) => (a -> b) -> (t, b)

となったので、試しに (+1) `fmap` (1,2) とやったところエラーが起きました。
No instance for (Functor ((,) t)) だそうです。
なぜ？

使い方が分かりません。

>>678

$ ghci
GHCi, version 6.10.4: http://www.haskell.org/ghc/ :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer ... linking ... done.
Loading package base ... linking ... done.
Prelude> :m + Control.Monad.Instances
Prelude Control.Monad.Instances> (+1) `fmap` (1, 2)
(1,3)

ってできたお。

>>679
ライブラリ リファレンスの Prelude のページに書かれているからといって、
必ずしも Prelude だけをロードすれば全て使えるというわけではないのですね。

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

RWH22章　構文解析器で　Windows環境のGHC-6.12.1 、HaXml-1.20.2 をつかっていたが
コンパイルできず（CFilter 型シグニチャが違うなど）、docContent、Posn, posInNewCxt
を探し出して、何とか動くようになった。Unix環境、他のHaXmlのバージョンでは、本のコード
で動作するのか？　ご存知の方がいましたら、参考のために教えてください。

Real World Haskellの日本語版が出て暫くたつけど、評判はどうなの？

宮脇カルチャースペース行ってきたけどやっぱ1刷しかなかったからそれ買ってきた。

>>681
HaXmlの公式サイトにある通り、1.13から1.20でインタフェースが大きく変わった
たぶんRWHでは1.13を前提にしてるんだと思う

HaXml-1.13.3 で動作確認できました。
ありがとうございました。

GUI（FRP）の他に Arrow が何か役に立った例ってありますか。
たとえば Arrow を導入することでこんなに見通しが良くなったとか。
（Arrow + FRP で本当に見通しが良くなったのかは置いておいて）

Haskell で Float 型およびDouble 型のゼロに最も近い正の値、
正の無限大方向に最も大きい値などは、どのようにすれば得られますか。

>>687
http://stackoverflow.com/questions/1780489/haskell-minimum-maximum-double-constant

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

ところで、こはなんで引数を必要とするのでしょうか。
何か意味があるのでしょうか。

別に要らない
floatRangeなんかがダミーの引数を要求する(これがないとどのインスタンスのメソッドか区別できない)ので
それに合わせてるだけだと思う
引数が邪魔なら、

myMinPositiveFloat :: (RealFloat a) => a
myMinPositiveFloat = minPositiveFloat undefined

>>690
わかりました。

次のように型クラスやインスタンスなどを定義するとエラーになります。

class Class1 a where
  func1 :: (Class2 b) => a -> b

class Class2 a where
  func2 :: a -> String

newtype Type1 = Type1 ()
newtype Type2 = Type2 ()

instance Class1 Type1 where
  func1 t = Type2 ()

instance Class2 Type2 where
  func2 t = "Type2"

コンパイルしようとすると func1 t = Type2 () の部分で

Couldn't match expected type `b' against inferred type `Type2'
  `b' is a rigid type variable bound by
      the type signature for `func1' at ...

というようなエラーが出る。
rigid type variable をキーワードにしてググってみたけど、いまいち理解できません。
どなたか、エラーの意味と解決策を説明して頂けないでしょうか。

やりたいことは、Class1 クラスの様々なインスタンス型が、
それぞれ Class2 の様々なインスタンス型を返す仕組みを作ることです。
オブジェクト指向で言う　Abstract Factory パターンみたいなことです。

>>692
Haskellの型変数は、そこにどんな型を代入しても良いということを表す(暗黙の全称量化)
>  func1 :: (Class2 b) => a -> b
だから、これだと、func1はClass2のインスタンスであるようなbならどれでも生成できるという意味になる
Class1 Type1の実装ではType2という特定の型の値しか返せないので、これに適合しない

意図としては、func1はClass2の「何らかの」インスタンスbの値を生成する、と言いたいんだろう
そういう場合、Haskell98にはないけど、GHCなら(たぶんHugsでも)存在量化という言語拡張が使える

{-# LANGUAGE ExistentialQuantification #-}
class Class1 a where
  func1 :: a -> SomeInstanceOfClass2

class Class2 a where
  func2 :: a -> String

data SomeInstanceOfClass2 = forall a. (Class2 a) => SIOC2 a

決算セールFinalが今日までか。
明日あたり発表してくれないかなー。

誤爆。失礼しました。

>>693
簡潔でとても分かりやすい説明なのですぐに理解できました。

型変数をただのワイルドカードのような感覚で使っていましたが、
意味がまるで違うのですね（どこかでそう解説してた様な気がする）。
全称量化と存在量化だと理屈が分かって納得できました。

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

hasktagsで生成したtagsを使ってtaglistのようなことが
できるvimプラグインって無いかな？
taglistはhaskellには使えないみたい

data Hoge = Hoge Int Int Intの値をIntのリストからフィードして作りたいんですが
foldl ($) Hoge [0..2]だとfoldに渡した($)の型が展開される度に変わるのでNGです。
リストから一気にHogeを作る方法はありませんか？

list2Hoge (x1:x2:x3:xs) = Hoge x1 x2 x3
じゃ駄目なのかな。

>>699
要素が少ないといいんですが、
20、30とあってHogeの変更もありうるので
できればfold等でできないかなと思いまして

data Hoge = Hoge [Int] にした方がましなんじゃないかそれとか思ったり。

>>701
ごもっとも
でもそれだとHogeの使い勝手が悪いので

>>702
Intの数が20とかになったときに使い勝手のよいアクセス方法はあるの？
Hoge [Int]だったら0,1,..,n番目の要素を取得したい場合
getElem n (Hoge xs) = head $ drop n xs
でいけるけど。

>>703
問題を単純化するためにIntにしたけど実際のコードでは
Gtkのウィジットを保持するdata GUIがあって、
Gladeで作ったxmlから連番で("button[0..n]"等)各ウィジットを読み込んで初期化
アクセスする時には個別なんでリストより一つ一つ名前が付いてる方が使い易いんです。

一括でどうにかしようって事なら
data Hoge = Hoge [(String, Int)]
でlookupしてアクセスするぐらいしかないんじゃないかと。

型定義のところだけ別ファイルにして、そのファイルを自動生成するプログラムを書き、makeチェーンに組み込むのはどう？
そういうのって、ほんとはLispとかが得意なんだと思うけど。

結局、リストを生成する段階で一つ一つ名前を与えるというオーソドックスな
方法に落ち着きました。
[button1, button2...] <- forM.. 元の動機がこれよりシンプルで保守性が
よい方法は無いものかと言うことでしたので

レスくれた方々、ありがとうございました。

haskell platform 2010はまた延期ですかね？

なんでgtk2hsはcabal化されないの？馬鹿なの死ぬの？

lhs2texで、日本語の通し方わかる人います？

UTF-8で統一しとけばちゃんと日本語通ってた

さっきのはなかったことにして下さい。

>>709
gtkのせいじゃないか？ついでにパッケージ名がgtk2hsじゃなくてgtkなのも気に入らん。どっちかに統一しろよ

Haskellやってみようと思うんだけど、書籍はいきなりＲＷＨでおけ？

プログラミングHaskellからの方が良い？

ちなみに、遊び程度だけどLispとOcamlは触れる。

ＣＧＩで掲示板作ろうと思ってるんだけど・・・

よろしこ

>>713
目的による。
RWHはcomprehensiveなtutorialなので、特に他の本を読むべきということはない。
しかしHaskellを深く理解するにはそれ以上の研究が必要になるであろう。

>>714

目的は

>>713
>ＣＧＩで掲示板作ろうと思ってるんだけど・・・

他にもSNSとかも作ろうと思ってる
あくまで趣味というか、息抜きレベル

700ページ読むのはきついけど、プログラミングHaskell読んでも
どうせＲＷＨ読まないとDBとの接続とか、セッション管理とか、
その辺のことが載ってないよっていうんなら最初からＲＷＨかな
と・・・　どう？

>>715
RWHを読むつもりなら、他の本は読まなくていい。

ただしRWHはHTTPやRDBそのものについて詳しく説明しているわけではなく、
数学を体系的に教えてくれる本でもない。だからネットを併用する必要がある。

>>716

ＴＨＸ

ついでに、やりたいことが>>715 くらいのことだったら、プログラミングHaskell
でも十分ってことはないですか？

200頁ってのは、こうし難い魅力でもある。

スレ汚しｽﾏｿ

ghc-6.10.4以降だとyi -t pangoが
yi: user errror (GConf: cannot get value of key, key is unser)とかでて起動しねぇ
gtk2hsのサンプルとかは一通り動くようになったんだけど
6.10.3までじゃないと難しいのかねぇ

>>717
プログラミングHaskell はあくまで言語の入門書で、
実用的なこと始めるには不足な印象。
でもまぁ、本の値段なんて大したことないんだから両方買えばいいんじゃね？

>>717
それどころか本を買う必要すらないかもしれない。
スキルがあれば、Wikibookと
http://en.wikibooks.org/wiki/Haskell
HaskellWikiだけでも何とかやれるんじゃないか？

英語読めるなら↓でいいじゃん
ttp://book.realworldhaskell.org/read/

>>721
まあそうだが、Real World Haskellは長すぎるという不満があったから、
簡潔なWikibookを紹介したんだよ。

AndroidでHaskell動いたら楽しいだろな

>>715
オレもちょっとGCIにチャレンジしているが（PHPでかくか迷っている…）、RWHは通しては読んでないよ。
データベースのところは参照したし、たいへん参考になった。
ただ、結局は、SQL文を文字列として生成して発行するわけで、インターフェースの基本さえ分かればそれ以上は必要なかった、という感じ。

むしろ、apachの設定とか、（実行するのがGHCがインストールされていない環境なら）ライブラリを静的リンクした実行ファイルを作るとかではまるんで、とにかく何でもいいからCGIとして実行的できるものを一つ作るのが先だと思う。

突飛な話だけどHaskell（とアセンブラ）でOS作ろうと思ったらできるのものなん？
それとも根本的に無理な話？

Yes, you can.

Haskellで書いてあるOSならHouseってのがある。

House: Haskell User's Operating System and Environment
http://programatica.cs.pdx.edu/House/

どう読んでもHUOSEなのに

Kleisli Triple <T,η,*>で言うところの自然変換η:I -> Tを
Haskellでunitではなくreturnという名前にしているのは、
do記法がより手続的に見える以上の理由があるの？

ない。
誰もが失敗したネーミングだと言ってる。

そもそも、「手続的に見える」よりもっと狭い。
C言語のように見える（見えなくもない）というだけの話。

ParsecのSourcePosは行と列を保持していますが
ソースの先頭からの絶対位置を取得する方法はないでしょうか？

ソースはファイルなので行と列を取得しておいて
行、列の分だけhGetLineとhGetCharを回す等を考えていますが
ベターな方法はないものかと思っています。

import Text.Parsec
import Text.Parsec.String

main = do
parseTest myp "abc\ndef"
parseTest myp' "abc\ndef"

myp = do
ret <- many $ holdLine $ oneOf "abc\nde"
eof
return ret

string' s = mapM (holdLine . char) s

myp' = do
ret <- string' "abc\nde"
eof
return ret

holdLine parser = do
pos <- getPosition
ret <- parser
setPosition $ flip incSourceColumn 1
$ setSourceLine pos $ sourceLine pos
return ret

あ、どうせ規制中だろうと思って適当に投稿ためしてみたら、解除されていた。
もし、Text.Parsec.Char の関数を使いたいなら、これでいちおうお望みのことはできると思います。
いまひとつスマートな感じがしないし、もっとスマートな方法がありそうな気がするけど。

Text.Parsec.Char の関数を使う気がないなら、もっとどうとでもやりようはあると思う。

>>732
ありがとうございます。
書き方が悪かったのかもしれません
「ソースの先頭からの絶対位置」というのは
パースが終ってから hSeek h AbsoluteSeek pos とできる位置のことです。

今、パーサをbinaryで書く方法とParsecで取得しておいたLine/Columnを辿って
絶対位置を割り出す方法のどちらがましか検討しています。

>>734
あ、hSeek だとバイトオフセットだから、>>732ではダメですね。
というか、エンコーディングのことを考えていませんでした。ごめん。

Real World Haskellの2刷り以降持ってる人、>>294の訂正は盛り込まれてる？

294に盛り込んである旨ちゃんと書いてありましたね。甘め、初版を掴ませおってw

>>736
立ち読みで軽く見ただけだが、
自分の指摘した一件が修正されてるのを確認した。

RWH 4.6.8右からの畳み込み

foldr step zero (x:xs) = step x (foldr step zero xs)
と記されているけれど、

foldr step zero (x:xs) = step (foldr step zero xs) x
と書くべきじゃないかしら。あまり意味ないか

次のページ見て自己解決した。本のままでいいわ

Foreign.Storable モジュールの Storable クラスについて質問です。

alignment 関数の戻り値として返す値は、C 言語の構造体で言うところの
４バイト アライメントや８バイト アライメントの「アライメント」の値ですか。

「本物のプログラマはHaskellを使う」で hsc2hs の使い方が簡単に紹介されていますが、
（http://itpro.nikkeibp.co.jp/article/COLUMN/20080805/312151/?ST=ittrend&P=3）
ここでは alignment = sizeOf と定義していますが、これは正しいのでしょうか。

>>741
http://haskell.org/ghc/docs/latest/html/libraries/base-4.2.0.0/Foreign-Storable.html#v:alignment

>４バイト アライメントや８バイト アライメントの「アライメント」の値ですか。
そう

>ここでは alignment = sizeOf と定義していますが、これは正しいのでしょうか。
Cのsizeof(T)の値はTのアラインメントの倍数になる
(そうでなければ、Tの配列を作ったとき、全ての要素のアラインメント要求を満たすことができない)
だから、alignment = sizeOfは(厳しすぎる可能性があるものの)正しい

>>742
ということは、アライメントがはっきり分かっている場合はその値を、
分からなければとりあえず sizeOf を返しておけば問題は無いということですね。

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

Haskellスレで聞くことじゃないかもしれないんだけど、
関数型言語のエッセンスを手っ取り早く学ぶのに良い言語って何だろう。
とりあえず、Java使いなのでScalaに傾き中なんだけど。

>>744
何事もまずは手を動かすことが大事だから、自分が入りやすいと思う言語、気になった実装系でよいと思う。
ただ、まぁ、ひとつあげろと言われるとHaskellだな、真面目な話。

理論的な話は置いておいて、プログラマとして実践的な面からの関数型言語のエッセンスは、高階関数の多用だと思う。
高階関数を多用するためには、無名の関数、有名の関数の両方が非常に簡潔にかけることが望ましい。
で、Haskell以上にそれが簡潔な言語をオレは知らん(Lazy Kを除いて)。

>>744
上にほぼ同意だが、余裕があればHaskellに加えてLISPもやるといい。
特に、Schemeインタプリタを自力で実装するといい。
しかし関数型言語ということであればHaskellだろう。Expand your brainといわれている。

>>745
個人的にはカリー化が簡単にできるのもポイント高い。
add x y = x + yとかあるのをカリー化したいときに
(add 3) で簡単に作れるのがいい。
schemeとかlispだと
(define (add3 x) (add 3 x))ってやらないといけない。

関数型言語としての特徴を学ぶなら、やっぱHaskellだと思うなあ。
こういった場合、中途半端はよくない。純粋関数型言語を選択して欲しい

私は Scheme や F# から関数型を知って色々勉強してましたが、
書籍「関数プログラミング」を読んでから
純粋関数型である Haskell の魅力にとりつかれました。
この本に関数型言語のエッセンスが凝縮されています。

この本 + Haskell がまさに「手っ取り早い」と思います。
（ただし、この本に Haskell の使い方は載っていない）

>>749
検索したら複数出てきましたがどれでしょうか？

俺はbirdの書いたのに一票

>>750
おっと、そいつはすまなかったな
これです。
http://www.amazon.co.jp/dp/4764901811

原書はHaskell版が出てるんだっけ？

ありがとう、Haskellを前向きに検討してみる。
ちなみに、外に出かけたので>>752を探してみたけど、今は入手困難みたい(´・ω・`)

>>754
中古ではダメなのか

>>755
それしかなさそうだね。
ただ、実は友達と勉強会やろうかって話をしてて、教科書にするには厳しそうだなと。

『プログラミングHaskell』　残り２章ってところまで写経してきて気が付いた
んだけど、この本難しい方？

ちなみにHaskellの本は初めて読んでます。

悟れるまで黙って繰り返し写経しててください。

なんで写経なの？頭で考えたら？

自分で考えることは賛成だが
そのための準備は必要

モナドの定義で何をやっているのかぜんぜん分からなかった
調べてみたら、論文に載るような難しい概念だということが分かった
それからは、中身は特に考えずにそういうもんだと思い込んで使っている

>>759

え？　写経って、本読んで考えながら、手も動かしてみることを
言うんじゃないの？

ちなみに、ＲＷＨの方が簡単？

>>762
写経＝コピー
理解できなくても、考えなくても、文字が読めて書ければ写経できる。

RWH は応用だから対象読者が違う。

>>761
たぶん、「そういうもんだ」と思い込んでいる、その「そういうもんだ」と理解していることが、理解すべきことの全てだと思う。
Monad クラスは形式的な枠組みを規定しているだけで、それ以上に意味も中身もない。

イルカとサメが似ているようなもん。外見が似ている、それだけ。

モナド則によってある程度意味を与えられていると思うが。

それも含めて形式的な枠組みに過ぎないという事なのか

>>763

>写経＝コピー
>理解できなくても、考えなくても、文字が読めて書ければ写経できる。

写経って言葉を少し間違って使っていたようです　ｽﾏﾝｺ

>RWH は応用だから対象読者が違う

応用≒実践ってことかな？

それだったら、ＲＷＨの方が目的にあってるような気がする・・・

>>761
モナドそのものについては圏論の初歩で理解できるよ。
対象、射、(共変)函手、自然変換の4つの概念くらいしか必要ないし。
あと「図式が可換」っていう意味が分かればモナドが弄れる。

けど、どうしてこんなにHaskellで利用されているのかをつかむには不十分みたいなんだよね。
頭で理解するより慣れた方が多分近道。
あと、おそらくHaskellプログラマかつ非数学者のためのpdfがあるけど、案外不評。
ttp://lambda-the-ultimate.org/node/1183
証明に可換図式を使わないとこんなに面倒なのか、って思う。

>>766
そういうこと。
５章から JSON ライブラリを作ってみたり、
バーコードリーダーを作ってみたりといった実践が始まる。
その中でテクニックを学んでいく。

とりあえず RWH を読んでみて、
説明を端折ってるなって思える部分に出会ったら、
他の文献を当たるなりすれば良いと思う。

>>768

ＴＨＸ

>>765
じゃぁ、言い直そう:

イルカとサメが似ているようなもん。海を泳ぐ、それだけ。

「中身は特に考えずにそういうもんだと思い込んで使っている」
その先を目指して理解できると、きっと「より面白い」と感じると思うんだがなぁ

イルカとサメがどーたらこーたらで止まってしまうのが、
ちょっとだけもったいない気がする

>>762
RWH、と言うかオラ本は全般に説明がくどいね。変な例えとかジョークで厚みが増しトル。読み物的。
それがイイって人も多いのかもしれないが。

ついでに池袋ジュンク覗いてきたけど初版がまだ店頭に並んでた

尼はまだ初版かな？＜ＲＷＨ

>>771
まだ読んでないけど、この論文とかが圏論の言葉少なめ、
計算機科学の言葉多めで面白いかもね。
ttp://www.disi.unige.it/person/MoggiE/ftp/lics89.pdf

もったいないかもしれないが、圏論の言葉をhaskellに翻訳すると、
対象 = Haskellのすべての型(IntとかMaybe Stringとか)
射 = Haskellでの関数::a -> b
函手　= newtype,dataで作られる型Tのコンストラクタ::a -> T a
自然変換 = t1 a -> t2 aという関数
Kleisli Triple = 型T, return::a ->T a, =<<:: (a -> Tb) -> T a -> T b

この後、どう面白くなるのかがまだ分からん。

>>766
>>写経＝コピー
>>理解できなくても、考えなくても、文字が読めて書ければ写経できる。
>
>写経って言葉を少し間違って使っていたようです　ｽﾏﾝｺ

あってるだろ
本物の写経も
考えずにコピーするだけの写経もあれば
意味を考えながらの写経もある

いままで数学とかまるで興味なかったけど挑戦してみようかと思ってます

Haskellでサーバアプリ作れるくらいのレベルだけど、圏論すぐに理解できますかね？
Haskellが得意な人向けの圏論の入門書とかサイトとかないでしょうか

クマーの予感

ググレカスという言葉を贈ろう

>>776
サーバアプリと圏論は全く関係ない。
F1 ドライバーだけどチャーハン上手く作れますかね、という質問といっしょ。

Haskell が得意な人向けの圏論の入門書やサイトもおそらく無い。
Haskell が得意であることと圏論が分かることもほとんど無関係だから。

「Conceptual Mathematics : A first introduction to categories」
この本の第２版（赤い本）でも読んで、まずは圏論の雰囲気でも掴むと良い。
各階段の段差が低いから、日本語で書かれた圏論関係の本よりよほど読みやすいと思う。

>>776
http://www.amazon.co.jp/dp/4627018304
見た感じとしては易しそうな感じだった。読んではない。

http://ci.nii.ac.jp/naid/110003743564

これも
http://ci.nii.ac.jp/naid/110003743465

どうみても、役には立たないな。
理論とは適当に折り合いをつけてプログラムしろぐらいの意味しかないだろ。

これじゃだめ？
http://coolee.at.infoseek.co.jp/kenron.html#-1

こんなんもあった。いろいろ書いてくれてる人がいるね。正しいかどうか見てないけどw
ttp://d.hatena.ne.jp/m-hiyama/20060821/1156120185

Most programming language researcher do not work for helping people but for their research interests.

興味なしに調べてもロクな文書は公開できないのでそれでもいいのです

Don't ask people for resources which might help you. Search for your own.

An introductory book to category theory.
http://www.amazon.com/Categories-Computer-Science-Cambridge-Texts/dp/0521422264

圏論は実際に作れる簡単な例題がないのかな
C言語が得意な人向けの線形代数とかの入門書はたくさんあるんだけど

Exercises? There are.

圏論って既に数学のいろんなところで使われてるから、
数学を嗜んでいる人なら意識せずに普段から使ってるよ。

高校の数学の先生になった友達と勉強会を開いたんだけど、
彼がホワイトボードになにやら図やら式やらを書き始めたのを見て、
あれ？君、圏論をどこで勉強したの？
って聞いたら、圏論？はい？
って答えが返ってきた。
それぐらい世の中に浸透してる。

Haskellもすっかり過去の言語となってしまったなあ

The more people use Haskell, the less advanced Haskell will become. Stop using Haskell immediately.

>>794

なんで？

>>795

Which language you recommend instead of Haskell?

やっべ俺Haskellて関数型言語の中ではモダンな方だと思ってた
知ったかぶりするには何を押さえておけばいいの？

Haskellはあらゆるプログラミング言語研究の最先端の成果を
常に詰め込みつづけるために作られた言語なわけだから、
開発が止まらない限り最もモダンな言語の一つなわけだけどｗ

全く普及の兆しをみせないHaskell

>>797
Try Scala or Clojure. Scala is seemed to be probable, but I like Clojure better.

>>798
Haskell is 20 years old.
If you are an early adopter, go to Go.
If you want something unpopular, say Cat.

この外人さんは誰

俺でもよめるやさしい英語

>>799
言語のコアは変えられない。できるのは拡張だけ。
まあ意味論が数学に基づいているから一般的なプログラミング言語としては限界だろうけど

Shiroさん

>>804
限界があるならそこで開発は終わるだろ。
後はメンテだけします、って事になって終了。

>>806
純関数言語としての根幹は変えられなくても、拡張の余地はある。
もっと手続的なほうが使いやすいかもしれないが、並列化のトレンドを考えれば抽象度が高いほうがいいだろう。
ゆえにHaskellが勝利する。

どうでもいいが、英語にミスが散見されるな。
書いたのは俺だが

純粋タイプで元気（まとも）なのはHaskellだけ？
ttp://ja.wikipedia.org/wiki/%E9%96%A2%E6%95%B0%E5%9E%8B%E8%A8%80%E8%AA%9E

一般的な人が終了しても、数学的な連中は続けるから。
日常的なことは他の言語を使ってればいい。

>>809
Haskellはそもそもその始まりが純粋関数型のフラッグシップ。
それまで乱立していた関数型言語の人をみんなHaskellに結集させたんだから当然。

>>810
Haskellやってるのは数学系の人じゃないんだけどね。
コンピュータサイエンスの人。

>>811
いや、ここに挙がってる他のは古いか細ってるかみたいだったから、
ほかに新しいのいないのかなと思って。

>>813
新しいのを作るのが意味ないからね。少なくとも研究目的では。
純粋かつ非正格評価という制約がある限り、先行するHaskellの劣化コピーにしかならない。
みんなHaskellに移ってしまったから、MirandaもCleanもリソースがない。
だからますますHaskellに集まる。
このポジティブフィードバック。

>>811
たしか、それぞれ独自に研究してた人たちが究極のを作ろうと集結したんだっけ。

この頃の話とか、Haskell に魅了された研究者たちの話って書籍化されてないのかな。
インタビューとか交えたノンフィクションがあれば是非読んでみたい。

純粋かつ正格な言語はまだですか

>>816
Clean

>>814
正格には、MirandaやCleanから人が移って減ったわけではない。
他の純粋な人たちがみんなでHaskellを作っただけ。

>>814
レスどうもです。そうでしたか。
今はどうやって関数型の利用を進めるかを考える時期なんでしょうかね

既存理論を関数型言語で取り扱えるように整理し直せばいい。
計算機理論の体系をフレームに他分野の理論を読み替えて、
具体的解を取得できる形式系を作ればいい。

Haskellで蓄積された型理論の研究成果はセキュアなシステムの構築に役立つことが期待されている。
Haskellの型システムに対する拡張の研究はこれからも続くだろう。

ttp://cacm.acm.org/magazines/2010/2/69367-type-theory-comes-of-age/fulltext

数学の厳密な意味論に基づいて現実世界をモデル化すれば、
主観と客観がないまぜになった実学を洗練することができそうだな

>>808

おめーかよｗ

おれは>>797だけど、厳密に言うとdoが抜けてるな

ちなみにScalaやClozureはJavaのランタイムに明るくないと
あんまり恩恵受けないってことはないの？

恩恵というのが何を意味するのかわからないが、
確かにプログラミング言語を仕事で使うにはランタイムの知識も必要だといわれている。
しかしGHCも遅延評価のおかげでとても不可解だ。サーバでは使えないだろう。

ところでScalaもClojureも末尾最適化をしないらしい。
再帰ではなくイテレーティブに書かなければいけない。
関数型言語と称するには無理があるんじゃないか。

遅延評価は慣れの問題じゃないの。

遅延評価をデフォにしちまうとどうしても余計な処理が入るから遅くなっちゃうね。

慣れというかたぶんバグった時の解析がキツい

みなさんはロギングをしたいときどうしてますか？
すべての関数をIO型にするしかない？

遅延評価はそのままでいいけど、グラフ簡約の様子をそのままグラフ化してプリントアウトしてくれるツールが欲しい

>>828
なぜ Writer を使わない？
そういう意味ではないの？

>>830
書き方が悪かった。
論点は，「ロギングを素直に挿入すると、関数の型を変えざるを得ないが、もっと良いやり方はないか？」
ということです。

>>831
unsafeio

>>831
デバッグのときとかに、関数の評価の様子を知りたいだけなら、traceを入れてghciで実行。

アプリケーションの機能としてログ出力を行いたいのなら、純粋な関数は引数が変わらないかぎりなんど実行しても動作が同じでそのログをとる必要はなく、
実行ごとに引数が変わるのは外部と関係するときだけだから、かならずIOモナドでログをとれるタイミングがあると思うんだけど？
モナド上で行わない限り、出力するタイミングを制御できないわけだし(評価順序をあれこれ考えればできなくもないけど)。

>>815
最初期の人ではないが、RWHを書いたサリバンへのインタビューがネットで読める。
http://broadcast.oreilly.com/2009/01/the-power-of-haskell.html

遅延評価は正格評価と比べて必ずしも遅いわけではない。
速い場合もあるし遅い場合もある。
値がサンクとして渡されるので、全体として時間コストも空間コストも予測が難しい。
GHCが遅いのは最適化よりも新規性目的で機能が取り込まれているせいもある。

そういや、速いという話だったGRINの話題がちょっと前に出てなかったっけ？

>>834
ありがと

ついでに、自分でも調べたら
「A History of Haskell: Being Lazy With Class」なる論文を見つけた。
http://research.microsoft.com/en-us/um/people/simonpj/papers/history-of-haskell/

面白そうなんで併せて読んでみる。

Cabalがエラりまくる
なんだよこれ３パッケージに１つはエラーでビルド失敗するわ

Cabalはパッケージマネージャではないから仕方ない

じゃあどうすれば仕方あるんですか！？

パッケージマネージャーを作る

怒らないでマジレスしてほしいんだけど
おまえら、なんでこんな時間に書き込みできるわけ？
普通の人なら学校や会社があるはずなんだけど
このことを知った親は悲しむぞ？
もっと、現実を見ようぜ。

今日日曜日だぞ

週末と平日の区別すらないのか。
普通の人ならそんな質問をしないはずなんだけど。
もっと現実を見ようぜ。

お仕事お疲れ様でし。

マジレスするとそれはコピペなのでスルーしとけ

Cabalが依存パッケージのビルドに失敗する
個別にインストールすれば成功するのに
なぜだろう

マジレスすると >>846 もコピペなのでスルーしとけ

駄目だiconvがインスコできね
死ねCabal

>>849
では　Cabal はもう死んだと思って、別の手段を使えばいいのではないか

諸君らが愛してくれたCabalは死んだ。何故だ！

>>851
研究のためのモルモットに過ぎなかったから

>>790
エピかつモニックだがアイソではない射がhaskellにあるか否か、とか。
答えは知らんが、圏論とhaskell以外の知識はいらない問題。
あと、圏論だけだけど、モナド<T,η,μ>からKleisli Triple<T,η,*>を導き、
Kleisli Tripleが満たす法則を証明し、
逆にモナド則をKleisli Tripleから導くとか。

普通のハスケルがくどすぎて嫌
lispはすでに習得しているレベルの人向けな本はないですか

>>854
・Haskell: The Craft of Functional Programming
・Algorithms A Functional Programming Approach
・The Haskell School of Expression
辺り

普通のハスケルは読んだこと無いから「くどさ」がよく分からんが、
もしかしたら一番上のもちょっとくどいかも知れん。

もう少し分かるなら、
・the fun of programming
も良い

>>854

RWHはダメなの？

分かるところは飛ばせばいいんだし

↓これの後半3ページをもーちょっと優しく解説してる記事か本を知りたいです
http://www.ipsj.or.jp/07editj/promenade/4703.pdf

>>857
余計なおしゃべりのないそれが一番いいと思うんだけどな
イメージが湧かないというのなら
http://blog.sigfpe.com/2006/08/you-could-have-invented-monads-and.html

>>857の記事を理解したくて緑色の本で圏論齧ってみたけどF-AlgとAdjointあたりでイミフになって挫折したことを思い出したわ

>>857
図式が可換、っていうのは
「その図中で、ある地点からある地点への経路をどのように取っても
　(どういう射の合成を使っても)等しい」という意味なので、
例えば自然変換η:Ix->Tの自然性を示す可換図式は
       ηA
 IxA ---> TA
 f|             |Tf
  V   ηB  V
 IxB ---> TB
こいつは、以下の式と同じ意味
Ixf○ηB= ηA○Tf (fはA->Bの全ての射,Ixは恒等函手,Tは函手)
ドメイン、コドメインなんて図で考えてれば間違えることは無いので、
積極的に図式を使うといい。

unsafePerformIOを使ってIO comonadを作るような論文があったと思うんですが思い出せません
心当りがある方がいらっしゃれば教えてください

> FUNDIO: A Lambda-Calculus With letrec,case, Constructors,
> and an IO-Interface:Approaching a Theory of unsafePerformIO

辺り?

ありゃ? 切れたね。

> FUNDIO: A Lambda-Calculus With letrec, case, Constructors,
> and an IO-Interface:Approaching a Theory of unsafePerformIO

辺り?