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

**デフォルトの名無しさん** · 2019/01/29(火) 09:05:47.90

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

haskell.org (公式サイト)
https://www.haskell.org/
日本Haskellユーザーグループ
https://haskell.jp/

前スレ
関数型プログラミング言語Haskell Part31
https://mevius.5ch.net/test/read.cgi/tech/1506447188/

**デフォルトの名無しさん** · 2019/01/29(火) 09:06:37.34

**デフォルトの名無しさん** · 2019/01/29(火) 09:07:46.66

関連サイト
(英語)
Haskell - Wikibooks, open books for an open world (ページ内に内容をまとめたPDFあり)
https://en.wikibooks.org/wiki/Haskell

Learn You a Haskell for Great Good! (『すごいHaskellたのしく学ぼう!』の無料オンライン版)
http://learnyouahaskell.com/chapters

Real World Haskell (同名書籍の無料オンライン版)
http://book.realworldhaskell.org/read/

(以下、日本語)
Haskell入門 5ステップ - HaskellWiki (公式サイト内、日本語入門セクション)
https://wiki.haskell.org/Haskell%E5%85%A5%E9%96%80_5%E3%82%B9%E3%83%86%E3%83%83%E3%83%97

Haskell - Wikibooks (上記Wikibooksの同タイトル日本語版。多くの項目が未編集)
https://ja.wikibooks.org/wiki/Haskell

Programming in Haskell
http://www.sampou.org/cgi-bin/haskell.cgi

Haskell のお勉強
http://www.shido.info/hs/

Haskell Programming
http://www.geocities.jp/m_hiroi/func/haskell.html

本物のプログラマはHaskellを使う:ITpro
http://itpro.nikkeibp.co.jp/article/COLUMN/20060915/248215/

［入門］関数プログラミング―質の高いコードをすばやく直感的に書ける！
http://gihyo.jp/dev/feature/01/functional-prog

**デフォルトの名無しさん** · 2019/01/31(木) 07:01:01.92

手続き型でゴリゴリやってきた人にとって関数型は
マラソンの選手に、匍匐前進と水泳で近道するよう強制しているかのようです

**デフォルトの名無しさん** · 2019/01/31(木) 07:24:27.44

>>4
手前味噌ですが、Haskell入門以前と言う電子書籍をAmazonでご購入下さい。
まさに貴方のような方に関数脳を作ってもらうための本です＾＾

**デフォルトの名無しさん** · 2019/01/31(木) 20:10:32.50

IOモナドは手続きモナド

**デフォルトの名無しさん** · 2019/02/01(金) 07:26:12.68

初心者がHaskellでオンライン問題集みたいなの解いてんだけど
Haskellでやるとこういうの楽しくてええな

**デフォルトの名無しさん** · 2019/02/02(土) 00:12:37.55

CPS書き換えドリル
次の英文を○○構文を用いて同じ意味の英文に書き換えなさい的な

**デフォルトの名無しさん** · 2019/02/03(日) 12:58:27.43

haskell紹介してるブログとか色々あるけどどこも肝心要のところがすっぽり抜けててイライラするな・・

例えば
fact 0 = 1
fact n = n * fact(n - 1)

これ無限ループになっちゃって終わらないでしょ終端条件も書いてないし。
fact 3を展開すると
3 * ( 2 * ( 1 * ( 1 * ………

0を入力すれば1になるってことはこの先ずーっと1が繰り返されるだけだし。
同じ値が２度続いたら処理を止めるとか変な仕組みでも入ってるのかねー

**デフォルトの名無しさん** · 2019/02/03(日) 14:29:08.38

>>9
自分で動かしてみればわかるけど
ちゃんと終わるよ

https://wandbox.org/permlink/goI0n8nF0ac90ofx

◆QZaw55cn4c · 2019/02/03(日) 15:04:51.94

>>9
＞無限ループになっちゃって終わらないでしょ終端条件も書いてないし。
いえいえ、終端条件が
＞fact 0 = 1
です、n ∈ N たる n からはじまって 0 で終わる、と読みます
fact 3 = 3 * fact 2
= 3 * 2 * fact 1
= 3 * 2 * 1 * fact 0
= 3 * 2 * 1 * 1
で止まります．

**デフォルトの名無しさん** · 2019/02/03(日) 15:10:17.81

>>9
恥ずかしいぞ

>fact 0 = 1
で、これ以上再帰してないじゃん

**デフォルトの名無しさん** · 2019/02/03(日) 20:51:10.38

>>12
それじゃ納得できないんだけども
終わるから大丈夫仕様ですってもやっとするから

>>9で書いたように1が無限に続いちゃうと思うんだけどな
0が入力されたら1を返すってことだから
1 - 1でまた繰り返しちゃうよね

そもそもどの値が来たら終わるか全く記述がないよね
そういうところも納得できないっていうかおかしい

**デフォルトの名無しさん** · 2019/02/03(日) 21:08:06.34

>>13
>>11 が説明してくれたとおりなのだけど、納得できない？

**デフォルトの名無しさん** · 2019/02/03(日) 21:13:08.06

>>14
あの説明で納得するようならここ来てないから
あれだとブログの説明と何も変わらない

まさか1かtrueを返したら問答無用で終わる仕様だったりするのかねー

**デフォルトの名無しさん** · 2019/02/03(日) 21:15:44.35

>>13
ああ　言っている意味は分かったけど
続かねーぞ　よく考えてみ　恥ずかしい思いするだろうけど

っていうか、>>11のひとが書いてるじゃん　

fact 1 = 1 * fact 0
= 1 * 1 で終了だろ

これ納得できないとしたら、別のところで引っかかっている
パターンマッチを理解していないとか

**デフォルトの名無しさん** · 2019/02/03(日) 21:18:28.59

>>15
バカで思い込みが激しいって最悪だぞ？どっちかにしろ。

**デフォルトの名無しさん** · 2019/02/03(日) 21:19:06.57

>>16
それじゃ終わらない
終了条件が書いていないから

なんどもいうように * 1がずーっと続くようにしか見えない
だからこの例題見たときにイライラしてたんだよね
前提となってる仕様があるけど説明省いたとかそれ系かなと

◆QZaw55cn4c · 2019/02/03(日) 21:19:41.63

>>13
では逆に質問しましょうか、そこから両者が部分的にでも合意できるポイントを探ることにしましょう
>>9
＞fact 0 = 1
＞fact n = n * fact(n - 1)
これをあなたはどのように解釈したかを、もう少し詳しめに記述していただくことは可能でしょうか、私の記述は今は >>13 が精一杯ですが、あなたの返答をみて改善できる点はないか検討したいと思います

**デフォルトの名無しさん** · 2019/02/03(日) 21:20:07.09

>>15

ほとんど同じ説明だが…

関数の定義が
fact 0 = 1
fact n = n * fact(n - 1)
となっている。
このとき、左辺が右辺に置き換えられる (簡約という)

つまり fact 3 は 3 * fact 2 に置き換えられる
そして fact 2 は 2 * fact 1 に置き換えられる
そして fact 1 は 1 * fact 0 に置き換えられる
ひとつめの関数の定義により、fact 0 は 1 に置き換えられるので
置き換えはここでとまる

以上をまとめると
fact 3
= 3 * fact 2
= 3 * 2 * fact 1
= 3 * 2 * 1 * fact 0
= 3 * 2 * 1 * 1
= 6

**デフォルトの名無しさん** · 2019/02/03(日) 21:22:45.27

>>15
fact 0で問答無用で終わる仕組みですが。。。

>>11 以上にやさしい説明はないと思われ。

普通の言語(ここで

◆QZaw55cn4c · 2019/02/03(日) 21:22:54.49

>>18
終了条件は
＞fact 0 = 1
です。関数 fact の引数が 0 なら、1 を関数の値として返し、fact の求値作業は終了します。
fact への入力が 1 でないならば
＞fact n = n * fact(n - 1)
の定義をつかって、最初の入力 n よりも小さい値 n - 1 (< n) を使った関数定義がつかえるように変換します

**デフォルトの名無しさん** · 2019/02/03(日) 21:25:18.35

>>19
理解したのは>>9の通りで
仮定として1かtrueを返したら再帰は止まる仕様になってると推測してる

>>20
だからfact(1)で無限に続いちゃうよね
1 - 1で fact 0をevalしてまたfact(1)になる
そこで終了条件が必要だけど何にも書いてないから記述通りならずーっと続く

としか見えないんだよね

**デフォルトの名無しさん** · 2019/02/03(日) 21:26:42.72

いやだから

fact 1 で１が出てくるでまた、fact 1になって永遠に続くとかの勝手な思い込みでしょ

あるいは、
fact 0 =1 になるから、また fact 1 -1 になると思ってるとか

だから、永遠に１が続くと勘違いしちゃっている

**デフォルトの名無しさん** · 2019/02/03(日) 21:27:00.44

>>22
ということはやっぱり1を返したら必ず再帰は止まる仕様であってるのかな？
だったらすっきりするんだけども

**デフォルトの名無しさん** · 2019/02/03(日) 21:28:01.94

>>23
>1 - 1で fact 0をevalしてまたfact(1)になる
ならねーよ　そこが恥ずかしいところだ

**デフォルトの名無しさん** · 2019/02/03(日) 21:29:01.89

途中で。。。

まあいい。

Pythonでも再帰出来る。
特別な話じゃない。

def fact(n):
if n == 0:
return 1
else:
return (n * fact(n - 1))

**デフォルトの名無しさん** · 2019/02/03(日) 21:29:11.55

>>23

>>>20
>だからfact(1)で無限に続いちゃうよね
>1 - 1で fact 0をevalしてまたfact(1)になる
>そこで終了条件が必要だけど何にも書いてないから記述通りならずーっと続く

そうはならない

fact 1 = 1 * fact 0
に簡約される

そして
fact 0 = 1 であって
fact 0 = 0 * fact(0 - 1) とは絶対にならないからここで終わる

高校数学がわかるなら、漸化式と同じだと思えばよい

**デフォルトの名無しさん** · 2019/02/03(日) 21:30:12.31

>>25
そうそう。そのとおり。

◆QZaw55cn4c · 2019/02/03(日) 21:31:19.47

>>23
＞1 - 1で fact 0をevalしてまたfact(1)になる

＞fact 0 = 1
というのは、関数 fact のうち fact(0) (引数が 0) のときの値は 1 である、と確定的な記述をしています。ここで答えが決まったので、さらに答えを求めるための関数適用作業には入りません、それはそういう意味です
どうして eval したあと fact(1) になる、と判断したのでしょうか？
fact(0) = 1 の 1 というのは fact() の値であって、fact の引数ではなく、また fact の引数になりうる記述は「fact 0 = 1」という記述の中には見つからないのですが

＞fact n = n * fact (n - 1)
この記述のなかには、たとえば引数が 7 だとすると「 fact 8 を fact 7 の値をつかって表現する」ということですから、fact 8 を eval する「途中で」 fact 7 を eval しようとする、ということは書かれています

**デフォルトの名無しさん** · 2019/02/03(日) 21:32:49.38

>>25
その考えであってる。

◆QZaw55cn4c · 2019/02/03(日) 21:32:49.97

>>25
「1 を返したら」とまるのではなく
fact 0 = 1
と fact の求値が、この行で確定しているから、止まるのです。
fact 0 = 100
という定義であっても、とまりますよ

**デフォルトの名無しさん** · 2019/02/03(日) 21:33:05.02

>>28
いやいやfact(1)の評価は0なんだし
fact 0の定義があるからまた1
どう考えても続くんだよね

そもそも再起から脱出するためのコードがどこにもないから怪しいとも踏んでる
何か前提となってる仕様がありそうだ

**デフォルトの名無しさん** · 2019/02/03(日) 21:34:47.28

>>29
やっぱりそうなんだ
そういう重要なことは早めに説明書きしといてくれないと大混乱だわ
まースッキリしたありがと

そういう仕様なら色々めんどくさいな・・・

**デフォルトの名無しさん** · 2019/02/03(日) 21:35:32.72

>>33
>いやいやfact(1)の評価は0なんだし

違う
どこにそんなことが書かれている？

◆QZaw55cn4c · 2019/02/03(日) 21:35:45.64

>>33
＞いやいやfact(1)の評価は0なんだし
ここが違っています。
fact(1) の評価は 1 * fact(0) であって、 0　じゃないです
fact(0) の値が具体的になにかは、fact(0) を意識しはじめた時点では分からないのですよ

**デフォルトの名無しさん** · 2019/02/03(日) 21:37:12.79

バカ過ぎて泣けてくる…

**デフォルトの名無しさん** · 2019/02/03(日) 21:37:24.99

>>33
おもろいな　だんだんネタに思えてきた

fact nの定義をよく見ろ　
fact 0 = 1 で再帰していないじゃん　ここで止まるだろ　普通に考えれば

他の言語も一緒だろ　ただそれをパターンマッチでやってるだけ

**デフォルトの名無しさん** · 2019/02/03(日) 21:37:39.39

>>34

えーと、すまん、「どんな場合でも」再帰は１を返したら終了すると考えているのなら
それは大間違いだ

**デフォルトの名無しさん** · 2019/02/03(日) 21:38:05.69

>>33
fact 1の評価は1 * fact 0

fact 0のみが再帰してない。(基底部)
再帰は再帰部と基底部が必ず最低1個ずつ存在する。

**デフォルトの名無しさん** · 2019/02/03(日) 21:39:25.68

>>23
>>>19
>理解したのは>>9の通りで
>仮定として1かtrueを返したら再帰は止まる仕様になってると推測してる

この推測が間違っているので、いったん忘れて素直にプログラムを読んでみよう

**デフォルトの名無しさん** · 2019/02/03(日) 21:39:35.29

>>35
教えてもらったからもう大丈夫だよ
1で再起が止まる仕様なら納得だし

>>36
fact(1)を入力したら 1-1を評価するから fact 0
特に問題ないよ

1で止まる仕様らしいからそれを前提にコード考えないといかんのか・・
ややこしいことになるねこれ

**デフォルトの名無しさん** · 2019/02/03(日) 21:41:09.23

>>42

>>29 や >>31 でお墨付きを与えたのが間違いだった
君はまだ理解できていない (断言)

**デフォルトの名無しさん** · 2019/02/03(日) 21:41:42.22

>>39
どーゆーこと
もうそれで覚えちゃったんだけども・・

**デフォルトの名無しさん** · 2019/02/03(日) 21:43:10.37

>>44
忘れろ
忘れてプログラムを読み直しな

◆QZaw55cn4c · 2019/02/03(日) 21:43:22.74

>>42
＞1で再起が止まる仕様なら納得だし
理解が不十分じゃないかと危惧します、その台詞「1 で再起がとまる」という言葉ですが、「何が」 1 で再起が止まる、と考えているのですか？
あなたの発言は、いちいち「何が」「どうだ」の「何が」が欠けているので不安です

◆QZaw55cn4c · 2019/02/03(日) 21:43:58.19

>>44
覚える、という言葉はこういうときに使うものではないと思いますよ

**デフォルトの名無しさん** · 2019/02/03(日) 21:44:56.66

もういちど繰り返すが、
>>41 に書いたように
「仮定として1かtrueを返したら再帰は止まる仕様になってると推測している」
が大間違いだ

**デフォルトの名無しさん** · 2019/02/03(日) 21:46:13.57

釣り宣言マダー？

**デフォルトの名無しさん** · 2019/02/03(日) 21:46:48.03

>>45
それだと>>9の通りで揺らがない

>>46
この記述だと無限に *1が続くわけだから
なにか終了条件が必要なわけで
1を返したら再帰が止まる仕様ならなるほど納得

◆QZaw55cn4c · 2019/02/03(日) 21:47:09.11

>>42
＞fact(1)を入力したら 1-1を評価する
どうしてそう考えたのですか？そのような記述がどこに書かれていたのか説明いただけませんか？

**デフォルトの名無しさん** · 2019/02/03(日) 21:49:35.33

>>50
> この記述だと無限に *1が続くわけだから

何で？続かないが。ちゃんと読め。

**デフォルトの名無しさん** · 2019/02/03(日) 21:49:54.21

>>48
大混乱してきた
1で再帰は必ず止まるんでないならさらにわからなくなるんだけども

**デフォルトの名無しさん** · 2019/02/03(日) 21:49:57.06

>>51
わかるじゃん　fact 0で1が出てきたら、また、勝手に再帰させて
fact 1に戻っちゃう　勝手に脳内変換させちゃってる

**デフォルトの名無しさん** · 2019/02/03(日) 21:51:42.20

>>51
fact(1)はfact(n-1)によってfact(0)になるよね
実は式自体が予想外の評価するってことなのかな？
いやまさかね・・

◆QZaw55cn4c · 2019/02/03(日) 21:52:52.90

>>50
＞この記述だと無限に *1が続くわけだから
あなたの理解になにが足りないのかがわかるような気がしてきました。

「fact の引数が 1 である」と「fact の求値が 1 である」とを区別していないようですね
この二つは厳然として異なります

fact 0 = 1

は、fact(0) の「求値が」1 である、といっているのです

fact n = n * fact (n - 1)

は、たとえば

fact 8 = 8 * fact 7
fact 7 = 7 * fact 6
fact 6 = 6 * fact 5
fact 5 = 5 * fact 4
fact 4 = 4 * fact 3
fact 3 = 3 * fact 2
fact 2 = 2 * fact 1

という記述を纏めて表現しているのであり、これは fact n の「求値」は fact (n - 1) という、もともとの引数 n とは違う n - 1 という引数を使った fact の求値で定義しているのです

**デフォルトの名無しさん** · 2019/02/03(日) 21:53:28.07

もしかすると、だけど

fact 0 = 1
を実行した直後に
fact 1 = 1 * fact 0
が続くと考えている？

もうしそうだとしたらそこが間違いで
fact 0 = 1
fact n = n * fact(n - 1)
はそのどちらかしか実行されない

◆QZaw55cn4c · 2019/02/03(日) 21:53:48.18

>>53
＞1で再帰は必ず止まるんでない
「何が」 1 で再帰が止まる、と考えているのですか？
「何が」の部分を答えてください

◆QZaw55cn4c · 2019/02/03(日) 21:56:12.46

>>54
＞fact 0で1が出てきたら、
何が 1 となるのか、そこをはっきり書いてください、「出てきたら」っていいますが、「何が」 1 と出てきたら、なんでしょうか？

＞また、勝手に再帰させて
何が　1 となるのか、0 となるのか、そこをはっきりさせないことには、それ以降の思考は不可能ですよ、あなたには「また勝手に再帰させて」とかいうことを考える段階ではありません

**デフォルトの名無しさん** · 2019/02/03(日) 21:57:58.25

>>56
ごめん意味不明わからん

>>57
もちろんそのように考えてる
fact 0 = 1の結果はすぐ反映されるんじゃないの？

**デフォルトの名無しさん** · 2019/02/03(日) 21:58:56.17

>>59
いや　俺は本人じゃないから

あくまでも、彼の脳内を勝手に想像しただけ　１がつづくケースを考えただけ
そのものでは無いかもしれないけど、どちらにしようが似たようなケースでしょ

◆QZaw55cn4c · 2019/02/03(日) 21:59:44.40

>>61
これは失礼…

**デフォルトの名無しさん** · 2019/02/03(日) 22:00:18.19

>>60
ああ、良かった

>fact 0 = 1の結果はすぐ反映されるんじゃないの？
そうだよ。そして fact 0 は 1 を返すから、もう再帰呼出しは起こらないよね？

fact 3
= 3 * fact 2
= 3 * 2 * fact 1
= 3 * 2 * 1 * fact 0
= 3 * 2 * 1 * 1
= 6

**デフォルトの名無しさん** · 2019/02/03(日) 22:02:19.10

>>63
いやいや終了条件が何も書かれてないから結局は続くよ
どのみちfact 0が1となるならまたfact(1-1)でfact(0)でしょ
間違ってないはずなんだけど何か使ってる人には常識的なお約束事とかあるのかな

**デフォルトの名無しさん** · 2019/02/03(日) 22:02:55.82

>>60
>fact 0 = 1の結果はすぐ反映されるんじゃないの？
ようするにそこでとまる

数学の階乗だから　fact nの引数は再帰する度に-1される。
どこかで、factの引数が0になったら、それ以上は再帰しない

難しい話じゃないし、他の言語で再帰理解していたら、分かるはず
自分で落ち着いて考えてごらん

**デフォルトの名無しさん** · 2019/02/03(日) 22:06:24.90

>>65
いやただのカウンターだったとしても止まらないし
やっぱりおかしいとは思う
何か前提がありそうな気はする

**デフォルトの名無しさん** · 2019/02/03(日) 22:07:56.45

>>64
fact 3
= 3 * fact 2
= 3 * 2 * fact 1
= 3 * 2 * 1 * fact 0 -- fact 0が・・
= 3 * 2 * 1 * 1 -- 1になる。factもうないのにここから何が続くの？
= 6

**デフォルトの名無しさん** · 2019/02/03(日) 22:08:07.10

>どのみちfact 0が1となるならまたfact(1-1)でfact(0)でしょ

fact 1 = 1 * fact (1-1) = 1 * fact 0

となるけど、これは fact 1 の時の処理だね

fact 0 の場合は 1 を返すだけだから、fact(1-1) という処理はもう出てこないよ

今の話は
fact 3
= 3 * fact 2
= 3 * 2 * fact 1
= 3 * 2 * 1 * fact 0
= 3 * 2 * 1 * 1
= 6

のうち
3 * 2 * 1 * fact 0
が
3 * 2 * 1 * 1
に変化するところだよ

**デフォルトの名無しさん** · 2019/02/03(日) 22:08:36.79

>>66
だとすると文法自体理解していない　あるいは関数自体
もっと、詳しく書くと

>どのみちfact 0が1となるならまたfact(1-1)でfact(0)でしょ
定義を見てごらん
fact 0 = 1 でこれは、=の右にfactが無いからこれで再帰はしないで、ここで終了
fact n = n * fact n-1 で=の右にfactがあるから再帰する

**デフォルトの名無しさん** · 2019/02/03(日) 22:10:11.03

>>67
= 3 * 2 * 1 * 1
= 3 * 2 * 1 * 1 * fact( 1 - 1 )
= 3 * 2 * 1 * 1 * 1 * fact ( 1 - 1)

どこまでも続くじゃない・・

**デフォルトの名無しさん** · 2019/02/03(日) 22:11:04.78

>>70
これはアカンよ…

**デフォルトの名無しさん** · 2019/02/03(日) 22:13:50.28

>>70
中学校の数学でそうはならないってことは習うから、学校の数学でそこまで勉強してからプログラミングに手を出しても遅くないのでは？

**デフォルトの名無しさん** · 2019/02/03(日) 22:14:19.16

>>69
fact 0 = 1で終了するというのが納得いってない
もしそうであれば1を返せば再帰は終了すると仮定したんだ

そもそもfact 0 = 1ってマクロ定義みたいなもんだし
直ちに評価されて式に代入されるよね

**デフォルトの名無しさん** · 2019/02/03(日) 22:17:47.65

>>73
他の言語で再帰ってのは理解しているの？

fact 0 = 1で=の右にfactが無いから、再帰は終了　だから、終了条件は書かれている。
もしこれが理解できないのなら、関数定義とか、パターンマッチとかもっと基本的なことに
戻らないと理解できないと思う

**デフォルトの名無しさん** · 2019/02/03(日) 22:18:13.63

>>72
プログラミング言語は数学じゃないから
再帰から脱出するならそのためのコードは絶対必要なはずなんだ
それがないってことは仕掛けがあるはずで
その仮定が1を返せば再帰から脱出できるという考え
でも違うらしいから大混乱してる

**デフォルトの名無しさん** · 2019/02/03(日) 22:19:53.64

>>73
fact 0 = 1
で「終了する」というのが間違い

fact 0 = 1
では、fact 0 が 1を返す(正確に言うと1に簡約する)
ということしか定義していない
ただ、もうfact関数を呼び出していないので、再帰呼出しはここで止まる

そして fact 0 = 1 がマクロ定義ということも勘違いなので忘れよう

>>67 が解説してくれた
fact 3
= 3 * fact 2
= 3 * 2 * fact 1
= 3 * 2 * 1 * fact 0 -- fact 0が・・
= 3 * 2 * 1 * 1 -- 1になる。factもうないのにここから何が続くの？
= 6

**デフォルトの名無しさん** · 2019/02/03(日) 22:21:37.72

>>74
Cで再帰させるなら終了条件にヒットしたらフラグたててreturnで戻ってく
関数定義の仕方ならサッと見たけど特に疑問はなかったよ
パターンマッチっていってもマクロ定義みたいなもんだし特にどうということも

**デフォルトの名無しさん** · 2019/02/03(日) 22:22:31.24

>>75
上に書いたけど、漸化式は理解している？
同じ書き方をします

Haskellは数学を基盤としているので、数学的な記述方法でプログラムが書けます
「再帰から脱出するならそのためのコードは絶対必要なはずなんだ」とあるけど、
もう書かれているよ
fact 0 = 1 って

**デフォルトの名無しさん** · 2019/02/03(日) 22:24:44.77

>>76
いやだから・・
fact 0は1なんだからその次はfact(1)になるでしょ
何も間違ってないと思うんだけど。

**デフォルトの名無しさん** · 2019/02/03(日) 22:25:28.82

>fact 0は1なんだからその次はfact(1)になるでしょ
その次はもうないよ

**デフォルトの名無しさん** · 2019/02/03(日) 22:26:23.52

>>78
それは終了条件じゃないよね
何が正解なのかさらに混乱して来た

**デフォルトの名無しさん** · 2019/02/03(日) 22:26:31.18

>>79
ならないよ。そこが間違ってるんだよ。

**デフォルトの名無しさん** · 2019/02/03(日) 22:28:21.00

>>81
君の言い方に合わせると「終了条件」と考えてよい

正しく説明すると
>>40 になる

**デフォルトの名無しさん** · 2019/02/03(日) 22:28:40.54

>>42
1で止まる仕様と言うか。。。
掛け算だから1を返すだけ(掛けても変わらない数)で、足し算なら0を返すよ。

sum1toN 0 = 0
sum1toN n = n + sum1toN (n - 1)

**デフォルトの名無しさん** · 2019/02/03(日) 22:28:53.80

>>81
終了条件だよ。
>>27のPythonコードで言うと
if n == 0:
return 1
の部分と同じだよ。

**デフォルトの名無しさん** · 2019/02/03(日) 22:30:37.00

>>83
だから・・
fact 0は1なんだから続くじゃない？
延々と再帰するようにしか見えない

**デフォルトの名無しさん** · 2019/02/03(日) 22:30:46.46

この人の脳内だと、
fact 0 = 1
が
fact 0 = fact 1
になってるんじゃないだろうか

**デフォルトの名無しさん** · 2019/02/03(日) 22:32:38.86

>>85
PythonやJavaは知らないのでなんとも

**デフォルトの名無しさん** · 2019/02/03(日) 22:33:23.20

この人　７７で書いてるけど、文法まともに読んでないんだよ

Haskell 文法自体は一見綺麗で簡単そうに見えるけど
実際には、理解するのが非常に難しい（今回の再帰のとこじゃないんだけど）
適当に文法流し読みして理解しようとするのが　間違っている

もっとも、階乗の再帰は、他の人の説明で理解できるだろうと思うが

**デフォルトの名無しさん** · 2019/02/03(日) 22:34:03.06

>>86
fact 0は1なんだから、

fact 3
= 3 * fact 2
= 3 * 2 * fact 1
= 3 * 2 * 1 * fact 0 -- fact 0が・・
= 3 * 2 * 1 * 1 -- 1になる。factもうないのにここから何が続くの？
= 6

はい！ここで一旦休憩！君に問題。
3 * 2 * 1 * 1はいくつだ？

**デフォルトの名無しさん** · 2019/02/03(日) 22:34:30.64

うーん、C言語だと

int fact(int n)
{
if (n == 0) return 1;
else return n * fact (n - 1);
}

と書くのと同じなんだけどねえ

**デフォルトの名無しさん** · 2019/02/03(日) 22:37:00.44

>>90
だから
=3 * 2 * 1 * 1 * fact(1-1)
=3 * 2 * 1 * 1 * 1*fact(1-1)
=3 * 2 * 1 * 1 * 1*1*fact(1-1)

という具合にいつまでもfactは続くよ
だから色々納得いかないことあるんだけど

**デフォルトの名無しさん** · 2019/02/03(日) 22:37:36.15

もうHaskellはあきらめるんだ……

**デフォルトの名無しさん** · 2019/02/03(日) 22:39:05.88

>>92

この１行目はどこから出てきたの？
=3 * 2 * 1 * 1 * fact(1-1)

この辺を脳内でテキトーに処理してるからわからないんだよ
fact 3
のところから地道に書きながら置き換えてみな

**デフォルトの名無しさん** · 2019/02/03(日) 22:41:48.43

>>94
それで地道にやったら >>9になったよ
あれ以外どうしろと・・

**デフォルトの名無しさん** · 2019/02/03(日) 22:42:17.34

>>92
算数のテストで
3 * 2 * 1 * 1は？って問題に、
3 * 2 * 1 * 1 * fact(1-1)って答えるの？
それは算数でも数学でもプログラミング言語でも間違いだよ。
算数でも数学でもプログラミング言語でも答えは6だよ。

**デフォルトの名無しさん** · 2019/02/03(日) 22:42:33.19

>>95
そうなのか。C言語はやったことがあるようだけど
>>91 は理解できてる？

**デフォルトの名無しさん** · 2019/02/03(日) 22:43:47.92

>>96
そこはどうでもいいところだから書かなかった

**デフォルトの名無しさん** · 2019/02/03(日) 22:43:59.88

>>95
ああ、>>9 みたいに一気に展開するのではなくて、
fact 3 =
のところからひとつずつ地道に置き換えてみた？
もしやってないなら、今すぐやってみよう

**デフォルトの名無しさん** · 2019/02/03(日) 22:44:48.18

>>98
どうでもよくないから君は間違っている

**デフォルトの名無しさん** · 2019/02/03(日) 22:45:27.31

>>97
あれでいいんだけど似たような制御構造がないよね
haskellのコードは全く別物に見える

**デフォルトの名無しさん** · 2019/02/03(日) 22:45:46.73

>>95
左辺から右辺に書き換えるって分かってる？

**デフォルトの名無しさん** · 2019/02/03(日) 22:49:36.42

>>99

=3 * 2 * 1 * 1
=3 * 2 * 1 * 1 * 1
=3 * 2 * 1 * 1 * 1 * 1
・・・

やっぱり変わんないよ？
何かやってる人には常識だからあえて書いていないとかのお約束ごととかある言語なんじゃないかなぁ・・
パッと見た感じそんなに難しい言語には見えないけど内容に納得できない

**デフォルトの名無しさん** · 2019/02/03(日) 22:50:08.66

>>98
どうでもよくないよ。正しい流れは、
fact 3
= 3 * fact 2
= 3 * 2 * fact 1
= 3 * 2 * 1 * fact 0
= 3 * 2 * 1 * 1
= 6

なのに、>>92によるとあなたは、
fact 3
= 3 * fact 2
= 3 * 2 * fact 1
= 3 * 2 * 1 * fact 0
= 3 * 2 * 1 * 1
= 3 * 2 * 1 * 1 * fact(1-1)
= 3 * 2 * 1 * 1 * 1 * fact(1-1)
= 3 * 2 * 1 * 1 * 1 * 1 * fact(1-1)

であるという。
正しい答え6にたどり着かない原因はあなたが
3 * 2 * 1 * 1
= 3 * 2 * 1 * 1 * fact(1-1)
と変形(?)してしまっているところなのは明らか。

◆QZaw55cn4c · 2019/02/03(日) 22:51:43.03

>>64
＞またfact(1-1)
どうしてそのように推測したのですか？その 1 - 1 ってどこから誘導したのですか？

**デフォルトの名無しさん** · 2019/02/03(日) 22:51:48.54

>>102
普通にやったけど特に問題なかったよ

◆QZaw55cn4c · 2019/02/03(日) 22:53:55.48

>>79
＞fact 0は1なんだからその次はfact(1)になるでしょ
ちがいますよ。なんども言っていますが「fact 0　は 1 」、っていう言葉が不正確ですね、fact 0 の「何が」 1 なんでしょうか？

**デフォルトの名無しさん** · 2019/02/03(日) 22:54:17.35

>>104
fact 0 = 1とか定義されちゃってるから変形もなにもあの形にしかならんでしょう

>>105
fact 0の結果が1だからそれはすぐ反映されるので

◆QZaw55cn4c · 2019/02/03(日) 22:54:49.82

>>86
＞fact 0は1なんだから続くじゃない？
fact 0 の「何が」 1 なんですか？そこが他の者と違っている点かと思います

◆QZaw55cn4c · 2019/02/03(日) 22:55:58.80

>>92
3 * 2 * 1 * 1 * fact(1-1)

その 1 - 1 はどういう理由で 1 - 1 と書いたのですか？

**デフォルトの名無しさん** · 2019/02/03(日) 22:56:02.92

>>107
不正確と言われても他に言いようがないし

**デフォルトの名無しさん** · 2019/02/03(日) 22:56:26.62

Cでこんな感じに書いてあげれば分かるのだろうか。
int fact(int n) {
switch(n) {
case 0: return 1; // fib 0 = 1
default: return n * fact(n-1); // fib n = n * fact (n-1)
}
}

**デフォルトの名無しさん** · 2019/02/03(日) 22:57:55.66

あっとボケた。>>112のfibはfactの間違い

**デフォルトの名無しさん** · 2019/02/03(日) 22:58:05.17

>>110
直前の結果が1なのでfact(n-1)に与えられてfact(1-1)
特に問題ないはずだけどもこれだけなら

◆QZaw55cn4c · 2019/02/03(日) 22:58:55.27

>>111
あなたは「fact 0 が 1 」といっていますが、我々は「fact 0 の値が 1」と「fact の引数が 1」とを別のものとして区別しているのです
あなたは区別していますか？あるいは「fact 0 が 1」というけれども fact 0 の何が 1 なんですか？

**デフォルトの名無しさん** · 2019/02/03(日) 22:59:39.94

>>114
>直前の結果が1なので

ここはOK

>fact(n-1)に与えられてfact(1-1)

ここが間違い。与えられるfact(n-1)がもう存在しない

◆QZaw55cn4c · 2019/02/03(日) 22:59:45.17

>>114
結果は結果、引数は引数です
結果を引数に入れたり、引数を結果にいれたりしていないのですよ

**デフォルトの名無しさん** · 2019/02/03(日) 23:01:37.23

>>112
なっ
まさかそういう意味なの？

fact 0 = 1
fact n = n * fact(n - 1)

のどちらかしか評価されないとか見ただけじゃわからないって！！
あーそういうことかー

**デフォルトの名無しさん** · 2019/02/03(日) 23:01:49.80

>>108
> fact 0 = 1とか定義されちゃってるから変形もなにもあの形にしかならんでしょう

いいえその形には絶対になりません。
「fact 0 = 1とか定義されちゃってるから」
= 3 * 2 * 1 * fact 0
は
= 3 * 2 * 1 * 1
になります。うん、これはいい。次。
「fact 0 = 1とか定義されちゃってるから」
= 3 * 2 * 1 * 1
は
= 3 * 2 * 1 * 1 * fact(1-1)
になります？いいえ、なりません。勝手に足した「 * fact(1-1)」どっから出てきたんだ。

3 * 2 * 1 * 1は6です。

**デフォルトの名無しさん** · 2019/02/03(日) 23:03:02.44

理解できたようで良かったけど、結局は
>>57 がわかってなかったということだなあ

**デフォルトの名無しさん** · 2019/02/03(日) 23:03:24.76

これは説明書きに書いておいて欲しかったなー
これじゃわかりようがないわ

**デフォルトの名無しさん** · 2019/02/03(日) 23:03:29.59

>>118
よかったね。君へのレスで「パターンマッチ」を検索してごらん

◆QZaw55cn4c · 2019/02/03(日) 23:03:47.98

>>118
そこでしたか！
うーん、それは見抜けなかったですね、いろいろしつこい質問をしてごめんなさい

**デフォルトの名無しさん** · 2019/02/03(日) 23:04:21.15

>>121
普通に数学の手法なので、数学を勉強しようか
(ちなみに、君以外は全員ふつうにわかってるぞ)

**デフォルトの名無しさん** · 2019/02/03(日) 23:04:27.74

完全解決してスッキリ
みんな時間とらせてしまってごめん
そしてありがとう

**デフォルトの名無しさん** · 2019/02/03(日) 23:06:11.09

>>125 がんばれよー

**デフォルトの名無しさん** · 2019/02/03(日) 23:06:13.09

fact 0 = 1 は、fact 0 = fact (fact 0)ではありません。

**デフォルトの名無しさん** · 2019/02/03(日) 23:06:37.09

>>120
>>60で
> もちろんそのように考えてる
って書いてるけどそのように考えてなかったよね…

**デフォルトの名無しさん** · 2019/02/03(日) 23:11:25.99

>>122 が言っている「パターンマッチ」を彼が調べてくれるといいね

**デフォルトの名無しさん** · 2019/02/04(月) 07:18:20.69

>>92
だから、fact 1-1になった後、fact 0になるだろ？
そしたらfact 0 = 1になるんだよ。
数学の数学的帰納法ググれ。

fact 0 = 1

これはfactの引数が0なら強制的に1になると言ってる。

fact n = n * fact (n - 1)

これはfact nを解くには引数のnに、nより1つ小さい数をfactに渡したものを掛けたものと等しいと言っている。
(そして最終的にfact 0で1が返って全体の値が求まる)

fact 3
= 3 * fact (3 - 1)
= 3 * fact 2
= 3 * 2 * fact (2 - 1)
= 3 * 2 * fact 1
= 3 * 2 * 1 * fact (1 - 1)
= 3 * 2 * 1 * fact 0
= 3 * 2 * 1 * 1 ― fact 0 = 1より
= 6

**デフォルトの名無しさん** · 2019/02/04(月) 07:24:43.06

ただし、fact 0の様な特殊な条件を上に書く必要がある(Haskellに限らず、どの言語も)

**デフォルトの名無しさん** · 2019/02/04(月) 07:30:26.48

スタック消費しない末尾再帰とか、まだ先があるのに先が思いやられる。。。
(末尾再帰も最近じゃCやJavaScriptでも効くらしい。実質ループだから使った事ないけど)

**デフォルトの名無しさん** · 2019/02/04(月) 11:21:38.86

遅延評価や並行並列がデフォルトの言語ならばスタック消費しないのは当たり前である

**デフォルトの名無しさん** · 2019/02/04(月) 11:34:48.97

へっ？

**デフォルトの名無しさん** · 2019/02/04(月) 11:56:25.98

人間の読解力なんて順調に行っても1日1行程度でしかない

**デフォルトの名無しさん** · 2019/02/04(月) 22:09:21.20

>>133
代わりにスペースリークするけどな

**デフォルトの名無しさん** · 2019/02/05(火) 00:47:55.71

リストや配列には複数の要素がある
オブジェクトにも複数のメンバーがある
その一部が不要になってもメモリは全部残る
ここまでは言語に依存しない

**デフォルトの名無しさん** · 2019/02/05(火) 02:19:00.11

数日ぶりに覗いたらすっごいスレ伸びてる

**デフォルトの名無しさん** · 2019/02/05(火) 03:02:15.20

ごいごいすー！

**デフォルトの名無しさん** · 2019/02/05(火) 05:35:54.03

>>9,112,118 だけ読めばおk

**デフォルトの名無しさん** · 2019/02/11(月) 10:04:55.57

HaskelでWindowsアプリケーション作りたいですけどできるんですか？

**デフォルトの名無しさん** · 2019/02/11(月) 22:30:07.24

問題は、何十年か前にそれができた人のコードを今コンパイルできるか
今できた人のコードを何十年後にコンパイルできるか
それができるのがC/C++で
他の言語はそれを不可能にして新しい言語を普及させたい

**デフォルトの名無しさん** · 2019/02/15(金) 14:13:18.51

さようなら遅延評価　2019-02-15
https://kazu-yamamoto.hatenablog.jp/entry/2019/02/15/115630

Haskellがとっつきにくい原因の一つに遅延評価がある。入門書では、無限リストと遅延
評価がことさら強調される。しかし、Haskellを業務で使ってみると、遅延評価が煩わしく
なってくる。遅延評価なしでもほとんどのことは実現できるし、メモリーの使用量は推測
できないし、あまりいいことはない。(中略)

、GHC 8.0 では、言語拡張 Strict と StrictData が提供された。この二つを使えば、
デフォルトの評価戦略が正格評価となる。
つまり、以下のコードの評価戦略は遅延評価だが、Strict と StrictData を用いると
正格評価となる。(中略)

Strict と StrictData をもう少しく知りたい人はStrict Haskellを読んでほしい。

純粋関数型データ構造を読んだ諸君、Haskellではデフォルトが遅延評価だからイマイチ
例題をうまく実装できないと思ったことだろう。でも、今なら簡単にできるのだ！(後略)

**デフォルトの名無しさん** · 2019/02/15(金) 14:59:49.72

ムグググググググ

**デフォルトの名無しさん** · 2019/02/15(金) 16:33:48.53

xcodeで使えないのが致命的なんだよな・・
リンクはできるがUIがらみのコードは書けないわけで

**デフォルトの名無しさん** · 2019/02/16(土) 07:21:27.63

スレを読み直してて気づいたけど、>>60ってこういう意味で言ってたのね

もちろんそのように(>>57の前半のように)考えてる
fact 0 = 1の結果はすぐ(fact n = n * fact(n - 1)に)反映されるんじゃないの？

**デフォルトの名無しさん** · 2019/02/16(土) 09:09:45.75

もういいだろう　ただ単に基本的文法すら知らない子じゃん

**デフォルトの名無しさん** · 2019/02/16(土) 13:13:23.08

とっつきにくいも聞き飽きたな
パワハラ上司に同じこと言えるのかと
本当にとっつきにくい相手はそういう輩だ

**デフォルトの名無しさん** · 2019/02/16(土) 13:16:38.83

ややこしいことをややこしい方法で簡単にするのがhaskell

**デフォルトの名無しさん** · 2019/02/16(土) 14:01:52.10

Pythonのように型を書かないやつはゴミクズ
とかいうハラスメントが一番の問題だから遅延評価は誤差の範囲内

**デフォルトの名無しさん** · 2019/02/17(日) 00:52:21.04

一回しか変数に代入しない場合は副作用になりますか？
YES か NOでお答えください。

JavaScriptで言えばこういうコードです。
const a = foo(), b = bar(a), c = baz(b);
（const変数は再代入ができません）

**デフォルトの名無しさん** · 2019/02/17(日) 00:52:52.45

Haskellスレの皆さんこんにちは✨😃❗
突然ですがこのたびWeb制作板JavaScript質問スレにて、スレ民の総意により、
[1,2,3].map(v => (v += 2, v * v));
のv += 2は副作用ではない。
と決定しました！
ありがとう！ありがとう！

**デフォルトの名無しさん** · 2019/02/17(日) 00:55:14.71

>>152は再代入と（再代入しない）代入の違いがわからず
代入は副作用であると言い張っているマヌケが
再代入の例を出し、代入は副作用であると
結論づけようとしているだけなので無視してください。

**デフォルトの名無しさん** · 2019/02/17(日) 01:04:11.22

>>153
？別の方と勘違いされているのでは？？
話はシンプル。質問をして、その答えを得た。以下が全てです。この質問と答えに、前後の文脈など関係ありますか？？

904 Name_Not_Found sage 2019/02/17(日) 00:42:09.09 ID:???
>>901
悪いけど以下の（ア）に入るのは1か2か答えてくれる？1か2の一文字書くだけだから出来るよね？
[1,2,3].map(v => (v += 2, v * v));
のv += 2は（ア）である
1. 副作用である
2. 副作用ではない

907 Name_Not_Found sage 2019/02/17(日) 00:44:40.52 ID:???
>>904
Wikipediaの2つの成立条件を考えれば、2. は迷惑だろ

908 907 sage typo 2019/02/17(日) 00:45:33.97 ID:???
×　2. は迷惑だろ
〇　2. であることは明白だろ

**デフォルトの名無しさん** · 2019/02/17(日) 01:06:42.19

あの？Haskellスレを荒らさないでくれますか？
関係ない話はJavaScriptスレに戻ってください

**デフォルトの名無しさん** · 2019/02/17(日) 01:13:02.79

>>155
おや？
>>151を書き込んだのはどなたですか？ｗ
何か都合の悪いことでもあったのですか？ｗ
大慌てで>>151を張りに来たようですが？ｗ

**デフォルトの名無しさん** · 2019/02/17(日) 01:15:49.49

>>151は単なる質問です。

**デフォルトの名無しさん** · 2019/02/17(日) 01:25:17.93

フフッｗ

**デフォルトの名無しさん** · 2019/02/17(日) 01:47:05.17

うるせ～～～～一生代入してろ

**デフォルトの名無しさん** · 2019/02/17(日) 03:04:30.74

Haskellスレ民の方々どうも！
Web制作板JavaScript質問スレにて、
https://en.wikipedia.org/wiki/Side_effect_(computer_science)
の以下の文章について…
> One common demonstration of side effect behavior is that of the assignment operator in C++.
副作用の振る舞いの一般的なデモとしては、C++の代入演算子があります。
> For example, assignment returns the right operand and has the side effect of assigning that value to a variable.
例えば代入は右オペランドを返し、かつそれと同じ値を変数に代入するという副作用を持ちます。

スレ民の叡智を結集した結果、

・C++の代入演算子は副作用があるが、JavaScriptの代入演算子は副作用がない

・[1,2,3].map(v => (v += 2, v * v));
のv += 2は主作用を使っているのであって、副作用など使っていない！

と決定しました！
パチパチパチ～
ありがとー！！

**デフォルトの名無しさん** · 2019/02/17(日) 13:09:25.08

初期化と代入の違いはC++でさんざんやったやつだろ
C++には遅延評価がないから余裕じゃないのか

**デフォルトの名無しさん** · 2019/02/17(日) 17:34:05.11

runSTという魔法がある

**デフォルトの名無しさん** · 2019/02/20(水) 10:51:29.01

Cのマクロ
#define fact(n) (((n)==0)?1:(n)*(fact((n)-1))
これだったら一見まともに見えて
実は無限ループする罠

fact(0)は
((0==0)?1:(0)*((((0)-1)==0)?1:((0)-1)*(....
となって無限ループ。
(ややこしいんで括弧の数とか間違って
るかもしれないけど)

C++でインライン関数で定義した場合は
論理式短絡評価で動くかもしれんが

**デフォルトの名無しさん** · 2019/02/20(水) 11:35:48.52

再帰を含む関数がインライン展開されることを
期待するほうが間違いだったか...

**デフォルトの名無しさん** · 2019/02/20(水) 11:43:51.95

スレチ

**デフォルトの名無しさん** · 2019/02/20(水) 16:55:25.36

テンプレートメタプログラミングでもしてろクソ

**デフォルトの名無しさん** · 2019/02/22(金) 10:09:30.67

花粉の時期に入るとみんなこれやり始めるよね

**デフォルトの名無しさん** · 2019/02/22(金) 19:18:12.74

だめだわからん

fold_left :: (a -> b -> a) -> a -> [b] -> a
fold_left _ a [] = a
fold_left f a (x:xs) = fold_left f (f a x) xs

リストが a1 a2 a3のとき

folder_left f (f a a1) [a2 a3]
になることはわかる

その先の展開が何時間考えてもわからん
f(f(f(a,a1),a2),a3)になるってゆーんだが
イメージに繋がらない

お前らこんな難解なの本当に使いこなせてるの？
ここまでわかりにくいと有用なのか疑わしく思えて来る

**デフォルトの名無しさん** · 2019/02/22(金) 19:43:58.95

>>168
foldlなんて単なるループみたいなもんだし
今どきJavaでもやるくらい

分かるまでは変に抽象化しないで、具体例で考えるといいよ

folder_left f a [a1 a2 a3]
じゃなくて
folder_left (+) 0 [1, 2, 3]
で考えるとか
そしたら
folder_left f (f a a1) [a2, a3]は
folder_left (+) ((+) 0 1) [2, 3]になる

要は最初に
int sum = 0
for(int a : xs) sum = sum + a

と書くのと変わらない
sumへの蓄積を、変数への再代入ではなく次の関数への引数として書いてるだけ

どちらかというと、いわゆる関数型っぽいのはこういうのよりfoldrでリスト作ったりするときの方かな

**デフォルトの名無しさん** · 2019/02/22(金) 19:47:35.11

>>169
まったくわからない
例題載ってるとこにも似たようなことは書いてあるんだけども

ループで書くならすぐ終わる話だけど
ややこしすぎてイメージがつかめない
イメージがつかめたらその時点で理解終了なんだけど

**デフォルトの名無しさん** · 2019/02/22(金) 19:51:15.80

a2とa3が分離されそうなことはわかるんだけども

folder_left f (f a a1) [a2 a3]
　　　　　　＾＾＾＾

こいつがどこ行くのっていうのと
どこをどうやったら（）で括られることになるのかイメージできない

**デフォルトの名無しさん** · 2019/02/22(金) 20:17:22.94

>>171
folder_left f (f a a1) [a2, a3]
になるところまではわかるんだよね？
そしたらまず括弧の中から先に計算するのはどの言語も普通だよね
だから先に(f a a1)の答えが出る
fは引数を2つとる関数だから、答えを出すのに支障はないよね
ここで(f a a1)の計算結果をz1としようか
そしたら上の式は
folder_left f z1 [a2, a3]になるよね？
そうすると、f、z1、[a2, a3]の3つの引数を使って、folder_leftがまた呼び出されるのがわかる？ここが再帰ね
folder_leftの定義は2つあるけど、[a2 a3]は空リスト([])じゃないから、下の
folder_left f a (x:xs)の方が呼ばれるよね？
ここでaはz1、xはa2、xsは [a3]だよね
だからベタで書くと
folder_left f (f z1 a2) [a3]になるよね？
同じように括弧の中が先に計算されるから、(f z1 a2)をz2としようか
そしたら
folder_left f z2 [a3]となる
また全く同じようにfolder_leftを呼び出すと、次は
folder_left f (f z2 a3) []となる
そして同じように(f z2 a3)をz3とすると、
folder_left f z3 []と書ける
ここでまたまたfolder_leftを呼び出してるわけだけど、最後のリストが空リストだよね
だからfolder_leftの2つの定義の内、上の方のfolder_left _ a [] = aが呼ばれる
上から順に呼び出し条件を見てるからね
ここでaはz3のことだから、最終的にz3が答えになる
じゃあz3が何かっていうと、(f z2 a3)だよね。そしてz2が何かっていうと、(f z1 a2)だよね
つまりz3は(f (f z1 a2) a3)のことだ
そして最後にz1は(f a a1)だから、結局
z3 == f (f (f a a1) a2) a3となる
これでどうだ

**デフォルトの名無しさん** · 2019/02/22(金) 20:22:50.89

>>172
()の中って完全に展開されるまで実行されないものと思ってた
例題もそんな書き方だったし

これならわかる！
ありがとう

**デフォルトの名無しさん** · 2019/02/22(金) 20:30:54.11

>>173
そこらへんは評価戦略の話であって別件だね
再帰の本質ではないよ
Haskellといえば遅延評価みたいなところがあるから混乱しやすいけどね

上で言うならz3こと(f (f (f a a1) a2) a3)を、最後までこの形で持って行って、最後にまとめて計算するのが遅延評価
上で書いたみたく適宜評価していくのが正格評価
Haskellだとfolder_leftは二種類あって、
遅延評価版がfoldl
正格評価版がfoldl'
ぶっちゃけ左畳み込みに関してはfoldlを使うことはない
全部foldl'でいい

**デフォルトの名無しさん** · 2019/02/23(土) 00:41:48.52

カリー化関数の意図がわからん

sum_of :: (Integer -> Integer, Integer, Integer) -> Integer
sum_of (f, n, m)
| n > m = 0
| otherwise = f n + sum_of (f, n + 1, m)

これはわかる

sum_of' :: (Integer -> Integer) -> Integer -> Integer -> Integer
sum_of' f n m
| n > m = 0
| otherwise = f n + sum_of' f (n + 1) m

どう見ても書き換えただけにしか見えないんだけどこれ意味あって書いてるのかな
カリー化って引数可変で動作する関数を定義するためのものって理解したけど
後者にはそんな意図が含まれてるように見えない

**デフォルトの名無しさん** · 2019/02/23(土) 02:34:37.24

>>175
やってるのは数式で書くと Σ[i=n..m] f(i) か
再帰をちょっと具体的に書き下さないと何のsumかわからんかった

それで多分やりたいのは
こういう風に個別の総和関数が手軽に作れますよみたいな話だと思う
タプルで定義されてるとこういう風にはいかない
(書けないことはないけどめんどくさい)

sumOfTwice :: Integer -> Integer -> Integer
sumOfTwice = sum_of (*2)

ここで(*2)とかできるのも
(*) :: Integer -> Integer -> Integer
がカリー化されてるおかげ
こういうのを部分適用と言って可変長引数とは異なる概念

**デフォルトの名無しさん** · 2019/02/23(土) 02:59:05.43

>>176
(*2)の意味わからなくて前後調べたら演算子をカリー化できるとかあって
やっと意味わかったありがとう

しかも例題の先の先の方に有効な利用法書いてあったけど
なんかどうもサイトの進め方と合わないなー・・変えるかー
こんなこと書いてもなんか意味あんのだから何なんみたいな悶々パターンが多すぎる

とても簡単ですとか書いてあったら相当難しいフラグ確定
考え方が違うんだろうな

**デフォルトの名無しさん** · 2019/02/23(土) 06:50:54.90

考え方を変えるのが関数型を学ぶ一番の目的だと思うけど、
合わないなら関数型あきらめればいいじゃん。
うちは論理型言語に全く馴染めなくて、それに時間使うのやめた。

**デフォルトの名無しさん** · 2019/02/23(土) 10:50:43.56

そうじゃない
人を信じるのをあきらめて嘘を嘘と批判する
とても簡単ですと言った奴は嘘つきのクズであると

**デフォルトの名無しさん** · 2019/02/23(土) 13:04:48.43

しかしいいサイト全然ないなどうしたもんか
お前らどうやって習得したのよこんな難解な言語

**デフォルトの名無しさん** · 2019/02/23(土) 13:35:58.14

例えばC#とF#の考え方は変わらないし
考え方を変えるというのも嘘だな

嘘に気付くのに1日かかるやつと5年以上かかるやつの差は大きい

**デフォルトの名無しさん** · 2019/02/23(土) 14:01:38.38

＞嘘に気付くのに

ひどい世の中だな

**デフォルトの名無しさん** · 2019/02/23(土) 17:11:04.23

Prelude> let foo n = ¥x -> x * n
Prelude> :t foo
foo :: Num a => a -> a -> a
Prelude> let foo10 = foo 10
Prelude> :t foo10
foo10 :: Integer -> Integer
Prelude> foo10 10
100
Prelude> foo10 20
200

Prelude> let foo100 = foo 100
Prelude> foo100 10
1000
Prelude> foo100 20
2000

Prelude> let foo5 = foo 5
Prelude> foo5 10
50
Prelude> foo5 20
100

Prelude> :t foo (1.234 :: Double)
foo (1.234 :: Double) :: Double -> Double

**デフォルトの名無しさん** · 2019/02/23(土) 17:12:26.05

>>183のクロージャの説明がさっぱりわからない

関数を生成する関数を簡単に作ることができるって言ってるんだけど
やってることは定義を繰り返してるだけでちっとも生成してない
どういう意味で関数を生成したって言ってるんだろ・・
Stringで関数生成してevalで評価しましただったらわかるんだけど、これ違うよね
それともhaskellの場合は関数定義は関数生成としているのか・・わからん
一体これは何が言いたいのか・・

実はどうでもいいことで気にしなくてもいいなら納得するんだけども

**デフォルトの名無しさん** · 2019/02/23(土) 17:31:29.38

前スレに比べて明らかに初心者が多いのは何故だ

**デフォルトの名無しさん** · 2019/02/23(土) 17:37:12.35

またHaskellのせいにしてるの？
以下は同等のJavaScriptだけど。
let foo = n => x => x * n;
let foo10 = foo(10);
foo10(10);
//=> 100
foo10(20);
//=> 200
let foo100 = foo(100);
foo100(10);
//=> 1000
foo100(20);
//=> 2000
let foo5 = foo(5);
foo5(10);
//=> 50
foo5(20);
//=> 100

てか何の言語なら知ってるんだっけ？

**デフォルトの名無しさん** · 2019/02/23(土) 17:46:51.51

>>186
そうじゃなくてこれ関数定義だけで生成なんかしてないよね？って話
ぱっと見パスしてもいいようなどうでもいいことにも見える
そうであれば次に行く

どうもHaskellは納得いかないことがあまりにも多いんだ
文化の違いなのか考え方の違いなのかわからんけど

CかObj-CかSmalltalk-80/VisualWorksで

**デフォルトの名無しさん** · 2019/02/23(土) 17:59:11.82

Cは実行時関数生成能力ないから仕方ないけど…

let foo10 = foo 10
は関数を返す関数fooに10を渡して、
関数(¥x -> x * 10)を得て（これが、ここが「生成」）
それにfoo10って名前を付けてるって理解は無理？
あなたこれまでに¥x -> x * 10って関数定義した覚えある？書いた覚えがあるのは¥x -> x * nでしょ？
まあ次行け次。

**デフォルトの名無しさん** · 2019/02/23(土) 18:05:45.67

>>188
foo10は結局のところ ¥x->x*n を呼び出してるだけじゃないの？
¥x->x*10って関数を生成してないよね？

そういうことではない？

**デフォルトの名無しさん** · 2019/02/23(土) 18:08:48.44

C++だったらtemplate引数として渡したら定義で、コンストラクタに渡したら生成
静的と動的がわかるのが前提だからわからないならpythonかjavascriptから始めるべき

**デフォルトの名無しさん** · 2019/02/23(土) 18:12:36.80

>>190
PythonならBlenderで頂点やマテリアル抽出するときに必須だったから使ったことあるけど
インデント縛りで胃が溶けそうだった
正直もうやりたくない・・

**デフォルトの名無しさん** · 2019/02/23(土) 18:18:49.99

>>189
> foo10は結局のところ ¥x->x*n を呼び出してるだけじゃないの？

Prelude> foo10 10
100
とかのこと言ってるんなら
let foo10 = foo 10
で生成した関数(¥x -> x * 10)を呼び出してるつまり
(¥x -> x * 10) 10
100

> ¥x->x*10って関数を生成してないよね？

してるよ
let foo10 = foo 10　の　foo 10の部分で。
（生成のタイミングは今回置いとくとして）

**デフォルトの名無しさん** · 2019/02/23(土) 18:28:43.67

>>192
わかった！
無名関数で定義されてるからできるってことかー
納得できたありがとう

次行ってみる

**デフォルトの名無しさん** · 2019/02/23(土) 18:29:48.03

templateとコンストラクタとメソッドの考え方
関数と関数と関数の考え方
変わったのは見た目だけ

**デフォルトの名無しさん** · 2019/02/23(土) 18:33:42.53

>>194
C++は全く知らないのでそっちはなんとも

**デフォルトの名無しさん** · 2019/02/23(土) 18:51:02.51

早速詰まった何を言ってるのかわからん

一般に、関数を呼び出す場合、関数を評価するための環境は空リストです。
最初に、引数がこの環境に追加されます。let で定義される局所変数もこの環境に追加されます。
もしも、環境に該当する変数が存在しない場合は大域変数を参照します。

たとえば、foo 5 と呼び出すと環境は次のようになります。

foo 5 ==> 環境 : [(n, 5)]

ghciで実行

Prelude> let foo n = ¥x -> x * n
Prelude> foo 5

<interactive>:2:1: error:
• No instance for (Show (Integer -> Integer))
arising from a use of ‘print’
(maybe you haven't applied a function to enough arguments?)
• In a stmt of an interactive GHCi command: print it
Prelude>

そりゃそうだよねぇ・・
なんなんだろう何が言いたいのかさっぱりわからない
本当にこんな説明でみんな理解してったの？

**デフォルトの名無しさん** · 2019/02/23(土) 19:26:38.79

>>196
そこクロージャの説明のとこでしょ？読み飛ばしていいと思うよ

手元にHaskellの入門書何冊かあるけど目次や索引にクロージャ無いし
純粋関数型言語でありデフォルトで関数がカリー化されているHaskellに
クロージャとかいう概念は別に要らないと思う
部分適用便利だねってことがわかればおk

**デフォルトの名無しさん** · 2019/02/23(土) 19:34:16.40

>>197
そっかわかったありがとう！
関数の合成もすぐわかったのでさらに次行ってみる

**デフォルトの名無しさん** · 2019/02/23(土) 20:14:35.45

データ型の定義まで来た
なんというかやっぱりこのサイトこれからhaskell入門の人にはどうでもいい余計なこと書きすぎなんじゃ・・
と思った

**デフォルトの名無しさん** · 2019/02/23(土) 21:08:00.52

do構文がIO型だからこのように書ける・・というのがどうもしっくりこないけど
都合上こうするしかなかったってだけの話で特別な意味はないのかな

calc :: IO ()
calc = do
putStr "Input Integer1 > "
x <- readLn :: IO Integer
putStr "Input Integer2 > "
y <- readLn :: IO Integer
let a = x + y
b = x - y
c = x * y
d = x `div` y
n1 = show x
n2 = show y
putStrLn (n1 ++ "+" ++ n2 ++ "=" ++ show a)
putStrLn (n1 ++ "-" ++ n2 ++ "=" ++ show b)
putStrLn (n1 ++ "*" ++ n2 ++ "=" ++ show c)
putStrLn (n1 ++ "/" ++ n2 ++ "=" ++ show d)