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

関数型プログラミング言語 Haskellについて語るスレです。

前スレ: 関数型プログラミング言語Haskell Part23
http://toro.2ch.net/test/read.cgi/tech/1376111807/

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

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

過去ログ (10〜)
Part21 ttp://toro.2ch.net/test/read.cgi/tech/1358702176/
Part20 ttp://toro.2ch.net/test/read.cgi/tech/1350428908/
Part19 ttp://toro.2ch.net/test/read.cgi/tech/1340760070/
Part18 ttp://toro.2ch.net/test/read.cgi/tech/1331902463/
Part17 ttp://toro.2ch.net/test/read.cgi/tech/1325510368/
Part16 ttp://toro.2ch.net/test/read.cgi/tech/1317958045/
Part15 ttp://hibari.2ch.net/test/read.cgi/tech/1310199414/
Part14 ttp://hibari.2ch.net/test/read.cgi/tech/1299385928/
Part13 ttp://hibari.2ch.net/test/read.cgi/tech/1286706874/
Part12 ttp://hibari.2ch.net/test/read.cgi/tech/1272536128/
Part11 ttp://pc12.2ch.net/test/read.cgi/tech/1252382593/
Part10 ttp://pc12.2ch.net/test/read.cgi/tech/1231861873/

　　　　 　　　　　　　　　　ノ 　　　　 ﾟ.ﾉヽ　 , /}　　　　　　...
　　　　　　　　　　　　,,ｲ`"　　　　　､-' 　 `;_' '　　　　..::::::::::::::...
　　　,-､　　_.._　　　(　　　　　　　　(,(~ヽ'~　　　　　..:::::::::::::::::::::::
　）'~ 　ﾚｰ'　　〉　　 ヽ　　　　　　　i`'}　　　　　　　.:::::::::::::::::::::::
　~つ　　 　　'-ｰ､　　i　　　　　　　|　i'　　　　　...:::::::::::::::::::::::
　／　　　　　　 <　　/　　　　　。/ 　 !　　......:::::::::::::::::::::::::　　　　これは>>1乙じゃなくて
/　　　　　　　　　~^´　　　　 /},-''　,●::::::::::::::::::::::::::::::::::::
i､　　　　　　　　,i'　_,,...,-‐-､/　　　 i　 ::::::::　　.:::::::::::::
..ゝ　　　　　　　　<,,-＝=､　　　,,-,/　　　　　 .:::::::::::　　　　　　　　　　　　放射能がうんたら
　)　　　　　　　{~''~>`v-''`ｰﾞ`'~　　　　　　　..:::::::::　　　　　　　　　　　　　　　　　　　　　　　　　　........::.
　{　　　　　　　 ﾚ_ﾉ　　　　　　　　　　　　..::::::::.　　　　　　　　　　　　　　　　　　　　　　　　　......:::::::::
ノ　　　　　　　　　''　　　　　　　　　　　..:::::::　　　　　　　　　　　　　　　　　　　　　　　 ...::.:...:::::::::
　　　　　　　　　　　　　　　　　　　　 .:::::::::　　　　　　　　　　　　　　　　　　　　　...:......::::::::::::　.
　　　　　　　　　　　　　　　　　　　　.:::::::::::.　　　　　　　　.....　　　　　 ..　　..::::::::::::::::::::::::　　　:::.
　　　　　　　　　　　　　　　　　　　　::::::::::::::::.::::::....:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::..　::　 ::..
　　　　　　　　　　　　　　　　　　　 .::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::　:::　　　　::.
　　　　　　　　　　　　　　　　　　　　:::::::::::::::::　::::::::::::::::::::::::::::::　:::::
　　　　　　　　　　　　　　　　　　　　　　　　　 .::　　　 ::.　　:::

過去ログ (20〜)
Part23 http://toro.2ch.net/test/read.cgi/tech/1376111807/
Part22 http://toro.2ch.net/test/read.cgi/tech/1364009659/
Part21 ttp://toro.2ch.net/test/read.cgi/tech/1358702176/
Part20 ttp://toro.2ch.net/test/read.cgi/tech/1350428908/

C++の限界
http://www.digitaltrends.com/wp-content/uploads/2013/02/gtav.jpg

C#の限界
http://www.stfuandplay.com/images/uploads/GunsIO-TOP.jpg

Haskellの限界
http://www.haskell.org/wikiupload/c/c2/Frag1.png

最高

Haskellのコスパのいい勉強順序とは？

C++←自転車
C#←空中戦艦
Haskell←ソルジャー

C++が最弱！ありえん！なんで自転車！

>>6
他の言語と同じだよ。

1. まず Hello World 含むトイプログラムを何十個と書いては実行し、
主な文法や機能を身に付ける。

2. 次にそれらのプログラムの実行がなぜ意図した結果になるのか、
中でどのような処理が行われているのか、その意味を理解する。
ただし、Haskell の場合は C や Java などと違ってここが難解なので、
具体的にコンパイラがどのようなコードを吐くかまでは理解しなくてもよい。
もっと抽象的に、プログラムを順に弱頭部正規形に簡約して評価していく様子が
頭に思い浮かべることができれば十分。

3. 何か小さなアプリをいくつか作り上げてみる（完成させるのがポイント）。
linux の echo コマンドや cat コマンドの簡易版でも良い。
完成したら、いくつか機能を付け加えてみる。

4. いくつか作ってみるうちに、ボイラープレートを何とかしたいなとか、
もっと簡単に機能を加える方法はないものかとか、
なんかプログラムが汚くてかっこ悪いなとか、いろいろ思うところが出てくる。
そうしたら、他人のコードを見たり、BBSで質問したり、
問題を解決してくれそうなライブラリを探したりすればいい。

実際はこんな綺麗にステップアップ式に学べるものではなく、
おそらく 2 3 4 を行ったり来たりすることになるが、
概ねこのような順で学ぶといいのではないか。

コストを時間と捉えるなら、私はこの順を勧める。

プログラマは頭なんてよくないよ
一種のサバン症候群だから日本語は苦手

>>8
これはありがたい

ネット上で日本語の質の良い入門サイト教えてほしい

gentle introductionの日本語訳

サンプル見ながらでしか書けない人っているよね

文字列を出力して改行する = putStrLn
こんにちは、世界 = 文字列を出力して改行する "こんにちは、世界"

SL4A で動きますか？

>>14
へー(、)という演算子が定義できるのか

冗談抜きでプログラムさくさく書けるひと尊敬するわ
コミュ障が多いけど

今時プログラムをさくさく書けないって古い地球人過ぎないか

マルチポストに反応する新しい地球人

>>13
関数マニュアル見ただけでかけるほどマニュアルはちゃんとかけてないし、
そもそも関数自体がそんな風にできてない
とすればどういう使い方を想定して関数があるのかをサンプル見て知るしかない

>>12
これのこと？
ttp://www.sampou.org/haskell/tutorial-j/index.html
結構古いけどhaskell98って今のhaskellと違う部分とか無いのかな

そんなに変わってない。基本的に高度な機能は言語拡張（処理系依存）でカバーするから
http://www.haskell.org/haskellwiki/Haskell_2010#Changes_since_Haskell_.2798

じゃあ大丈夫か
でもやっぱりそのサイトの日本語分かりづらかったから本買おうかな
Lispから本格的にHaskellに入信しようか迷う

Haswell の GUI は何がメジャーですか

gtk+とwxHaskellかな
qtもあるけど長いこと更新されてないと思う

節子それHaswellちゃう

通はHaskell+GLUT

http://www.haskell.org/haskellwiki/X_window_programming_in_Haskell
Xサーバでも、Xqartz、Xmingで動けばいちおうクロスプラットフォームになるのか。

よくかんがえてみたらJavaの実行環境もそんなもんだったな
インストーラ作ってハードル下げればクロスプラットフォームになるんじゃ

>>27
いや、Haskell+GLFWだね

Win32APIで勉強してる

結局よくあるプログラムには向いてないんだよね?
そういうのも綺麗にシャレオツに書ける言語ないかな。

>>32
地球には今のところ無いが、地球の科学技術レベルはまんざらでもなく１０年後くらいにはあるかも。

お、おう

プログラムを作ることに向かないプログラミング言語Haskell

でも論文採択率は良さそう...

WindowsやAndroidでも普通に動けばな

F#でいいんじゃねぇの

逆に関数型で生まれた概念が他の言語に入れば満足だ
純粋関数だけでどうせプログラム組めないし

>>39
一番成功している関数型言語がC言語というオチ

Cが関数型言語ってどういうこと
プリプロセッサで頑張る話?

手続き型言語が体に馴染んでいるならそれ使ってればいいじゃん？って思うんだけど
Haskellが第一言語の俺達とは相容れない運命なのさ…

pascalが手続き型でcが関数型だと勘違いしてた時期が俺にもありましたw

>>41
別にプリプロセッサだけで頑張る必要ないだろ。
純粋性を保つようにコードを書けばいいんじゃね？

>>44
あいや、Cで関数型と聞いて思い当たったのがプリプロセッサを純粋関数型言語として使うという話しかなかったので
Cの #define を駆使するとプリプロセッサだけで案外ちゃんと計算ができるんだけど、代入が表現できないので純粋関数型言語の作法で書かざるを得ないというネタ(思い出してみたらネタだったけど煽る意図ではなかった)

>>44
保証がない

昔から一応functionalヘッダ持ってたり最近ラムダ式とか仕様に入れだしたC++を挙げるならまだしもなぜわざわざCを

Haskell の解説を見ると呪文のようにループは再帰があればって書いてあるけど
本当はループ欲しいんじゃないの?

>>46
unsafePerformIOだって保証ないじゃん

>>49
無理に穴を見つけようとしないで、もっと気楽に素直になれ

>>48
心の底から要らない。あっても使わない

>>48
ループはいらんかもね。
俺は再帰よりもmapとかを多用するようになった。

caseいらないとかも同じで
最初から完璧な最終的なコード書けるならいいけど
実験的なコード書いてるときはどうしてもゆるい書き方が欲しくなるのだよ

xml-conduit モジュールの Text.XML.Cursor.content や attribute などは
戻り値として text モジュールの Data.Text.Internal.Text 型のリストを返します。

このリストの要素に対して text モジュールの Data.Text.unpack 関数を適用すると
String 型の値が返ってきます。

しかし、なぜ Data.Text.Internal.Text 型の値に
Data.Text.unpack 関数が使えるのでしょうか。

Data.Text.unpack :: Text -> String の第1引数の型は
Data.Text.Text であって、Data.Text.Internal.Text ではないにも関わらず、です。

>>54
コンパイラーさんがいいと言ってるんだから、細けぇことはいいんだよ！

再帰はスタックを馬鹿食いするから多用すべきではない

>>55
真面目にお願いします

>>54
名前空間が違うだけで、型は同じ。

>>56
List->Listなら、再起でもスタック消費しない。
それ以外は基本、末尾再帰。

>>57
http://hackage.haskell.org/package/text-0.11.3.1/docs/src/Data-Text.html

Egisonの話題ってここで良いの？

ダメだろ

どこですればいい？

>>63
こちらで
http://toro.2ch.net/test/read.cgi/tech/1383219359/

おっ　サンキュー

>>58
>>60

「名前空間が違うだけで、型は同じ」 そういうことなんですね。

でも、どうしてわざわざ Internal の方の名前空間を使うのでしょうか。

"Internal" というモジュールは他のライブラリでもありますが、
基本的にはより低レベルの内部的な処理のためのものだと思います。
ライブラリを利用する側の者が使うのはあまり好ましいことではないような気がしますが、
Data.Text.Internal の説明には

Modules which extend the Text system may need to use this module.

とあるように、むしろ Data.Text ではなくこちらを使うよう促していますよね。
なぜなんでしょうか？

>>66
それ以上は言語とは関係ないライブラリ固有の話題だからドキュメント調べろよ

>>66
＞Modules which extend the Text system
ってライブラリを拡張する場合だから、ただの利用者じゃないでしょ。

>>68
その上、その後ろに、こう書いてあるしな。

You should not use this module unless you are determined to monkey
with the internals, as the functions here do just about nothing to preserve
data invariants. You have been warned!

そもそも、>>54の前提がおかしい。

>xml-conduit モジュールの Text.XML.Cursor.content や attribute などは
>戻り値として text モジュールの Data.Text.Internal.Text 型のリストを返します。

ソースを見るとこうなってる。
http://hackage.haskell.org/package/xml-conduit-1.1.0.7/docs/src/Text-XML-Cursor.html#content

import qualified Data.Text as T
content :: Cursor -> [T.Text]

>>69
ghci の :t コマンドで型情報を調べたのですが、
どうも、現在どのモジュールを読み込んでいるのかによって
:t コマンドの結果が違うようです。

ghci を立ち上げた直後に :m + Text.XML.Cursor として
モジュールを読み込んだ状態だと、次のようになりました。

Prelude Text.XML.Cursor> :t content
content :: Cursor -> [Data.Text.Internal.Text]

Data.Text モジュールも一緒に読み込むと次のようになりました。

Prelude Text.XML.Cursor Data.Text> :t content
content :: Cursor -> [Text]

:l で読み込んだ自作のモジュール内に import Data.Text (Text) という記述があっても、
:t で型を調べるときは上記のように「何を :m で読み込んでいるか」によって結果が変わるみたいです。

私は ghci 上の Prelude Text.XML.Cursor> の状態で調べていたようです。

本当の型を調べるには :t は役立たず、ソースを読まなければならないということでしょうか。


環境
ghc 7.6.3

te

>>70
牛丼屋に入って調理場に向かって”並・たまご”と言うか、
カウンターで注文取りにきた人に”牛丼並盛・たまご1つ”
と言うかの違い。

基本的には出てくるものは同じだが、掟破りの注文方法がずっと通用する
保証はどこにもない。

t

>>72
今回の件で言えば、どれのことを「掟破り」と喩えているのでしょうか。

Data.Text.Internal.Text 型を使うのが掟破りで、
Data.Text.Text 型を使うのが通常の方法という意味でしょうか。
それだと、やはり ghci の :t では掟破りかどうかを判断できないということでしょうか。

それとも、型を調べるのにソースを参照するのが掟破りで、
ghci の :t を使うのが通常の方法ということでしょうか。
それだと今回のように正しい判断ができなくなります。

>>74
型を調べる正しい方法はドキュメントやソースを読むことであって、
:t を使うのは調理場の中に入って自分でご飯をよそうようなことだと思うけど。

ドキュメントはともかくソースを読んじゃダメでしょ
内部実装はいつ変更されても文句言えない

:tを使うのは食べログみる感じじゃない？
食べログで確認したとおりに二郎で注文したのに「うちはマシマシ禁止です」って
怒られたことがある

・モジュールは、別のモジュールからインポートした型や関数を再エクスポートできる
・Data.Textは、Data.Text.Internalで定義されたTextという型を再エクスポートしている
・再エクスポートしても実体は一つ。同じ型
・textパッケージの作者から見ると、TextがInternalで定義されているというのは実装の詳細で、
　普通の利用者にはData.Textからインポートして欲しいと思っている
・ghciから見ると、作者の意図など知ったこっちゃないので、:tでは
　Textが実際に定義されているInternalモジュールを提示する

C言語のヘッダファイルのような、モジュールの公開情報を知る方法ってないの？
型の定義とか、関数の型とか。
ドキュメントは古かったり間違ってたりするよね。ってのは偏見かなぁ。

下手くそな比喩やめろ

まだハスケルってあったの？
もうとっくに消えたかと思った。
C言語が流行ったときのパスカルみたいな存在だよねw

連続して訳の分からない比喩が

>>76
たとえば Text.XML.Cursor モジュールのドキュメントの content :: Cursor -> [Text] の項を見ると、
Text のリンクは Data.Text.Text ではなく、Data.Text.Internal.Text へ飛びます。

それが本当は Data.Text.Text を指していることは、今回ソースを読んだ >>69 の指摘でわかりました。

やはり型を知るにはソースを読まないといけないのが現状だと今回の件で認識しました。

それとも、もしかしてドキュメントのリンクがこのようになっているのは私だけでしょうか。
たとえば、ライブラリ（ドキュメント）のインストール順序によってはリンクがおかしくなるとか・・・

>>74
>Data.Text.Internal.Text 型を使うのが掟破りで、
>Data.Text.Text 型を使うのが通常の方法という意味でしょうか。

そういうこと。Text.XML.Cursor.contentも、そうしてる。

ghciは自分の知ってる型の中から合致するものを報告するだけ。
（xml-conduit モジュールの作者の意図とは無関係）

>>83
もしかして、Data.Text.Internal.TextとData.Text.Textが違うものだと
思ってる？

本体はData.Text.Internal.Textに定義してあって、Data.Text.Textは
そのリンクだと思えば良いよ。
でも、ライブラリ作者がユーザーに使ってもらいたいのはリンク(Data.Text.Text)の方。

ghciは空気読めないから、その作者の意図に反して本体を示すことがある。
haddocで自動生成されるドキュメントも同じこと。

>>83
>やはり型を知るにはソースを読まないといけないのが現状だと今回の件で認識しました。

極論を言えば、そういう場合もあるけど、今回の場合は”.Internal.”をみて、ユーザが
作者の意図を察してあげるのがプログラマ社会のルールだと思う。

>>79
haddockドキュメントの中でで、英語で書いてある部分は全部無視して型情報だけ見ればいい
そこは自動生成なので古くならない

>>84
> もしかして、Data.Text.Internal.TextとData.Text.Textが違うものだと
> 思ってる？

初めはそう思っていましたが、皆さんの指摘を受けて同じものだと知りました。

>>66 の時点で同じものだと知りましたが、ghci の :t を疑わなかったので、
同じ物のうちで TextとData.Text ではなく Data.Text.Internal の方を公開している
という勘違いをずっとしていました。
その勘違いも理解できました。

> 今回の場合は”.Internal.”をみて、ユーザが
> 作者の意図を察してあげるのがプログラマ社会のルールだと思う。

それなら仕方ありません。
私もそのように従うことにします。

みなさんアドバイスありがとうございました。

Haskellにはモジュール化設計や抽象データ型といった
モダンな大規模開発向け機能が欠落しているのかね？

モジュール化設計機能を備えた言語であれば、
モジュールの外部仕様(interface)と実現方法(implement)を
分離できるから、ツール類で実装向けデータ構造と
ユーザ提供向けデータ構造を正しく認識できるから、
>>87みたいな:tコマンドやhaddockでの誤認識は起こりえない

また、抽象データ型機能を備えた言語であれば、
内部の実装向けデータ構造をユーザから完全に隠蔽できるから、
Data.Text.Internalみたいな実装向けデータ構造が
外部から見えてしまうという根本の問題が生じ得ない

Haskellは関数型言語研究の最新の成果を反映した先端言語という
ふれこみであるけれど、(結局は数学者/研究者向けの言語だから、)
ソフトウェア工学において大規模開発では必須と認められている
これらの機構が完全に無視されてているように見える

結論として、Haskellは研究や試作といった用途には適しているのかも
しれないけど、大規模開発＆保守性を要求される産業界での
実用的な開発には不適格な言語ではないのかと考える

>>88
日本語が変だったので、以下の段落を書き直す

>モジュール化設計機能を備えた言語であれば、
.... 中略 ....、
>>>87みたいな:tコマンドやhaddockでの誤認識は起こりえない


モジュール化設計機能を備えた言語であれば、
モジュールの外部仕様(interface)と実現方法(implement)を
分離できるから、ツール類でも実装向けデータ構造と
ユーザ提供向けデータ構造を正しく認識できるはず
(もしできないのであれば、ツールのバグか機能不十分と見なすべき)
結果として、>>87みたいな:tコマンドやhaddockでの誤認識は起こりえない

あえてオブジェクト指向という言葉を避けているように見受けるが何かあるのか？

Haskellはデータとプロシージャが分離してる

インターフェースも実装も実体も同じ物2つをさして
見分けられないからモジュール性に優れてないってめちゃくちゃ言ってるな
単なるghcの不具合ってだけだろ

>>88
>分離できるから、ツール類で実装向けデータ構造と
>ユーザ提供向けデータ構造を正しく認識できるから、
今回の例ではデータ構造は一つだからこれは当たらない

>また、抽象データ型機能を備えた言語であれば、
>内部の実装向けデータ構造をユーザから完全に隠蔽できるから、
もちろんHaskellでもこれはできる。でもtextパッケージはあえてやってない
一部の用途ではどうしても内部実装に踏み込みたいことがある
そういう場合に、実装を完全に隠蔽していたら、せいぜいソースをコピーして
パッチを当てるしか道がない
それよりは、「特殊用途向け」に.Internalモジュールを公開して、その代わり
これは内部実装だからマイナーバージョンアップで壊れるかもしれないよ、
気軽に使うなよ、と宣言しておくのがまだマシだという思想

慣れれば一瞬でループを再帰に置き換えられるもんなの?

>>90
モジュール化と抽象データの概念がソフトウェア工学研究の成果として
認知されたのが1970年代後半から1980年代
この頃に設計された Modula, Mesa, Ada といった言語には、これらの機能が備わっている
オブジェクト指向の概念が登場したのは、その後になる

つまり、オブジェクト指向という言葉を持ち出さずとも論証できるから、
というのが第一の理由


また静的型付け関数型言語である Standard ML(SML) は
オブジェクト指向の機構を一切持たない古い設計であるが、
完全なモジュール化と抽象データの仕組みを備えているから、
>>88,89の問題はどのSML処理系を利用していても現実に起きたことがない

つまり、SMLでも問題が生じないのだからオブジェクト指向とHaskellの問題は無関係
これが、オブジェクト指向という言葉を持ち出さない第二の理由

>>94
効率を考えないなら書き換え自体は別に難しくないだろ
関わる変数を全て引数にするだけだし

あと
>ソフトウェア工学において大規模開発では必須と認められている
>これらの機構が完全に無視されてているように見える
こういう明かな間違いを平気な顔で言うのは恥ずかしいから、
今後は入門書の一冊でも読んでから批判するのが良いと思う

20年にわたるオブジェクト指向の実験は失敗に終わった
従来の構造化プログラミングと1980年代のsmalltalkからのアドバンテージがなかった

>>92
どこにghcの不具合があるのか
ghcは正しくはどうするべきだったと思う？

>>93
>今回の例ではデータ構造は一つだからこれは当たらない

>>93の後段では「一般用途向け(Data.Text.Text)」と
「特殊用途向け(Data.Text.Internal.Text)」という
二種類のデータ構造を提供していると書いてあるように読めるから、
矛盾していないかな？


>それよりは、「特殊用途向け」に.Internalモジュールを公開して、その代わり
>これは内部実装だからマイナーバージョンアップで壊れるかもしれないよ、
>気軽に使うなよ、と宣言しておくのがまだマシだという思想

こういったレイヤの異なる二種類のインターフェイスを提供するという考え方(思想)は、
決して間違いではないとは思う
ただし、SMLを含むモダンな言語のモジュール化機構では、
アプリケーション側で用途に応じて必要なモジュールだけをimportできる仕組みが、
言語仕様の一部として提供されている
結局、このレス(>>93)では、まともなモジュール化機構を持たないHaskellが
(形式的な理論ではなく)コード設計技法という小手先のテクニックで
モジュール化機能を模倣している、という説明にしかならない

これは、モジュール化機構を持たないJavaScriptが、コード設計技法と規約によって
モジュール化の基本である階層的名前空間を実現している実情と、よく似ている
そして、モジュール化機能がツールで支援できない点もHaskellと同様だ

Haskellは静的型付けだからコンパイルできればおｋ
例外が出たときは書いた奴が悪い
GHCは何も悪くない

>>97
間違っていると批判するのなら、>>97が正しいと考える
「大規模開発で必要とされる要素」を>>97自身が説明すべきではないのかな？
自らの意見を述べずに批判するだけなら、アホ民主党と何ら変わりがない

>>100
>矛盾していないかな？
Data.Text.TextとData.Text.Internal.Textは同じ型。あらゆる文脈で交換可能
(なので単にTextと書くことにする)
二つのモジュールの違いは、Data.Text.InternalがTextの内部実装に
アクセスする手段を公開しているのに対し、Data.Textはそうしていないこと

>アプリケーション側で用途に応じて必要なモジュールだけをimportできる仕組みが、
>言語仕様の一部として提供されている
これは当然Haskellにもある。ユーザは必要に応じてData.TextかData.Text.Internalの
一方または両方をimportする
>>97を繰り返すけど、入門書の一冊でも読んでから批判するのを勧める

Internalなどただの習慣にすぎない
exportしている関数は全部読めるだけだ
支障はない

>>102
いや、「大規模開発で必要とされる要素」については異論はないよ
Haskellには(簡素だけどちゃんと機能する)モジュールシステムと
抽象データ型を定義するための仕組みがある、と言っている

Text.ParsecをimportしてもText.Parsec.Stringで定義されているParserという型は使えない
Text.Parsecの中でText.Parsec.Stringをexportしていないから
それだけ

訂正
module Text.Parsec
( module Text.Parsec.Prim
略
, module Text.Parsec.String
略
) where

略

import Text.Parsec.String hiding ( Parser, GenParser, parseFromFile )

略

>>100
>アプリケーション側で用途に応じて必要なモジュールだけをimportできる仕組みが、
Haskellも特定モジュールのその上さらに特定データ型や関数のimportもできるけど
単に知らないだけだよね？君

>>99
gccみたいにalias名も出す

>>97
おれもHaskellはソフトウェア工学をかなり無視していると思う。
>>88 指摘は全く持ってそのとおり。
俺的にもpugsのオードリー・タンが大規模開発に成功したのはHaskellで（言語備え付けの機能を使わず）
構造化プログラミング（特に段階的詳細化法）をやったからだし。
Haskellは抽象データ型と実装の分離は一応できるものの、抽象データ型の利点であるはずのデータ構造を操作する手続きの
変更にやたら弱かった（はず）。

抽象データ型の利点は関連コードの局所化と仕様と実装の分離で、Haskellはなぜか
データ構造はデータ構造、そのデータ構造の操作はデータ構造の操作で、データ型の定義とは
別のところで定義しないといけない。だから大規模開発は（抽象データ型の発展系である）
オブジェクト指向には劣ると思う。

ただ、強い型付けのおかげで、JSP（ジャクソン流構造化プログラミング）には向いてる気がするんだよな。

>>111
そもそも、そのデータ構造の定義とデータ操作を同じ場所に記述するというのが失敗だった件
必要なのは、データ構造の抽象化ではなく、操作の方の抽象化だったというオチ

マイケルジャクソンは関係ないだろ

思ったんだがピラミッドって誰が設計したんだろう？

ソフトウェア工学ってオワコンじゃね？
いつの時代の話よ

似非OOPなんて、継承の弊害でメッキ剥がれてるだろ
DIとかインターフェース指向設計とか十分に経験則もできたんだから次に行けよ
もう不要な親子・依存関係とか作る時点で大規模向いてないんだよ

例えばC言語の場合は「公開ヘッダ」にData.Text.Textを定義して
「内部実装ヘッダ」にData.Text.Internalを定義して、
通常の利用者は公開ヘッダのみを用いてライブラリを使用でき、
特殊な利用者は内部実装ヘッダを用いてライブラリを使用できる。

だから今回のように「通常の利用者」が内部実装で使われている型を目にして混乱することはない。

でもHaskellでは「通常の利用者」に対しても内部実装ヘッダが公開されてしまうので、
今回のように内部実装を必要としない利用者に内部実装の型が公開されることで
:t の結果も内部実装向けの型を返すようになり混乱を招いている。

以上。

>>113
操作の方の抽象化とはなんのことだ？
抽象化、抽象化というがなんのために抽象化するかと言えば関連コードの局所記述を可能にするためだぜ。

>>118
>例えばC言語の場合は「公開ヘッダ」にData.Text.Textを定義して
>特殊な利用者は内部実装ヘッダを用いてライブラリを使用できる。
内部実装ヘッダを用いてって
内部実装外にAPI晒して内部実装用ヘッダも公開してますってなら同じだろ
頭悪すぎる

>>119
逆だろうが
抽象化は実装を外部に追い出すためだろ
一緒に書いてどうすんだよ

>>121
あ、ごめん。そうだわ。

寝ぼけて抽象データ型の話とごっちゃにしてしもうた。

>>110
>Haskellは抽象データ型と実装の分離は一応できるものの、抽象データ型の利点であるはずのデータ構造を操作する手続きの
>変更にやたら弱かった（はず）。
いやそんなことないと思うけど
具体例があればくれ

>>109
Textが再エクスポートされてるモジュールを全部列挙しろってこと？
:tで何か聞かれるたびにそれをするのは非現実的だろ

>>118
今回の問題では、利用者がData.TextとData.Text.Internalのどちらもインポートしていない
(もしインポートしていたら、ghciはData.Text.Internal.Textじゃなくて単にTextと答える)
だからghciにとってはどっちのモジュール名を使えば良いのか決められない
たまたま今の実装が、その型が定義されているモジュールの名前を返すようになってるというだけ

俺も今回の問題は単なる >>126 だと思う。
今回の件に限れば、これがコンパイル時に問題になることはない。

モジュール化設計機能や抽象データ型機能のレベルが
CやJavaなどで開発してきた者にとっては期待するほど高くない、
あるいはやや趣が異なり戸惑うというのはわかるが、
その根拠として今回の問題を挙げるのは的はずれだと思う。

>>126
間接的にでもData.Text.Internalが読み込まれている時点でおかしい
他のモジュール化が可能な言語ならData.Text.Internalがライブラリの外側まで漏れることはない

関数型は一言で表すと古くて新しい言語あるいは新しくて古い言語
一般的な言語しか触ったことない奴には関数型は新しく感じるけど
既に歴史自体結構長いし他の言語はどんどん新しい概念取り入れてるけどそこらへんはかなり昔のままだから古臭く感じる

>>128
こいつHaskellのこと何もわかってないだろ

ghciは実行時にリンクするからそう評価するだけじゃね
よくわからんけど
つか、hugsではどうなの？
インタプリタ専門だからその辺頑張ってそうだけど

>>129
モジュール化に関してはOCamlのが先進的機能たくさんあるわ
本当にOO言語その他をひと通り触ってたらそんな事言わねえよ
さっきからイメージだけで語ってんじゃねえよ

先進的？

>>128
GHCから見ればInternalモジュールも公開されたインタフェースの一部だよ
これをtextが意図的にやってるのは>>93の通り

>>134
他の言語を使ったことがない人には理解できないかもしれないが、
普通の言語は内部実装を公開したい場合は公開相手を選べるんだよ
今回みたいに一般の利用者まで巻き込んで可視範囲を広げるようなことはしない

だから「内部実装に触りたい人もいるから初期設定で全員に内部実装を公開してる」ってのは言い訳になってない

hackage.haskell.org/package/text/docs/Data-Text-Internal.html
hackage.haskell.org/package/text/docs/Data-Text.html
これ読めば全部わかるじゃん
ドキュメント読まない奴が悪いんじゃないの結局

>>135
可視範囲は広がってなんかないよ
今回はData.Text.TextもData.Text.Internal.Textもスコープの外
ghciは気を効かせてスコープの外の名前を無理矢理表示している
何も表示しないよりはマシ

ドキュメント読まないというよりHaskellのモジュールシステムを理解してない

>>138
では、理解できるように資料などがありましたら教えてください

>>111
関数だけでなくADTが必要という理論は
関数とデータ構造を区別するという前提がなければ成立しない

例えば関数と変数の名前空間を分ける言語とか
無名のデータ構造はあるけど無名関数がない言語とかはADTがないと駄目かもしれない
が、前提条件を満たさないものが劣っているというのは理論的にいえることではない

>>139
http://www.haskell.org/onlinereport/haskell2010/haskellch5.html#x11-980005

Javaとかのウンコ言語信者が
1ミリも理解できてないHaskellを何故かdisってる、
って理解でOK？

SML信者じゃね

>>141
ありがと。

classには変数と関数があったけど
interfaceは関数しかなくなったので
「関数だけでは物足りないよね」っていうマーケティングが効かなくなった

>>144
ありがとって、これ言語仕様じゃん
訊く前に真っ先に調べるモンちゃうの？
Haskellの仕様について深く議論しようとしてるんだし

Javaの信者なんているわけないだろ
どんな人生送ってたらそんな発想になるんだ

>>135
ちょっとその普通の言語でtextと同じ仕組みで型を公開しつつ可視範囲を限定できるコード書いてよ

もしも多数決と順張りだけで勝ち続ける人生だったらJavaの信者になるかな

そもそも用語の定義があいまいだからな
可視範囲って何だよ

scopeの訳語じゃないの

変数持続期間と違うの？

>>142
みんな勘違いしてるけど、javaはオブジェクト指向ではない
javaをオブジェクト指向だと言うなら、Cもオブジェクト指向と言うべき
オブジェクト指向の例であげるなら smalltalkにすべき
メッセージパッシングに注目するなら erlang にすべき

地球のオブジェクト指向は未熟だ。javaもC++もsmalltalkもerlangも。

この星において地球外生命体の方はブラケットを用いて
（きこえますか…きこえますか…）
とあなたの心に直接呼びかけるのがマナーです

わたしのなまえはスターシア

トミーリージョーンズの声で再生される

はじめまして、初書き込みです
現在hintと haskell-src-extsを使ったhaskellプログラムを書いているのですが、どうもうまくいきません
http://d.hatena.ne.jp/keigoi/20100125/1264411453
にあるサンプルを参考にしているのですが実行するとエラーを吐かれます
調べたところ、どうやらLanguage.Haskell.InterpreterモジュールのloadModules関数が悪さしているみたいです
そういえばhintをcabal installした時
Warning: Language.Haskell.Interpreter: could not find link destinations for:
Hint.Base.FromSession Hint.Base.ModifySessionRef Hint.Base.RunGhc
と言われました
何か関係しているのではと調べましたが原因は掴めないままです
同じとこでハマってる人いませんか

ちなみに各バージョンは
ghc-7.4.2
hint-0.3.3.7
cabal-install 1.16.0.2
Cabal library 1.16.0.3
Mac OS X 10.9
です

>>158
試してみたけどparseModeの型が変わっててコンパイルできない
>Warning: Language.Haskell.Interpreter: could not find link destinations for:
>Hint.Base.FromSession Hint.Base.ModifySessionRef Hint.Base.RunGhc
>と言われました
これはhaddockの警告だから無視して良い

>>158
ParseModeのところを直して、
H.set [H.languageExtensions H.:= [H.ImplicitParams]]
の行をコメントアウトしたら動いた

ghciの:tはどういう仕組みで型を調べているのでしょうか？

　　　import qualified Data.Text as T

　　　content :: Cursor -> [T.Text]

と書いてあるのに、:t contentで型を調べると

　　　content :: Cursor -> [Data.Text.Internal.Text]

になります

www.haskell.org/ghc/docs/latest/html/users_guide/ghci.html
どうぞ

>>162
ghcは内部的にはあらゆる型をそれが定義されたモジュールと合わせて区別する
xml-conduitをコンパイルした時点で、xml-conduit内の関数それぞれの型が
hiファイルに記録される。たとえば
content :: Text.XML.Cursor.Cursor -> [Data.Text.Internal.Text]
みたいに型情報が入ってる。(hiファイルはghc --show-ifaceで読める)
ghciは、これを読んで、なるべく分かり易いように表示する
Text.XML.Cursor.Cursorは、スコープにある型なので、単に「Cursor」と表示する
Data.Text.Internal.Textは、スコープにないので、そのまま「Data.Text.Internal.Text」になる

>>164
わかりやすい

自演乙
>>162
>>164
>>165

なんでも自演に見えるのは病気だよ

自演だろうと、そうでなかろうと、どういう文体だろうとどうでもいい

情報だけが大事

手紙じゃないんだから

いや、昨日の自演の続きかと思って

自演乙
本人乙

常套句でつね

>>163
全部調べましたがどこにも":t"の仕様に関する情報はありませんでした

>>164
> たとえば
> content :: Text.XML.Cursor.Cursor -> [Data.Text.Internal.Text]
> みたいに型情報が入ってる。

ソースコードには
　　　import qualified Data.Text as T
　　　content :: Cursor -> [T.Text]
と書いてあるのに、なぜ
　　　[Data.Text.Internal.Text]
として型情報が記録されるのかがわかりません。

それはそうとぉ、 :l *Main.hs、:m *Module みたいにしてやるとぉ、
:tでちゃんと型だけの表示になると思うんだけどぉ、俺の環境だけかなぁ？
みんなも試してみてよぉ

>>171
T.Textは、Data.TextからエクスポートされているTextという名前を参照する構文
で、Data.TextがエクスポートするTextは何かと言うと、
Data.Text.Internalで定義されたTextという型(これはData.Textのhiファイルに書いてある)
Data.Textのソースを見れば、Data.Text.InternalからインポートしたTextを
そのままエクスポートしてるのが分かる

>>173

俺は >>162 とは別人だが、ちょっと質問。

content :: Cursor -> [T.Text] の
Text.XML.Cursor.Curdor 型の方はなぜ
Text.XML.Cursor.Generic.Cursor と表示されない？

>>173
あ、ごめん、分かった

Text.XML.Cursor.Curdor 型の方は
type Cursor = CG.Cursor Node と型シノニムが定義されて、
それがエクスポートされているからか

>>173
ようやくわかったよありがとう。
Haskell何も知らん人に丁寧に教えてくれてありがとうｗ

結局既存のプログラムを置き換えようとすると
手続きっぽく書くことになるのかな

どんなプログラムでも関数的な書き方と手続き的な書き方の混合になるよ
混合比はプログラムの種類によって違うけど、手続き一辺倒になることは滅多にない

そそ、結局ラムダになるよね、基本

例えば編集距離を求めるコードはこうなる

levenshtein2 sa sb = last $ foldl transform [0..length sa] sb
　where
　　transform xs@(x:xs') c = scanl compute (x+1) (zip3 sa xs xs')
　　　where
　　　　compute z (c', x, y) = minimum [y+1, z+1, x + fromEnum (c' /= c)]

>>179
関数ポインタを持ってるC言語こそが本当の関数型ということになる

>>181
C言語が持てる関数ポインタの数はソースにより上限が決まる
本当の関数型なら有限のソースから無限に異なる関数を生成できる

突き詰めると、関数に必ず名前をつける言語は本当の関数型ではないってこと

>>182
C言語は、引数としての関数の記述には制限はない

C言語が実際には関数型かどうかなんて、このスレ的にはどうでもいいこと
Haskellの話とは何の関係もない
（C言語が関数型だろうと、Haskellには何の影響も及ぼさない）

新しくスレを作ってそちらで大いに議論してもらいたい

void *(*f)(void *(*)(void *(*)(void *(*)(void *(*)(void *(*)(void *(*)(void *(*)(...))))))));

こういうのって何段まで書けたっけ

>>184
Haskell言語の特徴として関数型言語であることを挙げるのはやめるべき
より純粋な関数型言語のCがあるんだから

やめるかどうかはともかく、関数型という一面が強調されすぎの感はある

でかい釣針だな。
http://ja.wikipedia.org/wiki/%E9%96%A2%E6%95%B0%E5%9E%8B%E8%A8%80%E8%AA%9E
から抜粋
>手続き型プログラミングなどにおける「関数」ではないことをまず注意する。

>>184
> （C言語が関数型だろうと、Haskellには何の影響も及ぼさない）

ダウト
関数型言語のシェアという点では関数型言語Haskellに大いに関係ある話題である

ならモナドやめろって話だよ

モナドは型クラスだから
曖昧なパラダイムや変動するシェアによって定義が変わることはない
そういう影響は受けない

モナドなんて構造の一つの表現にすぎないだろ
べつにHaskellに限った仕組みじゃなし

手続きとかいう曖昧な言葉を厳密な型であるIOモナドで表現した

人間が手続きを差別したり見下したりする必要はなくなり
コンパイラが機械的にチェックすればいいだけになるはずだった

haskellから遅延評価を排除したら何が残る？ラムダも破綻するだろ？

>>194
データ操作をデータ構造が分離した近代言語

>>189
Haskellのシェアも、このスレではどうでもいい
なんでそんな話をする？

この言語を使って実際にプログラムする事に関係ある話をしろよ

>>196
Haskellを使って実際にプログラミングするためには、機械語のレガシーソフトすら存在する現場において、Haskellの有用性と位置付けと言語的特徴を他の言語と比較して説明しなければならない

実際の労力に換算したら、その説得こそがHaskellプログラミングと言える

>>197
そういう事なら、他の言語と比較する事を手段として、
「Haskellの有用性と位置付けと言語的特徴」の話をちゃんとしてほしい

関数型とか手続き型とか、より純粋な関数型言語とか、
そんな名称の定義は一定していないし、綺麗に分けられるものではないのだから、
たとえば「Haskellは＊＊をするのに〜〜と書ける」というような
実際のプログラミングで優位性や特徴を語るべきだと思う

それと、シェアの話しならマ板でやってほしい

単なる一住人のわがままなので、これ以上は何も言わないでおく

>>198
実際の現場では、名称の定義も綺麗な分類も必要ない
特にクライアントに納入するコードの説得に必要なのは、シェアの話以外にない

>>199
そういうのはいつだって自慢話に帰着して終了なんだけど。

今まで一部の人間がひっそりと優越感に浸りながらオナニーしてたけど
馬鹿に見つかってしまって必死にその世界を守ってるという言語

と馬鹿が申しております

>>199
もし仮にコンピュータ言語のことで自慢できる立場の人がこのスレを見てるなら、スレ関係なくどんどん書きこんでほしいと思うのは俺だけか

>>194
型クラス、軽量スレッド、do記法、純粋性、ユーザ定義演算子、STM…
挙げればきりがない

javascriptの悪口なんて誰も言ってないのに何でHaskellを叩くのだろうか
UHC,Fay,GHCJSとかあるのに

オナニー言語

袋入り食パンのあれ、バッグクロージャって言うらしいね
どことなく関数型ぽくね？

つまりクロージャもラムダも高階関数もあるJavaScriptは関数型かつオナニー言語ってことだな

閉包ー閉包ー関数が好きー

>>198
自分が気に入らない話題の時は黙ってスルーするだけでなく
「俺の好きな話題以外は一切出すな！」って

大丈夫か？
社会生活的に。

自演評価

>>205
＞javascriptの悪口なんて誰も言ってないのに
えっ
＞JavaScript sucks. The depths to which JavaScript sucks is well-documented and well-understood.……
http://www.haskell.org/haskellwiki/The_JavaScript_Problem

遅延評価だけに後回し後回しの人生です

>>213
Haskellは必要なときには過不足なく仕事してるんだよ

お前は必要な時もサボってるだろ

ここはHaskellで書くスーパーハッカー的プログラムを公開するスレです

>>215
そう言うあなたがスーパーハッカー的プログラムを一切公開しない理由を説明してほしいです

よくいるよね
高価な文房具を買いそろえ、勉強はあまりしない
高価なギターやエフェクター類をそろえるが練習しない

10年ぐらいたって突然それらが遅延評価されて練習が始まるのです

ワロスwwwww

遅延評価とか言ってる割には

fib n = fib(n-2) + fib(n-1)
fib 1 = 1
fib 2 = 1

とかできなくて残念な言語

>>220
試してみたら普通に動いたよ

>>221
この定義の順番では「Pattern match(es) are overlapped」でまともに動きません。
fib 1 と fib 2 の定義を fib n の定義より先に書けば動きます。

>>220 は「遅延評価」をなにか別のものと勘違いしているか、
勝手に拡大解釈して期待してたのに思い通りにならなくて落胆しているか、どちらかです。

>>220
ご覧の通り

ghci>:{
Prelude| let {
Prelude| fib 1 = 1;
Prelude| fib 2 = 1;
Prelude| fib n = fib (n-2) + fib (n-1)
Prelude| }
Prelude| :}
ghci>fib 1
1
ghci>fib 2
1
ghci>fib 3
2
ghci>fib 4
3
ghci>fib 5
5
ghci>fib 6
8
ghci>fib 10
55
ghci>fib 100
^Z
[1]+ 停止

欠陥を指摘してドヤ顔しようとしたら言語の基本を知らなかっただけの>>220が涙目すぎてつらい

なんかすごい深い話かと思って二度見したわ
パターンマッチの規則も知らん奴に涙目とか言われても反応に困る

Backpack: retrofitting Haskell with interfaces
research.microsoft.com/en-us/um/people/simonpj/papers/modules/

へーHaskellのモジュールシステムってそんなに弱いんだー
知らなかったー

メモ化の話を蒸し返してきたのかと思ったらそれ以前の関数型ワナビだった

SMLやOCamlに比べればモジュールシステムが弱いのは有名
かと言って強いモジュールシステムが欲しいという声もそんなに聞かないけど

>>228
確かにmoduleシグネチャは強力だけど
ocamlはocamlでコンパイル順序の問題があるからな・・・

>>217
やめろ！

>>217
逆に色々不完全な奴ほど精力的だよな。
脳が不完全で矛盾だらけなやつほど行動力がある。

遅延するし必要なときは仕事するけど、不要な時も暇なら気まぐれで仕事するよって機構はないの？
ガベコレにいいと思うんだ

ガベコレは最近は排除の流れだがよろしいか

目の前の戦いに集中するのが完璧に正解
戦いが終わった後のために買い物したらどうなるか気付かない奴は不完全

>>234
つまり極論すれば知識や経験などは余計な物というわけですね。

必要だから持ってる知識と、ただ何となく持ってる知識を区別しない

replで
let result = f x -- fは何か物凄く重い処理
とやって、すぐにプロンプトが帰ってきたので、haskellスゲーと思って、resultの中身みたら長々と重い処理が始まった

これが遅延評価

knowledge is not orange.

a = [0, [1, [2, null]]];
a[1][1][1] = a;
循環するデータ構造を作りたいとき
遅延評価がないとnullと代入が出てくる

ふむ

>>237
これマルチコアプログラミング時の落とし穴なんですよね
リワハざっと読みましたけど

Futureとは違う

deepsecしましょ

Haskell Platform 2013.4.0.0 のリリース予定昨日だったけど遅れてんのかな

Haskell Platform のリリースが予定から遅れるなんていつもの事

リリースも遅延評価なので

今まで開発さぼってたんかい！

バグの追求に時間がかかっているんだよ。
オナニー言語らしいじゃないか。

人ば…アーリーアダプター言語らしい

正式版をリリースした後にキャンセルして、一ヶ月後にβ版からリリースし直した言語もあるんですよ！

AnyやAllの用途って何ですか？

Anal の用途なら分かるのだが…

リスト以外のデータ構造をFoldableにしてfoldMapしたりするんじゃないの？
http://hackage.haskell.org/package/base/docs/Data-Foldable.html

ThreadScopeでCPU（コア）の使い方を調べている時、
グラフのどの部分がプログラムソースのどの辺りの計算をしている時のものか
予想がつく場合もあれば、なかなか分からない場合もあります。

プログラムソースの中に、なにか目印を付けて、イベントログにその情報を出力し、
ThreadScopeで見た時にその目印がグラフ上に表示されるような事はできるでしょうか。

>>254
Debug.Trace.traceEvent

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

これで作業がはかどります。

Codec.Image.DevIL パッケージの Codec.Image.DevIL.writeImage 関数について質問です。

この関数で画像ファイルを出力するとき、すでに同じパスのファイルが存在すると、
上書きされずに関数から返ってきます。
エラーも何も起こりません。

新しい画像データで上書きしたように見せかけるには、
もしすでに同じパスのファイルが存在するなら、この関数を使う前に
そのファイルを削除しておくという方法があります。

しかしこの場合、もし writeImage 関数の内部で何かエラーが起きて関数が中断されても、
先に消したファイルは取り戻せません。

writeImage 関数で上書きするもっと良い方法はないでしょうか。
このパッケージの使用はあきらめて、別の画像書き込み用パッケージを探すべきでしょうか。

>>257
ファイルを別名に変えればいいじゃん。

>>258
アドバイスありがとうございます。

不格好ではありますが、幾分マシになったと思います。
リネームする方法を採用してみます。

Stateモナドを使う典型的な場合ってどういう場合でしょうか？
乱数関数を使うときというような例はよく出てくるのですが、もっと効果がはっきりした
使用例を知りたいのですが

>>260
カウンタ

ghc-modがcabalのsandboxの中のモジュールを認識してくれない
なんか設定加える必要あるの？

>>261
なるほど。ありがとうございます。カウンタは小さいが典型的ということでしょうか。
ただカウンタの例だと、Stateモナドってその程度のものかとも思ってしまうのですが、
これぞという使用例はないでしょうか？

局所的環境があると思えば、わざわざ引数を書かなくて済むから楽できるということでは
使うStateに別名をつけるとわかりやすいか
俺はプログラミング初心者なんでよくわかりませんが

get put modify runStateつかって具体的に教えてください

初心者なんで無理です
とりあえず練習にゴミみたいなのを書きました

import Control.Monad.State
import Data.List
import Data.Maybe

type ListState = State [Int]

main :: IO ()
main = print $ evalListState [3,6,2,7,1,8,0,9,5]

evalListState :: [Int] -> [[Int]]
evalListState a = evalState (mapM f a) []

f :: Int -> ListState [Int]
f x = g x >> get >>= return

g :: Int -> ListState ()
g x = get >>= \ys -> do put $ x : ys; modify sort

ローカルで hoogle を動かそうとしています。

hoogle data --local
hoogle server --local

として稼動させたのですが、ドキュメントのパスにパーセントエンコードが含まれる場合に File not found となるようです。
http://gazo.shitao.info/r/i/20131113234831_000.png
パーセントエンコードが含まれないパスなら問題ありませんでした。
これは何か設定上の問題でしょうか？ それとも hoogle のバグでしょうか？
バグだとしたら src/Web/Server.hs あたりのどこかで urlDecode をかませばよさそうに思いますが…。
解決策をご教示いただければ助かります。

異なる型を同一のリストに入れる方法を探しています

例えば
foo :: Int -> Int -> Int
bar :: Int -> Int
とした時、この二つの関数を同じリストに入れるというわけです
そのままリストに入れても弾かれるので両者を包むような型を作ろうと思いました

data Func = F (Int -> Int -> Int) | B (Int -> Int)

というデータ型を定義すれば
[F foo, B bar]
というリストが一応できます
しかしその中身は取り出せません
test (F f) = f
test (B b) = b
このような関数は定義できません、考えれば当然のことですが

一つのリストに入れ、その中身を取り出すような方法はないでしょうか？

data Func = F (Int -> Int) | B Int
foo :: Int -> Func
bar :: Int -> Func
[(Int -> Func)]

でどうでしょうか？

{-# LANGUAGE FlexibleInstances, InstanceSigs #-}

data Func = F (Int -> Int -> Int) | B (Int -> Int)
class Foo a where
test :: Func -> a

instance Foo (Int -> Int -> Int) where
test :: Func -> (Int -> Int -> Int)
test (F a) = a

instance Foo (Int -> Int) where
test :: Func -> (Int -> Int)
test (B a) = a

こうですかね
めんどい

InstanceSigsを使って型を書いた意味はないのかなあ
>>> let b = B succ
>>> let f = test b :: Int -> Int
>>> f 0
1

>>268
test (F f) _then _else = _then f
test (B b) _then _else = _else b

haskellでforとかwhileとかそういう言語構造の内容は本家のどこのページにのってますか？

Haskell は構文要素としては for や while に相当するものを持ってない。
if も関数に出来たと思うんだけど、なんで構文になってるんだろう。

>>273
http://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-220003

>>274
個人的には、if :: Bool -> a -> a -> a という関数より、
if then else という構文の方がソースが見やすい

関数にすると括弧が増えて lisp/scheme みたいになる

おまいらLisperをDISってんの?
http://gazo.shitao.info/r/i/20131114200901_000.jpg

ところで誰もこの問題を解決していないのでしょうか。

誰かがバグを見つけるよりコンパイラがバグを見つける方が早い
という願望がある限り解決しないみたいなパターンか

cmdargs パッケージを入れてコマンドラインオプションを解析しようとしました。

次のオプションを解析したいです。

-a か -b のどちらかのオプションが排他的に指定できる
もし -b を指定するなら、追加で数値を指定できる（-b 3 や -b 17 など）

このようなオプションは cmdargs パッケージで解析できるのでしょうか。

FlexibleInstances くらいはもうデフォでオンにしちゃって良い気がする

hello worldをひょうじするだけのサンプルコードをコンパイルするだけでファイルサイズが1MBも消費するんですが
これ軽量化するオプションか何かないですか？

jhc を使えばかなりマシになるけど、
言語機能としては GHC ほどまではサポートできていないので、
トレードオフだわな。

>>282
「haskell executable　size」でググると色々方法が出てくる

>>282
sharedライブラリとしてインストールされているパッケージを使っているならダイナミックリンクできます
ghc -dynamic hoge.hs
ついでにstripしてもいいのではないでしょうか

strip 前だと3MBくらいあるぞ

とりあえず本家のドキュメントを見て勉強しようかとおもうんだけど
Haskellにかんするドキュメントのページが見当たらない
なのでhttp://www.haskell.org/ghc/docs/7.6-latest/html/libraries/index.htmlから勉強しようと思うんだけど
リファレンスとかチュートリアルは公式サイトに用意されてないのですか？

>>287
それがリファレンスでないと申すか。

チュートリアル (へのリンク) はここにまとまってる。
http://www.haskell.org/haskellwiki/Tutorials
でも、全くゼロからの入門なら入門書の一冊くらいは読んだ方がいいと思うぞ。

instance Num a => Num (Maybe a) where {
Just x + Just y = Just (x+y);
Just _ + Nothing= Nothing;
Nothing+ Just _ = Nothing;
}

というような定義をすると (*) などのメソッドが定義されていないとして警告が出ます。
使う必要がなくてメソッドを定義しない場合に、意図的に未定義なのだということを明示して警告を抑制する方法はありますか？

未定義を英訳すると

be not defined

>>291
ありがとうございます。
それをヒントに調べたところ
(*) = undefined;
というようにすればよいことがわかりました。

試しに (*) = undefined とかしてみたら警告は出なくなったけど、
そんな風に見境なくインスタンス宣言していいものなの？
いろいろ訳の分からない事が起こりそうな気がするんだけど…

reflection使ってその場限りのMonoidとして定義するのがよさそう

>>294
ここでは例として Maybe を出しましたが、そういう基本的な型をインスタンスにしするのはあまり筋が良くないでしょうね。
実際にやろうとしていたのは自分で定義した2x2行列の型のべき乗なんです。
単に (^) を使いたいけどそのためには Num のインスタンスでなければならずかけ算だけは定義されていなければならないという状況です。

Numのインスタンス宣言は
メソッドの定義だけでなく Num a => がついてる全ての定義を実体化する宣言だから
その全てに対して意図的にundefinedにしたことを明示するのは無理じゃないかね

>>294
よくないと思う。Minimal complete definitionすら定義できないってことは
“そもそもその型はそのクラスのインスタンスではない”ということだと思う
つまり、そのインスタンス宣言は純粋に間違っている

>>298
なるほど。 >>296 のような状況なのですが、 (*) も未定義にしてみたところコンパイルは通っちゃいますね。
そんでもって実行時エラー。

しかし、必要な (実際に使われる) メソッドが定義されていないというのはコンパイル時に検出できないものなのでしょうか。
現在の GHC は「実際に使われはしないけどクラス定義が要求するメソッドを定義してない」のも
「実際に使われるメソッドを定義してない」のも等しく警告しか出さないというのはちょっと微妙な挙動に思えます。

>>288
チュートリアルでないことは確かだな

>>299
実際にはundefinedを呼ぶという定義をしているだけで
それの定義がこれなので問題なくコンパイルできるし実行時に評価されればエラーを出すっぽい雰囲気ですね
undefined :: a
undefined = error "Prelude.undefined"

headでも空リストを適用したのが評価されれば実行時にerrorになるっぽいそんな雰囲気

あーundefinedではなく本当に未定義でも通るのか
勘違いしてた

それでも評価しなければエラーは出ないけど

>>299
どのメソッドが使われるかは静的には分からないから、
「実際に使われた場合のみ」警告するのは難しい
(ごく粗い近似ならできそうだけど、粗すぎて役に立たない可能性がある)

スタイルとしては、型クラスのインスタンスは必要なメソッドを全部定義するべきとされている
(*)が定義できないなら、おそらくその型はNumにしない方が良い
AdditiveGroupとか検討しても良いと思う
http://hackage.haskell.org/package/vector-space-0.8.6/docs/Data-AdditiveGroup.html

そもそも行列は数だっか？

交換法則が成り立たないので駄目ですかね。

Numクラスは+と-と*があるから環っぽいな
環なら*に交換法則無くてもいけるから*との分配法則が成り立つアーベル群をなす加算を適当にでっち上げればいけなくも無いんじゃないかな

abs に自然な定義が出来ない気がする

そっか

n次正方行列なら行列環として定義して
absは行列のノルムと単位行列のスカラー積にしたらいけるんできるんじゃないかな

複素数や四元数ってスカラーでしたっけ？

絶対値はスカラーじゃん
でもそれだとインスタンスにできないから戻す単位元と乗じる等して台集合の中に戻す必要がある

話の筋としてはよくないな

pythonのラムダが便利だなと思って関数型言語の勉強を始めてみたけど
コード見ても何か居てあるのかさっぱりわかりませんよ

慣れですよ

haskell の CPP を、使ってみてるんですが、
#name での quoting って、ないんですか？

# を使うと、section なら、 () で囲めって怒られます。

検索で、うまく引っ掛からないんで、教えてください。

>>314
たとえば、どんなコードですか？
もしかしたら、そのコードの書き方が悪いのかもしれません。

コードに問題は特に無く、単にあなたが未熟なだけかもしれませんが。

cabal でパッケージをインストールするとき、ドキュメントも同時にインストールするように
.cabal/config を設定しているのですが、そのドキュメントに対して、
ソースコードへのリンクを張るように設定するにはどうすればよいのでしょうか。

http://hackage.haskell.org/packages/ ここのドキュメントみたいにしたいです。

>>314
ラムダを使ってる箇所は大抵開いて書き直す事ができて（関数定義の局所性などの問題を除けば）
同等で長ったらしい形に書き直せる．

そういう書き直しの練習をいくつかしてみれば，自分の理解に応じて「ここは確かにラムダで簡単に書きたい」とか
思うようになるかもしれないし「ここはわざわざラムダ使うより where できちんと関数定義したほうがいいな」とか
色々思うようになるんじゃないかな

>>314
関数型にはほとんど言語的メリットはないよ

>>316
gccを使う環境だと、CPPはgcc -P -tradirionalが使われる
これはANSI C以前のCPPなので#での文字列化はできない
代わりに
#define Foo(x) "x"
みたいなことができる

>>318
cabal install --haddock-hyperlink-source

configファイルではまだ指定できないらしい
https://github.com/haskell/cabal/issues/931

>>276
ifが関数でも構文でもBoolの値で分岐すること自体は否定されないから大差ない

オブジェクト指向だと、値で分岐するな、オーバーライドかオーバーロードで分岐しろ、
ってのが面倒臭い

Hoogle が停止中？

昨日からhaskell.org全体が止まってるみたい

なんでhaskell.orgすぐ死んでしまうん？

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

コマンドラインオプションもひと通り見たはずなんですが、見落としていました。
助かりました。

>>326
Haskellで書かれてるから

あんちはすけらに危険視されて狙い撃ちされてるから

haskell.orgはApacheっぽいね
まあ、単にサーバが貧弱だとか管理が適当なだけとかでしょ

Hayooの停止頻度に比べたらHoogleはまだマシ。

Hayooは使いやすいからもっと安定してくれると助かるんだけど・・・。

総本山のサイトが度々落ちるとか結構なマイナスイメージになるだろうにな
インフラ代恵んでやるぐらい金ある所もあるのにそれをしないというのはわけがあるんだろうな

>>329
そうだったのか
許さんぞLisperめ

おい、Lisper様に喧嘩売るのはやめろよ……

Lisperが何だってんだ
待ってろよ…今からエディタの括弧ハイライトに細工してきてやる

iPhoneで動くHaskellは1つだけ。
もっと増えないかなぁ

スマホで動かしてどうする
それよりライブラリリファレンスをスマホからみたい
拡大縮小ちまちませずにｽﾞﾊﾞﾊﾞﾊﾞﾊﾞｰﾝと表示して欲しい

ズババババーン
Prelude.head: empty list

テンプレの日本語サイトの情報がしょぼいんですが何故この２つがテンプレ入りしてるのですか？

真面目に議論されないから

自分が気に入ってるのはここ
http://www.geocities.jp/m_hiroi/func/haskell.html

日本語サイトでしょぼくないとこなんてあるのか？

>>341
広井氏のページは他の言語でも参考にしているよ。
個人ページ特有の調子こいた感じが全くなくて読みやすい。

逆に調子こいたページってどんなの

清少納言のページ

Haskell Platform 2013.4.0.0 のリリースまだぁ〜ﾁﾝﾁﾝ
待ちくたびれた

どうせそんな先進的な機能を使ったりしてないんだろ？
最新厨ども

最新の機能は使って無くてもバグを踏むことはある

Debug.Trace.traceEvent や traceEventIO などを使ってイベントログにメッセージを書きだしたのですが、
そのイベントログを ThreadScope で　Event labels を有向にして見てみると、
自分が書きだしたメッセージ以外にもランタイムが書きだした大量のメッセージもいっしょに表示され、
自分のメッセージがその中に埋もれてしまいます。

自分が書きだしたメッセージがログのどこにあるのか、検索する方法は無いでしょうか。
あるいは、色を変えたりして目立たせる方法でもいいのですが。

今は吐き出したイベントログを Emacs で開いて、自分のメッセージを検索し、
ログ全体のどの当たりにメッセージがありそうか当たりをつけてから、
ThreadScope で開いてその辺りを探しています。
しかし、非常に効率悪く、ThreadScope 上ではどうにも見つからない場合もあります。
（無いはずはないのですが・・・）

>>349
ghc-eventsというコマンドラインツールがある(ghc-eventsパッケージ)
ghc-events show <eventlogファイル>
でイベントの一覧がタイムスタンプ付きで出るので、grepとかで探せばいい

>>350
ありがとうございます。
幾分楽になりました。

qualified Data.ByteString.Lazy as B
qualified Data.List as L

この２つのモジュールに共通する関数
B.foldr と L.foldr のメモリ効率に関する質問です。

f :: B.ByteString -> B.ByteString
f = B.pack . B.foldr (\b xs -> h b : xs) []

g :: B.ByteString -> B.ByteString
g = B.pack . L.foldr (\b xs -> h b : xs) [] . B.unpack

関数 f は ByteString を直接 B.foldr で加工しています。
（たとえば暗号化したり、追加のデータを挿入したり）
一方、関数 g は一度リストに変換し、それを加工しています。

このような関数を使ったプログラムをコンパイルして、
RTS オプション -s で実行してメモリ使用量を調べました。

関数 f の方は ByteString のデータサイズに比例して
メモリ使用量も増えていました。
一方、関数 g の方は、データサイズに関わらず、
ほぼ一定のメモリ使用量で処理されました。

おそらく、リストに一度変換した方は遅延処理が働いて、
一定サイズのヒープで逐次処理されたのだと思います。
ただ、そう考えると、ByteString.Lazy の遅延性は
このプログラムでは働いていないということでしょうか。

B.ByteString 型の説明には
A space-efficient representation of a Word8 vector, ...
と書かれいているのですが・・・

>>352
現在のByteStringのfoldrの定義がおかしいのが原因
次のリリースで直るはず

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

とりあえず今のところはリストに一度変換するようにプログラムしておいて、
修正は気長に待ちます。

型クラス NFData のインスタンスについて質問です。

import Control.Monad.Par

data TestT a = TestD a

f x = do
　var <- new
　put var (TestD x)
　return var

この関数 f の型は f :: NFData (TestT a) => a -> Par (IVar (TestT a)) です。

TestT a 型が型クラス NFData のインスタンスであるという文脈を指定するのは分かります。
put 関数はその引数として NFData のインスタンス型（とそれを型変数としたIvar型）の値を取り、
ここでは put 関数に TestT a 型（および IVar (TestT a) 型）の値に適用しているので。

しかし、まだ TestT a 型を型クラス NFData のインスタンスとして定義してはいません。
それにも関わらず、なぜかエラーもなくコンパイルが通ってしまいます。

どうしてでしょうか？


GHC のバージョン : 7.6.3

>>355
すいません、自己解決しました。


f 関数を使って、TestT a の型変数 a に具体的な型を与えるようなことをしたら、
ちゃんと NFData のインスタンスではないことを知らせるエラーが出ました。

等式性制約(~)の実装を見たいのですがそれらしいソースが見当たりません
ghciで:infoしてもエラー吐かれるだけです
どこにあるかご存知の方いらっしゃいませんか

ghcのバージョンは7.6.3です

ghcのソース読んだ？

>>357
~は演算子じゃなくて構文だからソースレベルの定義はどこにもない
ghcは内部的には型構築子として扱うっぽいけど(prelude/TysWiredIn.hsのeqTyCon)

>>357>>368
実はghcのソースを読んでてみてそれらしいコードが無かったのでもしかしたらと思っていましたが、やはりそうでしたか
ていうことは~はhaskellで実装できないのでしょうか
どうしても似たような機能を持つ演算子が欲しいのですが

360です
似たような演算子というのは、例えば型リストxs::[*]と型x::* があるとします
この時「xsの中にxが含まれている」という型制約を表す演算子です
そのような演算子は論理的に実装可能でしょうか
よろしくお願いします

{-# LANGUAGE GADTs, TypeOperators, KindSignatures, DataKinds #-}
data (a :: *) :== b where Refl :: a :== a

data List a where {
Nil :: List a ;
(:::) :: a -> List a -> List a
}

infixr 5 :::

data Exists b c where {
Here :: a :== b -> Exists a (b ::: c);
There :: Exists a c -> Exists a (b ::: c)
}

sample :: Exists Int (String ::: Int ::: Char ::: Nil)
sample = There (Here Refl)

ghcの型システムの上でそれっぽいものは作れるようだけど

>>362
ありがとうございます
自分にHaskellの能力が無いためか、これを使いこなすのは難しそうです
あきらめてgeneric使います

GHCのソースコードを調べるやる気と根性がありながら、
>>362 をものにすることを諦めると申すか

少々もったいない気もする

haskell難しすぎる。

>>365
↓の3ページ目「Haskellドリル」で勉強したまえ(ただし、非売品)

「Haskellは企業でも十分実用になる」、NTTデータが
ソースコード解析サービスの舞台裏を披露　2013/11/26
http://itpro.nikkeibp.co.jp/article/NEWS/20131126/520642/

> 勉強したまえ(ただし、非売品)

NTTデータに入れなければHaskell書くなということですねやめてくださいしんでしまいます

>>366
>30人体制のチームで、1500ファイル、35万行のツールをHaskellで開発

1人約1万1千行か・・・
半年以上かけて作ってる俺のプログラムは未だに5千行を超えてないｗ

35万行で1500ファイルだと平均230行/ファイル。
モジュールの粒度としては似たようなもんだな。

質問です。
モナドを、途中で他のものに変更する、
または直接中身を取り出す事はできますか？

具体的にはIOの文脈で、他のMonad(QuickCheck.Gen)の値を、
直接取り出す方法を探しています。

初心者ですので、キーワードだけでも教えていただけると助かります。

すみません、自己解決しました。
Test.QuickCheck.Genのsample'を見落としていました。

ちなみに、これは汎用的に取り出す方法はあるんでしょうか？

>>368
私は全く違う言語を使っているので感覚がわからないのですが、
1ファイル平均230行というのは途方もなく大きく思えるのですが。
大規模開発だとそんなものなのですか？

>>370
Genに関してはTest.QuickCheck.Gen.unGen使えば取り出せるよ
一般的にいえばMonad mの文脈でMonad nの値を使うには
nからmへのMonadTransformerがあればliftを使って取り出す(持ち上げる)ことができる

chromium.git (C/C++)
ファイル数: 27551
合計行数: 6414627
平均: 232.8

その内例外処理の行数は何パーセントですか？

>>372
unGenの方が使えそうですね。
MonadTは名前だけは知ってましたが、そういうものだったんですね。

MonadTransformerとliftで調べてみます。
ありがとうございました。

>>374
知らんけどC/C++で何で例外が気になるんだ？
ほとんど使われてないと思うが

transformerとか入門書に普通に書いてあるけど、みんなプロだから読んでないのか

>>376
例外処理とエラーって別なんですかね
初心者なんでその辺わからないんですよ

>>378
別
例外処理はエラー処理方法の一つに過ぎない

>>379
例えば壊れたり、不正なコンフィグファイルを読み込んだ時デフォルト設定に差し替えて起動したり、
起動せずに修正するようにユーザーに促したりという処理はしませんか
それとも放置なんでしょうか。プロの皆さんはどうしてます？

>>380
C++ではそれをいちいち例外でやらない
議論したいなら別スレ立てろ

>>371
230行はそれ程大きく感じないな。
むしろ丁度いいか、やや小さめって感じ。

今のプログラム内で最大モジュールは1千行近い。
早い段階で分割しすぎると試行錯誤が面倒になるから、
落ち着くまではそのままにしてる。

この辺は大規模開発かどうかはあまり関係ない気がするな。

ちなみに、どんな言語使ってるの？

>>382
Prologです。述語ごとにファイルを作りますから、平均5行ですね。

Prologは第5世代言語だからな
その立場から見たら殆ど全ての言語が古臭く冗長に見えちゃう
それこそscalaになれた人から見たjava以上の差を感じるのだろう

第五世代コンピューター・プロジェクト

2位じゃダメなんでしょうか？

つーかFortranじゃなければダメでしょ。

4GLって汎用のプログラミング言語じゃない言語（RPGとかの問題領域を特化した言語）のことじゃなかった？
ましてや第五世代言語なんて定義無いと思うけど。

shuffle :: [a] -> IO [a]
のエレガントな実装を見せてください。

たとえばこんな式を書いたら
sqrt $ fromInteger 15
この型は
Floating a => a
じゃないですか。

で、もうひとつ関数を追加して
floor $ sqrt $ fromInteger 15
としたらこの型は
Integer
になるじゃないですか。

このとき sqrt が返す値の型は Floating クラスに属するわけで、
floor が受け取れるんだから RealFrac クラスでもあるような型ってことになるわけです。
でも、そうなると候補は Float と Double のふたつがあることになると思うんですけど、
実際にはどちらで処理されるんですか？

>>390
特に指定しなければDouble
http://www.sampou.org/haskell/report-revised-j/decls.html#default-decls

>>388
http://en.wikipedia.org/wiki/Fifth-generation_programming_language

>>389
効率やシャッフルの質を重視するなら Fisher–Yates shuffle を使いところだが、
リストでエレガントにやる方法が思いつかなかった。
俺が考えると、どうしても泥臭くなる。

代わりに、こんなのはどうだろう。

pick :: [a] -> Int -> (a, [a])
pick xs i =
　let (ys, ys') = splitAt i xs
　in (head ys', ys ++ tail ys')

shuffle :: [a] -> IO [a]
shuffle [] = return []
shuffle xs = do
　(y, ys) <- pick xs `fmap` (getStdRandom (randomR (0, length xs - 1)))
　ys' <- shuffle ys
　return (y : ys')

>>393
fmapの辺りは何をしているのでしょうか？

よく眺めたら理解できました。なかなか面白いです。

Pythonの次にいじる言語として、Haskellってどうっすか

Haskell は Python とは何の関連もない言語ですから、
Python の次とか前とか考えることに全く意味はないと思います。

いつでもいいので興味が向いた時にいじってください。

Hasekllの場合は、他のコンピュータ言語を一切教えずに始めからHaskellの方がいいと思うのは俺だけか

貴方だけかは知りませんが、少なくともHaskellの作者のひとりは
貴方とは違う意見のようです。

「言語設計者たちが考えること」という本でインタビューを受けた作者のひとりは、
他言語を学んでからという趣旨のことを言っていました。

どちらかと言えば、私も作者に同意見です。

問題の解法の表現方法が大きく違うというのをリスクとみなすならば、
それは初めにHaskellを学んだ後の次の言語にも言えることてす。

初心者にとっては他言語（特に手続き型）の方が、
問題を抽象化して解法を導くのに必要な考え方を学びやすいと思います。
また指導者も教えやすいと思います。
その考え方は、Haskellだろうと何だろうと全ての言語で通用するものです。

>>398,399
俺もExcelシート+VBAで基本的な問題解決方法を学んでからHaskellに移った方が良いと思う。

手続き型と干渉しないからC++と同時に教えれば良いんじゃね？

>>401
手続き型を教えるなら、まずブロック図や回路図を見せながら16bit機の
アセンブラを教えて、その後C言語を教えた方が良いと思う。

例えば reverse の後に再び reverse をすると何もしないのと同じなので無意味ですよね。
(無限の配列に対してだと無限ループになりますけどそれはとりあえず置いときます。)
なので、そういう場合には無かったことにするとか、そういう書き換え規則を表現することってできますか？
Common Lisp で言うところのコンパイラマクロみたいなもののことです。
GHC の拡張でそういうのがあったような気がするのですがどうにも詳しいことを重い出せなくて。

>>402
四則演算もわからない小学生に実数の定義から教えようってことかい？

>>403
http://big.freett.com/shelarcy/rewriterules.pdf
白石さんが昔書いたスライドにあった
RULESプラグマを使えば良いようだ

reverse . reverse = idならいけるけど
自然変換の性質を使ってreverse . f . reverse <=> f . reverse . reverse <=> f . id
みたいなのもできると面白そうだけど多分無理だろうな

>>403
書き換え規則の RULES プラグマですね。
の
たとえばソースに次のように記述すれば、reverse (reverse xs) という式は
最適化コンパイルの時に id xs に書き換えられます。
（引用符で囲んだ部分は規則の名前で、適当に名付けることができます）

{-# RULES "rev/rev" forall a. reverse (reverse a) = id a #-}

[ソースの記述] f xs = reverse (reverse xs)
[コンパイル後] f xs = id xs

簡単に言えば、書き換え規則中のイコールの左辺の「形」の式がソース中にあれば右辺に書き換えられます。

ただし、わざわざ「形」と強調したように、コンパイラは構文の形しか見ません。
ソース中の関数適用の式がアルファ変換（識別子名の置換）で書き換え規則左辺に変換できれば、
規則が適用されて右辺に書き換えられます。
ソース中の関数適用の式がベータ変換（簡約）でしか書き換え規則に変換左辺できなければ、
規則は適用されず書き換えられません。

たとえば先ほどの "rev/rev" の規則が記述されいても、次の式は書き換えられません。

[ソースの記述] g xs = (reverse . reverse) xs

ベータ変換（簡約）すれば、f xs も g xs も同じ意味の式になるのですが、これは無効です。
だから、これも書き換えるには、次の書き換え規則も記述しなければなりません。

{-# RULES "rev/rev 2" forall a. (.) reverse reverse a = id a #-}

中置演算は最適化時に関数適用に変換されてから、書き換え規則が適用できるか検証するみたいです。

詳しくは http://www.kotha.net/ghcguide_ja/latest/ の「7.19 書き換え規則」の項を見てください。

>>403
もっとひどい事もあります。

{-# RULES "rev/rev 2" forall a. (.) reverse reverse a = id a #-}

これを記述した場合、次のはちゃんと書き換えられます。

f = g [1..]
g xs = (reverse . reverse) xs

でも、次のは書き換えられません。

f = g [1..]
g = reverse . reverse

なかなか融通が効きませんね。


ちなみに、これは最新の GHC 7.6.3 での話です。
昔はどうだったか知りません。

マクロはなしの方向でいきませんか

いきません

>>406みたいな変なことになるのは、reverseがRULESで書き換えられることを意図していないから
GHC HEADだと次のような警告がでる

rev-rules.hs:2:11: Warning:
Rule "rev/rev" may never fire because ‛reverse’ might inline first
Probable fix: add an INLINE[n] or NOINLINE[n] pragma on ‛reverse’

>たとえば先ほどの "rev/rev" の規則が記述されいても、次の式は書き換えられません。
>
>[ソースの記述] g xs = (reverse . reverse) xs

reverseに例えばNOINLINE[1]を指定すれば、この式も問題なく書き換えられるようになる
((.)をインライン化した後で規則に適合するようになるので)

>>410
ご指摘ありがとうございます。

質問者さん（>>403）参考にしてください。

>>396
Node.js

JSはウンコすぎて話にならない

>>408
マクロ話の方向ですね分かりました

おさきまっくろ

>>414
3日も経ったその返しはちょっと寒い

誰かテンソル積を教えてください
斜めの座標じゃないシンプルな奴(添字の上下の考えなくていい)です
途中まで書いてみたのですがこんなんでいいんでしょうか

-- ベクトル
a = [1,2,3]
b = [4,5,6]
c = [7,8,9]

d = [3,3,4]
e = [5,2,1]
f = [2,3,4]

-- ベクトル3つからテンソル化(あっているの？？)
abc = [[[i*j*k|i<-a]|j<-b]|k<-c]
def = [[[i*j*k|i<-d]|j<-e]|k<-f]

-- テンソル和
plus = [[zipWith (+) j m|(j,m)<-zip i k]|(i,k)<-zip abc def]

-- テンソル積
mult = ???

まず反変ベクトルと共変ベクトルをどう構成してるか言ってくれないと

RT @chomado はぁ〜情報系彼女たん可愛い〜hshs.hs

反変/共変は直交座標では無関係だと思うのです
もうすこし調べて、上のabc/defがテンソル積だと分かりました
失礼しました

自前でfunctorを作る場面はよくありますか？

オーム社はおかげさまで2014年に創立100周年を迎えます。
長年のご愛顧に感謝してeStoreでは記念セールを開催中です。
（2013-12-04(水)12時から2013-12-11(水)12時まで）
http://estore.ohmsha.co.jp/titles

すごいHaskellたのしく学ぼう！
PDF版書籍データ　希望小売価格 2,800円→特別価格 1,400円
コンボパック(PDF版と紙版書籍のセット)　希望小売価格 5,600円→特別価格 4,200円

>>421
たまに

>>421
「functorを作る」の意味がよく分かりませんが、
Functorクラスのインスタンスを作るという意味でしょうか。

であれば、私はよくあります。
data で自前の型を作り、その値に対して map を施す必要があるなら、
map*** などその型用の別名 map 関数を作ったりはせず、
その型をFunctorクラスのインスタンスに fmap 関数を定義します。

もし、「functorを作る」が Functorクラスに相当するクラスを自作するという意味なら、
私はそのようなものは作りません。

オーム社9時まで玄箱クラウド増強中か

思い出したErlangの本だしてたのもω社だったか

Platform 2013.4.0.0 ｺﾈ━━('A`)━━!!!
timetableの更新だけでもしていただければありがたいのですが．．．

Platformに頼ってるからそうなる

ω社は Haskell に力を入れているのか

宣伝乙

>>424
ありがとうございます。
質問の意図は前者でした。

>>406
> コンパイラは構文の形しか見ません。

それは Common Lisp (というか他の Lisp でも同じだと思うけど) と同じですね。
もっと踏み込んで関係を表現する方法とかも GHC ならこっそり入ってそうな気がしたけど、それは過大評価かな。

>>432
「もっと踏み込んで関係を表現する方法」って例えばどういうの？

「こっそり入れる」ってどういうこと？
リリースノートに記載がないってこと？

今まで何かこっそり入ってたことってあったっけ・・・

>>422
書籍版半額にしろや

すごいH本に関して言えば電子版の方がカラフルで良いぞ

モジュールをインポートする方法について謎な挙動に遭いました。

repa を使っているのですが、次のように記述すれば問題なくコンパイルにパスします。

import Data.Array.Repa (Z, (:.), DIM2)
import Data.Array.Repa.Index

しかし、次のように Index の方をインポートしないと、

import Data.Array.Repa (Z, (:.), DIM2)

次のエラーが出ます。

Not in scope: data constructor `:.'
Not in scope: data constructor `Z'

次のように記述しても、同様のエラーが出ます。

import Data.Array.Repa
import Data.Array.Repa.Index (Z, (:.), DIM2)

また次のように記述しても、同様のエラーが出ます。

import Data.Array.Repa (Z, (:.))
import Data.Array.Repa.Index (DIM2)


Data.Array.Repa のソースを見ると、
そこから module Data.Array.Repa.Index がエクスポートされているように見えます。

なぜ import Data.Array.Repa の方の記述だけではエラーが出るのでしょうか。

(:.) (..)

>>437
ごめんなさい、レスの意図がよく分かりませんでした。

もう少し詳細に説明していただけると助かります。

(^ ^;)

>>438
import Data.Array.Repa (Z,(:.)(..),DIM2) 　ってことじゃね？

>>437 >>440
アドバイスの意図がやっと分かりました。

そして、Haskell 2010 Language Report の [5.3 Import Declarations] を調べてみて、
アドバイスの意味も分かりました。

つまり私は、型構築子 Z と (:.) をインポートしたが、
それぞれの値構築子の方はインポートしていなかったために、
ソース中でそれらを使っている箇所でエラーが報告されていたわけですね。

たまたま型構築子と値構築子が同名なので、質問してレスされるまで気づけなかった、と。

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

GHCは悪くないよ
悪いのは大抵ぼくの方だ(´･ェ･`)

「:?　とタイプして幾つかのヘルプを表示させなさい」と本に書いてあるけど、
ghciで画面が流れてしまって見れなくて困っている。

また、コマンドや関数を調べたい時にはどうすればよい?

> 443
> コマンドや関数を調べたい時にはどうすればよい?

それが :? で出てくるわけだが。
画面が流れるのはターミナルの設定をいじれば履歴を残す行数はいくらでも増やせるだろう。
個人的には Emacs 使えと思う。

>>443
ghciにはあまり親切なヘルプ機能がないからwebを参照するのが良い

GHCマニュアル、ghciコマンドの節
http://www.haskell.org/ghc/docs/7.6.3/html/users_guide/ghci-commands.html

関数名からドキュメントを検索
http://holumbus.fh-wedel.de/hayoo/hayoo.html

ありがとう。解決できた。

ghciコマンドについてはスクロールで
w3mでwebを参照して、関数名は w3m あたりで http://holumbus.fh-wedel.de/hayoo/hayoo.html?query=検索する関数名
で助かった。

新しいgtk2hsが一発でインスコできて感動した
二年前にはクソ苦労した記憶があるんだよな・・・

windowsならその勢いでyiもインストールしてみて欲しい
そして絶望しろ

もうWindows 2000 でHaskell は楽しめない
Haskell は僕らを見放したんだ(´･ェ･`)

>>449
Windows捨てろ。

マゾヒストなんだよ

モジュールのインポートについて質問というか疑問があるんですけど
比較的汎用に使えそうな自作のモジュールってどこに置いてどうアクセスするのが普通なんでしょうか？
というのも自分としては、
./HaskellProg/
　/util/
　/project1/
　/project2/
　...
みたいな感じでHaskellProgフォルダ以下にサブフォルダを作って
汎用モジュール用のutilフォルダと個別プロジェクトフォルダとを置いていこうと考えていたんですが、
util以下に置いたモジュールファイルにproject1フォルダの中から読む手段が、ぐぐっても全然わからないんです
自分のサブフォルダにある分にはスラッシュをドットに置き換えてimportすればいいというのは分かるんですけど…
コンパイラーのオプションに -i dirsとやれば探索パスを追加出来るという情報も見たのですが、
これもやはり上の階層へは辿れないみたいです
上の階層にアクセスする方法がちゃんとあるのか、それともそもそもアプローチが間違ってるのか、
アドバイスよろしくお願いします
環境は Haskell Platform 2013.2.0.0 for Windows、 OSはWin7 Pro 64bitです

cabal install

モジュール表記を、
module Util.Lib where ...
module Project1.Main where ...
みたいにしてHaskellProg直下からコンパイルすれば良いような

上の階層は..で辿れないか？

cabalでパッケージとしてまとめてsandbox add-sourceする

cp ../project1/* -t .
rm -R ../project1/

Haskell Platform 2013.4.0.0 ﾏﾀﾞｰﾏﾁｸﾀﾋﾞﾚﾀ
幻になってしまうのか

何故待ち望んでいるの？

64bit対応してくれるからじゃなかったっけ

何度でも言うが、最新のGHCをインストールして使え

json形式のデータをSocket（Stream）を使って送受信したいのですが、
お薦めパッケージがあれば教えてください。

jsonとHaskellの型を合わせるのが大変だったんで二度とやりたくない
お薦めパッケージは特にないごめんよ

>>463
ぐぬぬ...jsonやめてxmlにします。

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

っYAML

json schema広まらなかったね･･･

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

msgpack-rpc
http://hackage.haskell.org/package/msgpack-rpc

開発者が日本人のようなので、これにしようかと思います。

aeson一択

>>467
https://gist.github.com/repeatedly/5011298

>>468
aesonは通信周りの面倒は何もみてくれませぬ・・・

>>469
情報、ありがとうございます。
一読しましたが、問題無さそうです。

hoge >>= \[x] -> 〜
do { [x] <- hoge; 〜
って微妙に違うのね 〜

型定義をみていたら、値コンストラクタのフィールドで
型の前に「!」ついてたりするのを見るんだけど、
どういう意味なのか教えてください。

>>472
正格評価になる。

bang pattern って名前が付いてる
http://www.haskell.org/ghc/docs/7.4.1/html/users_guide/bang-patterns.html

>>473
>>474

ありがとう。

haskell !

とかググって困ってたので、助かりました。

Control.Concurrent モジュールの MVar を使った簡単なデッドロックなんだが、

main = newEmptyMVar >>= takeMVar

これ、ハングアップするんじゃなくて、
例外 BlockedIndefinitelyOnMVar が投げられるんだな

便利でいいんだが、どういう仕組みでデッドロックを検知してるんだろ
けっこう単純な仕組みなのかな

例外というかシグナルを投げてるのはrts側だな
MVarもrts側にプリミティブありそれとGCの機構を利用して上手くデッドロック起こしてるスレッドを回収してそのタイミングでシグナル投げる
みたいな仕組みになってるようだ
ただどうやってこのコードによて到達不可能なスレッドオブジェクトになるかっていうのはちょっとコード見ただけじゃわからなかった

>>477
結構複雑なことしてるっぽいね
プログラム側からGCの機構にアクセスできるんだね、初めて知った
それとも、アクセスしてるんじゃなくて、たまたま上手く利用できてるだけかな

当然、全てのデッドロックを検知してくれるとは思えんが、
どこまで賢いのか、暇があったら検証してみるよ

ところでこれ、-O2 でコンパイルしてもデッドロックを検知してくれる
この場合は余計な処理をしないで、処理速度の最適化に専念して欲しいんだがなぁ・・・

GHCだとスレッドがGCの回収対象になってる
ブロックしてるスレッドのスタックはGCのルートにならなくて、
他から参照されなくなった時点でGCされる
(他から参照というのは、ブロックしてるMVarを他スレッドが持ってたり、
ThreadIdオブジェクトを持たれてる場合)

スレッドがGCされるとき、黙って消されるんじゃなくてrtsが例外を投げてくれる

>>479
> スレッドがGCされるとき、黙って消されるんじゃなくてrtsが例外を投げてくれる

>>476 の例でも、スレッドがGCされるから、その際にMVarがブロックされ続けている事が分かり、
だから例外 BlockedIndefinitelyOnMVar が投げられるってこと？

ブロックされているのにスレッドがGCされるの？

仕組み以前に、挙動もイマイチ分からんから、別の例を作ったんだが、

main :: IO ()
main = do
m <- newEmptyMVar
forkIO (takeMVar m >> return ())
forever $ print 1

これだと、例外が投げられることもなく、永遠に 1 が印字され続けるが、また別の例

main = do
m <- newEmptyMVar
forkIO (takeMVar m >> return ())
print [1..10000]
_ <- takeMVar m
print [20000..30000]

これだと、10000まで印字されて、20000以降が印字される前に例外が投げられる

要するに、ブロックされているMVarに「全てのスレッドがアクセスしようとした時点」で、
例外が投げられるということなのかな？

>>480
>ブロックされているのにスレッドがGCされるの？
される。そのMVarが他のスレッドから参照されていないなら
永遠にブロックされ続けることが保証されるからGCして問題ない

>これだと、例外が投げられることもなく、永遠に 1 が印字され続けるが
実際にはそのコードでも例外が投げられてる
メインスレッドじゃないから何も表示されてないだけ
明示的にprintしてやれば分かる

import Control.Concurrent
import Control.Exception
import Control.Monad

main :: IO ()
main = do
　m <- newEmptyMVar
　_ <- forkIO $
　　takeMVar m `catch` \e ->
　　　putStrLn ("Exception: " ++ show (e :: SomeException))
　forever $ do
　　print (1::Int)
　　threadDelay 10000

newtype T = D Int

こういう型の値 x があったとして、newtype で宣言してあるから

let D i = x ってやって値構築子を外すのも、
逆に let y = D i ってやって値構築子をかぶせてやるのも、
オーバーヘッドなしで実行されると考えていいんだよね？

コンパイル時に除去されるんだっけ？

>>482
いいよ

ありがと、安心して使うよ

cabal でパッケージのドキュメントだけインストールって、どうやったらできる？
ライブラリごと再インストールしかない？

ハドックオプションでキャバるだけでしょ

あ、何でもない。

--hahhock-hyperlink-source オプションを付けて cabal install したんだが、
hscolour プログラムがインストールされていなかったことにあとから気づいたんだ。

これがインストールさけていないと、--hahhock-lhyprtink-source オプションを付けても
html ドキュメントが生成できずにインストールされない。
（ライブラリ自体は問題なくインストールされる）

で、hscolour プログラムをインストールしたんで、
ライブラリだけ後からでもインストールできないかなと思った次第。

パッケージを cabal unpack で落としてきて、
そこから cabal haddock でドキュメントを作ることはできた。
でも、それを正しくインストールする方法がわからない。


まぁ、まだ4、5個くらいしかパッケージをインストールしていない状態だから、
今なら全部はじめから再インストールでもいいんだけどね。

*.haddockを再生成せにゃならんからな
となると通常の方法ではソースコードも見ないとならんわけで再インストールしか無いのではなかろうか
cabalやhaddockのAPI叩けばhaddock関連をやるだけのcabal-installみたいなものも作れるとは思えるが
わざわざそんなものを作るほどの事でもないのだろう

>>490
> わざわざそんなものを作るほどの事でもないのだろう

まぁ、今回はね。
さっさと再インストールすることに決めた。

ただ、今後ドキュメントだけを再インストールしたい、
あるいは一部のドキュメントだけアンインストールしたいなんてことがあった時のために、
方法があれば備忘録に書き留めておこうかなと。

（前に、OpenGL系のライブラリを依存性の関係で2バージョンインストールしたことがあって、
その時もドキュメントは片方だけでいいのに、それも2つ表示されて目障りなこどあったし）

正規表現で、"abccdddefddddes" という文字列に、
dが3回以上続く文字列があるかどうか調べたいんだけど、
どうやってやればいいの？

regex-posix パッケージだけで事足りる？

Prelude Text.Regex.Posix> "abccdddefddddes" =~ "ddd" :: Bool
True

sed -ne '/d\{3,\}/p'
の要領じゃないか?
{3,}
で回数制限。

>>493
>>494
regex-posix パッケージをインストールし、

"abccdddefddddes" =~ "ddd" :: Bool
"abccdddefddddes" =~ "d{3,}" :: Bool

の両方ともできることを確認しました。

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

すいません、もうひとつ質問。

Char型のリストだけでなく、任意の型のリストで正規表現はできない？

たとえば [True, False, False, True, True, False, True] の中に、
False の後 True が n 回続くサブリストがあるか、みたいな。

ParseCか、showで文字列にして連結してから正規表現使う方法しか思いつかない

toChar :: Bool -> Char
toChar True = 'a'
toChar False = 'b'

ghci> map toChar [True, False, False, True, True, False, True]
"abbaaba"

>>497
>>498
やはり、一度 Char 型にマップしないといけないのか。

そして、正規表現にヒットしたサブリストを得るのなら、
更に Char 型から元の型にマップする、と。

直接できればよかったが、もう探している時間も無いので、
今回はこの方法で乗り切ることにするよ。

二人共ありがとう、助かったよ。

正規表現を使う以上は文字に変換するしかないと思います
文字に変換しているのをユーザーに意識させないような関数は
あるかもしれませんが

任意のリストに対する正規表現を書くことは可能だけど、良いライブラリがあるかは知らね
http://hackage.haskell.org/package/harp
とか

オートマトンを実装すればいいんじゃね？そんな難しくないし

>>502
オートマトンはデバッグで発狂する

Haskellで状態遷移を持つオートマトンって、どうやって書くの？

iを入力の型、oを出力の型、sを状態の型とすると、
i -> s -> (o, s)
という型の関数と(初期状態::s)の組でオートマトンを表現できる
実際には問題によって良い表現が違うけど

正規表現は美しくないと思うからそのくらいは自力で関数作りたいな

すまん、せっかくのアドバイスだが、もう時間がないんで文字列経由で実装した。
（オートマトンも実奏している余裕がない）

ただ、>>501 が紹介してくれた harp は興味あるから、
来週ぐらいにも腰を据えていろいろ実験してみようと思う。

ただ、そのパッケージダウンロードページから飛べる Home page の URL が死んでるんだが・・・
ドキュメントを見ても、使い方が分からん。

おそらく Match e a が正規表現のパターンで、これとテストしたいリストに
runMatch 関数を適用することで結果が得られるのだと思うが、
Match e a の作り方がよく分からんな。

あと、We have implemented HaRP as a pre-processor to ordinary Haskell.
この一文も気になる。

Persistent でデータベースにアクセスする方法を調べてるんだが、よく分からん。

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
TestTable
　number Int
　name String
|]

というテーブルで、number 列を PRIMARY KEY にしたいんだが、どうすればいい？

persistent-templateを使うならサロゲートキーにしないといけないからそれは無理

>>509
なるほど、そういうことか

ありがと

type Adapt1 f t1 = Adapt f t1 (IO CInt) -> t1 -> String -> IO()
ってどういう文法しょうか？
->のこんな使い方を初めて見たのでどういう文法なのかさっぱりわかりません。

>>511
ふつうの型シノニムじゃね？
Adapt1 f t1
は、
Adapt f t1 (IO CInt) -> t1 -> String -> IO ()
という型の略記

>>511
a -> b は aをとってbを返す関数 を表す"型"
型だから型シノニムを使ってそういう風に別名を定義できる

>>512>>513
型シノニムを書く時に、型シグニチャが入っていていいんですか？
Adapt f t1 :: (IO CInt) -> t1 -> String -> IO()
type Adapt1 f t1
なら分かるのですが。

いや、上の投稿はおかしかったです。
>>513
よく読んだら、
a->bが型そのもので、型シグニチャではないんですね。なんとなく分かりました。

>>515
ghciで:i (->)ってやってみるともう少し理解できるかも

コンソールアプリで Tab キーによる文字列補完能力を持つ入力機能がほしいんだが、
自前で getChar で Tab の文字コードを拾って、とかやらないといけないのかな。

なにか良いライブラリはある？

haskeline

ありがと

＼ﾊｽｹﾘｰﾝ／

ガリガリとオートマトンやパーサーを実装するときって、どんな図を描いてコーディングするの?

オートマトンを実装するときに状態遷移図を書くことはある
パーサのために図を書いた経験はない

パーサはコードが一番分かりやすいもんな

構文図？

>>523
パーサは正規表現があると途端に読めなくなる

Persistent の select 系関数って、
SQL でいう SELECT * FROM のタイプしかできないの？

全体じゃなくて特定の列のみ読み取るってのは、
select 系関数の戻り値から取捨選択するしか方法ない？

>>526
その方法と、SQLを書くことになるけどrawSqlを使う方法もある

main::IO()
main = do cs <- getContents
putStr $ lastNLines 10 cs
lastNLines::Int -> String -> String
lastNLines n cs = unlines $ taleLast n $ lines cs
--takeLastの関数の引数の型、返り値の型がわかりません
takeLast n ss = reverse $ take n $ reverse ss

>>528
ghciにロードして
:t takeLast

tupleに対するfmapが第二要素にしか関数を適用しないのはなぜ？

instance Functor ((,) a) where
fmap f (x,y) = (x, f y)

http://hackage.haskell.org/package/base-4.6.0.1/docs/src/GHC-Base.html#fmap

ええとfmap f (x, y) = (f x, f y)じゃだめなのかという意図の質問です

型が合わないじゃん

あっ、すいませんボケてました
f :: b -> a
(,) :: a -> b -> (a, b)

>>527
そっか

今のところ select 系関数の戻り値から取捨選択する方法で困ってるわけではないから、
本当に rawSql が必要な場合以外は今の方法でやっていくことにするよ

ありがと

pearls of Functional Algorithm Design

これの和訳ってどうなったんだろ
頓挫してないよね？

main = do cs <- getContents
putStr $ expand cs
expand :: String -> String
expand cs = concat $ map expandTab cs
expandTab :: char -> String
expandTab c = if c == '\t' then " " else [c]
expandTabの引数の型がStringではなく、Charであるのは何故ですか
[Char]ならわかるのですが
教えてください。よろしくお願いいたします

>>536
それはちょっと基本的すぎる見落としだな。
map の型を見よ。

cs が[Char]だからじゃね？

mapの型は (a -> b) -> [a] -> [b]
csがStringなんだからaはCharだよね

>>537
第一引数が、aを引数にとり、bを返す関数と、第二引数がリストですよね…

>>539
ここではaがChar、bがStringということでしょうか

だめだ、Haskell難しすぎます
Rubyに帰ろうと思います
みなさんありがとうございました

>>541
そう。それをconcatしてるから
expandの型は String -> String

Rubyのほうがよっぽど難しいと思うがなあ…

mapはexpandTabとcsを引数にとる
cs(String(リスト))は[a]にあたるから、aはCharである
こういうことでしょうか

そういう態度だから普及しないんだよ

良いモノは普及させる
本当に良いモノは普及させない

csはString、すなわちCharのリスト
mapの第二引数[a]は、[Char]に置き換えられるから、aはChar

map :: (a -> b) -> [a] -> [b]

map :: (Char -> [Char]) -> [Char] -> [[Char]]
a = Char
b = [Char]

-- Stringは[Char]と同じ
type String = [Char]

map :: (Char -> String) -> String -> [String]

つか>>536の定義って変ですよね？

型はとりあえず置いておいて、適当な例で動かしてみれば分かるんじゃない?

expand "ab¥tc"
expand ['a','b','¥t','c']
concat $ map expandTab ['a','b','¥t','c']
concat [expandTab 'a',expandTab 'b',expandTab '¥t',expandTab 'c']
concat ["a","b"," ","c"]
"ab c"

あ、スペースが潰れてたのか。自己解決しました。

>>547
そんなつまんない理由なのか。
あたくしのなんか普及したら人類が滅んでしまうから公開してないのに。

>>553
おい、そんなこといっていいのか？
お前のプログラム、闇プログラマに狙われるぞ

おまいら何処でハスケル使ってんのよ。
実務で使ってる人数人しか知らんのだけど。
つかどんな仕事してんの

ttp://janestreet.com/

>>554
ロシアのハッカーとかですか？
あたくしは不用意に>>556などを踏んでIP抜かれたりしませんし。
それにあたくしのタワゴトを信じる人は皆無でしょ？

https://www.sc.com/sg/

>>557
闇プログラマもjanestreetもしらんとは、精進しろ

スレの知能レベルから推測するに、去年からHaskellが中学校の必須科目にでもなったのかな？

正誤表

x スレ

o 板

>>560
英語が小学校、関数型とデータマイニングが中学での履修範囲になったよ

小学生向けの習い事教室にならないから不思議

>>562
マジで。手続き型が許されるのは小学生迄よねwwwとか言われる時が来るのか(´･_･`)

四半世紀後には、大学の専門必修でgrassとbrain f*ckを教えるらしいよ
もっとも、今だってムダしか教えてないけど

大学とかの悪口は結局自虐にしかならないぞ
学習しないんだな

学習しないんだな(ｷﾘｯ

ほとんどの大学は情報学科でhaskellなんてならわない
むしろ数学科のほうが学ぶ可能性が高い
名大は数学科だと定理証明系を習うみたいだね

定理証明系の使い方を習うのか、定理証明系を作るための理論を習うのか

情報学科って、prolog、schemeが標準?
パッと見、定理証明の方が開発に役立ちそうなんだけど

>>566
Youtubeに上がってる動画の方がマシってな講義してんじゃねーよカス共

prolog、schemeなんてやるのはいい大学だけ
中堅私大ぐらいだとせいぜいjava

そろそろ中堅私大でも計算機学科はHaskell教えてるんじゃない？

情報と称してるだけで計算機科学をろくにやってないようなとこならともかく。

中堅私大のカリキュラムはある程度でオブジェクト指向を教える
それにhaskellは向いてないから微妙だと思うが
haskell教えてる大学があるなら具体的にどこだよ

某旧帝の数学科だけど授業で触れたことあるのはRubyとCくらいだなー あとOctaveとか
ちなみにRubyは完全にただの手続き型言語として使われていた

エディンバラ

haskell site:ac.jp でググると研究室レベルでやってるとこは山ほどあるな

習ったことしかできないのがエリートω

習ってすらいないのがボンクラ

>>568
おみゃーさん、大学名の略称は格好悪いでよ。

ある程度でオブジェクト指向を教えるようなところなら関数プログラミングも教えるだろ。

>>572
出身大学の偏差値なんて50きってたがPrologならやったぞ

行き遅れのアホ教授と思っていたけど、Erlangのおかげで飯ウマかしら

prologは推論の基本を学ぶにはちょうどいい。他の言語は全部ダメ。

DFS、BFS、宣教師と人喰い土人までProlog
HaskellでAPI叩いてるだけのヤツらはアホに見える

計算機科学でHaskellとか何の冗談だよ

computer science > programming language > Haskell

高卒から見ると計算機科学＝プログラミングなのか？

原始時代？

ソフトウェアデザインの最新号がまた関数型言語の特集だな

>>588
そんなバカバカしい言葉にプライドを持っているのなんて、
せいぜい学科にいる教授と学生ぐらいだろう

なんだ、大学院生（博士課程）というものになんか幻想を持ってるのか？

計算機科学とHaskellにつながりがないとか、それこそ酷い冗談だな。
なにか計算機科学というものを根本的に勘違いしてるだろ。

>>588
Haskellに関する海外の論文に、こういう分類がされてたの。
もしかして日本だと違ったりするの？w

>>593
すまん>>587へのレスじゃ無いんだ
計算機学科で特定のプログラミング言語を教えてるなんてアホなレスがあったからさ

> 計算機学科で特定のプログラミング言語を教えてるなんてアホなレスがあったからさ

不特定の言語を教えてる学科があるなら教えてくれ。

計算機学科の学部レベルのプログラミング教育が、言語を指定せず、
任意の言語を使って教育できる、ということを示せたらチューリング賞も夢じゃないからな。

「特定のプログラミング言語を教える」が「特定のプログラミング言語を使ってプログラミングを教える」にすり替わってて笑う

結局デタラメを言ってるだけじゃねーか

> 計算機科学でHaskellとか何の冗談だよ
って発言したおバカさん。いつまでバカを言い続けるのかねぇ。

そこまで粘着するほど悔しかったのか……。

両者ともに何の根拠も示さずに罵倒しているだけなのが美しいな

証拠が無いのはどう見ても片方だけだが

おっ、Haskellerらしい話題で盛り上がってんね

>>602
Haskellらしいってより2chらしい話題だと思うｗ

>>595 チューティング賞と間違ってるぞ

坊主憎けりゃ袈裟まで憎い
まあ最初何を憎んでいたのか忘れちゃってるんじゃないの

流れをぶった切って申し訳ないが、質問させてくれ。

関数の型シグネチャのコンテキストの部分でチルダが使われているのはどういう意味？

こんな感じ f :: (C a ~ D) => ...

ttp://stackoverflow.com/questions/10376963/why-doesnt-this-haskell-typeclass-code-work
これかな？

>>606
equality constraintというGHC拡張で、(C a ~ D)なら(C a)とDが同じ型だという制約
http://www.haskell.org/ghc/docs/7.6.3/html/users_guide/equality-constraints.html

ありがと

>>607
すまん、それは違うな。
それは r という型変数を Int に解釈するようにプログラムされてるが、
そんな解釈はできんぞ、というエラーの方だね。

>>608
知りたかったのはこっちの方だ。
きっと拡張機能だろうなとは思ったが、名前が分からず途方に暮れてた。
リンク先調べてみるよ。

>>607
いや、チルダ記号が持つ意味は >>608 と同じか。

無下にしてすまんかった。

どそまい

ゴミみたいな話題と質問しか無いな

JavaScriptで学ぶ関数型プログラミング
http://www.amazon.co.jp/dp/4873116600/

なんか面白そう

す・れ・ち

javascriptで学びたくねえw

頭おかしいよな

Joy of Clojure の人のやつか

Listをimportしようとすると、
fgrep.hs:2:8
Could not find module 'List'
It is a member of the hidden package 'haskell98-2.0.0.1'.
Use -v to see a list of the files searched for.
とエラーを吐かれるのですが、どうしたらListをimportできますでしょうか

Data.Listじゃないの？

高階関数mapを自作してみました。mapの第一引数にはsquareを渡そうと思います。
map(f, list)
　int (*f)(int);
　char *list;
{
　char x = *list;
　char *xs = &list[1];
　if (x) {
　　(*f)(x - 0x30);
　　map(f, xs);
　}
}

square(n)
　int n;
{
　return n * n;
}

main(argc, argv)
　int argc;
　char **argv;
{
　map(square, "123");
}

そうですか

そのプログラミング言語、戻り値の型ってどうなってんの？　型推論？

返り値はdefaultではint型ですよ

(*f)(x - 0x30); これ何やってるの？

関数(*f)に引数(x-0x30)を渡して呼んでる

関数ポインタfを使って、square()の呼び出し
(x - 0x30)は引数で、0x30引いてるのはアスキーコードの引き算
結果として、数値の１、２、３が得られる

C言語だから、スレチかな？

import System
import List
main = do args <- getArgs
cs <- getContents
putStr $ fgrep (head args) cs
fgrep :: String -> String -> String
fgrep pattern cs = unlines $ filter match $ lines cs
where
match :: String -> Bool
match line = any prefixp $ tails line
prefixp :: String -> Bool
prefixp line = pattern 'isPrefixOf' line
>>618のエラーが出るのは何故でしょうか
GHCのバージョンは7.4.1です

きくまでも なかろうよ！

関数(*f)に引数(x-0x30)を渡して呼んで、その戻り値はどうなってるの？

この例じゃ、その値は捨ててるね

関数の書き方、古くね？

>>628

>>619 を無視か

というか、それなら import System でもエラーじゃないのか？

Systemのほうはエラーになりませんでした
ListをData.Listに書き換えたところ、今度はSystemのほうがエラーになりました

>>634
じゃあ、System を System.Environment に変えろ

Persist + Conduit について質問。

Conduit のソース側で、Persist を使ってデータベースから行を読み取りデータ型Aのリストを流し、
Conduit のシンク側で、そのデータ型Aを使って print 関数なんかで表示する

ということをやってみようとしてて、本当はモデルビューアーキテクチャで分けたいんだけど、
ソース側とシンク側が強く結びついてしまって、なかなかうまく分離できない。
（もちろん、ソース側をモデルに、シンク側をビューに置く）

ソース側の型は (PersistMonadBackend m ~ SqlBackend, PersistQuery m) => Int -> Source m A
シンク側の型は (MonadIO m) => Int -> Sink A m ()

これだけなら綺麗に分けられそうだけど、
ソース側とシンク側を繋げる関数を分ける関数の型が
(PersistMonadBackend m ~ SqlBackend, PersistQuery m) => m IO
となってしまう。

つまり、PersistMonadBackend m ~ SqlBackend, PersistQuery m この制約が、
モデルだけに限らず、ビュー側（あるいは間を取り持つところ）にまで影響する。

なので、もしモデルのソース側を Persist を使わず、別のなにか、
たとえばただのファイル読み取りにしようとすると、
ビュー側（あるいは間を取り持つところ）の型まで変えなければならない。


Conduit が表現しようとしているモデル（紛らわしいがMVのモデルの意味ではない）は、
モデルビューアーキテクチャには向かないのかな？

ごめん、ソース側とシンク側それぞれの型の第1引数にある Int は質問には不要だった
無視してくれ

>>636
グダグダしててスマん

モデルビューアーキテクチャじゃなくて、
モデルビューコントロールアーキテクチャね

あるいはドキュメントビューアーキテクチャ

>>636
>これだけなら綺麗に分けられそうだけど、
>ソース側とシンク側を繋げる関数を分ける関数の型が
>(PersistMonadBackend m ~ SqlBackend, PersistQuery m) => m IO
>となってしまう。
これの意味が分からん
「ソース側とシンク側を繋げる関数を分ける関数」って何？

>>639
一晩開けて読みなおしてみたら、確かに意味不明だな、ごめん。

MVC アーキテクチャにおいて、ユーザーからの要請で
モデルで管理しているデータをビューへ表示することを考える。

[Model] は次の関数を公開する。
recordsSource :: (PersistMonadBackend m ~ SqlBackend, PersistQuery m) => Source m A

[View] は次の関数を公開する。
recordsSink :: (MonadIO m) => Sink A m ()

[Control] は次の関数内でソースとシンクを繋げる。
viewRecords :: (PersistMonadBackend m ~ SqlBackend, PersistQuery m) => m ()
viewRecords = recordsSource $$ recordsSink

ごく簡単にエッセンスだけ抽出するとこんな感じ。
（実際は表示方法やデータの個数などいろいろ制御するための引数があったり、
関数の定義ももう少し複雑だったりする）

本当は [Control] は [View] がどのような仕組みで
データを管理しているのか知らなくても良いようにしたいのだが、
今現状では [View] が persistent パッケージのライブラリを使っている影響が、
[Control] 側にも及んでいる（型シグネチャのコンテキストという形で）。
よって、MVC アーキテクチャなのに、[Model] と [Control] が強く結びついている。

これをちゃんと分離したいのだが、Persist + Conduit でやっている限りでは
実現は難しいのだろうか。


あれから考えてみたのだが、Persist + Conduit に限らず、
モナドを使っている限りついて回る問題ではないかと少し思えてきた・・・

recordsSourse内でrunしてMonadIOで返すようにすればいいんでないの？

>>641
実はそれ考えてプログラムしてみたんだ。
確かにちゃんと分離できる。

が、データベースの制御について本やネットで調べてみると、
オープンとクローズは頻繁に行わない方が良いらしい。

今回のアプリはデータの表示、書き換えがユーザーの手によって頻繁に起こるから、
オープン／クローズは Main 関数内で一度ずつ行って、
その間で Conduit を使ってデータや、削除などの制御情報を流そうかと。

そうすれば、[Model] の表現方法が変わっても、
[Model] と、全体を取り持つ Main 関数の2つだけ変えればいいはず。

もし改善策が思いつかなければ、

(1) データベースを制御するごとにオープン／クローズするように諦めるか、
(2) Persist + Conduit の組み合わせを諦めるか、
(3) データベースを使うのを諦めるか

の3択になって、まぁ仕方ないかなと思ってる。

Persist + Conduit はもともと Yesod で開発されたものだけど、
Yesod のモデルではもしかしてオープン／クローズは繰り返すものなのかな。

>>642
ならModelでPersist関連のラッパーモナドとrun関数を用意して、それを返すようにするとか
実装は必要に応じてModel内で差し替えればいい

>>640
ControlがModelとViewを直接参照してるのがおかしいように見える
この二つを引数として取るようにできる？

>>644
できるが、そもそもこの二つ（ソースとシンク）を引数として取る関数が ($$) だよ。

というか、MVCアーキテクチャって、C が M と V の間を取り持つんじゃないの？
C がユーザーとのインターフェースを担当して M に仕事を依頼、必要なら V にも更新を依頼。


こういうストリームが Conduit でできると理想なんだけど

[ユーザーからデータ変更依頼] -> C ==> M ==> C ==> V

まぁ 2 つ目の C は要らんかもしれんが。
C ==> M のストリームは制御信号を流す（この例の場合はデータ変更依頼信号）。
M ==> C ==> V のストリームで実際のデータを流す。

無理なら、C を Conduit のソースにするのではなく、ソースはあくまで M にして、
C は M ==> (C) ==> V のストリームを発火させるだけにする。

データベースのオープ／クローズを1回で済ますために、
Main 関数で MVC全体を囲うように Prtsist の run をしているんだけど、

>>643
> ならModelでPersist関連のラッパーモナドとrun関数を用意して、それを返すようにするとか

このような状況で run を M 側に持ってくることができるのなら大満足だ
ちょっと考えてみるよ

>>645
>できるが、そもそもこの二つ（ソースとシンク）を引数として取る関数が ($$) だよ。
うん、このケースでは($$)そのものがコントローラに対応すると考えればいいと思う
単にデータを転送するより複雑なことがしたいなら、そういう関数を書けば良い
あるいはコントローラをConduitとして書けるならそれでもいい

いずれにしても、コントローラがPersistMonadBackend云々の制約を
知らなくても良いようにするには、コントローラが直接recordsSourceに言及しなくて
良いようにするのが一番手っ取り早い

>>646
> いずれにしても、コントローラがPersistMonadBackend云々の制約を
> 知らなくても良いようにするには、コントローラが直接recordsSourceに言及しなくて
> 良いようにするのが一番手っ取り早い

その方法を質問してたつもり

なかなか上手く質問できず誤解させてしまったようだ、すまん

>>647
>その方法を質問してたつもり
何が分からんのか分からん

> C ==> M ==> C ==> V
これをConduit式で素直にやるなら、最初のCがSource、
Mと二番目のCがConduit、VがSinkになる
もっと柔軟性が欲しければ、CがMとVを受け取ってm ()でも返すようにする
でmainでmを特定のデータベースバックエンドに実体化する

完全な(コンパイルできる)ソースを貼ってくれた方が伝わりやすいかも

HaskellでMVCを実現するなんて面白いね
このあたりを勉強したいのだけれど、おすすめのリソースがあれば教えて下さい

無いから自分で考えるしかない

>>648
> これをConduit式で素直にやるなら、最初のCがSource、
> Mと二番目のCがConduit、VがSinkになる

それは分かるが、そのモナドの型が
(PersistMonadBackend m ~ SqlBackend, PersistQuery m)
というコンテキストでなければならなくなる。
>>640 の viewRecords 関数のように。

> でmainでmを特定のデータベースバックエンドに実体化する

>>645 でも言ったが、現状そうしてる。

で、これも >>645 で言ったが、
run を M 側に持ってくることができるのなら大満足だから、
それを考えている。

>>651
>それは分かるが、そのモナドの型が
>(PersistMonadBackend m ~ SqlBackend, PersistQuery m)
>というコンテキストでなければならなくなる。
いや、そうやって分ければMVCが全部同じコンテキストを持ってる必要がなくなるだろ
Mでは(PersistMonadBackend m ~ SqlBackend, PersistQuery m)
Vでは(MonadIO m)
Cでは(Monad m)か(MonadIO m)

>>652
> Cでは(Monad m)か(MonadIO m)

これが今のところ俺の力ではできなくて、うーんって唸ってるところ。

MVC では制御の起点は C になる（ここの認識が間違ってたら全てやり直しだけど）。
データの表示という処理なら、C が M からデータを取ってきて、V へ渡す。
データの書き換えなら、C が M へ書き換えを指示し、結果を受けて V へ渡す。

C の中にはデータ変項関数 changeRecords やデータ表示関数 viewRecords などがあり、
またユーザーからの入力を受け付ける関数 input もある。
関数 input の中に、例えばユーザーがデータ変更ボタンを押したら関数 changeRecords を呼び、
ユーザーが最新データ表示ボタンを押したら関数 viewRecords を呼ぶ、などの処理がある。

この関数 changeRecords や関数 viewRecords の型は、
M が公開しているソース関数と同じコンテキストが必要になる。
(PersistMonadBackend m ~ SqlBackend, PersistQuery m) => ...

なぜなら、たとえば関数 viewRecords の定義は recordsSource $$ recordsSink だから。
この辺りは勉強中だから、本当にそうなのかと言われれば自信はない。

ただ、俺は viewRecords = recordsSource $$ recordsSink という関数は、
MVC の役割から言って C に書くのが相応しいと思ってる。
（だからコンテキストの問題で困ってる）

もしかして、この考え方を改めようというアドバイス？

ん？その場合どこでDBをrunするの？

>>654は>>652宛て

>>654
俺は Main 関数内で run してる。

>>653
>なぜなら、たとえば関数 viewRecords の定義は recordsSource $$ recordsSink だから。
そこにrecordsSourceを直接書く代わりにCへの引数として受けとるようにする
という話を>>644からずっとしてるつもり

>>654-655
mainを想定してる

>>657
飲み込みが悪くてすまんが、Cへの引数として受けとるというのが今ひとつ分からない。

もしかして、viewRecords 関数ではなく

f :: (MonadIO m) => Source m A -> m ()
f src = src $$ recordsSink

という関数を C に作れってこと？
で、viewRecords 関数の定義は f recordsSource にしろと？

もしそうなら、viewRecords 関数はどこに書く？

勘違いしてたらごめん

>>659
たとえば、メインループを行う関数がCにあるなら、それを

loop :: (MonadIO m) -> Source m A -> Sink A m () -> m ()
loop source sink = input >>= \case ...

みたいに定義して、main内で、

runSqlite $ loop viewRecords recordsSink

みたいに呼ぶ

メインループがmain側にある場合も基本は同じで、mainが
viewRecordsを渡してやる

>>660
あぁ、やっと言いたいことが分かったような気がする。

C の loop 関数では、具体的な viewRecords 関数などを内部で呼ぶ代わりに、
「データを流す役割のソース」や「データを変更する役割のシンク」や「データを表示する役割のシンク」
などといったソース群とシンク群を引数で受け取るようにして、それを使う。

で、main 関数内などの MVC を統括する部分で、実際に C の loop 関数に、
具体的なソースやシンクを渡すのか。

なるほど、とても参考になった。

>>643
こっちも意味がわかった。

SQLへのアクセスに関わる部分（runSqlConn や runResourceT なども含めて）は
すべて M の中に閉じ込めることができてスッキリしたよ。

二人共ありがと

FP Haskell Center

こういうIDEがクラウドじゃなくて普通にインストールアプリとして欲しいのだが

試しに使ってみたけど、リアルタイム構文チェック凄いな
エディタの構文チェッカープラグインよりこっちの方が速いって一体ｗ
このIDEもサーバ側も全部Haskell製(前者はFayでJSにしてあるけど)なんだなー、面白い

関係ないけど、Vim使いならSyntasticとghcmod-vim,neco-ghcあたりを入れればかなりIDEっぽく使えるのでお勧め

arrowを使うと仕様変更に強くなるって聞いたんですけど本当ですか？

>>665
誰に聞いたのそれ

>>665
本当だよ
君も今すぐ使った方がいい

銀の弾丸

>>665
本当だよ。
みんなもう使ってるよ。

早く使わないと取り残されるよ。

>>665
というかモナドは時代遅れだよ

というか、みんなまだArrow使ってるのか

一人ぐらいArrowとは何ぞやと語ってくれる事を期待した自分が馬鹿だった

あれだよ。矢だよ。矢

>>672
もっと煽らないと……。

a...arrowってなんですか？

arrow使ってるのに関数をカジュアルにuncurryされると萎える

uncurryのなにがまずいの？

>>672
なんで最初にそう聞かないの？　いくらでも教えてあげたのに
おっとそろそろ出勤だ

>>676
これは
uncurry (+) <<< (*100) &&& (*10) $ 2
こうすればいいですか><
app <<< (+) . (*100) &&& (*10) $ 2

この書き込みを真に受けて質問したんですが、レスを見る限りこの人がおかしいだけなんですかね。

haskell-jaより引用:
(ikegami氏)
Arrow でつくると、疎結合の疎の具合がさらにゆるゆるになるので、多少の仕様変更にもすぐに対応できるかわりに
さらにスピードが低下する
仕様変更に対する強さ <-> スピード という両軸で見ると
Arrow <<< State/Reader/Writer monad << ST monad
http://www.haskell.org/ghc/docs/latest/html/libraries/base/Control-Monad-ST.html
ST は黒魔術なので、はっきりいっておすすめできない (が、スピードのために必要になるかもしれないので老婆心で)

文脈を知らないけどそれだけ見ると支離滅裂だな

まさかSTが黒魔術だったとは

あー、そんな書き込みもあったな
例えばＩＯモナド版と純粋関数版の二つを作らなければならないはずのところを
arrowで抽象化しておけば一つだけ作ればすむ
だからＩＯで使うつもりだった関数を急に純粋に変えたくなった
みたいな状況で仕様変更に強くなるか、と聞かれたらyesなのでは
もうarrowのことあまり覚えてないので間違ってたらゴメンネ

なるほど、参考になります……

初めから全部モナドで抽象化しておいて
純粋にしたいところだけidentityモナド使えばいい気がしてきた
やっぱarrowいらんわ。arrowは糞。

モナドはdo記法があまりにも的確すぎて、数学の歴史を愚弄している

最近どこかで聞いたフレーズ…

>>686
愚弄？ｋｗｓｋ

歴史を愚弄でググレ

HSpec を使ったテストコードを cabal で自動実行したいのだが、
テストコードの書き方が分からん。
（参考資料 : https://github.com/kazu-yamamoto/unit-test-example/blob/master/markdown/ja/tutorial.md）

Exceptoin の bracket 関数を使って、
メイン処理の前後でリソースの確保と開放を行う関数 useResource（仮名）がある。

メイン処理サブ関数 f1、f2、..., fn があって、
メイン処理関数 f :: Resource -> IO a の中でそれらが呼ばれ、処理される。
もちろん、f1、f2 らはそれぞれ useResource 関数で確保したリソースを使う。

本来なら f に useResource を適用して一連の処理を行うのだが、
今は個々の f1、f2、..., fn をテストしたい。

こういう状況の場合、HSpec 用の t :: Spec 関数はどう書くのが一般的なのかな。

describe "〜〜〜"
　it "〜〜〜" $ do
　　[ここ]

[ここ] に useResource を書いて f1 や f2 などをそれぞれぶち込んで
結果を正常値と比較したり、例外の発生をテスしたりすると、
個々のテスト毎にリソースの確保と開放が発生するよね。

cabal で自動テスト実行するなら、これは仕方ないのかな？

もしリソースがデータベースとかで、テストで QuickCheck を使ってたら、
けっこう悲惨なことにならない？

一般的な自動テストの話で恐縮だか、
時系列で変化するものは、一般的に考慮が必要。

単体テストなら
・関数的な結果を返すモックにする
・DBの中身が変わらないことを前提に、トランザクションで囲んで、rollbackさせる
(comitされる処理は対応出来ない、serialやoid消費される前提)
現在時間などの変数に注意。

結合やシナリオということであれば、
・DB初期化、シード投入、実行
・組み込みDBなら、スナップショット切り替え、実行

quickcheckに組み合わせるのは、基本モックなのではという気がする。

>>691
あぁ、なるほど、こういう場合にモックを使うのか

ありがと、やってみるよ

hspec-test-framework パッケージを入れて、
HSpec に test-framework をかぶせて使ったのだけど、
テスト結果を Jenkins で使える XML 形式で出力するにはどうすればいい？

hspec-test-framework パッケージのTest.Framework.defaultMainのソース見て分かった

現状無理だったわ

スレ汚してすまんかった

テスト時にモックを使う方法で基本的なことを確認させてほしい。

>>690 の状況をシンプルにすると、
モジュール A の中でデータベースを使っていて、
データを出したり書き込んだりする関数が公開されている。
このモジュール A が公開している関数をテストしたい。

もちろん、モジュール A は変更を一切加えること無く。

データベースの接続などはコストが高いのでテスト時はモックを使う、となると、
そもそもモジュール A はデータベースへ直接アクセスしていてはダメだということか？

例えば、データベースへのアクセスを抽象化した型クラスを作り、
そのインスタンス型の値を外部からもらって、それを使ってアクセスするようにしておかないと、
データベースのモック化はできない、という認識でいいのかな？

クラスの定義において、関数の引数や戻り値の部分を型変数でパラメータ化するように、
コンテキストの部分をクラス変数みたいなのでパラメータ化できないでしょうか。

たとえば

class C c where
　f :: (??? t) => Int -> t

のようなクラス宣言があったとして、この ??? の部分を
型クラス C のインスタンス型毎に変えたいです。

{-# LANGUAGE InstanceSigs #-}

instance C X where
　f :: (ClassA a) => Int -> a
　f v = ...

instance C Y where
　f :: (ClassB b) => Int -> b
　f v = ...

このようなことは可能でしょうか。

>>696
すいません、関数 f を使う時に
コンテキスト制約に使ったクラス ClassA から型 X のものであること、
コンテキスト制約に使ったクラス ClassB から型 Y のものであることが推論できるように
ということです。

そのような推論ができなければ、クラス C の定義において
関数 f の引数か戻り値に c を入れておくことで対処しますが、
とにかく >>696 のような使い方ができるクラス変数なるものはあるか、という質問です。

>>696
{-# LANGUAGE ConstraintKinds, TypeFamilies #-}
class C c where
　type Constr c :: * -> GHC.Exts.Constraint
f :: (Constr c t) => Int -> t

ごめんインデントみすった
{-# LANGUAGE ConstraintKinds, TypeFamilies#-}
import GHC.Exts
class C c where
　type Constr c :: * -> GHC.Exts.Constraint
　f :: (Constr c t) => Int -> t

>>697
>コンテキスト制約に使ったクラス ClassB から型 Y のものであることが推論できるように
具体的にどういうコードでどういう推論が起こって欲しい？

>>699
ありがとうございます。
そのやり方で、インスタンス毎にコンテキスト部分をかえることができました。

ついでに、ConstraintKinds や TypeFamilies を調べている特に、
次の方法でも似たようなことができる事が分かりました。

{-# LANGUAGE MultiParamTypeClasses, ConstraintKinds, TypeFamilies #-}

class C c p where
　f :: (p t) = Int -> t

instance C A X where
　f :: (X t) => Int -> t
　f v = ...

instance C B Y where
　f :: (Y t) => Int -> t
　f v = ...


> 具体的にどういうコードでどういう推論が起こって欲しい？

今回挙げた例で言えば、

g :: (X t) => t
g = f 7

という使い方をすれば B の f ではなく、A の f だとみなされると嬉しいです。

>>700
>次の方法でも似たようなことができる事が分かりました。
そのコードならTypeFamilies拡張要らないな
>>699の場合ではConstrという関連型を宣言するのに必要だった

>g :: (X t) => t
>g = f 7
>
>という使い方をすれば B の f ではなく、A の f だとみなされると嬉しいです。
これは無理だと思う。fの型は
f :: (C c p, p t) => Int -> t
だけど、gの型シグネチャからは(X t)から(p t)が言えることが要請されるだけで、
p=Xが確定する訳じゃないので、情報が足りない

>>701
あの後いろいろ試してみたのですが、自分で見つけた方法の方は、
今回の目的に関して言えば、どうも使い勝手が悪いです。

> これは無理だと思う。fの型は ・・・

このことと関連しますが、自分のやり方だとクラス内の全ての関数で、
class C c p where の c と p をシグネチャのどこかに入れないと推論できない。
class C c p where 程度ならまだなんとかなりますが、
class C c x y z ... where と少し増えただけでとても不便になりました。

その点 >>699 の方法は柔軟性があるので使いやすかったです。

> gの型シグネチャからは(X t)から(p t)が言えることが要請されるだけで、
> p=Xが確定する訳じゃないので、情報が足りない

やはりそのようですね。
こちらの方は諦めます。

こういう事ってできますか？（実際はもっと複雑ですが要約するとこんな感じです）

f :: a という関数シグネチャがあって、この関数 f の定義として、
a が Int 型だった場合のみ特別な事をして、そうでない型の場合は一般的な事をする。

f :: Int
f = 特別な何か

f :: a
f = 一般的な何か

みたいな。

>>703
「特別な何か」と「一般的な何か」が意味的に同じ(違うのは効率だけ)なら、
書き換え規則で後者を前者に書き換えるのがおすすめ
意味的に違うならOverlappingInstancesしかないけど、
いろいろ厄介なので、使わないで済むなら使わないのを勧める

>>704
ありがとうございます。
調べてみます。

ghci 上での書き換え規則について質問です。

予め ghc でコンパイルして *.hi ファイルを作っておくことで、
対となる *.hs ファイルをロードすれば ghci 上でも書き換え規則が適用されるんですが、
*.hi ファイルの無い *.hs ファイルのロードのみでも適用する方法って無いでしょうか。

ちょっとだけ不便です。
「そう言えば忘れてた」と思って *.hs の内容をちょっと変更して、
ghci 上で再ロードした時に、書き換え規則が適用されず「あれ？」となり、
*.hi ファイルを出していなかったことを思い出すまで時間がかかったり・・・

ghci 上でちょっとした修正と実行テストを繰り返す場合など、なかなか面倒だったりしますよね。

>>706
書き換え規則は最適化の一種なのでghciでは使えないっぽいね

>>707
やはりそうですか。
これは我慢するしか無いですね。

将来のバージョンでは書き換えなど
最適化してロードされるオプションも付けて欲しいです。

>>708
要望はglasgow-haskell-usersへ

>>709
英語が書けないから、要望を出すのは諦めました。

その程度の簡単な英語もわからないんじゃ Haskell 使うのつらくない？

>>711
今のところ全く問題ないです。
読むことはできるので。

東南アジアの留学生がHaskell使うために日本語の勉強しなおしたとか言ってたのを思い出した

HUnit で、実装が正しければ必ず例外が発生することをテストするにはどうすればいい？

例外が発生しない状態だとテストに失敗しとたとみなす、という意味だけど。

>>714
例外が投げられたら捕捉してTrueを返し、そうでなければFalseを返すようなアクションを書いて、
それを(@?)かなにかを使ってテストにすればいいと思う

>>715
やっぱそういう事になるのか
例外をテストする関数か何かライブラリにあっても良さそうなもんだが・・・

ありがと

test-framework でテストを構築してるんだけど、たとえば

testGroup "Test Group1"
　[ testCase "Test1" test_something1
　, testCase "Test2" test_something2
　]

というテストグループがあったとして、
test_something1 のテストに成功した場合のみ
test_something2 のテストを行う、ということはできる？

試しに test_something2 のテストを testGroup で囲ってみたが、
何も変わらなかった（普通にテストされる）。

Haskellでコンソールの好きな場所に好きな色で文字を表示する方法を探しています。

やりたいことは、コンソールの一部領域だけスクロールするように見せたり、
プログレスバーを表示させたりするような CUI アプリを作ることです。

>>718
個人的に使っているのは、この二つ。
CUIフレームワークなら: http://hackage.haskell.org/package/ncurses
自分で細かく制御したいなら: http://hackage.haskell.org/package/ansi-terminal

tasty-rerun
じゃあかんの？

>>720
俺へのレスだったか、すまん気づかんかったわ

あかんも何も、tasty というテストフレームワークの存在を初めて知ったから、まだ分からん
tasty-ant-xml 使って jenkins とも連携できそうだから、ちょっと試してみるよ

>>720
使ってみたが分からんかった
tasty-rerun でどうやれば >>717 を実現できる？

--rerun-filter オプションで指定できる 4 つのオプションを組み合わせるってこと？

>>719
調べてみたところ、出力なら ansi-terminal で十分であることが分かりました。

ただ入力側も扱いたいので ncurses を使おうとしましたが、
パッケージのインストール時に外部ライブラリとして ncursesw/ncurses.h が必要です。
私の使っている ArchLinux ではどうもこの ncursesw を使うのに一手間かかるようで、
その一手間がどういったものか情報が得られませんでした（ncurses.h 自体はある）。
正確に言えば、私が理解できる情報が得られなかったわけですが。

もう少し調べてたところ、vty というパッケージがあることが分かりました。
"vty is terminal GUI library in the niche of ncurses." とのことです。
これで行けそうな気がします。

アドバイスありがとうございました。

ConduitのドキュメントがHoogleで引っかからないです。
でもHayooでは引っかかる。
みんなHayoo使ってるんですかね？

(^o^)／ おHayoo-

>>724
Hayooメインで使ってる。
でも、サービスがよく止まってるから、結果的にHoogleも併用してる。

Hoogleはローカルで動かすもんだろ

~.cabal/config 編集して
documentation: True
にしてから
cabal install world --reinstall
すると、ドキュメントもローカルに落とせるんですね、、知らなかったです。
これをhoogleコマンドから引けたらもっといいんですけど、どうすればいいのかよくわからない…

自分の環境では"hoogle data"と打ち込むだけでHoogleのインデックスが作られるけど、確かcabal側の操作が他にも必要だった気がする

Haskellでゲーム作って(真似て)みたよ。
字幕をONにして見てね。
http://www.youtube.com/watch?v=ABsutPSLuqQ

*>とか<*の使いどころって、どこ？

すごいなー　１５００行でつくれちゃうのかー
本家はjavaだっけ？処理速度的にどうなのか気になる

Haskell は純粋関数型で、副作用が排除されてるから融合変換はかなり豪快に出来るって聞いた。
ただ細かな部分での最適化はそれほどでもないみたい？

親父から授かった遺言は、haskellを極めろ

>>730
コード見たい

>>735
完成したら公開する予定って G+ で言ってる

>>732
書きなぐった感じで作ってもそれぐらいだったよ。
偉い人が書くと余裕で半分以下になると思う。

処理速度は他言語で似たようなもの作ったことないから
比較できない・・・。

ただ、直感的にFortranと比べると若干遅い気がする。
表面に出るブロックだけピックアップして描画してるんだけど、
ピックアップするときに50万ブロックの走査したら数秒かかったｗ

>>733
今回のコードは8割以上IOモナドに浸食されてるんで・・・。

>>735-736
動画の最後でも言ってるんだけど、やはり大方の人に
最後まで見てもらえてなさそうだなｗ

>>737
動画最後まで見たけど、早送り気味で見たから。

>>738
そっか。
最後までみてくれてありがとう。

>IOモナドに侵食
それでも別に融合変換は出来るのでは？

>>740

>>733の副作用に条件反射して答えちゃいました

そもそも融合について名前程度しかしらなかったので
「関数プログラミングの楽しみ」やRWHの該当箇所を
流し読みしてみた。

でも、アドレス変換して値を参照してるところを直値を
直接参照して計算するようにプログラムを変換してくれ
るのかな・・・程度にしかわからなかった orz

もしその理解で正しいなら、この技法を取り入れたら
かなり早くなりそう。

難しいことは避けてきたけど、そろそろ真面目にHaskell
を勉強します・・・ m(_ _)m

え、融合変換って最適化コンパイル時のコード置き換えでごにょごにょやって高速化する奴じゃないの？

直接参照云々はUNPACKのことかな。これも確かに高速化に繋がるけど、融合変換とか副作用とかとはあんまり関係ない

>>742
説明の仕方が悪かったです。

中間のデータ構造を省いて必要な値を直接参照するように変換するような
もののような気がします。
例えば、以下のようなデータ構造があって、ある関数が特定の箇所を
走査する場合に以下のように変換するようなイメージだと理解しました。

data Aaa = Aaa { bb :: Double, cc :: Bool}

func :: [Aaa] -> Double
func aaa = foldl (\ s (Aaa {bb=d}) -> s + d ) 0 aaa

この関数を以下のように変換してくれる？

func aaa = foldl (+) 0 aaa'
where
aaa' = map (\ Aaa {bb=d}) -> d) aaa

UNPACKとの違いはよく分かりません・・・。

補足。

>>743では変換後もリストを使ってますが、そのリストが直値の配列
になってるような感じだと思いました。

上手く説明できずスミマセン。

コンパイラの最適化で自動的にやってくれることのような気もします・・・。
ただ、副作用の有無は最適化時に重要になってくるような気もします・・・。

副作用に汚染されてても融合変換ってうまくはたらくんだっけ？

>>743
逆じゃね？

>>745
結局のところ、どうなんでしょう・・・。
ただ、副作用があると難しそうですよね。

>>746
言わんとしてることは分かります。
たぶん、会話が噛みあってないだけだと思います。

総合政策学部みたいなヤツがHaskellコード書いてるのを見ると、
よっぽど暇な学科なんだろうなって思う

世界をコードで動かそうとしてるんだろ

なんかかっこよさそうだから、そのうちHaskelやってみようつと。
「僕、今ハスケルで君の美を表現してるんだ」
これで芸大女ともやれるな
よぉぅしっ

嫌味ね

もちろん青春は遅延評価です

大学で微積や応用数学の演習問題をガリガリ解いたのが、すっごく無駄な時間に思えてきた

ムダでしょ(~_~;)
いまどきスマホのCASでもできちゃうから

A4のノートを2ダース以上消費したのに、今では全く使わない

数学の楽しい演習問題は無駄な時間だと言うのに、スーパーマリオのノーミスプレイのためのトレーニングを無駄な時間だと言わない

どっちも同じなのに

数学の演習問題をノーミスプレイして、ニコ動に上げれば良い。
そうすりゃ、予備校が潰れてメシウマ。

>>753
日本の教育がオカシイと思う。

微積も大事だけど、もっと代数・幾何や統計に力を入れないと
実社会の問題を解く時に役に立たないと思う。

日本の企業の7割が赤字なんだから、実社会では足し算と引き算すらも役に立ってない

もう算数教育やめるべき
無駄

微積と統計をガリガリと解きつつ、関数型言語と金融業でFA
制御理論は不要

制御理論、熱力学、電磁気学、信号処理、ロボット工学が不要
確率微分方程式のような金になりそうなものに全力を出すべき

NTTデータ「社内公用語をHaskellにする。奴隷どもJavaやPHPやCで書いた古いシステムは今すぐ書き直せ」
http://blog.livedoor.jp/itsoku/archives/34270447.html

さすがNデーは頭のいい奴が多いな。
底辺じゃHaskellなんてクイックソート書くもの無理だろw

Prologでクイックソート書くより楽

NTTデータの企業ロゴって、フリーメイソンのピラミッドと目玉にソックリ

そもそもNTTデータって、もうなにも生産してないでしょ

生産する人間を生産する。メタ生産。

アウトソーシングメタプログラミング

>>766
Lispっぽくてかっこいいなｗ

今もう、自称ハッカーの黒歴史を抱えた闇プログラマたちは、皆、Haskellぐらい習得してるだろ

ってか、言語とかどうでもいいよ。
プログラミングは中国人の仕事だよ

中国に投げる前に終わるような仕事は、中国にまで投げない
つまり、PHPとHaskellを極めておけば安心

>>753
むだではない
天才ならいざ知らず、非天才には意味がある
ま、機械的に形式操作として解いていたなら

むだ！

だけどな

>>772
Webでつかわねーだろカス

WRYYYYYYYYYYーッ

金融関係の数学まで到達するかしないかが損益分岐点
下手なメーカーへ行くぐらいならWebの方がマシ

i番目の引数を返すprojection関数
例えば
(projection 1) 1 2 3 4 === 1
(projection 2) 1 2 3 4 === 2
(projection 3) 1 2 3 4 === 3
(projection 3) 1 2 3 4 5 6 === 3

となるようなものを作ろうとしましたが、うまくいきません。
コードとエラーは下のURLのとおりです
ttps:　//ideone.com/uQueJq

どうにかしてこれのコンパイルを通す方法はないでしょうか？
のような

可変長引数なのかダメなんじゃ

projectionW (Right n) _ = projectionW (Right n)
左辺の型が違うと思う
projectionW :: Either Int Int -> ProjFunc n

template haskell 使えばできる

>>775
>金融関係の数学まで到達するかしないかが損益分岐点

本当に純粋数学的な能力が生かせる仕事って金融とか保険のアクチュアリー以外に
なんかあるの？

あとJavaとかしか使わないプログラマでも、Haskell勉強するとレベルアップするとか言われる
けどさ、実際どういう能力が上がるのよ？
発想とか頭の回転ならパズルでも解いた方が効率いいんじゃね？

抽象化能力が増すとか？てきとうだけど。

>>780
パズルを解くのにJavaを使いたいと思う変態がいるのか?

>>781
[1,2] ++ [3,4]
これと同じことをJavaで書くのは超面倒

アルゴリズムの洗練化や検証をHaskellでやって、それからJavaなどに置き換えることはあるね。

clojureでやれよ。

>>776
ttps://ideone.com/Ki2fYH

元のコードだと、たとえばInt -> IntとFunc nが等しいという情報から
n=S Zを推論できない(全く無関係なnでもInt -> Int ~ Func nになるかもしれない)

変な人が増えてるな

>>784
IBMがマシンの設計にAPLを使ったようなもんか。

>>785
それ、Haskell並の型推論できんの？

>>755
修士程度まで数学を真面目にやってないと「使える」ようにはならない．

ピアノやバイオリンみたいなもんだよ．この手の古典楽器は十年以上
やらないと人前で見せられるレベルにならない．

>>789
Haskell並みの型推論は必要なのか？

無くても特に問題ないだろ？

絵の方面のソフト作ると高校数学使いまくりだけどな。

どうせショボい行列演算だろ

行列はリアルタイムレンダリングだとよく使うけど
オフラインレンダリングだとほぼ使わない

>>780
純粋数学の力と、複数の言語を使う力は正反対だから、人により全く逆方向に成長する

>>793
んなことはない。高校数学フル動員だぜ。
一例としてパラメトリックベジェ曲線の分割や交点を求めるときに
３次関数の解の公式が使えないのでニュートン法を使うわけだが
初期値によっては振動してしまうので、初期値を決めるために微分で極値を求めるとか。

パラメトリックベジェ曲線が捻れて「よ」の字の交点みたいなのがあるときに
それを求めるのは偏差値５５くらいの高校数学の問題だと思う。

x=a*t^3+b*t^2+c*t+d
y=A*t^3+B*t^2+C*t+D
で表されるパラメトリックベジェ曲線がねじれてできる交点を求めよ
（難易度：難　範囲：高校数学）
多分おまえらの知能じゃ解けない。

それが解けても仕方ない
それが解けるプログラムを書いてくれ

解はシンプルでエレガントなのでこれをプログラムで解くのは効率が悪い。

最近の高校生すげーな
素直に感心するわ

悔しいが俺には解けん

出来る出来ないを必要不必要にすりかえるカス

>>801
気になって他のことに手が付けられなくなってしまったではないか
>>798 を解きたいからヒントをくれ

交点は、あるとしたら一箇所しかできんなよな
そのシンプルでエレガントな式には、
a b c d A B C D の判別式が含まれてたりするのか

出題者自身が正解知らないからw

>>803
交点が１つというのはセンスがいいな。
これに加えてヒントを二言うと解けちゃう。
ヒント
　変数の置換を３回やれば解ける。まずtをuとおき辺々差をとる

>>805
ちょっと待って

変数の置換を３回とか、tをuとおき辺々差をとるとかは、
究極にシンプルにエレガントにした最終結果だよな

そうじゃなくて、なんで３回の置換をする必要があるのか
なぜ辺々差をとるのかをちゃんと理解しないと、解けたとは言わん

>>805 がそのシンプルな式に至った思考の経緯から（たぶん紆余曲折を経たのだろう）、
何かヒントを出してほしいのだが

何か書籍かテキストかを見て学んだのなら、それを紹介してくれてもいい
（というか、そっちの方が有難いが）

受験数学で腕を研いてれば方法論は人それぞれの中に形成されるもんだよ。
解く方法ではなく解く方法の方法というメタ論理を教えることは無理。

偉そうなこと言ってるけど要は解法を知ってるだけと
居るよね、クイズの答え知ってるだけでドヤ顔するやつ

>>807
すまん、大学には行ったことがない
つまり受験数学で腕を研いた経験がないのだが

これを自力で解くには受験数学をこなすところからやる必要があるのか・・・

数学センスのあるやつなら対称形をみつけたら方法を直観できるはず(ｷﾘｯ
つまり辺々差をとるとはそういう方法のうちの一つ。
直観できないやつはもはやセンスがない。

なお「自分のセンスがない」のと「数学は不要」とがイコールになってしまったやつはカス

交点が1個というHint利用すると綺麗にとけたっぽいけど
最後に交点が1つだけであることを保証する照明要求されると自分だと詰む。

>>810
なんかものすごいヒントを与えられたような気がするが、
その意味が分からないのが悔しすぎる

これを当たり前に解く受験生の力ってすげーな

今は解けそうもないから、ここで訊くのはもう諦めるよ
そろそろいい加減スレチだしな

その代わり、その「対称形」と「辺々差をとる」の繋がりが学べる数学の分野を教えてくれ
入門書からじっくり読んでものにしたい

へりくだり方がわざと過ぎるな

>>813
じゃあもっとフランクに聞こうか


答えはもういいよ
それだけ知ったところで何の意味もないしね

それより、「対称形」と「辺々差をとる」の繋がりが学べる数学の分野を教えてくれ
誰でもいいよ

センスは研くもんであって教えてもらうもんじゃないという人生哲学論まで教えなきゃいけんのか？

要は解法を知ってるだけと

>>814
仕事で使わない数学学んでも時間の無駄
どうしてもやるなら競技プログラミングでもやっとけ

アホは解法が載ってるサイトとか教科書を永遠に探してろよ。

>>817
それ言うなら、仕事で使わんHaskell学んでも時間の無駄になんだが？

俺は完全に趣味だよ、知りたいというだけ
仕事はプログラムとは何の関係もないし

>>818
おまえがインテリぶってるだけのアホに思える
つっこまれると屁理屈ばかり

普通に大学受験で使う問題集解いていけばいいんじゃない
でも完全に趣味だと味気無くてモチベ維持がきついかもしれん

目的がなければ餅餅が続かないが、受験も目的とは言えない
ある問題が解けることと受験合格には、解けた問題が得点に変換されるという意味しかない
数学には壮大が目的があるが、それと目の前の問題を結び付けるにはあまりに迂遠過ぎる

センスとか経験はコスパを測定できないのでコストカッターの反感を買いやすい

>>822
数学の前に国語勉強した方がいいよ

受験数学にセンスもなにも、、、

受験数学なんて暗記

受験数学なんていってるやつ数学できないんだろ
東大二次試験以外の受験数学なんて「解法のパターン」対応でしかない。
ああいのは数学とは言わない。
数学ができるというのは数学的な空間を作り出せることであって、受験数学問題を解く、つまり、所詮演繹的帰結を得るのが数学じゃないんだよ

たのしいさんすう（こうさん）

やはり関数プログラムは無駄だな。みんなもそう言ってるな。おれはC♯とVBひとすじの王道！みんなも王道になろう！

受験数学の質問はここでいいの？

スレチ

>>829
ふたすじじゃねーか

「C♯とVB」っていう名前の自作言語だろ

C♯とVBという2つの丘の間にひとすじ（王道）が通ってるとか

えっちー

え？

VBとDelphiを暗記していた人はC#がトラウマになって二度と暗記ができない体質になる
またはオープンソースしか信じなくなる

意味が分からん

>>830
おう、いつでもこい

スレチ

Delphi
懐かしいぜ

円馬鹿出ろ

Fusion について質問。

計算の中で、次のように同じ代数データ型の [分解] と [構築] の組が続けて起こる場合に、

[引数投入] ---> [分解 1] ---> [構築 1] ---> [分解 2] ---> [構築 2] ---> [結果取得]

これを次のように中間の無駄な [構築] ---> [分解] を排除する

[引数投入] ---> [分解 1] ---> [構築 2] ---> [結果取得]

これが Fusion だという認識で合ってる？ (その方法は手計算とかコンパイラ最適化とか色々あるが)
それとも、Fusion は Fusion でも、Stream Fusion の事？

>>843
Stream fusionはそういう形だけど、一般にはもうちょっと広いと思う

[構築1] --(中間データ)--> [分解1]

を、

[構築1+分解1]

のように、中間データを生成しないコードに変形する

flipは引数の1番目と2番目を入れ換えた関数を得るけど
1番目と3番目を入れ換えた関数を得たい場合はどうすんの？

>>845
flip $ (flip .) . flip $ (flip.) . flip $ (flip .) . flip

え？そんなややこしいことしないとダメなの？(＠_＠;)

そこで、>>846を Fusion すると.....　/* 続きは、誰かタノム */

自作すれば済む話だと思うが

真面目な奴ほど、一年に一つ新しいプログラミング言語を覚えよう、とかいうのを
真に受けちゃって、やっぱり今は関数型言語だよね、Haskellって奴がなんかすごいらしい、
とオーム社の買って、カリー化あたりで良い加減面倒になって、新しい発想が身に付いた、
とか勘違いしてるけど、結局やってる仕事や書いてるコードに何も変化はありませんでした、
となってしまうのかな？

自己紹介、乙

>>850
再帰的思考や高階関数の概念は比較的わかりやすい上に効果は大きい

Haskellの背景にある数学の概念は強力だよな
モナド則みたいな性質とそういった性質を満たしていることの証明って、スキルとして応用範囲広いと思う
デザインパターンとか原則を見つけたり策定する力が養えそう

まだまだ分からないところ多いけど、プログラミングをメタな視点で考察しやすくなるんじゃないかって思うよ

使えるところまで行かなくたっていいじゃない
にんげんだもの（誤用）

Haskellに触って何も得ることがないってのは
よほどすごいプログラマか
よほど理解力がないプログラマか
どっちなのか

Haskellを知ってるらしいのに、Haskellには型が無い、という超絶トンチンカンなことを
書き込んだ奴がいたからな。すごく理解力がないプログラマは実在すると思う。

千恵子はHaskellに型が無いという

>>856
書き方を知っているだけで、型推論を知らなかったんだろうなぁ
理解力というか、バックグラウンドの知識が乏しいんだろうね

知識が無い人がトンチンカンなことを言うのは、いつの時代もどこでも同じだな
頭を下げて教えてください、と言えないやつは裸の王様になっていくのさ

ろくでなし ろくでなし なんてひどい いい型

>>850
コードが変化するとしたら、classが減ってlambdaが増えるとか
キャストを使わなくなってテンプレートメタプログラミングを使うとか

haskellの型を一切意識せずに正しい動作をするコードを書いていたとすれば逆にすごいんじゃないだろうか

matlabを叩く制御理論の研究室にいくべきだった。
統計は流石にウマでもシカでも出来るようになってしまった

>>817
俺は趣味で金融工学を学んで夜の麻布で帝王になると定められている。
シュプリンガーの本を読み続けるには、そのぐらいの信仰心が必要。

実務で使うから、仕事で使いそうだから、つぶしが効きそうだから。
こういう理由で物事を学ぶと、結局のところ何も成し遂げることはできない。
ピンクドンペリを注いだり、シャンペンタワーを立てたりなど夢のまた夢

Haskellスレってこんなんだったっけ。何というか、いかにも"2chの"プログラミングスレっぽい。大学の春休みか？

おれの見てるスレここ数日全部こんな感じでウンザリしてるんだけど
大学生の春休みって今頃だっけか

>>844
こういうこと？

f :: データA -> データB
g :: データB -> データC

という関数に対する g (f データA) という計算で、
途中の「f によってデータBを作る部分」と「g によってデータBを消費する部分」を取り除き、
データAを消費して直接データCを作る。

これが Fusion で、これをストリームに対して行うのが Stream Fusion？

> おれの見てるスレここ数日全部こんな感じでウンザリしてる

同意ｗ　なーんか最近妙だよ。しばし静観だな。

>>863
＞金融工学
ここ笑うところですか？

>>866
ちょうど卒論の提出が終わったあたり

>>865
少なくとも二年ほど前からはずっとこんなスレだぞ

俺のﾁﾝﾁﾝがでかいから仕方ないんだよ

俺のニシキヘビを見てくれ

ニシキヘビの質問はここでいいの？

>>867
そんな感じ
細かいことを言うと、Stream Fusionが取り除いてる中間データは
Streamじゃなくてvectorやリストだと思う

Text.Regex.Posixって，もしかして日本語が入ってるとちゃんと処理できない？
たとえば
"= abcアイウ" =~ "^=.*" :: (Int, Int)
ってやったら(0, 5)になる
"= abcあいう"だとちゃんと(0, 8)になるのに

全部UTF-8だから大丈夫かと思ったんだけどなあ

とりあえずutf8-string使って試してみた

Sublime Text に課金するか、emacsに戻るか…
Sublimeいいけど、flymakeがないのが辛いんだよなぁ。

みんなはエディタなに使ってるのん？
vi
FP Complete Haskell
Yi
(聞くところによると、ghci内で全部完結してる人もいるらしい…)

Emacs以外ではLeksahがわりといい感じ
でもやっぱりEmacs

>>879
お前は vi/vim 野郎に殺されるかもしれないことを覚悟しておくがいい

vimにもghc-modとかあるけどEmacsだと何がそんなに良いの?

ttp://leksah.org/
格好いい画面だのう

おれもEmacsだな

べつにviやyi、Leksahなど他のエディタに比べてどうだとかいう問題じゃない

単に昔からEmacsに慣れ親しんでいるから

2013.4.0.0 しんでしまったん？

俺はvimだな上の人と同じで慣れてるからって理由だけと
javaみたいな言語ならideやないとあれやけど
haskellなら別にエディタでええかな

普通型の強い言語の方がIDE便利だよな
その流れで行くとHaskellは超IDE向きなはずなんだが
leksahとか昔触った感じだと完成度がイマイチ

超強力なデバッガが欲しいな

スペースリークの発見を支援してくれたり
弱頭部正規化の様子をビジュアライズしてくれたり

curryでも使えるんかな＞leksah

emacs、vimより優れた環境に出会ったことがない

何かの開発環境を作る機会が出来た日には、
emacs,vimでは実現が不可能な機能だけ作ろうと思う

メモ帳+コマンドプロンプト 最強伝説

たまにはメモ帳使ってみるか > ちょw 改行されないオワタ

>>881
Emacsのhaskell-modeはインデントが超超超強力
カーソルのある行を評価したり、ghciとの連携も快適


ところで、vimのインデントをマシにしてくれるプラグインない？？

Eclipse FPが抜けとるぞ！

あと次世代IDEを作るぞ！って
lamdu
っていうのがある

>>893
あのインデント、時々ウザい

どうやってコンフィグするんだっけ？

Emacsで実現てきない機能ってなんだよ
3D表示にでもするのか？

>>890
MSみたいな奴だな

案の定石の投げ合いが始まった

定石の投げ合い?

「本当に欲しかったもの」の風刺画に出てくるイカした空中ブランコがIDE

IDEなんて不要って結論出てるだろ

IDEあると便利だよなと何気なく思ってたが、今まで書いたプログラムを顧みてみたところ、
IDEが必要な規模のアプリをHaskellで作ったことがないことに気づいた

というわけで、IDEが喉から手が出るほど欲しくなるようなアプリを作ってみたいが、
何がいいだろう？

>>902
スーパーIDE

>>903
今まで簡単なテキストエディタ作ったことあるが、
コードに色を付けてくれるエディタライブラリをペタと貼るだけで、
ほとんど希みの機能が実現されてしまったからなぁ

IDEってあれの延長だろう？
果たしてIDEが欲しくなるようなアプリだろうかと・・・

本人が気づかない場所で気付かないことをしくさるのがIDE
本人がやらないとバックアップとるくらいしかしてくれないのがemacs

私？
私はもちろん、メモ帳+コマンドプロンプトです
部下に勧めるのももちろんメモ帳+コマンドプロンプト
なぜなら彼らもまた特別な存在だからです

Haskellってなんかかっこいいね
そのうちやれたらいいな
今はLispで忙しい

lispって型チェックしてくれるんだっけ?

します。しすぎます。

動的言語じゃないの?

>>904
今もう、エディタ用のコンポーネントって出来上がってるんだっけ？
それをツギハギしたところで、プログラマとして優れているとは思わないけど

>>910
> 今もう、エディタ用のコンポーネントって出来上がってるんだっけ？

たとえば GtkScintilla とか

> それをツギハギしたところで、プログラマとして優れているとは思わないけど

無様でも目的のアプリが完成することが一番大事
最後までやりきって完成させることができない人は、
Haskellに精通していようが、知識経験豊富だろうが、カスでしかない

と自分に言い聞かせて、今日も家計簿アプリをちまちまと作ってます

プログラマとして優れてるかは知らんが、既存の部品を組み合わせて素早く目的のものが作れるのはエンジニアとして優秀だよな

>>904
なら難しいテキストエディタ作ればいいだけのこと
行を表示するところから始めるんだ

>>911
viやnanoみたいに、行レベルのバッファから作る必要あるんだっけ?
そういった部分を作らないでコンポーネントとして利用するのが、どのあたりが難しいの？

>>912
APIからコンポーネント作るヤツの方が優秀

>>911
動的言語や、cやc++では、アプリケーションが完成する気がしない

世の中って分野によって必要な技術が全く違うのに、
既に出来合いの劣化版家計簿つくるのに時間を使って何が楽しいんだろう

完成できない理由は2つ

・自分のレベルと比較して目標が高すぎる
・小さなアプリを作る前からくだらないと思ってる

どちらも自惚れからくるが、この2つが同時に満たされると「どんな言語でも」アプリは完成しない
逆にこの2つを同時に乗り越えられれば「どんな言語でも」アプリは完成させられる

>>917
小さなことからコツコツとアプリ作りの技術を磨いていくのです

劣化版家計簿でも、完成するとかなり嬉しいものですよ
（既に出来合いのものでは嬉しくないです、あくまで自分で設計して自分で作る）

完成したら、少し改良してみようと、次のステップへの意欲が湧く

アホでしょ。だいたい、全てのアプリケーションは高度なわけで、
簡単に作れるものって、メモ帳かGUIのボタンを並べただけのものぐらい

どの言語のスレでも××で何作ってんのと訊く奴がいて
最終的にお前らはプログラマとして駄目だという話へ持っていきたがっている

日常的には、パーサーかアルゴリズムぐらいしか記述するものがない。
そもそも、設計が必要な時点でプログラミングから離れるだろ。

>>920
アホだから、「小さなものからコツコツ」です

たしかに、小さなものばかりを作り続けても意味無いですけどね
ひと通り感慨にふけった後、ソースや実行ファイルを含め完成したものを省みると、
不満に思うとところが必ず出てくるので、それを次に活かすのです

そのうち、自分の中で簡単だと思うレベルが上がることを期待して

多分、API使い回せないなら、家計簿作りなんてやるだけ無意味

GUIエディタのコンポーネントを作るのと、
コンポーネント使って家計簿を作るのでは、
山を歩いて登るかケーブルカーで登るかぐらい別次元の問題。

スレ違い

初心者がもの作ってるのに対して上から目線で
すでにあるもの作ってなにになるんだよ？
みたいなこと言う人でまともなもの作ってる人を見たことがない

ttp://livedoor.blogimg.jp/netamichelin/imgs/b/3/b3eb6252.jpg
これ思い出した

>>927
その初心者が、明らかに口だけにしか見えないんだけど

>>928
そういう世界じゃないから。

(´-`).oO(うるさいなぁ)

こういう時idあればngにできて便利

Haskellでまともなアプリ作ってるやつなんて居るわけないだろ

たしかに
>>929←はNGにしたい

最初期のminecraftと同等のもの作ってる人はいるぞ

>>932
本家のサイトを見たら、Haskellでアプリを作っている人なんて沢山いることが分かる
それも帳票みたいなウドでもヘチマでも作れるようなものじゃない

個人的には Darcs を作った人に憧れます

全くヒットしなかったけど（正確には初めヒットしてすぐ衰退した）、考え方が論理的で、
あぁHaskell（関数型）のアプリってこういうものを言うんだと思いました

Haskellで生産するのはアプリじゃなくて論文です

darcsってgitとくらべて何がすごいの？

べつに

車輪の再発明っていう論法は、逃げだよなあ
やんなきゃできるようになるわけないもの

自分が使うか興味のあるもの以外、作る必要がない