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

Haskellの公式HP
http://www.haskell.org/
日本語サイト
http://www.sampou.org/cgi-bin/haskell.cgi
Http://www.teu.ac.jp/kougi/koshida/Prog6/index.html

過去ログ、関連スレは>>2-5

過去ログ
関数型プログラミング言語Haskell
Part1 http://pc.2ch.net/tech/kako/996/996131288.html
Part2 http://pc2.2ch.net/test/read.cgi/tech/1013846140/

関数型言語
Part1 http://pc.2ch.net/tech/kako/987/987954395.html
Part2 http://pc3.2ch.net/tech/kako/1007/10073/1007387924.html
Part3 http://pc2.2ch.net/test/read.cgi/tech/1037527388/l50

純粋関数型言語Concurent Clean
http://pc2.2ch.net/test/read.cgi/tech/1075629340/l50

ＭＬ！！！！！！
http://pc.2ch.net/tech/kako/1002/10021/1002111468.html
関数型プログラミング言語ML
Part1 http://pc2.2ch.net/tech/kako/1012/10124/1012445015.html
Part2 http://pc2.2ch.net/test/read.cgi/tech/1058630709/l50

CommonLisp Scheme MacLisp ....
Part1: http://piza2.2ch.net/tech/kako/987/987169286.html
Part2: http://pc.2ch.net/tech/kako/1002/10025/1002584344.html
Part3: http://pc.2ch.net/tech/kako/1008/10082/1008220265.html
Part4: http://pc.2ch.net/tech/kako/1016/10162/1016211619.html
Part5: http://pc3.2ch.net/tech/kako/1023/10230/1023091882.html
Part6: http://pc3.2ch.net/tech/kako/1031/10315/1031560687.html
Part7: http://ruku.qp.tc/dat2ch/0311/20/1042167213.html
Part8: http://pc2.2ch.net/tech/kako/1058/10582/1058263391.html
Part9: http://pc2.2ch.net/test/read.cgi/tech/1069594582/
Part10: http://pc2.2ch.net/test/read.cgi/tech/1075630259/l50

CommonLisp初心者スレ
http://pc2.2ch.net/test/read.cgi/tech/1075464728/l50

Emacs Lisp
Part1 http://pc2.2ch.net/test/read.cgi/tech/1004551074/
Part2 http://pc2.2ch.net/test/read.cgi/tech/1068467385/l50

4

5までいってないけど書き込んでもいいのかな？
>>1乙。
# MLスレの571他です。

>>5
関数スレ見たらもう張るものもないので

>>1
otu!

Control.Exception にある catch や try や handle って IO a の型がからんでくるから、IO 関係ないとこだと使えないよね。
IO 関係ない関数での引数が気に入らないとかのエラー処理は、Maybe でやるのが Hakell 流なんでしょうか?
それとも容赦なく error が使っちまうべきなんだろうか?

>>8
>  IO 関係ない関数での引数が気に入らないとかのエラー処理は、Maybe でやるのが Hakell 流なんでしょうか?
Yes.  Maybeがモナドであることの有難味がわかるよ。

>>9
Maybe だといちいち Just か Nothing か判定して、
fromJust とかしいといけないから、めんどうだと思ったんだけど。
いまいち自分が Maybe を理解してない気もするな。

> Yes. Maybeがモナドであることの有難味がわかるよ。
その有難味を具体的に教えてください。

>>10
例えば
-- f, g x, h xのいづれかがNothingを返したとき、value_in_error_caseを返す。
(f >>= g >>= h) `maybeCatch` value_in_error_case

ここで
maybeCatch = flip . fromMaybe
# ヒントをもらったら答えを聞く前に自分で考えてみるようにしたほうがいいと思う。

しかし、本当に
>  引数が気に入らない
が問題だというなら、より正しい対処は(適切な抽象型をもちいるなどして)
そんなことがおこらないようにすること。
何か計算の結果が不確定である場合はしかたがないが。

アボートしていいプログラムやassertionならそもそもIOでのcatchもtryもいらない。
errorでいいし、時にはパターンマッチの失敗だけでいい。
f x | validity_check x = ...

>>10
> その有難味を具体的に教えてください。
いちいち Just か Nothing か判定したり、
fromJust とかしなくていいところ。

そっか、すぐ Maybe 外すことばかり考えていたけど、
(Just x) >>= k = k x
Nothing >>= _ = Nothing
とかで、気にせず Maybe 付いたままでいけばいいんだね。
どうもありがとう。

>>11
小さなことだけど。
× flip . fromMaybe ○ flip fromMaybe
ですよね。

OO 言語だと、最初は大体 bank accounts の説明から始まりますよね。
Haskell で bank accounts を実装するとどうなるのでしょうか。

>>15
bank accountsと一口にいわれてもよくわからないが…
こういうこと(カプセル化)でないなら、
期待しているものが載ってるURLをくれ。

ポリモルフィズムはtype class。
継承は難しい。
# OOA, OODが全てではない。

-- テストしてない
module BankAccount (
    -- Do not export any constructor.
    name, money, newAccount
    --, query, ...etc
    ) where

data Account = Account String Integer
name (Account s m) = s
money (Account s m) = m
newAccount (s, m) = Account s m

-- data Database = Database [Account]
-- query (Database as) nm = filter ((== nm).name) as

>>15
> OO 言語だと、最初は大体 bank accounts の説明から始まりますよね。
考えが古典的過ぎるのでは?

C の構造体がどうのこうのとか。

>>16
こういうのをお願いします。アカウントを複数作れて、それぞれに withdraw, deposit
可能な感じです。

http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-20.html#%_sec_3.1.1

>>17
状態遷移を扱う例が他に思いつかなかったもので。OO かどうかにはこだわっていません。

>>18
depositだけ実装。

どうしても
> (withdraw 25)
> 75
> (withdraw 25)
> 50
こんなことがしたい、という意味？

それとも、こういう機能があればいいのか？
例:
$ ./a.out
Print
>> Status: [(0,100),(1,1000),(2,300)]
Deposit 1 300
Deposit 2 400
Print
>> Status: [(0,100),(1,1300),(2,700)]
^D

前者なら、
make_withdraw :: IORef Account -> Money -> IO Money
make_withdraw ref money = 
    do {x <- readIORef ref; writeIORef ref (x - money); readIORef ref}

というのを作っておいて、
ref_account <- newIORef newAccount
let withdraw = make_withdraw ref_account -- :: Money -> IO Money
とする。

後者なら、普通は前者のような設計はしない。

>>19
一行目は編集ミスなので無視してくれ。

>>19
× make_withdraw :: IORef Account -> Money -> IO Money
○ make_withdraw :: IORef Money -> Money -> IO Money

>>19
どうもありがとうございます。
毎回出力する必要は無いので、後者だと思います。

>>22
>  毎回出力する必要は無いので、後者だと思います。

なんかずれてるような。
> (withdraw 25)
> 75
> (withdraw 25)
> 50
このwithdrawは(同じ引数に対して別の値をかえすので)
関数じゃないというのはわかってる？

だから、
withdraw :: Int -> Int
ではなくて
withdraw :: Int -> IO Int
になる。別にIO Intにしたからって毎回出力するわけじゃないよ。

>>22
depositだけ実装。
============================
module Main where
import Data.FiniteMap
import Data.Maybe
type Database = FiniteMap Int Int
-- errors are silently ignored.
deposit :: Database -> (Int, Int) -> Database
deposit db (nm, mon)
    = fromMaybe db (lookupFM db nm >>= return . addToFM db nm . (+ mon))
testDB :: Database
testDB = listToFM [(0, 100), (1,1000), (2, 300)]

data Cmd = Deposit Int Int | Withdraw Int Int | Print | Error
  deriving Read

============================
続く

============================
main = loop testDB
  where
    loop db = do  s <- getLine
                  cmd <- catch (readIO s) (\e -> return Error)
                  case cmd of 
                    Deposit i m ->  do  loop $ deposit  db (i, m)
                    Print ->  do  putStrLn $ ">> Status: " ++ show (fmToList db)
                                  loop db
                    _ ->  do  putStrLn ">> Sorry, not implemented"
                              loop db
============================
終わり

>>23
どうもありがとうございます。

>このwithdrawは(同じ引数に対して別の値をかえすので)
>関数じゃないというのはわかってる？

なるほど。感覚的に難しいですね。頂いたコードはじっくり読ませて頂きます。
初心者なもので、時間がかかりそうですが。

HaskellにLispの疑似関数型プログラミング感覚を持ち込むとはまる罠

Haskell の短めのサンプルコードがたくさん解説されたり、アーカイブでまとめられている
サイトはありますか?

The Haskell School of Expression

>>28
http://rwiki.jin.gr.jp/cgi-bin/rw-cgi.rb?cmd=view;name=Haskell

UNIXコマンドのHaskellでの実装が多数あります。
というか、僕が書いたものが多いですが。
wikiなので勝手に書きこんじゃいました。
解説はしてませんが、短いコードが多いです。
参考になればうれしいです。
それと、メール欄にsageと書いておくことをようやく学びました。

>>28
Preludeの関数を書く、ついてくるPreludeを読むのがお薦め。

>>30のリンクをみて。

uniq 改良版(getArgs...はかわらないのでstdin用)
--
import Data.List
main = interact $ unlines . map head . group . lines
--

basename, wcあたりも面白そうだ。

>>32
やられた。
そうか、groupが使えたか。
ちょっと悔しいな。
改良版も加えておきます。

皆さんありがとうございます。
いろいろなコードをちまちまハックしたいと思います。

Haskell はまだリファレンスだけでは全くかけないので。

a = [0, 1, 2, 3, 4] てなリストがあったとき、
f 3 a => [[0, 1, 2], [1, 2, 3], [2, 3, 4]]
といった値を返す関数 f が欲しいのですが、
Haskell に標準であるでしょうか？

List.hsとPrelude.hsを探したけど、無かった。
無いとは言いきれないけどね。
いちおうお求めの関数は
f :: Int -> [a] -> [[a]]
f num lst
| length lst >= num = take num lst : f num (tail lst)
| otherwise = []
でいいとは思います。

あ、インデントが。
f num lst以下の2文はインデントを深くしないと、だめです。
いちおう念のため。

myTakeを定義しておいて、(長さが足りないとNothing)

g :: Int -> [a] -> [[a]]
g num lst = mapMaybe (myTake num) (tails lst)

これだとlst >> numでもOK

myTake :: Int -> [a] -> Maybe [a]
myTake n _ | n < 0 = Nothing
myTake n _ | n == 0 = Just []
myTake n (x:xs) = case myTake (n-1) xs of
Just xxs -> Just (x:xxs)
Nothing -> Nothing
myTake _ [] = Nothing

takeMaybe :: Int -> [a] -> Maybe [a]
takeMaybe n []
| n == 0 = Just []
| otherwise = Nothing
takeMaybe n (x:xs)
| n < 0 = Nothing
| n == 0 = Just []
| otherwise = takeMaybe (n-1) xs >>= \r
-> Just (x:r)

>>30 wc.hs 書いてる人につっこみ。
data は複数形、単数は datum.

-- 知っててやってるんだったら無視して下さい。
-- (data って変数名使えないから、とか。)

あと下から4行目の data は datas の typo でしょう。

こんなのでもいいかも。

import List
h num lst = [ take num x | x <- tails lst, length x >= num ]

i num = map (take num) . filter ((>=num) . length) . tails

だんだんエレガントにしようとするところが関数型言語スレらしいな。
#############################
import Data.Maybe
-- 再帰で書いてみた
f n xs = catMaybes $ f' n xs
    where   
        f' n [] = []
        f' n xxs@(x:xs) = (takeJust n xxs):f' n xs

-- AKA myTake and takeMaybe
takeJust 0 xs = Just []
takeJust n [] = Nothing
takeJust n (x:xs) = takeJust (n - 1) xs >>= \xs -> Just (x:xs)

>>42
>>36(無限リストにつかえない、何度もlengthを求める)よりは
いいけど、takeとlengthを両方使うのは無駄がおおいのでいまいちかと。

-- テストしてない。多分遅い。
h num lst = filter ((== n) . length) $ f' num lst 
  where 
    f' num [] = []
    f' num lst = take num lst:f' num (tail lst)

>>44
訂正
  >>36(無限リストにつかえない、何度もlengthを求める)よりは
と同じだね。

>>41
そうか、そういえばそうだったな。
datasなんて単語はないのか。
指摘してくれてありがとう。
ま、いまのところは和製英語ってことで...。
そのうち直します。
日本人だと変数名には苦労するよね。

タイプミスは直しておきました。

>>44
なるほど。
lengthを軽々しく使わないほうがいいのかもな。
じゃあ、こんなので

j num = map (take num) . filter (biggerOrEqual num) . tails

biggerOrEqual :: Int -> [a] -> Bool
biggerOrEqual 0 _ = True
biggerOrEqual n [] = False
biggerOrEqual n (x:xs) = biggerOrEqual (n-1) xs

>>47
無限リスト対応問題のほうはそれでいけるね。

>  biggerOrEqual :: Int -> [a] -> Bool
こういうのが欲しくなることは結構ある。おれは
大体再帰で頭を落としていくようにくむから、[]との比較ですむけど。
書くならこうかな。

biggerOrEqual n xs = [] /= drop n xs

biggerOrEqual  -> longerThan

longerThan だと Equal が含まれないよ。

>>50
だからそうかえたんだよ。

>>48
なるほど、dropはnが大きすぎると[]を返すんだね。
きれいなやりかただ。

で、35の関数はわかりやすさと効率を考えると
以下のものがいいということになる？

38とほぼ同じ。少し見やすくしてみた。
効率がいいのはこれなのかな。
それとnum < 0のときはデフォルトのエラーを起こすようにした。

k num = mapMaybe (takeOfMine num) . tails

takeOfMine 0 _ = Just []
takeOfMine n [] = Nothing
takeOfMine n (x:xs) = maybe Nothing (Just . (x:)) $ takeOfMine (n-1) xs

>>52
そんなもんかな。
# 個人的にはtakeOfMineは>>43のtakeJustのほうが
# Haskellらしくて好きだけどね。(48 == 43だったりする:-)

>>53
Maybe Monadってやつね。
僕も好きだな。
でもこっちのほうが好き。

takeJust n (x:xs) = do xs <- takeJust (n-1) xs
return (x:xs)

なんか手続き型言語に擬態してるかんじが好き。

なんだろ、インデントが重要な言語だと、困るよね。
どうしたらいいんだろう。
上の例ではreturn (x:xs)はxs <- takeJust ...にきっちり合わせないとエラー。

>>55
> なんだろ、インデントが重要な言語だと、困るよね。
いや、困らん。
…でも困る人は{...;..;.}って書けばいい。

とここまでかいて、他の人はIEとかで
プロポーショナルフォントでみているのだと気づいた。困るかも。

k 0 がポイント：

k 0 xs = [[]] ++ [[]|x <- xs]
k n xs = [x:y|(x,y) <- zip xs (k (n-1) (tail xs))]

>>56
  インデントを掲示板でちゃんと表示できたらいいと思ったからさ。

> takeJust n (x:xs) = do xs <- takeJust (n-1) xs
> return (x:xs)

こう書けばいいのかな。

>> 57
同じトピック内で同名関数が定義されたため、参照透明性が破られてしまいますた。

は冗談として、
m 1 xs = [[x] | x <- xs]
m n xs = [x:xs | (x,xs) <- zip xs $ m (n-1) $ tail xs]
でどうだろう。

>>57,59
かなりきれいな解法だと思う。
いままでで一番いいかも。

>>59
いや，f 0 にはそれなりの根拠があるので生かしておいて

f n [] = []
f n xxs@(x:xs) = top n xxs ++ f n xs
top 0 xs = [[]]
top n [] = []
top n (x:xs) = map (x:) $ top (n-1) xs

xxs@(x:xs)は不要なパターンでした

f n [] = []
f n xs = top n xs ++ f n (tail xs)
top 0 xs = [[]]
top n [] = []
top n (x:xs) = map (x:) $ top (n-1) xs

>>61
take* n ≒ top だね。map, ++ の使いかたあたりが微妙に遅そうにみえる。
>>57が綺麗でよさそう。
#  k 0 xs = []:[[]|x <- xs]
#  k n xs = zipWith (:) xs (k (n-1) (tail xs))

zipWith ... 忘れていたよ。

>>36-64 みなさまありがとうございますm(_ _)m
私じゃぜんぜん思いつかないエレガントな解で、惚れ惚れいたしました。

どういたしまして。もう一つ：

f n xs = zipN $ take n $ tails xs
zipN xss = if any null xss then [] else map head xss : zipN (map tail xss)

ただし f 0 xs で暴走。

処理系が落ちてこないので、試さずに挑む。
f n xs = [[xs !! (x + y) | y <- [..n-1]] | x <- [..(length xs)-n]]

>>67
たぶん、
× [..n-1] [..(length xs)-n]
○ [0..n-1] [0..(length xs)-n]
でしょう。

この場合、僕がはじめに作った関数同様、
無限配列で使えないので解としては、やや劣ると思われます。
それと、いちいち(!!)を使うのは効率上どうなんだろうか。
処理系なしで作ったのならしかたないか。
普段はlispを使っているようですね。
はじめにいれる処理系はhugsがおすすめ。
多少なじんできたら、がんばってghcをいれるといいかも。

>>66
いいね。
これもわりと感動もんかも。
単純な処理だと思っても以外と奥が深いもんだな。

以下は別に新しい考えかたは何もないですが、
上のほうで作っていた関数を見やすくしてみました。

p n xs = if drop (n-1) xs == [] then [] else take n xs : p n (tail xs)

dropとtakeを両方使ってるあたりが泥臭いかも。
無限配列を扱えるもののなかで最も素直な解だと思う。どうかな。

>>68
しまった。
書き込んでから気付いたのだが、これだと
p :: Eq a => Int -> [a] -> [[a]]
になってしまう。
まあ、素直な解ということで許してほしい。

もうひとつ素直な解を。

# q n = filter ((==n).length) . k n
# where k _ [] = []
# k n xs = take n xs : k n (tail xs)

どうだろう。

f n xs = take ((length xs)-n+1) [take n x | x <- tails xs]

f n xs = filter ((==n).length) [take n x | x <- tails xs]

>>70
>>44の#と一緒。

>>71
> f n xs = filter ((==n).length) [take n x | x <- tails xs]

でも素直でわかりやすい。同じだけど：

f n xs = filter ((==n).length) $ map (take n) $ tails xs

「関数のn乗」って関数はなかったんでしたっけ：

f n xs = (iterate chop $ map (take n) $ tails xs) !! n
chop (x:xs) = if null xs then [] else x : chop xs

f n xs = map (take n) $ chopn n $ tails xs
chopn n xs = fst $ foldr _chopn ([], n) xs
where _chopn x (xs, n) = if n > 0 then (xs, n - 1) else (x:xs, 0)

>>73
「関数のn乗」 -> ない。
chop -> init 

> f n xs = map (take n) $ chopn n $ tails xs
> ....
無限リストに使えん。

気持ちは分かるんだが、
    新しい良いアイディアが含まれていなかったり、
    明らかに良くない方法だったりするものを
無闇に書き込むのは止めないか？(せめて欠点を併記するとか)

他の初心者が無分別に使うかもしれないし、
いいアイディアのものが埋もれる。
中級者以上(？)には面白くないし。

>>74
> 「関数のn乗」 -> ない。

なぜないんでしょう，あってもよさそうなのに。

> chop -> init

ありがとう。では直しておきます。

f n xs = (iterate init $ map (take n) $ tails xs) !! n

これは無限リストで大丈夫ですね。

> 新しい良いアイディアが含まれていなかったり、
> 明らかに良くない方法だったりするものを
> 無闇に書き込むのは止めないか？(せめて欠点を併記するとか)

欠点を併記するというのはいいですね。でも，今まで前を拾うこ
とばかりしいたから，今度は後ろを落としてみたらどうかという
発想なので「無闇に」というのとは違いますよ。

> 「関数のn乗」
手許に処理系ないんだけど、foldl とか (.) とかで簡単に作れそうな。

>>75  
> 発想なので「無闇に」というのとは違いますよ。
失礼。
あなただけに書いたわけではなくて、>>70-71などを指していた。

> 「関数のn乗」
(iterate f x) !! n が普通なんだろうけど、
自分でtail recursiveな
nest :: (a -> b) -> a -> Int -> b
nest' :: (a -> b) -> a -> Int -> b  -- strict
あたりを書いたほうが、速くていいね。
標準にあったほうがいいというのに同意。

> 手許に処理系ないんだけど、foldl とか (.) とかで簡単に作れそうな。
foldlは無駄な処理をするのでまずい。
composition f n = foldr (.) id $ replicate n f
あたりか。

最後は>>76宛。

なんどもすまん。
  nest :: (a -> a) -> a -> Int -> a
だね。

>>77
> 標準にあったほうがいいというのに同意。
ですよね。標準でないのは f^n は複数の n に対して評価する
可能性があるのでリストにキャッシュしておけ，という主張か
とも思ったのですが。あっても悪くない気がします。


f n xs = (transpose $ map inits $ tails xs) !! n
（制限：n は xs のサイズ以下，無限リスト可）

なんとなくテクニックの紹介をしてみる。

Haskellのリストは一つの型しか保持できない。
しかし、複数の型であっても、その間に「関係」があれば、
それらの型をラップし、一つのリストにいれた上で使用することができる。
--------------
{-# OPTIONS -fglasgow-exts #-}
-- different types
data A = A String deriving Show
methA (A x) = length x
data B = B Int deriving Show
methB (B x) = x
-- but they have the methods of the same return type Int
data C = forall x. C x (x -> Int)
runC (C x f) = f x
testC = map runC [C (A "I am A") methA, C (B 100) methB]
-- if they belong to the same type class
data ShowC = forall x. (Show x) => ShowC x
instance Show ShowC where
    show (ShowC x) = show x
testShowC = show [ShowC $ A "I am A", ShowC $ B 100]
-- nearly nonsense
data X = forall x. X x

sage

GHC-6.2.1 released

Functional Programming With Haskell
http://www.amazon.com/exec/obidos/tg/detail/-/0077093305/

久々の新刊かも

>>84
豪快に割引されてますな。

前スレでガイシュツだったのか。
http://pc2.2ch.net/test/read.cgi/tech/1013846140/ #554
一年以上も前に。

wxHaskell使ってる人っている？

>>84
ペーパーバックで５０００円か…

>>87
できあがる実行ファイルがでかすぎる

>>89
Minimulコードでどれぐらい？

>>90
@ Mac OS X 10.3

--- Hello.hs
module Main where
import Graphics.UI.WX

main :: IO ()
main = start hello

hello :: IO ()
hello =
　　　do
　　　　f <- frame [text := "Hello world!"]
　　　　quit <- button f [text := "Quit", on command := close f]
　　　　set f [layout := widget quit]
---

$ ghc -package wx -o hello Hello.hs

で、helloのサイズが7M強。

stripして3M弱だな。

そりゃすげえな

よくしんねぇけど、
ツールキット全部そんなかに入ってんじゃないの？
だったら仕方ねぇと思うけど。
外出しには出来ねぇのかな？

GHC を ports の導入されていない FreeBSD に導入したいんだが
どうすればいいのだろう？

make install

a) portsを入れてmake install
b) packageを持ってきてpkg_add

みんなまずインタプリタで開発して、
安定してきてリリースする間際にコンパイラに移行するの？
インタプリタで正常動作してるけど、コンパイラではうまく動かないってこと多い？
Haskellってコンパイル撃遅い(というか長い)ッてきいたけどﾏｼﾞ？

>>96
GHC のコンパイルには GHC バイナリが必要です

>>97
ports や package は教育上入れてもらえない学生さんなんですよ

>>99
FreeBSD の ftp サーバの ports/distfiles に
ghc-<version>-i386-unknown-freebsd-boot.tar.bz2 があるからこれを展開して，
ghc のコンパイル時にこの展開先にある ghc を指定してコンパイルすればok．

ちなみに ports も同じことをしている(処理が自動化されてるだけ)．

>>98
コンパイルはたしかに激遅．
プログラマが楽するためにコンピュータに頑張ってもらってる感があるね．

マニュアル印刷したいんだけど、1枚のHTMLにしてくんないかな。印刷しづらい。
http://www.sampou.org/haskell/report-revised-j/

>>101
そんなのちょこっとスクリプト走らせれば楽勝だろ？

>>98
> みんなまずインタプリタで開発して、
おれはそうしてる。GHCiでときどきHugsでチェック。

> インタプリタで正常動作してるけど、コンパイラではうまく動かないってこと多い？
そんな経験は無い。

>>100
ありがとう

試してみてうまくいったらまた報告します

NHCの方が良質のコードを生成するって聞いたことあるけど、
もう今は昔の話なのかな？

このスレでも聞いてみる。
Scheme,OCaml,Haskell,Clean、覚えて「損しない」「一番得」
な言語はどれ。ぶっちゃけ周辺ライブラリーが充実してるのどれ。

>>106
得するのは、全部覚えること。
得しないのは、ひとつしか覚えないこと。

>>106
若いなら全部やれ

>>105
コンパイルは速いけどね。
Hugs/GHC共通のHierachical moduleの多くが使えないのが痛すぎる。

今試しに
main = interact id
をnhc98(FreeBSD-CURRENT, from ports)でコンパイルしたらbus error....

r抜けてたHierarchical

>>106
統計やるならRが結構ナイスだ。

>>110-111
Ｒスレはこっちに↓あ〜る

＝　統計解析フリーソフト　Ｒ　＝
http://science2.2ch.net/test/read.cgi/math/1062650510/

工科大の
http://www.teu.ac.jp/kougi/koshida/Prog6/Text08/index.html
の問題1 ですが、

> sigma :: (Int -> Int) -> (Int -> Int)
> 上記の関数sigmaを，1) ラムダ記法を使って，2) 関数の部分適用を使って，定義せよ．ただし，sigma fは，自然数nに対して
> f 0 + f 1 + ... + f n
> を計算する関数とする．

lambda 版 は以下のように作成しました。
sigmaLambda :: (Int -> Int) -> (Int -> Int)
sigmaLambda f = \x -> sum [f i | i <- [0 .. x]]

で、部分適用版ですが、

sigma :: (Int -> Int) -> Int -> Int
sigma f 0 = f 0
sigma f n = sigma f (n-1) + f n

で、いいんでしょうか。
題意のような関数を返すのですが、部分適用という感じがしません。
出題者がどのような回答を期待しているか知りたいのですが。
(あと、なんか lambda版を、内包表現とか使ってて、出題意図に沿ってないような気がするのです)

>>113
> 題意のような関数を返すのですが、部分適用という感じがしません。
addNum'' n m = n + m に部分適用を使ったといっているのだからそれでいいだろう。
sigmaPartial f n = sum [f m | m <- [0..n]]

> (あと、なんか lambda版を、内包表現とか使ってて、出題意図に沿ってないような気がするのです)
それなら使わなければいいのでは？
sigmaLambda = \f n -> if n == 0 then f 0 else sigmaLambda f (n - 1) + f n

sigma,sigma' :: (Int -> Int) -> (Int -> Int)
sigma f = \ n -> foldl (\ s i -> s + f i) 0 [0..n]
sigma' f = let iter s x = if x < 0 then s else iter (s+f x) (x-1) in iter 0

import Control.Monad.Fix (fix) -- fix f = f (fix x)
sigma = flip fix 0 $ \s t f n -> if n < 0 then t else s (t + f n) f (n - 1)

fix f = f (fix f)ね。

Haskell に例外処理の機構はあるの？

ある。
Haskell98でもIOモナドからthrowできる例外(IOError)があるし、
最近のGHC、Hugsでは普通の関数からも例外(Exception)をthrowできる。
catchはIOモナドの中でおこなう。

参照: Control.Exception

Haskell勉強中なんですけど、
「モナドは継続渡しを提供する」という大雑把な理解でいいでしょうか？
･･･違うかな？

なんで Prelude で (!!) は Integer じゃなくて Int で定義されているの？

>>121
実際問題それ以上使うことはないからだろう。
Haskell 98 Report によると maxBound::Int は少なくとも 2^29-1。
(!!)のインデックスは0-originだから、長さ2^29のリストまで扱える。
これ以上の長さのリストを使う場面は……。

円周率の世界記録に朝鮮したい人はどうすれば？

>>123
自分で最低義すれ。

>>123
円周率は全桁保持していなくても次を計算できたはず。

>>124
アドレスの制限があるから多くの計算機と既存の処理系では
再定義しても無駄。

>>120 こんなん見つけた

ttp://www.jaist.ac.jp/~kiyoshiy/writing/wadler_essenceoffunctionalprogramming.pdf

ここの資料はjaistのゼミ資料？
他にはHaskellDBが自分的に興味深い．
TorqueとかHibernateなんて目じゃない． Haskellだけど…

>>121
haskell@でもちょうど議論されてるね。
上ででたものの他に、こういう意見があった。

Integer派:
*   Lazyにcreated/destroyedなデータならアドレスの制限を
    受けずに大きいものを利用できるはずだ。
*   Intは一般的なケースへの最適化であり、
    "Premature optimization is the root of all evil."

Integerには反対派:
    Integerにするのは、巨大なリストという特殊な状況への最適化である。
    (Integral b) => がよろしい。

Hanatani さんすげーな。
オレもああいう凄腕Haskellerになりたい。

>>128
なんか凄いもの作ったの？

しばらく見ないうちに「関数型言語」のスレがひどいことになってるな。

>>130
Aranskさま〜〜早くこのスレにも御光臨してくださいませ〜〜
Aranskさま〜〜早くこのスレにも御光臨してくださいませ〜〜
Aranskさま〜〜早くこのスレにも御光臨してくださいませ〜〜
Aranskさま〜〜早くこのスレにも御光臨してくださいませ〜〜
Aranskさま〜〜早くこのスレにも御光臨してくださいませ〜〜

たま〜にはあげてみる

Haskell Support for the Eclipse IDE
http://eclipsefp.sourceforge.net/

0.3.0はEclipse最新var.(M9〜正式版)に対応しているぞ。

おお． しかしスクリーンショットがほしい所かも． 後でインスコしてみるか…

Fudgets
http://www.cs.chalmers.se/Cs/Research/Functional/Fudgets/

触ってる人いる？ これから弄ってみようと思うのだけど．

featureのページに，
Declarative flavour. While it is possible to enable GUI programming in
a functional language by providing an interface to an imperative GUI toolkit and,
in effect, using an imperative sub-language within the functional language,
Fudgets provide a declarative style of programming also for the construction of GUIs.

とある． なんだか期待大．

>>133
使えたら是非おしえてくれ。
Declarative GUI toolkitって数年前から
どれもメンテが止まってるっぽいんだよな。

最近ではwxHaskellがスタンダードになりつつあるけど、
やっぱりHaskellならDeclarativeにやりたい。

Haskell Marathon
http://www.sampou.org/cgi-bin/cahier.cgi

Haskell で Marathon を実装するのかとｵﾓﾀ。

マラソン参加してみようかな。入門ページ読んだくらいで準備はよいだろうか

マラソン直前に台風直撃の悪寒

LL WeekendでのHaskellに対する聴衆の感想は「Haskellのコードはよくわからない」というのが多かったみたいでつね

5分だか7分だかでわかれという方が無理があるという話がある。発表者陣はよ
くやったと思うよ。
「わたしはもうループも書けなくなってしまって……」というのにワロタ。

LL侍はHaskellを斬ったの？

>>141
「Hello, worldもブラックボックス斬り」されてました。

おれはhaskell haskell haskellだ
関数型の haskellだ
短くて 簡潔で 理解しやすいコードを書けるぜ
って、言うじゃない

だけど
難しくて monad が理解できませんから

残念！
「Hello worldさえブラックボックス」
斬り

むしろHello, worldだから難しいような気がする

main = do putStr "Hello, World!"

で済むから、コード自体は特に難しくは見えない。
ただ、入門者が Hello, World に到達するまでの過程が難しいんだよね……。

>>145
そのdoはいるの？

この場合はいらないけど、先々のことを考えたら入れた方がいいかな、とちょっ
とだけ思ったのです。
main = do str <- getLine
putStr str
みたいに。

いきなりIOから入るのがまずい。
fact→fib→qsortあたりから入れば
得体の知れないモナドをとりあえず回避できる。

再帰とリスト処理しかできないHaskellちゃん
がんばってもせいぜい二分木

膣門です。
"Hindley-Milner" って、何て読むんでつか？

誰か「モナドだけで書く Haskell プログラミング」を書いてくれい

>>151 Cでも使ってれば？

そういやHaskellのコンパイルはC経由なんだよね

末尾再帰の保証とかC経由じゃ無理だろ

GHCで最適化オプション付けるとCのコード吐くんじゃなかったっけ?

>>150
メール出して聞いたら?
ttp://www-maths.swan.ac.uk/staff/jrh/ J. Roger Hindley
ttp://www.cl.cam.ac.uk/~rm135/ Robin Milner

>>156
もちつけ

>>154
そりゃ当然、Cにする前にプログラム変換するだろ
それに大抵のCCには-foptimize-sibling-callsみたいなのがあるだろうし

レベル低いな。っつってもHaskellのことは何も知らないのであれなんだが。。。
ユーザーレベルで言語をマスターするっつーのは、ある処理系を骨までしゃぶり
尽くすことだろ。リスパーのように自作こそ最強だが、複雑な言語ではそこまでは
まあ、なかなか出来るもんでもないしな。
GHCのことについて詳しい奴がいないのを見ると、誰もHaskellでまともに
プログラム書こうとしてないように見える。結局おまいらは、話のネタに
関数型言語を選んでるだけなんだよ。

↑Aransk?

Simon Peyton Jones は C-- もやってるのに、自前でオプティマイズ出来ないってのは意外。

>160
Aranskはいちゃもん言うだけでプログラムすら書かんだろ?

wxhaskellについてですが、
サンプルプログラムのBouncingBalls.hsでセグメンテーションフォールトが
起きます。(http://wxhaskell.sourceforge.net/quickstart.html)
プログラムを起動し、'p'などのアルファベットを入力することで生じます。

そこで小さなプログラムを作って試してみたのですが、
やはり同様な現象が起ります。

$ cat test.hs
import Graphics.UI.WX

main :: IO ()
main = start test

test :: IO ()
test = do f <- frame []
p <- panel f []
set f [layout := widget p]
set p [on(charKey 'a') := print "test ok"]
$ ghc -package wx test.hs -o test
$ ./test
(ここでキーボードの'a'を入力)
セグメンテーション違反です

環境
wxhaskellのバージョンは0.7
wxGTKのバージョンは2.4.2
OSはlinux

他の環境でもこのバグが再現するでしょうか。

>>163
特に問題発生せず

環境
wxHaskell 0.8
wxWidget 2.5.2
MacOS X 10.3

$ ghc -package wx test.hs -o test
$ /usr/local/wxhaskell/bin/macos-app -v test

できたtestをFinderからダブルクリックで起動
真っ白いパネルが出てくる
'a' 押すと「コンソール」に "test ok"

とりあえずバージョンアップしてみれば

wxHaskellを0.8にバージョンアップしたら問題は解決しました。
どうもありがとうございます。

このような関数はどう書けばいいんでしょうか？

f (+) [1 2 3] [4 5 6] => [5 7 9]

f g (x:xs) (y:ys) = (g x y) : f g xs ys

f g xs ys = [g x y | (x, y) <- zip xs ys]

これを拡張したn引数(n階?)の関数とn個のリストをとる
関数はどう書くのがいいでしょう。

f n g [x11, x12, ...] [x21, x22, ...] ... [xn1, xn2, ...]
=> [(g x11 x21 ... xn1), (g x12 x22 ... xn2), ...]

みたいな。lispのmapってこんな感じですよね。あちらは
関数のarityがわかるからnは不要ですけど。

f g = map (hoge g) $ zip
Haskellはよく知らんので、hogeをどうやって書くのか調べてもよく分からん。

引数の数が可変ってhaskellでは書けないような気が。
何か方法あったっけ？

>>166

zipWith (+) [1, 2, 3] [4, 5, 6]

>>171
別に可変個の引数は必要ない。
1引数の関数のリストと引数のリストを受け取って適用して返す演算子をつくればOK。
演算子をxとすると
[f, f, f] x [x11, x12, x13] x [x21, x22, x23]
とか。Haskellの細かい文法知らんのでこう書けるかどうかは知らないけど。

どういう型になるんだ？

map sum $ transpose [[1,2,3],[4,5,6],[7,8,9]] => [12,15,18]

こんなもんでどうでしょうか。

>>174
[a->b]->[a]->[b]かな?

zipWith ($)

Prelude> (zipWith ($)) (map (+) [1,2,3]) [4,5,6]
[5,7,9]

ナルホド。

只の関数適用(f x)と(f $ x)って何か違うところあるの？
それとも( )じゃワケがわからないから($)と書けるように
目に見える演算子として用意されているだけ？

$ は関数合成では？

関数合成は . でしょ。
>>179 何も代わらない。関数適用のための演算子だから。
本来の利用法は >>178 みたいなものなのかな(個々の要素にそれぞれ適用する
ためには、関数適用の演算子があると便利)。

f $ g x と書くと、演算子の優先度の関係上 f(g x) と同じことになるので便
利、ついでに結合性の関係で f $ g $ h x とか書ける、というのが個人的に
は嬉しい。カッコの省略にも使える。
関数合成はあくまで関数の合成の演算子なので、 f . g . h x とは書けない。
(f . g . h) x なら書けるけど。

可変個数の zipWith については、

Functional Pearl "Do we need dependent types?"
Daniel Fridlender and Mia Indrika, 2000 J. Functional Programming,
vol. 10, July.

ttp://www.cs.chalmers.se/~indrika/publication.html

に載っているので興味があるひとは読んでみるべし。

>>171-181
> 只の関数適用(f x)と(f $ x)って何か違うところあるの？

ある。$はただの関数だから、引数の型がそこで固定される。
f :: a -> (forall b. b -> b) -> a
f x g = g x

とすると、f 0 id はOKだが、f 0 $ id はだめ。
ST Monadなんかをつかっていると結構引っかかる。

-- zipWithN
infixl 2 <$>
infixl 1 <->
(<$>) = map
(<->) = zipWith ($)
-- 例
-- (\x y z -> x + y + z) <$> [3,4] <-> [5,6] <-> [7,8]

----------------------------
-- 可変引数 
ncat :: NCat b => b
ncat = ncat' id 
class NCat a where
  ncat' :: (String -> String) -> a
instance NCat String where
  ncat' f = f ""
instance NCat b => NCat (Char -> b) where
  ncat' f x = ncat' (f . (x:))

-- 例
-- ncat 'a' 'b' 'c'

# >>183の171は179の間違い。

>>184
型指定が要った。
ncat 'a' 'b' 'c' :: String

携帯から読むと AA 判定されててﾜﾗﾀ >>183-185

AA的プログラミング

(--#) とか (*^-^*) とか？

Categories for the Working Mathematician の訳書ってなんていうタイトルでつか？

スマソ。
「そのうち出る」 = 「そのうち出版される」という意味か。
「テキストの候補に挙がる」ではなく。

誤爆にも程があります

「数学に勤しむ貴方のための圏論」てのがそれらしいが
近刊とあってまだ出てないようだ。

ttp://www.kyoto-su.ac.jp/~hxm/hxm.cc/research.ja.html

末尾再起すると、遅延評価されないですね。
(length (hoge xx yy zz)) < 3
とかで困る。かも。

>>193
> 末尾再起すると、遅延評価されないですね。
そんなことはない。

> (length (hoge xx yy zz)) < 3
> とかで困る。かも。
lengthがstrictだからhogeがlazyでも意味がないとはいえるが、
末尾再帰とは無関係なので、意味がわからない。

なにを誤解してるのですか？

>>193
『末尾再帰の最適化』をすると遅延評価できない（或いはその逆）、のことを言いたいのかな。
それだったら解る。

あ、でも例 (length (hoge xx yy zz)) < 3 の意味はやっぱりわからない。

>>195
> 『末尾再帰の最適化』をすると遅延評価できない（或いはその逆）、のことを言いたいのかな。
詳しく説明きぼんぬ。
gotoでジャンプするコードにするとサンクが作れないのかな？

>>195

take n 末尾再帰関数(無限リスト)

みたいなのが出来ないということでは？

括弧の位置を間違えた。
take n (末尾再帰関数 無限リスト ・・)
です。

すいません。どっかいってました。
>197さんの言うとおりです。
例は適当にかいたらだめでした。

>>197-198
なにができないと？
take' 0 xs = xs
take' n (x:xs) = take' (n - 1) xs 

take n (take' 10 [0..])

>>200
返値も無限リストの場合です。

nub0 :: Eq a => [a] -> [a]
nub0 = nub0' []
nub0' l [] = l
nub0' l (x:xs)
　　| elem x l = nub0' l xs
　　| otherwise = nub0' (x:l) xs

take 10 (nub0 [1..])

>>201
nub0 [1..]自体がbottom(無限リストではない)なんだから
末尾再帰も糞もないですよ。

nub0' :: [Int] -> Int
nub0' = foldr (+) 0
だって同じこと。

いろいろと書き方がまずくてすみません。

nub0 を末尾再帰で定義したから、nub0 [1..] が
bottomになったわけで、Hugsでの定義の

nub l = nub' l [] where
　nub' [] _ = []
　nub' (x:xs) ls
　　| x `elem` ls = nub' xs ls
　　| otherwise = x : nub' xs (x:ls)

のようにすれば nub [1..] は無限リストになる、という意味です。

いいかげん誰かモナドをわかりやすく説明してくんない？
関数型言語のキモは副作用とのコラボレーションなんだし

>>204
http://www.sampou.org/haskell/a-a-monads/html/index.html
ではだめ？

んじゃ自分の理解度の確認を兼ねて。（突っ込みよろしく）

モナドは数学上はモノイドといって単位元を持つ半群のこと。
一応簡単な説明。
（Ｘ * X ) * X = X * ( X * X )　といった「結合側」が成り立つ演算＊があって
（Ｅ * X ) = ( X * E ) = X となる単位元Ｅを持つようなＸのこと。

X　が整数だとすれば * は足し算 E は 0
もちろん * を掛け算 E は １としてもいい。
* を文字列の結合 , Eを空文字列 "" とすれば文字列もモノイドとみなせる。

で、ＨａｓｋｅｌｌのＩＯ型には
上の文字列モナド(モノイド)の1文字づつの代わりにＯＳのシステムコール呼び出しの機械語が
入っていると思えばいい。

ＩＯﾓﾅﾄﾞA( [キー入力] ) >> ＩＯﾓﾅﾄﾞB( [画面出力] ) 　を適用すると　
　 ＩＯﾓﾅﾄﾞＣ( [キー入力]の次に[画面出力] )　になる

みたいな。
で　どんどん >> や >>=で繋いでいくわけ。

もちろん結合則も成り立つ。
ちなみにreturn 関数が返すＩＯ型が単位元になってる。

これはreturnの返すＩＯには何もシステムコール？が含まれてないから
上の文字列モナドの空文字列みたいな感じ

これで宜しいでしょうか>>204

>>206
Monoidだと思って話すなら:

結合法則: (a * b) * c = a * (b * c) を満たす演算*が定義されていて、
単位元 e (e * a = a * e = a をみたす) を持つような集合を
Monoid(以下、単に半群という)といいます。
例えば"行列"や"微分方程式の解作用素"は半群になっています。

*** Point(1): a * b /= b * a。順序は変えられない

この半群の集合への作用(注1)の仕方を定めたものがMonadです。
return == e で、あとは * にあたるものが >>= となります。
そういうと、return :: a -> M a (M "a" なのは単位元だから) なんだから、
>>= :: (s -> M t) -> (t -> M u) -> (s -> M u) 
じゃないのかと思うかも知れませんが、
>>= :: M t -> (t -> M u) -> M u
でもいいのです。
というのは、(c * d)' x = c' (d' x)なので、*を決めることと、
M sの任意の元(d' x 等)をどこにうつすかを決めることは同じことだからです。

続く。

この行は前のメッセージの最後にあるべきでしたが、

*** Point(2): x /= y ならば a' x と a' y は等しくなくてもよい


さて、例えばIOモナドなら、putStr :: String -> IO () 
は上のaやらbやらにあたります。ではgetLine :: IO Stringはというと、
元を一つしか持たない集合をUとしてgetLine :: U -> IO String の省略記法
なのです。元が一つしかないのだから、わざわざU->を考える必要はありません。

Point(1)、(2)がIOの、順序を変えられない、毎回違う答えが帰るかもしれない
という性質を満足させてくれます。

main = getLine >>= putStr は、(putStr * getLine) と同じもので、
実行するのは putStr' (getLine' world) を計算することです。
getLineが毎回異なる文字列をputStrに>>=で与えても、それはworld
が違ったからだと思えばなにも問題はありません。

*1 (作用)
    行列をベクトルにかけるとベクトルができますが、これと同じように、
    半群(M)の元(a, b, ..)をある集合(S)の上の関数とみなすことができます。
    好き勝手に関数とみなすのではなく、次の性質をみたすとき、
    半群MがSに作用している、ということにします。関数とみなすときには'をつけます。
    (a * b)' x = a' (b' x) (x は S の元)
    
# monoidとmonad (triple)はどちらも数学の概念で、似ていますが別物です。

（Ｘ * X ) * X = X * ( X * X )　といった「結合側」が成り立つ
の()の意味はなんだ？
単に型が合うかどうかか？演算の時間的な順番か？

>>209
演算の順序。
代数の本を読めばどしょっぱなに書いてあるよ。

じゃあ（入力 * 出力）* 入力 = 入力 * （出力 * 入力）になって
最初に出力してくれるのかい？

コードの結合順序と、実行順序を混同するな。

Cで {{f(); g();} h();} と {f(); {g(); h();}} が同じ結果になる
みたいなものだ。

だから（Ｘ * X ) * X = X * ( X * X )ってのはどういう意味なの？

>>213
モノイドの説明だとしたら、その式はそうとしか言えないのでは。整数上の加
算について考えると、
(1+2)+3 = 1+(2+3)
が結合則。
1+0 = 0+1 = 1
が単位元の性質ということ。数学の話だよ。

モナドだとすれば、 >>207-208 じゃないのか。
(f * (g * h)) x = ((f * g) * h) x = f(g(h(x)))
という風に理解したんだがこれは当ってる？

Haskell の記法を使えば、
x >>= (\x -> x >>= h >>= g) >>= f = x >>= h >>= (\x -> x >>= g >>= f)
かな？

モナドというのは、「評価の順序を保証するもの」という風に考えているんだ
が、その事を「結合則は成立するが、交換則は成立していない」という事で表
現しているということなのでは。

副作用の話は 208 の方に書いてあると思うんだが、こっちはよくわからない……。

>>214
> 「結合則は成立するが、交換則は成立していない」
「交換則は必ずしも成立するわけではない」のほうが適当では？

この場合の（Ｘ * X ) * X = X * ( X * X )の意味は
どういう風に括弧をつけても関数Xの適用順序は
左から右、右から左と一定であるって意味でいいの？

>>215
ああその通りですね。失礼しました。

>>213=216
まあその通りといえばその通りではないかと思います。
*を関数の合成みたいな演算だと考えればよいのでは。

で、208に質問なんですが、

> *** Point(2): x /= y ならば a' x と a' y は等しくなくてもよい

はわかるとして、 GetLine :: U -> IO String であり、 U が一点集合なのだ
としたら、これは x = y である(にもかかわらず a' x /= a' y になりうる)
例のように読めてしまったのですが、どこで間違えているんでしょうか？

getLine' world というのは、常に world が与えられるが、 world が毎回異
なるので返り値が異なることがあるっていうこと？　でもそれって一点集合な
んでしょうか？

結合法則は分かったが

*** Point(1): a * b /= b * a。順序は変えられない
*** Point(2): x /= y ならば a' x と a' y は等しくなくてもよい
Point(1)、(2)がIOの、順序を変えられない、毎回違う答えが帰るかもしれない
という性質を満足させてくれます。

っていうのは普通の関数とどこが違うの？
普通の関数でもそういうのあるんだから、
モナドとかいわずに普通の関数と一緒に扱えばいいじゃない。

x = yでもa' x と a' yは等しくなくてもいいんじゃない？

結合法則は満たすけど交換法則は満たさないって状況、
小学校でやる一般的な算数にある？

引き算、割り算

結合法則満たすのか？

perl -e '$op="-"; print eval "4 $op (3 $op 2)"'
perl -e '$op="-"; print eval "(4 $op 3) $op 2"'
これ、答えが違っちゃうけど、、なんか間違ってます？

>>219
> っていうのは普通の関数とどこが違うの？
> 普通の関数でもそういうのあるんだから、

どこの世界の関数だそれは（ｗ

べき乗とかなら交換したら意味がちがうし
x /= y ならば a' x と a' y は等しくないんちゃう？

もちつけ。モノイドがモナドなわけじゃないぞ。
> この半群の集合への作用(注1)の仕方を定めたものがMonadです。

>>219
逆で、関数でそういう性質が成り立って、文字列の連結や状態遷移でもそういう性質が成り立つからそれらを抽象化してモナドにしたってこと。
連結リストや配列リストの性質を抽象化してリストとして扱うようなのと同じ。

じゃあ普通の関数もモナド？

>>220
x = y で a' x = a' y でなくても構わないっていうのは数学的にはおかしい
気がしますが。
プログラム的には副作用が起きているなら成立すると思いますが、その副作用
を上手く扱うのがモナドなんじゃないの？

順序は正しく守って、毎回違った答えが出ても
処理系はエラーを出さず理論的にもきちんとまとめられるってことか？

>>218
そうですね。すみません。208は全然ダメです。 
モナドをモノイドで押し切ろうというのは無理がありました。

>>229
普通の関数だと、たとえば
f(g(x), h(y))
がどの順番で評価されるかは不定。でも、モナドを使えば、その順序を確定さ
せることができる。

……副作用とかいう話じゃなくて、順序を確定させることが重要なのかなあ。
順序が確定的だから、副作用が起きるコードでもOKみたいな感じ？

モナドってのは何をさすんだい？
a * bだったらaやbがモナド？それとも*がモナド？

>>233
順序と、引数返り値に直接アクセスできないところが味噌です。
type IO a = world -> (a, world)
なら、main world0 = let (s, world1) = getStr world0 in print s world0
とかやってしまえないようになるところ。

>>234
a, bと*の組みです。
行列群が、行列と行列のかけ算の両方がないと考えられないのと同様に。

a,bはプログラム中の式
*は各式の関係を表す演算子

>>232 自己レスもちろん>>207もだめです。
モナドは雰囲気はモノイドなんですがやっぱりモノイドとは
みなせそうにないので、これも嘘です。
> この半群の集合への作用(注1)の仕方を定めたものがMonadです。
予想と違って、正しいかもしれないものだと素直に読んだ方が
多かったようで、申し訳ないです。

理解した部分だけ書くと、結合法則を満たす関数の合成を使うと
IOのような実行の順序が重要な意味をもつ関数を（順序不定で）合成しても
合成された関数は一意的な順序でIOが実行される関数になるということか？

順序を保つ合成が結合法則を満たすのは分かったが、
結合法則を満たす合成は全て実行の順序を保つでいいのか？

>>238
順序不定には合成できないから、明示的に順序をつけることを強制できる。

putStr (getLine, [getChar])
でなく
getLine >>= (\s -> getChar >>= (\c -> putStr (s, [c])))
か
getChar >>= (\c -> getLine >>= (\s -> putStr (s, [c])))

じゃあモナドは実行の順序が決められてる関数の中の一つってことか？

例えば左から右へ順番に実行する関数hogeが定義できて、
hoge getLine getCharから
getLine >>= (\s -> getChar >>= (\c -> putStr (s, [c])))と
同じ動作を定義できるのか？

>結合法則を満たす合成は全て実行の順序を保つでいいのか？

これは成り立たないと思う。

モナドの結合法則の概念と順序は本来関係ないんじゃないかな。
たまたま順序を組み立てるのにﾓﾅﾄﾞが使えるってだけだと思う。

http://www.sampou.org/haskell/a-a-monads/html/introII.html
↑のListモナドとかは
順序とは関係なさそうだし。（関数から複数の遅延込みの非正格値を返すためのもの？）
モナドの用途は順序の決定のみにあらずってとこか。

>>241
hoge :: IO String -> IO Char -> IO ()
hoge f g = f >>= \s -> g >>= \c -> putStr (s, [c])

getLine :: String、getChar :: Char だったら無理。

>>242
> List モナドは非決定性をもつ計算の連鎖を、演算をそれぞれのステップで可能なすべての値に適用することで、合成する戦略を内包しています。
だけなら、モナドでなくてもいいね。
------------
module MList where

data MList a = a :*: (MList a) | MNull deriving (Eq, Show)
infixr 3 :*:


instance {- Broken -} Monad MList where
  (x :*: xs) >>= f = merge (f x) (xs >>= f)
    where 
      merge (x :*: xs) ys = x :*: merge ys xs
      merge MNull ys = ys
  MNull >>= f = MNull
  return x = x :*: MNull
  fail s = MNull

toMList xs = foldr (:*:) MNull xs

(>=>) = (>>=) -- 2ch : ">> が多すぎます！"
(>=>) :: Monad m => m a -> (a -> m b) -> m b
test f = test1 f == test2 f
test1 f = f [1,2] >=> \x -> f [3, 4] >=> \y -> f [5, 6]
test2 f = (f [1,2] >=> \x -> f [3, 4]) >=> \y -> f [5, 6]

そうだよなあ。
モナドが「暗黙の引数world」と「関数のeagerな評価」を意味するだけなら，結合法則はなくてもよい。

IOモナドについて。
話の流れから多少それるのかもしれませんが、
IOモナドの僕のとらえかたは以下のような感じです。

putStrはStringを引数としてとり、
「その文字列を表示する動作」を返す関数。
であり、putStr "Hello " >> putStr "World"
とした場合、putStr "Hello "とputStr "World"のそれぞれが評価される
順番は問題ではない。
putStr "Hello "が評価された時点では、
"Hello "は出力されずに、「"Hello "を出力する動作」が
決定するだけである。
そして、putStr "Hello " >> putStr "World"は、
"Hello "を出力した後に"World"を出力する動作として評価される。
この時点では何の出力も生じない。
この動作は、main = ...というように、mainに代入されることにより、
評価器とは切り離された装置によって出力に変えられる。

つまり、putStr "Hello " >> (putStr "World" >> putStr "\n")
とした場合、putStr "World >> putStr "\n"の部分が先に評価されて、
「"World"を出力した後に、"\n"を出力する動作」となり、
その後に、putStr "Hello "と結び付けられて、
「"Hello "を出力した後に「"World"を出力した後に"\n"を出力」する動作」
となる。
これは、
「「"Hello "を出力した後に"World"を出力」した後に"\n"を出力する動作」
と等しい。

>>246
ありがとう、やっとすっきりした。
つまり継続を渡しているわけね。

>>246
> であり、putStr "Hello " >> putStr "World"
> とした場合、putStr "Hello "とputStr "World"のそれぞれが評価される
> 順番は問題ではない。

順番は問題。これは左から評価しないと(されるように>>が定義されてないと)、
putStr "Hello ">> error "Error." 等が正しくうごかない。

> この動作は、main = ...というように、mainに代入されることにより、
> 評価器とは切り離された装置によって出力に変えられる。

上とも関連して、出力しながら内部の式を評価するわけで、
評価し終わったものを実行するのでは「ない」のだから、
 main world を評価すると考えるほうがいいのでは。

上で自分でもただStateモナドのようにかいてしまったけれど、
IO a = World -> (a, World) {- ただしStrict -} と思うことにして。 

(正則性と関連して実はIOはモナドの結合法則を満たしていなかったような)


> つまり、putStr "Hello " >> (putStr "World" >> putStr "\n")
> とした場合、putStr "World >> putStr "\n"の部分が先に評価されて、

ここも左から評価される。

あとは大体OKと思う。

>>248
>順番は問題。
>>256は
> putStrはStringを引数としてとり、
>「その文字列を表示する動作」を返す関数。
という前提だからいいんじゃないの?

>>249
putStr "Hello " >> error "Error." 
の右辺を先に評価したら"Hello"が表示される前にerrorで終わってしまうでしょ。

正格性解析かなにかで>>の左辺と右辺が
Strictにしかも_|_にならずに評価できると知っていたら
何かの気まぐれで右辺から評価するかもしれないけど、基本は左から。

ちなみに右から(Lazyに)評価したら末尾再帰も無意味になるし無限ループも書けない。

ちなみに右から(Lazyに)評価したら末尾再帰も無意味になるし無限ループも書けない。
どういう意味だ？

評価という言葉を誤用したみたいです。

putStr "Hello " >> putStr "World"は、
"Hello "を出力する動作の後に、"World"を出力する動作を続けた動作と解釈される。
と言いかえるべきなのかな。

(1+3) : []を、(4ではなく)1+3を空のリストに加えたものと解釈される。
というのと同じで、この1+3が4になるのはmainに関連づけられたとき
(とhugsなどで、返り値の表示を求められたとき)のみである。

つまり、putStr "Hello " >> putStr "World"が左から評価されるのは、
print ((1+2)：(2+3)：[])が左から評価されるのと同様、
値が必要になった時点で評価されるという、遅延評価の性質から理解できる。

print ((1+2):(2+3):[])でまず1+2が、つぎに2+3が評価されるのは、
(:)に左から順に評価するという性質があるのではなく、
必要とされるのが1+2のほうが先であるというためである。
これは、print $ reverse ((1+2):error "foo":(2+3):[])の出力が[5,となる点からも確認できる。

それと同様にputStr "Hello " >> putStr "World"が左から評価されるのは、
まずputStr "Hello "がプログラムの実行に必要とされ、その後にputStr "World"が必要とされるためであり、
(>>)が左から評価されるといった性質を持っている必要はない。

(しかし、(>>)の右側が左側よりも先に必要とされるという状況は考えられないので(>>)が左から評価される性質を持つというのは
そんなに間違いではないかもしれない。)

putStr "Hello " >> error "Error."がうまく評価されるのも同様で、
"Hello "の出力の際にはerror "Error."を評価する必要がないためである。

現時点での僕の解釈ですので、間違いもあると思います。
Haskellに積まれた概念は非常に興味深いので、
今後も熟考していこうと思っています。

どうも隔靴掻痒の感があるな。
モナドの表示的意味は言語仕様に書いてないのか？

[| >> |]ρσ = ...?

>>252
いったいどういう原理によって
> まずputStr "Hello "がプログラムの実行に必要とされ、その後にputStr "World"が必要とされるためであり、
こうなってると思ってるわけですか？ 

mainや(>>)は関数じゃなくてなにかすごく賢い"評価器とは切り離された装置"
が何が必要かを見切って必要なところだけ評価するという立場？
それならそれでもいいですが…

私は、State(World)についてStrictなMonadだと思えば、
なぜ(>>)の左が先に必要になったのかが、説明できると書いたわけです。

>>251
まず、mainだけ特殊な評価をうけるとは考えないことにします。

右から評価されると無限ループも書けないというのは、
main = loop where   loop =  act >> loop
                    act = print "x"
ここでloopの右辺を先に評価したらact >> (act >> (act >> ..))と
ネストした列ができるだけでloopの処理が進まないという意味です。
末尾再帰も同様のことになります。

先に述べたように、特殊な評価装置や特殊ルールは考えないので、これは、
(>>)がそういう順序に評価を導くように定義されているということを意味します。

単にmainそのものを評価しても、(\_ -> ...)の形か、
(コンストラクタ) ...の形になって...の部分は評価されずに終わります。
これでは...の中に書いてあるIOアクションの列をどう評価、
実行していけばいいかはわかりません。

そこで、mainは関数であって(type IO a = World -> (a, World)、
プログラムの実行とはmain worldを評価する、つまりmain worldの
返り値を求める評価を行うことだと考えることにします。

例えば(putStr "X") worldを評価すると、
"X"が出力されたWorldを返します("X"が出力される)。

これは、普通の評価なので、main worldの返り値(a, world)が求まれば
いいので、まず返り値に必要な部分から計算されます。
したがって、遅延評価ならば、a >> bにおいてworldに最後に関与する
「外側」にある"b"のほうから評価が行われるはずだということになります。
これが「右から(Lazyに)」の意味です。

ちろんこれではループも書けないのでIOモナドとしては使えません。
しかし、WorldについてStrictなモナドだとすれば、
左から評価されるようになります。

-- typeではモナドの定義がHaskell98では書けない。
newtype IO a = IO { runIO :: World -> (a, World) }
instance Monad IO where
    ioact >>= f = IO $ \world -> world `seq`
        let (a, world') = runIO ioact world 
        in  runIO (f a) $! world'

もしよくわからなければ、Control.Monad.Stateのlazyなstateモナドで
loopや末尾再帰のプログラムを書いて挙動を観察してみてください。

これに基づいて議論しませんか？

http://www.haskell.org/definition/haskell98-report.pdf

>>257
基づいてないと？

IOの話なら、規格の性質を満たすIOはいかにして定義され得るか
ということを議論しているつもりなんだけど…

なんかグダグダになってんのか話が進んでるのか判断できないんですが
デバッグ辛くないですか？

別に。 > デバッグ辛くないですか？

>>257のreportを見る限り，どちらの方法でもIOモナドの外部仕様を満たせるんじゃない？

The >>= operation passes the result of the first operation as an argument to the second operation.

ということなので，f >>= gに対して，fの中で起こる副作用がgの中で起こる副作用より先に起こる
ようにするには，

(1) >>=は，左辺の引数についてstrict
(2) g（正確にはgの中での副作用の呼び出し）がstrict

のどちらでもよい（ように思える）．

>>261
> どちらの方法でもIOモナドの外部仕様を満たせるんじゃない？
だれが(1)を主張しているの？

> (1) >>=は，左辺の引数についてstrict
f >>= g のfが先に評価されるだけで、actionの実行とは関係ない。
例えば、f >> (g >> (h >> ..)) の無限列ができるだけでactionが実行されない
こともあり得る。

> (2) g（正確にはgの中での副作用の呼び出し）がstrict
なにがいいたいのかよくわからない。
Monadの話をしているのだから>>=の性質について話さないと。
>>255-256理論のことなのかな(そうは読めないけれど)。


それから、IOモナドはこれ
> Special operations (methods in the class Monad, see Section 6.3.6) 
> sequentially compose actions, 
> corresponding to sequencing operators (such as the semicolon) in imperative languages.
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
を要求してるからf >>= gのfが先に評価されるのであって、
>>261の部分からはそうなるとは限らないことに注意。(cf. LazyなStateモナド)

俺はHaskellのことは余りしらないんだけど、Haskellの言語仕様も
MLのように表示意味論（操作意味論でもいいけど）でformalに定義
されてるんじゃないの？

色々と仕様の背後にある意図を考えるのもいいけど、まずちゃんとした定義
を出してくれると素人には有難いなあ。言葉の定義も人によって違うみたいだし。
ちなみに

fがstrict <=> f(_|_) = _|_
lazy evaluation <=> λ計算でいうところのnormal reduction

ということでいいの？

>>263
> MLのように表示意味論（操作意味論でもいいけど）でformalに定義

IOはどうなんだろ？
http://citeseer.ist.psu.edu/peytonjones93imperative.html
# 個人的にはHaskellのコミュニティはそういう文化じゃないと思ってる。
# formalなsemanticsがどうとかで論文書くんじゃなくて、
# 新しい便利なアイディアをどんどん導入して実際に使う。
# informalなsemanticsだけど気にしない、みたいなことがよく書いてあるきがする。
#
# そういうことに興味がないことによる偏見かもしれない。

ググッたらちょっと古い(1996)けどこんなのも
http://www-fp.dcs.st-and.ac.uk/~kh/papers/io-tutorial/section3_7.html
> No formal semantics for these I/O primitives is possible at present, 
> because there is no complete formal semantics for Haskell itself.

formalでないと理解した気がしないなら、
Concurrent Haskell (Simon PJ他)の論文でIOのsemanticsは誰かの論文を参照、
みたいなことが書いてあった気がするから、探してみたら。


> fがstrict <=> f(_|_) = _|_
> lazy evaluation <=> λ計算でいうところのnormal reduction
いいんじゃない。ちなみにdataコンストラクタはlifted。

normal order reduction ≠ lazy evaluation

>>265
等しくはないね。
でもλ計算でいうところのnormal-order reductionをするわけでしょう？

どうもありがとう。
Simon Peyton Jones, Andrew Gordon and Sigbjorn Finne. Concurrent Haskell, POPL, 1996.
をざっと見たところ、その辺の詳しい話は

Roy L. Crole and Andrew D. Gordon.
A Sound Metalogical Semantics for Input/Output Effects, CSL, 1994.
Andrew D. Gordon.
Functional Programming and Input/Output, Cambridge University Press, 1994.

を参照と書いてあった。暇なときにみてみよう。
ちなみに"Concurrent Haskell"の論文も結構面白い。IOの話については
下のような記述があった。ご参考…といってもここの人には常識か。

The sequencing combinators, >> and >>=, feed the result state
of their left hand argument to the input of their right hand
argument, thereby forcing the two actions (via the data
dependency) to be performed in the correct order.
...
In principle, then, a program is just a state transformer
that is applied to the real world to give a new world.
In practice, however, it is crucial that the side-effects
the program specifies are performed incrementally, and
not all at once when the program finishes. A state-transformer
semantics for I/O is therefore, alas, unsatisfactory, and
becomes untenable when concurrency is introduced, a matter to
which we return in Section 6.

【ビギナ】初心者が習うべき言語は？ part6【必読】
http://pc5.2ch.net/test/read.cgi/tech/1092932484/494-

おい。
Ｒｕｂｙにケチ付けてるこの馬鹿引き取ってくれよ。

ほっといてやれ

>>268
> Ｒｕｂｙにケチ付けてるこの馬鹿引き取ってくれよ。
事実誤認だよ。

>>269
ありがとう。

>>265
normal reduction = leftmost reduction = lazy reduction
じゃなかったっけ

eager evaluation と call-by-value が対応して
lazy evaluation と call-by-need が対応して

normal-order reduction というと call-by-name が対応するといいたいんじゃない？

>> 254
> なにかすごく賢い"評価器とは切り離された装置"
が必要性を判断してくれると仮定しなければ、
print $ [3, 1+2, 4] !! 0
で1+2が評価されない理由は説明できないと思う。
具体的にはその装置はHaskellの一部であって、
Haskellプログラムの内側では議論できない実装に近い部分の話になって
くるんじゃないかな。

>>255,>>256のような議論は有意義だと思うが、
上述したような「装置」によって、(：)と(>>)を同列に扱えるのであり、
(:)にその「装置」が必要とされている以上、
(>>)に他の特別な理論をあてはめるよりは、
必要に応じて評価される。という
lazy evaluationの原則を単純にあてはめればすむのではないかと思う。

ちなみに、
IOというものは[](リスト)と同様にそこにある何かであり、
たとえばputStrLn "Hello"が実行されると"Hello"を出力するのは、
[1,2,3]が(!!1)で2を返すのと同様にとらえられるのではないだろうか。

IOは評価時点では出力されずに、実行という次のステップで出力が生じる。
これは、
main = putStr "Hello " `seq` putStrLn "World"
での出力が
World
であるという点からも理解されるのではないだろうか。

HaskellのIOでは評価と実行は切り離されている。ということに今日気付いた。

「評価する」というのと「印字する」というのが微妙に混同されているような、いないような。

>>274
> print $ [3,1+2,4] !! 0
あたりのことを言われてるのかな？

Haskellにおいて、評価は印字などの動作によってしか引き起されない。
だから、とりあえず単純な印字の例を挙げただけ。

べつに
print $ replicate ([3,1+2,4]!!0) "foo"
のような例でもかまわない。
(当然この場合も1+2は評価されない。)

Haskellでは、IOに関連づけられなければ、式が評価されることはない。
対話的環境でも暗黙のprintがなされていると考えられると思う。
(ちなみに、対話的環境では返り値がIOならばそれの実行を、
それ以外だったらprintをするようになっているのだと思う。)

当然、print $ [3,1+2,4]!!0で、
1+2が印字されないことをもって、評価されないと言っているわけではない。
print $ [3,error "foo", 4] !! 0
で、エラーが生じないというのと同じことを言ったつもりである。

もしかしたら、もっと根本的な誤りを突いているのかもしれない。
そうだったらもう少し詳しい説明をよろしくおねがいします。

>>273
を読んで分かった…
君はlazy evaluationがそもそも分かってないんだorz

lazy evaluationが、「必要」に応じて評価されるのは、
> > なにかすごく賢い"評価器とは切り離された装置"
> が必要性を判断してくれると仮定しなければ、
こういうのがなにかが必要性を判断するわけじゃないよ。
単にoutermost leftmost reductionをしてるだけ。

質問に答えて欲しい。
(0) [3, 1+2, 4] !! 0 と length [0..] > 0 の評価はそれぞれどう進む？
(1) seqの初心者が陥りやすい誤解について説明せよ
(2) Stateモナドは自分で書ける？ (Yes/No)
(3) その評価の順序が分かる？ (Yes/No)
(4) (Lazy)Stateモナドで無限loopが書けないのはわかってる？ (Yes/No)

> IOというものは[](リスト)と同様にそこにある何かであり、
リストモナドも自分で定義できるし…

>>275
> 対話的環境でも暗黙のprintがなされていると考えられると思う。
それってLispでいうrea-eval-print loopなんじゃないの？

先月から勉強しているのですが、
haskellでｎ個の中から、ｍ個を取り出す組み合わせの数、mＣnのプログラムの書き方がわかりません。
だれか教えてください。お願いします。

宿題ですか?

せめて自分でどこまでやったか書け。

課題です、すいません。
漸化式で作るところまでは考えたのですが、C++と違ってfor文が使えないので、
自分ではどうしたらよいかわからなくなってしまいました。

解1: マジメに計算する。階乗はどう書く？　mPn はどう書く？　両方が出来
たら適切な引数を与えて割ればいいよね。

解2: mCn = .. + .. といった形で書ける。 .. と .. はどちらもコンビネー
ションだけど、 m と n の部分が少し小さい。で、m や n が 0 とか 1
だったらどうなるか、というのを考える。そしたら再帰で書けるよな。

という2つの考え方があるよ。

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

ここは優しいインターネッツですね

haskellの課題が出る講義があることに驚き。東大情報？
そのレベルの学生が再帰プログラムに不慣れなことにも驚き（失礼！）。

東大理情ではOcamlはやりますがHaskellはやりません。
工学部計数工学科（武市先生のいるとこ）ではHaskellをやる（人もいる）。

それにしても「関数型プログラムは理解し易くて初心者向き」なんじゃないのか...

東京工科大じゃないの？
http://www.teu.ac.jp/kougi/koshida/Prog6/index.html
と思ったけど課題内容が違うから違うのかな。

京都産業大学？

>>287
呼んだ？

漸化式が作れたのならプログラムのほとんどができたようなもんじゃないか

-- 数え上げobscured。c 10 3 などとして使う
c = flip ((length .) . filter . (. length . filter id) . (==)) . 
      (foldl ((=<<) . (. (return .) . (:)) . (>>=) ) [[]]) . (flip replicate [True, False]) 

ぐっ。↑を導いた過程の解説きぼんぬ。

コマンドプロンプトみたいなものを作ろうと思ってまず下のような単純なのを作って
hugsで動かしてみたら問題なく動いたのですが、ghcでコンパイルして実行すると、
プロンプト "$ " が表示されず、適当にキー入力したあと ":!" でループを抜けると、
入力した個数分のプロンプト "$ " がずらずらと表示されてしまいます。
ちなみに、ghciではhugsと同様に期待通りの動作です。
いったいどうすればghcでも期待通りの動作になるんでしょう？

main = do {
putStr "$ ";
str <- getLine;
case str of {
":!" -> return ();
_ -> main } }

ghcはver 6.2.2と6.2.1で試してみましたがどちらも同じ結果でした。

hFlush あたりを使うとよいのでは?

>>290 の導出過程希望。
まさか直接書いたの?

>293

putStrのあとに hFlush stdout を入れてやったらうまくいきました。

でも最初は実行順序が狂ってるのかと思ってしまいました。

>>294
ghcはターミナルではLineBufferingだから一行たまるまで出力されない。
hSetBuffering stdout NoBufferingを最初に書いてもいい。

>>291
>>293
手で地道にpoint-freeに書き換えました:-)
元は確か 
-- not tested
c n m = length $ filter ((m ==).length.filter id) $
            foldl (\ys xs -> [ x:y | x <- xs, y <- ys]) [[]]
                 $ replicate n [True,False]
こんな感じ。
自動化してフィルタプログラムにするとおもしろそう。

表示の問題は解決したんですが、他の部分に影響が出てしまいました。

プロンプトからの入力をParsecを使ってパースしようとしてるんですが、
文法の都合上Parsecのtryを使ってる部分があります。
hFlushとかstdoutは import IO しないといけないみたいなのでやってみると
そのtryを使っているところで

ERROR ".\test.hs":15 - Ambiguous variable occurrence "try"
*** Could refer to: System.IO.Error.try Text.ParserCombinators.Parsec.Prim.try

とかいうエラーが出てしまいます。(処理系はhugsです。ghcでも似たようなエラー)
どうしたら良いんでしょう？

一応パーサの部分とstdoutが必要な部分は完全に切り離されているので
パーサ部分を別のモジュールにしてやることで回避出来ることは確かめましたけど、
それ以外の方法はあるのでしょうか？

>>296
import qualified Text.ParserCombinators.Parsec as Parsec
して
Parsec.try と書くとか
import System.IO.Error ( hFlush, stdout, ... -- tryを以外だけリスト)
とか

For futher details, see section 5.3 of the Haskell 98 report.

>>297

ありがとうございます。
後者のやり方を使ってみます。

>>295
おおう、そのcならまともに読めますね。
((=<<) . (. (return .) . (:)) . (>>=)) の部分はやはりlist comprehensionからの変形か。
[[Bool]]が渡っているところをfuseして、さらに読解不能なコードにできるかもw


ところで、monadの話はどうなった。

なぜ、関数型言語は、Hello Worldを隠したがりますか？

　 　∩＿＿＿∩　　 　　　　　　｜
　　 | ノ＼　　　　 ヽ　 　　　　　　|
　　/　　●゛　　● |　　　　 　　　|
　 |　∪　　( _●_)　ミ　 　　　　　j
　彡､　　　|∪|　　 |　　　 　　　>>300
/　　　　 ∩ノ ⊃　 ヽ　　
(　 ＼　／ ＿ノ　|　 |
.＼　“　　／＿＿|　 |
　　＼ ／＿＿＿ ／

Haskellはじめたばかりなのですが、よくわからないので教えてください。
a = "b"
b = 1
c = do
　"c"
d = do
　2
と書いて、dだけ、
*** Binding : d
*** Outstanding context : (Monad b, Num (b c))
と言われるのはなぜですか？

文字列は文字のリストで、リストはMonadクラスのインスタンスだから。
数値はMonadクラスのインスタンスではないから。

>>303
ありがとうございます。
doの中からは、Monadクラスのインスタンスを返すことは出来るけど、
他のものは返せないと。
doの中から数値を返したい場合はどうしたらよいのでしょうか？
Monadクラスのインスタンス作って返すしかないってことでしょうから、
returnを使って、IOモナドを返せばいいということなのでしょうか？
IOモナドって使わなくてすむなら使わないほうがいいみたいなのですが、
数値を返す関数はdo使わなくてもかけるだろうってことなのかな？
Haskellは難しいです。頭がクラクラします。

>>304
> doの中から数値を返したい場合はどうしたらよいのでしょうか？
一般には無理。リスト等、中身を取り出せるモナドもある。
f :: Int
f = head $ do return 3

> 数値を返す関数はdo使わなくてもかけるだろうってことなのかな？
なんでモナドが使いたいのかわからない。
例えばどんな「数値を返す関数」にモナドを使おうと思うわけ？

　　　　　　 ∧＿∧　　　／￣￣￣￣￣￣￣￣￣￣￣￣￣
　　　　　　（ ´ 曲｀）　 ＜　モナドナ♪ドーナー♪ドーナー♪
　　　　　　⊂　　　 ）つ　＼＿＿＿＿＿＿＿＿＿＿＿＿＿
　　　　　　　（＿⌒ヽ
　　　　 　　 　)ノ ｀J

>>304
引数をとらずに数値を返す関数を書きたいということですか。
Haskellの場合、引数なしの関数は値そのものとまったく同じものになります。
C言語などでは、int some (void) { return 3 }とint some = 3は違うものですが、
Haskellではsome = 3 :: Intとなり両者の区別は存在しません。

また、doの意味を誤解しているようですね。
doというのはある種のシンタックスシュガーで、
do a
b
c
という表記は a >> b >> cというように解釈されます。
この(>>)はMonadクラスで定義された関数なので、
doをMonadクラス以外のものに適用しても意味がありませんし、
doの後に式がひとつの場合も意味がありません。

Haskellの考え方になじむまでは難しく感じると思いますが、
段階をふんで理解していけば大きな困難はないと思います。
hugsでいろいろな関数をつくって遊んでみることをおすすめします。
洋書ですが、「The Craft of Functional Programming」がおすすめです。

>>307
訂正
do a
   b
   c

>>307
> C言語などでは、int some (void) { return 3 }とint some = 3は違うものですが、
> Haskellではsome = 3 :: Intとなり両者の区別は存在しません。

int rand(void) に相当するものはどうなるのでしょうか？

>>309
Haskellでは関数は毎回同じ値がかえってこないといけないので、
そのようなものはありません。

では乱数はどうするかというと、
ramdom :: (RandomGen g) => g -> (a, g)
のように、generatorを渡して乱数を生成し、次のgeneratorを
返すことで実現します。

実際にはこのままでは使いにくいので、
randoms :: (RandomGen g) => g -> [a]
と無限リストにするか(これがお薦めです)、
C言語と同じ様に副作用によってgeneratorの状態を保存するために
モナドを用います。

# System.Randomで乱数関係の関数が定義されています。

>>310
こういう、Haskell風の思想を交えた解説は新参者にとって非常に参考になります。

出来れば、あまり人に頼らず勉強したいところなのですが、、、
申し訳ないのですが、考え方があまりに違うので、質問させてもらっています。
詳しく解説していただけて、非常に感謝しております。頭が下がります。
>>305
モナドを使いたくて、doを使っているわけではありません。
doを使いたくて知らないうちにモナドを使っていたようです。
>>306
doについてよく理解していないことがわかりました。
単にc言語の{}に対応した表現が出来るものだと思っておりましたが、違うのですね。

洋書は気合入れて買ってみても、
結局、挫折することは目に見えているので控えさせていただきます。
翻訳版が出るとうれしいです。

関数は同じ値を返さなくてはならないというのも面白いですねぇ。
>>311
ありがたい話しです。

モナドもよくわからない、Haskellのジェネレータもよくわからない。
とにかく、わからないことずくめなので、ゆっくり腰を据えて勉強するしかないなぁ。
Java知ってるから、C#も１日でだいたいわかるって具合には行かないですねぇ。

関数型のプログラムのコツは写像を追うことです、
JavaとかCとかやってると、どうしても手続きに目がいってしまって最初は全然まともに組めないです。
他にも、プログラム中に時間概念が無いので時系列を作り出す必要があるという点にも馴れにくかったです。
この辺はまるで相対論よろしく時間を次元の一つとして捉えて４次元空間的を直接取り扱う感覚を覚えました、
そんな感じで、過去から未来まで全部お見通しの神様の気分でプログラムしてます。
こんな感覚になるまで、僕もかなりの期間悩みました。
乱数なんかもそうですよね、あらかじめ無限個ある全ての乱数を作って置いておくという、
Javaなんかやってると、この感覚はそう簡単にはなじめないですね。

---------------------------
import Numeric
f :: Float -> Int -> Float
f x n = sin (pi*x*(2*n+1))
-----------------------
このプログラムがエラーになる理由を教えてください。
型が不一致といわれるのですが。

>>314
n が何なのか知らないが、pi は Float ではなくて？

nは整数（自然数）のつもりです。
piは標準ライブラリ定義されているFloatの定数だと思います。
この関数定義自体が出来ないみたいなんですが。

>>314
型があわない。

f x n = sin ( pi * x * (2.0 * (fromIntegral n) + 1.0))

>>314
型の不一致。
(*) :: Num a => a -> a -> a
なので、例えばaがIntでは、Int -> Int -> Intとなり、
aがFloatならば、Float -> Float -> Floatとなる。
違う型同士のかけ算はできない。
この場合、fromIntegralを利用して以下のようにすればいい。
f :: Float -> Int -> Float
f x n = sin (pi*x*(2*fromIntegral n+1))

ありがとうございます。
fromIntegralで型変換（？）しなきゃ掛け算できないんですね。
ちょっと面倒ですけど、rubyで(1/n)とやるとn>=2で0になってしまう（←これが分からず何時間もロスした＾＾；）
とかよりは明確でいいんですかねぇ。

追加です。
c x t n = (4.0/pi) * exp (-pi^2*t*(2*fromIntegral n+1)^2) * sin (pi*x*(2*fromIntegral n+1)) + (c x t (n - 1))
c x t (-1) = 0
これで「c0.5 0.001 10」を評価するとスタックオーバーフローしてしまう理由を教えてください。

これは関数定義の順番の問題。
Haskellでは、先に書かれたものから順にパターンマッチが行われるため、
c x t n = ...はnに対する条件がないため、
nが-1のときもこっちが適用されてしまい、無限ループにおちいる。
c x t (-1) = 0
c x t n = ...
の順に並べれば問題は解決する。

http://www.teu.ac.jp/kougi/koshida/Prog6/text02.html
ここで使っている、
文字→コード ord :: Char -> Int
コード→文字 chr :: Int -> Char
という関数が定義されていないようです。
環境はwindows 2000 でhugsを使っています。
:versionと入力すると、以下のように出ます。
-- Hugs Version Nov 2003
:browse Preludeとしてみてもordという関数はないので
バージョンＵＰして使えなくなったということでしょうか？

Prelude> :l Char
Char> :t ord
ord :: Char -> Int

>>319
わざわざ Float->Int->FloatにしようとするからfromIntegralが
必要になる。

f x n = sin ( pi * x * (2 * n + 1))

だけで明示的に型を指定するのやめれば

*Main> :t f
forall a. (Floating a) => a -> a -> a

という型になるがあとは勝手にやってくれるよ。

あーでもそれじゃnに整数以外の数つっこめちゃうのでだめか。

>>321
ありがとうございます。gnuplotでグラフを書かせるためのファイルを
出力しようと目論んでいるのですが、rubyより知的な気分ですね。

可読性はどうなんでしょう。
多少字面は見づらいけど、数学みたいに書けて
コンピュータ特有のことを考えないで済む分楽かもしれませんね。

>>323
なるほど。:loadしないと使えないのですね。
runhugsやGHCで使う場合というか、ファイルに書いておいて使う場合は、
(なんていったらよいのでしょう？)
import Charすればよいのですね。わかりました。

ありがとうございます。

みんなこの言語使って何やってるの？

「最近Haskellっていう言語勉強しててね。 いやーCとは全然違うすごい言語だよ。
関数型って言うんだけどね。」
「すごーいよく分からないけどかっこいいー」

「最近Haskellっていう言語勉強しててね。 いやーCとは全然違うすごい言語だよ。
関数型って言うんだけどね。」
「すごーいよく分からないけどかっこいいー。じゃあ、今晩はカレーにしようか？」

今晩はカリーか。

今晩はカリだ。

アライグマ　Haskell

>>328
言語習いたてのワクワクをモ一度味わいたくて。
とりあえずＫＩＳＳローダ作るのが目標です。

ＫＩＳＳローダってなんですか

CommonLisp/Scheme と Haskel と ML の中で一番実用に近いのは何？
私は CommonLisp だと思うんだけど。

>>336
比較対象が微妙に違っているわけだが。

すみません。最近勉強を始めた者ですが、頭が悪いものでどうにもわからず
困っています。よろしければご教授願えませんでしょうか。
３つをまとめる関数 zip3 を zip を用いて定義せよ、という問題で
zip3 :: [a] -> [b] -> [c] -> [(a,b,c)]
zip3 (x:xs) (y:ys) (z:zs) = change (zip (zip x y) z) : zip3 xs ys zs
where
change :: [((a,b),c)] -> [(a,b,c)]
change [((x,y),z)] = [(x,y,z)]
zip3 _ _ _ = []
というものを考えたものの、どこがどう悪いのか自分ではわかりません。
１週間悩んで進展なしで独力では無理なようなので、どなたかお教えいただけませんでしょうか？

zip3 :: [a] -> [b] -> [c] -> [(a,b,c)]
zip3 xs ys zs = map change $ zip xs (zip ys zs)
where
change (x,(y,z)) = (x,y,z)

>>339
型があってない。っていうかzip使ってない。

> zip3 (x:xs) (y:ys) (z:zs) = change (zip (zip x y) z) : zip3 xs ys zs
x , y, z :: aだから zip x y とはできない。(もともとa = [b]でないかぎり)
zip3 (x:xs) (y:ys) (z:zs) = (x, y, z) : zip3 xs ys zs
と書こうとしてるわけだからこれではzipの使いようがない。

参考>>184の上半分
zip3 x y z = (,,) <$> x <-> y <-> z

{-
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith f (x:xs) (y:ys) = (f x y) : (zipWith f xs ys)
zipWith f [] _ = []
zipWith f _ [] = []

zip :: [a] -> [b] -> [(a,b)]
zip xs ys = zipWith mkpair xs ys
　　where
　　　　mkpair x y = (x, y)
-}
zip3 :: [a] -> [b] -> [c] -> [(a,b,c)]
zip3 xs ys zs = zipWith mkpair xs (zip ys zs)
　　where
　　　　mkpair x (y, z) = (x, y, z)

zip3' = (zipWith (uncurry (,,)) .) . zip

zip3' = const zip3 zip

339です。自室のPCからでははじかれてしまって書き込みができなかったので
遅くなってしまいましたが、ありがとうございます。
たいへん助かりました。
…お礼の言葉が遅くなってしまい、申し訳ありませんでした。ｍ（＿＿）ｍ

-- Haskell Mode

Haskell Haskellモード 関数型言語でーす

Haskellモード Haskellモード Haskellモード Haskellモードでーす
Haskellモード うにゃ〜 うにゃにゃ lazily evalute!

関数 … カリー様 関数 … か・た・す・い・ろん
モナド >>= … わたしのシモベェ〜 モナド >>= …

Haskellモード Haskellモード Haskellモード 98モードでーす
Haskellモード Haskellモード Haskellモード Haskellモードでーす

たらい、回したくなっちゃった…

>>346
大丈夫？

Everyday Haskell
http://www.sampou.org/cgi-bin/haskell.cgi?Everyday&l=jp
が面白い

fold右派とfold左派にワラタ

The Evolution of a Haskell Programmerでググれ
という話ではなかったようだなスマソ

これ既出?
http://www.cin.ufpe.br/~haskell/vhs/

>>347
346の文字列を読んで、ラテン系の伴奏が聞こえてくるようだと
かなりダメ。

>>346
禿げﾜﾛｽ
ｶﾘｰ様(・∀・)ｲｲ!!

保全sage

Hatena::Diary 「Haskell」を含む日記
のとある日記を見てちょっとワラた

「むしゃくしゃしてやった．Haskell で書くつもりはなかった．今は反省している．簡潔に書けるが，知らない人には全く読めないだろうし，知っている人はもっとうまく書くかもしれない．」

ocaml age

>>355
ワラた。
++ "しばらくしたら…誰も読めなくなるだろう。"

The Implementation of Functional Programming Languages オンライン復刻記念
ttp://research.microsoft.com/Users/simonpj/papers/slpj-book-1987/

って既出？

>>358 おおっ！ 既出ではないと思う。さんくす。
といいつつ書籍で持ってるのだがw。いい本だよねー。

OCamlだとMLっぽいから書きやすいんだけど…。

>>358
やけにでっかいから何かと思ったら、300もあるページがみんな画像……

Revision Control System を、調べてたら、
darcs ( ttp://abridgegame.org/darcs )
というのを、ﾊｹｰﾝしました。
これは、haskell で書かれているので、「haskellってなんや。」と調べる流れでここに来ました。

私が知らないだけ、haskellでかかれたアプリはいっぱいあるのかも知れませんが、
上の方に出てないみたいなので、書いてミマス。

激しくｶﾞｲｼｭﾂでしたらすいません。

haskellで書かれたアプリはそんなに珍しくないと思う。
http://www.haskell.org/practice.html
にいくつか載ってる。

haskellとOCamlではどちらがメジャーですか？

そういうのをドングリの背比べというのではないだろーか。

スラド本家?とLtUで取り上げられた<darcs
http://it.slashdot.org/article.pl?sid=04/11/25/0136249&tid=156&tid=218
http://lambda-the-ultimate.org/node/view/391

純粋に関数的な「パッチの適用」を，ファイルやディレクトリの読み書きからキレイに分離でき，
また，パターンマッチングと高階関数が，パッチのプリミティブの実装にとてもマッチする，とある．

詳しくはこちら．
http://osdir.com/Article2571.phtml

>>346
超ワロタｗ

>>367
元ネタｷﾎﾞﾝﾇ

>>368
http://that3.2ch.net/test/read.cgi/gline/1104975149/1-9

ぬるほど

Haskellの初歩を学校でやっているのですが、
宿題が出て難しすぎるので誰か助けて下さい。

２つの項を入力されたらmost general unifierを出力する
*(1,y) *(x,+(a,b)) -> {x->1,y->+(a,b)}
のようなプログラムを作れ、という課題が出たのですがサッパリわかりません。
どなたか教えて下さい

>>372
もう一年やれば、理解も深まるよ。

というか，課題が全然理解できないんだが．

あ，分かってしまった．もう一年がんばってね．

問題の意味がわからないのならどうしようもないな

>>372
これ、数学板のmathematicaｽﾚでも見たぞ
ﾏﾙﾁすんな、消えろ

もっと低レベルな人にあわせてくれる学校に入りなおしましょう。

>>370
ｶｯ

[1,5,8,43]などのリストをパラメータとして受け取って
[("1st",43),("2nd",8),("3rd",5),("4th",1)]のように
ランクをつけてランク順に返す関数が欲しいのですが
問題は[5,6,6,22,23,24,24]のような場合に
[("1st",24),("1st",24),("3rd",23),("4th",22),("5th",6),("5th",6),("7th",5)]
のように返さなければいけないことです。どうすればいいかさっぱりです。
誰か教えて下さい。

List> group $ reverse $ sort [5, 6, 6, 23, 24, 24]
[[24, 24], [23], [6, 6], [5]]
ここまで来りゃ後はなんとでもなるだろ。

>>381
ありがとうございます！！

あ、ランクを付ける際にはカウンタみたいなものを用意するんですか？

宿題か？ 宿題なのか？ テメエェェェ

>>381
演算子 $ って初めて見ましたが，なかなか便利ですね．
勉強になりました．

はい、そーです

> ここまで来りゃ後はなんとでもなるだろ。

いろいろ考えたのですがなんともなりません。
むしろここから先が一番大変なのではないかと・・・
まじで教えてくれませんか？

ここまで来てなんともならんてのは、けっきょく全然理解してないってことだ
ろ。これくらい自分で考えてみ。でないとただのカンニングだろ。

僕にはこれが限界でした。

rank :: [[a]] -> [(Int, a)]
rank x = [(i, n) | (i, a) <- zip [1..] x, n <- a]

確かに理解は非常に足りません。ですが、本を読んでも、
いろいろなほかのテクニックを知ってもループという基本的なことを
するのがこんなに難しい言語は初めてなのです。
なんらかのライブラリを使う必要があるのかもしれないと思って、
Listのところは大体見たんですが結局何も見当たらずもうダメです。
こんな簡単であろう問題に3時間も4時間もかけてる自分がすごい嫌になってきます。

ま、気楽にやれや、学生なんだし。

そう気楽でもないんすよ。いろいろあって。
ヒントを下さい。お願いします。

>>391
[1..]のところを["1st", "2nd", ...]というリストにすれば終わりだろ。
英語のカウントに勝手に直してくれるようなライブラリはないだろうな。

>>392
> [1..]のところを["1st", "2nd", ...]というリストにすれば終わりだろ。

そのリストはどこまで続くんですか？

いや、それじゃランク順の法則が違うんですよ。それだと
[("1st",24),("1st",24),("2nd",23),("3rd",6),("3rd",6),("4th",5)]
になっちゃうんですよ。

課題は
[("1st",24),("1st",24),("3rd",23),("4th",6),("4th",6),("6th",5)]
にならなきゃいけないので前のリストのカウントを常にしないと次のランクが
分からないわけです。これをどうしたものかと・・・・

>>393
同じ課題で悩んでる人ですか？そのリストは(length x -1)thまで続くんじゃないでしょうか？

与えられた整数に英語のカウントをつける関数はもう作ってあるんですが。

addSuffix :: Int -> String
addSuffix x
| x == 1 = "1st"
| x == 2 = "2nd"
| x == 3 = "3rd"
| otherwise = show x ++ "th"

>>394
> にならなきゃいけないので前のリストのカウントを常にしないと次のランクが
> 分からないわけです。これをどうしたものかと・・・・

rankingの関数が、
1)降順ソートずみ整数の(部分)リスト (初期値 全リスト)、
2)これまでに処理した整数の数 (初期値 ゼロ)、
3)直前に処理した整数 (初期値 -1とか、入力リストに絶対あらわれないもの)、
4)直前に処理した整数のランク (初期値 ゼロ)、
のよっつを引数として取ればいいんじゃないの？

> 与えられた整数に英語のカウントをつける関数はもう作ってあるんですが。
> | otherwise = show x ++ "th"
これだと
21番目は "21th"
22番目は "22th"
になっちゃうよ……

あ、ほんとだ！ご指摘ありがとうございます。
じゃぁ条件分岐のところ、xの代わりにmod x 10で。

rankingの関数はやはり4つも引数が必要ですか・・・・。
じゃぁそれでちょっと頑張ってみます。

ちょっとやり方は違うけど4つの引数使ってやっとできました。
でもなんかぎこちない感じ・・・。これでいいのでしょうか。
もっとスマートなやり方があるような気がしてなりません。

setRank :: [Int] -> [(String, Int)]
setRank [] = []
setRank (x:xs) = ("1st", x):[(addSuffix a, b) | (a, b) <- subSetRank xs x 2 0]

subSetRank :: [Int] -> Int -> Int -> Int -> [(Int, Int)]
subSetRank [] _ _ _ = []
subSetRank (x:xs) preVal position k
| x == preVal = [((position - (k+1)), x)] ++ (subSetRank xs x (position+1) (k+1))
| otherwise = [(position, x)] ++ (subSetRank xs x (position+1) 0)

addSuffix :: Int -> String
addSuffix x
| mod x 10 == 1 = "1st"
| mod x 10 == 2 = "2nd"
| mod x 10 == 3 = "3rd"
| otherwise = show x ++ "th"

>>394
失礼。俺なら395よりは、
groupBy (\x y -> snd x == snd y) $ zip [1..] $ reverse $ sort [5, 6, 6, 23, 24, 24
]
から変形するな。

import List
rank :: Integer -> String
rank x
| x `mod` 10 == 1 = s ++ "st"
| x `mod` 10 == 2 = s ++ "nd"
| x `mod` 10 == 3 = s ++ "rd"
| otherwise = s ++ "th"
where s = show x

ranks :: [String]
ranks = map rank [1..]

sort_group :: Ord a => [a] -> [[a]]
sort_group l = group $ reverse $ sort l

main :: Ord a => [a] -> [(String,[a])]
main lst = zip ranks (sort_group lst)

>>399
全然違うじゃないか。
それにmainはIO aの型であるべきもので、使わないほうがいい。

誰も書かないから突っ込むけど、
11th,12th,13th

そんな私はsort使うためにimport Listするとhugsにレイアウトが違うと怒られる駄目駄目プログラマ。

importがImportになってた スレ違い御免orz

どうもありがとうございます。おかげ様で前のよりはマシになったかと思います。

setRankS :: [Int] -> [(String, Int)]
setRankS x = concat [setFirst n | n <- (groupBy (\x y -> snd x == snd y) $ zip [1..] x)]

setFirst :: [(Int, Int)] -> [(String, Int)]
setFirst ((x, y):xs) = [(addSuffix x, b) | (a, b) <- ((x, y):xs)]

>>401
またまた貴重なご指摘ありがとうございます。

addSuffix :: Int -> String
addSuffix x
| x == 11 = s ++ "th"
| x == 12 = s ++ "th"
| x == 13 = s ++ "th"
| mod x 10 == 1 = s ++ "st"
| mod x 10 == 2 = s ++ "nd"
| mod x 10 == 3 = s ++ "rd"
| otherwise = s ++ "th"
where s = show x

あーごめんなさい。私もまだ間違ってた。
111th,112th,113th,211th....。序数詞は怖い。もうないよね。

| mod x 100 == 11 = s ++ "th"
| mod x 100 == 12 = s ++ "th"
| mod x 100 == 13 = s ++ "th"

これ足せばOK？

宿題しか話題のない悲しい言語

>>407
> 宿題しか話題のない悲しい言語
達見かな。で、どうしてそうなのかという質問がなされ、欠点が羅列され、
いやそんなことはない理論的に美しいという反論が出て、数少ない実用例も示され……

関数型言語なんてみんなそうなんじゃない？
Lisp系は処理系が簡単だから使われるけど、それ以外は…

初心者を馬鹿にするとき、一番盛り上がります。

>>409
OCamlをフリーソフト(非オープンソース)を書くのに使っていますが。

じゃあ、みんなでＨａｓｋｅｌｌで言語処理系を作ろう。

Haskellでテトリスは作れますか？

>>413
作れます。

Haskellのテトリス↓
http://web.comlab.ox.ac.uk/oucl/work/ian.lynagh/Hetris/
http://fxp.hp.infoseek.co.jp/haskell/HSDL/

ghcってどれくらいきちんとdebugされてるのかなあ。
仕事に使っても大丈夫？

>>411
こういうコンテキストで話すなら、商用に使われてナンボだと思うが。
俺自身は宿題用だろうが日曜プログラマーの趣味の道具だろうが構わんけど。

>>416
まあオープンソースだから、sourceforge.net/projects/ghc/やメーリングリストを見て
自分で判断してくださいということで。


ver6.4のリリースが延び延びになっているのが気になる。
RCのソースもコンパイルできないし…(@Mac)

そうそう。
あくまでも最先端の研究用なので、品質に期待してはいけない。

C,C++の代わりとまではいかなくても、
Perlの代わりぐらいにはなりますか？

>>420
もう少しHaskellのこと勉強してから出直してきたら

>>421
言語の完成度じゃなくてghcの完成度を聞いてるんだけど。

ｴｽﾊﾟｰ募集中ですか(w

ghcってとてもバグが少ないとおもう。
特に、コンパイル結果がおかしいというのは一つも知らない。
言語拡張を使ってコンパイラが落ちるのはあったが、gccだってよく落ちたし。

品質に期待してはいけないってのは、なんか具体的な理由があるの？

GHC最強。ノアだけはガチ。

ghcは完璧。バグなんて有り得ない。

ttp://www.ghc.or.jp/

ghcの品質に問題ありとかいってる奴は頭がおかしいな。

関数型言語で書かれてないソフトウェアなんて
信頼性低すぎて使ってられないよな。

ghcにはバグなんてない。
ghcの信頼性 >>>>>>>>> gccの信頼性

　　　　　ｶﾀｶﾀ
　　||￣ Λ＿Λ
　　||＿（Д`；　）　「なに？このスレ・・・」
　　＼⊂´　　　）
　　　　（　　┳'

妙な雰囲気を紛らわす一服の清涼剤sage

ttp://pggirls.asukaze.net/index.php?cmd=read&page=ｲ霖?/Haskell､ｿ､?

ghcにバグがないことは証明済みです。

The Monad.Reader
http://www.haskell.org/hawiki/TheMonadReader

証明が間違ってないことも証明済みです

よく分からんが、ghcにバグは有り得ないってことか。

そゆこと

ttp://sourceforge.net/tracker/?group_id=8032&atid=108032

ghcってのは宗教か何かですか？

真理です

我々はこのスレを笑い飛ばしていたものです…。
しかし、その後、、、

テレビで観た外国人犯罪者。刑務所で個室をもらい、支給されたパソコン
でお勉強。本国から雑誌や新聞、書籍を送ってもらい、専属の通訳と翻訳家
つきで、食事はその国にあわせたもの。日本人受刑者は狭い部屋ですし詰め。
しばらくして、別のニュースでホームレスが川に落ちたインスタントラーメンを
取ろうとして転落、そのまま凍死してしまったという記事を読んで、せつなくな
ってしまった。
新聞で日本で暮らす脱北者のインタビュー記事。「生活保護の支給額が足りない」
「支援してくれないので日本は冷たい」だと。
別の記事で生活保護を受けられなかった母子がおんぼろアパートで餓死。
この国は本当に狂っている。

・・・という内容をghcで矛盾を含まずーディングしはじめる兵(ﾂﾜﾓﾉ)が現れるのを
目の当たりにすることになったのです。　　〜Fin.〜　　　（2ch.千夜一夜物語）

真理です

生活苦や迫害から逃れるため北朝鮮を脱出した元在日朝鮮人
大阪府八尾市に支援者が用意した２部屋のアパートで
月約１７万円の生活保護と支援者からのカンパで暮らす。

ソウルに住む長男も呼び寄せたいというが、
「いまの生活保護額では厳しい」と悩む日々だ。

http://www.asahi.com/national/update/0310/OSK200503100048.html

　　　　　　　　　確定申告済ませたか？

　　　　　　俺も17万円と2部屋のアパート欲しい。　　　　　　
　　　豊な生活送るには、17万円ポッチじゃ、まだタリン。　
　　　　　おまえ等の税金もっともっと　よ　こ　せ！

ghcならコンパイル可能

ｇｈｃだからこそコンパイルエラーの結果に終わります。　こんなんに真値判定出されてたまりますか。

http://www.haskell.org/ghc/download_ghc_64.html

新たな教典が来ましたね。
もちろんバグはありませんので、安心してご利用ください。

>>449 ＝モズクズ様↓
http://www.gema3.net/bbs/icon/inore.jpg

SOE本とCraft本で、どちらがお勧めですか？

>>451
両方

今年度は、Hugsの新版出ないの？

Mar 2005 releaseがでてるけど

あれ、いつの間に。

Charが、うにコードに対応したんだ。

hugs98-Mar2005-patched.tar.gzｷﾃﾙ━━━━━━(ﾟ∀ﾟ)━━━━━━ !!!!!
updated with urgent bug fixes

同じ関数型言語でもHaskellのほうがSchemeより易しくない？
SMFの解析を書き始めてるけど、コストをあまり考えすぎなくてよい気がするし、
Schemeよりも簡潔に書けるし、実行速度もいくぶん速い。
いまのところ、手続き型の処理を書かなくても
（コストを気にしない限りは）それほど書くのが難しくない。
ただ、効率を気にしだすと書き換えるのは難しいのかな？

素朴な疑問だが、lazyな言語で割り込み処理（シグナル等）はどうやって書くのだろう。
割り込み時の状態はどう定義されるのだろうか。

>>459
もれも良く分からんが、MIT pressから出てるSICPっていう本読んでると
無限ストリームっていうのが出てくるから、それ使うんじゃない？
A Gentle Introduction to Haskellっていう、Haskellの紹介文書
にも無限ストリームを使ったクライアントーサーバー処理の例が出てくるよ。

数学理論に立脚した言語で現実世界を対象としたプログラミングを行うことは間違いだ

>>461
はい？もう一度言ってもらえますか？よく見えなかったので。

>>459
たぶんlazyな言語に対して割り込みのformal semanticsを与えた人はいないと思う。
もの凄く難しい。

>>460
それは単なる入出力ではなかろうか。

イベントや割り込みであろうが入出力には違いないだろ
辻褄が合ってればいい

割込みは「単なる」入出力とは違うってことだろ

ghcでバイナリデータをバイト単位で扱うときって、Word8を使えばいいの？

Charだと数値との比較ができなくて不便。

MacOS X 10.3 で Haskell を使うのにお勧めの方法は何でしょうか？
Hugs98 か ghc になると思うのですが。 fink には入っているのは
どちらも Hugs98 2001-Feb と ghc 6.2 で少々古かったです。

Mac使うのを止めるのがオススメ！

そうだね。
爪弾きにされ、余計な苦労ばかり増えて良いところなんて一つもないし。

finkに頼らんでもHugsなら自分でmakeすればOKだし
GHCは本家にバイナリが用意してある

マイナー言語やる上で Mac は悪くないプラットフォームなんだけどね。
ML も主要なのは殆ど対応しているし。

haskellよりもMLの方が文法綺麗じゃないですか？？そんなことないかな…

ML、特にSMLはDefinitionが出て以来そのままだからなあ(97年に改訂されたけど)。
Haskellの方も一応98はあるけど、そうじゃない部分は随時面白い話があるたびに
手を入れてきた感じなのは否めないのかも。

http://www.amazon.co.jp/exec/obidos/ASIN/0201342758/
http://www.amazon.co.jp/exec/obidos/ASIN/0521644089/

この 2 冊が欲しいのですが、中を確かめてから欲しいので
都内で在庫がある店知りませんか？
東京駅〜秋葉原〜神保町あたりだと助かります。

グランデに電話してみれば?

> 474
Haskell: The Craft of Functional Programmingはかなりおすすめです。
買って損はないと思います。

結局 Amazon で注文しました。

http://www.hatena.ne.jp/1087912125
ここに載っててありそうなところには電話かけましたが
店頭に在庫はないみたいでした。Amazon がない時代は
みんなどうしていたんだろう…。大学生協で取り寄せかな。

>>474
神田行けばいくらでもあるだろ。
デカイ本屋で在庫あるか訊いてみろ。

>>478
私には >>477 以外に出てくる本屋以外にデカイ本屋は知りません。
おすすめのコンピュータの洋書をあつかっている店の名前が分かる
なら教えてください。

>>479
http://www.book-kanda.or.jp/town/map/map.htm
http://www.book-kanda.or.jp/town/newbook/index.htm

明日、神田を周ってこようと思います。
ありがとうございました。

>>474
君見て自分も思い出したように買ったよ
まあ回っても見つからないと思うよ

昨日行ってきました。
水道橋駅を降りて、神保町駅まで歩きその周辺の本屋を巡りました。
コンピュータの洋書を扱っているのが、三省堂の本店しか見つける
ことができませんでした。在庫はあらず。

いくらでもあるとのことなのですが、探しかたが悪いのか、
>>482 さんの言う通りなのか不明です。

Amazon から Haskell: The Craft of Functional Programming
は届いたので読みすすめてます。結構面白いです。

>>483
> コンピュータの洋書を扱っているのが、三省堂の本店しか見つける
> ことができませんでした。

え、マジ? それは探し方が悪いのでは。

そうですよね。もっと探検してみます。

オレも他にはゆうりんどう(字わからん)くらいしか思いつかない。いいとこあるなら教えてcray。

洋書なんて読むなよこの非国民が

英語も読めないの？国辱。

洋書 = 英語書かよ、この拝米主義者め

英語＝拝米の方がよっぽど（ｒｙ

Haskell: The Craft of Functional Programming は英語だろ？
国辱どもが。

当たり前のことを言うな一知半解野郎

これがゆとり教育の弊害か。確かに国辱。

>>487-493
レベルの低い話は止めろ

科学とかに関しては日本なんてどうでもいい罠。

Haskellの勉強してると類(kind)という言葉が出てくる。
手持ちの関数型言語の参考書では見かけないので、類を扱うのは比較的
珍しいことなのかと思うのだけれど、どう?
なんでHaskellには類が必要なの?

Haskellだと、普通の多相型（[]とかMaybeとか）に加えて
「型構築子から型構築子への写像」（StateTとか）のようなものを定義できるから、
単に「無引数の型構築子」だとか「１引数の型構築子」とかいうだけじゃ不十分だからだと思う。

まあ、似たような機能のあるC++では「類」なんて聞いたこともないんだけど。
関数型言語についてはよく知らんので誰かフォローよろしく。

WinXPで動くHaskellのコンパイラってある？

>>498
え？GHCがwindowsで動くでしょ？？？

　　　　　　　　　　　∩ノ
　　　　　　　　　　／　つ
　　　　　　　　 ／　／　　／￣￣￣￣
　　　　　　∧ ∧／　　 ＜　５００ゲットぉぉぉぉ！
　　　　 ⊂(ﾟДﾟ ） 彡　　 ＼
　　　　　　　 ⊂彡　　　　 　￣￣￣￣
　　 ＿＿__●●●＿__ ﾊﾞｲｰﾝ
　／ 〇 〇 ＼|／　 ／|
　|￣￣￣￣￣￣￣|

498ではないが、
WINXP sp2 で GHC のインストーラはエラーで落ちました。
hugs98 は簡単にインストールできました。

言語仕様を見るとHaskellの方がはるかに機能的に見えるのだけど、実用面を見るとHaskellはボロボロ。
結局、開発するならOCamlに軍配があがるんだよね。

だから品質には期待するなとあれほど（ry

だからghcにバグはないとあれほど（ry

>>497
Haskellよく知らんけど、合ってるんじゃん？
C++のテンプレートは展開してからチェックするので、いらないんでしょ。たぶん。

>>463
>たぶんlazyな言語に対して割り込みのformal semanticsを与えた人はいないと思う。
>もの凄く難しい

Haskellよく知らんので何か勘違いしてるかもしれんが、

http://research.microsoft.com/Users/simonpj/Papers/papers.html

のA semantics for imprecise exceptionsの5.1節とか
Imprecise Exceptions, Co-Inductivelyは違うの？

Haskellで正規表現は標準でサポートされているのですか?

>>507
http://www.google.co.jp/search?hl=ja&q=Haskell+regex&lr=

>>501
３月２１日位にインストーラーが変わっている様なのですが、それでインストールしても
駄目ですか？
当方はXP SP2でインストールできています。

つーかインストーラーぐらいちゃんと作れませんか？

>>509
最新版でインストールもできましたし、ちゃんと動きました。
ありがとうございます。

imprecise exception 云々よりどっちかというと Asynchronous exceptions in Haskell の方が該当する希ガス。

この言語扱うのに数学の知識必須みたいだな。初めて使ったが…

そうなの？どの辺でそう感じた？

>>514
いや、大したことじゃないんだけど、集合論とか。

文系お断り言語

Text.Regex は入力を不必要に最後まで読んでくれたりして微妙に嬉しくないんだよなあ。

で、この言語なんて読むんだ？
はすくぇる？

ハスケルカリー

GHCのコンパイルがなかなか終わらない。

ひょっとして、マシンパワーがかなり必要なの?
普段使っているのはおんぼろラップトップなんだよね。

>>520
こちとら、PowerBookG4(867MHz,RAM640MB)で
2ステージ+testsuite が6〜8時間。

朝起きたら無事終わってた
GHCは普通のコンパイラとは内部構造がかなり違うようですな。

某スレでハスケルでGUIは辛いと言われてしまいました。
誰か反論の文句をおねがいします。

だからあれほどHaskellは実用アプリケーション作成向きでは無いと(小一時間

だからあれほどghcは完璧だと（ｒｙ

情処の記事を読んで触ってみた。

今月からFPの連載だね。

FP ってなんですか?

一時期流行った自分視点のゲームだろ

そりゃFPSだ。

動的計画法のことだろ？

Functional Programmingのことかと思った。

> 動的計画法のことだろ？
それはDP(dynamic programming)

わかりにくいネタでごめん

まじでどこで連載してるのか教えてくれ

情報処理学会誌ですね。
久しぶりにビニールを開けてみました。
相変わらず読むところが少ない…。

辛ければヨーグルトを使う

GHCがpanicっていってコンパイル止まったよ。
間違ったソースの中には対応しきれないものがあるようだ。

>>537
嘘はいけない。ghcにバグはない。

ghc のバグじゃなくてコンパイルするソース側の

＞嘘はいけない。ghcにバグはない。

なんか凄い事聞いた気がする。
ほんと？

ほんとにそうならghcのwebにバグレポートのリンクがあったりしないべ。

Ｆｉｎａｎｃｉａｌ　Ｐｌａｎｎｅｒ

ほんとだよ。GHC cannot process input file. please report this to us とか出たもの。
もちろんソースは正しくないやつなんだが、それでもコンパイラが適切なエラーメッセージを
出せずに止まったことは事実。

ああ、拡張機能や新機能を使うと稀に起こるよ、panic。
ちゃんと報告してあげて下さい。

例のHaskell連載って公開してるんだね
http://www.ipsj.or.jp/07editj/promenade/

ハスケル！ハスケル！

　　　 _ 　∩
　　(　ﾟ∀ﾟ)彡
　　(　 ⊂彡
　 　|　　　|　
　 　し ⌒Ｊ

LISP Macro みたいなことできますか？
-- dotimes :: n -> (n -> IO()) -> IO()
dotimes n f = __dotimes 0
where __dotimes i | i >= n = return ()
| otherwise = do (f i)
__dotimes (i + 1)
-- dotimes 10 ( \x -> putStr (show x))
こんなもの？

遅延評価だし、アクションが第一級の対象だから、
全ての関数がマクロであるようなものじゃないか？

なんかピントの外れたことを言ったな。
誰かフォローよろしく。

dotimes' n f = sequence_ [ f n' | n' <- [0..n-1] ]
main = dotimes' 10 (putStr.show)

例えばhaskellのif

if p then c else a
は、

case p of
　True -> c
　False -> a

の構文糖衣とみなせる。逆でもよい。
マクロの代わりになるかどうかは、自分のifをcaseで定義できるかどうかを
考えてみればわかる。

myif

mycase

さあどうぞ。

myif :: Bool -> a -> a -> a
myif p c a = case p of True -> c; False -> a

でいいんじゃないのか？

>>553
thenとかelseはどこいった？

シンタックスを定義できなてもマクロと言えると思うが。

↑それで消費者が納得すると思ってんのか？

>>555
関数マクロと言うべきか。


>>548の回答としては、

Ｑ．LISP Macro みたいなことできますか？
Ａ．できません。

haskellでは
a `lambda` (a + 1)
の様な表現ができないのが本質的っぽいね。

つまり、遅延であろうがなかろうが、LISPのようなマクロを書けるかどうかは
引数評価を自分でコントロールできるかどうかにある。
少なくともLISPのマクロ内に出てくるシンボルみたく、引数の一部を
評価せずにキーワードそのものとして扱うみたいな仕組みがないと。

「遅延評価」の意味で「評価」と言うと意味が違うと思う。
引数の評価をコントロールするだけならhaskellでもできる。
「解釈」と言えばいいのかな？

LISPのマクロはdefineを含むコードを生成できるけど、Haskellではそのような真似はできないはず。

HaXmlで下のinputからoutputのような出力を得たいんですがどのようにすれば
良いでしょうか？

---input---
<function name='deleteBy' type='(a -> a -> Bool) -> a -> [a] -> [a]'>
<description>
similar to <f>delete</f>, but it allows the programmers to supply
their own equality test
</description>

---output---
["deleteBy", "similar to delete, but it allows the programmers to supply
their own equality test"]


<description>の中の<f>の処理がうまく行かず下のような結果になってしまい
ます。<description>の中のテキスト部分だけを抜き出したいです。別リスト
にしないで1つの文字列として。

["deleteBy", "similar to ", "delete", ", but it allows the programmers to supply
their own equality test"]

コードとサンプルデータを載せます。

import System.IO
import System.Environment
import Text.XML.HaXml
import Text.XML.HaXml.Pretty (content)

main :: IO ()
main =
do ~[arg] <- getArgs
h <- openFile arg ReadMode
str <- hGetContents h
case xmlParse "list.xml" str of
(Document _ _ (Elem _ _ contents))
-> mapM_ print $ map getCont contents

getCont = map content . contFilter

contFilter :: CFilter
contFilter = f `o` (tag "function")

f = cat [ ("name"?) , multi txt `o` (keep /> tag "description") ]

<module name="List">

<function name='deleteBy' type='(a -> a -> Bool) -> a -> [a] -> [a]'>
<description>
similar to <f>delete</f>, but it allows the programmers to supply their own equality test
</description>
<example>
<in>deleteBy (\x y -> y `mod` x == 0) 4 [6,8,10,12]</in>
<out>[6,10,12]</out>
</example>
</function>

</module>

今月の文章は先月の和田先生のよりわかりにくいなあ。
例題をどう解くかの説明が全くなくて、説明もHaskellの説明にはなってるけど
例題のプログラムの説明としてはかなり端折られてるのが原因かな。

バイナリファイルを弄りたいんですけど
Haskellでビット演算の関数とか演算子とか
あれば教えてください。

:browse Bits

>>567
ありがとうっす

モナドって全然わかない

↑日本語もわかない人

最近自分は悟った。

モノイドとか圏論とかの背景思想を無視して
使う立場だけからいうと
モナドは数珠繋ぎ強制ギプスみたいなものだと。

(IO Char)とか(IO Int)とかの型は
CharやIntの値がくるまれたカプセルみたいなもんだ。
ちなみにIO ()の()はCでいうvoid型
return xx とやると普通の値もIOモナドで包むことができる。

ただしIOモナドは一度くるんだら中身を取り出す方法がない。
IO型の関数を普通の関数と組み合わせても型違いで
コンパイルエラーになる。
(IO ()ももちろん型違いでエラー）

そこでモナドの中身の値を
橋渡しするアダプタ(>>=)を使う。

結局>>=や>>で(IO ｘｘｘ)型の関数同士やreturn xxで
数珠繋ぎにするしかないように強制される。

そいつは面倒だあ

IOモナドってGPLみたいだなとか思った。

数珠つなぎのしくみや値を包みこむ性質を利用して
他にもいろいろなモナドがあるし自分でも作れる（かもしれない）

Stateモナドは数珠繋ぎを利用して
IOモナドみたいな状態遷移を自分で作れる。

Maybeモナドは値を包むほうが主眼のモナド
実際の値の代わりにNothingというダミーを
突っ込んでおくことができる。
データベースのNULL値みたいに使える。

モナドと聞くと王監督の顔が思い浮かぶのは何故？

>>571
>CharやIntの値がくるまれたカプセルみたいなもんだ。
俺にはこの表現がなじまない。
カプセルってのは中身が取り出せてこそのものだよな。
だから、「CharやIntにに関係する何か」くらいの認識しかできない。

自分でIO型の関数作れば
前のIO関数から>>=で渡された
中身の生の値をちゃんと自由に扱える。

「取り出す方法が無い」んじゃなくて
「>>=を使って（間接的に）取り出すしか方法が無い」が
正しいかも。

monadic I/Oの意味論を破壊して喜ぶって、マゾですか？

そーゆーのには、
C言語とアセンブラがお勧め(w

>576
ﾜﾛｽ
俺も思いついた

もな〜ももなど？

>>549
そのとおりだよね。

>>583
だからー、
その件はLISPマクロのようには書けないって話だろーが

>>559
名前渡し？遅延評価ってそういうことなのでは？

名前をキーワードとして扱う？CLtL4の仕様ですか？ｗ

某バイナリファイルのヘッダ構造体の読み込み関数が
だいたい目処がたってきますた。

ところでdata宣言で作った構造体？にたいする
Javaのシリアライズみたいな仕組みやライブラリって
Haskellにはないんすかね？
リフレクションみたいな仕組みがないと無理？

ファイルフォーマットをリストで与えて結果もリストで返すみたいなのは
できそうだけどそれじゃせっかくの強力な型システムが活かせないような、、

>>585
あ、違うか
名前渡してないもんね
普通の意味の値の他に名前も値にできるようでないと圏論的には不完全なようなキガス

とゆーことは変数のポインタでいいのかどうか

＞圏論的には不完全

というと？

ちょっと質問です。

二項関係 r の反射的・対称的・推移的閉包に (x,y) が属するかどうかを判定する関数
inEqvCl ってのを書いてみたんですけど、もうちょっとすっきりした書き方とかないでしょうか？

inEqvCl :: Eq a => (a,a) -> [(a,a)] -> Bool
inEqvCl _ [] = False
inEqvCl (x,y) s = chk s y x
　where
　　chk lst v u | v == u = True
　　　　　　　　| v `elem` ux = True
　　　　　　　　| otherwise = or $ map (chk lst' v) ux
　　　where
　　　　lst' = [ p | p <- lst, u /= fst p, u /= snd p ]
　　　　ux = do p <- lst
　　　　　　　　if u == fst p && u /= snd p
　　　　　　　　　 then return $ snd p
　　　　　　　　　 else if u == snd p && u /= fst p
　　　　　　　　　　　　then return $ fst p
　　　　　　　　　　　　else fail ""

実行例
(2,1) `inEqvCl` [(0,2),(3,4),(5,4),(1,5),(5,0),(6,7),(8,7)]
=> True
(1,6) `inEqvCl` [(0,2),(3,4),(5,4),(1,5),(5,0),(6,7),(8,7)]
=> False

>>591
こんなのでどうかな。
題意を理解していないので間違ってたらｽﾏｿ
import List

inEqvCl :: Eq a => (a, a) -> [(a, a)] -> Bool
inEqvCl _ [] = False
inEqvCl (x, y) s
  | x == y = True
  | y `elem` ns = True
  | otherwise = any con ns
  where
    ns = map snd $ filter ((==x) . fst)  exts
    exts = s ++ map (uncurry $ flip (,)) s
    con n = inEqvCl (n, y) (s\\[(x, n), (n, x)])

面白そうなのでオレもやってみた。

-- 同値類のリストを算出
classify :: Eq a => (a, a) -> [[a]] -> [[a]]
classify (x, y) [] = [[x, y]]
classify (x, y) (c : cs)
| x `elem` c = (y : c) : cs
| y `elem` c = (x : c) : cs
| otherwise = c : classify (x, y) cs

inEqvCl :: Eq a => (a, a) -> [(a, a)] -> Bool
inEqvCl (x, y) lis = (not . null) (filter (f x y) (foldr classify [] lis))
where f x y c = x `elem` c && y `elem` c

いろいろ最適化の余地があるが。

あ、>>593 間違ってるわ。これだと [(3, 4), (1, 3), (2, 4)] とかで
うまくいかない。

>>592-594

ありがとうございます。
やっぱり短く書けるんですね。

無限のリストだと止まらなくなるかな

PolyGP: A Polymorphic Genetic Programming System in Haskell
↑のプログラムソース PolyGP.tar って、uclのサイトから消えている様ですが、
どこかにバックアップないでしょうか?
よろしく、おながいします。

とりあえず問題が2つありました。

1. 反射的閉包なんで、inEqvCl (x,x) [] == Trueにならないといけない。

>>592さんのからinEqvCl _ [] = Falseを取り除けばOK。

2. (\\)は最初の1つしか取り除かないので、最初の集合に対称なものがあると拙い。

(\\)の代わりに下の(//)を使って対処。

(//) :: Eq a => [a] -> [a] -> [a]
xs // ys = [ x | x <- xs, x `notElem` ys ]


>>596
無限リストは今回は対象外なので問題ないです。(^^;

Haskellの配列の更新(//)は一部変更でも配列全部作り直したり
してるんですか？
リングバッファとかに使っても大丈夫ですか？

600

>>599
自己レス
ttp://d.hatena.ne.jp/tanakh/20040809#p1
ここみるとだめっぽい感じでした

GCが仕事してくれること期待して
配列ガシガシ使い捨てにでもするか

いつまでたっても関数型のボトルネックだな＞配列・構造体
これが解決しない限り関数型が栄えることは無い

俺達でwadlerを唸らせる解を考えよう

配列も、マクロな視点で見ればただの変数に変わりない
だから、修正された瞬間複製するのが妥当な戦略だろう
しかし、オリジナルが参照されないとわかっているなら複製する必要ないから複製を省略する。
ここまで考えてふと思いついた。
すなわち差分をもっとけばいいんじゃないかと。
配列n番目更新しますた！更新しますた！という情報を各インデクス毎に持っとくわけよ
配列を全て更新しおわたとしても、またさらに更新するかもしれない
その場合はまたその差分を作るわけよ
するとどうだい？
差分として分解された各配列の要素はまるでりすｔ(ry

おれには難しすぎたようだ！

>>602
Uniqueness Typing

配列や構造体もモナドにしたら？

starray とかいうモナドがあると聞いたが
漏れは調べてないので諸君調べて報告してくれ

マクド

>>606
つIOUArray

伝説のモナド

ナボナ＠亀屋万年堂
http://www.navona.co.jp/

これのことでしょ？

>>607
それはスタレイました

>>28で紹介されているhttp://rrr.jin.gr.jp/のRWikiがNot Foundで見れません。

どうしたらよかとですか？

自己解決しました。
://pub.cozmixng.org/~the-rwiki/rw-cgi.rb にありました。

ハスケルを勉強したい時にはどうしたらいいですか？
日本語の丁寧なチュートリアル文献がありますか？
>>1のは難しいですよ

>>615
1. haskellで適当なコードを書く
2. -ddump-realCをつけてコンパイル
3. 1と2の結果を見比べる

>>615
ttp://www.geocities.jp/shido_takafumi/hs/index_hs.html
とか。

>>616
これなかなか良いね。

>>615
http://www.sampou.org/cgi-bin/haskell.cgi?Programming%3aWayToHaskeller&l=jp
とかはどう？

>>616
Cに落とさなくてもcore言語レベルでいいんじゃない？

mona do !

monadius

Hugsなんだけど

Main> -1 ってやると
-1

Main> ( - 1) 2 とやると

ERROR - Unresolved overloading
*** Type : (Num a, Num (a -> b)) => b
*** Expression : fromInt (-1) 2

　んん？(-) は単項演算子なのか！？


しかしMain> ( - ) 1 2 とやると
-1 とかえってくる。

(-)は二項演算子ってことになってるんじゃなかったのか！？

http://www.sampou.org/haskell/tutorial-j/numbers.html
>negate は Haskell では唯一採用された前置演算子です。
>これを (-) と書くことはできません。
>それは、こう書けば、減算関数になってしまうからです。

どうなってるの？＞識者の方々

-1
(- 1)
(- 1) 2
の - はnegateのことで単項演算子

(-) 1 2
((-) 1) 2
(1 -) 2
1 - 2
の - は二項演算子

>>624
それって上の引用の記述と矛盾してないかって事。

HugsはHaskell98モードでも再現したよ。
上の記述が古いのかHugsの独自仕様なのか、、、

実際-1と書けたほうが便利だけどね。

一瞬
「(\x -> x - 1) を 自動的に -1 に変換してるのかHaskell凄えな」

と思ったけど
型が全然違うし。

括弧のついてない - はその直前に第1引数になるものがなければ単項演算子として解釈されるってだけなんじゃないの。

>>623
原文は
>negate is the function applied by Haskell's only prefix operator, minus; we can't call it (-), because ...
だから、誤訳かと。
一応報告しておいた。

>>625
>それって上の引用の記述と矛盾してないかって事。

どこが？

誤訳なのか？　"minus"が抜け落ちてるけど大意は変わらない気がするが。
単にセクションと単項のマイナスが構文上区別できなくて、その場合は単項マイナスの方を優先するってだけの話じゃん。
http://www.sampou.org/haskell/report-j/exps.html#sections
より
> - は文法上、特別扱いで、(- exp) はセクションではなく、前節で説明したように前置の符号反転演算子の適用である。

誤訳か誤読かはともかく納得しますた。
これから安心して-1って書けるよ

最近すげぇ低レベルの話題ばっかなのは、
やっぱ新入生？？

ヒント：ネタ切れ

レベル低くてゴメンよ
配列の更新についてネタ振ったのも自分

学生じゃないけど
最近Haskellに挑戦してるのさ
初心に帰って楽しい。
ところでソースアップできるところないすか

>>629
>>623の表現だと単項マイナスが存在しないように読めるから、誤訳といっていいと思う。

33 名前： 名無しさん＠毎日が日曜日 Mail： 投稿日： 05/06/03 21:46:40 ID： M3Iswrux

type Dame = Human

jobHunting :: Dame -> [Company] -> Maybe Future
jobHunting _ [] = Nothing
jobHunting d (c:cs)
　| hasShokureki d = Just Saiyou
　| (age d) < 25 = Just Saiyou
　| otherwise = jobHunting d cs

>>602
そんな貴方に APLやJやKはいかが?
関数型言語スレで話題になってたと思うが、過去ログ倉庫入りかも。

APLやJやKは、関数型言語の源流というだけで、今更な言語。
APL挙げるくらいなら、KRCやFを挙げるよな、まともな人間なら。

Lisp -> ML -> Haskell ってながれじゃないの？

？
現在の関数型言語ブームの源流は、
Fortran、BNF、1977年チューリング賞受賞者John BackusのFL(F言語)
で　　す　　が　　何　　か　　？

い　い　え　何　も　？

Ｃ＋＋　　→　くそ
Ｃ　　　　　→　くそ
Ｊａｖａ 　 　→　くそ
Ｆｏｒｔｒａｎ　→　くそ
ＭＬ　　　　→　ゴミ
Ｈａｓｋｅｌｌ　→　ゴミ
Ｏｃａｍｌ　 →　クズ
Ｒｕｂｙ　　 →　クズ
Ｌｉｓｐ　　　→　クズ
Forth　　 →　クズ
λ-Ｃａｌ　　 →　アホ
π-Ｃａｌ　　 →　アホ
μ-Ｃａｌ　　 →　アホ
φ-Ｃａｌ　　 →　アホ

ｺﾋﾟﾍﾟうざ

>>637
関数型言語の源流というよりは、配列計算言語の源流でわ?
SとかRとか(SASとかSPSSとか)、影響うけてるでそ?

>>現在の関数型言語ブーム
え、今、ブ、ブームなんですか......　よい時代に生まれたことを感謝します。

空前のブームのため、Haskellプログラマは企業から引っ張りだこです。

>>645

　　 ／￣￣￣￣￣ ミ
　 /　　 ,――――-ミ
　/　　／　 ／　　 ＼ |
　|　 /　　　,（･）　（･） |
　 (6　　　　　　 つ　　|
　 |　　　　　　＿＿_　 |　　 ／￣￣￣￣￣￣￣￣￣￣
　 | 　　　　 /＿＿/ ／　 ＜ なわけねーだろ！！
／|　　　　　　　　 ／＼　　 ＼＿＿＿＿＿＿＿＿＿＿

とりあえずLha展開関数動いたよ。
http://www3.atwiki.jp/nanakoso/pages/4.html

だれかモナドを２つ以上同時に使う方法教えて下さい。

>>647
モナド変換子で合ってる。

http://www.sampou.org/haskell/a-a-monads/html/transformers.html
やっぱりこの辺りは避けて通れませんか。

モナドをやっつけたと思ったらまた難物が、、、

ええっと、haskellよりmathematicaの方が有能だしいいのでは関数型として？

放置。

Haskellで数式処理システム作ろう！とかいう噺があったやうな…?

>>649
こんどはＣＩＡか？

いや、FBIです

649>>http://haskell.org/hawiki/MonadTransformersに簡単なつかいかたとかあるよ。がんばれ!

WinXPにHugsを導入したんですけど、読み込みまでは行くみたいなんですけど
実行してみると結果が表示されません。
例えば
myfactorial :: Int -> Int
myfactorial n
| n == 0 = 1
| otherwise = n * myfactorial (n-1)
というファイルを読み込んで
myfactorial 5
と入力しても何も結果が表示されずに
Main>
という状態に戻ってしまいます。何か原因があるのでしょうか。

XPでやってみたところ、GUIのやつ(WinHugs)が駄目なようです。
オプションあたりが怪しいけどｻﾊﾟｰﾘ

ghcでControl.Monad.Readerをインポートすると
Monad ((->) r)のインスタンス宣言（中味はReaderと同じ）が
付いてくるっぽいんだが、いったいこれは何なんだ？
かなり便利だから積極的に使いたい気もするけど、
ドキュメントされてないみたいだし。

import Control.Monad.Reader

-- 3で割れて、かつ5で割れない自然数
t = filter (liftM2 (&&) ((==0) . (`mod`3)) ((/=0) . (`mod`5))) [0..]

Vital 使ってる人居ます？
http://www.cs.kent.ac.uk/projects/vital/

I/Oをマクロは解決しないか

FpLの抽象構文を拡張して、利用者定義関数が算術式と論理式とを混在してとることができるようにするにはどうすればよろしいですか？評価意味論を適当に拡張するらしいのですが・・・

名前呼びを用いると、ある式eに対してD,ρ├ e ⇒ A ｋとなる数字ｋが存在するけれども、値呼びを用いると、D,ρ├ e ⇒ A ｋとなる数字が存在しない宣言の例ってありますか？

まず元ねたを書け。話はそれから。

圏論の基礎　日本語訳　S.マックレーン
http://www.amazon.co.jp/exec/obidos/ASIN/4431708723/qid=1121765296/sr=8-1/ref=sr_8_xs_ap_i1_xgl/250-1176990-6892214

"Catefories for Working Mathematician" (働く数学屋のための圏論)　の題名が
「圏論の基礎」になっちまうんだとしたら、

"Categories, Types, and Structures: An Introduction to Category Theory for the Working Computer Scientist (Foundations of Computing Series)"
の題名はどーなるんだ？
「一週間で判る！くもんしきけんろん (いちねんせいむけ)」か(笑

>>664
買っちゃった。

>>666
でどうよ？

>>665
"Basic Category Theory for Computer Scientists (Foundations of Computing)"
「圏論の超基礎」つうのもある・・・

"Categorical Logic and Type Theory (Studies in Logic and the Foundations of Mathematics)"
「論理＆数学ラブ♥な人のための、カテゴリー・ロジックと型理論」
なんつう分厚い数学書も買うには買ったけど、これは完全に死蔵本だな、たぶん。

ってな意味で、いきなり訳書を読めるアンタ(>>666)、
幸せ者だぞｺﾞﾗｧ！！！

>>667
誤植が多いみたい。

誤訳じゃなくて誤植ってのが泣けるね。

「できる圏論」

モノイダル圏とか分からない件

http://www.sampou.org/haskell/tutorial-j/goodies.html
暇だからこれ読んでたんだが、ユーザ定義型のデータ構築子と型構築子の意味が分らん。
誰かなんかC,C++の似たような概念の用語で分りやすい説明キボンヌ。

データ構築子 <=> classのコンストラクタ
型構築子 <=> template

型構築子はtypedefでは？

typedef は多相(総称？)型の定義ができんでしょ。

CやC++でプリミティブと言われてる型は、Haskellでは全て列挙型
という見方をするの？

data Int = -65332 | ... | -1 | 0 | 1 | ... | 65332
という例が載ってるけど、こんな感じに、
新たに型を作る。作られる型がデータ構築子
そのときに型のデータのインスタンスを列挙する。列挙されるのがデータ構築子。

こんな感じでいいのかな？頭悪くてすいませんねｗ

×新たに型を作る。作られる型がデータ構築子
○新たに型を作る。作られる型が型構築子

しかし新たに型を定義する式のためのキーワードがdataで、
Cのtypedef風なものにtypeが使われてるのはなんかちょっと違和感あるというか。
typeはいいとして、なんでdataなの？

>>680
データ型宣言だから、では駄目かい？

>>681
厨房臭いんですが、dataってのは納得できないですね。
それはまあいいとして、このスレはちょっとレベルが違いすぎるので、
初心者はこっちで質問することにしました。どうもです。

関数型言語Part IV
http://pc8.2ch.net/test/read.cgi/tech/1083649982/

言語に特有の質問なんだから、このスレのほうがいいんじゃないか？

SMLはtype synonym宣言に'type'、データ型宣言に'datatype'を使う。
Haskellはそいつを参考にしたが、'datatype'は長いので'data'にした。
というのも考えられるかも。

OCamlなら全部typeで済ませられるぞ(逆に言うと宣言の見掛け上区別できない)。

Peyton Jonesの本が面白すぎて夜も眠れません。

HaskellからCleanに宗派変えてみる。

ここでは、こういうネタはスレ違い？
http://www.geocities.jp/takascience/windows/monadius.html

本家からもリンクされてる。
Monadius
A shoot 'em up game using OpenGL. Takayuki Muranushi also wrote a couple of other games in Haskell.
http://www.haskell.org/practice.html

_|_って何から来てるんですか？
数学？

>>689
うん

どの分野か教えてもらえますか？これも圏論？

越田先生＠東京工科大のレジュメ http://www.teu.ac.jp/kougi/koshida/Prog6/

ってのは、今はどこで見れるの？

http://www.teu.ac.jp/10/002921.html
もう読めないのかも。Internet archiveにはあるか？

>>693
亡くなられたのか……まだ若いのに。

プログラム工学VI 授業関連資料
http://web.archive.org/web/20031014180912/http://www.teu.ac.jp/kougi/koshida/Prog6/index.html

>>693
うへー、マジカヨ。
ご冥福をお祈りいたします。

貴重な(ry

この人のチュートリアルをどこかにページにそのままうｐしたらまずいのかな？
需要はかなりあると思うのだが。

それより誰かが成書に仕上げて印税が遺族に行くようにできるとよいな。

おいおい越田先生、死んだのかよ。面識なんてもちろんないけど
チュートリアル何度も読んでたから、泣けてくるじゃネーか
合掌(-人-)

>>693
ひさしぶりに覗いたら悲しい知らせが。
南無。　そしてありがとう。

http://mono.kmc.gr.jp/~oxy/hiki.cgi?rtype

Ruby 2.0 勝手に実装してくれよ

実装できるほどの仕様が決っていないのでは?

ここでPugsの話題が出ないのが謎
本家よりずっと先にリリースって、すげーと思わない？

すげー過疎

とりあえずVersion 6.4.1リリースage

引数のパターンマッチング
guard
if-then-else
case-of

って基本的には同じですか？

引数のパターンマッチングと case-of はほとんど同じと考えてよい。
if とパターンマッチは違う。

パターンマッチには真理値で条件を与えることができる。これはガード部とか
言われる。 guard がそのことを指して書いたのであれば、 if と似ていると
は言えるかもしれない。

guard 関数はぜんぜんまったく関係ない。

if b then t else f
は
case b of {
  True -> t;
  False -> f;
}
の省略記法。この意味では同じといえると思う。

その4つは束縛変数を導入できるかという点で区別することもできるね。

ここにいる奴って、普段何してるんだよ

haskellでオナニーできてるか？

昨日STGで2回…

monadﾀｿ(;´Д`)ﾊｧﾊｧ

★〜彼方の願い星〜★
このレスを見た人は、超ラッキーな人♪
でも、このレスを見ただけじゃ何も起らないよ。
効果を実感したいなら、このレスを５回違うスレにレスしてね♪
だぁい好きなあの人に告られたり、
成績がどんどん良くな★〜彼方の願い星〜★
このレスを見た人は、超ラッキーな人♪
でも、このレスを見ただけじゃ何も起らないよ。
効果を実感したいなら、このレスを５回違うスレにレスしてね♪
だぁい好きなあの人に告られたり、
成績がどんどん良くなって、先生に褒められちゃったり．．．。
次々とＨＡＰＰＹな事が訪れます♪
此の頃変なのがいっぱい回★〜彼方の願い星〜★
このレスを見た人は、超ラッキーな人♪
でも、このレスを見ただけじゃ何も起らないよ。
効果を実感したいなら、このレスを５回違うスレにレスしてね♪
だぁい好きなあの人に告られたり、
成績がどんどん良くなって、先生に褒められちゃったり．．．。
次々とＨＡＰＰＹな事が訪れます♪
此の頃変なのがいっぱい回っ★〜彼方の願い星〜★
このレスを見た人は、超ラッキーな人♪
でも、このレスを見ただけじゃ何も起らないよ。
効果を実感したいなら、このレスを５回違うスレにレスしてね♪
だ
これが本物の、初代ＨＡＰＰＹメールです♪ってますが、これは本当です!!
これが本物の、初代ＨＡＰＰＹメールです♪って、先生に褒められちゃったり．．．。
次々とＨＡＰＰＹな事が訪れます♪
此の頃変なのがいっぱい回ってますが、これは本当です!!
これが本物の、初代ＨＡＰＰＹメールです♪

Emacsのハスケルモ〜ドって使いにくくないですか?
特にインデントが何回も叩かないと希望の位置にこない。

haskell-mode、出来はすごく良いと思うけど。
インデントはすくなくとも手で揃えるより楽だし、ローテートしてくれるのは良いよ。
関数定義も補完してくれるし。
ただcase 〜 of のインデント位置のポリシーだけは気にいらないな。あれは of の前で改行することを想定しているのだろうか。

そうですか。もうちょっと頑張って使い込んでみます。
あと、M-x turn-on-haskell-hugs して C-c C-l するとEmacsが固まって
C-g打つまで帰ってこなくなるんですが、何か設定が必要なのでしょうか?
Hugs.Base>
というプロンプトで一回 :load して、プロンプトが
Main>
になった後はすんなり動くんですが。

Emacsのバージョンは21.3です。

Haskell-modeは優秀だと思う。

>716
そういう症状は体験したことがないなあ。自分はおおむね
http://www.haskell.org/haskell-mode/installation-guide.html
のように設定している。
でも最近はもっぱら ghci で hugs を使ってませんねぇ。

716ですが原因を特定しました。

私の環境ではhugsを起動した直後のプロンプトは
Hugs.Base>
なのですが、huskell-hugs-start-processでcomint-prompt-regexpに設定する
パターンが"^\? \\|^[A-Z][_a-zA-Z0-9]*> "となっていて
ドットを含まないためのようです。これを修正すると問題は解消しました。
(せめてdefvarしていて欲しかった……)

hugsもhaskell-mode.elもFreeBSDのportsで入れたのですが、みなさんの
hugsではプロンプトは別の文字列なのでしょうか?

>719
少し前(200311_1)には
Prelude>
だったが、今は確かに
Hugs.Base>
になってるね。

Haskell 使おうっと思ってんだけど、サンプルプログラムがなきゃ分からん。

いきなり Pugs, Rtype, Monadius だと手ごわすぎるので、もうちょい下のレベルで、
おすすめを教えて頂戴。

ウェブアプリを作ることがほとんどなので、Wiki, Blog(Diary), BBS 辺りが理想なんだけど。

>>721
俺は特に何かをお薦めする程わかっちゃいないが、取り合えず
http://www.haskell.org/practice.html
を紹介しとく。

>>722
さんきゅ。

とりあえず、

Flippi: a Wiki clone written in Haskell
http://www.flippac.org/projects/flippi/

でも見てみるよ。

「連載: Haskellプログラミング」のメモ化のところがよーわからん。
State s t、withState、bindStateのところで詰まってしまった。
誰か日本語でわかりやすく説明して!

Stateモナドの知識がないと難解だと思う。

type State s t = s -> (t, s)
というのは、現在の状態を受け取って新しい状態とさらに何かを返す関数。
だから、State s t型の値を「状態を変更してついでに値を生み出す仕掛け」と見ることができる。
ここで、「状態を変更せずに常に決められた値xを生み出す仕掛け」は

\state -> (x, state)

と書ける。これがwithState x。
一方、「起動されたとき仕掛けxと仕掛けyが順に起動されたかのように振る舞う仕掛けthenState x y」は
次のように定義できる。

thenState :: State s a -> State s b -> State s b
thenState x y = \s0 ->
  let (_, s1) = x s0 in -- xに初期状態s0を与えて起動、中間状態s1を得る。xによって生成された値は無視。
  y s1 -- yに中間状態s1を与えて起動、終状態と値の組を得る。これはそのまま合成されたしかけの戻り値となる。

thenStateではxによって生成された値を無視したが、この値に基づいて
次に何をするか決めることができないと面白くない。そこで、yとして単なる仕掛けではなく、
「xによって生成された値を受け取って仕掛けを返す関数」を渡すことにする。

bindState :: State s a -> (a -> State s b) -> State s b
bindState x y = \s0 ->
  let (result, s1) = x s0 in -- xを起動し…
  (y result) s1 -- …次に(y result)を起動

すごくわかりやすい! あなたとても賢いね。
どうもありがとうございました。

State s t を状態遷移図での状態aから状態bへの矢印とイメージしました。
withState x は、状態遷移図で状態aから同じ状態aへ戻る矢印(出力x)ですね。

Haskell はなかなか自分の思い通りにかけるようにならない orz

Cとかと違ってプログラマのほうに能力がないと何もできんよな……

Haskellで書くとバグがなくなると聞いたんですが本当ですか？

バグは出にくいが慣れないうちは普通にコンパイルを通すだけで苦労する。

>>729
俺も最初はランタイムエラーは絶対出ないものと思ってたけど
guardとかの場合わけ漏れとか
パターンマッチの不整合エラーがたまにある、、、

ぬるぽとかと比べて感覚的に頻度少ないけどね。

>>729
いいえ

整数をゼロで割ると実行時エラーになるし。

完全でないパターンマッチは、ghcなら警告を出させることもできるから、
あとはプログラマの問題という気がするが。

「連載: Haskellプログラミング」の9月号分を読んで
なんとなく理解したところでは
Haskellで評価の順序を強制するためにはCPSのように書くことが必要で、
Monadは継続に付加情報を(連続的にというか玉突き的にというか)持ち回る道具、
do構文はそれを手続き型のように書く構文、
というところだろうか?

Monadは全てを記号論的に処理する枠組み
doは状態遷移を隠蔽するモナド関数
で合ってる？

>>734
Stateモナドについてならその理解でいいと思う。
ただし、モナドの意味論は個々のモナドでかわる。モナドそのものは
「do記法で書くことのできるひとまとまりの計算の構成を支援するもの」くらいではないかな。
たとえばIOモナドは副作用が存在しうるような場合の計算の順序の保証する。
Maybeモナドは途中でNothingになるかもしれない計算のまとまりを構成する。
などなど。

あとは「モナドのすべて」を読むといいと思うよ。
http://www.sampou.org/haskell/a-a-monads/html/index.html

　 　 　 /＼
　 　 ／　 　＼　　今このとき,モナドは立ち上がる
　　 /∧＿∧　＼　　　　
　／（　´∀｀）　 /＼
　＼（　　　　） ／　　＼ 　　　
　　 ＼ 　　　/ 　 　 　 ＼
　　　　＼／ 　 　　 　　　＼
　　　　　　　　　 ∧∧∧∧＼
　　　　　　　　　（　 ´／）　））ヽ∧
　　　　　　　　 ／ 　 ／　　/ ´∀） ∧∧
　　　　　　 ○(　　 ｲ○　 （　　　,つ, ,ﾟДﾟ) 　
　　　　　　　／ヽ　 )） ヽ　 )ヽ　)と　　, ｲ
　　　　　　 （_／（_/(_／（_/ﾉ（_/⊂ﾉ> )Ｊ
　　　／￣Y￣｀|/￣＾Y￣ヽ/￣￣Y

純粋関数型言語を業務で使ってみたい。

ぜひ使ってくれ

あなたの業務が研究・教育ならいくらでも…

hasktags って使える？
誰か、 GHCmacs でも作ってくえ。

行列をhaskellで実装する場合、単位元ってモナドで表現する？

連載　Hakellプログラミングの８月号にのってる
両替問題の最初でつまづいてしまいました。

cc ::Amount -> [Coin] -> Count
という関数を
a < 0でないとき
cc a (c:cs) = cc (a-c) (c:cs) + cc a cs
と定義してますが、なぜこれで指定した金額aの両替の組み合わせ個数になるんですか？

初歩的な質問で済みませんが教えてください。

>>743
貨幣cを一つ以上使う場合の数は、cを一つ使った後の両替を考えて、cc (a-c) (c:cs)
貨幣cを一つも使わない場合の数は、cc a cs
この和が求めるものになる。

>>744
なるほど。
うまく考えるものですね。
ありがとうございました。

簡単な例を作るといいよ
10円 を 5円 と 1円 で両替して樹形図を書く

高校でやったろ? 順列と組み合わせ。

>>747
お前がいまやってるんだろ？ww

母関数を使えば簡単に計算できるのに

>>748
今頃やってるとしたら遅すぎると思うんだが。
夏頃やってたような。昔の記憶だが。

>>749
母関数から特定の項を取り出す手間とボトムアップに解を構成する手間はいっしょ

>>751
母関数から特定の項を取り出すのは紙と鉛筆で簡単にできるでしょ。
わざわざプログラムなんて書く必要もない。

>>752
詳しく頼む。

俺は Polya の本にその母関数の一般項の計算には DP を使うと書いてあったので、無理だと思ってたんだが。

>>753
組み合わせ論の入門書やConcrete Mathに出てるようなんじゃだめなの？

>>754
Concrete Math の p.331 から 2 ページくらいで計算されてるやつ？

この例の最初のところに「一般の効果の場合に計算するのはとても難しい」とあるし，
その下で計算されてる {1, 5, 10, 25, 50} の特殊例においても「trick」と称される
計算をしないといけないし，さらに，最終結果に残ってる A_k は多項式を実際に展開しないと求まらない．

というわけで，これは一般性が無いという意味で >>744 が母函数から簡単に出るという
説明にはなってないし，特殊例を含めても >>752 の「簡単」ってのはどうかと思う．


コレじゃないならポインタください．

Haskellのデータ構築子が非正格なのは便利なんだけど、
一般の関数が非正格で嬉しいことってある？
デフォルトで正格でも良いような気がするんだが。

以下の二つが大きいそうだ
・相等性についての議論が楽になる(単純に置換するだけでOK)．
・制御構造を自分で設計できる．
　cond p x y | p         = x
　           | otherwise = y           
　recip x = cond (x == 0) 0 (1/x)
　は正格なら recip 0 = bot, 非正格なら recip 0 = 0．

>>757
反応ありがとう。

>・相等性についての議論が楽になる(単純に置換するだけでOK)．
なるほど。気付かなかった。
でも、現状だとIntのaccumulator引数付きのちょっとした末尾再帰関数なんかを書くたびに
明示的に正格評価を指定しないとパフォーマンスに打撃があるわけで、
「議論が楽になる」って利点はこのコストに見合うんだろうか。

…などと思うのは俺が言語を使うだけの立場だからかな。

>・制御構造を自分で設計できる．
これはどちらかというと特殊なケースだから、非正格をデフォルトにする理由としては弱いと思う。

もともとは研究者の研究者による研究者のための言語だから、
コストパフォーマンスより性質を重視してるんじゃない？
ていうか、非正格の言語を統一する目的で作られた言語だしね。

正格がデフォルトの言語はMLを始めすでにいっぱいあるから
そっちを使ったらどうかな。

>>758
俺は前者も後者も重要と思ってるんだけどね。まあとりあえず前者について少し強く推しておく。

「three x = 3 」 と定義したときに、「 2 + three x == 5 」 が成立するかどうかを判定することを考える。
これを非正格に評価するとthree x を単純に 3 に置き換えて 2 + 3 == 5 にして、成立する、と結論が出るんだけど、
正格評価だと、x が絶対 bot にならないなら成立、そうでないなら不成立、というようにドメインまで考えないと駄目になる。

特に函数が複雑に組み合わさってる場合に、どこかで bot になる可能性があるとかそういうことを考えるのはしんどいし、
上の函数でもそうだけど、 bot 以外で成立、とかいうのは本質的に成立にしちゃったほうが有意なケースが多いんだわ。

相等性？(0.6 + 0.000000000000000041) == 0.6
浮動小数は代数的ではないとはいえ、言語的にこれでいいでしょうか？

>>756
バックトラックが、普通に全数探索するようなコードを書くだけで実装できてしまうとことか。

どうでもいいこと。

>>757
> 　recip x = cond (x == 0) 0 (1/x)

(x == 0) ? 0 : (1/x)

ちゃんとしたコンパイラなら動くきがす。

え、だから？
煽りじゃなく本気で意味がわからん。

Hugs.Base> let n Ｃ r = product [n-r+1..n] `div` product [1..r] in 5 Ｃ 3
10

なんとなくtak関数を書いてみたらCより速くてびっくりした。
thunkの絡まない計算は速いんだな。

Cのコンパイラオプションは？

>>767
-O2。
言われて気づいたけど、-O2 -fomit-frame-pointerとしたらCの方が速かった。

haskellには実行速度を求めないで美しいライブラリを書いて欲しいんだよね。

Cとかと違って本質的な速度向上がありうるしね．
簡単な記述のほうがプログラム変換に持ち込みやすいし．

贅沢を言うが、美しいコードが速いコードにコンパイルされて欲しい。
fac n = product [1..n]が末尾再帰のfacと同等なコードにコンパイルされる日は
来るんだろうか…

つ Clean (速いコード)
import StdEnv, BigInt
factB :: Int -> BigInt
factB n = foldr (\x y =y *% x) one [1..n]
//factB n = foldr (%*) one [1..n] // %* がないから

>>771
product は foldl で書けてるわけだから，もう末尾再帰になってると思うが．

乗算が全部遅延されるから末尾再帰の意味があんまりない。

コンパイラが正格性解析して最適化するから問題無し。

>>772
多倍長演算に時間をとられる階乗は例が悪かったかも。
興味があったのは、リストを作って壊すオーバーヘッドをなくすような最適化。

>>773
ごめん。明示的な再帰で書かれたfacのことを言いたかった。
fac = iter 1 where iter a 1 = a; iter a n = iter (a*n) (n-1)

>>774
標準 Prelude では sum とか product の fold は積極評価のオペレータを
導入して実装されてるんじゃなかったっけ．

>>776
リストを作って壊しているとは限らない．というか普通はそんなことしてない．
product n = foldl (*) 1 (take n (enumFrom 1)) で定義したとき，
product n
= foldl (*) 1 (take n (enumFrom 1))
= foldl (*) 1 (take (n-1) (enumFrom 2))
= foldl (*) 2 (take (n-2) (enumFrom 3))
...
= foldl (*) n! (take 0 (enumFrom n))
= foldl (*) n! []
= n!
みたいに評価されるから，陽に空リスト以外のリストを作る部分は無い．

>777
少し前にメーリングリストで「sumはfoldl'を使うべき」という議論があったね。
いま見直したら、議論は「可算は常にstrictと言えるか」とかいう方向にシフトしちゃってたけど。
んで、型クラスを使っている以上、+演算子が常に strict に評価可能である保証はできないので、ということで議論は終結してしまっていた。
実際、 GHC では sum とか product では普通の遅延評価版を使っているよ。

実際問題としては strict 版の sum' と product' が(Listにでも)用意されていればいいと思うんだけど。

ちなみに仕様上も、
http://www.sampou.org/haskell/report-revised-j/standard-prelude.html
foldl を使うことになっているので、仕様が変わるまでは積極評価版にはならないと考えた方がいい気がする。

>>778
そかー……．

まあ product [-10000..1] とかを一回の乗算で終わらせられる可能性があるから
戦略上絶対に悪いというわけじゃないんだろうけど癪だなあ．

>>777
>リストを作って壊しているとは限らない．というか普通はそんなことしてない．
その過程は、細かく言うと(foldlの代わりにfoldl'を使って)
...
= foldl' (*) 1 (take (n-1) (enumFrom 2))
= foldl' (*) 1 (take (n-1) (2:enumFrom (2+1))
= foldl' (*) 1 (2:take (n-2) (enumFrom (2+1)))
= foldl' (*) 2 (take (n-2) (enumFrom (2+1)))
...
のように進むから、1ステップごとにconsを作っては壊す必要があると理解してたんだけど、違う？

>>778
>実際、 GHC では sum とか product では普通の遅延評価版を使っているよ。
IntとIntegerについては正格な版が使われると明言されてる。
http://www.haskell.org//pipermail/haskell/2005-November/016727.html
といってもDoubleやWord32やRationalは遅延評価版だけど。

『ふつうの Haskell プログラミング』2005 年度内発売予定
ttp://i.loveruby.net/d/20051129.html#p01

>>781
ネ、ネタにしかみえねぇ……
マジなのか？

ふつうの人は、Haskellでプログラミングしない。

>>781
年内ではなく、年度内かよ。

ホントでたら買わせていただきます。
それよりも誰か The Craft of Functional Programming  を訳してください。英語で挫折してしまいました。

世界よ、ありがとう

出版も遅延評価で行なわれます。
宣言はされても評価はされません。

参照透明性の関係で版ごとにタイトルが違うか、IOモナドに包まれて出版されます。
後者の場合、読者もIOモナドに包まれないと読めません。

つまり必要が生じたときにその箇所だけ読まれるわけじゃなくて前から順番に読まれることが保証されているといいたいのか

読んだ知識をIOモナドの外で活用したい場合はどうしたらいいですか？

unsafePerformIO

年度内って、来年の四月までってこと？

http://i.loveruby.net/d/20051129.html#c04

12月内ってことじゃない？

出版前に査読してもらうってことだろ。

>>793
ごめん。reviewの意味を勘違いしていた。

ごめん、以下のプログラムが読み解けないです
「addの戻り値型は引数型の関数となっている、と指定している」
ということらしいのですが、誰か解説してくれまへんか

class Add a b c | a b -> c where
add :: a -> b -> c

functional dependency ってヤツだよ。
それは関数ではなくて、「aとbからcの型は一意に定まる」ことを示している。
http://www.cse.ogi.edu/~mpj/pubs/fundeps-esop2000.pdf

"100" から 100 を取り出すような関数はどうやりますか

readの作り方？

>>797
read "100" :: Int

>>798
そうです。

>>799
言葉足らずですみません。

foldl (\x y->10 * x + (ord y - ord '0')) 0

浮動小数の桁数指定で最後の桁の次を四捨五入の場合は？

何の話？

roundN :: (RealFrac a, Integral b) => a -> b -> a
roundN x n =
(frac (round (x * b))) / b
where b = 10 ^^ n
frac = fromRational . toRational

>>800
誰だ君…

>>798
そうです。

>>799
言葉足らずですいみません。

Webで以下のような定義を見かけたのですが、

data List a = Nil | Cons a (List a)

instance Eq (List a) where
Nil == Nil = True
Cons x xs == Cons y ys = xs == ys
_ == _ = False

Cons x xs == Cons y ys = xs == ys
の部分って正しいの？
このままだと (Cons 1 (Cons 2 Nil)) == (Cons 1 (Cons 3 Nil))
が True になるんだけど・・・
かといって
Cons x xs == Cons y ys = x==y && xs == ys
とかすると、最初のほうの x==y で
「add (Eq a) to the class or instance method `=='」
とか怒られるんだけど、じゃーどう定義したらよいのか
わかりまへん

>>796
ありがとうございます。まだよくわかってないですが
読んでみます。

>>806
リストという構造自体の等価性の問題ですから
中身は関係ない(というか見ちゃいけない)のです

add (Eq a) to the class or instance method `=='
とあるように，
中身の等価性まで考えようとしたら，List に格納できるデータ型
が Eq クラスのインスタンスに制限されてしまうのです．

>>797じゃないですがReadのインスタンスの作り方わからない…
readsPrecとreadListの作り方のチュートリアルか何かないでしょうか(できればShowの方も)
Haskell98Report読んでもサッパリです

instance Eq a => Eq (List a) where
　Nil == Nil = True
　Cons x xs == Cons y ys = x == y && xs == ys
　_ == _ = False

>>808
なるほど。納得です。

>>810
こうすると出来ますね。
Eq クラスのインスタンスに制限されるってこういうことだったのですね
有難うございました。

>>809
チュートリアルじゃないけど、GHC.Readにいくつかinstanceの例がある。
http://cvs.haskell.org/cgi-bin/cvsweb.cgi/fptools/libraries/base/GHC/Read.lhs?rev=1.29;content-type=text%2Fplain

理解したら、是非チュートリアルを書いてくれ。

　　　　　　　　　　　　　　　　　　ミ　　（　　ﾉ
　　　　　　　　　　　　　　　　　　　 　 ／￣＼ 　　♪　
　　　　　　　　　　　　　　　　　　　〜（ﾟ ∀ 。 ）⌒ 　　　
　　　　　　　　　　　　　　　　　♪　　　＼＿／ 　彡
　　　　　　　　　　　　　　　　　　 　 ノ　ι　 ヽ

　　　　　　　　　　　　　　♪　　.ﾊ
　　　　　　　　　　　　,ﾍ　　　　（（
　　　　　　　　　　　　）ﾉ　　　　.））
　　　　　　　　　　　 （（　∧∧//
　　　　　　 　 　 　 　 ＼(ﾟ∀ﾟ　)　　　　　　
　　　　　　　　　　　　　　）　　ﾉ　　　　　　　　　ヾ　　　　　♪
　　　　　　　　　　ミ　シ´　／　　　　　　　　　　　　,γ　
　　　　　　　　　ミ　r´　　（　　　　　　　　　　∧∧//　　　
　　　　　　　　　　　ヽ、　　ヽ　　彡　♪　　 (　ﾟ∀ﾟ)'　　　
　　　　　　　　　　　　　）　　ﾉ　彡 　 　 　 .,/　　 ヽ　ﾐ
　　　　　　　　　　　　ノ　,、（　　　　　　　ノ ﾉヽ 　 l
　　　　　　　　　　　r´／　） ）　　　ミ　(´／　 ﾉ　ノ
　　　　　　　　　　（ （　　（ （　　　　　　 　 γ´ (´
　　　　　　　　　　　ヽ）　　ヽ＼　　　　　　 ﾉ　ﾊ ヽ　　 ♪
　　　　　　　　　　　　　　　ﾉ　　）　.　　 ／ ,,/ （,,ノ　彡
　　　　　　　　　♪ 　　　（_＿ノ　　 　 （_,,ノ

http://shootout.alioth.debian.org/gp4/benchmark.php?test=all&lang=all
パフォーマンスが凄いことになってる。

shootoutって、普通のプログラマが見ても
「Cはやっぱり速いなあ」とか「インタプリタはやっぱり遅いなあ」とか
「Javaはやっぱりメモリ喰いだなあ」とか思うだけで、
「関数型言語頑張ってるな。ちょっと使ってみるか」とは全く思ってくれない罠。

複数の関数の挙動に影響を与える「オプション」を外部(コマンドラインとか)から指定したいとき
C++みたいな言語の「thisの省略」がすごく羨ましいんだけど、
似たようなことをHaskellっぽく書けないものだろうか。

implicit parameterでそれなりに書けそうだけど、
使われてるのを見たことがない。

みんな明示的に引数を持ち回るのが苦痛じゃないのか？

>>816
そんな君にReaderT。
StateTでもいいぞ。

>>817
おー、ありがとう。
この目的のためにReaderモナドで計算順序を導入するのには抵抗があったけど、
既にもなでぃっくなコードにReaderTを混ぜ込むなら面倒が少ないな。

この言語は素晴らしいですか？

最高ですかー！

この言語の、C++に較べて、劣っている点を教えて下さい。

・C++ではテンプレートを使ってコードの抽象性と実行時効率を両立できるけど、
Haskellでは困難。

・C++では名前空間・クラス・関数をかなり自由に相互ネストさせられるし、
ネストに従って細かくスコープを分けてくれるのに対して、
Haskellの名前空間はフラットで、レコードのフィールド名のスコープがモジュールレベルだったり、
関数に局所的な型の定義ができなかったりして不便。

・互いに関連のないものに同じ名前を与えるC++風の多重定義は難しい。
やってできないことはないけど、想定された言語の使いかたではないだろう。

俺は今酔ってるし、ニートだし、最強だ。
ﾓﾅﾃﾞｨｳｽを参考にシューティングゲーム作るぞ。うぉー！

>>823
マジ応援してる。

出来上がったコードの実行速度はめっちゃ遅いですか？

>>825
>>814

Haskell Hackerが超がんばってキモいコード書けばgcc相当にはなるらしい。
俺のような凡人が普通に書いたらめっちゃ遅い。

ハスケルハッカーがキモいコードを書けば、
バグは少ないわ高速だわの最強のコードが生成されるのですね？

それとも、キモいコードってのはバグを許す代わりに高速にするとかいう類の話？

http://shootout.alioth.debian.org/gp4/benchmark.php?test=nbody&lang=java
http://shootout.alioth.debian.org/gp4/benchmark.php?test=nbody&lang=ghc&id=4

・コンパイルが大変で、
・コードが読みにくい分バグが多く、
・遅い

確かに読みにくいね。

>・コンパイルが大変で、
どういう意味？

ハスケル勉強したいが
参考書がきっと1万とか法外な値段でしょ？
手が出ません＞＜

数学やってる人がHaskellを直ぐに分かるのは、
集合論と一階述語論理について勉強済みだからなんだよね？

もうすぐ青木さんの本とかが出るでしょ。
使うだけなら数学の話は特に必要ないよ。たぶん。

数学の知識はいらないと思うけど、論理学の基礎なしじゃむりだぽ。

数学に基づいて作られた言語ではあるが，その理念を理解して利用するのと，ただプログラミング言語として利用するのとでは意味が違う。

「アルゴリズムのプロトタイピングなら C や Java よりも簡単で，早くできます」

とは大学の教官の弁。単位きたかなあ。

早く作れても速く動かないのではなぁ…

>>837
みんなで速くするんだと思います＞＜
CやFORTRANが速いのは多分歴史が長いからだと思ってる

--以下チラシの裏

今日やったこと：eclipseの日本語化とFPの導入

一言：eclipseをeclispだと思ってて「HaskellなのになんでLisp？」とか考えてた。英語弱いな、俺

今からやること：エヴァの映画借りてきて見る

>>837
だからプロトタイピングなんだろ。
物好きがいろいろやってはいるけど、どう考えても研究用途の言語だよな。
だから意味がないというわけではないが。

>>839
ちょっとお前は論点ずれてるよな。

>>830
liftMとか素人なら完全に御手上げ。
あと、何この演算子？ってのを使ってる
(.|. (shiftL i 3)) -- google氏も無視

逆にhaskellが神言語になってる例
http://shootout.alioth.debian.org/gp4/benchmark.php?test=pidigits&lang=dlang&id=0
http://shootout.alioth.debian.org/gp4/benchmark.php?test=pidigits&lang=ghc&id=3
d 言語90行
haskell 11行
実行速度ほぼ同じ

理由
Integer型が使える
Monadを使う必要もMonad持ち上げをする必要がない。(配列を使う必要がない)

>liftMとか素人なら完全に御手上げ。
たぶん、すぐ慣れると思う。

>(.|. (shiftL i 3)) -- google氏も無視
そんなあなたにHoogle
http://www.haskell.org/hoogle/?q=.%7C.

>>842
すげー。
型から検索できるのがHaskellらしいな。

みなさんは、式がどういう順番で評価されていくか
手にとるようにわかるのですか？
私はどう書いたら速いコードになるのかいまいちわかりません。

評価順序など考えない。何のための遅延評価だと思っとる。

速いコードを書くのが目的なら関数型言語など、いや、
高級言語など使うのはお止めなさい。

普段は評価順序なんか考えないでコーディングして、
効率が足らないことが分かったとき、そこをアセンブリで書き直す代わりに
既にあるHaskellのコードをいじって効率を確保する、というのは、
それなりに合理的だと思うんだが。

べつに速さで C と張り合おうとか思ってるわけではないのですが、例えばhead $ xs ++ [x]が O(1) かどうかというのは、評価順がわからないとわからないですよね？こういう簡単な例なら私にもわかるのですが、ちょっと複雑になると頭を抱えてしまうわけです。

>>847
多分、どんな順序で書いてもコンパイラが同じように並べかえてくれるんじゃないかなぁ？
コンパイラが考えうる中で最も効率的なコードが出るようにね

>>847
非正格になれてないだけ。

個人的経験では、Haskellerの半分はスピードレーサー（最適化おたく）だと思う。

マシン非依存の部分ならば、
Cよりhaskellの方が速いコードが書けるはず。
なぜならば、見栄え良く、簡潔に書け（簡潔じゃないとコンパイルできない）
無駄なく書けるから。

cだと、綺麗なコードを書くために無駄なコードを書きまくると思うし、
汚い普通のコードを書いても、Haskellと同程度しか速くならない。

cの有利な点は、
gcがない, 配列操作, アセンブラ的コードが書ける, 速いライブラリがある。

と言ってみる。

非正格だから遅いみたいな話は聞いた事がある。詳細は知らないけど。

>>851
>なぜならば、見栄え良く、簡潔に書け（簡潔じゃないとコンパイルできない）

これは速いコードとは関係ないんじゃないの?
早くコードを書く事は出来るのかもしれないが。

「マシン非依存の部分」なんてあるのか？

Haskellのソースはスリムだがバイナリがピザデブ杉。

>>853
add

Haskell学んでC++でメタプログラミング
これ最新最強。newなんていりませんから！

なんでCはいつも最速なの？

・・・