993コメント338KB

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

レス数が950を超えています。1000を超えると書き込みができなくなります。

0001デフォルトの名無しさん

2009/01/14(水) 00:51:13

0002デフォルトの名無しさん

2009/01/14(水) 00:51:48

関連書籍
・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

0003デフォルトの名無しさん

2009/01/14(水) 00:52:14

関連スレ
・関数型言語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 5
　http://pc11.2ch.net/test/read.cgi/tech/1186292994/
・Lisp Scheme Part25
　http://pc11.2ch.net/test/read.cgi/tech/1231856193/
・【入門】CommonLispその4【質問よろず】 --DAT落ち、次スレなし
　http://pc11.2ch.net/test/read.cgi/tech/1201402366/
・Emacs Lisp 3
　http://pc11.2ch.net/test/read.cgi/tech/1191875993/

0004デフォルトの名無しさん

2009/01/14(水) 00:52:45

・日本語の扱いについて

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のような例外を除くと、単純にリテラルを使うことはできない。

2. GHC6.6
ソースコードにはUTF-8、入出力にはLatin-1を仮定する。このため、EUC-JPでリテラルを直に
書くことはできない。

(続く)

0005デフォルトの名無しさん

2009/01/14(水) 00:53:10

(続き)

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)が正しく動作しない。

0006デフォルトの名無しさん

2009/01/14(水) 00:53:44

　　　　　　　／/
　　　　　／　 /　　　ﾊﾟｶｯ
　　　　 //⌒)∩＿＿∩
　　　　/.|　.| ノ　　　　　ヽ
　　　 /　|　| 　●　　　● | 　　　　
　　　/ 　|　彡　　( _●_)　ミ　まピョーん☆
　　 /　　|　ヽ　　|∪|　　/＿
　　/／　│　　　ヽノ　　＼／
　　"￣￣￣￣￣￣￣（..ノ

0007デフォルトの名無しさん

2009/01/14(水) 00:54:06

前スレ11 ：デフォルトの名無しさん：2008/05/17(土) 20:00:31
そろそろ、テンプレの 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 のコメントに書いてある)
よろしくたのむ、な。

0008デフォルトの名無しさん

2009/01/14(水) 00:56:06

テンプレここまで。
関連書籍に二冊追加。
Unicodeの入出力について、誰かまとめてくれるとうれしい。

0009デフォルトの名無しさん

2009/01/15(木) 18:24:13

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

0010デフォルトの名無しさん

2009/01/17(土) 15:11:50

今Emacs使ってHaskellやってますが、引数の型とかに合わせた候補リストみたいなの
出す機能があるエディタってありますでしょうか。

0011デフォルトの名無しさん

2009/01/17(土) 15:40:04

>>10
emacsでも出来た気がするけどね。
なんていうモードだったか忘れたけど。

viでもjeditでも出来るよ。
jeditはわりと惜しいエディタでもある。java製だし、プラグインのAPIは洗練されてないし、不安定だし、という理由で。

0012デフォルトの名無しさん

2009/01/17(土) 17:21:47

>>11
emacsのhaskell-modeは使ってますけど、型から候補を出したり補完したり
するのは知りませんでした。

0013デフォルトの名無しさん

2009/01/17(土) 17:42:09

viで出来るってのも初耳なんだが、どうやるの？

0014デフォルトの名無しさん

2009/01/17(土) 21:43:26

vim にはプラグインがあったような。詳細は覚えてないけど、ググればすぐ見つかるはず。

0015デフォルトの名無しさん

2009/01/17(土) 23:30:53

haskell for vim のことを言ってるのであれば
そんな高度なことは出来なかった気が

0016sage

2009/01/19(月) 12:26:27

>>11
最新の haskell-mode for Emacs には hoogle と hayoo 用のインターフェースがついてる。
ネット経由で、型から関数の一覧をとってこれる。今、試したら hayoo はお休み中みたいだが。
ここ参照な。

Haskell mode for Emacs - HaskellWiki
http://www.haskell.org/haskellwiki/Haskell_mode_for_Emacs

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

hayoo
http://holumbus.fh-wedel.de/hayoo/hayoo.html

0017デフォルトの名無しさん

2009/01/28(水) 12:38:00

初心者質問ですが、derivingというのは特定classのみ許される仕様なんでしょうか。

自分でderivableにする方法ってありますか？

0018デフォルトの名無しさん

2009/01/28(水) 20:36:35

Haskell98にはない
GHC拡張に似たようなものがある
http://www.haskell.org/ghc/docs/latest/html/users_guide/generic-classes.html

001917

2009/01/28(水) 22:35:28

>>18
ありがとうございます。拡張なんですねぇ。頑張って理解してみます。

Javaなどの言語をやってきたんですけど、同じ関数名で引数の型が
相違するようなのを簡単に作れないのかなぁ、と思ったのです。組み込み
のclass(Eqなど)で通常は十分、ということなんでしょうかね。

0020デフォルトの名無しさん

2009/01/29(木) 00:00:02

>同じ関数名で引数の型が相違するようなのを簡単に
Javaのどういうコードが念頭にあるのか分からんけど、
もし実装の継承がしたいということなら>>18は大して訳に立たないと思う
手でインスタンス宣言を書くしかないんじゃないか

0021デフォルトの名無しさん

2009/01/29(木) 00:47:19

単にオーバーロードのことを言ってるように思えるのだが
どっちにしてもderiving関係なくね

002217

2009/01/29(木) 20:03:34

すみません、ちょっと曖昧でした。オーバーロードではなくて、
多相な関数を定義する簡易的な方法についての質問です。

>>18というのは、Lispのマクロ的なものなんでしょうか。

0023デフォルトの名無しさん

2009/01/29(木) 22:04:42

本当にderivingが使える型クラスを作りたいなら>>18でいい(ただしできることは限られる)んだけど、
>>19や「多相な関数を定義する簡易的な方法」を聞くと違うような気がする
(Javaにはderivingに相当する機能はないよな？)
なにか具体例を見せてくれれば分かると思うが

derivingの意味を誤解してるかもしれないので念のためまとめると、
・Haskellの型クラスはインタフェースを表現する(Javaのinterfaceみたいに)
・ある型クラスの規定するインタフェースについて、個々の型における具体的な実装を書くのがインスタンス宣言
・定型的なインスタンス宣言を自動生成する機構がderiving

>>18のは、自分で定義したクラスに対してこの自動生成を可能にする方法の一つ
構文的にはderivingというキーワードを使わないけど、やってることは同じ

0024デフォルトの名無しさん

2009/01/29(木) 23:07:40

存在型(forall)のことかな？

0025デフォルトの名無しさん

2009/01/30(金) 07:46:36

>>22
多相な関数って、例えばこんな関数？

id :: * -> *
id x = x

002617

2009/01/30(金) 11:24:58

>>23
ありがとうございます。どうもJavaのイメージとごっちゃになってる
部分があって、勘違いしてるような気がしてきましたw

型ごとに振る舞いが違う関数であれば、個別にinstanceしなければ
ならないでしょうし、そうでなければ>>25のような形になるわけですね。

002717

2009/01/31(土) 12:06:49

もう一つclass関連での疑問なのですが、そもそも、オーバーロードが必要な場合
には逐一class宣言とinstance宣言が必要だ、というのは何か必然性があるんで
しょうか。class書いてもいいけど、書かなくても裏で同様のつじつま合わせをして
くれてもいいように思えるのですが。

0028デフォルトの名無しさん

2009/01/31(土) 14:01:03

>>27
つじつまあわせなんてしたら型推論なんてできなくなる。

型推論は、関数のこの引数はこの型じゃなければならないから･･･
みたいなことを繰り返して型を確定していくのに、
すべての関数がオーバーロードされているかもしれないんじゃ、
型を確定させることができない。

そもそもJavaなどで簡単にオーバーロードができるのは、
引数として渡される値の型が簡単に分かるから。
引数として渡される値の型と、オーバーロードされている関数の型を比較すれば
実際に呼び出すべき関数が簡単に分かる。
しかし、型推論のある言語では、型が簡単には分からないので、
class,instance宣言必須という制限をつけて範囲を限定している。

0029デフォルトの名無しさん

2009/01/31(土) 14:26:12

Java的な意味でオーバーロードがしたい場合は単に違う関数名を付けるのが普通
Haskellの型クラスは実行時多態を行うためにある

用語がややこしいけど、
Haskellでいうオーバーロード(クラスを使う) <=> Javaでいうポリモーフィズム
Javaのオーバーロードに対応する機能はない

003017

2009/01/31(土) 14:37:11

>>28
> つじつまあわせなんてしたら型推論なんてできなくなる。

ああ、そうでした。型推論の問題なんですね。納得です。

>>29
> Java的な意味でオーバーロードがしたい場合は単に違う関数名を付けるのが普通

やはりそうなんですね。自分はコード書く際に名前付けるのが一番悩んでしまう
ので、その辺がスッキリならんのかなぁと思ったのですが。そこは仕方ないんですね。

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

0031デフォルトの名無しさん

2009/02/05(木) 02:48:48

日本人待望のGHC用Unicode入出力のパッチが来てるな
テスト希望、議論希望、それからWindowsで動かせるようにしてくれたら嬉しいだとさ
ttp://www.haskell.org/pipermail/libraries/2009-February/011255.html

0032デフォルトの名無しさん

2009/02/05(木) 18:20:14

utf8-string てのが前からあったでしょ？なんか変わったの？

0033デフォルトの名無しさん

2009/02/05(木) 18:57:29

普通のStringを普通にputStrして普通に文字が出る
外部コードもUTF-8固定じゃなくて選べるし、デフォルトでロケールに合わせてくれる

0034デフォルトの名無しさん

2009/02/07(土) 20:44:03

各種schemeインタプリタのようなaproposはghciにもありますか？
これがあるとシンボルの入力補完のシステムとかが楽に組めて便利なんですが

0035デフォルトの名無しさん

2009/02/07(土) 21:09:03

ghciのUIにはないと思う
ghciに補完機能がある以上内部では持ってるはずだから、
やりたいことによってはGHC APIが役に立つかも

0036デフォルトの名無しさん

2009/02/09(月) 20:19:27

ちょっと前に2chで関数型ユーザーを叩いてみたのだけど、
やっぱり関数型の内実は80%ほどが幻想だな、という感想を持った。
Lisp,Schemeのユーザーはすぐ折れたがHaskellのユーザーは頑固だった。
まあ純粋で美しいから信者になってしまったのだろうけど、
純粋な美しさでHaskellに勝てるものはいないだろうと思う。
しかし自然言語を目指さず数学的な記述を目指したところでいいプログラムは書けない。
数学は定理を証明するための言語で、プログラミングは定理の証明ではない。
証明出来るならプログラムなんか書く必要ないしな。

0037デフォルトの名無しさん

2009/02/09(月) 20:28:06

curry howard correspondence

0038デフォルトの名無しさん

2009/02/09(月) 20:29:09

あぁ、あとこのスレは過疎もいいところだから関数型言語叩くならhaskell-cafeにおいで

0039デフォルトの名無しさん

2009/02/09(月) 20:46:24

このスレは過疎な訳じゃなくて話題がないだけだろ
見てる奴は多いだろうからいいネタがあれば盛り上がると思うぜ

0040デフォルトの名無しさん

2009/02/09(月) 20:52:12

そういやCleanって最近話題聞かないな

0041デフォルトの名無しさん

2009/02/09(月) 22:40:16

>>36
Haskellユーザーとは痛み分けだったろ。それにSchemeのほうも一年以上
かかってたじゃねぇか。

0042デフォルトの名無しさん

2009/02/09(月) 22:41:35

Haskellの強みを論理的に教えてください。

0043デフォルトの名無しさん

2009/02/09(月) 23:15:21

あなたにとっての「強い」を論理的に説明してください

0044デフォルトの名無しさん

2009/02/09(月) 23:17:24

>>43
あなたはもう発言しなくてよろしい

次の方どうぞ

0045デフォルトの名無しさん

2009/02/09(月) 23:26:37

>>42
チューリング完全なら、ぜんぶ同じでは？

0046デフォルトの名無しさん

2009/02/09(月) 23:27:20

瞬殺された>>42が朝まで暴れるとみた

0047デフォルトの名無しさん

2009/02/09(月) 23:28:39

>>36は勝利宣言だけかいｗ

0048デフォルトの名無しさん

2009/02/09(月) 23:30:41

難しい話じゃなし、疑問があるなら勉強すればいいんだよ
絡みたいだけの奴はやっぱスレに張り付いてんだなあ

0049デフォルトの名無しさん

2009/02/09(月) 23:34:37

>>48
言わせてもらいますが、
Haskellの強みをはっきり書いた論文も書籍もありませんよ。

0050デフォルトの名無しさん

2009/02/09(月) 23:36:40

関数型言語はなぜあなたのコンプレックスを刺激するのか論理的に説明してください

0051デフォルトの名無しさん

2009/02/09(月) 23:39:39

モナドのすべてにでてくる各種モナドがイミフだったから
あれらの定義を仕様を表す論理式から導き出せるようになりたい
使ってるうちに解るとは到底思えないぐらいイミフ

0052デフォルトの名無しさん

2009/02/09(月) 23:41:39

IOモナドが意味不明だったので、Lispも糞だと結論付けました

0053デフォルトの名無しさん

2009/02/09(月) 23:44:38

攻撃的な発言は発言した内容が自分自身にそのまま当てはまると内心で思っている証拠だということに最近気づいたところなんだよ。

0054デフォルトの名無しさん

2009/02/09(月) 23:49:37

だから相手を攻撃するということは自分自身の弱さを曝け出すことにもなるんだよ。

0055デフォルトの名無しさん

2009/02/09(月) 23:54:31

こういう話題になると
今までみんなどこに居たんだと思うぐらいレスが付くなあ

0056デフォルトの名無しさん

2009/02/10(火) 00:12:59

>>45
全然話の流れと関係ないとこで気になったんだが
チューリング完全なら全部一緒という論調ってどこか違和感がある

CのプリプロセッサとCはどちらもチューリング完全性だと思うが
単純に構文糖衣という意味以上に、能力的にはCのほうが高いと思う。
スケーラビリティの点で。
Cで関数引数nに、簡単に大きな引数を指定出来るのに対し
プリプロセッサで同じことをやろうとすると、
大きな引数nの値と同じ数だけ自分でデータを作る必要が
あったように思う

そういう意味でプログラム自身をデータと見なせるLispは
かなりスケーラビリティ的な意味で能力が高いと思うわ
しかし、プログラム自身をデータと見なせるだけでは
まだスケーラブルにならない世界もあるんじゃ無かろうか
うまく説明できんが、
自然数→整数→実数→複素数の進歩のように

0057デフォルトの名無しさん

2009/02/10(火) 01:12:25

どうでもいいところに突っこむが、Cプリプロセッサのための任意長整数ライブラリは存在するよ
http://sf.net/projects/chaos-pp/
とか

0058デフォルトの名無しさん

2009/02/10(火) 01:36:36

>>36
Haskellユーザーよりも、Lisp,Schemeの方が、バカの扱いに慣れているって事が分かりました。

0059デフォルトの名無しさん

2009/02/10(火) 14:26:27

自然言語を目指すとか10年古い釣りワードが入ってるし

0060デフォルトの名無しさん

2009/02/10(火) 14:54:02

10年どころか、30年古いぞｗ

0061デフォルトの名無しさん

2009/02/11(水) 01:18:09

ネタかと思ったら、本気だったのか。
ttp://d.hatena.ne.jp/haruyutaka/20090208/p3

0062デフォルトの名無しさん

2009/02/11(水) 01:27:05

>>61
この子大学生かな。
知らないことも多そうだし、覚えたての言葉を使いたくて仕方が無いようにみえる。
もう少し論文とか読めばどんな研究している人がいるのかもわかってくるだろうし、
今からあんまり頭固くしてほしくないなぁ。

0063デフォルトの名無しさん

2009/02/11(水) 01:34:10

2chで煽って騒いだってしょうがねーだろ。
本気で相手してくれるやつなんていないのわからないのかなぁ。
ここのやつらも本気で相手にしてるのは論文の方だと思うし、2chは遊びと割り切ってるはず。

関数型言語が今後どういう風に発展していくのかという展望がまだ掴めていないなら、
まずは論文をたくさん読めば良いと思うよ。
言いたいことがあるなら論文で書いてくれ。

とマジレス

0064デフォルトの名無しさん

2009/02/11(水) 02:19:51

論文読むより実用的アプリを書くほうが実際ためになると思うが。

0065デフォルトの名無しさん

2009/02/11(水) 02:27:51

>>64
もちろん手を動かしてプログラミングしてみないとわからないこともある。
論文を読むのは、自分が気づかなかった別の価値観を発見することでもあり、
ほかの人がどういうことに興味を持っていて
どうすればその人たちの助けになるのか知るためでもあるんだよ。

0066デフォルトの名無しさん

2009/02/11(水) 02:32:06

こういうことを書くとブログや掲示板でも良いじゃないか、と思うかもしれないが、
ブログや掲示板は雑音に埋もれてしまうのが常だから、
言いたいことがあるなら是非とも論文で書いてくれ。

0067デフォルトの名無しさん

2009/02/11(水) 08:35:48

>>61
多分LINQあたりで「やべ、C#って最強言語じゃね？」ってなって、一気に信者化したんだろうな。
かわいいねぇ。

0068デフォルトの名無しさん

2009/02/11(水) 09:30:55

馬鹿の壁

0069デフォルトの名無しさん

2009/02/11(水) 10:44:28

自分は一般プログラマなんですけど、実際のところ研究者たちの実験的ツール
としてのHaskell、ではなくて実用アプリへの具体的な一歩を目指そう、という
動きはありますか？

例えば、RubyはRailsで目立ったわけですけど、似たようなキラーフレームワーク
のようなものが開発中とか、企業で予算をつけてやってるとか、そういう動きはあるん
でしょうか。

Haskellの本を色々見てると実に楽しいんですが、やっぱりHaskellerの大半は
研究として興味あるのであって、実用アプリについてはあまり興味ないのかな
とも感じます。

0070デフォルトの名無しさん

2009/02/11(水) 11:23:36

そんなあなたにRealWorldHaskell

0071デフォルトの名無しさん

2009/02/11(水) 11:45:01

>>69
> 自分は一般プログラマなんですけど、実際のところ研究者たちの実験的ツール
> としてのHaskell、ではなくて実用アプリへの具体的な一歩を目指そう、という
> 動きはありますか？
それが研究なんだけどｗ

0072デフォルトの名無しさん

2009/02/11(水) 12:04:09

>>61の奴はpmokyの別blogな。
pmokyはやねう企画の内部告発して2chに勝利宣言してたキチガイ。
http://d.hatena.ne.jp/pmoky/20060510
http://d.hatena.ne.jp/pmoky/20060526/p8

007369

2009/02/11(水) 12:28:31

>>70
そうなんですけど、あれは一般に広まってるアプリの実装例の解説書ですよね。

やっぱり、JavaやRubyにあるようなFrameworkと等価なもの、且つ関数型の
魅力が発揮できてるものが無いと火がつかないんじゃないかなぁ。

C#なんかは、自分は好きじゃないですけど、そういう利便性の追求という点
ではそれなりによく出来てるとは思います。皆が欲しがりそうなものをよく
揃えてるなぁと。

Haskellerはそういうのは興味なくて、もっと言語自体の面白さを追求する
ことが多いんじゃないでしょうか？

0074デフォルトの名無しさん

2009/02/11(水) 12:35:26

>>73
JavaやRubyで使われているフレームワークと等価なものがほしいなら
JavaやRubyではどうしてダメでHaskellなのか
というのが論文では必要になりますね。
それが言えなければHaskellで実装する必要も無いでしょう。

0075デフォルトの名無しさん

2009/02/11(水) 12:41:29

>>73
> Haskellerはそういうのは興味なくて、もっと言語自体の面白さを追求する
> ことが多いんじゃないでしょうか？
というよりもむしろ純粋関数型言語で実用的でコミュニティも活発なのがHaskellぐらいしかないので、
関数型言語でもっとも効率的にプログラミングするにはどうすればいいか、
というのを研究する材料に使われることが多いというだけですね。
既存技術を持ち込むことにはあまり興味がないというのは正しい見方かもしれないけれど。
既存技術を持ち込むのに適した関数型言語ならOcamlとかのほうが適任かもしれないね。
むしろ、そういう考え方をHaskellに持ち込まないでほしいというのが俺の思いでもあるし、
多くのHaskellerもそう思っているはず。

0076デフォルトの名無しさん

2009/02/11(水) 12:44:34

既存技術っていうのはオブジェクト指向で培った技術という意味ね。
既存技術って言ったらいろいろ含まれすぎだから。。

007769

2009/02/11(水) 12:59:24

もちろん、オブジェクト指向とか持ち込む必要ないですよ。等価という言葉に
語弊があったかな。

そうではなくて、こうすりゃ簡単にWebアプリができちゃいますよ、みたいな
ものが必要じゃないのかなと。だけど、Haskeller一般はそんな量的な問題
関心なくて、もっと質的なことを追求したい、という感じがするわけです。

Railsのように実装手順が簡易且つ明確で、しかも副作用の無いことから
くる不具合の低減、並列処理の親和性なんかをアピールした、お手軽
フレームワーク、ライブラリが出てくるとぐっと違ってくると思うわけです。

要するに、Haskellが世間でお金になる。そういう状況ってこないのかなぁと。

0078デフォルトの名無しさん

2009/02/11(水) 13:07:54

>>77
オブジェクト指向に親和性が高い技術ってあるでしょ？
そういうのはそのまま持ち込めない、あるいは持ち込んでも不細工。
例えばオブジェクト指向で人気が高いデザインパターンとかはそのまま関数型言語に持ち込んでも不細工だし、
Railsにしたってオブジェクト指向を基盤としているからそのまま関数型言語で使うと不細工。

関数型言語で似たような機能をどのように違和感無く実現するか、っていうのは一つの研究テーマになってるよ。
まだ研究が実っていない部分が多いから、こうすればいいのになんでやらないんだ、っていう外部の感想は良く聞くけどね。

0079デフォルトの名無しさん

2009/02/11(水) 13:08:44

OCamlは一応オブジェクト指向機能がついているからオブジェクト指向の技術がそのまま持ち込めるんだよ。
だから関数型言語の中ではわりと人気が高いのかな。

008069

2009/02/11(水) 13:17:50

>>78
いや、ちょっと分からないです。Javaなどで使われてる実装パターンがHaskellにも
応用なんかする必要ないと思いますよ。

自分が言ってるのは、RailsをHaskellに移植しろ、って話じゃないんですよね。そうじゃ
なくて、Haskellならではの、だけど利便性ではRailsに負けないライブラリが欲しいなぁ
ということなのです。

Haskellが広まってそれが普通の開発でお金が取れるようにならないかな？っていう
素朴な願望なんですね。

0081デフォルトの名無しさん

2009/02/11(水) 13:21:40

不細工だろうが何だろうがとりあえず動くなら持ち込めばいいと思うけどな
それがなされてないなら需要がないんだろ

>>77
HAppS
A web framework for developers to prototype quickly, deploy painlessly, scale massively, operate reliably, and change easily.
http://happs.org/

こういうの？使ったことないけど

0082デフォルトの名無しさん

2009/02/11(水) 13:24:17

>>80
> Haskellならではの、だけど利便性ではRailsに負けないライブラリ
そういうのも含めて言っているよ。

研究中としかいいようがない。
文句言う前に論文あさって、やりたいことがあるなら人に言う前に自分で作ったら良いじゃん。
できたら論文にするなり、製品にするなりしたほうが自分のためになるよ。

0083デフォルトの名無しさん

2009/02/11(水) 13:25:30

Haskellが得意とするのは二つだ
lambda-calculus と pi-calculus
オブジェクト指向？どこの原始人ですか、あんたｗ

0084デフォルトの名無しさん

2009/02/11(水) 13:32:59

Haskellerは言語自体の信者なんであって
実用ソフト書くことになんか興味ないだろ
もともと言語自体実用的じゃないし

0085デフォルトの名無しさん

2009/02/11(水) 13:35:40

>>82
(1) モノをつくる、(2) 論文を書く、(3) 文句を言う、の中で
わざわざ2chで、どんなバカでもお手軽に自尊心にエサをやれる(3)を選んでるヤツに対して無茶いうなw

0086デフォルトの名無しさん

2009/02/11(水) 13:40:21

>>84
Haskeller全体の傾向のことは分からんが、実用に興味がある奴はそれなりに居るよ
ライブラリがそれなりに整備されていってるのが証拠

言語仕様が実用的じゃないってのは意味不明

0087デフォルトの名無しさん

2009/02/11(水) 13:41:35

>>84
あなたにとっての「実用的」を論理的に説明してください

0088デフォルトの名無しさん

2009/02/11(水) 13:50:01

>>87
実用プログラムが簡単に書けることだな
テキストエディタとか、表計算ソフトとか、お絵かきソフトとか
人の楽しみや金銭的利益を発生させる役に立つことが出来るプログラムが
簡単に書けることだ

0089デフォルトの名無しさん

2009/02/11(水) 13:52:00

>>88
そんなのも書けないなら一からHaskellの勉強(笑)やり直せ

0090デフォルトの名無しさん

2009/02/11(水) 13:56:23

>>89
お前しょうもないやつだな

0091デフォルトの名無しさん

2009/02/11(水) 14:02:16

そろそろ勝利宣言とかくるのかな？

0092デフォルトの名無しさん

2009/02/11(水) 14:05:12

Yiとか割と夢が広がるようなソフトもあるけど、
これは俺がemacs厨なだけかもしれん

0093デフォルトの名無しさん

2009/02/11(水) 14:09:33

>>79
OCamlはオブジェクト指向の技術があるからわりと人気が高いってそれマジで言ってんのww？

0094デフォルトの名無しさん

2009/02/11(水) 14:11:53

>>93
大真面目。
実際、ただのCamlだったころはほとんど人気が無かった。
オブジェクト指向でも開発できる、というのが心理的な安心感を与えるのだろう。

0095デフォルトの名無しさん

2009/02/11(水) 14:12:58

お前らってオブジェクト指向をやってる奴は全員バカだと思ってるの？

0096デフォルトの名無しさん

2009/02/11(水) 14:15:09

OCamlはF#人気に便乗してるだけだろ
もっとも、F#はオブジェクト指向は排除されたようだが

0097デフォルトの名無しさん

2009/02/11(水) 14:16:08

違うって。
F#はOCaml人気の後に出てきた後発組

0098デフォルトの名無しさん

2009/02/11(水) 14:16:44

まぁ、GUIソフトをうまく書けるのか、っていうのはそれなりに重要な点だと思う。

でも、GUIソフトの書き方で、これがすばらしい、理想的だっていう
言語、フレームワークにはまだ出会ってないので、
何が必要なのかとかはよく分からん。

GUIはいろいろ考えるよりも、実直に状態マシンで仕様化して、
それを書き下したほうが結局は分かりやすくなるような気もするし、
そういう意味では、Haskellはむしろ書きやすい言語なのかもしれない。

0099デフォルトの名無しさん

2009/02/11(水) 14:18:10

Yampaとか全然使い方がわがんね

0100デフォルトの名無しさん

2009/02/11(水) 14:18:16

>>88
３点質問します
・あなたはどの程度Haskellが使えますか？
・言語仕様とラブラリやコンポーネントの話がごっちゃになっているのは何故？
（それとも何のライブラリも使わずに0からお絵描きソフトや表計算ソフトを作るってこと？）
・BtoCだけでなくBtoBも考えたら、どの言語が一番「金銭的利益を発生させる役に立つことが出来ている」と思いますか？

0101デフォルトの名無しさん

2009/02/11(水) 14:21:03

xmonadのソースでも読んでみたら?

0102デフォルトの名無しさん

2009/02/11(水) 14:23:29

言語として副作用もまともに扱えないのにGUIもクソもないでしょう

0103デフォルトの名無しさん

2009/02/11(水) 14:25:32

>>95
いやそうじゃなくて、OCamlのオブジェクト指向部分はかなり悪評高いんだよ。

>>94
OCamlのオブジェクト指向はかなり人気がないことをもちろん知った上での発言だよね？
何かそれでもOCamlのOOP部分に利点があるというならそれはどんな点？

0104デフォルトの名無しさん

2009/02/11(水) 14:25:40

GUIの書き方はGrapefruitが個人的な理想にかなり近い
ライブラリ自体は全然実用段階ではないけど

0105デフォルトの名無しさん

2009/02/11(水) 14:26:29

てか>>102=84なのか？
だったらマジで勉強しなおしたほうが良いと思うぞ。

0106デフォルトの名無しさん

2009/02/11(水) 14:27:44

副作用無しでイベント駆動系が綺麗に実装できたら面白いなぁとか思ってるけど
gtk2hsはIORef使いまくりで吹いたｗ

0107デフォルトの名無しさん

2009/02/11(水) 14:28:20

>>102
たぶんHaskellを誤解してるな
Haskellに副作用はないけど、副作用とは別の方法でちゃんと入出力ができるから心配要らんよ

0108デフォルトの名無しさん

2009/02/11(水) 14:29:13

>>103
コミュニケーションが取れないな。
お前はOCamlまたはF#の人気の根拠は何だと思っているんだ？

010969

2009/02/11(水) 14:30:40

>>81
> HAppS

そういうの。だけど、Jakartaプロジェクトにあるようなレベルとはやっぱり違うんですよね。

>>82
> 文句言う前に論文あさって、やりたいことがあるなら人に言う前に自分で作ったら良いじゃん。

あはは。すみません、自分はそこまでできません。

Haskellerの皆さんって頭イイ人多いと思うんですよ。そこでうまく金にする方向へは行かない
んでしょうかね。

0110デフォルトの名無しさん

2009/02/11(水) 14:34:11

>>109
お前、名大のOB？

0111デフォルトの名無しさん

2009/02/11(水) 14:37:09

>>108
＞F#の人気の根拠
そもそも人気ではないと思うんだが。

＞OCamlの人気の根拠
型推論とかがあるからじゃないかな。
で、Haskellみたいにモナドにくるんだりせずに直接副作用操作が書ける、という手軽さ。
　　　　　　　　　　　　　　　　＋
実用的なライブラリもそこそこ揃ってる。GUIツールキットとか。

0112デフォルトの名無しさん

2009/02/11(水) 14:37:16

>>106
Grapefruitはgtk2hsのラッパとして動くけど、そのへんをうまく隠蔽してるよ
ボタン一個を表示して、クリックされる度にボタン上のテキストの"*"が増えていくサンプル
Grapefruit付属のexampleから抜粋

mainCircuit :: (StdToolkit toolkit) => UICircuit Window toolkit era () (DSignal era ())
mainCircuit = proc () -> do
rec let

title = pure "Simple"

text = SSignal.scan "*" (const . ('*' :)) push

X :& Closure ::= closure `With` X :& Push ::= push
<- window `with` just pushButton
-< X :& Title ::= title `With` X :& Text ::= text
returnA -< closure

0113デフォルトの名無しさん

2009/02/11(水) 14:43:16

GUIにあんまり興味ないけど、HaskellのGUIライブラリとか親和性とかについて前に誰かまとめてくれてたね。
nobsunだっけ？

0114デフォルトの名無しさん

2009/02/11(水) 14:45:58

横からすまんが
>お前はOCamlまたはF#の人気の根拠は何だと思っているんだ？
OCamlやF#って人気あるの？
単なるあなたのマイブームでない「人気」の証拠を、示してもらえますでしょうか？
Radditとか見てもあまり話題にあがってないと思います。

0115デフォルトの名無しさん

2009/02/11(水) 14:49:52

日本ではF#発表されるまで全くの無名だろ>OCaml
日本語の本なんてここ3年にでたのしかないし。

0116デフォルトの名無しさん

2009/02/11(水) 14:49:59

>>114
MicrosoftがVisual StudioにF#を乗っけようとしているから。

0117デフォルトの名無しさん

2009/02/11(水) 14:52:32

Microsoftは合理的な資本主義の営利企業だから儲からないことはやらないだろう。
そのMicrosoftがF#を打ち出してるんだから人気がある、あるいは人気が出る、あるいは人気を出させる、
と判断したからだろう。

0118デフォルトの名無しさん

2009/02/11(水) 14:54:09

>>117
Visual J#って覚えてる？あとその人気についても。

0119デフォルトの名無しさん

2009/02/11(水) 14:58:28

当てが外れることもあるから商売＝ギャンブルは成り立つんだよ。

0120デフォルトの名無しさん

2009/02/11(水) 15:14:37

で、F#はどのへんで人気なの？

0121デフォルトの名無しさん

2009/02/11(水) 15:16:33

うるせーよ自分で調べろよ

0122デフォルトの名無しさん

2009/02/11(水) 15:40:41

じゃあHaskellはどの辺で人気なの？

0123デフォルトの名無しさん

2009/02/11(水) 15:42:13

人気なんてありませんよ。
人気がある言語をお望みでしたらどうぞお帰りください。

0124デフォルトの名無しさん

2009/02/11(水) 15:50:27

>>112
今の普通の言語だと

コンストラクタ
{
...
　button.Click += button_click;
}

void button_click()
{
　button.Text = button.Text + "*";
}

こんな風になるわけじゃない
こんなんと比較してどの辺が優れてるの？

0125デフォルトの名無しさん

2009/02/11(水) 15:55:59

カレーハワードの対応でリストに相当するもんはなんなんでしょうか
試しにzipwith :: (a->b->c)->[a]->[b]->[c]を場合分けで証明して、
そこからカレー(ry対応でhaskellのコードに変換したかったんですが
リストをどう処理していいのかわかりませんでした

0126デフォルトの名無しさん

2009/02/11(水) 16:37:41

よし、今日の晩飯はカレーだ

0127デフォルトの名無しさん

2009/02/11(水) 16:42:03

>>121
GUIの要素って、いくつかの入力といくつかの出力のある部品とみなせるじゃん
たとえばボタンなら、表面のテキストや、無効化されているかどうかの状態が入力で、クリックイベントが出力
Grapefruit(や、その他のFRPライブラリ)だと、こういう部品をいくつか繋げてより大きな部品を作る、という操作を簡単に
(定型的なイベントハンドリングのコードを手で書くことなく)行なえて、それを繰り返してGUIプログラムを書くことになる
個々の部品はそれぞれ独立して記述・テストできるし、プログラムの構造がGUIの構造を反映するから、保守しやすくなると思う
(小さいもの(たとえば関数)を組み合わせて順次大きいものを作るというスタイルが有効なのは、プログラマなら良く知ってるはず)

>>112の例だと、まずボタンの出力であるクリックイベントをscan(Data.List.scanlのアナロジー)を使って'*'の羅列に加工し、
それをボタンのテキスト入力にフィードバックした回路を作ってる
その回路がウィンドウに入っていて、全体として入力が空で出力がウィンドウを閉じるclosureイベントだけ、という回路になっている

あと細かい点として、部品の合成をするときは、部品の実体を直接繋ぐんじゃなくて、
部品の設計図(Haskellではアローで表現される)を合成して、最後に一括してインスタンスを作る
部品はコピーできないけど設計図はコピーできるので、扱いやすい
この設計図は通常の値なので、パラメタを指定すると設計図を返す関数、みたいなのも自然に書ける

こういう特徴をまとめてdeclarativeだというんじゃないかな…

0128デフォルトの名無しさん

2009/02/11(水) 16:42:57

ごめん、>>127は>>124へのレス

0129デフォルトの名無しさん

2009/02/11(水) 16:51:41

>>125
良く分からんが、
zipWith f xs ys = []
という自明な証明がある自明な命題っぽい

0130デフォルトの名無しさん

2009/02/11(水) 16:58:26

>>125
言っている意味がわかりません。

0131デフォルトの名無しさん

2009/02/12(木) 21:32:21

Haskellerってやっぱゴリゴリアプリ作るよりも、論文読んで理論理解を進める
ことを主にしてるんですかね。

0132デフォルトの名無しさん

2009/02/12(木) 22:31:27

Haskellerって言っても色々いるだろ
俺はHaskellの論文読んでる時間よりHaskellのコード書いてる時間の方が圧倒的に長い

0133デフォルトの名無しさん

2009/02/12(木) 23:35:47

Haskellと量子計算
> 第1回　関数型プログラミングの世界へようこそ
ttp://itpro.nikkeibp.co.jp/article/COLUMN/20060801/244812/
ttp://www.cs.nott.ac.uk/~txa/talks/ottawa-03.pdf

0134デフォルトの名無しさん

2009/02/13(金) 00:00:15

つうか論文ってどこで読むの（＾ρ＾）

0135デフォルトの名無しさん

2009/02/13(金) 00:02:05

>>134
学会の論文誌

0136デフォルトの名無しさん

2009/02/13(金) 00:02:23

haskell wikiにおいで

0137デフォルトの名無しさん

2009/02/13(金) 06:32:45

やっぱHaskellerってGHCのコードは全部読んだことあるの？

0138デフォルトの名無しさん

2009/02/13(金) 06:46:01

>>134
とりあえず手始めに
Simon Peyton Jonesのサイトにいくのはどう？

0139デフォルトの名無しさん

2009/02/13(金) 09:33:20

rts以外は全部読んだよ

0140デフォルトの名無しさん

2009/02/13(金) 09:33:36

>> 94
OCamlはオブジェクト指向があるからというより、単に実効速度が早いからじゃね？
型推論があって短く書けるし、コンパイルも早いし、
副作用もかけるからモナドが分かんなくても大丈夫だし
静的型があるから実行時の信頼性も高いし
サーバーサイドでOCamlは結構使われているんじゃないかなぁ。
でもOCamlの人はHaskell好きが多い気がする。

0141デフォルトの名無しさん

2009/02/13(金) 20:14:26

OCaml好きの俺は↑の通り速度+強い型付けに惹かれて始めた。
型推論の便利さは始めてから気づいたが
オブジェクト指向部分にはさして興味ない

Haskellはインデント強制と遅延評価が嫌いだが
それ以外の部分は、かじった程度には好きかなぁ

0142デフォルトの名無しさん

2009/02/13(金) 20:17:55

>>141
もともとLISP好きとか？

0143デフォルトの名無しさん

2009/02/13(金) 20:50:17

Common LispはわからんけどSchemeは好き。
C++のSTLさわるようになってちょっとたった頃
自分のやりたいことはC++では面倒だと悟って
Scheme→OCamlに至る

0144デフォルトの名無しさん

2009/02/13(金) 20:51:55

>>139
すげえな、やっぱみんなそうなのか。。

0145デフォルトの名無しさん

2009/02/13(金) 21:23:55

プログラミング習得の流れ
VB.net => C# => F# => OCaml => Haskell => Agda => Coq
もしくは
Java => Scala => Scheme => OCaml => Haskell => Agda => Coq

0146デフォルトの名無しさん

2009/02/13(金) 21:28:36

>>132
どんなコードを普段書いてるんですか？仕事で？

0147デフォルトの名無しさん

2009/02/14(土) 01:23:46

>>146
仕事＝研究

0148デフォルトの名無しさん

2009/02/14(土) 04:31:57

>>144
俺は全く読んだことないよ。

0149デフォルトの名無しさん

2009/02/14(土) 07:19:22

Real World Haskell 全文公開
ttp://book.realworldhaskell.org/read/

こりゃすげえ

0150デフォルトの名無しさん

2009/02/14(土) 08:54:49

Real World Haskellは研究者の方から見るとどういう位置づけ
の本になりますか？

「新しいこと何もないじゃん。ツマンネ」って感じでしょうか。

0151デフォルトの名無しさん

2009/02/14(土) 09:24:21

>>145 ちょ、オレまだJavaだよ。まだまだだな。

0152デフォルトの名無しさん

2009/02/14(土) 12:03:36

>>145 これが選民思想ってやつか。

0153デフォルトの名無しさん

2009/02/14(土) 17:15:09

>>145
右に行くほどWindowsに冷たくなっていくのがなぁ
関数型言語やり始めて初めてWindowsが嫌われる理由がわかったよ・・・

0154デフォルトの名無しさん

2009/02/14(土) 17:59:45

>145
ScalaとかOCamlとかやったことねぇｗ

0155デフォルトの名無しさん

2009/02/15(日) 19:06:31

OCaml速いの？Cleanの方が速いってイメージがあるけど。

0156デフォルトの名無しさん

2009/02/15(日) 20:35:41

Cleanってもうずっとメンテとまってるじゃん。

0157デフォルトの名無しさん

2009/02/16(月) 01:05:48

>145
確かにプログラムすごい人はみんな右側を目指している気がする。
現在のビジネス現場に用いられるかは別だけど。

0158デフォルトの名無しさん

2009/02/16(月) 01:47:40

Agdaもcoqも知らなかった
軽量スレッドとSTMとSIMD向き機能と
豊富なライブラリが有れば十分だと思う
いい線行ってるのは、Haskell,Clojure,F#じゃない?

0159デフォルトの名無しさん

2009/02/16(月) 15:54:04

clojure って、注目、集めてるのかな?

俺、ちょっと前、Webで引っかかって、
へ～と、思っただけだったんだけど。

Java ベースって所で、軽く読んだだけで
済ませちゃった。

0160デフォルトの名無しさん

2009/02/16(月) 16:02:42

Javaベース＝ウンコ　→　終了

0161デフォルトの名無しさん

2009/02/16(月) 17:55:35

今更かもしれないけど
ttp://hackage.haskell.org/cgi-bin/hackage-scripts/package/ghci-haskeline
ghci-haskeline だと windows でも ghci でタブで補完が効きます、お試しあれ。

0162デフォルトの名無しさん

2009/02/16(月) 21:59:40

>>160
なんでJavaベースでやろうとするんだろな。
Scalaとかそれだけで敬遠してるわ。

0163デフォルトの名無しさん

2009/02/16(月) 22:10:38

>>162
処理系作るのが簡単だから。

0164デフォルトの名無しさん

2009/02/16(月) 22:29:33

いいじゃん Java ベースでも。Clojure は実用性も強く意識
してる、いい言語だと思うよ。

0165デフォルトの名無しさん

2009/02/16(月) 22:47:01

>>164
Javaの仮想マシンが不安定なんです。

0166デフォルトの名無しさん

2009/02/16(月) 23:52:26

不安定って話は聞いた事が無いな。
ちょこちょこREPLを立ち上げる様な使い方だと、
相性が良いとは言えないとは思うけど。

0167デフォルトの名無しさん

2009/02/17(火) 00:02:29

GCがウンコなんで、Javaもウンコ。
もう仕様が悪いとしか言いようがありません。

0168デフォルトの名無しさん

2009/02/17(火) 00:18:05

・Java以外の言語でコーディング --> Javaバイトコード生成
・JVM(サーバ、クライアント共に)がきちんとクロージャなどをサポートするように進化
の条件が揃えば商用アプリ作成がしやすくなるんでは?
Java言語自体は衰退するかもしれんが。

0169デフォルトの名無しさん

2009/02/17(火) 00:23:53

>>166
おれも、Java だからという理由で気になるのは起動速度くらいだなぁ。
REPL といえば、ghci も起動速度遅いよね。hugs は早いの？

0170デフォルトの名無しさん

2009/02/17(火) 02:34:49

ぱっと見、興味を持ったとこ。
lazy-cons defn when-let あと、lisp-1
arcより、面白そうな気もする。

javaを嫌う人は結構いるだろうから、
もし、このlispがはやったら、
nativeで書く人が出てくるんじゃない。

けど、class library使えなくなっちゃうか。

0171デフォルトの名無しさん

2009/02/17(火) 07:21:29

Javaな時点でJavaを越えられないんだから夢が無いわ

0172デフォルトの名無しさん

2009/02/17(火) 09:18:12

CALの話が全く出てこないな…

0173デフォルトの名無しさん

2009/02/17(火) 09:45:21

>>166
起動してから３時間ぐらいスリープで無限ループしてからほかの処理をさせると、
いきなりエラーはいて終了することが良くあるんだけど原因は何なの？

0174デフォルトの名無しさん

2009/02/17(火) 18:36:42

今は史上初めて関数型がメインストリームに躍り出そうな瞬間、だね。
Java->Scalaと.NET->F#によって。
それでもJavaはJavaのほうが使われるだろうし
.NETはVB/C#のほうが使われるだろうけど。

0175デフォルトの名無しさん

2009/02/17(火) 18:39:57

マイクロソフトのおかげでJavaプログラマは激減の一途です。
まもなくJava終了のお知らせが来るでしょう。

0176デフォルトの名無しさん

2009/02/17(火) 21:28:09

>>174
F#ってギャグかと思ってたんですが、結構使われそうな雰囲気なんですか？

0177デフォルトの名無しさん

2009/02/17(火) 22:05:36

HaskellやOCaml知ってる人が現場で.Netで作ってね　って言われても、C#、VBは嫌じゃね？

金儲けではF#, 趣味や研究ではHaskellってのがこれからはよくあるんじゃないかなぁ。

0178デフォルトの名無しさん

2009/02/17(火) 22:09:42

よくわからないんだけど、他人がソース読むこと考えたらC#は嫌とかいってらんないと思うけどなあ
結局関数型でないと見通しが悪くなったり、特殊なことがやりたいときくらいになるんじゃないかなあ

0179デフォルトの名無しさん

2009/02/17(火) 22:10:18

仕事でやるなら楽だから結構好き＞C#

0180デフォルトの名無しさん

2009/02/17(火) 23:26:30

>>167
GCはもう文句をつける部分じゃなく、どうやって付き合って行くかを
考える部分だぞ。それくらい完全に浸透している。
しかもJavaVMのGCはかなり充実していて、バカに出来る物じゃないぞ。
特に並列GCについてはかなり頑張っていると思う。

0181デフォルトの名無しさん

2009/02/17(火) 23:32:20

>>180
GCの実装にはいろいろアルゴリズムがあるけど、Javaの仮想マシンに使われてるGCのアルゴリズムには苦情が多いよ。

0182デフォルトの名無しさん

2009/02/17(火) 23:36:36

付き合っていく以前に、Java自体衰退してるじゃん。既に。
アメリカじゃJavaが捨てられて混沌の世界になってるらしい。

0183デフォルトの名無しさん

2009/02/18(水) 00:30:28

>>182
ttp://sourceforge.jp/magazine/09/01/27/0039208
GoogleCodeに登録されているプロジェクトの使用言語を見るとJavaがCに次いで多い。
Haskellは話題にはのぼるけど実際に使われることが少ないのな。人が少ないからか。

0184デフォルトの名無しさん

2009/02/18(水) 00:38:38

>>181
どんな苦情があるの?

マルチプロセッサであれだけスケールしてくれるGCは他にはあまり無いし、
実装はきちんとしているイメージなんだが。

0185デフォルトの名無しさん

2009/02/18(水) 00:43:20

>>183
それは昔からの蓄積でしょ？
オープンソースが大きく取り扱われるようになった頃とJavaの流行が重なってるから、登録もその頃のものだろう。

0186デフォルトの名無しさん

2009/02/18(水) 00:44:48

もしくは商業ベースでのJavaプロジェクトがほとんど無くなったのでオープンソースに流れてきたのかな？
ともかくJavaが衰退してきているってよく聞くよ。

0187デフォルトの名無しさん

2009/02/18(水) 00:51:51

過去、C++が終わったという話をずっと聞き続けて来た気がするが、
『終わった事にする商法』はいつ終わるんだろうな…

0188デフォルトの名無しさん

2009/02/18(水) 01:00:13

プログラマは常にマーケッターに騙され続ける生き物

0189デフォルトの名無しさん

2009/02/18(水) 01:10:57

>>173
そんな話は知らんけど、ヘボプログラムだったんじゃないの？
暇を見て調べておくからエラーログと再現プログラムをくれ。

0190デフォルトの名無しさん

2009/02/18(水) 01:23:15

そろそろ Haskell の話題に戻ろうぜ↓

0191デフォルトの名無しさん

2009/02/18(水) 07:20:32

>>177
本当に「知っている人」はどんな言語でもちゃんと使えるよ。
半端な奴が「関数型じゃないとイヤ」とか言う。

0192デフォルトの名無しさん

2009/02/18(水) 07:26:29

私怨を持ち込む奴が半端物でなくてなんであろう

0193デフォルトの名無しさん

2009/02/18(水) 11:20:08

>>176
ギャグどころかやつらは本気みたいだぞ
ttp://igeta.cocolog-nifty.com/blog/2008/09/fsharp.html

むしろこのまま突っ走って行ってほしいところ

0194デフォルトの名無しさん

2009/02/18(水) 13:01:46

言語を作る人と言語を使う人（信者）の２種類いる

0195デフォルトの名無しさん

2009/02/18(水) 19:53:05

>>193
そいつただの実験厨じゃんw
実験厨は実験してるだけで実用的なアプリは作らないので
使われたことにはなりません

0196デフォルトの名無しさん

2009/02/19(木) 07:34:57

>>195のようなことを言う奴が実用的なアプリをつくっている例を見たことない。

0197デフォルトの名無しさん

2009/02/19(木) 10:58:06

>>196
実用的なアプリを作っている奴が>>195のような書き込みをしたことがないという証拠がない。

0198デフォルトの名無しさん

2009/02/19(木) 11:13:11

>>197
あのさ、事実のあるなしじゃなくて、事後確率の問題なんじゃねーの？
統計にがてだった？

0199デフォルトの名無しさん

2009/02/19(木) 11:25:26

>>198
君ってどこまで負けず嫌いなの？
統計と言うなら数字を出すべきだし、それ以前に偏見を持って物事に当たるべからずっていう行間の意味が理解できないほど国語苦手だったの？＾＾；

0200デフォルトの名無しさん

2009/02/19(木) 11:28:45

実験厨のあとは同一認定厨が登場しました。次は何厨房が出るんでしょう？

0201デフォルトの名無しさん

2009/02/19(木) 11:29:36

なんだ、ただの釣り師か。

0202デフォルトの名無しさん

2009/02/19(木) 11:32:20

>>201
いいから頭冷やせって、>>196さんよぉ

0203デフォルトの名無しさん

2009/02/19(木) 11:34:27

どうでも良いけど最近arrowの話題めっきり聞かなくなったな。

0204デフォルトの名無しさん

2009/02/19(木) 11:40:21

一時はすべてのhaskellライブラリがarrowで書き換えられるんじゃないかって勢いだったのに、
所詮は一過性の流行でしかなかったということか。

0205デフォルトの名無しさん

2009/02/19(木) 12:25:55

arrowへの書き換え作業が、なぜメインストリームに乗ると考えるかが不思議。

0206デフォルトの名無しさん

2009/02/19(木) 16:24:46

まぁ、実際arrowに書き換えないと乗り遅れるとみんなが思っていた時期もあった。

0207デフォルトの名無しさん

2009/02/19(木) 17:12:55

arrowが分かってない人だけじゃね

0208デフォルトの名無しさん

2009/02/19(木) 17:44:54

うむ。おじいちゃんもがんばってるんだからみながんばれ
ttp://www.cmas60.com/index.php

0209デフォルトの名無しさん

2009/02/19(木) 22:20:57

おじいちゃん、F#にのりかえたようですが

0210デフォルトの名無しさん

2009/02/19(木) 22:52:40

情報処理学会誌で、和田先生がHaskellのコラム書いてたのを思い出した

0211デフォルトの名無しさん

2009/02/19(木) 23:08:58

そのおじいちゃんすごいな、しかもForthちょうど今日完成したんだな。おめでたい

0212デフォルトの名無しさん

2009/02/20(金) 01:24:25

初心者です。
WIndows + Hugs でウィキペディアからデータをとるプログラムを作ろうとしているのですが、
いきなり文字化けでつまずいています。

module MediaWiki where

import System.IO
import Network

loop :: IO a -> IO a
loop a = a >> loop a

test = do
h <- connectTo "ja.wikipedia.org" (PortNumber 80)
hPutStr h "GET / HTTP/1.1\nHost: http://ja.wikipedia.org/wiki/%E3%83%A1%E3%82%A4%E3%83%B3%E3%83%9A%E3%83%BC%E3%82%B8\n\n"
f <- openFile "D:/test.txt" WriteMode
loop (hGetLine h >>= hPutStr f)

きちんとループ処理していないので、エラーで終了しますが、とりあえずデータは取れます。
しかし、文字化けしています。文字化けを回避する方法はないでしょうか。

0213デフォルトの名無しさん

2009/02/20(金) 01:36:45

自己解決しました。
お騒がせして、すみません…

0214デフォルトの名無しさん

2009/02/20(金) 01:44:20

>>213
どうやって解決したの?

0215デフォルトの名無しさん

2009/02/20(金) 02:17:05

>>214
テキストエディタ(Notepad++)が、コーディングをうまく認識しなかったようです。
メモ帳でUTF-8を指定して開くと読めました。

0216デフォルトの名無しさん

2009/02/20(金) 02:54:57

notepad++はやめときな。
あれはバグが多すぎて、書いたものや開いたものの安全は保障できないぜ。

0217デフォルトの名無しさん

2009/02/20(金) 02:57:21

winやったらxyzzyあたりでいいんじゃないの

0218デフォルトの名無しさん

2009/02/20(金) 03:06:07

xyzzyの機能はmeadowの劣化版だし、スクリプトに互換性ないでしょ。

0219デフォルトの名無しさん

2009/02/20(金) 03:14:58

使う気があるなら、ntemacsでもmeadowでも良いと思うよ。
ただ、notepadあたりを使ってる人に導入が簡単だろうか？
と思ったからだよ。notepadよりはマシだろ？
本当はemacsのhaskell-modeは欲しいね。

0220デフォルトの名無しさん

2009/02/20(金) 12:14:18

ghcって、バイナリ作るところまで担ってるの？それともアセンブラまで生成
して、アセンブルは外部に丸投げ？

0221デフォルトの名無しさん

2009/02/20(金) 12:33:48

アセンブルは丸投げ

0222デフォルトの名無しさん

2009/02/20(金) 12:46:47

GHCはCコードを生成してＣコンパイラに渡す

0223デフォルトの名無しさん

2009/02/20(金) 12:48:58

>>220
アセンブラを生成って・・・
処理系を生成するわけじゃないんだからｗ
この文脈の場合は　アセンブリ言語を生成　って言ったほうが誤解を招かないよ。

0224デフォルトの名無しさん

2009/02/20(金) 12:49:59

つうことはwindowsならgccでなくcl.exeを使うようにすることもできるのか

0225デフォルトの名無しさん

2009/02/20(金) 12:52:20

>>224
-pgmcオプションかな。

0226デフォルトの名無しさん

2009/02/20(金) 13:31:36

デフォルトはCを介さずアセンブリを直接生成じゃね？
少なくとも俺の環境(x86, Linux, ghc-6.10.1)だとそうだ

>>224
中間Cコードはgcc依存じゃないだろうか
gccが生成したアセンブリに後処理を加えてるくらいだから

0227デフォルトの名無しさん

2009/02/20(金) 19:23:33

アセンブラソースかアセンブリソースって言わないかな？

GCCのcc1もバイナリ生成しないし、自分の知ってる処理系では
MSC系とTurboC系ぐらいしかないな、直接オブジェクト吐く
コンパイラって。

0228デフォルトの名無しさん

2009/02/20(金) 19:26:49

じゃマシンコードで

0229デフォルトの名無しさん

2009/02/20(金) 19:52:34

turboC懐かしいなぁ・・　初めて親に買ってもらったCコンパイラがturboCなんだが、もう20年も昔のことなのか。

0230デフォルトの名無しさん

2009/02/20(金) 20:29:12

このブルジョアめ…

0231デフォルトの名無しさん

2009/02/20(金) 20:37:59

金無くて、BASICでCコンパイラ書いてる奴も居た。
または8bitマシン語でメタコンパイラとか。
ghcもメタコンパイラと言えるんだろうか?

0232デフォルトの名無しさん

2009/02/20(金) 20:53:01

以前、川合史朗さんが書いたものだったと思うのですが、Haskellはトップダウン
なプログラミングでScheme（Lisp）はボトムアップだ、という話題を読んだことが
あります。

結局、Haskellの型チェックがコンパイル時に入るために、ごにょごにょと試しつつ
トップレベルの構造に至る、という作り方ができないんだと。

これってそうなんでしょうか。最初にピシッと構成が見えてないとプログラミングが
できない、ってのは不便な気がします。

0233デフォルトの名無しさん

2009/02/20(金) 21:27:24

>>223
ごめん、アセンブラリルの区別に自信なかった。
やっぱ間違ってたか。

0234デフォルトの名無しさん

2009/02/20(金) 21:31:13

>>232
Haskell だからってそんなことないと思うけどね。

Functional Parser のチュートリアルでよくあるじゃん。
プリミティブな部品(char とか)を作って、それを組み合わ
せて高度なもの(many とか)作って、さらにそれを組み合
わせて・・・っていう流れ。これってボトムアップだよね。

0235デフォルトの名無しさん

2009/02/20(金) 21:45:22

>>232
トップダウン、ボトムアップの部分は知らないけど、使っていて特にそう感じた事は無いけどなあ。
Haskellは多相型が強力なのと、未知の値->取り敢えずモナドに放り込む、未知の関数->取り敢えずArrow
で組んでいけるから構成が事前に固まっていなくても問題無い。

LISP系(Sheme、Gauche他)も、こんなオペレータがあればいいのにと思った時点ですぐ実装できる。

最初に構成が見えていないプロジェクトがやりにくいと感じるケースは、言語というより体制
(大人数・ウォーターフォールでやってて、コーダーに完成形の仕様書を渡す必要あり、など)に
原因ありの場合が多かった。
まあこれはC、Javaでも言える事なんで、むしろどんなケースで困ったのかが興味ある。

0236デフォルトの名無しさん

2009/02/20(金) 22:22:32

>>234
そのFunctional Parser自体をつくる時点でトップダウンという罠

0237デフォルトの名無しさん

2009/02/20(金) 23:54:46

>ghci
Prelude> let m3 x = 3 * x
Prelude> m3 5
15
Prelude> let m3 x = (*) 3 x
Prelude> let m3 = (*) 3
Prelude> let m3 = (* 3)
Prelude> m3 5
15

ここまではOK

Prelude> let mm x = x * x
Prelude> let mm = ?????

上記の?????が判らんorz

0238デフォルトの名無しさん

2009/02/21(土) 00:07:04

let mm = \x -> x * x

0239デフォルトの名無しさん

2009/02/21(土) 00:11:08

型限定版で
let mm = (** 2)

0240デフォルトの名無しさん

2009/02/21(土) 00:13:18

>>238,239
サンクス。しばらく他(多)言語使ってたんでちょっと混乱してたw

0241デフォルトの名無しさん

2009/02/21(土) 12:12:04

>>234 >>235
なるほど。自分はHaskellコードをそれなりの規模で書いた経験が無いので
実感できてないのかも知れないのですが、川合さんがおっしゃってるような
ことはよく感じちゃうんですね。

末端の補助関数みたいなものを、後からこのほうがいいな、と思ってちょっといじ
っただけで、バーっと型エラーになってしまうという。そうなると、最初にどうある
べきなんだろうか、とある程度の見通しを立ててからじゃないと手戻りが多い
気がしてます。

慣れの問題なんでしょうかね。

0242デフォルトの名無しさん

2009/02/25(水) 02:30:14

ここのエバンジェリストってだれ？

0243デフォルトの名無しさん

2009/02/25(水) 13:44:12

>>235
>Haskellは多相型が強力なのと、未知の値->取り敢えずモナドに放り込む、未知の関数->取り敢えずArrow
>で組んでいけるから構成が事前に固まっていなくても問題無い。

試行錯誤する例として短めのサンプルコードはあるでしょうか？

0244デフォルトの名無しさん

2009/02/25(水) 19:13:37

モナドやArrowを後から変更することはあるけど、
書き始める時点で全く未知ってのは、少なくとも俺の場合はないな。

0245デフォルトの名無しさん

2009/02/25(水) 21:53:08

実用性ってことでは、ライブラリに「なるほどこう使うのか」と分かるサンプルコードが付属しているのが大事だと思う。
オレがプログラミングで試行錯誤するのは、ライブラリの使い方が良く分からなくて、自分のやりたいことができるのか、どうできるのかを確認するのが大半のような気がするから。

0246デフォルトの名無しさん

2009/02/26(木) 00:51:13

素人です…
仕事で関数を使った表をやれと言われました

何にも知識無い人間でもできるもんですか？

0247デフォルトの名無しさん

2009/02/26(木) 00:59:20

>>246
http://pc11.2ch.net/test/read.cgi/bsoft/1235573810/

0248デフォルトの名無しさん

2009/02/26(木) 02:01:40

>>246
言っている意味が分かりません。
excelの話ですか？

0249デフォルトの名無しさん

2009/02/26(木) 02:34:32

総あたりでの素因数分解です
ある程度の汚さはアルゴリズム由来なのかもしれませんが、もっと格好よく書きたいです
state monadとかを使えば格好よく書けるでしょうか

http://codepad.org/5PUyX0zV

0250デフォルトの名無しさん

2009/02/26(木) 03:30:54

>>249
アルゴリズム的には、n < m の場合を考えてるのが変。
Haskell的には f の返り値が変。

f 1 _ = []
f n (m:ms)
| q == 0 = m : f b (m:ms)
| otherwise = f n ms
where
(b, q) = n `divMod` m

g n = f n [2..]

0251デフォルトの名無しさん

2009/02/26(木) 03:46:50

こんなんでました。

f _ [] = []
f n ps@(m:ms) = let (b, q) = n `divMod` m in if q == 0 then m:(f2 b ps) else f2 n ms

main = print $ map (\x->(x, f2 x [2..x])) [1..100]

0252251

2009/02/26(木) 03:48:33

あ、>>250のほうが美しい。

0253デフォルトの名無しさん

2009/02/26(木) 05:05:45

数学的には 1 に [1] を返そうとしてるのが変。

0254デフォルトの名無しさん

2009/02/26(木) 10:41:48

>>249は末尾再帰の形にしようとして苦労してるように見える
Haskellだと直接consを返してもスタックが伸びていくことはないから、
consが返せるならその方が綺麗になることが多いし、逆にメモリ使用量が減ることもある

例えばmapの定義
map f [] = []
map f (x:xs) = f x : map f xs
は、呼び出し側が結果のリストを先頭から順に読み捨てていく限り、定数空間で動く

>>250
n < mのテストがないと再帰が止まらんだろ
>>250のコードでn == 1のテストをしてるのと同等

0255デフォルトの名無しさん

2009/02/26(木) 18:07:04

すごい読解力

0256デフォルトの名無しさん

2009/02/26(木) 19:18:54

返すのが ret だけなら末尾再帰にしようとしてるっぽいけど、
n や m まで返そうとしてるのは、単に関数型言語に不慣れなんじゃないかな。

0257249

2009/02/26(木) 19:50:35

皆様回答ありがとうございます
(_, _, a)とかでてくる時点でおかしいとは思ったんですが、随分綺麗に書けるものなんですね
>>249のコードは手続き型のループによる繰り返しを使ったアルゴリズムを元に考えたので
末尾再帰の形っぽくなったんだと思います

0258デフォルトの名無しさん

2009/02/27(金) 18:26:14

Finally! Fast Unicode support for Haskell
http://www.serpentine.com/blog/2009/02/27/finally-fast-unicode-support-for-haskell/

0259デフォルトの名無しさん

2009/02/28(土) 00:14:51

>>258
グレート！ haskellはあまり触ってないけど、この件はもっと盛り上がってもよいとおもう。

0260デフォルトの名無しさん

2009/03/02(月) 20:42:29

http://www.atmarkit.co.jp/news/200902/27/langs.html

Real World Haskellって売れ行き順位とか結構高かった気がするんだけど、
これが入っていたら少しは変わったのかな。

C#なんか本買う必要あるんかねぇ。よく分からん。

0261デフォルトの名無しさん

2009/03/02(月) 20:55:06

>>260
MS王国が大好きなんちゃうか？

0262デフォルトの名無しさん

2009/03/03(火) 22:52:37

この言語がメジャーになる日が来ると思う？
どうなったらメジャーになれると思う？

0263デフォルトの名無しさん

2009/03/03(火) 22:57:53

>>262
こっちの系統は。。。scalaのほうがウケそう。
こんかれんとはすけるとかならありえそう？<じぇむす。ぶれーく

0264デフォルトの名無しさん

2009/03/03(火) 23:18:00

もっとポータビリティが向上すればok
yhcもっとガンガレ

0265デフォルトの名無しさん

2009/03/03(火) 23:28:42

>>264
そういえば、ghcってデカイよな。中性脂肪たっぷりってかんじ。

0266デフォルトの名無しさん

2009/03/03(火) 23:33:39

別にメジャーにならんでいい

0267デフォルトの名無しさん

2009/03/04(水) 00:21:41

メジャーになってライブラリの質と量が上がれば嬉しいけどなー

0268デフォルトの名無しさん

2009/03/04(水) 00:38:07

ライブラリ充実しても、普通に使えるようになるまでのハードルの高さが
ネックになってメインストリームにはならないんだろうね

0269デフォルトの名無しさん

2009/03/04(水) 00:41:29

メジャーになったらHaskellで飯くえるぞ（笑）

0270デフォルトの名無しさん

2009/03/04(水) 09:05:40

yhcがhaxeみたいになったらいい

0271デフォルトの名無しさん

2009/03/04(水) 09:52:23

Pythonのpy2exeみたく実行に必要なファイルをまとめて1個のexeファイルとかに出来ると良いんだけど。

0272デフォルトの名無しさん

2009/03/04(水) 09:53:16

>>271 は yhcの話しです。

0273デフォルトの名無しさん

2009/03/04(水) 09:54:29

>>269
メジャーになったら飯が食えるというのは幻想です。
良い物がメジャーになってない場合、市場規模は小さいから仕事を探すのは大変ですが、
特殊技能者として高給をもらえる可能性があります。
日本じゃないけど金融なら Haskell で 3000万円/year な所はありますよ。

飯食えんとか言ってる人はそもそも飯食ってやろうという覚悟のない人か、
現在の市場で雇われるにはまだ能力が足りない人。

メジャーになったらIT土方が大量に流入してくるので当然単価が下がります。
ま、Haskell で土方やりたいんだったらどんどんメジャーにしてくださいw
(まぁHaskell は比較的土方が流入しにくい構造にはなってると思うが。)

0274デフォルトの名無しさん

2009/03/04(水) 10:03:32

土方だって「飯は食える」よ。
ただIT土方は本物の土方と違って就業時間が厳しいが。

0275デフォルトの名無しさん

2009/03/04(水) 10:18:49

んなこと言ってるから買いたたかれて土方になっちまうんだよ。

0276デフォルトの名無しさん

2009/03/04(水) 10:22:06

cで土方やるよりhaskellで土方やる方がまだマシ

0277デフォルトの名無しさん

2009/03/04(水) 12:48:31

正直、どうやったらITドカタにならざるを得ない状況になるのか分からない。
就職口もシステムエンジニアか研究職ばっかりだし、派遣だったら一発で分かるし、ブラック企業って臭いで分かるし、
ITドカタの人に聞きたいけどどういう仕事探ししてるの？

0278デフォルトの名無しさん

2009/03/04(水) 12:53:35

最近、名刺は研究職だけど実態はドカタって人が増えてる気がする。

0279デフォルトの名無しさん

2009/03/04(水) 13:27:42

定時と同じかそれより早く帰れて、年間休日150日ぐらいあって福利厚生がよくて(ry

0280デフォルトの名無しさん

2009/03/04(水) 13:40:57

今なら仕事なくて定時帰宅多いんじゃね？

0281デフォルトの名無しさん

2009/03/04(水) 14:28:41

そうでもない

0282デフォルトの名無しさん

2009/03/04(水) 14:43:45

名ばかり研究職とか普通

0283デフォルトの名無しさん

2009/03/04(水) 14:51:04

隙間風がピューピュー、雨漏りしまくりのボロアパートでネズミをペットにして霞を食べていきてるっていうのが平均的な研究者の生活水準

0284デフォルトの名無しさん

2009/03/04(水) 14:57:08

小学生かよ

0285デフォルトの名無しさん

2009/03/04(水) 16:40:27

http://codepad.org/IjH5NT71
二引数のブール関数の引数とその戻り値の組み合わせを演算の定義とみなして
ある演算規則のもと、<=>と同じ結果を返すものでかつ<=>と同じ定義でないもの以外を探索するプログラムです

Haskellらしく書けてますか？
あと、もっとシンプルに書きたいんですがなんかいい方針とかありますかね？

0286285

2009/03/04(水) 18:39:57

上げてからMaybeの意味がないと気付いた…orz

0287デフォルトの名無しさん

2009/03/04(水) 19:45:02

土方土方言ってる人って何なのww？

0288デフォルトの名無しさん

2009/03/04(水) 20:00:50

蒸し返すお前から名乗れw

0289デフォルトの名無しさん

2009/03/04(水) 21:07:33

土方の話題を蒸し返して申し訳ないですが、現状の土方プログラマ業界に
Haskellが浸透したらかなり業界の風景が変わるんじゃないかな。

そもそもHaskell使っただけで、今までの命令型言語で発生してた途轍もない
ゴミコードを書き散らすことがかなり抑制されるわけですよね。副作用を利用
した手続きの羅列が禁じられてるわけだから。

逆に言えば、そうやって手続きをズラズラ書き連ねることでしかコーディングできない
人々は、Haskellで書くことになった途端思考停止になって何も書けないんじゃないか。
そして、元々命令型でも綺麗にコーディングできる人たちは生き残る。

そういう淘汰がすぐにでも起きてほしいと思ってる人は多いと思う。プログラミング
を仕事にするのが敬遠されるのは、結局はゴミコード製造機のお守りをさせられて、
賃金が能力に比例しないからでしょ。Haskellが普及したら変わると思うんだけどなぁ。

0290デフォルトの名無しさん

2009/03/04(水) 21:22:10

ゴミコードならすぐ上に上げられてるじゃないか

0291デフォルトの名無しさん

2009/03/04(水) 21:23:53

>>289
で、例えば現存するHaskellのGUIライブラリについてどう思う？

0292デフォルトの名無しさん

2009/03/04(水) 21:36:12

>>290
ひでえw

0293デフォルトの名無しさん

2009/03/04(水) 21:50:02

>>289
ゴミコードを書く奴はどんな言語を使ってもゴミコード書くんです。

0294デフォルトの名無しさん

2009/03/04(水) 22:35:52

>>290
じゃあ、どこがどうゴミなのか解説してあげて。その一行なら誹謗中傷に等しいじゃないか
尋ねてきてる人に何言ってんだ。と思ったよ。

0295デフォルトの名無しさん

2009/03/04(水) 22:47:48

>>285
せっかくリストモナド使うなら、patternsはこう書ける。

patterns n = if n > 0
　　then do
　　　ps <- patterns (n-1)
　　　ft <- [False, True]
　　　return (ps ++ [ft])
　　else [[]]

0296デフォルトの名無しさん

2009/03/05(木) 01:23:02

Haskellでも「副作用を利用した手続きの羅列」と同等な構造のコードは書けるし、書けないと困る

0297デフォルトの名無しさん

2009/03/05(木) 07:40:34

土方にHaskell書かせたら、引数が10個以上ある関数が山のように作られるだけ。

0298デフォルトの名無しさん

2009/03/05(木) 09:00:12

>>285
http://codepad.org/xbkr4jcX
特にどうということはないけど、
・isAssociative あたりの定義がおかしかった
・関数の場合しか考えてなさそうなので、
relation じゃなくて table にした
・一般化のバランスがおかしいと思った
（トップレベルにある fromListPair, db, search や DB型とか）

0299デフォルトの名無しさん

2009/03/05(木) 10:31:55

>>298
allTable = [zip domain zs | zs <- patterns (length damain)]
のほうがいいのと、>>285の意図は
p t = all (\q -> q (tab2op t) == q iff) ps where iff = (==)
っぽい

0300285

2009/03/05(木) 17:56:11

ありがとうございます！！
なんと行数が半分になるなんて…
sequenceやこの形でのパターンマッチは知りませんでした
最低でもPreludeだけは一通り触っておく必要性を感じました

0301デフォルトの名無しさん

2009/03/07(土) 00:03:14

http://donsbot.wordpress.com/2009/03/04/playing-with-ghcs-parallel-runtime/
こんなん出たんやね。ぱられるらんたいむだよ！ぱられるだよ！

0302デフォルトの名無しさん

2009/03/07(土) 02:00:19

もうイヤ

0303デフォルトの名無しさん

2009/03/08(日) 12:46:40

例えば g の関数を適用してから f の関数を適用するような関数を作るには単純に関数合成を行なえば良いわけですが、

> fg = f . g

g が2個以上の引数を受けとる関数の場合は引数を明示的に書く必要があります。

> fg x y = f (g x y)

ポイントフリーにすることも出来ますが、とたんにゴチャゴチャした書き方になってしまいます。
(Haskellには2個以上の引数を受取る関数など無い! という話もありますが、説明の便宜上のことなので御容赦下さい。)

そこで、右側での適用を終えてから左側の関数へ適用するような演算子を定義できないものかと考えました。

> fg = f .$ g

こうすると g が2引数でも3引数でも対応できるような演算子 .$ があれば便利ではないかと。
で、以下のふたつの定義を考えてみたのですが、うまくオーバーロードさせるためのクラス定義がどうにも思い付きません。

> (.$) :: (a -> b) -> a -> b
> f .$ g = f g
>
> (.$) :: (a -> b) -> (c -> d) -> (c -> b)
> f .$ g = \x -> f .$ g x

「ふつうのHaskellプログラミング」を読み返してみるとクラス定義の説明がえらく簡単で、あんまりわからなかったんですが、
この本で説明されているHaskellの機能だけで実現できるものでしょうか？

0304デフォルトの名無しさん

2009/03/08(日) 16:29:53

>>303
Haskell 98 の範疇ではできないと思う。
下のような感じになるんだろうけど、
fundep が足りないのか、flexible や undecidable が悪いのか、
((sum :: [Int] -> Int) .$ take) 5 ([1..10] :: [Int])
のように型をはっきりさせないと no instance って怒られる。

{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies,
FlexibleInstances, UndecidableInstances #-}

class FApp a b f g | a b f -> g where
(.$) :: (a -> b) -> f -> g

instance FApp a b a b where
f .$ x = f x

instance FApp a b f g => FApp a b (c -> f) (c -> g) where
(f .$ g) x = f .$ (g x)

0305デフォルトの名無しさん

2009/03/08(日) 16:32:37

>>303
class (Functor f) => Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
-- Defined in Control.Applicative
ということ？

或いは、

ap :: (Monad m) => m (a -> b) -> m a -> m b
-- Defined in Control.Monad
のこと？

0306デフォルトの名無しさん

2009/03/08(日) 19:21:55

>>303
関数の型が与えられても引数の数は決まらないから無理だと思う
例えばconstは定数関数を作る一引数の関数として使うことが多いけど、型だけ見たら二引数関数に見える
idは型を見れば一引数関数だけど、Just `id` 4みたいな使い方も可能

妥協して純粋に型の「見た目」だけで引数の数を決定するなら、GHC拡張を使って実現できた

{-# LANGUAGE IncoherentInstances, OverlappingInstances, TypeFamilies, FlexibleInstances,
MultiParamTypeClasses, UndecidableInstances, ScopedTypeVariables #-}
module Curried where
class Curry f args result where
curryP :: (args -> result) -> f
class Uncurry f args result where
uncurryP :: f -> (args -> result)
instance (Curry rf as result, f ~ (a -> rf)) => Curry f (a, as) result where
curryP c x = curryP (\as -> c (x, as))
instance (Uncurry b as result, args ~ (a, as)) => Uncurry (a -> b) args result where
uncurryP f (a, as) = uncurryP (f a) as

module Main where
import Curried
instance (f ~ result) => Curry f () result where
curryP c = c ()
instance (args ~ (), result ~ f) => Uncurry f args result where
uncurryP f () = f
($.) :: forall f g a b c. (Uncurry f a b, Curry g a c) => (b -> c) -> f -> g
f $. g = curryP (\x -> f (uncurryP g (x :: a)))
-- テスト
main = print $ ((+1) $. const) 100 200

モジュールを分けないとコンパイル通らないあたり怪しげな匂いがプンプンするが

0307303

2009/03/08(日) 20:38:55

>>304
私が漠然と想像してた形に近いです。
型を書かないといけないのは、
sum とかはオーバーロードされてるからですかねぇ。

クラス定義のところのその型変数の書き方の意味がよくわかってないので、
まずはそこを学ばないといけないようです。

>>305
どちらも違うと思います。

今回、このような演算子があればよいなぁと思ったのは
Gauche にある compose っぽいのをイメージしてたのです。
.$ という演算子も Gauche で compose の別名として定義されてるので
そのままもってきました。
合成と適用をうまいことやってくれる演算子としてピッタリな気がしたので。

>>306
結構な大作をありがとうございます。
今の私ではそう簡単に理解できなさそうですが。
色々なオプションがあるんですねぇ。

> 関数の型が与えられても引数の数は決まらないから無理だと思う
> 例えばconstは定数関数を作る一引数の関数として使うことが多いけど、型だけ見たら二引数関数に見える
> idは型を見れば一引数関数だけど、Just `id` 4みたいな使い方も可能

Haskell で単純に引数の数を利用することは出来ないとは思っているので、
f .$ g で f を g に適用可能な場合には適用して、
そうでない場合には g をもうひとつ何かに適用してから、
という風な場合分けで考えてました。

0308デフォルトの名無しさん

2009/03/11(水) 18:28:45

関数コンストラクタ (->)って何か読み方あるんでしょうか？

0309デフォルトの名無しさん

2009/03/11(水) 21:20:34

♂の尖ってる部分

0310デフォルトの名無しさん

2009/03/12(木) 01:58:55

右って読んでる

0311デフォルトの名無しさん

2009/03/12(木) 11:12:18

やじるし

0312デフォルトの名無しさん

2009/03/12(木) 12:23:14

あろー

0313デフォルトの名無しさん

2009/03/13(金) 12:09:52

real world haskellがjolt awardとったみたいよ。

http://www.joltawards.com/winners.html

0314デフォルトの名無しさん

2009/03/13(金) 12:20:34

おめでとう >>313 きみはこれから明い道が開いているよ

0315デフォルトの名無しさん

2009/03/14(土) 16:55:10

リストのn番目の内容を取り出すのはどうすれば良いですか
ls[n] じゃダメですよね？

0316デフォルトの名無しさん

2009/03/14(土) 16:57:54

ダメに決まってるだろ!!

0317デフォルトの名無しさん

2009/03/14(土) 17:58:54

自分で調べろよ!!

0318デフォルトの名無しさん

2009/03/14(土) 18:45:52

0319デフォルトの名無しさん

2009/03/14(土) 18:52:43

お前ら優しいな!!

0320デフォルトの名無しさん

2009/03/15(日) 14:02:30

>316
ダメなのは判るのですが、それをHaskellでどう書けば良いのか判らないのです…。

>317
何でググれば良いでしょうか？
Preludeは一通り見たのですが、takeくらいしか見当たりません。
かと言ってリストをArrayに全部移すのも違うだろうし…。

0321デフォルトの名無しさん

2009/03/15(日) 14:06:36

ググってわからなければふグれ
http://haskell.org/hoogle/?q=(!!)

0322デフォルトの名無しさん

2009/03/15(日) 14:27:37

>321
!!
英字の関数名ばかり見てました…orz

>316-319
何気に答えられていたことに気付きませんでした…すみません

0323デフォルトの名無しさん

2009/03/15(日) 16:24:46

Hoogleで関数の名前が知りたい時は型で検索するといいよ
http://www.haskell.org/hoogle/?hoogle=%5Ba%5D+-%3E+Int+-%3E+a

0324デフォルトの名無しさん

2009/03/16(月) 00:15:29

ふグるとな・・・

0325デフォルトの名無しさん

2009/03/16(月) 17:18:07

ふぐりますか？ふぐりませんか？

0326デフォルトの名無しさん

2009/03/16(月) 17:29:01

エロサイトでも調べとんのかと思うぞ^^;<ふぐる

0327デフォルトの名無しさん

2009/03/16(月) 22:38:21

HaskellでSetの中身を指定した書式で表示したいときとかってどうするのでしょうか？

OCamlでは例えば(int, int)のTupleのSetをダンプしたいときはSet.iterを使って、

module TupleSet = Set.Make (...(省略)
let dump = TupleSet.iter (fun (a, b) -> Printf.printf "%d/%d\n" a b)

というようにできるのですが、HaskellのSetにはiterのような関数はありません。

私が思いついたのは、

import Data.Set (elems)
import Text.Printf (printf)

dump set = mapM_ (\(a, b) -> printf "%d/%d\n" a b) $ elems set

または

dump set = mapM_ (\(a, b) -> putStrLn $ show a ++ "/" ++ show b) $ elems set

というようなコードですが、もっとHaskellっぽいスマートなやり方があるような気がします。

0328デフォルトの名無しさん

2009/03/16(月) 23:26:04

要素を列挙するときに一旦リストを介するのは十分Haskellっぽいやり方だと思う

見た目を気にするなら
mapM_ (\(a, b) -> ...) $ elems set
より
forM_ (elems set) $ \(a, b) -> ...
の方がスマートかもしれん

あるいは、
dump set = putStr $ unlines $ map format $ elems set
where
format (a, b) = ...
みたいに、一番外側までしかIOを絡ませない方がHaskellっぽいかも

0329デフォルトの名無しさん

2009/03/17(火) 01:06:19

>> 328
レスありがとうございました。

確かにIOが途中で登場するより、最後に出てきたほうがスマートですね。

教えていただいたforM_からFoldableというクラスがあることを知り、そこからconcatMapが使えそうな気がしてきました。
リストモナドの(>>=)がconcatMapであることを利用して、今のところ

dump set = putStr $ elems set >>= format
where format (a, b) = ...

辺りまでたどり着きました。

0330デフォルトの名無しさん

2009/03/17(火) 08:14:07

難読化の好きそうな人だな

0331デフォルトの名無しさん

2009/03/17(火) 18:52:27

難読というほどのものでもないだろ

0332デフォルトの名無しさん

2009/03/19(木) 12:22:50

Fizz-Buzz問題をHaskellで書いてみました。どうでしょうか？

hoge :: Int -> String -> (Int, String) -> (Int, String)
hoge m s nt@(n, t) = if n `mod` m == 0 then (n, s ++ t)
else nt

fizz :: (Int, String) -> (Int, String)
fizz = hoge 3 "Fizz"

buzz :: (Int, String) -> (Int, String)
buzz = hoge 5 "Buzz"

piyo :: (Int, String) -> String
piyo (n, "") = show n
piyo (_, s) = s

fizzbuzz :: Int -> String
fizzbuzz n = piyo $ fizz $ buzz (n, "")

main = putStr $ unwords $ map fizzbuzz [1..100]

0333デフォルトの名無しさん

2009/03/19(木) 12:58:59

今日の一行 fizzbuzzでググれ

0334デフォルトの名無しさん

2009/03/19(木) 13:03:04

Haskell関係なく、(Int, String) -> (Int, String)を作るあたりがまわりくどいな
fizzとbuzz以外のルールを将来追加する可能性を考えてそういう形にしてるの？

それから、ググったら同じ構造のコードが出て来たんだが、引用元に批判を加えて欲しいの？

0335デフォルトの名無しさん

2009/03/19(木) 13:04:39

>>334は>>332へのレス

0336デフォルトの名無しさん

2009/03/19(木) 13:27:03

>>335
問題から素直に、fizz :: Int　-> String　で作ったら数字が出なくて
当てはまらない時は数字を返すようにしたら、5Buzzってなって
しょうがないのでタプルにしてStringが無いときは数字、あるときはStringにしました。
やっぱり一つの関数にして複数のifで分岐するような作りの方がいいのでしょうか？

0337デフォルトの名無しさん

2009/03/19(木) 13:52:05

たった三つの分岐だし、俺なら一つの関数内で全部やるな
それが嫌なら、

fizz, buzz :: Int -> String -- 該当しないときは空文字列を返す
みたいなのを用意して、
case fizz n ++ buzz n of
"" -> show n
s -> s
とか
あるいは、空文字列が技巧的だと思うならMaybeでもいい

0338デフォルトの名無しさん

2009/03/19(木) 14:17:22

>>332のアイデアで

module FizzBuzz where

data Fb = S [Char] | I Integer
instance Show Fb where
show (S s) = s
show (I x) = show x

hoge w n (S s) = S s
hoge w n (I x) | x `mod` n == 0 = S w
| otherwise = I x

fizzbuzz = hoge "FizzBuzz" 15
fizz = hoge "Fizz" 5
buzz = hoge "Buzz" 3

main = putStr $ show $ take 100 $ map (buzz. fizz . fizzbuzz . I) [1..]

0339デフォルトの名無しさん

2009/03/19(木) 15:20:07

>>337
アドバイスありがどうございます。case文は勉強になりました。
再帰の練習も兼ねて書き換えてみました。

hoge :: [(Int, String)] -> (Int, String) -> (Int, String)
hoge [] ns = ns
hoge (x:xs) ns@(n, s) = if n `mod` fst x == 0 then hoge xs (n, snd x ++ s) else hoge xs ns

piyo :: [(Int, String)]
piyo = [(3, "Fizz"), (5, "Buzz")]

fizzbuzz :: Int -> String
fizzbuzz n = case hoge piyo (n, "") of
(n, "") -> show n
(_, s) -> s

main = putStr $ unwords $ map fizzbuzz [1..100]

0340デフォルトの名無しさん

2009/03/19(木) 16:09:35

流れに乗り遅れた予感。
特に意味はないけどモナドにしてみた。

> import Control.Monad
> import Text.Show
>
> data FizzBuzz a = FizzBuzz String | Foo a
>
> instance Monad FizzBuzz where
> FizzBuzz a >>= k = FizzBuzz a
> Foo a >>= k = k a
> return = Foo
>
> instance (Show a) => Show (FizzBuzz a) where
> show (FizzBuzz a) = show a
> show (Foo a) = show a
>
> exam :: (a -> Bool) -> String -> a -> (FizzBuzz a)
> exam f s x = if (f x) then FizzBuzz s else Foo x
>
> x /? n = (x `mod` n) == 0
>
> fizzbuzz x = return x
> >>= exam (/? 15) "FizzBuzz"
> >>= exam (/? 3) "Fizz"
> >>= exam (/? 5) "Buzz"
>
> main = forM_ [1..5] (print . fizzbuzz)

0341デフォルトの名無しさん

2009/03/19(木) 19:20:30

素直にこんなんじゃいかんの？
main = putStrLn $ unwords $ map fizzbuzz [1..100]
where
  fizzbuzz x
   | x `mod` 15 == 0 = "FizzBuzz"
   | x `mod` 5 == 0 = "Buzz"
   | x `mod` 3 == 0 = "Fizz"
   | otherwise = show

0342デフォルトの名無しさん

2009/03/19(木) 20:35:57

>>341
いいんだけど、それじゃ、盛り上がらんだろう

0343デフォルトの名無しさん

2009/03/19(木) 20:50:10

>>341
一つの関数でやるって話はずっと前から出てるだろ

0344デフォルトの名無しさん

2009/03/19(木) 20:52:39

main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[1..100],let(%)m=drop$n`mod`m*4]

0345デフォルトの名無しさん

2009/03/19(木) 22:33:04

darcsでは，かなり賢いパターンマッチを使ったパッチ当てが行われているのでしょうか

0346デフォルトの名無しさん

2009/03/20(金) 13:15:22

darcsはあなたの10倍程度賢いです

0347デフォルトの名無しさん

2009/03/21(土) 17:18:15

software designの今月号でhaskell特集(intro)しているね
http://gihyo.jp/magazine/SD/archive/2009/200904

0348デフォルトの名無しさん

2009/03/21(土) 19:18:34

>>346
ほとんど神の領域ということですねわかります

0349デフォルトの名無しさん

2009/03/21(土) 20:18:23

そうです。神にもっとも近い言語です。
Haskellを極めれば、ほかの低俗な言語がクズに思えてきます。

0350デフォルトの名無しさん

2009/03/21(土) 20:48:49

Haskellはカルト

0351デフォルトの名無しさん

2009/03/21(土) 21:42:22

一部の人だけな

0352デフォルトの名無しさん

2009/03/22(日) 04:00:10

>>349
darcsは言語じゃねーだろ、アホか。

0353デフォルトの名無しさん

2009/03/22(日) 04:08:51

┐(´ー`)┌

0354デフォルトの名無しさん

2009/03/22(日) 20:20:15

>>352
darcsは宗教だw

0355デフォルトの名無しさん

2009/03/25(水) 18:46:30

遅延評価って無敵に最強なの？なんか弱点とかないの？
Haskellの宣伝を聞いているとアホな俺がなにも考えなくてもいいのかと思えてきました。

0356デフォルトの名無しさん

2009/03/25(水) 18:48:18

遅延評価それ自体のコストが大きいこと？

0357デフォルトの名無しさん

2009/03/25(水) 18:57:05

遅延評価自体のコスト…ですか。
それは実行時、それともコンパイル時でしょうか？
コストの種類は空間的なものですか、時間的なものですか？それとも処理系の複雑さでしょうか。
たとえば再帰でいう末尾再帰のように使い方によって差がでたりするのでしょうか。

ちょっとマンガ買うかHaskellの本の買うか迷ってまして。

0358デフォルトの名無しさん

2009/03/25(水) 19:11:28

実行時に時間的にも空間的にもコストがある
時間的コストはせいぜい積極評価の場合の定数倍だけど、ボトルネックにひびくこともある
空間的コストは慣れないとまったく予測できない。マジヤバい

0359デフォルトの名無しさん

2009/03/25(水) 20:36:56

>>357
これを読むと良いよ↓
http://itpro.nikkeibp.co.jp/article/COLUMN/20070403/267180/

0360デフォルトの名無しさん

2009/03/25(水) 21:00:55

初心者質問です。

タイプ宣言の時に関数を指定できると思います。

type T = String -> String

この時の"->"は型コンストラクタなんでしょうか。しかし、

test ((->) a b) = a ++ b

こういうのはダメって怒られます。"->"は特殊な扱いなんでしょうか。
それとも私の発想がどっかおかしいんでしょうか。

よろしくお願いいたします。

0361デフォルトの名無しさん

2009/03/25(水) 22:00:07

>>360
> test ((->) a b) = a ++ b

これが可能な型コンストラクタの例をあげてみて

0362デフォルトの名無しさん

2009/03/25(水) 22:52:33

runWriter >>> (printf "\nresult : %d\n" *** debugPrint) >>> uncurry (>>) ＄ foo 10 0
(IO a, IO a)をIO aにしようと思えばこういう風に結合するしかないんでしょうか？
m(m a)や[m a]をならすjoinやsequenceみたいなものがあると思うんですが

0363デフォルトの名無しさん

2009/03/25(水) 23:00:55

結合ってのは uncurry (>>)の部分でArrowの濫用をしているというところではないです。
しかし自重してかつリスプみたいにならないで済む方法があれば教えてほしいです。
haskell初心者にありがちなポイントフリー厨になっているというところは多少自覚しておりますorg。

0364デフォルトの名無しさん

2009/03/25(水) 23:44:22

>>359
読んでみたけど、入門以前な私にはちょっと難しかったです。
fstは組み込みの演算子でタプルの先頭を取り出すと理解しましたが、
一つ目の例だと先行評価の例でもコンパイル時に(\x -> fst (sum x, product x))を(sum x)
と最適化してから実行したらどうなのかな？と思いました。要するにCでいうこんなのかなと。
int t1, t2;
t1 = sum(x);
t2 = product(x); //副作用がないなら、これコンパイル時に消えるんじゃない？簡約というのは実行とはちがうのかな。
return t1;
二つ目の例だと、(やはりCとかを仮定すると)sumとproductの引数xは同一の変数というイメージがあります。
整数のリストへのポインタみたいな感じをもっていると、遅延評価の例で
「sumが0+1+2+3+4になったときのxをproductで使える」とどう嬉しいのかイマイチです…
よくわからないので、本読んでみることにしました。最初はテンプレにあるIntroduction to Functional Programming Using Haskellというのでいい？

0365デフォルトの名無しさん

2009/03/26(木) 00:13:22

>>364
> int t1, t2;
> t1 = sum(x);
> t2 = product(x); //副作用がないなら、これコンパイル時に消えるんじゃない？簡約というのは実行とはちがうのかな。
> return t1;

コンパイル時に消えるかどうかはコンパイラの実装依存だと思うけど（GHCだとどうかはもっとエロい人、お願い）、実行時にはproduct(x)はHaskellでは評価されない、という話がそのページに書いてある。
Cでも、product(x)が副作用がないっていうことが分かっていればコンパイル時に消えるだろうけど（GCCではそんなマークがつけられたような…）、それは普通は分からないし、原則的に副作用があると仮定されている。

つまり、デフォルトでは、副作用ありだと考えていちおう実行するのがC、副作用なしだと考えて実行しないのかHaskell、ということ。
べつに、Cでもコンパイラの特殊な拡張構文とかを使って副作用なしマークを付けまくるぜ、というのであれば、この点に限ればたいして違いはないと思う。

> 二つ目の例だと、(やはりCとかを仮定すると)sumとproductの引数xは同一の変数というイメージがあります。
> 整数のリストへのポインタみたいな感じをもっていると、遅延評価の例で
> 「sumが0+1+2+3+4になったときのxをproductで使える」とどう嬉しいのかイマイチです…

これは、Cだと当然そうで、Haskellのほうがすごいわけじゃない。
ただ、Haskellへの誤解として、

(\x -> (sum x, product x)) [0..5]
=> (sum [0..5], product [0..5])
=> (sum [0,1,2,3,4,5], product [0..5])
=> (15, product [0..5]])
=> (15, product [0,1,2,3,4,5])
=> (15, 0)

という評価をしている（[0..5]が二回評価されている）という誤解がありえるから、それを否定しているわけ。
Cと同じ（というか正格評価と同じ）オーダで計算できますよ、ということ。

0366デフォルトの名無しさん

2009/03/26(木) 07:35:35

>>355は明らかに宿題だろw

0367デフォルトの名無しさん

2009/03/26(木) 20:24:39

fun of programming からの問題についての質問です。

newtype Except a b c = E(a b (Either String c))

instance ArrowChoice a => Arrow (Except a) where

↑この定義を求めよ、という問題がありますが分かりませんでした。Arrowに
Stringの例外を挿入するということなんですが、挫折しました。

どうかよろしくお願いいたします。

0368デフォルトの名無しさん

2009/03/26(木) 22:16:40

個別スレがないのでここで聞いてみますが
lazy-k(もしくはunlambda)をラムダ式にしてくれるような変換器って
どっかにないでしょうか

0369デフォルトの名無しさん

2009/03/26(木) 22:23:59

>>366
本当に興味から聞いてみたんだけど、定番の宿題だったのかな
それはすいませんでした。とりあえずPogramming in Haskellを買いましたよっと

0370デフォルトの名無しさん

2009/03/26(木) 22:47:28

>>367
書いてみた。添削希望

import qualified Control.Category
import Control.Category((>>>), Category)
import Control.Arrow

newtype Except a b c = E (a b (Either String c))

instance (ArrowChoice a) => Category (Except a) where
id = E $ arr Right
E g . E f = E $ f >>> (arr Left ||| g)

instance (ArrowChoice a) => Arrow (Except a) where
arr f = E $ arr (Right . f)
first (E a) = E $ first a >>> arr combine
where
combine (Left e, _) = Left e
combine (Right x, y) = Right (x, y)

0371デフォルトの名無しさん

2009/03/27(金) 09:43:38

riみたいにコンソールからドキュメントを参照できたらいいのになぁー
それがあればemacsからdescribe-functionとかfind-functionみたいに
コードから一発で飛ぶとかできて便利になるのに…

0372367

2009/03/27(金) 20:16:35

>>370
ありがとうございます！

0373デフォルトの名無しさん

2009/03/28(土) 14:25:12

GHC 使ってて気付いた。
breakEnd ってリストとか ByteString に使えるやつはあるんだけど、
String バージョンは無いの？

0374デフォルトの名無しさん

2009/03/28(土) 19:14:57

fromString って何の意味があんの？
read があればいらないんじゃね？

0375デフォルトの名無しさん

2009/03/28(土) 19:57:08

役割が違うだろ

read "\"foo\"" :: String
= "foo"
fromString "\"foo\"" :: String
= "\"foo\""

0376デフォルトの名無しさん

2009/03/28(土) 21:18:11

>>375
thx

0377デフォルトの名無しさん

2009/03/29(日) 01:04:31

Parsecみたいにコンビネータで柔軟に書式を構築できて
コンパイル時に書式をチェックできるようなprintfはありませんかね？
%4dみたいな数字の表現が辛いから無理なんでしょうかね

0378デフォルトの名無しさん

2009/03/29(日) 02:49:49

>>377
いいたいことがよくわからん。
コードで例を書いてくれ

0379デフォルトの名無しさん

2009/03/29(日) 12:43:42

>>377
これ?
http://www.cs.nott.ac.uk/~gmh/wgp01/hinze-paper.pdf

0380デフォルトの名無しさん

2009/03/30(月) 12:33:00

>>378
int_ @ alighLeft 3 >> ", " >> str_
から(\n s -> take 3 (show n++repeat ' ') ++ ', ' ++ ", " ++ s)
みたいな関数を返すような演算って絶対誰か考えてる筈だなと思ってました

>>379
それです
unparsingっていうんですね、その考えはありませんでした

0381デフォルトの名無しさん

2009/04/02(木) 09:28:08

GHC 6.10.2がリリースされてた。
http://haskell.org/ghc/download_ghc_6_10_2.html

0382303

2009/04/05(日) 20:47:13

>>304
どこかに forall を入れれば良いような気がしてきました

0383デフォルトの名無しさん

2009/04/12(日) 21:04:55

cabalでパッケージ入れる時にldが200mbぐらい実メモリ喰うんだけど
これって普通なの？

0384デフォルトの名無しさん

2009/04/12(日) 21:49:39

よくあること
興味があるならdocumentを作るようにして、でかいパッケージでも入れてみな
haddockが700Mとか余裕で食うから

0385383

2009/04/12(日) 23:32:02

>>384
ありがとう
仕方ないんだね

0386デフォルトの名無しさん

2009/04/15(水) 22:07:44

遅延評価勉強法ってありますが、自分の場合Javaとかはそれで学習しました
けど、遅延評価言語Haskellは何故かできませんでした。

最初は戯れ的にやってたんですが、教科書最初から読まないと結局ダメ
だったです。これって自分固有なんでしょうか。

何かHaskellとかが普及しない原因が、遅延評価勉強法が通用しない、
つまりいい意味で適当に書くことができない、ってことはないんですかね。

0387デフォルトの名無しさん

2009/04/15(水) 22:26:17

量産型あまちゃのつ

0388デフォルトの名無しさん

2009/04/15(水) 22:28:26

俺もそうだった
そもそも自分の知ってるものとぜんぜん違うものを学ぶときは教科書を最初から読むもんじゃないか？

普及しない原因の一つではあるかもな

0389デフォルトの名無しさん

2009/04/15(水) 22:30:46

新しい機能を使うのを遅延するためには、
代替手段として古い機能が残されていなければならないからね。

0390デフォルトの名無しさん

2009/04/15(水) 22:50:08

真の遅延評価であれば、Haskellが必要になるまで勉強しない

つまり、一生しないわけだが

0391デフォルトの名無しさん

2009/04/16(木) 00:21:12

悲しいこと言うなよ

0392デフォルトの名無しさん

2009/04/16(木) 09:24:29

俺はここの機能はJavaのアレと比べてどうなんだ！って興味から入ったな
型推論とか、継承とパターンマッチとか、型クラスとか、
そういうとこから入って最終的にモナドがどうのとかやってた。
ちょうど大学で離散数学をやってたのもいい刺激になった。

遅延評価勉強法といってもコード書かないと勉強したことにならんわけではないので
そういうのでもいいんでないかな？

0393デフォルトの名無しさん

2009/04/16(木) 20:11:43

>>388
確かに最初に概要を知らないと手がつけられないというのはあると思います。

だけど、Haskellの場合は何か違うんですよね。本当にちゃんと教科書を最初から
読んで、知識を積み重ねていかないとダメだったんです。他の言語の場合は
適当に概要を流して、あとは作っていきながら覚える、って感じだったんですけど。

0394デフォルトの名無しさん

2009/04/16(木) 20:28:43

IOまでの道のりが長いからかな

0395デフォルトの名無しさん

2009/04/16(木) 20:43:45

俺はモナドまでわかって初めて教科書開いたけど。
これまでの言語の知識が無駄になるわけじゃないよ。
俺にとって初めての関数型言語だったけど、いままでの言語の延長線上にみえるものでもあった。

例えばだけどオブジェクト指向なのでよくいわれるような、
「部品の再利用性」の概念がわかっていれば高階関数の便利さはわかる。
http://www.sampou.org/haskell/article/whyfp.html

0396デフォルトの名無しさん

2009/04/16(木) 20:54:47

>>394
そもそもHello, Worldって言語ごとに癖の強い部分が出るから困る

CのHelloWorldは可変長引数だし、
C++のHelloWorldは変態な演算子オーバーロードだし、
C#やJavaのHelloWorldはドット大杉クラス変数だし
ほかの言語も文だったり式だったり関数だったりメソッドだったり。

0397デフォルトの名無しさん

2009/04/16(木) 21:01:17

ついでにstd::coutとかがグローバル変数になっているのも
レジストリがどうのとか特殊な方法で実装されているもので、
その点ではHaskellのprintStrLnとかとどっこいのような気がする

0398デフォルトの名無しさん

2009/04/16(木) 23:49:05

>>395
Lispなどの経験者じゃなくて、CやJavaからHaskellで「遅延評価勉強法」ができた、
というのは凄いと思います。

自分が教科書をきちんと読もう、と決意したのは、Haskellの記述方法云々では
なくて、例えばfoldって何なんだとか、そういう関数型文化を知らなかったから
というのはあります。

ただ、それだけじゃなくて、関数型でコード書く場合には宣言的であることを強要
される感じがするんですよね。例えば中学生が文章題の数学の問題解く場合に、
文書に従った手続きは分かっても、そこに書かれていることを方程式にせよ、
って言われた途端に思考停止する子とかいますよね。

Haskellで書くときはそういう感覚になります。そうなると、適当にずらずら書くことは
不可能で、きっちり勉強してないと難しいと思うんですがどうなんでしょうかね。
敷居の高さはその辺にあるんじゃなかろうかと思うんですが。

0399デフォルトの名無しさん

2009/04/17(金) 00:18:47

全てが副作用無しである必要はないと思うんだよ
ピンポイントで正しいと判定できれば
モナドみたいな屁理屈使って無理矢理全てに適用するなんて
ナンセンスだと思うね

0400デフォルトの名無しさん

2009/04/17(金) 00:27:20

命令的なコードを書くならモナドがあれば十分なのに、副作用なんていう謎なものを持ち出すのがナンセンスだよ

0401デフォルトの名無しさん

2009/04/17(金) 00:33:11

関数適用を入れ子にすることをずらずら並べると言おうと思えば言えるけど、そういうことじゃない？

宣言的かどうかという面でいえばオブジェクト指向だって(手続き型と比べれば)宣言的だよね。
そうするとまともなオブジェクト指向も敷居が高いといえるのかな？(オブジェクト指向言語を手続き型的に使ってる？)

0402デフォルトの名無しさん

2009/04/17(金) 00:36:39

>>399
>ピンポイントで正しいと判定できれば
そのためにunsafeな関数やFFIが用意されてると思うんだけど

0403デフォルトの名無しさん

2009/04/17(金) 00:54:29

IOモナドがモナド則(associativity)を満たしているというのがいまだに腑に落ちない

0404デフォルトの名無しさん

2009/04/17(金) 01:08:23

>>401
まぁ、関数型でもそう書けるとは思いますが、難しくないですか。

あと、仰る通りでオブジェクト指向で綺麗に書けているコードは宣言的ですね。
だけど、これをいきなり書け、って入門者が言われれば敷居は高いんじゃ
ないでしょうか。Javaなどはその辺の逃げ道がいくらでもあるわけです。
Haskellには逃げ道無いんですよね。

0405デフォルトの名無しさん

2009/04/17(金) 01:09:02

副作用を許す→等式推論が死ぬ程難しくなって初心者お断り度がさらにうp

0406デフォルトの名無しさん

2009/04/17(金) 01:51:48

>>403
上手く言葉が整理できないんだけど。

手続き型言語のIOを例えるなら、
虫籠を用意して、クワガタを取りに行くようなものになる。
この場合、クワガタを取りに行って虫籠を用意するのはおかしい。
副作用があるばあい、順番が変わるとおかしなことになるってわけだ。

そこで、IOモナドは評価された瞬間に副作用のある行動はせず、
副作用のある行動の予定をリストにし、bindによってその予定リストを構築する。つまり、

「() -> IO 虫籠」>>=「虫籠 -> IO クワガタ」

のようなIOモナドは、内部では、

「((), 空の予定リスト) -> (虫籠, [虫籠を用意する予定])」>>>
「(虫籠, [虫籠を用意する予定]) -> (クワガタ, [虫籠を用意, クワガタを取りに行く予定])」

おそらくこんな感じになっているので、
前の関数から簡約されても、後ろの関数から簡約されても結果は同じになり、
[虫籠を用意する予定, クワガタを取りに行く予定]が最終的な予定リストになる。

この予定リストをプログラム終了後に手続き的な処理系に渡して実行すればIO処理ができる。

0407デフォルトの名無しさん

2009/04/17(金) 02:27:32

>>406
その例でループや条件分岐が発生したら
どこに組み込まれるんですか？

虫籠みつかったY→クワガタ取りにいく
N
↓
探しなおす

0408デフォルトの名無しさん

2009/04/17(金) 04:10:45

人工知能用語でいうところの状況計算

0409デフォルトの名無しさん

2009/04/17(金) 19:59:18

>>407
条件分岐やループが入ってくると>>406みたいな予定リストのアナロジーでは説明が付かなくなるな

IOモナドがモナド則でいう結合律を満たすのって、副作用のある言語でも関数合成が結合律を満たすのと同じことじゃね、と思って、
comp :: (b -> IO c) -> (a -> IO b) -> a -> IO c
の結合性を仮定して
a >>= b = comp b (const a) ()
がモナド則を満たすことを証明できるかと思ったけど俺には無理だった

0410デフォルトの名無しさん

2009/04/17(金) 20:38:18

>>409
じゃ、LispのS式のようなものはアナロジーにならないかな。
HaskellにとってS式はただの木構造でしかないわけで、どこから作っても同じS式が出来上がる。
S式の評価順序には意味があるけれども、それはHaskellとは別の処理系が実行するから全然問題ない。

あとさ、関数合成がある言語でも副作用のある関数を使えば結合則は満たさないよ。

0411デフォルトの名無しさん

2009/04/17(金) 20:39:23

IO aをState RealWorld aとして
StateMonadがmonad lawを満たすことを利用してすれば証明できそうな気がせんでもない
もう少し考えるわ…λ

分岐やループはArrowを持ち出すとなんとかなるのかな？

0412デフォルトの名無しさん

2009/04/17(金) 21:08:10

>あとさ、関数合成がある言語でも副作用のある関数を使えば結合則は満たさないよ。
結合則が破られる例ある？

0413デフォルトの名無しさん

2009/04/17(金) 21:41:36

関数合成の結合則って
(f . g) . h = f . (g . h)でしょ？
両辺ともf(g(h x))に簡約されるんだから、これが同じ値にならないってのは
結合則とか関係なしに単に参照透明性を持たないってだけなのでは？

0414デフォルトの名無しさん

2009/04/17(金) 22:24:13

難しいこと考えるの好きだよな

0415デフォルトの名無しさん

2009/04/18(土) 13:43:56

モナドごてごてでも良いからＤｅｌｐｈｉみたいなＲＡＤ環境がＨａｓｋｅｌｌにも欲しいです。
Ｈａｓｋｅｌｌで楽にWindowsアプリの開発できる日は・・・来ないですよね・・・orz
あと、標準でＵＴＦ－８（Ｓｈｉｆｔ－ＪＩＳとまでは言わないから・・・)表示できるようになって欲しい・・・

0416デフォルトの名無しさん

2009/04/18(土) 14:21:58

>>415
作ってる人はいるよ。
Eclipseのプロジェクトとかなかったっけ？

0417デフォルトの名無しさん

2009/04/18(土) 15:13:38

本当ですか?
詳しく教えてもらえると助かります。
今はWindowsＧＵＩはＣ＃で作ってますが、Haskellで統一できるならそうしたいです＞＜

0418デフォルトの名無しさん

2009/04/18(土) 15:48:23

インタラクティブなプログラムを書きたいならHaskellはまだ準備不足だと思うねぇ。
まだHaskellは下地作りの段階で、実用としてバンバン使っていける段階じゃないよ。
だいたい方向性が定まったぐらいの段階かな？
並列・並行処理路線ってやつ。

0419デフォルトの名無しさん

2009/04/18(土) 15:51:00

いつそんな路線が決まったんだｗ

0420デフォルトの名無しさん

2009/04/18(土) 16:55:04

DelphiみたいなRADじゃないけど、gtk2hs+gladeじゃダメ？
Unicodeに関してはData.TextチームがStream Fusionを使ったライブラリをリリースしたよ
まだ実用としてバンバン使うわけにはいかないけど

0421デフォルトの名無しさん

2009/04/18(土) 17:08:24

＞＞４２０
RADじゃないGTK２ｈｓは名前は知ってるんです。
時間が有れば勉強してみるつもりですが・・・
結局コードをゴリゴリになりますし、手続き的なコードがまる見えなので・・・・
RADならそういうコードが見なくて済むのに・・・と＾＾；
やっぱりRADはまだ無いですよねぇ＾＾；

＞＞４１８
まだ実用的なのは作れないでしょうけど、どうせ私は趣味でやっているのでお遊びのゲームアプリとか作るのにDelphiみたいな環境で作れたら積極的に作っていこうと考えていたんですけど・・・
やっぱりVisualC#やDelphiでメインで開発してHaskell+GTK2hsは勉強用になりそうですね＾＾；

0422デフォルトの名無しさん

2009/04/18(土) 17:35:13

全角に寛容な涼スレ

0423デフォルトの名無しさん

2009/04/18(土) 17:44:57

>>418
あ、実用的じゃないのはUnicodeの方もでしょうか?
だから自己責任で手動で入れろと言うことなんでしょうかね?
私が言いたかったのは標準で(何も入れなくても）Unicodeで日本語が表示できる日はまだかなぁ・・・と^^;

0424デフォルトの名無しさん

2009/04/18(土) 22:23:27

RADはいらんが、ステップ実行できるデバッガが欲しい

0425デフォルトの名無しさん

2009/04/18(土) 22:49:02

なんて手続き型なw

0426デフォルトの名無しさん

2009/04/18(土) 22:58:41

GHCiぐらいまともに使いこなせ

0427デフォルトの名無しさん

2009/04/19(日) 01:10:04

>>424
もうあるよ

0428デフォルトの名無しさん

2009/04/19(日) 20:52:18

Hindley-Milnerよりも理論的に良い型システムってありますか？
これを拡張したら
何となく、主型が一意に決まらなかったりしそうに思うけど

0429デフォルトの名無しさん

2009/04/21(火) 14:56:53

個人的にlispに浸かるのが嫌なのでemacsを越えようと頑張ってるYiに期待している。
キーバインドがemacsモードとviモードと選択できるのも面白い。
シンタックスハイライトの書き方とかドキュメントがもっとあれば弄ってやりたいけど、まだまだHaskellを操れないから指咥えて見てる。

0430デフォルトの名無しさん

2009/04/21(火) 23:02:46

ごめんなさい。
Yiを知らないのですが、Lispに浸らないなら、何に浸るのでしょう?
まさか、Haskellに浸れるのでしょうか?
だったら私も応援したいです＞＜

0431デフォルトの名無しさん

2009/04/21(火) 23:03:49

Yi で ESC キーをメタキーに設定するやりかたがわからないおれはまけぐみ

0432デフォルトの名無しさん

2009/04/21(火) 23:26:01

VC2005 C++/CLIの構造体の構文が知りたいです。

strcut A {
Int32 hoge;
String^ moe;
};

は構文エラーでしょうか？
定義する場所も知りたいです。

0433デフォルトの名無しさん

2009/04/22(水) 00:27:01

>>430
http://code.google.com/p/yi-editor/

0434デフォルトの名無しさん

2009/04/22(水) 02:11:39

HSDLもhsSDLもビルドは出来て、ライブラリのインストールまでは出来てるんですが、
リンカエラーが出ていて困っています。

E:/test/hoge.o(.text+0xb21):fake: undefined reference to `__stginit_hsdlzm0zi2zi0_MultimediaziSDL_'

やったことは、こんな感じです。

①cabalの修正(includeとかlibとか)
②runghc setup.hs configure
③runghc setup.hs build
④runghc setup.hs install
⑤↓これをコンパイル

import Multimedia.SDL
main = putStrLn "hoge"

更に、他の関数も色々使い始めると、リンクエラーとして、こんなものも出てきます。
E:/test/hoge.o(.text+0x98e):fake: undefined reference to `hsdlzm0zi2zi0_MultimediaziSDLziInit_sdlQuit_closure'

コンパイル環境はこんな感じです。
GHC 6.8.3 SDL 1.2.11 / 1.2.12 / 1.2.13
GHC 6.10.2 SDL 1.2.13

このエラーに何か心当たりある人いませんか？

0435デフォルトの名無しさん

2009/04/22(水) 02:17:14

>>434
コンパイルオプションに" --make"を入れても駄目？

0436デフォルトの名無しさん

2009/04/22(水) 02:22:18

>>435
まさしくそれでした(；´Д｀)　ありがとうございます。
--make入れないとライブラリ見に行ってくれない、っていうことでしょうか…。

0437デフォルトの名無しさん

2009/04/22(水) 02:53:21

--make使わないならリンク時に-packageオプションが必要なんじゃなかったっけ

0438デフォルトの名無しさん

2009/04/22(水) 20:56:30

Yiもいいかもしれんがleksahもいいな。
forall aと打ったら∀ aと表示される。
++は⊕になるし>>としたら≫になるし>>=は↠になる。
ソースコード開いたら数学記号が出てきて一瞬ビビるが、中々面白い試み。

0439デフォルトの名無しさん

2009/04/22(水) 23:15:50

試したいんだけど
leksah: error: a C finalizer called back into Haskell.
use Foreign.Concurrent.newForeignPtr for Haskell finalizers.

って出て落ちちゃうんだよね…orz

0440デフォルトの名無しさん

2009/04/23(木) 01:03:45

>>438
言われて気づいた。
\x -> は、λx →になんのね。

0441デフォルトの名無しさん

2009/04/23(木) 14:29:02

darcs headだと落ちないみたい
でも表示変えるぐらいならemacsでもできる

0442デフォルトの名無しさん

2009/04/24(金) 00:26:19

cygwinからhaskell-mode使ってる人いますか？
C-c C-lで渡されるCygwinのパスをghciが認識しないため
:loadでエラーが出るのですが
なんかいい解決策ありますかね
elispわからないので
cygpathについて調べて.emacsやらを改良するってのは
私には無理そうです

0443デフォルトの名無しさん

2009/04/24(金) 02:45:43

ググって解決しました
inf-haskell.elに追加
(defun get-cygwin-path (x) "translate cygwin path into windows path"
(let* ((x (concat "cygpath -wa " "\"" x "\""))
(y (shell-command-to-string x))
(z (substring y 0 (- (length y) 1)))
(w (replace-regexp-in-string "\\\\" "/" z)))
w))
;haskell-load-file関数の以下の箇所を修正
;(file buffer-file-name)
(file (get-cygwin-path buffer-file-name))

0444デフォルトの名無しさん

2009/04/25(土) 10:19:34

>>438
emacsのhaskell-modeでもできる。
customizeでhaskell-font-lock-symbolsをunicodeにすると、
not が￢
-> が →
<- が ←
=> が ⇒
~> が ⇝
-< が ↢
:: が ∷
. が ○
forall が ∀
になる。

0445デフォルトの名無しさん

2009/04/25(土) 10:42:04

はいはい APL APL

0446デフォルトの名無しさん

2009/04/26(日) 20:21:19

Haskell基礎的なものは一応勉強したんですが、実際のコードとか見ると、結構
GHCの型関連のオプションが必要になりますよね。

こういったオプションに関する資料でよくまとまったものが読みたいのですが、
GHCのドキュメント以外には何かよいものはありますでしょうか。

0447デフォルトの名無しさん

2009/04/26(日) 20:43:09

haskell wiki

0448デフォルトの名無しさん

2009/05/03(日) 20:46:04

foldr1 f . g = foldr1 h
という合成で、
h x y = foldr1 f (g [x,y])
と置けばなんとなくできそうな気がするんですが、
これがどういう時に成り立つかまでが出せません

とりあえず g[x] = [x]は出るんですが、残るfとgを両方含む等式では
何度計算しても
g (x:xs) = g [x, foldr1 f (g xs)]という変な式しか出ません

[x]と(x:xs)を放り込んで簡約していく以外の方法で簡単に出せるものがあるなら紹介してください
よく知りませんがhyloとか言うのを使えば楽に出せたりするんでしょうかね？

0449448

2009/05/03(日) 21:54:32

ちなみに出展はIntroduction to Functional Programming Using Haskellの137ページ4.6.8です。
この章の他の問題はなんとか解けたんですがこれだけさっぱりわかりません。

とりあえず、この問題
foldr1 f . scanl1 g = foldr1 hという合成をする為に
foldr1 f . g = foldr1 hという式を導き出すという方針でいける筈ですが、
この式が出せないという…

0450デフォルトの名無しさん

2009/05/03(日) 22:16:40

質問の意味が分からない
何かを求めたいの？何かを証明したいの？

0451448

2009/05/03(日) 22:38:03

>>450
わかりにくかったようですねすいません

一言で言ってしまえば、

foldr1 f .g = foldr1 hにおいて、
この式が成り立つ条件ってのを求めるのが目標です

あと、その定めた条件下でこの式がなりたつことの証明もやりたいです

0452デフォルトの名無しさん

2009/05/04(月) 01:30:08

うーん・・・
いわゆるVector3とかを定義するにはどうするのがよいですかね？

data IVector3 = IVector3 Int Int Int

みたいに定義することも出来るし演算も定義は簡単だけれど
この方法だと次元ごとにデータ型を特殊化しなきゃならなくて美しくなさすぎる…

といってリストとかタプルじゃ根本的解決にならないしなぁ

0453デフォルトの名無しさん

2009/05/04(月) 01:34:31

>>452
タプルが普通だと思う
名前がつけたいならtypeとかnewtypeとかすればいいじゃん

0454デフォルトの名無しさん

2009/05/04(月) 10:30:12

{-# OPTIONS -fglasgow-exts #-}
data Z
data S n

data Vec len where
Nil :: Vec Z
(:::) :: Int -> Vec l -> Vec (S l)

infixr 1 :::

instance Show (Vec Z) where
show _ = "[]"

instance Show (Vec n) => Show (Vec (S n)) where
show (i ::: v) = show i ++ ":" ++ show v

0455デフォルトの名無しさん

2009/05/04(月) 19:04:35

>>454
Vec上のfilterにはどんな型がつくんですか？

0456448

2009/05/05(火) 02:04:14

foldr1 f . g = foldr1 hというものに拘らずに、直接foldr1 f . scanl1 g = foldr hを計算したら
h x y = f x (g x y)かつ
x * (y + (y * z)) = (x * y) + ((x * y) * z) where (+) = f ; (*) = g
すなわちgがfに対して分配でき、かつgが結合的であるとき
という条件が出てきました(当然、対象になるリストが非空であるときというのも条件です)

これはfoldr1 f . scanl g = foldr h eという合成のときの条件とほぼ同じで、かつ
fにmax, gに+を代入すると+両辺ともにx+y+zになり4.6.9で使える結果となり
それっぽいなとは思うのですが、いまいち釈然としませんね
「fusion law of foldr1」はどこに行ったのでしょうというか…

0457デフォルトの名無しさん

2009/05/05(火) 03:19:27

>>452
つ[Array]

0458448

2009/05/05(火) 08:26:56

zが負のときを忘れてました
でもy<0 -> x `max` (x+y) = xを使うと両辺ともx+yに簡約され
f = max, g = (+)のとき件の規則による書き換えが有効ってことには違いありませんね

0459デフォルトの名無しさん

2009/05/13(水) 12:10:04

haskellで不便だと思う分野って何？
その辺のライブラリを勉強で作ってみようと思うんだけど
GUIとか？

0460デフォルトの名無しさん

2009/05/13(水) 22:24:08

>>459
手続き的なことをやりにくいこと

0461デフォルトの名無しさん

2009/05/13(水) 22:34:02

>>459
俺には理解できないこと

　　　　　　　　　　　　　俺　　　　　　　バカ　　　普通　　ハッカー　ウィザード
　　　　　　　　　　　　　┝　-　-　-　-　┿━━━┿━━━┿━━━┥
　　 ∩＿＿＿∩　　　/)
　　 | ノ　　　　　ヽ　 ( i )))
　　/　　●　　　● | /　/
　 |　　　　( _●_)　 |ﾉ　/　　　ここら辺クマ……
　彡､　　　|∪|　　　　,/
／　　　　ヽノ　　　/

0462デフォルトの名無しさん

2009/05/13(水) 22:45:22

>>459
コンパイルが遅いこと
GCばかりすること

0463デフォルトの名無しさん

2009/05/13(水) 22:53:35

コンパイルの遅さやＧＣの頻発はライブラリで解決するものなの？

0464デフォルトの名無しさん

2009/05/13(水) 23:02:18

>>461
一般人＜バカ＜普通＜神＜ハッカー

ウィザード？は？

0465デフォルトの名無しさん

2009/05/14(木) 01:16:27

>>463
ライブラリはむしろ、それらに依存するものだよ。

0466デフォルトの名無しさん

2009/05/14(木) 01:26:24

>>459
yi 用 plugin の has2ch

0467デフォルトの名無しさん

2009/05/14(木) 02:22:16

ライブラリじゃないんだけど、
haskellのsource file の保存場所を指定する仕組みが欲しい。

cabal で、package 毎に階層のTopを指定するとか、
.hiファイルに元ファイルの場所を書き込んでおくとか。

cabal install でソースも一緒にインストールしてくれると楽なんだけど。

0468デフォルトの名無しさん

2009/05/14(木) 10:13:38

HXT格好いいですね
directoryのtraverseも同じようにArrowTreeを使って抽象化できないものなんでしょうかね？

0469デフォルトの名無しさん

2009/05/17(日) 15:32:29

yiってemacsおきかえるぐらい発展しそうですか

0470デフォルトの名無しさん

2009/05/17(日) 16:15:49

committerがemacsと同じくらいの人数まで増えればあるいは…

0471デフォルトの名無しさん

2009/05/17(日) 22:06:23

↓こんな感じのモナドつくってみたんだが、200MBくらいのファイル読んだだけでスタックが溢れる(´Д｀;)
なんかうまく回す方法ないでしょうか…

mapper :: [(Int, String)] -> WriterT (D.DList String) IO (M.Map Int Int)
mapper [] = return M.empty
mapper ((n,cs) : rest) =
　　if cs == "" || not (all isNumber cs)
　　　　then tell (D.fromList ["Impurt Error at line : " ++ show n]) >>
　　　　　　　mapper rest >>= \result -> return $ (-1, 1) `upsert` result
　　　　else mapper rest >>= \result -> return $ (read $ cs :: Int , 1) `upsert` result
　where
　　upsert (k, v) m =
　　　　if k `M.member` m then M.updateAt (\k' v' -> Just $ v'+v) k m
　　　　else M.insert k v m

newtype DList a = DL {unDL :: [a] -> [a]}
append xs ys = DL (unDL xs . unDL ys)
empty = DL id
instance Monoid (DList a) where

　　mempty = empty

　　mappend = append

0472デフォルトの名無しさん

2009/05/18(月) 11:10:16

appendの定義をundefinedにしてもスタックオバ風呂になったから
mapperの方にも問題はありそう
特にrec >>= fてのから危険な臭いがする
とりあえず、foldl'で書くことを試してみてはどうだろうか？

0473デフォルトの名無しさん

2009/05/18(月) 16:02:02

>>471
updateAt の第2引数はマップ内のレコード番号でキーとは違うけど、それはわかってるかな？
本当は insertWith (+) k 1 じゃない？そうだと（つまり数字の出現回数をカウントしたいんだと）
したら、素直に頭から処理する末尾再帰の形にすればいいと思う。いまのだと>>472の言うように
mapper rest のせいで入力レコード数分スタックを積んじゃってるから。

0474471

2009/05/18(月) 20:55:27

>>472,473

あー理解できました
わざわざトレースしてくれてありがとう

とりあえず（insertWith (+) k 1に直したうえで） foldl' で (M.empty, D.empty) に畳み込んだらうまくいったので
明日は末尾再帰を試してみます

0475デフォルトの名無しさん

2009/05/19(火) 00:23:09

Haskellは宣言的言語でhowでなくwhatを書く、
とかいいだしたのは誰なのかしら？

0476デフォルトの名無しさん

2009/05/19(火) 00:26:03

そんな当たり前のことを誰が言ったか気にする人いるの？

0477デフォルトの名無しさん

2009/05/19(火) 00:42:26

コロンブスの卵

0478デフォルトの名無しさん

2009/05/19(火) 04:20:13

ブスの卵

0479デフォルトの名無しさん

2009/05/19(火) 04:50:22

当たり前どころか嘘じゃね？

0480デフォルトの名無しさん

2009/05/19(火) 06:19:39

>>479
お前は馬鹿か？
どこがどう嘘なのか言ってみろ

0481デフォルトの名無しさん

2009/05/19(火) 09:58:07

HowじゃなくてWhatっていうのはHaskellじゃなくて
Haskellを含む関数型言語のコミュニティに強い影響を与えている
Bird-Merteens formalismという考え方における目標なんじゃないのかな？

0482デフォルトの名無しさん

2009/05/19(火) 16:01:17

>>481
だけど、Haskellの最初の10年くらいの大方の評価は
「Prologに似ている関数型言語」だよ。その時点で
宣言型で誰も文句はなかったんじゃないの？

0483デフォルトの名無しさん

2009/05/19(火) 17:21:20

> Prologに似ている

初耳

0484デフォルトの名無しさん

2009/05/19(火) 17:35:02

>>483
遅延評価のKRCがそっくりだったから。その後、統合して
Haskellが出てきたと受け止められた。あっPrologに似てるな
というのが私や仲間の印象だった。

0485484

2009/05/19(火) 17:42:12

ごめん。KRCがHaskellに似ているのではなくてPrologに似ていた。
いまErlangを見るより、KRCの方が似て見えた。その流れだと
Haskellは受け取られ、先入観もあるかもしれないが、あっやっぱり
Prologに似てるなと思った。

0486デフォルトの名無しさん

2009/05/19(火) 19:09:19

>471-474

のやりとりをみると、宣言的？となる気持ちはわかる。
まあprologでも大差ないが。

0487デフォルトの名無しさん

2009/05/19(火) 19:28:51

普通の人はMirandaやGoferと似ていると思っただろ。
Prologとか斜め上すぎ。

0488デフォルトの名無しさん

2009/05/19(火) 19:44:12

>>487
そりゃ、普通の人じゃなくて関数型言語の研究者でしょ。

0489デフォルトの名無しさん

2009/05/19(火) 19:52:28

で、こん中でMirandaでプログラム書いたことある人ってどんくらいいるの？

0490デフォルトの名無しさん

2009/05/19(火) 20:10:01

>>489
実際に動かしたことはないけどワドラーの「関数プログラミング」読みながら
コード書いたことはある
そのときPrologに似てると思った。パターンマッチングのせいだろうけど

0491デフォルトの名無しさん

2009/05/19(火) 21:15:26

論理プログラミングや関数型プログラミングは、宣言的プログラミングの
サブカテゴリだぞ。

0492デフォルトの名無しさん

2009/05/19(火) 22:38:37

foldl' でもまだループごとに未評価の式（マップへのインサート）が溜まってる模様
（Mapをつくる関数は無事に終了するもののその後Mapを評価しようとするとスタックオーバーフローに）

↓最終的にこんなんつかったらどうにかなりました

import Control.Parallel.Strategies

instance NFData (DList a) where rnf = \_ -> ()

foldlRNF f acc xs = helper acc xs
　where
　　 helper a [] = a
　　 helper a (x:xs) = helper a' xs

　　 where a' = f a x `using` rnf

0493デフォルトの名無しさん

2009/05/20(水) 01:54:02

>>489
処理系買ったよー

0494デフォルトの名無しさん

2009/05/20(水) 08:29:24

>>489
学部生のときMirandaネタで卒論書きました。

0495デフォルトの名無しさん

2009/05/20(水) 11:20:05

入力されたテキストの、行頭の１つ以上連続した半角スペースを
同じ数の半角の　＆ｎｂｓｐ；　という文字列に置き換える
…ってHaskellで書くとどうなりますか

0496デフォルトの名無しさん

2009/05/20(水) 12:23:58

main = interact $ unlines . map processLine . lines

processLine :: String -> String
processLine ln = nbsps ++ rest
where
(ws, rest) = span (==' ') ln
nbsps = concat $ map (const " ") ws

0497デフォルトの名無しさん

2009/05/20(水) 20:34:13

このスレの平均年齢って？

0498デフォルトの名無しさん

2009/05/20(水) 20:39:38

大学学部生以下お断り

0499デフォルトの名無しさん

2009/05/20(水) 22:17:26

>496
を～、知らない関数がたくさん…読み込んでみます

0500473

2009/05/21(木) 06:09:01

>>492
モナドなし、再帰版。出力の形式はWriterTのように計算結果とログのタプル（ペア）です。

mapper :: [(Int, String)] -> (M.Map Int Int, String)
mapper seq = let res = mapperHelper seq M.empty (D.fromList "Log:\n") in
(fst res, D.toList $ snd $ res)

mapperHelper :: [(Int, String)] -> (M.Map Int Int) -> (D.DList Char) -> (M.Map Int Int, D.DList Char)
mapperHelper [] mon log = (mon, log)
mapperHelper ((n, cs) : rest) mon log = mon `seq`
if (all isNumber cs)
then
mapperHelper rest (M.insertWith'(+) (read cs :: Int) 1 mon) log
else
mapperHelper rest (M.insertWith' (+) (-1) 1 mon) (log `mappend` D.fromList ("Error at line " ++ show n ++ "\n"))

0501デフォルトの名無しさん

2009/05/21(木) 12:09:21

>>499
これはそんなに難しくないよ。

main は標準入力から受けたテキストを、
1. 行ごとに分けて (lines)
2. 各行を変換して (map processLine)
3. 各行をつなげる (unlines)

processLine は一行のテキストを変換するわけだけど、
1. 先頭からのスペース続きの部分と、それ以降の残りの部分に分けて (span (== ' ') ln)
2. スペースの部分を   に変換して (concat $ map (const " ") ws)
3. 変換したところ (nbsps) と残りの部分 (rest) を繋げる (nbsps ++ rest)

0502デフォルトの名無しさん

2009/05/21(木) 22:02:22

放り出してたところに回答が…
ありがとうございます(｀・ω・´)

いろいろ連れ回して再帰するってのが手続き脳にはつらいんだなあ、と実感

0503473

2009/05/21(木) 23:33:16

末尾再帰最適化というのはgotoをカッコ良さげに読んでみただけです。
haskellのlazinessやモナドの合成と相性が悪いのでそこは気をつけないといけませんが。

0504デフォルトの名無しさん

2009/05/22(金) 00:21:17

>>496 は今後投稿する時に使わせてもらうか
いや俺の場合、今までもPythonでやってたけど…。

0505デフォルトの名無しさん

2009/05/22(金) 08:14:15

バイナリファイルのパーサーで効率よい方法ないですかね？
C言語なら構造体ぶち込んで終了みたいなところが結構だるいんですが…

struct Hoge
{

data Hoge = Hoge Word32 Word32 [Word16]

0506デフォルトの名無しさん

2009/05/22(金) 08:19:15

>>503
？？
一般に末尾再帰の形になっていたほうがlazy evaluationと相性よくないか？

0507デフォルトの名無しさん

2009/05/22(金) 08:20:19

うお途中でEnterしてしまったorz

//C
struct Hoge {
　　DWORD a;
　　DWORD b;
　　WORD c[16];
};

Hoge hoge;
fread( &hoge, 1, sizeof(hoge), file );
もしくは
fread( &hoge.a, 1, sizeof(DWORD), file );
fread( &hoge.b, 1, sizeof(DWORD), file );
fread( &hoge.c, 16, sizeof(WORD), file );

//Haskell
data Hoge = Hoge Word32 Word32 [Word16];

parseHoge :: [Word8] -> Hoge
parseHoge = ???

Cの後者の書き方のような場合、fileの中で状態を持ってるから上手くいくんだろうけど、
そういう書き方に相当するのをHaskellでやるならモナド使えってことなのかな

0508デフォルトの名無しさん

2009/05/22(金) 08:32:00

>>507
俺なら面倒だからパターンマッチでやっちまいそうだw

0509473

2009/05/22(金) 08:44:48

>>506
lazy evaluation になっていると末尾再帰最適化されないということです。
端的にいえばこういうこと：
http://stackoverflow.com/questions/412919/how-does-haskell-tail-recursion-work

0510デフォルトの名無しさん

2009/05/22(金) 09:55:22

>>509
末尾再帰の最適化はされてるよ
その例でスタックが溢れるのは別の問題

もし末尾再帰の最適化がなされないなら、$!を使った例でもスタックが溢れるはず

0511473

2009/05/22(金) 11:19:42

「末尾再帰最適化されない」というのは誤解を招く表現だったかな。
表面上は末尾再帰最適化手続きによって関数呼び出しが平坦化されても、再帰の際の引数の
変形がlazinessによって結局スタックに積まれてしまい本質的な計算としては最適化されて
いない、ということです。

0512デフォルトの名無しさん

2009/05/22(金) 13:49:28

>>496 ってわざとわかりにくくしてるの？
それともHaskell に慣れるとこんな感じのソースの方がわかりやすいの？

↓こっちの方がよっぽどわかりやすいと思うのは私が初心者だから？
main = interact $ unlines . map f. lines

f:: String -> String
f(' ':xs) = " " ++ (f xs)
f s = s

0513512

2009/05/22(金) 13:53:07

ああ、 がスペースになっちゃった。
こう↓ね

f(' ':xs) = " " ++ (f xs)

0514512

2009/05/22(金) 15:26:12

補足
「わざとわかりにくくしてるの？」の意図は、たとえば、

A.わかりにくいけど、いろいろなテクニックを披露するためにあえてそうした
B.わかりにくいけど、処理の効率化を考えてあえてそうした

などの場合です。

0515デフォルトの名無しさん

2009/05/23(土) 03:39:28

>>512
それじゃ先頭のスペースしか変換されないよ

0516デフォルトの名無しさん

2009/05/23(土) 03:41:35

>>511
それこそlazinessのおかげで複雑な式が残らずに済むのだが？

0517デフォルトの名無しさん

2009/05/23(土) 04:33:48

>>512
確かにそっちの方が単純で読みやすい気がする
でもまあ好みじゃね？俺はできれば再帰を使いたくない

>>496は、お題を読んで最初に思いついた通りに書いただけ
>>512の書き方には思い至らなかった

0518デフォルトの名無しさん

2009/05/23(土) 06:35:18

>>516
おぬし・・これがスタックオーバーフローの話だったことを忘れてはおるまいな？

0519デフォルトの名無しさん

2009/05/23(土) 17:25:24

最近関数型言語を勉強している者ですが、
パターンマッチとif文、case文の使い分けがよくわかりません。

基本的にif文で書ける者は全部パターンマッチで書ける気がします、
どう使い分けしたらいいですか?

0520デフォルトの名無しさん

2009/05/23(土) 17:30:03

ifを使った方が書きやすい/読みやすいと思ったときに使えばいい
所詮構文糖

0521デフォルトの名無しさん

2009/05/23(土) 17:46:49

>>519
こうしろと言うことはないし、どういう書き方をしても恥ずかしくない。
ただ、なるべく短く書くのがカッコイイ、再帰を使うのはダサイ、ポイントフリースタイルだとカッコイイという風潮はあるかもね。

0522デフォルトの名無しさん

2009/05/23(土) 18:37:18

>>521
ない。

0523デフォルトの名無しさん

2009/05/23(土) 18:40:41

＞なるべく短く書くのがカッコイイ、再帰を使うのはダサイ、ポイントフリースタイルだとカッコイイという風潮はあるかもね。

こういう人が「Haskellは直感的に書けるから！！！」

とか言いながら全く直感的じゃないコードを量産してるんだろうなwwwww

0524デフォルトの名無しさん

2009/05/23(土) 18:52:58

>>522
ある。

0525デフォルトの名無しさん

2009/05/23(土) 18:57:11

>>523
関数の中身を理解する目的なら、型宣言と自然言語のコメントさえあれば短いコードは非常に読みやすいと思うんだけどね。
一時的に使う変数が多いとごちゃごちゃして見にくい。

0526デフォルトの名無しさん

2009/05/23(土) 20:02:07

>>525
もちろん短いほうが読み易いことは多いが、

普通なら途中に意味のある変数を導入しつつ数行にわたって書くところを
あえて1行でワンライナー的に書いたりするテクニックが可読性を上げるとは到底思えないなー。

むろん短いことが正義なのでコメントとか型宣言とかは一切ないよww。

0527デフォルトの名無しさん

2009/05/23(土) 20:18:43

再帰は関数型では基礎だと思ってたが違うのか…

0528デフォルトの名無しさん

2009/05/23(土) 20:46:25

マ採用試験の基本だな

0529デフォルトの名無しさん

2009/05/23(土) 21:31:10

素人style >341
真のHaskeller >344

ということだな

0530デフォルトの名無しさん

2009/05/23(土) 21:31:22

>>527
Haskellにはfoldlとかmapとかiterateとかいろいろ関数が用意されているでしょ？
わざわざ再帰で終了条件を場合分けをしなくても良いようにそういう関数を駆使すれば良いんだよ。
また、「終了させなくても良い」場合もあるんだよ。
Haskellは遅延評価だから。

0531デフォルトの名無しさん

2009/05/23(土) 21:32:48

>>527
再帰が基本ってのはそうだけど、
表記の上では直接的に再帰で書くのではなく、
map なり iterate なり fold なりを使えという意味だろ。
Scheme なんかでもそういう風潮はあると思う。

0532デフォルトの名無しさん

2009/05/23(土) 21:33:12

>>529
適度な粒度に関数を分けることも重要。
極端なことは駄目。

0533デフォルトの名無しさん

2009/05/23(土) 21:34:36

あまり注目されないけどfixとかapも意外と便利な関数だぜ

0534デフォルトの名無しさん

2009/05/23(土) 21:39:52

便利だよな…1行で書くのに

0535デフォルトの名無しさん

2009/05/23(土) 21:45:45

<$>とか凄く便利、知らないころは>>=return . fとかアフォなことやってた

0536デフォルトの名無しさん

2009/05/23(土) 22:21:47

Cとかに慣れてる奴はポイントフリーの美しさがわからんようだな

0537デフォルトの名無しさん

2009/05/23(土) 22:26:37

　　　　　　　＿＿＿_　　　
　　　　　　／＼　　／＼　ｷﾘｯ
.　　　　　／　（ー）　（ー）＼　　　　　　
　　　　／　　 ⌒（__人__）⌒ ＼　　　　Cとかに慣れてる奴はポイントフリー
　　　　|　　　　　|r┬-|　　　　| 　　　　　の美しさがわからんようだな
　　　　＼　　　　 `ー'´　　／
　　　　ノ　　　　　　　　　　　＼
　／´　　　　　　　　　　　　　　ヽ　　　　　　　
　|　　　　ｌ　　　　　　　　　　　　　　＼
　ヽ　　　 -一''''''"～～｀`'ー--､　　　-一'''''''ー-､. 　　
　　ヽ＿＿＿＿(⌒)(⌒)⌒)　)　　(⌒＿(⌒)⌒)⌒)

0538デフォルトの名無しさん

2009/05/24(日) 01:27:18

短く記号で書けたって
数ヵ月後何書いたか判らなくなるだけだよ

0539デフォルトの名無しさん

2009/05/24(日) 01:36:41

>>538
何ヶ月後どころか、１時間後でも何書いたか忘れるけどなにか？
でも型とコメント読めば解るだろ普通

0540デフォルトの名無しさん

2009/05/24(日) 07:03:02

問題は無理にワンライナーで書いたコードはまともなコメントを残しようがないという件

0541デフォルトの名無しさん

2009/05/24(日) 09:15:16

Haskellをまったく知らない中小企業の社長に
おたくのシステムはこうだと、Haskellのソースを
示して理解を得ることだって可能でしょ。
そういう場合は、どんなコードにするの？

0542デフォルトの名無しさん

2009/05/24(日) 09:37:48

ワンライナー含めて、式がネストしてると中間値が見れないからデバッグ等が面倒

0543デフォルトの名無しさん

2009/05/24(日) 09:38:30

なぜ中小企業限定なの？

0544デフォルトの名無しさん

2009/05/24(日) 09:46:28

liftMってなにが便利なの？

0545デフォルトの名無しさん

2009/05/24(日) 10:35:06

モナドがつくれること。

0546デフォルトの名無しさん

2009/05/24(日) 11:06:05

>>543
現実味があるから。

0547デフォルトの名無しさん

2009/05/24(日) 11:31:36

liftMよりFunctorとかApplicative使った方がよくね？

0548デフォルトの名無しさん

2009/05/24(日) 14:03:14

>>541
Haskellを任意のプログラミング言語に置き替えて考えてみよう。
君が考えていることの荒唐無稽さが理解できると思う。

0549デフォルトの名無しさん

2009/05/24(日) 15:24:08

euclidean x y | y == 0 = x
| otherwise = let (b,q) = divMod x y
in if q == 0 then y else euclidean y q

こういうのをごっちゃごっちゃにならんようにポイントフリーにできないものかね？
なんかfold f . unfold gの形(hylomorphismってやつ？)で表現できそうな気はするんだけども…
安直にlast . unfoldr fでやるとfがMaybe(Maybe a)みたいなものを返す必要がでてきて
あまり綺麗にならんのよ.

0550デフォルトの名無しさん

2009/05/24(日) 16:11:37

`mod`を使って、
パターンマッチ渡しに書き換えて、
そのパターマッチ渡し再帰パターンを担うメタ関数を使う、必要なら新たに定義する。

0551デフォルトの名無しさん

2009/05/24(日) 16:23:26

>>548
Prologでは当たり前にやってるよ。

0552デフォルトの名無しさん

2009/05/24(日) 16:38:13

で、日本に無数にある中小企業の社長の何人がPrologハカーなんだ？

0553デフォルトの名無しさん

2009/05/24(日) 18:06:44

>>549
頭の体操って事でArrowで書いてみた。

import Control.Arrow

euclidean = loop eucA

eucA (xy, f) = (f xy, eucA2 f)
eucA2 f = mergeArr . right (appF f . ifZero . mod_snd) . ifZero . swapArr

swapArr = snd &&& fst
-- mergeArr (Left v) = v
-- mergeArr (Right v) = v
mergeArr = id ||| id

ifZero (0, y) = Left y
ifZero (q, y) = Right (y, q)

-- appF f (Left v) = v
-- appF f (Right v) = f v
appF f = id ||| f

-- mod_snd = \ (x,y) -> (mod x y, y)
mod_snd = uncurry mod &&& snd

0554a36 ◆K0BqlCB3.k

2009/05/24(日) 18:07:01

>>549
それってこれと同じじゃないの？

euclidean x 0 = x
euclidean x y = euclidean y (mod x y)

0555デフォルトの名無しさん

2009/05/24(日) 18:13:31

>>552
ハカーじゃない普通の人でも読めるって話じゃないの？

0556デフォルトの名無しさん

2009/05/24(日) 18:26:56

って話じゃないの？

0557デフォルトの名無しさん

2009/05/24(日) 18:32:50

>>552
粗利経費構成(SS,_年月,_粗利経費構成) :-
　月報(数量計,'0110-0350,自動車用燃料合計',X),
　月報(粗利計,'0110-0350,自動車用燃料合計',Y),
　月報(粗利計,'0110-8999,総合計',Z),
　試算表合計(SS,一般管理費科目,_年月,_一般管理費),
　試算表合計(SS,人件費,_年月,_人件費),
　試算表合計(SS,売上総利益の部科目,_年月,_売上総利益),
　member([SS,[MF]],X),
　member([SS,[MF粗利]],Y),
　member([SS,[_総合計粗利]],Z)
　A は MF粗利 / MF,
　_油外は四捨五入(_総合計粗利 - MF粗利),
　Win は _油外 - _人件費,
　<以下略>
石油販売会社の社長さんには、上のコードの意味は理解できるものです。
Prologのプログラミングができる必要はありません。

0558a36 ◆K0BqlCB3.k

2009/05/24(日) 18:36:08

>>541
>>552
>>557
話の意味がわかりません。

0559デフォルトの名無しさん

2009/05/24(日) 19:04:16

>>558
>>541 の質問は、 >>529 の分類を読んで書き込みました。
すなわち、Haskellの誰にでも理解できるスタイルは
どんなものになりますか？　ということです。

0560a36 ◆K0BqlCB3.k

2009/05/24(日) 19:23:48

>>559
技術的な話を社長にしても仕方ないぜ
コードの説明に力を入れるよりも、開発者が信用を得られるように努力した方が建設的じゃないかな

0561デフォルトの名無しさん

2009/05/24(日) 19:30:24

>>560
それは論点をすり替えてるな
「Haskellの誰にでも理解できるスタイルは」という問いの答えになってない

0562デフォルトの名無しさん

2009/05/24(日) 20:22:37

プログラムは誰にでも理解できるものではありません。

0563デフォルトの名無しさん

2009/05/24(日) 20:34:02

関数型言語は誰にでも理解できるものではありません。
とは思わない。

0564デフォルトの名無しさん

2009/05/24(日) 23:35:00

社長とかおかしいだろ
それいうなら「そのコードをメンテしたくないと思うかどうか」で言うところ

0565543

2009/05/24(日) 23:44:58

>>557
ほー。おもしろい。（煽りじゃないよ）
そういう関係のを仕事でやってた？

0566デフォルトの名無しさん

2009/05/24(日) 23:55:32

haskellは理解するものじゃないんだよ
haskellを理解したと誤解するのが正解
本当に理解したのは別の何か

0567デフォルトの名無しさん

2009/05/24(日) 23:56:07

>>564
システムの発注者と利用者が同一人というケースの代表として、
中小企業の社長としたのだが・・・

0568デフォルトの名無しさん

2009/05/25(月) 03:32:54

>>564
ソースプログラムがどこまでドキュメンテーションの役割を
担えるかという話だろ。

0569デフォルトの名無しさん

2009/05/25(月) 03:42:12

別言語のプログラマがひとつ事例を出してくれたのだから、
だれかHaskellの例を書いてみればいいじゃないか。

0570デフォルトの名無しさん

2009/05/25(月) 06:09:43

>>567
その場合に「発注者＝利用者」である中小企業の社長はコードを理解せずに
ただ単に利用者として使うものじゃないか？

0571デフォルトの名無しさん

2009/05/25(月) 07:38:47

>>570
成果主義の給与体系への移行などの場合、業績係数がどうの、特別給を
設定しようと、最期まで細部に注文を出すのは、総務部長ではなく、
社長です。その注文に即、対応して、プログラムを変化させるためには、
プレゼンテーションして、予めソースプログラムを読んでもらう他にない。
数行挿入して、そうすると、この社員の総支給はこうなります、と示します。
こうやって試行錯誤しながら、その場でシステムをまとめるのですが、
プログラム言語なんて解らなくても、本当に求めている人には何をやって
いるのか、書いてあるのか、解るのです。

0572デフォルトの名無しさん

2009/05/25(月) 08:38:21

>>557
それ、Prologつーより、識別子名にマルチバイトが使える手続き型言語使うのと同じじゃんw

0573デフォルトの名無しさん

2009/05/25(月) 08:46:10

>>572
そうですよ。COBOL/JAVAと似ているでしょ。
そんなこと関係ないです。

0574543

2009/05/27(水) 20:06:58

>>567
最初からそう書いてくれないと分かんないよｗ
なぜ社長？？って理解できなかったぞ

0575デフォルトの名無しさん

2009/06/01(月) 21:59:19

GHCのCore言語 (コンパイル中に使う中間表現) のパーサを書いています。
GHCの実行時に「-fext-core」を付け、書き出されたコードを読むと
「base:GHC.Prim.sym」や「base:GHC.Prim.trans」が登場するのですが、
これらが何なのかご存知の方はいませんか?
GHCの資料を見ても載っていなくて難儀しています。

0576デフォルトの名無しさん

2009/06/01(月) 22:52:36

http://www.haskell.org/ghc/docs/6.10.1/html/libraries/ghc/Coercion.html
よく知らないけど、ここに載ってるmkSymCoercionやmkTransCoercionで生成される奴じゃね？
AからBにキャストできるならBからAにもキャストできるっていう対称律と、
AからBとBからCのキャストが可能ならAからCのキャストができるっていう推移律

0577575

2009/06/01(月) 23:14:25

「An External Representation for the GHC Core Language
(For GHC 6.10) 」に登場するキーワードの
「%sym」と「%trans」が怪しいと思い、
それぞれ検索置換してみたら、とりあえずパースできました。

ひょっとすると、コンパイラに組み込みの何かから
言語に組み込みのキーワードに変更されたのかもしれません。

意味的にも正しいのかはまだ未確認ですが、
とりあえず全体をパースできるようになってから詳しく見てみます。

0578575

2009/06/01(月) 23:18:10

>>576
おおお、
>>577で書いた仕様書には、
「%sym」の右に「transitive coercion」、
「%trans」の右に「symmetric coercion」と書いてありました。
>>576の解説にも同じようなことが書かれているので、
まさしくこれのようですね。
感謝です。

0579575

2009/06/01(月) 23:19:11

>>578は、
「%sym」の右に「symmetric coercion」
「%trans」の右に「transitive coercion」
の間違いでした。
何度も済みませんです。

0580デフォルトの名無しさん

2009/06/04(木) 11:55:33

フィボナッチ数列を生成する
let fibs = 1:1:2:[x+y | (x,y)<-zip fibs (tail fibs)]
が高速な理由がよくわかりません

fib 1 = 1
fib 2 = 2
fib n = fib(n-1)+fib(n-2)
よりも断然高速な理由はなんでしょう？

結局は一つ数を増すために
zip [1,2,3,5,8,13] [2,3,5,8,13]
[(1,2),(2,3),(3,5),(5,8),(8,13)]
のような計算を毎回やっているって事ですよね。
(8+13)以外はすべて無駄のように思います。
最外簡略とグラフ簡略だから結局は速いのか？

でもfib n = fib(n-1)+fib(n-2)
の圧倒的な遅さは理解できない。。。

0581デフォルトの名無しさん

2009/06/04(木) 13:08:30

zipが行なわれるのは一回だけです。

0582580

2009/06/04(木) 14:31:35

>>581
がんばって考えて見た。次の理解であってる？
take 10 fibsとやった時に
fibs = [1:2:a1:a2:..:a7:a8]
tail fibs = [2:a1:a2:..:a7:a8]
そんでこれらのzipは
[(1,2),(2,a1),..,(a7,a8)]
なので
fibs = 1:2:[3,(2+a1),..,(a7+a8)]
っという事になるわけね。
ここでa1が3と評価できて、
次にa2が2+a1=5と評価され、
次にa3がa1+a2=3+5=8と評価され。。。
最後にa7+a8が評価される。

これができるのも最外簡略のおかげ？

ちょwwwこんなのどうやって思い付くの?lol

0583デフォルトの名無しさん

2009/06/04(木) 15:32:05

だいたいあってる。fibsの長さは確定しなくて必要に応じて伸びる。
というか最後にまだ計算されていないかたまりがくっ付いていて必要になるたび計算されて伸びる。

0584デフォルトの名無しさん

2009/06/04(木) 19:47:09

>>580
ちょっと形が違うけど、このへんに解説があった。
http://d.hatena.ne.jp/SaitoAtsushi/20090208/1234085992

0585デフォルトの名無しさん

2009/06/04(木) 21:54:57

>>2のThe Haskell School of Expressionにくわしく解説されてたような

0586デフォルトの名無しさん

2009/06/04(木) 23:02:13

>>582
等差数列s: S0 = X; S1 = Y; Sn = f(Sn-1, Sn-2) は
s = X:Y:[f(x, y) | (x, y) <- zip s (tail s)]

n-Zがあれば、Zの分:とtailを増やせばいい。
三項に跨がればzip3を使う。
漸化式から導いた数列の筆算を考えると良く分かる。

0587デフォルトの名無しさん

2009/06/05(金) 01:27:54

昔、現在の場所以前の全ての項を使って計算する
x[n] = f(x[0],x[1],...,x[n-1])
という数列を作ろうとし、
x = [f xs | xs <- inits x]
と書いてうまくいかなかった。

原因は標準ライブラリのinitsの実装が不適切で、
head (inits undefined) == []
とならないことだった。

inits' xs = []:if null xs then [] else (map (head xs:).inits.tail $ xs)
と定義しなおしてやれば意図通り計算できた。
undefinedに対する挙動以外は修正前と同じ。

0588デフォルトの名無しさん

2009/06/05(金) 21:11:57

>>505
亀だがやってみた
Offってやつがそれ

import Foreign
import System.IO
import Control.Monad.State

main :: IO ()
main = do
  writeHoge file hoge
  hoge' <- readHoge file
  print $ hoge == hoge'
  where
  file = "hoge.txt"
  hoge = Hoge 3 5 [1,3..32]

-- 書き
writeHoge :: FilePath -> Hoge -> IO ()
writeHoge file hoge = do
  withBinaryFile file WriteMode $ \h -> do
    with hoge $ \p -> do
      hPutBuf h p $ sizeOf hoge

-- 読み
readHoge :: FilePath -> IO Hoge
readHoge file = do
  withBinaryFile file ReadMode $ \h -> do
    alloca $ \p -> do
      hGetBuf h p $ sizeOf (undefined :: Hoge)
      peek p
{-

0589デフォルトの名無しさん

2009/06/05(金) 21:12:44

>>588のつづき
-}

-- >>507の
data Hoge = Hoge Word32 Word32 [Word16] deriving (Show, Eq)

-- 読み書きに使うクラス
-- Word系もStorableを実装してるのでそのまま使える
instance Storable Hoge where
  sizeOf _ = dword * 2 + word * 16
    where
    dword = sizeOf (undefined :: Word32)
    word = sizeOf (undefined :: Word16)

  alignment _ = 8

  peek p = runOff $ do
    a <- peekOff p
    b <- peekOff p
    c <- replicateM 16 $ peekOff p
    return $ Hoge a b c

  poke p (Hoge a b c) = runOff $ do
    pokeOff p a
    pokeOff p b
    mapM_ (pokeOff p) (take 16 c)
{-

0590デフォルトの名無しさん

2009/06/05(金) 21:14:20

>>589のつづき

下の代わりに
  type Off a = StateT (Ptr Hoge, Int) IO a
としてちょっと書き換えると上のpが省ける
-}

-- その読み込みモナド
-- オフセットをIntで覚える
type Off a = StateT Int IO a

-- OffをIOでやる
runOff :: Off a -> IO a
runOff m = evalStateT m 0

-- フィールド取り出し
peekOff :: (Storable a, Storable b) => Ptr a -> Off b
peekOff p = do
  offset <- get
  e <- liftIO $ peekByteOff p offset
  put $ offset + sizeOf e
  return e

-- フィールド書き込み
pokeOff :: (Storable a, Storable b) => Ptr a -> b -> Off ()
pokeOff p a = do
  offset <- get
  liftIO $ pokeByteOff p offset a
  put $ offset + sizeOf a

0591デフォルトの名無しさん

2009/06/06(土) 01:52:15

質問です。

mapM print [1,2,3]
を実行すると
1
2
3
[(),(),()]
と表示されるのですが、なぜ最後に[(),(),()]が表示されてしまうのでしょうか？

0592デフォルトの名無しさん

2009/06/06(土) 01:56:36

質問です。

[[1],[0..],[],[2,3],[4]]
というリストから要素数が1のリストだけをフィルタするにはどうすればいいですか？

0593デフォルトの名無しさん

2009/06/06(土) 04:05:38

Emacsでghciを起動したとき(haskell-mode からcomintでも、eshellから起動でも）
1~2回何か評価しただけで"Leaving GHCi"とだけ出て勝手に終わるようになってしまった。
何があかんのやろ。

>>592
extractSingleton lst = filter lenChecker lst
where lenChecker [_] = True
lenChecker _ = False

0594デフォルトの名無しさん

2009/06/06(土) 04:47:06

>>593
解答ありがとうございます。
しかし、私が求めている答えとは違うようです。
今回は要素数1でしたが、要素数100のリストだけをフィルタしたい場合はどうすればいいのでしょうか？

0595593

2009/06/06(土) 05:29:31

　　　　　　ヾ('A`)/　　ｽﾞｺｰ
　　　　　＼(.＼ノ
　　　　､ﾊ,,､　￣
　　　　￣´´
当方人様の考えを読む能力は持ち合わせていないので、どう違うか書いてくれないことには
にゃんともしがたいですね。>>593のコードがどのように働くのか、調べてみましたか？
無限長のリストを入力として許容したければlength関数が使えないので
checkLen 0 [] = True
checkLen 0 _ = False
checkLen n [] = False
checkLen n (first:rest) = checkLen (n-1) rest
のように書くしかないのではないかと思う。

0596デフォルトの名無しさん

2009/06/06(土) 11:49:19

>>591
mapM print [1,2,3]自体に[(),(),()]を表示する機能がある訳じゃないので、どうやって実行したかによる
たとえばGHCi上で入力したなら、GHCiのお節介でIO動作の結果が表示される(たとえばGHCi上でgetLineと打ってみれば分かりやすい)

>>594
filter ((==replicate 100 ()) . map (const ()))) list

0597デフォルトの名無しさん

2009/06/06(土) 11:51:46

>>593のlenCheckerを使って
filter (lenChecker . drop 99) list
でもいいな

0598デフォルトの名無しさん

2009/06/10(水) 12:36:18

onlisp読み終わったぐらいなんですが
haskellの勉強するならどの本がお勧めですか

0599デフォルトの名無しさん

2009/06/10(水) 12:41:23

>>2の一つ目

0600デフォルトの名無しさん

2009/06/10(水) 16:19:37

f :: WriterT [String] IO a

comb = do a <- f ; b <- f ; c <- f ; return (g a b c)

bar = do (_, log) <- runWriterT comb ; mapM_ h log

この場合、hがlogの先頭だけしか必要としない場合でも、
f内で行われるIOの動作は3回分きっちり実行されますよね。
これをfが評価される度にhを実行するようにしたいんですが、どうすればいいんでしょうか？

例えばf内でgetLineを使ってるようなとき、
barで入力される度にhがf内のtellで追加された分のログに対して実行されるような動作です

0601600

2009/06/10(水) 16:27:16

askUser :: WriterT [String] IO String
askUser = do s <- liftIO $ getLine
　　　　　　 tell $ [(printf "input: %s" s)]
　　　　　　 liftIO $ putStrLn "accepted"
　　　　　　 return s
foo = do a <- askUser
　　　　 b <- askUser
　　　　 c <- askUser
　　　　 return $ a++b++c
baz = do (res,log) <- runWriterT foo
　　　　 mapM_ putStrLn log
　　　　 putStrLn res
というコードでfoo bar bazと入力したときに

foo
accepted
input: foo
bar
accepted
input: bar
baz
accepted
input: baz
foobarbaz

となって欲しいという事ですs

0602デフォルトの名無しさん

2009/06/10(水) 20:17:38

GHCでのコンパイルがうまくいかないので、相談させてください。

コンパイルしようとすると、
「C:\DOCUME~1\(文字化け。おそらくユーザ名？)\LOCALS~1\
　　　　Temp\/ghcXXXX_0/ghcXXXX_0.s:
　　　　　　　openFile: does not exist (No such file or directory)
というエラーが出て、全く前に進めないのですが、どうすればいいのでしょうか？
（XXXXは4桁の数字で、コンパイルを試みるたびに別の数字に変わります）
コード内容は、以下のような簡単なものです。

main :: IO ()
main = putStr "Hello, world!"

使用OSは、Windows XP Home Editionです。

0603デフォルトの名無しさん

2009/06/10(水) 21:00:52

>>602
たぶんテンポラリディレクトリにマルチバイト文字が含まれてるとコンパイルに失敗するバグがある
TMPDIR環境変数を設定するか、-tmpdirを毎回渡すかして、日本語の含まれないパスをテンポラリディレクトリに指定してみたらどう？

0604602

2009/06/10(水) 21:23:11

>>603
TMPDIR環境変数を設定したらコンパイル通りました！どうもありがとうございました。
なるほど、海外産だから2バイト文字に対応してないんですね。
日本語文字が文字化けしている点で気づくべきでした。

0605デフォルトの名無しさん

2009/06/10(水) 21:37:19

海外産……その一言ですべてが許される魔法の言葉

0606デフォルトの名無しさん

2009/06/11(木) 23:31:42

>>600
何をしたいのかはっきりは分からないけど、多分WriterT [String] IOを使う場面じゃないな
[String]には「必要に応じてIOを行う」みたいな機能はないので、
その機能を持った専用のデータ型を用意する必要があるはず
たとえば
newtype Log = Log (IO (Maybe (String, Log)))
みたいなのとか

0607デフォルトの名無しさん

2009/06/12(金) 00:46:54

今日、仕事帰りの電車の中で「圏論の基礎」を読んでる青年を見かけた。
思わず声をかけそうになってしまった。

0608デフォルトの名無しさん

2009/06/12(金) 00:49:52

「やらないか」

0609デフォルトの名無しさん

2009/06/12(金) 00:51:44

圏論の基礎読んだけどいまいちよくわからなかった

0610デフォルトの名無しさん

2009/06/12(金) 01:08:43

>>608
注）電車はハッテン場ではありません。

0611デフォルトの名無しさん

2009/06/12(金) 19:01:31

ハッテン場の有り様をHaskellで書けないものか。

0612デフォルトの名無しさん

2009/06/13(土) 00:16:00

Haskellは純粋なので書けません。

0613デフォルトの名無しさん

2009/06/13(土) 02:35:39

うまい！ｗ

0614デフォルトの名無しさん

2009/06/13(土) 19:02:30

確かに、うまい (w

UHCはJHCと同じGrin言語を内部表現に使っているね。
LHCはJHCのコードを使っていた (今は残っていない) というし、
Grin言語は最適化に向いているんだろうね。
メジャーなGHCを含めてパフォーマンスを比較した人とか、いるのかな?

0615デフォルトの名無しさん

2009/06/15(月) 01:14:32

コードフォマッタ機能が欲しいのですが
最近いいIDEでましたか？

0616デフォルトの名無しさん

2009/06/15(月) 06:42:51

漢なら自分でYiをハックしる！女でも。

0617デフォルトの名無しさん

2009/06/15(月) 07:27:37

>>616
あんたみたいなド変態じゃないから
できねーよｗ

いちいちスペースとかでエラーでるのなんとかしてくれよｗ

0618デフォルトの名無しさん

2009/06/15(月) 07:51:11

マジレスすればEmacsのhaskell-modeでいいんでねいの？
>>593の問題はhaskell-mode-hookに (setq process-connection-type nil) 追加で自決しました☆

0619デフォルトの名無しさん

2009/06/15(月) 21:12:07

コードをフォーマットするだけなら、これをVimでも何でも

import Language.Haskell.Parser
import Language.Haskell.Pretty
main = do
  result <- fmap parseModule getContents
  case result of
    ParseOk r -> do
      putStrLn $ prettyPrint $ r
    _ -> print result

0620デフォルトの名無しさん

2009/06/15(月) 21:26:36

>>619
コメントが全部消えたぞ

0621デフォルトの名無しさん

2009/06/15(月) 23:57:59

>>620
純粋さを汚すコメントは除去されます

0622デフォルトの名無しさん

2009/06/17(水) 04:31:41

>>609
Robert Goldblatt のtopoiを読んでみるといいのでは、今は廉価版などがでているから。

0623デフォルトの名無しさん

2009/06/17(水) 09:13:06

それはハッテン的な内容の本ですか？

0624デフォルトの名無しさん

2009/06/17(水) 15:04:22

Curryスレってないの？

0625デフォルトの名無しさん

2009/06/17(水) 15:15:45

>>624
http://gimpo.2ch.net/test/read.cgi/cook/1238762192/

0626デフォルトの名無しさん

2009/06/18(木) 00:01:26

F a の a は対象。

0627575

2009/06/19(金) 14:20:40

GHC6.8.3でコンパイルできて6.10.xではできないプログラムを
Javaに移植することになった。
GHC6.8.3が「-fext-core」で書き出す「.hcr」ファイルを
だいたいJavaに変換するトランスレータを書いているのだけど、
もう完成間近になって、「type Index = Int」とか書いた場合に
「.hcr」ファイルには書き出されないことを発見。
他にも「newtype」で元の型が書いてなかったり。
これってバグだよね??
Haskell自体の話では無いけど、有名だったりしますか??

0628627

2009/06/20(土) 12:31:18

「graph.hs」が元のファイルで、
「graph.hcr」が「-fext-core」でGHC6.8.3が書き出すファイル、
「graph.java」が自作トランスレータ (未完成) が書き出すファイルです。
(最後のはおまけ, そのまま動くようなファイルではありません)
改行コードはLFのみです。

http://www1.axfc.net/uploader/Sc/so/10578

0629627

2009/06/20(土) 12:33:13

間違って送信してしまいました。

「graph.hs」では「type Tag = Int」と書いているんですが、
「graph.hcr」の時点でTagの定義についての情報は消えてしまうんですよね。
バグというよりは仕様なのかな?

0630デフォルトの名無しさん

2009/06/20(土) 13:17:41

>>629
GHC 6.10.1のリリースノートに、
> External core (output only) is working again.
とあることだし、6.8系列でまともに動かないことは知られてたんじゃね？

0631629

2009/06/20(土) 14:46:15

>>630
おお、やはりそういう話がありましたか。
パーサを書いていて、仕様書通りで無い部分が
何箇所かあったのでおかしいとは思っていたのですが。
情報ありがとうございました。

0632デフォルトの名無しさん

2009/06/20(土) 18:25:33

centosでghcをパッケージ化してるところはないでしょうか
darcsをコンパイルしたいのです

0633デフォルトの名無しさん

2009/06/20(土) 19:25:33

　　　　　　　　　　　　　　　　　　＿__　　　　　つ
　　　　　　　　　　　　 ,.　‐￢'´.:.:.:.::｀:ｰ- ､　　　つ
　　　　　　　　　　／.:.:.:.:.::;.:.:.:.:.:.:.:.:.:.:.:.:.:.::丶､
　　　　　　　　／.:.:.::,.::/:/7: :..:.: .::i.::､.::､:､.:.:.:ヾ:､
　　　　　　　　　 /.:/ .: / / 1 | .: .: .: .:| : ﾄ .:i.::ヽ.:.:.:ヽ:､
　　　　　　 /.:/.:.::/.:/:/ !.:|.: .: .: .: !: :j i.::|.:.::ｌ .: .: ｌ.::i
. 　　　　　　　,'.:/!.:.:_レ'千⌒ﾍ.:.:.:.:.:jrァ￢ャ:､」: .:.:.::! :ｌ
　　　　　　 ,.:/ |.:.:.:|!　,二、ヾ､.:.::/ﾚ' _, 」/　i:| .:.:.:.:|.::|
　　　　　　　　!′|.:.:i:|.f' 匕ﾊヽ　∨/　1J｀ト､.l:!.:.:.:.::j.::ｌ
　　　　　　　　|.:.:|:!　じﾘ　　　　　 lぃリ　!ﾘ.:.:.:.:,'.:.:!
　　　　　　　　　l.:.:|:ｌ ""　　丶　　　｀ ´""/.:.:.:.:ﾊ.:,'
　　　　　　　　　　'､:ﾄヾ､　┌──-ｭ　　　 /:;ｨ.::/ 〃
　　　　　　　　　　　ヾ＼　　ゝ　　ﾉ　　／イ:／イ:ｉ
　　　　「｀¨'￢＝＝=┴─────‐--イ不1＿ﾄ､|＿_
　　　　|　　　　　　　知らないが　　　　　　　　　　　 |
　　　　|　　　　　　　　　　　　　　　　　　　　　　　　　　|
　　　　レ￢　　　　お前の態度が　　　　　　　r─ ､|
　　 r'′-┴､　　　　　　　　　　　　　　　　　　　ｉ⌒ヽ　＼
　　　i´　　-イ　　　　　気に入った！　　　｀ト､　＼ヽ

0634629

2009/06/20(土) 19:45:04

>>632
一年以上前の話ですが、Fedora用のパッケージを使えるらしいです。
http://d.hatena.ne.jp/sotarok/20080208/1202464337

0635デフォルトの名無しさん

2009/06/22(月) 20:36:23

viでHaskellならこれがいいのかな？

Superior Haskell Interaction Mode (SHIM) : GHCi integration for VIM
ttp://www.vim.org/scripts/script.php?script_id=2356

使ってる人いる？

0636635

2009/06/23(火) 19:26:25

Cygwin上で試してみたらそんなコマンドが無いと言われしまった・・
もうちょっとやってだめならviスレに行ってみる

0637635

2009/06/23(火) 20:04:03

vim-rubyをいれたら使えるようになった。連投スレ汚しすまん。

0638デフォルトの名無しさん

2009/06/24(水) 19:21:32

プログラミングしりとり
http://schiphol.2ch.net/test/read.cgi/575/1010948472/l50

0639デフォルトの名無しさん

2009/06/28(日) 14:55:13

mtlについて初心者向けに説明した資料ってありますでしょうか。断片的に
色々見てはいますけど、いまいちスッキリ理解ができません。

0640デフォルトの名無しさん

2009/07/04(土) 23:36:06

(.) :: a -> (a -> b) -> b
(.) = flip ($)

"Hello, World".putStrLn

>>639
強いて言うならAll About Monadぐらいか…

0641デフォルトの名無しさん

2009/07/08(水) 00:45:17

ハスケル速くなった？小食になった？

0642デフォルトの名無しさん

2009/07/09(木) 22:18:41

どっちもまだ

0643デフォルトの名無しさん

2009/07/10(金) 00:40:42

readsの戻り値はなぜ配列なのでしょう？
何か区切り文字があるのでしょうか？

カンマで句切ったら別々にパースするのかと思ったら違いました…
Prelude> (reads "1,2")::[(Int,String)]
予想→[(1,""),(2,"")]
結果→[(1,",2")]

0644デフォルトの名無しさん

2009/07/10(金) 04:27:37

読めなかったら[]を返す
複数の読み方があったらそれらを全部返す
しかし、標準のインスタンスのreadsで複数要素が返ることってない気がする

それから、配列じゃなくてリストな

0645643

2009/07/10(金) 12:25:18

>>644
なるほど、Maybe の代用にもなるって事ですね
ありがとうございました

0646デフォルトの名無しさん

2009/07/11(土) 01:23:55

以下の様な関数は、標準であるでしょうか？

eachParam::(a->b)->(b->b->c)->a->a->c
eachParam f1 f2 a b =f2 (f1 a) (f1 b)

fst3 (a,_,_) = a
snd3 (_,b,_) = b
thd3 (_,_,c) = c

ないとすれば、関数名は妥当でしょうか？
こういう名前の方が良いというのがあれば教えて下さい。

0647デフォルトの名無しさん

2009/07/11(土) 01:51:02

Haskellでは3つ以上のタプルの扱いは面倒くさいから(a,(b,c))みたいにすると扱いが楽だと思う。

0648デフォルトの名無しさん

2009/07/11(土) 02:56:02

>>646
前半は Data.Function.on
後半は知らない

0649646

2009/07/12(日) 04:03:36

>>647
なるほど、それも一つの手ですね。

>>648
ありがとうございます。
やっぱり、あるんですね。

3つ組タプルの取り出しもありそうなんだけどなあ…。
zip3とかはあるのに、なんでだろう…。

0650デフォルトの名無しさん

2009/07/15(水) 22:15:17

圏論とHaskellを勉強しようと思うのですが、今突っ込んでも理解できるとは思えません。
準備運動としては何がオススメでしょうか。。。

0651デフォルトの名無しさん

2009/07/15(水) 22:35:59

とりあえずhaskellだけ勉強して、圏論が必要かどうかはそれから考えるというのはどう。

0652650

2009/07/15(水) 22:47:31

>>651
ありがとうございます。
圏論無しでもHaskellって理解できるんですね。なるほどです。
Haskellの入門書でオススメはありますか。

0653デフォルトの名無しさん

2009/07/15(水) 22:57:29

たかが一プログラミング言語だよ、構えるなよ、PHPぐらいの気持ちで行こうぜ

0654650

2009/07/15(水) 23:27:10

>>653
どうもです。
いやいや、、、PHPちょこっといじったことありますが、あれ、結構簡単ですよね、たぶん。
Haskellはhaskell.orgを覗いてみたんですが、何か異世界に入ったようにさっぱりわかりません。

0655デフォルトの名無しさん

2009/07/15(水) 23:37:50

日本語の入門書といえば >>2 の
・入門Haskell
・ふつうのHaskellプログラミング

0656650

2009/07/15(水) 23:46:50

>>655
ありがとうございます。
調べてみました。ふつうのHaskellプログラミングの方が評判がいいみたいですね。

英語も多少読めるのですが、洋書だと何がオススメでしょう。

0657デフォルトの名無しさん

2009/07/16(木) 00:42:07

Graham Hutton - Programming in Haskellが評判良いようです、とても。

0658650

2009/07/16(木) 01:01:46

>>657
ありがとうございます。
調べました。Mewのかずさんが絶賛してますね。。。
ふつうのHaskellプログラミングとProgramming in Haskellのどちらかに
しようと思います。

みなさん、ありがとうございました。

0659デフォルトの名無しさん

2009/07/16(木) 10:22:58

schoolもいいぜ。
>>655のは取っつきやすさのみが取り柄。

0660デフォルトの名無しさん

2009/07/16(木) 10:28:13

>>655
日本語で Haskell 関連の書籍っていうとその2冊だけだよね？
Real World Haskell の日本語訳のはなしが以前にあったと思うんだけど、
その計画って今はどうなんてんだろ。

0661デフォルトの名無しさん

2009/07/16(木) 10:40:48

haskell-ja のログ見てみるといいことがあるかも

0662デフォルトの名無しさん

2009/07/16(木) 12:22:41

Haskellの本なんか読んだこともないよ。
webで十分だろ。

0663デフォルトの名無しさん

2009/07/17(金) 14:57:29

haskell の数値型について、解説してある所は、ありませんでしょうか？

realfrac や floating、realfloat などの関係が知りたいです。

0664デフォルトの名無しさん

2009/07/17(金) 15:07:49

>>663
型見ればすぐわかるじゃん

0665デフォルトの名無しさん

2009/07/17(金) 15:18:22

ttp://haskell.org/onlinereport/basic.html#sect6.3

0666デフォルトの名無しさん

2009/07/17(金) 15:41:38

>>665　の日本語版
ttp://www.sampou.org/haskell/report-revised-j/basic.html#sect6.3

0667663

2009/07/17(金) 16:47:01

>>664-666
ありがとうございます。

後出しですいませんが、その図をみながら考えていました。

知りたかったことは、個々の class が附与する性質です。

細かく分けて階層構造になっているのが、何でかな～と。

特に RealFracとFloatingのあたりの継承関係で分けて行っている部分です。

一応、Haskell 98 Report と、GHC.Float, GHC.Real 辺りを見ながら考えて
よく解らなかったので質問しました。

-- まだ、良くは解っていないのですが、
-- 疑問の発端となったGHCのエラーメッセージが、私の読み取り違いで、
-- 別な部分を直したら、compile 通ったので、motivation は
-- だいぶ落っこちました。

0668デフォルトの名無しさん

2009/07/17(金) 16:50:59

例えば、
RealFracにはDouble, Float, Rationalが入るけどComplex Doubleは入らない
FloatingにはDouble, Float, Complex Doubleが入るけどRationalは入らない
RealFloatにはRationalもComplex Doubleも入らない

0669デフォルトの名無しさん

2009/07/20(月) 21:21:27

cabalコマンドってupgradeやuninstallができなくなってるけど
みんなどうやってパッケージのインストールや更新をしてるの？
鳥のパッケージシステムだと、hackagedbにあるパッケージすべてを
扱えるわけじゃないし

0670デフォルトの名無しさん

2009/07/21(火) 09:10:35

個別にはできますよね。

何か前のバージョンでcabal upgradeしたら整合性がおかしくなって
動かなくなったことがある。色々調べたけど面倒なので入れ直した。

確か今のバージョンでcabal upgradeってやると、そんな感じのメッセージ
でるんじゃなかった？

0671デフォルトの名無しさん

2009/07/21(火) 22:40:13

さっきまさにpackage.confから一行削除してバージョン違いをインストールしなおした

0672デフォルトの名無しさん

2009/07/23(木) 12:41:47

haskellからOpenGL動かしたいんだけどGLUTのインスコの仕方教えてください

0673デフォルトの名無しさん

2009/07/23(木) 13:30:36

sudo emerge freeglut

0674デフォルトの名無しさん

2009/07/23(木) 21:30:14

Why Haskell？

http://comonad.com/haskell/community.jpg

0675デフォルトの名無しさん

2009/07/23(木) 22:40:44

Redditでこの記事を読んだけど英語力が無さすぎて何が面白いのかよくわからなかった

0676デフォルトの名無しさん

2009/07/23(木) 22:48:59

ヒント　ズボンの丈

0677デフォルトの名無しさん

2009/07/24(金) 01:38:40

Haskellコミュニティ
・知的で
・熱狂的で
・職がない

0678デフォルトの名無しさん

2009/07/24(金) 01:52:15

プレゼン中なのになんか寂しそうな顔してるな

0679デフォルトの名無しさん

2009/07/24(金) 10:59:55

>Why Haskell？
自虐的な問いになってしまったようだなw

0680デフォルトの名無しさん

2009/07/24(金) 11:08:32

ﾜﾛﾀ

0681デフォルトの名無しさん

2009/07/24(金) 15:13:39

オライリーのビューティフルコードにハスケルの章あったよね

0682デフォルトの名無しさん

2009/07/25(土) 10:18:49

Haskellが普及しない原因って、単に難しいからなのかな。

それともRailsのようなキラーアプリが無いから？

0683デフォルトの名無しさん

2009/07/25(土) 11:02:02

普及しなくても何の問題もない言語が普及する。
普及しないと何か問題があるような言語は普及しない。

0684デフォルトの名無しさん

2009/07/25(土) 11:27:23

誰特だよって言語が普及するのか

0685デフォルトの名無しさん

2009/07/25(土) 22:38:40

>>682
日本語の扱いに難があるから

0686デフォルトの名無しさん

2009/07/25(土) 23:36:47

>>682
難しすぎるからｄふぇ所

0687デフォルトの名無しさん

2009/07/25(土) 23:37:53

>>686
難しすぎるからでしょ

0688デフォルトの名無しさん

2009/07/25(土) 23:39:18

>>682
くだらん制約のなかでプログラムを書くのはゲームとしてのおもしろさはあっても
実用にはならないからじゃないか。Haskellはまったく知らなくてちょっとかじって
みようとしたら日本語が出なくて驚いたけどそれ以前に実用になるとは思わないか
ら誰も日本語化しないのだろう。
なんかschemeやprolog,smalltalkをかじったころを思い出した。どれもゲームとし
てのおもしらさはあってもこんなのでプログラムを書きたいとは思わない。

0689デフォルトの名無しさん

2009/07/25(土) 23:57:32

かつてのマイコンと同じようなものかもしれん

0690デフォルトの名無しさん

2009/07/26(日) 00:05:09

スペースリークの問題が解決しない限り
本腰を入れて使いたいと思えない

0691デフォルトの名無しさん

2009/07/26(日) 00:09:08

スペースリークの問題が解決って、何も考えずにコード書いてもスペースリークが発生しないようになるって意味？
それなら永遠に解決されないんじゃね

0692デフォルトの名無しさん

2009/07/26(日) 00:16:50

特に遅延評価に特有の物。だから永久に本腰をいれて(ry

0693デフォルトの名無しさん

2009/07/26(日) 00:32:20

　　　　／　　　　＼
　　　／　 _ノ　ヽ､_　＼
　／　oﾟ⌒　　　⌒ﾟo　＼　今日もまた、コードの間に
　 |　　　　（__人__）　　　　| 　seqをはさむ
　＼　　　｀ ⌒´ 　　／　仕事が始まるお…

0694デフォルトの名無しさん

2009/07/26(日) 01:49:08

なんか、すげー範囲の狭い仕事だな。
振る人が、大変そう。

0695デフォルトの名無しさん

2009/07/26(日) 02:04:28

昔はPrologプログラムに!を入れる仕事をしてたんだけどね、
もう誰もPrologやってないからこっちに流れてきたんだよ。

0696デフォルトの名無しさん

2009/07/26(日) 04:41:37

そうですか!

0697デフォルトの名無しさん

2009/07/26(日) 10:31:50

>>695
その前はEQUIVALENCEでメモリ効率化ですね!

0698デフォルトの名無しさん

2009/07/26(日) 11:31:55

GHCの一番嫌なところはGHC ver X.Y.Zのライブラリのバイナリがver. X.Y.Z'で使えないこと。
せめてマイナーバージョンが同じならそのまま使えるようにして欲しいものだ。
次に嫌なのはファイルサイズがでかいこと。

0699デフォルトの名無しさん

2009/07/26(日) 12:06:20

gtk2hsのファイナライザの問題は解決したの？

0700デフォルトの名無しさん

2009/07/26(日) 12:11:22

leksahとかが落ちるやつなら五月ぐらいに出たやつで解決してたと思う

0701デフォルトの名無しさん

2009/07/28(火) 12:42:41

モナドわかんねーよ！
モナドわかんねーんだよ！
ゆとりでも分かるモナド入門ドキュンメントくれよう…

0702デフォルトの名無しさん

2009/07/28(火) 12:51:28

モナドがわからなくてもIOはできる。
OSのシステムコールとか、プロセッサのIOアーキテクチャがわかってなくても、
C言語から入出力が使えるようなもの。

0703デフォルトの名無しさん

2009/07/28(火) 12:56:32

少し例え話をしよう。
一本の棒があったとする。
武器に使えるし、杖として使うかも、あるいは物干し竿としても使える。
でも、どの用途が棒の本質だろうか？
どの用途も使い道のひとつでなく棒の本質はただ棒であるということにつきる。

つまりはそういうこと。
モナド則を満すものがモナド。

0704デフォルトの名無しさん

2009/07/28(火) 13:00:21

続けて

0705デフォルトの名無しさん

2009/07/28(火) 13:39:36

「ゆとり」ってさ、本来の目的で言えば、ゆとりを持った時間で、
好きな事をするってことだろ。

だから、すごい、プログラミングバカとか出てきても良いと思うんだけど。

0706デフォルトの名無しさん

2009/07/28(火) 14:04:34

課外活動を強制とか、結局学校関係で拘束される時間は変わってなかったからな。
そういう意味では不幸な世代だ。

0707デフォルトの名無しさん

2009/07/28(火) 14:05:13

随伴が意味不すぎる

0708デフォルトの名無しさん

2009/07/28(火) 14:51:04

darcsの改造したいのですが、どの本でhaskell勉強するのがお勧めですか

0709デフォルトの名無しさん

2009/07/28(火) 18:36:33

>701
http://www.sampou.org/haskell/a-a-monads/html/
けして「入門」ではないが、良いドキュメントだ。

これを最後まで読む気になれない、読んでもイミフ、
あるいは練習問題が全く分かんないのなら、
もっとレベルを下げたドキュメントをがんばって探してくれ。

0710デフォルトの名無しさん

2009/07/28(火) 18:46:16

ソース読めばわかるだろ＜モナド

0711デフォルトの名無しさん

2009/07/28(火) 19:07:11

モナドいうなクライスリートリプルといえ

0712デフォルトの名無しさん

2009/07/28(火) 19:33:05

>>710の方法で悟った奴っているのか？
超すごいと思うが遠回りな気がするなwww

0713アイちゃん

2009/07/28(火) 19:42:23

アハ！メイビとかリストとかモナドだっつっても
実際どういう実装でモナドロウを満たすか確認しないとイケないって事か

リストがモナドだって言われても
あのモナド３ロウからどう実践的活用するのかさっぱり想像つかんかったからな
モナドロウから勝手に使い方まで演繹して使いこなさないといけないと思ってた

0714a36 ◆K0BqlCB3.k

2009/07/28(火) 19:49:11

>>712
別におかしな方法ではないぜ
モナドを理解する最短の方法だ
ソースを読めば「こんな簡単な事だったのか。数学かんけーねーじゃんｗｗｗ」
と思うはず。

0715デフォルトの名無しさん

2009/07/28(火) 20:05:25

モナド則がどうのこうのってのは基本的に自分で新しいモナドを作るときだけ気にすればよい。
使うだけならそんなこと覚える必要は全くない。

自分がモナドで気持ち悪いなと思ったのはreturnが他の言語で言うところのreturnと全然違うあたり。

0716デフォルトの名無しさん

2009/07/28(火) 20:09:40

ことさらに圏論との関わりを熱く語る人がいるよね
たかがHaskellのモナドごときで大げさに

0717デフォルトの名無しさん

2009/07/28(火) 20:16:29

>>714
>>710はHaskell処理系のソース（ghcとかhugsとか）読むって意味だと思ったわ。
数学関係ないっていうのは全く同意します。

0718デフォルトの名無しさん

2009/07/28(火) 22:27:56

モナドは基本的にライブラリレベルの存在だから、処理系関係なくね？

0719デフォルトの名無しさん

2009/07/28(火) 22:46:56

fundepを応用したキモい型レベルプログラミングもどきを使ったものがあるから
ソース読めばわかるというのは同意できない

0720デフォルトの名無しさん

2009/07/28(火) 23:04:45

>>701

まあおちついてこれでも読め。

The Haskell Programmer ’s Guide to the IO Monad ― Don’t Panic
ttp://stefan-klinger.de/files/monadGuide.pdf

よけいわからなくなること請け合いだw

0721デフォルトの名無しさん

2009/07/28(火) 23:23:32

IO inside - HaskellWiki
http://www.haskell.org/haskellwiki/IO_inside
というのもあるよ

0722デフォルトの名無しさん

2009/07/29(水) 21:48:08

map 関数などの引数に与える匿名関数の中身全体が
その匿名関数の引数に関する case ~ of しか無い場合、
case ~ of をいちいち書かなくてよい構文糖衣ってありますか？

例えば...
m = map (\x -> case x of
2 -> 20
_ -> x)
[1..9]

0723デフォルトの名無しさん

2009/07/29(水) 21:49:26

こんちは．
『ふつうのHaskellプログラミング』を読んで Haskell に挑戦しています．
今はハノイの塔などのプログラムを練習に書いているレベルなんですが，
円盤を動かした後の塔の状態を逐次表示させようとしたら，関数の引数が
増えたりコードが手続き型っぽくなったりして，嫌なコードになりました．
もう少し Haskell らしいプログラミングをしたいのですが，どんなことに
気をつければよいのかとか，次はこういうことをしてみるといいなどの，
諸先輩方のアドバイスをいただきたいです．お願いします．

0724デフォルトの名無しさん

2009/07/29(水) 22:23:27

>>722
例の場合だとif..then..else があるけど、そういう意味ではないよね…

0725デフォルトの名無しさん

2009/07/29(水) 22:43:24

0726デフォルトの名無しさん

2009/07/30(木) 03:57:22

>>722
ない

0727デフォルトの名無しさん

2009/07/30(木) 07:26:26

>>726
了解しました。
ありがとうございました。

0728デフォルトの名無しさん

2009/08/01(土) 08:59:45

>>723 見てなんとなく作ったハノイの塔をさらしてみる

import Array

hanoi' 0 _ _ _ = id
hanoi' cnt from to mid =
　hanoi' (cnt-1) from mid to . ((from,to):) . hanoi' (cnt-1) mid to from

move ary (from,to) = ary // [(from,rest),(to,top:(ary!to))]
　where top:rest = ary!from

hanoi cnt = scanl move start $ hanoi' cnt 0 2 1 []
　where start = listArray (0,2) [[1..cnt],[],[]]

main = mapM_ (print . elems) $ hanoi 4

0729まだまだ初心者

2009/08/03(月) 00:11:46

>>728
なかなか勉強になります。
配列の使い方がなんとなくわかりました。

0730デフォルトの名無しさん

2009/08/06(木) 14:14:11

windowsでHaskellのコード書くときどんなエディタ使ってますか？

オートインデントとかキーワードの色づけとかインテリセンスみたいな機能の付いたお勧めなエディタって有りませんか？

0731デフォルトの名無しさん

2009/08/06(木) 14:36:04

emacs with haskell-mode

0732デフォルトの名無しさん

2009/08/06(木) 16:55:53

現実問題として emacs 以外の選択肢は無いよなぁ…

0733デフォルトの名無しさん

2009/08/06(木) 18:29:22

メモ帳で事足りてるからまだ使った事ないけど、Yi はどうよ。
http://www.haskell.org/haskellwiki/Yi

ページの最後の方に emacs と比べていいとこ悪いとこ列挙してるけど、
やっぱ emacs の方がいいの？

0734デフォルトの名無しさん

2009/08/06(木) 19:33:07

Yi がどうかはともかくとしてメモ帳は無いわ…
どんだけマゾなんだよ

0735デフォルトの名無しさん

2009/08/06(木) 19:48:56

↑ん？良く聞こえなかったもっかい言って

0736デフォルトの名無しさん

2009/08/06(木) 19:52:39

メモ帳は無いわ…
どんだけマゾなんだよ

0737デフォルトの名無しさん

2009/08/06(木) 20:06:24

あぁ、ごめん勘違いしてた。
メモ帳じゃなくて TeraPad だった。

さすがに自動インデントの無いメモ帳じゃ効率がた落ちですね。

0738デフォルトの名無しさん

2009/08/06(木) 20:28:42

EclipseFPを試してみたけどHaskell向けのオートインデントってのはないのか。

0739デフォルトの名無しさん

2009/08/08(土) 16:29:56

なんでvim使わないの？

0740a36 ◆K0BqlCB3.k

2009/08/08(土) 16:51:49

俺がvimを使わない理由は、vimの使い方を忘れちゃったからさ

0741デフォルトの名無しさん

2009/08/12(水) 21:58:57

最近、D言語みてたらC系列から離れられない奴が癌に思えてきた。
C風の構文でラムダとか汚すぎだろ。
普通に考えたらアホだが、Cから離れたくない奴が多すぎるからDみたいな汚い言語が生まれてくる・

0742741

2009/08/12(水) 22:01:59

すまねえ誤爆だ

0743デフォルトの名無しさん

2009/08/12(水) 22:57:49

俺も早くC系列から離れたいけどゲーム屋だから仕方なくC系列

0744デフォルトの名無しさん

2009/08/13(木) 00:45:33

おい、ゲーム屋。
魔女っ子がHaskellという呪文で
魔法の挙動と環境を定義して戦うゲームを作ってくれ。

0745デフォルトの名無しさん

2009/08/13(木) 00:56:40

それなんて現代魔法？

0746デフォルトの名無しさん

2009/08/13(木) 01:49:26

魔法言語リリカル☆LISPってゲームなら既にあるが？

0747デフォルトの名無しさん

2009/08/13(木) 02:00:24

りこさんとすずに匹敵するキャラがhaskellにも必要だ

0748デフォルトの名無しさん

2009/08/13(木) 02:04:35

こよみと美鎖がいるじゃない

0749デフォルトの名無しさん

2009/08/13(木) 02:08:16

Haskellを広めるためにはこういうロビー活動が必要ということだな

0750デフォルトの名無しさん

2009/08/18(火) 14:14:58

Haskell？良い言語だと思うよ？
でもそれが役に立つってんなら
もっと実用アプリが出てきててもいい筈なんだ

0751デフォルトの名無しさん

2009/08/19(水) 23:52:47

http://hackage.haskell.org/packages/archive/pkg-list.html

実用アプリならここに山程

0752デフォルトの名無しさん

2009/08/20(木) 00:00:15

>>751
ほとんどがライブラリというｗ

0753デフォルトの名無しさん

2009/08/20(木) 09:53:09

きてます
ttp://www.bk1.jp/product/03155747

0754デフォルトの名無しさん

2009/08/20(木) 10:12:01

reddit haskellの記事全部消化したら買うわ

0755デフォルトの名無しさん

2009/08/20(木) 17:07:14

ｷﾀ（´∀｀）ーーーーーー？？？

0756デフォルトの名無しさん

2009/08/20(木) 19:44:31

これ結構前に発売された奴の和訳？
ならネットに訳あるけどな

0757デフォルトの名無しさん

2009/08/20(木) 20:08:27

どう見ても機械翻訳だろ

0758デフォルトの名無しさん

2009/08/20(木) 20:15:14

機械翻訳じゃないだろ
こなれてないだけで

0759デフォルトの名無しさん

2009/08/20(木) 20:20:45

そうか？
余りにも意味不明すぎる日本語だぞ

0760デフォルトの名無しさん

2009/08/21(金) 00:10:00

機会翻訳にいっぴょう

あれはちょっと俺でももっとマシな訳を思い付くというか……

0761デフォルトの名無しさん

2009/08/21(金) 01:02:28

一回機械翻訳して所々手直しした感じかなあ
章によって差が激しい
幸いコード多めだし、原文が併記してあるからギリ読めるw

で、>>753のはやっぱこれの書籍化なのかね
何か書籍ならではのアドバンテージが無いと買うまでいかないかも

0762デフォルトの名無しさん

2009/08/21(金) 01:16:17

>>761
nobsunさんが関わってるし、それはないだろ……仮にも出版元オライリーだぜ？

0763デフォルトの名無しさん

2009/08/21(金) 03:33:24

ちょっとfailの実用例教えて

0764デフォルトの名無しさん

2009/08/21(金) 06:18:00

>>763
適当にgrepしてみたら、
・IOモナドの中で、Perlのdieみたいに無責任に死ぬ
・ParsecのParserモナドの中で、メッセージ付きでパースエラー
の二つの用途がほとんどだった。もちろん暗黙のfailはたくさん使ってると思う

いちおうGoogle Code Searchも
ttp://www.google.co.jp/codesearch?q=%22fail+%22+lang%3Ahaskell

0765デフォルトの名無しさん

2009/08/21(金) 10:57:08

>>762
nobsun自演乙

0766デフォルトの名無しさん

2009/08/21(金) 11:40:11

サンクスエニウェイ

0767デフォルトの名無しさん

2009/08/21(金) 11:59:09

seq挿入がメンドい

0768デフォルトの名無しさん

2009/08/21(金) 16:54:44

そこは、プロにまかせてみれば？
>>> >>693 <<<

0769デフォルトの名無しさん

2009/08/21(金) 17:48:51

遅延評価言語でseq使うとか負け組じゃん

0770デフォルトの名無しさん

2009/08/21(金) 20:22:43

*勝ち負けに、こだわらないプログラミング。
*遅延評価言語であえての正格評価がアツい。

0771デフォルトの名無しさん

2009/08/22(土) 13:14:04

デフォルトを正格評価にするオプションありませんか？

0772デフォルトの名無しさん

2009/08/22(土) 13:27:51

非正格だからこそいちいち処理が終わったかどうかとか考えなくて良いのに。

0773デフォルトの名無しさん

2009/08/22(土) 13:31:51

eager haskellを実装して
template haskellのquasi quotationで埋め込む

0774デフォルトの名無しさん

2009/08/22(土) 14:02:59

デフォルトを正格にできたら
使用すると処理が終わらん関数が色んなところで出てきそう

0775デフォルトの名無しさん

2009/08/22(土) 14:10:03

なんか根本的に破綻しそう

0776デフォルトの名無しさん

2009/08/22(土) 20:13:36

いちいち不用意に∞リスト使ってないか
ちまちま調べないといけないじゃん
もはやちまちまseqするのと手間の大差はない

0777デフォルトの名無しさん

2009/08/22(土) 20:47:20

不用意に無限リスト使っているかちまちま調べるのが苦痛な場合が思いつかない

0778デフォルトの名無しさん

2009/08/22(土) 21:54:52

例を挙げてください

0779デフォルトの名無しさん

2009/08/22(土) 22:04:38

フローに循環があるかどうかを検出すれば無限かどうかってわかったりしない？

0780デフォルトの名無しさん

2009/08/23(日) 00:07:00

改行はともかく、字下げにまで意味があるのには、いつまでたっても慣れないよ・・・

0781デフォルトの名無しさん

2009/08/23(日) 00:16:55

>>780
それについてはかなり批判が多い仕様だと思うよ。

0782デフォルトの名無しさん

2009/08/23(日) 00:20:56

オフサイドルールで不便だと感じた事はないなぁ

まぁ、ルールとして文法に盛り込む明確な理由も分からんが。

0783デフォルトの名無しさん

2009/08/23(日) 01:12:18

オートインデントがやりづらいのが最大の欠点。

まぁ、最悪{ hoge; fuga; ... }という逃げ道もあるけど。

0784デフォルトの名無しさん

2009/08/23(日) 01:30:35

オフサイドルールについては専用スレがあったような気がするので
そちらにもどうぞ。

0785デフォルトの名無しさん

2009/08/23(日) 01:36:14

オフサイドルールは自分もちょっと不便と感じるかも

0786デフォルトの名無しさん

2009/08/23(日) 09:33:35

サッカーのオフサイドもなんか意味がよくわからんし、よくルール変更あるよね。

0787デフォルトの名無しさん

2009/08/23(日) 09:47:26

パスをつなぐだけでゴールしていいとなると単調になってつまらんということらしい

0788デフォルトの名無しさん

2009/08/23(日) 09:49:16

じゃあパス禁止で

0789デフォルトの名無しさん

2009/08/23(日) 10:57:25

そもそもボールを奪いあう競技なのに相手に触れてはいけないというのが意味不明。
アメフト、ラグビーみたいのがあるべき姿。

つまりオフサイドルールはあまりよろしくない。

0790デフォルトの名無しさん

2009/08/23(日) 11:37:44

スポーツだが戦争みたいに争うのは、教育的にもよくないな。
もっと平和的な精神をいれるべき。
ボールを取るときは、争いではなく話し合いで解決すべき。

0791デフォルトの名無しさん

2009/08/23(日) 11:48:28

そもそも勝敗を付けると負けた方がかわいそう
必ず引き分けになるルールにすべき

0792デフォルトの名無しさん

2009/08/23(日) 11:54:23

そもそも時間の無駄。
競技を禁止すべき。

0793デフォルトの名無しさん

2009/08/23(日) 11:55:17

憲法で規定されている平等を誤解してる奴が多いな。
結果の平等ではなく機会の平等を謳っているだけなんだがな。

0794デフォルトの名無しさん

2009/08/23(日) 12:44:03

>>789
アメフトにもラグビーにもオフサイドはあるわけだが。

0795デフォルトの名無しさん

2009/08/23(日) 13:08:02

>>794
うん、あるよ。でもサッカーみたいに意味不明じゃない。

ラグビーのは「前に投げてパスしちゃいけない」っていうルールから考えると当然のものだし、
アメフトのはボールが動きはじめてから動きなさい、っていう物でしょ？

0796デフォルトの名無しさん

2009/08/23(日) 13:18:21

>>793
じゃあフィールドにボールをたくさん投げ入れて、
どちらのチームにも平均して同程度のチャンスを与えるべき。

0797デフォルトの名無しさん

2009/08/23(日) 13:32:06

1. オフサイドなし
2. ボールのやりとりは話し合い
3. 必ず引き分け
4. プレイヤー全員がマイボールで機会平等

0798デフォルトの名無しさん

2009/08/23(日) 13:34:46

ところでHaskellとラグビーの関係は？

0799デフォルトの名無しさん

2009/08/23(日) 13:50:13

その点に突っ込むのを遅延していたのです

0800デフォルトの名無しさん

2009/08/23(日) 13:54:55

バカばっカリーですね

0801デフォルトの名無しさん

2009/08/23(日) 14:26:58

>>795 グラスゴーだろ馬鹿

0802デフォルトの名無しさん

2009/08/23(日) 14:28:48

>>795
> ラグビーのは「前に投げてパスしちゃいけない」っていうルールから考えると当然のものだし、
> アメフトのはボールが動きはじめてから動きなさい、っていう物でしょ？

どっちもハズレ。サッカーのもラグビーのもアメフトのも、
オフサイドラインより前でプレーしてはいけないという原則で一致している。
違うのはオフサイドラインの基準点と、オフサイドの対象となるプレーの基準だけだ。

0803デフォルトの名無しさん

2009/08/23(日) 14:40:47

>>802
どこがハズレなんだ？
別に間違ったこと書いてるか？

まあどちらにしろサッカーではそのオフサイドラインの決め方が意味不明なんだがな。

0804デフォルトの名無しさん

2009/08/23(日) 14:42:23

どうでもいいが、>>789の意図は、オフサイドうんぬんというより、
ボールを奪いあうのに相手に触れてはいけないという所にあると思うんだが。

0805デフォルトの名無しさん

2009/08/23(日) 14:43:50

サッカーでは接触プレーは認められているよ。知らないの？
ショルダーチャージもスライディングタックルもＯＫだよ。
バスケと勘違いしてる？

0806デフォルトの名無しさん

2009/08/23(日) 14:44:46

>>803
じゃあ、おまえが理解している「サッカーでのオフサイドライン」の定義をHaskellで記述せよ。

0807デフォルトの名無しさん

2009/08/23(日) 17:20:56

なんでこんなに盛り上がるの…？

0808デフォルトの名無しさん

2009/08/23(日) 17:52:30

>>807
現実逃避

0809デフォルトの名無しさん

2009/08/23(日) 17:57:53

もしかして: Unemployed.

0810デフォルトの名無しさん

2009/08/23(日) 18:15:44

逃げたかオフサイド厨www

0811デフォルトの名無しさん

2009/08/23(日) 19:25:21

このスレは堅苦しい話題が多いから、
たまには脱線するのも、まあいいんではないかと。

0812デフォルトの名無しさん

2009/08/23(日) 19:27:25

堅い話題ってどんな話題？

0813デフォルトの名無しさん

2009/08/23(日) 19:31:13

まあ直前に魔法少女ネタで脱線してるわけだが

0814デフォルトの名無しさん

2009/08/23(日) 20:53:36

関数型言語のスレは脱線しやすいのなｗ
Lispスレも脱線してたぞｗ

0815デフォルトの名無しさん

2009/08/23(日) 20:53:37

なのは劇場版に期待

0816デフォルトの名無しさん

2009/08/23(日) 21:58:01

>>815
板違い

0817デフォルトの名無しさん

2009/08/23(日) 22:02:29

>>809が脱線を止める呪文を唱えたおかげでとまったな

0818デフォルトの名無しさん

2009/08/24(月) 07:21:31

>>817
いや、>>809は土曜日曜祝日に唱えると逆流する呪文だ。気をつけろ！

0819デフォルトの名無しさん

2009/08/27(木) 20:30:43

今 "Haskell: The Craft of Functional Programming" を読んでいるのですが、
意味が分からないところがあります。
（とりあえず飛ばして先に進んでますが、どうも気になる）

351ページに [Data-directed programming] の例が載っているのですが、
これの何がどう Data-directed programming なのか、誰か説明して頂けないでしょうか。

ここで著者が言ってる Data-directed programming とは、
"計算機プログラムの構造と解釈" で解説されているのと同じものでしょうか。

0820デフォルトの名無しさん

2009/08/27(木) 21:15:11

何がどうっていうか… そのまんまじゃないか

0821デフォルトの名無しさん

2009/08/27(木) 21:22:20

>>820
"The Craft of" の Data-directed の説明と、
"計算機プログラム" の Data-directed の説明が、
全く同じものには見えなかったんです。

前者は単に遅延評価がこんなところで役立つと言っているようにしか読み取れず、
後者は単に関数の型によるディスパッチの方法を述べているようにしか読み取れないんです。

たぶん私が Data-directed の表層しか捕らえられていない為に
これら２つが全く違う事を説明しているように見えるのだと思いますが、
どう同じなのか説明して欲しいんです。

0822デフォルトの名無しさん

2009/08/27(木) 21:35:51

sicpの方はgeneric programmingとかabstract data typeの話題だけど
craft ofの方はデータを加工する関数を組み合わせて目的の値を得るっつう
アプローチと遅延評価が相性いいよとかそういうネタのように思った
確かに全く意味が違ってるな

0823デフォルトの名無しさん

2009/08/28(金) 09:05:47

Text.Regex なんですが
メタ文字を文字扱いしたい時どうすれば良いですか？
\. しようとしたらレキシカルエラーです

0824デフォルトの名無しさん

2009/08/28(金) 09:06:36

Haskellの奴は使ったこと無いからよく分からんけど
文字列の中に仕込もうとしてるなら"\\."としないとだめなんじゃないか

0825デフォルトの名無しさん

2009/08/28(金) 09:13:22

有り難う御座いました*´｀*

0826デフォルトの名無しさん

2009/08/29(土) 22:29:21

既出かも知れんが・・・

日本人が日本語で自分の言葉で書いたIOモナドの解説の中では
ここが一番分かりやすかったから紹介しておく。
http://blogs.dion.ne.jp/keis/archives/5880105.html#more
全3ページ。

これを読んだ後で他のより詳しい解説を見たら、すんなり理解できた。

0827デフォルトの名無しさん

2009/08/29(土) 23:21:58

>>826
おお、これは素晴らしい
指示書とかちゃんとその辺がわかってる説明始めて見た

0828デフォルトの名無しさん

2009/08/30(日) 02:54:39

アクションとか「処理系に任せる」という設明は本当に正しいの？
実際の入出力を言語で記述できないのはCだって同じでしょ？
CのIOライブラリも「処理系に任せる」わけで、違いはないと思える…。

0829828

2009/08/30(日) 02:55:43

×設明
○説明

0830デフォルトの名無しさん

2009/08/30(日) 03:07:30

はぁ？どこの妄想C言語ですか？

0831デフォルトの名無しさん

2009/08/30(日) 03:08:31

>>828
>>826的に言うと、
Cは「評価」されるとすぐ「実行」されるが、
Haskellはプログラムが終わるか、unsafeIOがくるかでもしないと「実行」されない。

0832名無しさん＠そうだ選挙に行こう

2009/08/30(日) 03:28:45

まあ、IOに関していえば、Cであっても、Cの世界では
副作用は起こっていないといえる。
その点ではHaskellとCは同じだろう。
だから826も828も両方正しいだろうね

0833名無しさん＠そうだ選挙に行こう

2009/08/30(日) 03:31:41

Cで副作用だといえるのは、

int a=1; //グローバル変数

void function(){
a=2; //副作用
}

のようなソースコードを実行したときだろう
これはさすがに処理系に任せてるわけではないでしょ

0834名無しさん＠そうだ選挙に行こう

2009/08/30(日) 03:58:24

>>831
それは遅延評価の話ですよね？
遅延評価がデフォルトのHaskellにおいて
実行順序をコントロールするためにIOモナドが必要なのはわかります。

わからないのは、「処理系に任せるから副作用がない」という説明。
これは本当にIOモナドの説明として正しいのでしょうか？

>>832
IOモナドの説明として正しいのでしょうか？

>>833
Ｃに副作用がないとは言ってません。

0835名無しさん＠そうだ選挙に行こう

2009/08/30(日) 04:03:22

>>831
あっ、すみません。
831さんの説明をよく理解していませんでした。

>Haskellはプログラムが終わるか、unsafeIOがくるかでもしないと「実行」されない。
これ、本当に正しいですか？
まさに、ここが疑問なんです。

Haskellはアクションを組み立てるだけ
→プログラム終了後にアクションが順番に実行される
って事ですよね？本当ですか？

0836名無しさん＠そうだ選挙に行こう

2009/08/30(日) 04:16:38

831ではなく、832-833だが
>>834
だから、処理系に任せるという点では同じだといってるじゃん
君のいってることと826はなんら矛盾しない

それから、アクションを組み立てるだけ→いつ実行されるかは終了後であろうが
その場であろうがかまわない
そんなことに意味はないし、処理系依存だろ

0837名無しさん＠そうだ選挙に行こう

2009/08/30(日) 05:43:21

副作用絡みの記事

Haskellには副作用がないのか？ - あどけない話
http://d.hatena.ne.jp/kazu-yamamoto/20090627/1246135829

Scheme:call/ccと副作用
http://tinyurl.com/mjolrq

0838名無しさん＠そうだ選挙に行こう

2009/08/30(日) 08:03:03

現実の世界に副作用が存在するという事実は覆せないから、
出来るのはせいぜい副作用を隠す事だけだ。

でも、副作用は、隠された作用のことで、隠されている事こそが問題だったはずなんだ。

0839名無しさん＠そうだ選挙に行こう

2009/08/30(日) 08:47:30

>>832-835
いや、入出力に関してHaskellとCは明確に違う

まず、HaskellにもCにも「式」とか「評価」という言葉があるよな
どちらの言語でも、例えば「円周率の平方根」を表す式は書けるし、
xが正の整数を表す変数だとして、「フィボナッチ数列の第x項」を表す式も書ける

ところが、もう少し詳しく見ると、HaskellとCでは「式」の振る舞いや扱い方が微妙に違う
例えば、「評価されたときに画面にhelloと表示する式」はCでは書けるし、普通のスタイルだけど、
Haskellでは、unsafePerformIOみたいな非常用の装置を使わないと書けないし、実際滅多に書かない
この違いをもって、「Cは入出力に副作用を使うけど、Haskellは使わない」みたいに言う

この違いの影響の一例として、HaskellもCも部分式の評価順を完全には規定しない言語だけど、
Cでは評価順の不定性によって入出力の順番が不定になることがあるのに対し、
Haskellでは普通にIOモナドを使っている限りそういうことはない

> Haskellはアクションを組み立てるだけ
> →プログラム終了後にアクションが順番に実行される
> って事ですよね？本当ですか？
本当だけど、「プログラム終了後」という言葉の意味が直感と違うかもしれない
ここでいう「プログラム終了後」ってのは、「mainが評価された後」ってこと
mainの評価とは、mainをWHNFまで簡約すること。この簡約自体は普通一瞬で終了する

「WHNFまでの簡約」が、普通に言う「実行終了」とは違うってのは次のような例を考えてみると分かる
f :: Int -> Maybe Int
f x = let y = (xを使ったおもしろい計算) in Just y
こうやってfを定義して、「f 5」をWHNFまで簡約しても、おもしろい計算はまだ実行されない
一番外側のJust構築子を発見した時点でWHNFなので、その中身の計算は遅延されるってことね

0840名無しさん＠そうだ選挙に行こう

2009/08/30(日) 08:56:01

>>838
現実の世界には作用(つまりアクション)はあっても副作用なんてないよ
副作用とは式を評価する「ついでに」なにかアクションを行うことなんだから、
「式」とか「評価」とかいう概念を持ち込んで初めて副作用という発想が出てくる

Haskellはアクションを「ついで」で実行することをやめて、値として明示的に扱うことにした、それだけ

0841名無しさん＠そうだ選挙に行こう

2009/08/30(日) 10:23:28

>>840
不正解。シッタカやめて人の話に真摯に耳を傾ける習慣をつけなさい。

0842名無しさん＠そうだ選挙に行こう

2009/08/30(日) 10:26:45

>>841
正しく説明してよ

0843名無しさん＠そうだ選挙に行こう

2009/08/30(日) 10:29:15

> 副作用なんてないよ

0844名無しさん＠そうだ選挙に行こう

2009/08/30(日) 10:36:31

どう不正解なのか分かるように教えてくれ

0845名無しさん＠そうだ選挙に行こう

2009/08/30(日) 10:46:53

結局>>841説明出来ないのか。おまえがシッタカだなw

0846名無しさん＠そうだ選挙に行こう

2009/08/30(日) 10:49:41

落ち着け、ひとりで何レスしてんだｗ

皆がお前みたいに一日中2chに貼り付いて即レスするわけじゃないんだから
待ちゃあいいじゃないか。

0847名無しさん＠そうだ選挙に行こう

2009/08/30(日) 11:04:03

ID無い板で何言ってんだか。

0848名無しさん＠そうだ選挙に行こう

2009/08/30(日) 11:43:42

ソウダネ、IDナイカラ、ダレガダレダカサッパリワカラナイネ。

0849名無しさん＠そうだ選挙に行こう

2009/08/30(日) 12:53:10

落ち着け、ひとりで何レスしてんだｗ

皆がお前みたいに一日中2chに貼り付いて即レスするわけじゃないんだから
待ちゃあいいじゃないか。

0850名無しさん＠そうだ選挙に行こう

2009/08/30(日) 12:58:06

>>849
自演乙

0851名無しさん＠そうだ選挙に行こう

2009/08/30(日) 13:13:18

>>839
つまり、「式を評価すると”同時”に、評価以外の何かをする」と
いうのが副作用で、同時でない場合、あるいは、同時か
どうかわからない場合などは副作用と呼ばないということでいいの？

0852名無しさん＠そうだ選挙に行こう

2009/08/30(日) 13:46:29

>>837
おお、その上の記事もすばらしい説明だね
最初の1つめの立場をとれば、CのIOにも副作用はないと言えるな

0853名無しさん＠そうだ選挙に行こう

2009/08/30(日) 14:11:07

おまえはなにをいってるんだ

0854名無しさん＠そうだ選挙に行こう

2009/08/30(日) 14:20:41

式の評価で環境に不可逆の変化が生じるのが副作用

0855名無しさん＠そうだ選挙に行こう

2009/08/30(日) 14:28:45

関数型言語において引数・戻り値に現れない作用のことを副作用と呼ぶ
世界を渡せば万事解決

0856名無しさん＠そうだ選挙に行こう

2009/08/30(日) 14:31:25

馬鹿が使うHaskellには副作用があるよ。賢い人が使えば副作用はないよ。

add x y = do {
x'<-x;
y'<-y;
print x';
print y';

x''<-x;
print x'';
y''<-y;
print y'';

return (x'+y');
}

main = add (add (return 1) (return 2)) (add (return 4) (return 8))

0857名無しさん＠そうだ選挙に行こう

2009/08/30(日) 14:34:08

>>853
一つ目の立場をとれば、CをCの実行プロセスを
式の評価と実行にわけて考えるわけだから、
式の評価までがCだと考えれば、printfやfflushに副作用は
ないと言える

0858名無しさん＠そうだ選挙に行こう

2009/08/30(日) 14:39:16

>>851
タイミングはあんまり関係ない
式eが評価されたことによって何か入出力が行われたらそれはeの副作用
式eが評価されて、得られた値に基いて何か入出力が行われるのはeの副作用とは違う

>>857
Cだと式の評価の過程で入出力の実行が起こるから、「式の評価までがC」という言いかたはできないよ

0859名無しさん＠そうだ選挙に行こう

2009/08/30(日) 14:45:29

>>858
「評価」という言葉の定義から考えたほうがよさそうだね

0860名無しさん＠そうだ選挙に行こう

2009/08/30(日) 14:54:41

>>858
評価の過程で実行が起こっても、その実行をCの外のことだと考えれば
副作用ではなくなるんじゃない？
でも、Cの中と考えるしかないのかもしれないね。

式eが評価されて、得られた値に基いて何か入出力が行われるのを
副作用と呼ぶ立場もあるんじゃないかな。
だって、環境に変化が与えられているから。
>>837の上の記事で言えば2番目の立場

0861名無しさん＠そうだ選挙に行こう

2009/08/30(日) 15:01:52

Cの仕様書によれば、実行環境の状態に変化を与えるものを
副作用と呼ぶ
この定義に従うなら、CのIOに副作用はある

Haskellもこれと同じ立場に立つ(実行環境の状態が1つだけ、Haskellの中の
世界にあると考え、それが変化していくととらえ、その変化を副作用と呼ぶ立場)なら、
副作用はあると言える

ただし、

1. 実行環境の状態をHaskellの外のことだと考える立場
2. 実行環境の状態をHaskellの中のことだと考えるけれども、その状態自体を
　値だと考える立場

の二つの立場なら、副作用はないといえる

0862名無しさん＠そうだ選挙に行こう

2009/08/30(日) 15:29:38

>>860
>式eが評価されて、得られた値に基いて何か入出力が行われるのを
>副作用と呼ぶ立場もあるんじゃないかな。
少なくとも「式eの」副作用ではないよな？

>>861
確かにそう定義されてるけど、実際に規格内で副作用という言葉はもっぱら
式の評価に付随するものとして扱われてるはず
あくまで「式の評価に際して」実行環境の状態に変化を与えることを副作用と呼ぶんだと思う
http://en.wikipedia.org/wiki/Side_effect_(computer_science)

でも混乱を避けることを考えるなら、「Haskellには副作用がない」と言う代わりに
「Haskellではあらゆる式が副作用を持たない」という言い方をした方が良いのかも

0863名無しさん＠そうだ選挙に行こう

2009/08/30(日) 15:33:58

>>862
式の評価に付随する場合と、付随しない場合の違いはどうやって区別する？

0864名無しさん＠そうだ選挙に行こう

2009/08/30(日) 15:48:50

>>863
式を評価する手順の規則は言語ごとに決まってる訳だけど、その手順に従って式を評価する過程で、
その状態変化を起こすことが規定されている場合に限り、付随すると判断する

でいいかな

0865名無しさん＠そうだ選挙に行こう

2009/08/30(日) 15:54:50

>>864
つまり、上のほうで否定した「同時に」ってことだよね

0866名無しさん＠そうだ選挙に行こう

2009/08/30(日) 16:04:05

式の評価と同時に何かしても、その「何か」で環境の状態が変化しないならそれは副作用に非ず

0867名無しさん＠そうだ選挙に行こう

2009/08/30(日) 16:05:27

>>865
ルールで決まってるかどうかの問題で、タイミングの話はしてないよ
例えば「この式が評価されたら五秒後にメモリを書き換える」みたいなのだって立派な副作用だし、
式を評価しながら同時に環境に何か無関係な状態変化を起こしても、それはその式の副作用じゃない

0868名無しさん＠そうだ選挙に行こう

2009/08/30(日) 16:10:02

副作用ってのは環境に変化を与える物だけじゃなくて環境の変化に影響される物もあると思うんだ。
たとえば現在時刻の取得とか。

0869名無しさん＠そうだ選挙に行こう

2009/08/30(日) 16:16:18

>>867
ならば、Haskellみたいに、「タイミングはいつかわからないけど、とにかく
この順番に文字を表示しろ」のようなものだって、立派な副作用だろ

0870名無しさん＠そうだ選挙に行こう

2009/08/30(日) 16:17:52

>>868
現在時刻の取得自体は副作用じゃないのでは
その例でいけば、現在時刻を変化させてるのが副作用で

0871名無しさん＠そうだ選挙に行こう

2009/08/30(日) 16:23:32

参照透明性が満たされないってのも副作用の1つという立場だと
IOモナドでない現在時刻取得関数は参照透明性を満たさないから副作用だよ。

0872名無しさん＠そうだ選挙に行こう

2009/08/30(日) 16:29:26

参照の透明性が破られる原因の1つが副作用なのであって、
逆ではないと思うのだが？

0873名無しさん＠そうだ選挙に行こう

2009/08/30(日) 16:32:22

>>869
putChar 'a' >> putChar 'b' みたいな式を考えてる？
この式を評価して何年待っても文字は出力されないよ
「aを出力し、次にbを出力する」という手順を表現する単なるデータが返ってくるだけ

0874名無しさん＠そうだ選挙に行こう

2009/08/30(日) 16:52:47

>>873
じゃあ、それを評価してみてよw
出力しかしない恣意的な例じゃなくて、出力した結果を入力として受けるような例で。

0875名無しさん＠そうだ選挙に行こう

2009/08/30(日) 16:59:18

おまえはいったいなにをいってるんだ

0876名無しさん＠そうだ選挙に行こう

2009/08/30(日) 17:08:36

"Haskell: The Craft of Functional Programming" を読んでいて、
また分からないところが出てきました。
空間複雑性（space complexity）の問題です。

確認なんですが、次の２式の空間複雑性は違いますか、同じですか？
(a1) [1,2] ++ [1,2]
(a2) [1,2,3] ++ [1,2]

もうひとつ、次の２式の空間複雑性は違いますか、同じですか？
(b1) [1 .. 5] ++ [1 .. 5]
(b2) [1,2,3,4,5] ++ [1,2,3,4,5]

0877名無しさん＠そうだ選挙に行こう

2009/08/30(日) 17:11:49

>>874
>出力しかしない恣意的な例じゃなくて、出力した結果を入力として受けるような例で。
文字列をファイルに書き出して、それを読み込むアクションでいい？

import Control.Exception

action :: IO String
action = do
writeFile "temp.txt" "hogehoge\n" -- temp.txtに出力した結果を…
readFile "temp.txt" -- 入力として受ける

main :: IO ()
main = do
evaluate action -- actionをWHNFまで評価する
putStrLn "done!"
getLine -- すぐに終了しないように入力待ち
return ()

実行してみると分かる通り、temp.txtは生成されない
actionを評価しても、手順を表現する単なるデータが得られるだけで、それが勝手に実行されることはない

0878名無しさん＠そうだ選挙に行こう

2009/08/30(日) 17:22:37

それ単なる遅延評価

0879名無しさん＠そうだ選挙に行こう

2009/08/30(日) 17:25:52

遅延評価は関係ないよ
評価を強制するためにevaluateを使ってる

0880名無しさん＠そうだ選挙に行こう

2009/08/30(日) 17:30:37

temp.txtを読んだ結果を使っていないから、lazynessによって評価されなかった。それだけのはなしだろ。

0881名無しさん＠そうだ選挙に行こう

2009/08/30(日) 17:39:16

HaskellのIOはそんな迷惑なlazinessを持たないよ

main :: IO ()
main = do
writeFile "temp.txt" "hogehoge\n" -- temp.txtに文字列を書き込む
readFile "temp.txt" -- temp.txtの内容を読んで捨てる
return ()

これを実行すればちゃんとtemp.txtが作られる

HaskellのIOについて自信満々に語るならせめて基本的な振る舞いくらい知っといてくれ

0882名無しさん＠そうだ選挙に行こう

2009/08/30(日) 19:57:38

>>873
何年待っても文字は出力されないってのは嘘だろう
そうじゃなきゃputCharの命令は意味がない
自動的に処理系が実行するという仮定があるじゃないか

0883デフォルトの名無しさん

2009/08/30(日) 20:36:26

>>856
まさに裸の王様

0884デフォルトの名無しさん

2009/08/30(日) 20:48:49

ここまで来て誰もhaskell.orgの解説を読めと言わないのはなぜだ？

http://www.haskell.org/haskellwiki/Functional_programming

3.2.4.2 Side effects through monads

Another way of introducing side effects to a pure language is to simulate them
using monads. While the language remains pure and referentially transparent,
monads can provide implicit state by threading it inside them. The compiler
does not even have to 'know' about the imperative features because the
language itself remains pure, however usually the implementations do 'know'
about them due to the efficiency reasons, for instance to provide O(1) mutable
arrays.

Allowing side effects only through monads and keeping the language pure makes
it possible to have lazy evaluation that does not conflict with the effects of
impure code. Even though the expressions are evaluated lazily, some parts of
them are forced by monads to be evaluated in a specific order and the effects
are properly sequenced.

0885デフォルトの名無しさん

2009/08/30(日) 20:52:25

>>878 >>881
つまり、Haskellのevaluateを呼んでもIOは実行されないと
いいたいんだろうが、mainに書けば、実行される
結局、「mainに書けば、式の評価とは別に実行される」という
前提があるわけでしょ？

0886デフォルトの名無しさん

2009/08/30(日) 20:53:21

そういう前提があるにもかかわらず、「付随している」と言わないのは
おかしいでしょ
Cでは、そういう前提のことを付随と言っているわけで

0887デフォルトの名無しさん

2009/08/30(日) 20:58:09

>>884
ようするに、>>837の第3の立場だね

0888デフォルトの名無しさん

2009/08/30(日) 21:03:59

the end

0889デフォルトの名無しさん

2009/08/30(日) 22:13:12

StateMonadのことからやれば、だいぶスッキリすると思うが。＞入出力

0890デフォルトの名無しさん

2009/08/30(日) 22:50:01

直接の答えは載ってないんだけど、考える上で参考になるかもしれない論文
Amr Sabry, What is a Purely Functinonal Language?
http://www.cs.indiana.edu/~sabry/papers/purelyFunctional.ps

「純粋関数型言語」の定義を提案する論文。
「5.2 Effects as Monadic Operations」のところで、モナドにより副作用(状態)を表す言語が(この論文の定義では)「純粋」であることが示されている。

この論文では次のような手順で「純粋である」とは何であるかを探っていく。
1. 明らかに純粋であろうと考えられる言語を用意する
2. 明らかに純粋でないだろうと考えられる言語を用意する
3. 1が「純粋」であり2が「純粋でない」となるような定義を考える

結論から言うと、参照透過性も、observational な等価性も、簡約の合流性も純粋であるということの定義としては不適当で、
代わりに純粋関数型言語の定義として、次の3つの性質による定義を提案している(簡略化したものなので正確な定義は論文を参照のこと)。
1. 純粋型付きλ計算の項を含む。それらの項のセマンティクスは純粋型付きλ計算のセマンティクスと同じである。
2. call-by-value, call-by-name, call-by-nameの3つの評価関数が用意されている。
3. 任意の式Mに対して、3つの評価関数においてMの評価結果が定義されているならば、それらは等しい。

0891デフォルトの名無しさん

2009/08/30(日) 22:59:45

>call-by-value, call-by-name, call-by-nameの3つの評価関数が用意されている。

？

0892デフォルトの名無しさん

2009/08/30(日) 23:02:08

call-by- value, name, "need" の3つだね。

0893デフォルトの名無しさん

2009/08/30(日) 23:06:22

Haskellにcall-by-need以外があるのか？

0894デフォルトの名無しさん

2009/08/31(月) 18:20:58

アクション型の式を「評価」することと、
そこに埋め込まれた処理内容が「実行」されることは違うよってことだよね。>>877とかは。

「評価＝実行」の単純な関係からせっかく逃れたのに「評価」って言うな！みたいな。

0895デフォルトの名無しさん

2009/08/31(月) 19:32:34

実行しなければどうということはない！みたいな。

0896デフォルトの名無しさん

2009/09/01(火) 00:08:31

>>894
そんなのCでも違うよ
評価と実行が何らかの規則で結びついてるから問題なわけで
Haskelldeあってもね

0897デフォルトの名無しさん

2009/09/01(火) 02:29:22

それとこれとは話が違うような

0898デフォルトの名無しさん

2009/09/01(火) 02:51:16

>>896は>>878や>>880のような立場なのか、それ以外なのかよくわからん。

0899デフォルトの名無しさん

2009/09/01(火) 03:10:22

import Control.Exception

main :: IO ()
main = do
evaluate main
return ()

0900デフォルトの名無しさん

2009/09/01(火) 03:33:23

http://cvs.haskell.org/Hugs/pages/users_guide/using-hugs.html#BASIC-COMMANDS
例えばHugsでは普通、式が入力されればそれが単に評価される（その値を得るまでの処理が実行される）わけだけど、
式がアクション型だった場合は特別に、アクションとして実行するところまでやっちゃうことになっている。
（つまり、アクションの実行は式の評価の一種ではないし、その一部でもない）

> However, if expr has type IO t for some type t, the resulting IO action is performed:

こういう例外的な振る舞いが紛らわしいということかもしれない。

0901デフォルトの名無しさん

2009/09/01(火) 08:06:16

紛らわしいというより、そういう振る舞いをさせる機能を
付随したとか、副作用と呼ばないための定義が
不完全じゃないかといってる

0902デフォルトの名無しさん

2009/09/01(火) 08:50:05

結局、アキレスと亀のパラドックスと同じで、
副作用を発生させる前の時点のみを考察しているから、
副作用は存在しないという結論になっているだけ。

0903デフォルトの名無しさん

2009/09/01(火) 09:09:59

だから、

Allowing side effects only through monads and keeping the language pure makes
it possible to have lazy evaluation that does not conflict with the effects of
impure code.

これが全てでしょ。副作用の有り無しを論じようとするのは筋違い。

0904デフォルトの名無しさん

2009/09/01(火) 09:44:09

このところの流れがさっぱりわからないが
なぜわからないのかがわかったので勉強してくる

0905デフォルトの名無しさん

2009/09/01(火) 09:49:44

すべては一期一会だと言い張る仏教徒みたいなもんだな

0906デフォルトの名無しさん

2009/09/01(火) 11:58:13

面白い言い回し大会終了

0907デフォルトの名無しさん

2009/09/01(火) 12:33:52

>>903は「副作用」という言葉の意味を微妙にずらして説明している部分を取り出しているので
あれだと思うけど、話を見ていると、問題なのは「副作用」の定義だけじゃないと思う。

例えば、I/Oの処理だって「評価」の枠内で実行されてるじゃないか、のような主張。
これがまだ何なのかわからない。

0908デフォルトの名無しさん

2009/09/01(火) 12:43:34

>>907
> 「副作用」という言葉の意味を微妙にずらして
どこがどうずれているんだ？

0909デフォルトの名無しさん

2009/09/01(火) 12:50:17

だって上の方では副作用を含む関数（関数的な手続き）を「impure」と表現しているのに、
「pureな言語に副作用を導入」してなお「言語は依然pure」だ、という言い方は食い違って見えるけど

0910デフォルトの名無しさん

2009/09/01(火) 13:18:00

>>909
副作用をmonadに閉じ込めることで、プログラム全体としてはpurityを損なわないから
pureな言語と呼んでいるんだろう。

0911デフォルトの名無しさん

2009/09/01(火) 13:31:49

突然「monadの中のside effect」という概念が飛び出していると思われ

0912デフォルトの名無しさん

2009/09/01(火) 13:40:56

何を言いたいんだ？？？

0913デフォルトの名無しさん

2009/09/01(火) 13:56:34

それまでは「式の副作用」しか出てきていないでしょ

0914デフォルトの名無しさん

2009/09/01(火) 14:06:02

>>903の部分は、副作用を「introduce」すると言いながら
その方法として副作用を「simulate」すると（副作用そのものを実現しないように）言ったりして、
厳密さを犠牲にしていることは明らかだと思うよ。

0915デフォルトの名無しさん

2009/09/01(火) 14:17:02

>>913
何に対しての「それまで」？

0916デフォルトの名無しさん

2009/09/01(火) 14:29:29

>>915
>>903が
http://www.haskell.org/haskellwiki/Functional_programming
このページの
> 3.2.4.2 Side effects through monads
この部分にあるのに対して、それ以前の部分では、ということ

0917デフォルトの名無しさん

2009/09/01(火) 14:36:26

>>916
で、その部分でmonadに言及することの何が問題？

0918デフォルトの名無しさん

2009/09/01(火) 14:43:45

Haskellたん「mainアクション実行するなよ！絶対するなよ！」

0919デフォルトの名無しさん

2009/09/01(火) 14:48:07

式の意味として返却値以外のものがあるとき、それを副作用というんだよ、
副作用のない言語をpureだというんだよ、という流れの中でしか「副作用」が出てきていなかったのに、
（pureな言語において）「副作用をmonadに閉じ込める」というのは、意味を持たないじゃん。
副作用「として実現されていたような種類の動作」を、というならわかるけど。

0920デフォルトの名無しさん

2009/09/01(火) 15:40:17

モナドに閉じ込められている副作用とは、
(言語の実装に必要な) モナドを実行する関数 (:: (Monad m) => m a -> a)
の副作用のことだろうね。
副作用として実装されるだろうけど、言語レベルでは未定義ってこと。

0921デフォルトの名無しさん

2009/09/01(火) 16:03:40

モナドを実行する関数って何？

0922デフォルトの名無しさん

2009/09/01(火) 17:06:03

例えば、対話環境でprint "foo" >> return "bar"と入力すると、"bar"を返す。
つまり、対話環境を実装するにはIO String -> Stringを実装しなきゃいけないんだよ。

0923デフォルトの名無しさん

2009/09/01(火) 17:16:33

アクション × 状態k → 状態k+1
状態 → 返却値
みたいな純粋な関数があればいいのでは。大雑把だけど。

0924デフォルトの名無しさん

2009/09/01(火) 17:19:12

いや、ちょっとアレか。とにかく
・内部状態の変化を純粋な関数で表現できないわけじゃない
・実装時に関数概念を持ち出す必要は特にない
という感じだけど

0925デフォルトの名無しさん

2009/09/01(火) 18:20:29

1> [3] ++ take 3 $ repeat 3
2> [3] ++ $ take 3 $ repeat 3
3> [3] ++ (take 3 $ repeat 3)

リストを結合するとき、3以外エラーになるのは何ででしょう？

1は、ともかく、2がparse error になっちゃうのは、
理由が解りません。

0926デフォルトの名無しさん

2009/09/01(火) 18:51:27

2 でも ++ を前置記法にするとエラーにならずに正しく評価されるな。

0927デフォルトの名無しさん

2009/09/01(火) 18:53:16

>>922
ごめん、入出力の話を>>923では勝手に内部状態の話にしてしまっていた…。
そりゃそんな簡単じゃないよねｗ
でも処理系はともかく、対話環境の話はまた別なような…

0928デフォルトの名無しさん

2009/09/01(火) 19:19:21

>>925
もっと簡単な例でもいいのでは。
OK> 1 + 2 + 3
NG> 1 + $ 2 + $ 3
OK> (1 +) $ (2 +) $ 3
OK> (+) 1 $ (+) 2 $ 3
OK> (\x -> 1 + x) $ (\x -> 2 + x) $ 3
優先順位の低い演算子でせき止めても括弧は省略できないよ、という感じ？

0929デフォルトの名無しさん

2009/09/01(火) 19:58:37

まともな資料
http://www.haskell.org/onlinereport/exps.html#sections
http://www.sampou.org/haskell/report-revised-j/exps.html#sections
括弧は構文の一部らしい

0930デフォルトの名無しさん

2009/09/01(火) 20:34:56

$って云うのはSyntax Sugar でもなんでもなくて、単なる中置演算子だから、

++ $ ってやると中置演算子が二つも並んでることになってParseErrorになる。

($) の定義自体は
f $ x = f x

と単に関数適用だけで、あれが上手い具合に働いてるのは infix の指定をよろしくやってるから。

0931デフォルトの名無しさん

2009/09/01(火) 23:35:06

>>903の説明は>>837の上の記事の第二の立場から見た副作用という言葉を用いて、
第三の立場を説明してるだけじゃん。

0932デフォルトの名無しさん

2009/09/01(火) 23:36:06

×　第二の　→　○　第三の

0933デフォルトの名無しさん

2009/09/01(火) 23:42:36

夏休み終わったのにまだそんな話か

0934925

2009/09/01(火) 23:43:28

>>926,927-930
レス、ありがとうございます。

>>930
> $って云うのはSyntax Sugar でもなんでもなくて、単なる中置演算子

Prelude> :type ($)
($) :: (a -> b) -> a -> b

この視点が抜けていました。

すごく良く解りました。
ありがとうございます。

>>928
> もっと簡単な例でもいいのでは。

>>925 の順番は、いつも自分で List を使っているとき、

1 -> エラー -> あっ-> 2 -> エラー　-> えっ？あっそーだった -> 3

と、修正していく順番でした。w

0935デフォルトの名無しさん

2009/09/02(水) 05:27:15

>>903はlazinessとimpureが両立するという意味であって、
言語がpureに保たれているなんて一言も言ってないんじゃね？

0936デフォルトの名無しさん

2009/09/02(水) 05:45:45

>>935
おまえは英語を勉強してこい

0937デフォルトの名無しさん

2009/09/02(水) 08:32:01

>>935
> and keeping the language pure

0938デフォルトの名無しさん

2009/09/02(水) 14:43:44

Programming in Haskell の作者のWeb ページに

A Japanese version is currently in preparation.

かいてあるお

0939デフォルトの名無しさん

2009/09/02(水) 17:55:20

>>819 や >>876 の話題には興味ありませんか？

0940デフォルトの名無しさん

2009/09/02(水) 20:24:53

>>939 >>876
あほうな疑問かも知れないけど、
規模を示す変数が何もなければ複雑性はO(1)じゃないのかな

0941デフォルトの名無しさん

2009/09/02(水) 21:27:15

>>940
そうでしたか。

では、次の２つでは空間複雑性は違いますか？

(c1) [1, 2, 3, 4, 5, ...... , n-1, n]
(c2) [1 .. n]

私は違うのではないかと考えているのですが。
（分かるとは思いますが、c1 は 1 から n までの整数を直接並べた式です）

0942デフォルトの名無しさん

2009/09/02(水) 22:10:49

(c1) [1, 2, 3, 5, ...... , n-1, n]
(c2) [1 .. 3] + [5 .. n]

0943デフォルトの名無しさん

2009/09/02(水) 23:50:23

すいません、>>941 のままだと変な質問ですね。

リスト内の全ての要素を評価する関数に引数として c1 や c2 を渡したら、
その関数の評価における空間複雑性は変わるのかという質問です。

で、私は今のところ変わると考えていますが、どうでしょうか。
そう思う理由は長くなるのでレスを分けて書きます。

>>942 はどちらも同じという意味でしょうか。

0944デフォルトの名無しさん

2009/09/02(水) 23:52:56

>>943 と思うわけは以下の通りです。

[Craft of] には 423 ページに次の式が載っており、

[m .. n]
| n>=m = m:[m+1 .. n]
| otherwise = []

[1 .. n] の計算は O(1) だそうです。
なぜなら、この計算は次の様な流れで処理され

[1 .. n]
-> 1 : [1+1 .. n]
-> 1 : [2 .. n]
-> 1 : 2 : [2+1 .. n]

各ステップで [ の前の部分は「出力可能な計算結果の部分」であり、
空間複雑性を測るにはそれ以外の未だ出力できない部分を考える必要がある。
上記の計算ではそのような未出力部分は「サイズが一定」なので O(1) だそうです。
つまり、[1+1 .. n] や [2+1 .. n] の部分は空間複雑性的には同じサイズと言っています。

私はこれを、式を構文の要素に分けた時のその要素数＝サイズだと解釈しました。

ならば、>>941 の c1 を >>943 のような関数に渡せば、
そのサイズは n に依存するのではないでしょうか。
つまり、c1 は O(n) だと思うのですが、どうでしょうか。
一方 c2 は O(1) だと思います。

0945デフォルトの名無しさん

2009/09/02(水) 23:53:06

>>903はようするに、

「副作用がモナドを通してのみ許され、言語が純粋ならば、
　遅延評価と純粋でないコードが衝突しないで共存できる」

と言っている。つまり、

・副作用や、純粋でないコードがどこかに存在する
・しかし、言語は純粋である

といってるように読める

0946デフォルトの名無しさん

2009/09/03(木) 04:15:16

「副作用」とか「純粋」という言葉で「言語」を説明しているのか、
それ以外の何かを説明しているのかがぼやけている人がけっこう多いという印象

0947デフォルトの名無しさん

2009/09/03(木) 07:02:54

IOアクションはパチンコの景品のようなものだと思えばいい。
現金じゃないから賭博じゃないよみたいな。

0948デフォルトの名無しさん

2009/09/03(木) 08:03:09

つまり、言語がpureであるというのは、プログラムが与えられた時に
purely functionalなものとしてWHNFまでreduction出来るということ？
Haskellはmonadを導入することでそれを可能にした。ゆえにpureであると。

0949デフォルトの名無しさん

2009/09/03(木) 08:37:38

>>944
「出力」

0950デフォルトの名無しさん

2009/09/03(木) 11:03:41

>>948
言語がpureであるというのは、モナド絡みで言うなら、式の評価順が変わっても結果は変わらないこと

0951デフォルトの名無しさん

2009/09/03(木) 12:27:38

>>949
「出力」という単語から連想できるものを色々考えてみましたが、
言いたい事がよく分かりませんでした。

0952デフォルトの名無しさん

2009/09/03(木) 12:34:04

いつまでも言葉のドッジボールを続けるより圏論ですよ

0953デフォルトの名無しさん

2009/09/03(木) 15:03:02

>>943-944
入力したデータを保持するだけでO(n)かかるじゃないかってことですよね。
でも元の話は遅延評価のコストの話だと思うので、
値が既に決まっていたら意味を失うような気が。

0954デフォルトの名無しさん

2009/09/03(木) 17:50:22

>>951
出力したらリストも要素もいらなくなるんだから、
作業用の空間はO(1)で押えられるでしょ。

0955デフォルトの名無しさん

2009/09/03(木) 18:19:13

>>954
出力したらリストも要素もいらなくなるんだろうけど、
>>953 が代弁してくれたように、引数で束縛したら保持するので
O(n) 必要なのではと思いました。

> 値が既に決まっていたら
この部分がよく分からないんです。
値が決まる、というのはもうこれ以上簡約できない状態にまで簡約される、
という事ですか。

次のページに下記の式があって

exam4 = list ++ [last list]
where
list = [1 .. n]

これは list が [1 .. n] を hold on to しているので O(n) だそうです。

そういう理由でこれが O(n) なら、この [1 .. n] を [1, 2, 3, .... n] にしても、
おなじ O(n) 必要な気がします。

もしそうなら、[1, 2, 3, .... n] を引数にして関数を呼べば、
その引数がこれを hold on to するので O(n) 必要な気がするのですが、
違うのでしょうか。

0956デフォルトの名無しさん

2009/09/03(木) 18:30:23

つまりですね、何らかの追加的な計算が生じなければ、
「アルゴリズムの」ではなく「ある式の」計算量（複雑性）などと言っても
意味がないのでは、ということです。

0957デフォルトの名無しさん

2009/09/03(木) 18:37:30

>>956
すいません、何らかの追加的な計算とは例えばどういったものでしょうか。

>>943 の「リスト内の全ての要素を評価する関数に引数として c1 や c2 を渡したら」
というのとは追加的な計算とは違うものでしょうか。

0958デフォルトの名無しさん

2009/09/03(木) 18:42:08

>>956
あ、たぶん意味が分かりました。
よく読み返してみたら [craft of] で言っているのは、
ある式の複雑性ではなく、ある計算の複雑性でした。

つまり、「リスト内の全ての要素を評価する関数に引数として c1 や c2 を渡したら」
なんて言っても、その全ての要素を評価する関数の計算方法を決めてやらなければ、
それによって複雑性は如何様にも変わってくるということでしょうか。

0959デフォルトの名無しさん

2009/09/03(木) 18:47:59

exam4で言えば、「list」の具体的な値を求める計算の中でどれだけ同時に記憶領域を使うかという問題だろうと思ったわけです。
それ以外の計算は、exam4のアルゴリズム全体が要求するものですし。

0960デフォルトの名無しさん

2009/09/03(木) 18:50:23

それが遅延評価でしょ。捨ててしまえば0だし。

0961デフォルトの名無しさん

2009/09/03(木) 18:52:15

言い換えると、
同じ式でも、組合せ方によって（次々領域を解放するかによって）遅延評価のコストが違ってくるよ、
という話に見えたという。

0962デフォルトの名無しさん

2009/09/03(木) 18:53:10

>>960
すいません、質問者である私自身がかなり混乱しているので、
どのレスの何に対して言っているのか明確にして頂けるとありがたいです。

0963デフォルトの名無しさん

2009/09/03(木) 18:55:24

とりあえず
>>955 ← >>956
>>958 ← >>959、>>961

0964デフォルトの名無しさん

2009/09/03(木) 19:04:50

>>958の後半の認識で一致していると思います

0965デフォルトの名無しさん

2009/09/03(木) 19:16:20

それが遅延評価だもんね

0966デフォルトの名無しさん

2009/09/03(木) 20:13:24

>>964
わかりました。
では、次のように定義した foldl に引数として渡した場合はどうでしょうか。

foldl :: (a -> b -> a) -> a -> [b] -> a
foldl f st [] = st
foldl f st (x:xs) = foldl f (f st x) xs

(d1) foldl (+) 0 [1 .. n]
(d2) foldl (+) 0 [1, 2, 3, ..... n]

この２つの計算時の空間複雑性はどうなんでしょうか。

0967デフォルトの名無しさん

2009/09/03(木) 20:17:14

どちらも
int v = 0;
for (int i = 1; i <= n; ++i) { v += i; }
return v;
レベルにまで最適化されるのでO(1)

0968デフォルトの名無しさん

2009/09/03(木) 20:22:34

>>967
それなら >>955 の exam4 も
exam4 = [1 .. n] ++ [last [1 .. n]]
レベルにまで最適化されて O(1) だと思うのですが、
何故こちらは最適化されないのでしょうか。
そういうルールなんでしょうか。

0969デフォルトの名無しさん

2009/09/03(木) 20:26:08

>>968
> exam4 = [1 .. n] ++ [last [1 .. n]]

と>>955の、

> exam4 = list ++ [last list]
> where
> list = [1 .. n]

の違いを頑張って理解しなよ。

それから、

>>941
> (c1) [1, 2, 3, 4, 5, ...... , n-1, n]
> (c2) [1 .. n]
>
> 私は違うのではないかと考えているのですが。

違うと思う理由を「説明」してみて。

0970デフォルトの名無しさん

2009/09/03(木) 20:36:42

>>969
違いを頑張って理解しようとしている最中なので、しばし待ってください。

> 違うと思う理由を「説明」してみて。
>>944 が理由です。

もう一度いいますと、私は未出力部分はサイズというのは、
式を構文の要素に分けた時のその要素数＝サイズだと解釈しました。
それは違うよと言われていないが、この認識が正しいとも確信がないので、
とりあえず未だにこの考えでいます。

なので、c1 は要素数は n に因らず一定だし、
c2 はサイズの増加が n の線形になっているように私には見える。
だから違うと思いました。

0971デフォルトの名無しさん

2009/09/03(木) 20:37:28

すいません。

私は未出力部分はサイズというのは、
==>
私は未出力部分「の」サイズというのは、

0972デフォルトの名無しさん

2009/09/03(木) 20:46:23

exam4は生成後のリストの長さがn + 1だからO(N)じゃね？
仮にコンパイル時に展開されたとしても評価されたときには
リストの長さ分のメモリを食うわけだし
そういう理解じゃ駄目なの？
あと、foldl (+) 0 [1..n]はIntegralだとO(N)ぐらいになるかも…

0973デフォルトの名無しさん

2009/09/03(木) 20:51:06

> > list = [1 .. n]

これは共有される。

> > (c1) [1, 2, 3, 4, 5, ...... , n-1, n]

これは外延的に列挙した記法のつもりらしい。

[1, 2, 3, 4, 5, (略) , n-1, n]

0974デフォルトの名無しさん

2009/09/03(木) 21:04:03

list ++ [last list]
これは、本来単調なループでも書けるくらい簡単な仕事だけど、
こうやって名前をつけて2度書くと一旦全部展開しちゃうんだよ、みたいな例だよね？
ぶっちゃけ考えたことなかったｗ
勉強になります

0975デフォルトの名無しさん

2009/09/03(木) 21:09:39

いやまてよ…そんなに簡単でもないかも…
やばいProlog脳か…

0976デフォルトの名無しさん

2009/09/03(木) 21:11:02

>>973
ということは、共有されなければ、
where 節で定義しても O(1) で計算できるということでしょうか。

exam5 = list ++ [last [1 .. n]]
where
list = [1 .. 5]

これは O(1) ですか。

0977デフォルトの名無しさん

2009/09/03(木) 21:11:50

すまん、焦ってた。

exam5 = list ++ [last [1 .. n]]
where
list = [1 .. n]

です。

0978デフォルトの名無しさん

2009/09/03(木) 21:50:24

グラフ簡約面白いな

0979デフォルトの名無しさん

2009/09/03(木) 21:57:04

よくよく考えてみたら、exam4 でも O(n) になる理由が分かりません。
(++) と list は次の様な定義ですよね（それぞれ一行にまとめました）。

(++) [] [] = [] ; (++) [] ys = ys ; (++) xs [] = xs ; (++) (x:xs) ys = x : (xs ++ ys)
last [] = error ; last [x] = x ; last (x:xs) = last xs

だとすると、exam4 の評価ステップは次の様になりませんか。

list ++ [last list]
==> (++) list [last list]
==> ++ の定義のどれにマッチするのか調べるために、引数が [] かどうか調べる
==> どちらも [] ではないので最後の定義にマッチする
==> (++) [1 .. n] [last list]
==> (++) 1:[2 .. n] [last list]
==> この時点で x=1、xs=[2 .. n]、ys=[last list] となっているはず
==> 1 : ((++) [2 .. n] [last list])
==> 以下、++ の２つ目の定義にマッチするまで続く

こう考えましたが、すると ++ の２つ目の定義にマッチするまで
list は [1 .. n] をずっと束縛したままなのですが、
それでも、その為に必要なメモリ量は n に依存しない、
つまり [1 .. 3] でも [1 .. 10] でも変わらないような気がするのですが。
どこが間違っているのでしょうか。

0980デフォルトの名無しさん

2009/09/03(木) 22:18:21

>>979
> ==> (++) 1:[2 .. n] [last list]

list変数が押えているから、
このパターンマッチ渡しで受けている1:のコンスセルは捨てられないのだよ。

0981デフォルトの名無しさん

2009/09/03(木) 22:27:35

>>980
何か見えてきたような気がします。
たとえば次の所までステップが進んだとして、

1 : 2 : 3 : 4 : ((++) [5 .. n] [last list])

この段階の list は 1 : 2 : 3 : 4 : [5 .. n] を指して（押さえている）いる
ということでしょうか。

だから、++ の２つ目の定義にマッチするまで、
1 から n までの長いリストがずっと保存されるから O(n)
ということでしょうか。

0982デフォルトの名無しさん

2009/09/04(金) 06:45:44

そうです。
main = print [1 .. 10]
ならコンスセル一個とGCで済みます。(実装によっては二個)

0983デフォルトの名無しさん

2009/09/04(金) 18:33:12

>>982
なるほど、これについてはやっと納得できました。

ただ、>>967 で O(1) になる理由が曖昧なのではっきりさせたいです。
そもそも「最適化」の仕組みやルールがはっきりしないのですが・・・

foldl の定義が次の様だとして
foldl f st [] = st; foldl f st (x:xs) = foldl f (f st x) xs

次の様に評価のステップが進んだらどちらも O(n) になりませんか？
foldl (+) 0 [1 .. n]
==> foldl (+) 0 1:[2 .. n]
==> foldl (+) ((+) 0 1) [2 .. n]
==> foldl (+) ((+) 0 1) 2:[3 .. n]
==> foldl (+) ((+) ((+) 0 1) 2) [3 .. n]

つまり、((+) 0 1) を評価して 1 にまで簡約しなくても
foldl の２つ目の定義にマッチできるのではないでしょうか。
（+ 演算子の戻り値の型さえ分かれば評価しなくても foldl にマッチする事が分かる）

評価しなくてもマッチするが、それでも効率化のために評価してしまうのが、
最適化なのでしょうか。

それとも最適化は関係なく、((+) 0 1) などは既に出力されていると見なすのでしょうか。

0984デフォルトの名無しさん

2009/09/04(金) 18:36:46

>>967は「最適化」とか適当なこと言っているから気にするな。

0985デフォルトの名無しさん

2009/09/04(金) 18:59:57

>>983
[m..n]というのはenumFromToの構文糖衣と考えれば、これはunfoldrを使って
unfoldr f n
f x = x -> if x <= m then Just x else Nothing
と書けるから

foldl (+) 0 (unfoldr f 0)
= {unfoldr}
foldl (+) 0 (0:unfoldr f 1)
= {foldl}
foldl (+) (0+0) (unfoldr f 1)
= {...}
foldl (+) z (n:[])
= {foldl}
z+n

でfoldlのアキュムレータと(x:未評価のy)
という形のリスト分のメモリしか使用しないのでO(1)
他の例でも[m..n]というものをenumFromToつまりunfoldで置き換えてみよう

0986デフォルトの名無しさん

2009/09/04(金) 19:08:16

あーなんか変だ
f x = if x <= m then Just (x,x+1) else Nothing
[1,3..n]なら
Just (x,x+2)になる

0987デフォルトの名無しさん

2009/09/04(金) 20:55:36

>>985 >>986
[m..n] を unfoldr を使って表現するなら、
f x = if x <= n then Just(x, x+1) else Nothing
unfoldr f m
ですよね（あなたの定義だと m と n が逆なのでは？）。

それは些細な事なのでいいのですが、私が疑問に思っているのは、

==> foldl (+) ((+) 0 0) (unfoldr f 1)
==> foldl (+) ((+) 0 0) (1 : unfoldr f 2)
==> foldl (+) ((+) ((+) 0 0) 1) (unfoldr f 2)

というように + 演算子を引数に適用しないでずっと残していたら、
その分の記憶領域が必要にならないのか、という点です。

で私の考えは、+ 演算子とその引数は評価しなくても foldl にマッチするので、
この時点では評価はされず、つまり + 演算子を引数に適用させずにずっと残ると思うのです。

それは、unfoldr を使おうが、別の方法で [m .. n] を表現しようが同じだと思うのですが。

0988デフォルトの名無しさん

2009/09/05(土) 01:04:45

グラフ簡約だから(+)は一つ記憶しとけばいいのでは?

0989デフォルトの名無しさん

2009/09/05(土) 10:09:37

>>988
(+) の引数（0 や 1 や 2 など）はどれだけ記憶しておけばいいのでしょうか。
全く記憶する必要はないのですか？

0990デフォルトの名無しさん

2009/09/05(土) 21:48:32

zip-archive-0.1.1.3を使っています
このライブラリではData.ByteString.Lazyをソースファイルに使うので
Zipファイルの扱いも定量スペースでできることを期待していたのですが
head $ filesInArchive archiveを評価すると、Zipファイル全部を
メモリに読み込もうとします。

ライブラリのソースを読んでも、どうして定量スペースで処理されないのか
私のレベルでは理解できませんでした。
どなたか御教授ください。
よろしくおねがいします。

0991デフォルトの名無しさん

2009/09/06(日) 12:06:09

おもしろそうなんで調べてみた。
zip-archiveはData.Binary.Getっていうバイナリデータ用のパーサを使ってる。
それで、ZIPファイルを読み込むtoArchiveを単純化すると次のような関数になる。

\入力 -> if パース成功? then 読み込んだデータ else error "エラーメッセージ"

ここで「読み込んだデータ」にアクセスするためには「パース成功?」の部分をTrueかFalseへと完全に評価しなければならない。
この場合「パース成功?」という式は、ZIPファイルが途中で切れてないことなどをチェックする式で、この式を評価するためにはZIPファイルを最後まで読まなければならない。

# ちなみに結果のごく一部にアクセスしたいだけなのに入力を全て読み込まないといけないという問題は多くのパーサにある。

じゃあData.ByteString.Lazyを使う意味はないのかというと、パースした途中でエラーがあったときに残りの部分を読まないとか、ZIPファイルの後に大きなゴミが付いててもその部分は読まないとかの利点はある。

0992990

2009/09/06(日) 13:44:49

>>991
非常に分かり易い説明、ありがとうございます。
ファイル毎にrunGetするような実装に書き換えてみたいと思います。
ありがとうございました。

0993デフォルトの名無しさん

2009/09/06(日) 16:01:54

さっきうちのHugsがPreludeの読み込みに失敗したのも、そっち系かな

レス数が950を超えています。1000を超えると書き込みができなくなります。