X
関数型プログラミング言語Haskell Part33
レス数が1000を超えています。これ以上書き込みはできません。
0002デフォルトの名無しさん
垢版 |
2020/02/10(月) 18:18:05.22ID:L6eYQqyh
過去スレ一覧
31) https://mevius.5ch.net/test/read.cgi/tech/1506447188/
30) http://mevius.2ch.net/test/read.cgi/tech/1484491434/
29) http://peace.2ch.net/test/read.cgi/tech/1436869629/
28) http://peace.2ch.net/test/read.cgi/tech/1428535861/
27) http://peace.2ch.net/test/read.cgi/tech/1420718555/
26) http://peace.2ch.net/test/read.cgi/tech/1406436392/
25) http://peace.2ch.net/test/read.cgi/tech/1393313450/
24) http://toro.2ch.net/test/read.cgi/tech/1382705669/
23) http://toro.2ch.net/test/read.cgi/tech/1376111807/
22) http://toro.2ch.net/test/read.cgi/tech/1364009659/
21) http://toro.2ch.net/test/read.cgi/tech/1358702176/
20) http://toro.2ch.net/test/read.cgi/tech/1350428908/
19) http://toro.2ch.net/test/read.cgi/tech/1340760070/
18) http://toro.2ch.net/test/read.cgi/tech/1331902463/
17) http://toro.2ch.net/test/read.cgi/tech/1325510368/
16) http://toro.2ch.net/test/read.cgi/tech/1317958045/
15) http://hibari.2ch.net/test/read.cgi/tech/1310199414/
14) http://hibari.2ch.net/test/read.cgi/tech/1299385928/
13) http://hibari.2ch.net/test/read.cgi/tech/1286706874/
12) http://hibari.2ch.net/test/read.cgi/tech/1272536128/
11) http://pc12.2ch.net/test/read.cgi/tech/1252382593/
10) http://pc12.2ch.net/test/read.cgi/tech/1231861873/
09) http://pc11.2ch.net/test/read.cgi/tech/1211010089/
08) http://pc11.2ch.net/test/read.cgi/tech/1193743693/
07) http://pc11.2ch.net/test/read.cgi/tech/1174211797/
06) http://pc11.2ch.net/test/read.cgi/tech/1162902266/
05) http://pc8.2ch.net/test/read.cgi/tech/1149263630/
04) http://pc8.2ch.net/test/read.cgi/tech/1140717775/
03) http://pc8.2ch.net/test/read.cgi/tech/1076418993/
02) http://pc2.2ch.net/test/read.cgi/tech/1013846140/
01) http://pc.2ch.net/tech/kako/996/996131288.html
0003デフォルトの名無しさん
垢版 |
2020/02/10(月) 18:18:27.57ID:L6eYQqyh
関連サイト
(英語)
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

A Gentle Introduction to Haskell, Version 98
http://www.sampou.org/haskell/tutorial-j/

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

お気楽 Haskell プログラミング入門
http://www.nct9.ne.jp/m_hiroi/func/haskell39.html

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

［入門］関数プログラミング―質の高いコードをすばやく直感的に書ける！
http://gihyo.jp/dev/feature/01/functional-prog
0004デフォルトの名無しさん
垢版 |
2020/02/10(月) 18:28:11.16ID:L6eYQqyh
質問すると埋まりそうだったので新スレ立てさせてもらいました

Stringで長さ(文字数)ではなくUTF-8コードとしての総バイト数を知れるような関数はありますか？
0006デフォルトの名無しさん
垢版 |
2020/02/10(月) 20:13:34.39ID:gQeDR86I
>>4
:set -XOverloadedStrings
import Data.Text.Lazy (Text)
import Data.Text.Lazy.Encoding (encodeUtf8)
import Data.ByteString.Lazy (unpack)
length . unpack . encodeUtf8 $ ("あ" :: Text )
-- 3
0009デフォルトの名無しさん
垢版 |
2020/02/11(火) 11:04:03.53ID:GjzPGqUa
universe-base パッケージに Data.Universe.Helpers.diagonals という関数があって、

diagonals [[1,2,3,4], [5,6,7,8], [9,10,11,12]] = [[1], [5,2], [9,6,3], [10,7,4], [11,8], [12]]

という、つまり行列を対角線状に走査して並べ直す計算をしてくれる。
で、これの関数定義がかなりシンプルなんだ。

diagonals :: [[a]] -> [[a]]
diagonals = tail . go [] where
go b es_ = [h | h:_ <- b] : case es_ of
[] -> transpose ts
e:es -> go (e:ts) es
where ts = [t | _:t <- b]

簡単な行列で関数を展開してみると何をやっているのかよく分かる。

これ考えたヤツ天才じゃね？
今の俺は他人のソースを展開して理解するので精一杯だけど、
いつかこんな関数定義ができるよう精進したい。
0011デフォルトの名無しさん
垢版 |
2020/02/11(火) 14:18:49.70ID:d+YF7kv3
J言語でも同様の操作は用意されている。
___ a =: >: i. 3 4
1 2 3 4
5 6 7 8
9 10 11 12

___ </. a
+-+---+-----+------+----+--+
|1|2 5|3 6 9|4 7 10|8 11|12|
+-+---+-----+------+----+--+
0012デフォルトの名無しさん
垢版 |
2020/02/11(火) 18:22:03.26ID:RQLUpvMq
畳み込み計算(foldじゃなくてconvolutionの方)とかやりたいときにあると便利かも？
0015デフォルトの名無しさん
垢版 |
2020/02/12(水) 13:53:42.16ID:MDE/KJVl
別に他の言語でも10倍量書けば同じことが出来るんだから使わなければいいだけ
共同作業の時は困るから天才だけでチーム組んでもらえばいい
0016デフォルトの名無しさん
垢版 |
2020/02/12(水) 14:24:47.66ID:B2qV6LKd
凡才も天才もほぼ同様に書けるpythonのような素晴らしい言語より、
凡才でも拙く書けるけど天才ならシンプルに書けるhaskellのような素人お断りな言語の方が好き。

魔法みたいで中二心をくすぐられるし、学ぶ意欲がわく。

まぁ、仕事の道具としては迷わず前者を使うけど。
0017デフォルトの名無しさん
垢版 |
2020/02/12(水) 20:45:42.48ID:DqzYUQ+/
>>9
Rなら同様の関数をもっと短く分かりやすく書ける。

diagonals <- function(A) lapply(2:sum(dim(A)), function(i) A[row(A) + col(A) == i])

diagonals(matrix(1:12, 3, 4, byrow = TRUE))

これで [[1], [5,2], [9,6,3], [10,7,4], [11,8], [12]] というベクトルのリストが
生成される。

>>16
そうだな。プログラミング言語は問題を解くための道具だが、Haskellの場合、
プログラミング言語自体が解くための問題になっている感じ。
0018デフォルトの名無しさん
垢版 |
2020/02/12(水) 22:22:34.78ID:ohhYjydu
Haskellの書き方極めればC言語に匹敵する速度が出せるって聞いたんだけどマジ？
0020デフォルトの名無しさん
垢版 |
2020/02/13(木) 02:31:41.26ID:7PHqZJTi
>>17
短さはともかく解りやすさは一概には言えないと思う。こんなのはどうかな
l = take 3 . unfoldr (Just . splitAt 4) $ [1..12]
diagonals l = map catMaybes . transpose $ zipWith (<>) (inits . repeat $ Nothing) (map (map Just) l)

> プログラミング言語は問題を解くための道具だが、Haskellの場合、
> プログラミング言語自体が解くための問題になっている感じ。
これは言い得ていると思う。Haskell の色んな所に入り込んだ抽象化のおかげで、
従来、アプリを作る末端のプログラマーが各々処理していた仕事が、ライブラリやコンパイラ側に吸い上げられる。
だから全体としての仕事の総量は少なくなる。でもそのかわり、ある程度書けるためにはベースの抽象に慣れる必要がある。
fmapってなに/モナドってなに/Foldableってなに/Lazyってなに... 学習コストは他の言語に比べてずっと高い。

>19
> Haskellの書き方極めればC言語に匹敵する速度が出せる
可能だよ
https://chrispenner.ca/posts/wc
0021デフォルトの名無しさん
垢版 |
2020/02/13(木) 04:40:03.75ID:8j+a4fKo
>>20
それ前にも紹介されてて俺もすげーなと思ったが、よく考えると、
じゃあ今wcやlsのようなLinuxコマンドをhaskellで書きたいかと聞かれれば、
べつにいいやと応える。

もっとこう、せめてSwichやPS4のインディーズゲームや、
窓の杜の人気編集ソフトレベルのアプリで、
Cと張り合う猛者は居ないのかな。

Darcsだって肝心の速度ではgitに敵わなかったわけだし。

前に、ブロック崩しでCと比較した人が居たような気がしたが、
どこのページだったかな。
0022デフォルトの名無しさん
垢版 |
2020/02/13(木) 16:46:02.30ID:7PHqZJTi
>>21
俺はコマンドラインユーティリティを Haskell で作るのイイナって思ってる。
型の恩恵でヘルプとか書き漏らさないし、単純な計算なら自動でコマンド化できるっぽい。

Haskell 製のゲームは何故かとても少ない。こちらとか
https://store.steampowered.com/app/591640/Light_It/?l=japanese

beatmaniaのような音ゲーを120行で実装するって触れ込みのチュートリアル
http://fumieval.github.io/rhythm-game-tutorial/ja.html
0023デフォルトの名無しさん
垢版 |
2020/02/13(木) 17:49:26.84ID:0eJoVY/8
>>9
Rubyだと

def diagonals(a)
m = a.size
n = a[0].size
a.flatten.group_by.with_index{|v,i| i/m+i%n}.values
end
0024デフォルトの名無しさん
垢版 |
2020/02/14(金) 14:43:09.16ID:3dEdKDtV
Haskellで書かれた他人のコードって詠みにくいと思うのは俺だけか？
型クラスやモナドが難しいというより、何がどこで定義されてるかよくわからんし、どういう動作をする関数なのかがぱっと見でわからん。
0025デフォルトの名無しさん
垢版 |
2020/02/14(金) 16:56:30.18ID:NyO1b3mL
言語というより、可読性に対する意識の問題だと思うよ
みんな薄々読みにくいと思ってるけど、互いに頭悪いと思われてマウント取られるのが怖くて言い出せないから、読みにくいコードはいつまでも読みにくいまま
実用言語では「俺が読めないのは書いた奴が悪い」が基本なので、互いに指摘しあうことで自然と改善されていく
0026デフォルトの名無しさん
垢版 |
2020/02/14(金) 16:59:16.33ID:ONnLM1s9
>>24
千差万別としか言いようがない。
Github や hackage にあるコードを見ても、分かりやすいものもあれば、そうでないものもある。
CやJava、Python などと比べて、特に差は無いように思えるが。

何かが定義されている場所は同じモジュール内か、さもなくばインポートしているモジュール内なんだから、
検索すれば見つかるでしょ。
よくわからん、という意味がよくわからん。

動作がぱっと見でわからんというのは、それこそhaskellに限った話ではないのでは？
言語の習熟度や、そのコードで解いている問題のジャンルにもよるでしょ。
0027デフォルトの名無しさん
垢版 |
2020/02/15(土) 10:44:39.37ID:2OHXNxKd
The build process was killed (i.e. SIGKILL). The typical reason
for this is that there is not enough memory available (e.g. the OS killed a
process using lots of memory).
へんなエラーが出来て今までコンパイルできなものが急にできなくなった
Haskellは最悪
もう使いたくない
0029デフォルトの名無しさん
垢版 |
2020/02/15(土) 12:35:42.03ID:2OHXNxKd
テンプレートハスケルをつかったでっかいソースだからなるのかな
一つのファイルコンパイルするのに１０分位掛かるんだけど
分割するようにすればなおる？
0030デフォルトの名無しさん
垢版 |
2020/02/15(土) 14:01:44.69ID:45cVu0dh
>>24
問題の関数を使っているモジュールをghciにロードして:iコマンド使えば、
それがどのモジュールで定義されているのか分かるが、
そう言うことではなく？
0031デフォルトの名無しさん
垢版 |
2020/02/15(土) 16:54:40.60ID:/Ku5gNgy
GHC本体も重いけどhaddockもクソ重なんだよなぁ…
Haskellで実用的なプログラムは書けないということなのか、
単にhaddockの設計がアレなのか…
0032デフォルトの名無しさん
垢版 |
2020/02/15(土) 17:37:02.81ID:J1bovO5o
ちょいとしたwebサーバーなら良いかもと思うがそれならほかの選択肢があるんだよな。。
0033デフォルトの名無しさん
垢版 |
2020/02/15(土) 17:41:30.59ID:2OHXNxKd
cabalのbaseのバージョンって指定しないとぶっ壊れてコンパイルできなくなるんだな
ハスケルには罠が多すぎる
0035デフォルトの名無しさん
垢版 |
2020/02/15(土) 18:44:53.36ID:20tth6Hi
>>33
ふーむ
cabal ファイルに書くパッケージのバージョン制限は、
その範囲ならなんでもビルドできますよ、サポートしてますよってサイン。
だから base 含め妥当なバージョンを書いておくべきってのは言えるけど…

状況はリビルドしただけで依存パッケージのバージョンが上がって壊れた、みたいな感じかな？
cabalってそんな風に動作するんだっけか
0042デフォルトの名無しさん
垢版 |
2020/02/18(火) 19:15:31.61ID:MNdOSpyG
>>40
あざっす
>>41
コンバーターを作る前段階としてのパーサーなのでコンバーターとして完成したら公開する予定です
今はdo、コピペ多用で見苦しいことになってますしｗｗｗ
0043デフォルトの名無しさん
垢版 |
2020/02/27(木) 10:14:58.86ID:MNKJ7PH5
PowerShellのリダイレクトに悩まされた
プログラムやHaskell側のエンコーディングの問題かと思ったらPowerShellの問題だった
0044デフォルトの名無しさん
垢版 |
2020/02/28(金) 00:06:13.33ID:zwPBDzBW
ハスケルむずくて嫌い
OOPっぽく拡張可能にしようとするとつい存在量化したくなってわけわからなくなる
0045デフォルトの名無しさん
垢版 |
2020/02/28(金) 01:47:53.28ID:4Hc/i95c
>>44
目標や方針を明確にしないでなんとなくプログラムすると、
拡張可能化に限らず訳わからなくなることが多いね。
haskellは特に。

だから俺は、面倒でもごく直近のゴールとその道筋をノートに書いてから、
コーディングするように心掛けてる。
頭の中だけで出来るヤツもいるけど、俺はまだ無理。
0046デフォルトの名無しさん
垢版 |
2020/02/28(金) 04:53:58.95ID:Ngh6BpVw
Writing implicit global project config file to: C:\sr\global-project\stack.yaml
Note: You can change the snapshot via the resolver field there.
Using latest snapshot resolver: lts-15.1
Stack has not been tested with GHC versions above 8.6, and using 8.8.2, this may fail
No setup information found for ghc-8.8.2 on your platform.
This probably means a GHC bindist has not yet been added for OS key 'windows32'.
Supported versions: ghc-7.8.4, ghc-7.10.1, ghc-7.10.2, ghc-7.10.3, ghc-8.0.1, ghc-8.0.2, g
hc-8.2.1, ghc-8.2.2, ghc-8.4.1, ghc-8.4.2, ghc-8.4.3, ghc-8.4.4, ghc-8.6.1, ghc-8.6.2, ghc
-8.6.3, ghc-8.6.5

32bit版のWindowsでhaskell Stackが使えない人は
C:\sr\global-project\stack.yamlファイルの
resolver:部分をlts-13.11に変更すればghcのインストールが出来るよ。

GHC8.6.4からは32bit Windowsに対応していない
https://www.haskell.org/ghc/download.html
ページの下に「LTS 13.11 for ghc-8.6.3, published 12 months ago」と書いてあるので
stack.yamlファイルを編集してこのLTSバージョンを指定した後にstack newコマンドを実行すれば
ghcのインストールが始まるよ。
https://www.stackage.org/
0048デフォルトの名無しさん
垢版 |
2020/03/02(月) 10:29:59.00ID:vpGCvE08
今までなんとなく難しそうと思って避けてたProfunctor Opticsだけど、ようやくちゃんと勉強し始めた
0050デフォルトの名無しさん
垢版 |
2020/03/03(火) 00:52:57.62ID:halZ50DI
>>49
自分は圏論をBartosz Milewskiの動画や本で勉強してるから、
彼のブログやTwitterがメインの情報源だなあ
0051デフォルトの名無しさん
垢版 |
2020/03/03(火) 01:49:10.31ID:PY4QrkVr
Haskell圏論で調和解析の問題解いてんのもしかして？
盛り上がりが別のところにあるとかどういう
0052デフォルトの名無しさん
垢版 |
2020/03/03(火) 02:02:40.82ID:PY4QrkVr
俺の推測が正しければHaskellの一番高いニーズは普通のソフト書くためじゃない。研究用だろ
0054デフォルトの名無しさん
垢版 |
2020/03/08(日) 11:51:03.08ID:+VYxIyVU
spacemacs（intero）からvscode（hie）に移行しました。
前者だとノーマルモード時に, s bでターミナル起動+stack ghciできてたのですが、
vscodeで同じようにやるのは、どうやったら出来ますか？
0057デフォルトの名無しさん
垢版 |
2020/03/09(月) 16:04:10.40ID:UrIT8yLm
>>56
以前はhaskell用のプラグインを色々入れてIDE構築してたけど全部消した。
Alignやvim-surroundみたいな汎用的なプラグインはいくつか入れてるけど、
今はhaskellに特化したものは何もない。

結局これが一番使いやすい。
Practical Vim を実践するだけでほぼ十分にすらすらプログラミングできる。

うるさいから、ghcidも止めた。

ウィンドウは左右に分けて左にソースコード、
右にターミナルを開いてる。
左はたまに更に上下に分けて2つのソースを開くこともあるけど一時的。
タブは俺は今のところ必要ないな（使いこなせれば便利だとは思う）。
0058デフォルトの名無しさん
垢版 |
2020/03/11(水) 22:40:07.34ID:Y6q+o+d/
勉強用だけど
vim -> markdown -> pandoc -> ipynb -> ihaskell
ihaskellはdockerに隔離してる
もしjupyterを使っているなら
ihaskellのインストールは気を付けた方が良いと思う
通常のインストールをしたらjupyterが壊れた
ihaskellの問題ではなく
pythonのパッケージマネージャーの問題かもしれない
0059デフォルトの名無しさん
垢版 |
2020/03/22(日) 11:54:03.39ID:WkTC8Krl
d:\Users\dev\development\Haskell\test-project>stack setup
Stack has not been tested with GHC versions above 8.6, and using 8.8.3, this may fail
Preparing to install GHC to an isolated location.
This will not interfere with any system-level installation.
Already downloaded.
Already downloaded.
Already downloaded.
Decompressing ghc-8.8.3.tar.xz...

7-Zip 9.20 Copyright (c) 1999-2010 Igor Pavlov 2010-11-18

Processing archive: C:\Users\dev\AppData\Local\Programs\stack\x86_64-windows\ghc-8.8.3.tar.xz

Extracting ghc-8.8.3.tar

Everything is Ok

Size: 2555330560
Compressed: 204702116
Extracting ghc-8.8.3.tar...
Extracted total of 10091 files from ghc-8.8.3.tar
C:\Users\dev\AppData\Local\Programs\stack\x86_64-windows\ghc-8.8.3-tmp4384\ghc-8.8.3\:
renamePath:MoveFileEx "C:\\Users\\dev\\AppData\\Local\\Programs\\stack\\x86_64-windows\\ghc-8.8.3-tmp4384\\ghc-8.8.3\\"
"C:\\Users\\dev\\AppData\\Local\\Programs\\stack\\x86_64-windows\\ghc-8.8.3\\": permission denied (アクセスが拒否されました。)


は？２GBも展開して書き込んでSSDの素子を疲弊させておいてエラー吐いて落ちるとか許せないんだが？
7-zip使って展開してるなら一時展開フォルダの指定させてほしいんだが？
Everything is Ok <- fuck なんだが？
0060デフォルトの名無しさん
垢版 |
2020/03/22(日) 12:10:51.78ID:F4lre3ad
スレチなので7-zipのスレへどうぞ
0062デフォルトの名無しさん
垢版 |
2020/03/22(日) 14:03:20.64ID:WkTC8Krl
ghcを解凍するフォルダのセキュリティを、Everyoneに変更許可を与えると通ったわ
なんでそうなるのかは判らん。フォルダのリネーム（もしくはフォルダ間のファイル移動）に自分以外のアカウントが関わってて、
そいつが権限持ってないから拒否されたってことになるのか

それはそうと、stackの台詞眺めてると this may fail 多いな。自信ないのかよ
そんなんじゃ頼れないよ
0063デフォルトの名無しさん
垢版 |
2020/03/22(日) 15:30:18.75ID:RcMMm8Pa
stackが新しいGHC(を使うStackage LTS)で警告出す件は本家にissue出とるね
Warnings about untested GHC and Cabal
https://github.com/commercialhaskell/stack/issues/5212

stackは去年の7月以来新バージョンのリリースが止まってる
(何かいざこざがあったようなことを目にしたような覚えが…)
https://github.com/commercialhaskell/stack/releases
コミットは止まってないようだけれど
https://github.com/commercialhaskell/stack/commits/master
0064デフォルトの名無しさん
垢版 |
2020/03/24(火) 18:40:03.52ID:u3xw5MBv0
謎のPermission Denied 問題の解決策は chcp 65001 かよやられた

それにしてもサンプルのビルドひとつすら乗り越えられず
あまつさえググることすら向き合えず
大望を抱いたあげく最初の石ころにつまづいて数日を無為に過ごすとは… ああ、
0067デフォルトの名無しさん
垢版 |
2020/03/26(木) 19:26:27.91ID:Irxv1x7O
Haskell自体はクソの役にも立たないが、Haskellを勉強すると実用言語でプログラミングする際のコードが劇的に綺麗になる
0068デフォルトの名無しさん
垢版 |
2020/03/26(木) 19:37:30.96ID:V4QUinUk
綺麗になるんじゃなくてHaskellerにとって読みやすいコードを練成できるようになるだけでは
0069デフォルトの名無しさん
垢版 |
2020/03/26(木) 20:35:55.95
数年ぶりにハスケルやったらタブはやめろって明言してくるようになっててわろうたｗｗ
0070デフォルトの名無しさん
垢版 |
2020/03/26(木) 20:45:53.86ID:ylVms19z
Haskellerにとって読みやすいコードわかる

MonadだのApplicativeだのを無理に再現しようとして
でも型システムがへぼいから限界あって買いてる方も楽しくないし
読む方の辛さは言わずもがなだしで誰も幸せにならない
0071デフォルトの名無しさん
垢版 |
2020/03/26(木) 23:26:28.22ID:yOeobzsz
他言語よりも深く考察され美しくまとまった言語上の概念がものすごく多数ある
抽象的な概念が他の言語より圧倒的に多くて、プログラミング言語全般についての理解を深めるのにとても役に立つ
比較的習得難易度の高いrust等の言語や、今後出てくるであろう新手の言語等も、haskellを知っていれば習得が容易になったり、深く理解して議論できるようになったりすると思う
実用アプリ作りたいだけならあんまやる必要ない
0072デフォルトの名無しさん
垢版 |
2020/03/27(金) 01:37:52.01ID:HVPmfsVI
モナドの説明見て一気に嫌になったな・・
結局書き換えをよしとするなら純粋関数型なんて言うのやめろよと
破壊操作無くしてまともにコードが書けないってことがわかってるなら最初からそのようにしておけと
どう言う目的で作った言語なのか知らないけど読めば読むほどイライラするねこれ
現実は酷いけど理想だけが飾り立てられているという印象
0074デフォルトの名無しさん
垢版 |
2020/03/27(金) 07:23:52.96ID:7fKLUCpq
そんなに間違ってはないけどな。
haskellの解釈としては「命令列」を構成して返しているから副作用はない！
副作用を起こしているのは実行系だ！
みたいな屁理屈だし。
0076デフォルトの名無しさん
垢版 |
2020/03/27(金) 11:19:04.85ID:7fKLUCpq
haskellの評価順序を考えた場合、そう解釈する以外ないと思うが。
他の説明があるなら聞きたいとこだよ。
0079デフォルトの名無しさん
垢版 |
2020/03/27(金) 12:16:47.55ID:1lYTVmI1
>結局書き換えをよしとするなら純粋関数型なんて言うのやめろよと
>破壊操作無くしてまともにコードが書けないってことがわかってるなら最初からそのようにしておけと

その批判はやや的外れ
誤解してる人が多いけど、Haskellは別に破壊的代入含む非純粋な計算を禁止しようとしてるのではない
Haskellのやろうとしてるのは、純粋な計算と非純粋な計算を型システムにおいてコンパイラが区別できるようにすることだけだぞ
0080デフォルトの名無しさん
垢版 |
2020/03/27(金) 12:26:56.96ID:1lYTVmI1
というか正直モナドなんかそんな何回も何回も繰り返し議論の対象にするほどのもんでもないだろ…
HaskellスレなんだからHaskellerだけでもっとHaskellらしい話題がしたいのに、
定期的にHapkeller以外がきて水差してくよな
他の手続き方言語のスレでわざわざその言語よく知らない奴が来てifとかforの話を延々されたらどんな気分よ
0083デフォルトの名無しさん
垢版 |
2020/03/27(金) 17:41:48.21ID:IjRdCSk7
- Haskell自体はクソの役にも立たないが、
- 実用アプリ作りたいだけならあんまやる必要ない

何故だい? プログラミング言語なんてただの道具じゃないか。Haskellで良いプログラムが 書けるなら、使うべきなんだ。
『普通のやつらの上をいけ』！『普通のやつらの上をいけ』！
0085デフォルトの名無しさん
垢版 |
2020/03/27(金) 18:46:42.72ID:inQsOLrL
IO a は State# RealWorld -> (# State# RealWorld, a #) を newtypeしたものだって話じゃないか？
命令列っていうのはState# RealWorldの列ってことだろ、多分
0086デフォルトの名無しさん
垢版 |
2020/03/27(金) 18:50:49.13ID:inQsOLrL
言語ではState# RealWorldの列だけ作って副作用ないけど
処理系がState# RealWorldの列を一気にフラッシュしてるから
処理系レベルでは副作用が出るって事だろ
0087デフォルトの名無しさん
垢版 |
2020/03/27(金) 19:23:16.95ID:7fKLUCpq
大体そんな感じ。
IO を返す関数が「副作用をもたない」と解釈するとしたらそう考えるしかない。
とはいえ、IO が発生する関数とそうでない関数をちゃんと分けていい感じに使うって
発想は他の言語でも役に立つ考えだからそこはいいと思う。
0088デフォルトの名無しさん
垢版 |
2020/03/27(金) 19:40:29.88ID:US1WE8+5
>>83
目的は良いプログラムを書くことではなく役に立つプログラムを書くことだろう
お前のようにそこを履き違えてる奴が多いからHaskellがいつまでもクソの役にも立たないと言われ続けるんだよ
0089デフォルトの名無しさん
垢版 |
2020/03/27(金) 19:46:20.02ID:adWh10vX
まともなHaskellのテキストがIO返す関数に対して副作用がないなんて書いてるの見たことないけど…
0091デフォルトの名無しさん
垢版 |
2020/03/27(金) 19:58:51.05ID:inQsOLrL
realworld Haskellって本のrealworldってghc におけるIOモナドの実装のこと言ってて
モナドの説明で度々出てくる『文脈』っていうのもその命令列のことだと理解してるんだが
どんなもん？
0092デフォルトの名無しさん
垢版 |
2020/03/27(金) 20:03:05.86ID:EYGPwzDC
そんな難しく考えなくても計算機に与える命令のつらなりってことじゃないの？
命令には純粋っぽい命令とそうでない命令があるけど、計算(評価)前ならどんな命令だろうが単なる値だから副作用もへったくれもないって理屈じゃね
実際はメモリー上の命令は全て状態だけど、書き換えられないように管理すれば純粋とみなせるってことだろ
例えば、
1+2*2^2^-1+3*3^3^-1
という式を考えた場合、これ全体を値として捉えることもできる
実際値として使おうとすると+、*、^の部分を命令として評価しないといけないけど、使い方によっては全部評価する必要はない
これに10足したかったら
11+2*2^2^-1+3*3^3^-1
で済ますこともできる
これを小数点以下10桁まで表示したくなった時、必要な桁まで計算(評価)すれば良い
‭18.1551758356…
Haskellの基本的な考え方はこういうことでしょ
0093デフォルトの名無しさん
垢版 |
2020/03/27(金) 20:16:36.86ID:adWh10vX
まずはっきりさせておきたいが、Haskellのテキストで
「命令列」なるものは出てこんし誰もそんなものを使ってモナドを説明しようとしてない。
あくまで「命令列」とは、>>74が自身でモナドを理解するために有用な概念だと見出し定義した用語と考えるべきだ

だからここで有意義な議論がしたいなら、まず目的を確認する必要がある。
我々は>>74さんの頭の中を理解したいのか？
それともモナドに対してより良い理解を形成したいのか？
0094デフォルトの名無しさん
垢版 |
2020/03/27(金) 20:19:07.32ID:inQsOLrL
遅延評価と考え方は似てると思う。状態の受け渡しとかが出てきてこんがらがる
0095デフォルトの名無しさん
垢版 |
2020/03/27(金) 20:21:43.46ID:inQsOLrL
>>93
自分も>>74の理解で問題ないと思うんだよ
0096デフォルトの名無しさん
垢版 |
2020/03/27(金) 20:47:16.26ID:oRj/lH5B
IOモナドに副作用を追いやれることがどれくらい良いことなのかを議論するのは悪くないと思うけど、
副作用が無いなんて嘘付き！とかそもそもプログラムってのは副作用の塊だ！っていうのは誤解か誤読かフカシに騙されたかのどれかなので楽しくない話になる、と思う
0098デフォルトの名無しさん
垢版 |
2020/03/27(金) 21:16:36.28ID:7fKLUCpq
>>93
別に厳密に何か言ってるわけでもないからあんたの思ってる通りでええよ。
ただの解釈だからこだわらずに勝手に理解したらいいさ。
0099デフォルトの名無しさん
垢版 |
2020/03/27(金) 21:17:09.88
言語設計者じゃなければ難しいこと考える必要なんてないんだ。ただの Haskell ユーザだろ？
（Haskellの）モナドは Haskell という基盤上で動作するDSLプラットフォームだよ。
各々が Haskell 上で動作するオレオレ言語を作れるんだ。
だから一度それを走らせれば、その中に他人の言語が干渉することはできない。
C++を書いてる途中でJavaコードを直接混ぜることは許されないというトートロジー。
他のDSLとはポートを作ってそこでデータを輸出入する

（Haskellの）モナドはC++コードにJavaコードが混ざらない事を保証してくれる
そういうイメージ

（Haskellの）モナドのライブラリには、その設計者の思想によるDSLの書き方がある。
それを知らずに型とだけ睨めっこしててもIQテストだよ
0100デフォルトの名無しさん
垢版 |
2020/03/27(金) 21:54:14.38ID:62v2q1lB
>>96
Haskellの解説本・サイトは「副作用のないプログラミング!」のように喧伝し、
副作用がまるで悪いものであるかのように誤認させているからな。

医薬品の副作用は意図しない有害な作用なので避けるべきだが、プログラム言語の
副作用は数学的な意味で関数とは言えないだけで、意図した有益な作用だから何の
問題もない。副作用があろうとなかろうと、関連が深い処理をまとめて記述する
手続き型言語の方が使いやすい。

純粋関数型なんて実用性が大きく劣る。ラムダ関数や高階関数など関数型の
おいしい所だけ手続き型に取り入れるのが賢明。
0101デフォルトの名無しさん
垢版 |
2020/03/27(金) 22:59:10.30ID:adWh10vX
>>100
うん。だからあなたは純粋関数型なんて実用性が大きく劣るものなんか使わず
あなたの好きな手続き型の言語で実用的なプログラム書いてればいいじゃん。
その言語のスレにいってその言語の好きなところとか新しく出てきたすごい機能とかの
話題で盛り上がったほうがよほど生産的ではなくて？
わざわざこんなスレにツバかける来る暇があったらさあ。
0102デフォルトの名無しさん
垢版 |
2020/03/27(金) 23:33:11.47ID:gM1jKcLP
>>93
おれも同意だね
ここに限らず命令列、指令書みたいなメタファーで説明しようとするやついるけど
初学者にとって全く理解の助けにならない
プログラミング言語を説明するのに命令列って説明になってない

worldの考え方とモナドによる隠蔽で説明した方が理解しやすい
0103デフォルトの名無しさん
垢版 |
2020/03/27(金) 23:51:09.98ID:bDbxDlCw
Mワードは控えようね！
0104デフォルトの名無しさん
垢版 |
2020/03/28(土) 09:17:26.94ID:HVNiklPA
実装に依存するな、メタファーに依存しろ

こういうのって実装はコロコロ変わるがメタファーは不変という前提なんだよね
前提が崩れたらやっぱり実装に依存する方が正解だったことになる
0105デフォルトの名無しさん
垢版 |
2020/03/28(土) 11:10:45.76ID:qGbN9Cxf
モナドに関しては、モナドというインターフェースを実装しとけばそのデータはdo記法という特殊構文に対応する
ぐらいの説明でいい

IOモナドに関しても、world云々とかioモナドの実装とか知らなくても問題ない
IOアクションをdo記法で組み合わせて手続型言語風の書き方を再現できることだけ知ってれば良い
0106デフォルトの名無しさん
垢版 |
2020/03/28(土) 12:07:59.94ID:6h+JM2Gw
>>88
ハァ？ じゃあ役に立つプログラムを書けばいい

良い／役に立つはどう違うか、説明できないだろ
雰囲気で誤魔化せると思っているお前みたいなアホが真の元凶
良いプログラムが役に立つプログラムと無関係なら、良いなんて指標は何の役にも立たん

Haskellで役に立つプログラムをお前が書け
それができないならせめて、何が足りないのか言え
0107デフォルトの名無しさん
垢版 |
2020/03/28(土) 12:16:59.39ID:6h+JM2Gw
このスレだけでなくあちこちに、"悟り派"が蔓延ってるのにそろそろ一言言っておくぞ
悟り派は、Haskellで悟りを得て自分の言語に持ち帰る
そして自分の製品のなかに不完全なHaskellのサブセットを作ってブーたれる。やれ遅延評価がない、モナドがない…
そんなんするくらいなら最初からHaskellで書けや

新規の参入、それ自体はいいことだが…
0108デフォルトの名無しさん
垢版 |
2020/03/28(土) 12:38:06.30ID:6h+JM2Gw
>>104
IOアクションの命令書のメタファーは登場した当初から変わってないでしょう

>>102
指令書のメタファーは初学者にとって助けにならない？
そうかな、わかりやすいと思ったけど
RealWorld の State 、って説明はこっちはこっちで腑に落ちたし

>>92
の解説は、自分はなんか違和感を持ったが… うまく反論できない
0110デフォルトの名無しさん
垢版 |
2020/03/28(土) 12:53:14.21ID:6h+JM2Gw
>>101
「ついてこれないならついてこなくていい」スタイルもどうかと思うぞ
そんなんやってたら、いずれ砂漠になっちまう
ただでさえスレッドが一週間止まるなんてざらにある現状なのに

>>100
> 副作用があろうとなかろうと、関連が深い処理をまとめて記述する手続き型の方が使いやすい
Haskell はモナドの do 構文を通して手続きをサポートする。手続き型言語でもある
副作用の有無に関わらず処理をモジュールにまとめることはできる
むしろ入出力が型に明に表れるので通信的凝集などの高凝集なモジュール分けに自然になりやすい

ただそれと引き換えに、ラフに、スケッチ的にプログラミングするのがやりにくい
これは原理的なトレードオフではないと思うが、少なくとも現時点ではそうだ
0111デフォルトの名無しさん
垢版 |
2020/03/28(土) 13:03:17.72ID:6h+JM2Gw
>>109
(雑種って言い方がすでに汚ねぇ)
人種にするみたいに、思想に文句をつけてるわけじゃなくてだな…
プログラマー全体の仕事の総量は増えてるってことを批判してる。非効率
0113デフォルトの名無しさん
垢版 |
2020/03/28(土) 13:39:06.65ID:6h+JM2Gw
>>112
そんな面倒なこと？
Haskell風ライブラリを作ることか？ それとも最初からHaskellでやること？
後者だとすれば何がボトルネックになっているのか
0114デフォルトの名無しさん
垢版 |
2020/03/28(土) 13:51:46.86ID:HVNiklPA
言語仕様はよいよね
実装はどこがよいのかさっぱりわからんが、知らなくても問題ないと言われる
0115デフォルトの名無しさん
垢版 |
2020/03/28(土) 14:01:08.48ID:sKmY04JT
なら、F#でいいと思います。
副作用もあるし、コンピューテーション式もあるよ。
0117デフォルトの名無しさん
垢版 |
2020/03/28(土) 14:06:58.93ID:6h+JM2Gw
>>115
ふむ、それらがあった方が Haskell よりも良い――その理由を説明してほしい
Haskell サイドに取り入れられるかもしれない
0121デフォルトの名無しさん
垢版 |
2020/03/29(日) 21:28:27.32ID:AoSt3bhf
Haskellの理解に圏論は必要ないとよく言われるけど、
End/Coend勉強したらHaskellのポリモーフィズムとか
存在型のことがよくわかったし、
コモナドとか余代数は圏論的理解しといた方が絶対にいいなと思った
今はKan拡張に挑戦中だわ
0123デフォルトの名無しさん
垢版 |
2020/03/29(日) 21:42:16.37ID:dETyGOxM
>>121
理解が何を指しているかによる

haskellでwebアプリやゲームを作ることができる
というのが理解の指標なら、圏論は知らなくてもいい
0124デフォルトの名無しさん
垢版 |
2020/03/29(日) 21:46:33.53ID:AoSt3bhf
>>123
ekmettのライブラリとかHaskellの型システムを強化する言語拡張など、高度に抽象的なコンストラクションがどういう意図で作られていてどういう場面で役に立つのか
0125デフォルトの名無しさん
垢版 |
2020/03/30(月) 04:34:10.51ID:BWxPCUH7
>>121
うい。
知ってた方が良いけど、知らなくても使えはする。
むしろ最近はHaskellより圏論に興味が移ってる。
(Haskellやその他の言語はその理論の確認用)
0126デフォルトの名無しさん
垢版 |
2020/03/30(月) 04:43:23.39ID:BWxPCUH7
>>66
手続き型言語と数学の関連性が見える様になると、数学的に正しい=バグが無いプログラムを書けるようになる。
だったら数学(特に圏論)だけで良いんだけど、ほぼ数学なHaskellで実際に動かして手続き型言語と数学の共通点を確認出来る。
0127デフォルトの名無しさん
垢版 |
2020/03/30(月) 04:50:50.17ID:BWxPCUH7
モナドについてはDSLと言うのは言い得て妙で、mainはIO ()を得るために式を展開する。
その過程で副作用を含む式が動き出す。
個人的にはHaskellは副作用は有るが、参照透明性は崩れていないと言うのがHaskellが純粋関数型言語を主張する根拠なのだと思う。
0128デフォルトの名無しさん
垢版 |
2020/03/30(月) 05:26:16.39ID:RViSHasz
アプリを作ることに限れば、圏論の触り部分すら知らなくても問題ない。

C#やJava、Pythonは大して深く理解していない入門を抜けたばかりの人でも、
アドバイスを受けながら一通りアプリを完成させられるでしょ。
未知の必要なライブラリも本やドキュメントを読んで使い方を学べるでしょ。

haskellもまったく同じ。
入門を抜けたらすぐにアプリを作れる（し、そうすべきだと個人的には思う）。
そこに圏論の知識は微塵も要らない。

圏論の知識が活きるのは意味論をしっかり考える時だ。
**に圏論が役立ったよ、圏論のおかげで**が理解できたよと言っている人は、
意識的にせよ無意識的にせよ、その**の意味論を考えてたのではないか。

それ自体は素晴らしいことだと思う。
でもそこまでの深い理解がなくても実用的なアプリは問題なく作れる。

因みに、バグを減らすのにも圏論の知識は必要ない。
0129デフォルトの名無しさん
垢版 |
2020/03/30(月) 07:45:32.21ID:b0eBXbnt
HaskellをやってるうちにHaskellの魅力に気づいて
Haskellで何かを作るよりもHaskellという言語自体のことをもっと深く知りたくなることもあるだろ
そう言う場合に圏論は最良の選択だよ

俺としては、Haskellでアプリを作るためにはまあ圏論を知らなくてもいいと思うけど、
圏論を勉強すれば、より高い視点から見えるものもある
必須じゃないが、苦労して圏論を学んだボーナスだな
0130デフォルトの名無しさん
垢版 |
2020/03/30(月) 09:41:29.75ID:rvpoYgUk
モナドがらみだとF#のコンピューテーション式使って
async定義されてるらしいな　ちょっと、モナド凄いと思ってしまった

裏で共通作業をするって意味なら分からなくはないけど、
その仕掛けは気になる

F# vNext は何が "ヤバい" のか: Monadic Programming の新時代
https://qiita.com/cannorin/items/1936faded610c3ab6c18
0131デフォルトの名無しさん
垢版 |
2020/03/30(月) 18:05:04.07ID:Dztwglzx
型クラスとインターフェースがなんとなく似てるので、
型クラスのようなことをインターフェースでまねしようとしてなんか違う…ってなってたけど、やっとなぜなのかわかった

インターフェース(クラスポリモーフィズム)って、そもそも型クラスとは全く別物で、むしろ存在型の一例になってるだな
やっぱり型クラスは型クラスで、型クラスのない言語でこ対応物なんてなかったんや
0134デフォルトの名無しさん
垢版 |
2020/03/31(火) 11:43:52.10ID:0EnDwwx5
目的はお金でも知識でもいいよ
例えばお金自体が目的だったらそのお金が無駄に多過ぎるんじゃないかとか心配する必要はない
0136デフォルトの名無しさん
垢版 |
2020/03/31(火) 13:55:00.32ID:0EnDwwx5
事前に目的を決めても「俺すげーしたいだけ」とかいう真の目的が後から出てくる
事前に嘘をついていたことか問題だと思えば沈黙が正解

だが隠し事をしていたことが問題だと思えば沈黙は悪
黙っているくらいなら嘘でも何か言った方がマシと思ってますます嘘が増える
0137デフォルトの名無しさん
垢版 |
2020/03/31(火) 18:03:32.10ID:pMTrfgV+
存在しない敵に吠え続ける
0138デフォルトの名無しさん
垢版 |
2020/03/31(火) 18:05:52.76ID:j91gJgzW
>>135
学歴コンプやばそう
0139デフォルトの名無しさん
垢版 |
2020/03/31(火) 21:38:58.38ID:OTxurRkT
だから金だろうと知識だろうと、学歴だろうとなんでもいいんだよ。
糞みたいなプライドで開発の邪魔しなけりゃな。
0140デフォルトの名無しさん
垢版 |
2020/03/31(火) 23:05:18.94ID:gNdJtX6R
学歴だろうと知識だろうと仕事の腕前だろうと、
お前らキモオタクがそういう承認欲求を満たそうとすると裏目に出るだけだぞ
表ではお世辞であしらわれて、裏ではチョロいとナメられるのがオチ
0141デフォルトの名無しさん
垢版 |
2020/03/31(火) 23:24:14.95
トンデモを惹きつけてしまうのは Haskell の業
アイドルにストーカーがついてまわるのと抽象的構造が似ている
Haskell は高度知的アイドル型言語
0145デフォルトの名無しさん
垢版 |
2020/04/01(水) 13:27:17.06ID:0siDwK7Q
simulationライブラリで純粋な関数式プログラミングをする
ttp://x0000.net/topic.aspx?id=3631-0

UIライブラリ (C#, 2D) を作ったよ
ttp://x0000.net/topic.aspx?id=3688-0

学術巨大掲示板群: アルファ・ラボ
ttp://x0000.net

物理学 化学 数学 生物学 天文学 地理地学
IT 電子 工学 国語 方言 言語学 など
0148デフォルトの名無しさん
垢版 |
2020/04/02(木) 01:48:53.35ID:l/tHPd/2
Haskellって技術書少ないよな
みんな何で勉強してんの？
0149デフォルトの名無しさん
垢版 |
2020/04/02(木) 05:42:29.80ID:RR8wjO3M
>>148

マイナー言語の割には多いと思うけど。

人気ランクが上のkotlinやclojure、elmは少ないし、同じぐらいの順位のprologやsmalltalkは新刊が出てなくて、昔出た書籍のほとんどが絶版している。
0151デフォルトの名無しさん
垢版 |
2020/04/02(木) 06:33:57.84ID:6/i0fPdP
>>148
特別なことはなく、ネットや本で学んだよ
例えば

・Thinking wih Types
型レベルプログラミングを学んだ
https://leanpub.com/thinking-with-types

・Optics By Example
lensに代表されるopticsを学んだ
https://leanpub.com/optics-by-example

・Hexagonal architecture
Haskell & DDD でアプリを作るパターンの一つを学んだ
https://blog.ploeh.dk/2016/03/18/functional-architecture-is-ports-and-adapters/

・Effect system
IOを安全に扱う方法を学んだ (正確にはモナドの合成を分かりやすく扱う方法)
DDDによるアプリ制作においてさっきのが戦略とすれば、こっちは戦術
http://okmij.org/ftp/Haskell/extensible/exteff.pdf
ライブラリもいくつかある

あと、Redditの投稿を追いかけていれば色々学べる
https://www.reddit.com/r/haskell/


と言うか、紹介しきれないほどの情報がネットに溢れているんだが
0152デフォルトの名無しさん
垢版 |
2020/04/02(木) 15:08:36.64ID:ttPPzFzn
情報収集のスキルは人それぞれでしょ
reddit はニッチなライブラリの質問とかリリース情報みたいなの多くね？
かったるくていちいち追ってられない

俺はそういうのは twitter にいる Haskell 賢人に任せている
これ面白いよ！って記事をフィルタして共有してくれるから、それ読んで勉強してる
ありがたや ありがたや
0154デフォルトの名無しさん
垢版 |
2020/04/03(金) 02:49:35.37ID:y19+kh0E
>>150
日本語の書籍の事だろ？
それは先ずない
ロシアが次点あとはドイツなんかも結構あるドイツは翻訳ばっかだが(´・ω・｀)
0159デフォルトの名無しさん
垢版 |
2020/04/03(金) 16:45:57.10ID:ked6xspS
日本の翻訳文化って外国語を自国語に取り込んじゃうのがすごいとかなんとかって話で、翻訳量自体は別にそれほどでもなかった気がする
0160デフォルトの名無しさん
垢版 |
2020/04/03(金) 17:43:30.64ID:VVxcL9Mv
オーバーシュートω
ロックダウンωωω
0161デフォルトの名無しさん
垢版 |
2020/04/03(金) 17:47:56.79ID:JepZACIl
マジレスすると多分中国語が英語の次だろうな
場合によっちゃ英語より多いかもしれん
中国語の場合は入ってくるだけで出ていかないブラックホールだから実態が掴みにくい
0164デフォルトの名無しさん
垢版 |
2020/04/03(金) 18:57:42.55ID:Yw161NPN
はーい先生怒らないから犯人は正直に手を挙げなさい

>「プログラミング初心者なんですけど、何からやったらいいですか？
> 最近ようやくJavaScriptが少しだけ読めるようになってきた頃です」。
>
> そうしたら「JavaScriptなんて暗黒で恐ろしい言語はダメだ、純粋関数型言語であるHaskellからやった方がいい」みたいなことを言われました。

https://codezine.jp/article/detail/11885
> 「わからなかったけど、コードを書いて動かす楽しみと快感を覚えたんですよ。
> Haskellをもっと理解したいと相談したら、『圏論の基礎』という本を勧められました。
> でもその本も全然わからなかったんです（笑）」
0166デフォルトの名無しさん
垢版 |
2020/04/03(金) 20:09:26.90ID:Yw161NPN
初手マックレーンは草 ...ってか鬼畜
もっとこう RealWorldHaskell とかあるでしょ
0167デフォルトの名無しさん
垢版 |
2020/04/03(金) 20:11:51.67ID:Yw161NPN
>>163
エンジニアの容姿を判定するのは無しだろうよ...
なんだ Haskell は、高潔なのは言語仕様だけか？
0170デフォルトの名無しさん
垢版 |
2020/04/03(金) 23:36:38.26ID:Wo72KAYJ
学術的に進化してもらって
実用的な部分をメジャー言語が取り込んでくれればおk
0171デフォルトの名無しさん
垢版 |
2020/04/04(土) 00:13:54.60ID:HfszwI8c
>>151
>例えば
テンプレ入
0173デフォルトの名無しさん
垢版 |
2020/04/04(土) 14:52:35.68ID:ym7hUMuJ
むしろミーハーでもなんでも構わんのだけど、いち Haskeller が女性ってだけで
容姿を蔑んだり・持ち上げたりする連中がいるなら――もしいるのなら反省してほしい、と思った。

DSL を Freeモナドにするか、Tagless Final にするか、それぞれのメリットはなにか…
Haskeller はそういうことで悩んでいたいのであって、性別とかを理由に余計な荷物を背負わせるべきじゃない。
(ghc も依存している llvm はそういう辛さを避ける為に行動規範を定めているんだけど、いまのところまだ ghc には無いっぽい)
https://llvm.org/docs/CodeOfConduct.html
0174デフォルトの名無しさん
垢版 |
2020/04/04(土) 14:56:51.64ID:ym7hUMuJ
>>169
個人的な Haskell のイメージは、なんかシュッとした紳士みたいな感じ
エラーメッセージは確かに、ともすると口うるさいw
0176デフォルトの名無しさん
垢版 |
2020/04/04(土) 17:30:47.61ID:V7kxF8pu
haskellでやり過ぎなほど徹底的に宣言性にこだわってプログラムする実験をしてみたが、なかなか面白いぞ。
手続き的になりがちなゲームプログラミングでやってみると特に。
0177デフォルトの名無しさん
垢版 |
2020/04/04(土) 20:17:31.82ID:H4c+c10U
今から出会い系の女と会ってくるがやばいんか？
0182デフォルトの名無しさん
垢版 |
2020/04/05(日) 14:28:05.53ID:k4Q+DqWZ
>>181
HaskellでActionという用語をみたことが俺はないけど、Haskell直系の子孫のPureScriptだと
型注釈の->の右辺にEffectがある関数をアクションと定義するそうだ。
EffectはHaskellでいうIOに対応すると思ってもらえたらいい。
ちなみに->の左辺にEffectがある関数をハンドラという。


-- アクション
throwException :: forall a. Error -> Effect a

-- ハンドラ
catchException :: forall a. (Error -> Effect a) -> Effect a -> Effect a
0191デフォルトの名無しさん
垢版 |
2020/04/06(月) 09:29:24.23ID:H7siEM1Y
CabalのドキュメントのSecure repository のところ、
root.jsonのkey idを省略するのはお勧めしないとか書いてるけど、
なにかしないといけないの？
0193デフォルトの名無しさん
垢版 |
2020/04/07(火) 07:33:13.33ID:UmG0jYGu
本当に言語に詳しい奴ってのはその言語の弱点をしっかりおさえてるもんよ。
0194デフォルトの名無しさん
垢版 |
2020/04/07(火) 07:36:16.93ID:SJ9J2Mim
？
0195デフォルトの名無しさん
垢版 |
2020/04/08(水) 08:37:32.33
IO がオルタナティヴになったのって最近なのか
Aizu Online Judge のGHCだとコンパイルエラーになる
0197デフォルトの名無しさん
垢版 |
2020/04/12(日) 14:46:14.07ID:qLx35nn/
目的は二つ
式を評価し過ぎないこと
副作用を実行し過ぎないこと

手段はただ一つ
最外簡約
0199デフォルトの名無しさん
垢版 |
2020/04/12(日) 19:41:52.11ID:EEQhx4+u
codewarの問題をHaskellで解いてみてるんだけど
、12000msタイムアウト多発する
リスト内包表記とか再帰はHaskellerはあんまり使わないの？
nに含まれる素因数とかすぐタイムアウトする
0200デフォルトの名無しさん
垢版 |
2020/04/12(日) 21:46:48.73ID:ogEgOOCw
>>199
arithmoiとかのライブラリ使うとめっちゃ速いよ
ソースを見てみるといいかも

あと、prime factorization haskell
とかをキーワードにして検索してみるとか
0201デフォルトの名無しさん
垢版 |
2020/04/12(日) 22:42:42.81
Haskell で競プロ辛い・・・
200000個の整数読み込んで処理するような問題だとMLEになりがちだ
本当にそんなに使ってるのかよ・・・疑わしいなぁ

ランタイムがとりあえずあるだけ使おうとして、足りなくなったらもう要らない空間を探して、そこに上書きするようにしてるの？
だとすると、とりあえずあるだけ使おう期間の段階で上限ぶっちぎってるってことかね
もしかして

GHC「記憶域ください」
競プロシステム「あなたは上限なのでもうあげません」
GHC「仕方ないな、じゃあガベージコレクションしてなんとかやりくりしよう」

ではなくて

GHC「記憶域ください」
競プロシステム「どうぞどうぞ」
GHC「どうも」
競プロシステム「はいそれは毒まんじゅうです。今のでMLEです」
GHC「えっ！！！！」

こうなんじゃないか？
ソースコードで「メモリ使用はは150MB以内で巧くやりくりしろ」とかって制限の指示できないんですか？
0206デフォルトの名無しさん
垢版 |
2020/04/13(月) 06:56:02.05ID:rnoGia+U
競プロ mle でググってみた

MLE
メモリリミットエラー(Memory Limit Error)の略
提出したプログラムが許可された以上のメモリを使用したときに出る
（一部のコンテストで採用されている表現）
0207デフォルトの名無しさん
垢版 |
2020/04/13(月) 12:33:53.04ID:tr0y4100
>>201
とりあえずローカルでプロファイル取って実行してみると
スペースリークや大量のGCの原因が推定できるはず
(「Haskell プロファイラ」とかでぐぐって)
未評価のサンクが大量に積み上がっているとか、
イミュータブルな連結リストの使い方が悪くて
大量の一時リストを作ってしまっているとか
あたりじゃないかと想像してみる
0208デフォルトの名無しさん
垢版 |
2020/04/13(月) 13:06:48.82ID:pEw+DEbK
タイムアウトのやつ
この問題やってて
ttps://www.codewars.com/kata/54d496788776e49e6b00052f/train/haskell

通らないコードがこれ
sumOfDivided :: [Integer] -> [(Integer, Integer)]
sumOfDivided xs = map (\x -> (x,foldr (+) 0 (filter ((==0).(flip rem x) ) xs)) ) $ prime_factors ( product xs) 2
where
prime_factors 1 _ = []
prime_factors m n
| rem m n == 0 = n : (prime_factors (quot m n) $ n+1)
| otherwise = prime_factors m $ n+1

こういう感じでコード組み立てるんだけど、他の問題でもしょっちゅうタイムアウト起こしてる
応答の速いコードにするにはどんなふうに変えていけばいいかを知りたい
cで言うと値コピーしてソートしないでポインタでソートすると速いみたいな
0209デフォルトの名無しさん
垢版 |
2020/04/13(月) 21:38:04.55ID:tr0y4100
>>208
どう改善すればいいかはすぐにはわからないが
prime_factors関数は末尾再帰ではない再帰をしているから容易にスペースリークしそうな感じはする
0210デフォルトの名無しさん
垢版 |
2020/04/14(火) 00:39:23.37
できるだけリストを避けて
読み込みもByteString 版 getContents と readInt の組み合わせで高速化
そして困ったときの Data.Sequence 様やで！

C系提出者は軒並み 0.1 s で処理を終えている中、220MB 1.9 s 弱かけてなんとか致命傷でかいくぐった
制限超過してる気がするが、マイナー言語へのアファーマティブアクションかな？
くぅ～疲れましたw これにて AC です！
0211デフォルトの名無しさん
垢版 |
2020/04/14(火) 01:34:33.76
>>208
prime_factorsだけど
quotRem なら一回で両方得られる
探索は3から+2ずつ探すべき
n　が√m を超えてしまったら探索を打ち切るべき

リストの整数全部に出てくる素因数を予めリストアップしたいんだろうけど
そのprime_factorsだと絶対に素因数が存在しない、（２を除く）偶数空間と√mの後の空間をmに達するまで探していてとてもとても無駄
この無駄はmが大きいほど酷いことになるが、見事に君のコードはproductなんてしてmを巨大化させている
例えば、1000000 の素因数は少なくとも1000 以降は存在しないのに1001, 1002, 1003, ... , 999998, 999999, 1000000 まで探すところを想像してみて

一目気づいたのはそんなところかね。先ずはそこを直してから一局といったところか
0212デフォルトの名無しさん
垢版 |
2020/04/14(火) 01:52:08.41
>>207
まあ最終手段はそうなるんでしょうね
しかし早すぎる段階での最適化はたいてい悪手って言われてるし
その前に、アルゴリズムの選定が間違ってるんではとなって、あれこれ作戦変えて
いつしか通るわけです。すると結局いつまで経ってもプロファイリングを練習する機会が来ないんですよね
0213デフォルトの名無しさん
垢版 |
2020/04/14(火) 01:54:06.60
あ、いや、あれこれ作戦変えるヒントを得る為にプロファイリングするのか・・・
やっぱり手を出してみるか
0214デフォルトの名無しさん
垢版 |
2020/04/14(火) 10:48:29.31ID:Ez55nAck
異世界人「アルゴリズムをあれこれ変える」
主人公「言語をあれこれ変えてみよう」
0216デフォルトの名無しさん
垢版 |
2020/04/15(水) 17:46:40.69ID:/WUIZ9Nz
>>211
39の素因数って3,13よね？
√39が6くらいだから探索区間は√mじゃ不十分かなって
でも確かに偶数はいらないから2:[3,5..]でいいね
全部の素因数のリスト作るのに全部掛け合わせて処理はひどいなと見直して思った
リストは早くするなら使わない方針なのね

Quatremとリスト以外（sequenceが代替？）調べて組み込んでみようかな
0217デフォルトの名無しさん
垢版 |
2020/04/15(水) 17:47:28.61ID:/WUIZ9Nz
お礼書き忘れたすみません
回答ありがとうございますなんとか通ってもらいます
0218デフォルトの名無しさん
垢版 |
2020/04/15(水) 19:54:09.51ID:JKZ0KcR7
>>216
なんの話かよく知らないけど39を素因数分解してるのなら、
約数として3が見つかったら、その時点でもう39が素数じゃないことが判明するから、13を調べる必要ないよ
√39以下の数字調べればオッケー
0219デフォルトの名無しさん
垢版 |
2020/04/15(水) 19:55:22.34ID:JKZ0KcR7
間違えた
「素因数分解してるのなら」じゃなくて「素数判定してるのなら」だった
0220デフォルトの名無しさん
垢版 |
2020/04/16(木) 01:02:59.81ID:6p+dWGIK
>>208
計算速度や使用メモリ量以前に、解が正しくないよ。
試しに sumOfDivided [8] やってみ。

もう少し言うと、prime_factors 関数がおかしい。
関数名に相応しくない計算をしていられる。

まずは、必要な個数の正しい素数列を作ることを考えた方がいいと思うぞ。
0221デフォルトの名無しさん
垢版 |
2020/04/16(木) 01:13:24.21
>>216
あ、説明で嘘を吐いてしまった。確かに√m以降に素因数は存在しないは偽だった
それでも尚、√で打ち切っていい手筋は揺るがない。
√39より前の3を発見して、39 `quot` 3 (=13) に対して再帰的に同じことをする
ただし割ることを試すのは今割り切れた素数からね（同じ素数で複数回われることもある）。
もう一回3で割ろうとして失敗し、次は√13 を超えるので打ち切って、13 は素数と判定してリストに加える
だから結果として、√m 以降の素因数を取りこぼすことはない
0222デフォルトの名無しさん
垢版 |
2020/04/16(木) 09:43:04.65ID:xRrLSzP4
>>221
素数系のアルゴリズムは手続き的にはよく知られたものが色々あるけど
それをHaskellっぽく(宣言的に)定義しろって言われると割と悩む
STMonadとか使えば手続き的な実装はできるけど何かに負けた気分になる
0223デフォルトの名無しさん
垢版 |
2020/04/16(木) 12:23:07.85ID:DtoAMVDb
速度あげようと思ったら、どうのように計算するかということに介入する必要があるから手続き的になるのはしょうがないのでは
0224デフォルトの名無しさん
垢版 |
2020/04/16(木) 14:44:08.63ID:ta7mONc0
魔法を使える主人公がなぜか銃を乱射するというマナー違反
を許せない真面目系脇役の魅力
0226デフォルトの名無しさん
垢版 |
2020/04/17(金) 18:51:48.64ID:Tw57yEwr
ごきげんよう、高貴なるhaskellプログラマの皆様方
今日も可憐におプログラミングですことよ
ほほほ
0229デフォルトの名無しさん
垢版 |
2020/04/18(土) 11:31:33.48ID:v8V9P+IO
C言語プログラムなどを実行すると電磁波の影響で身体への副作用が発生するからな
副作用を抑え人間本来の自然な免疫力を高めるのがhaskell
0231デフォルトの名無しさん
垢版 |
2020/04/18(土) 13:41:19.98ID:urv0mT/N
>>229
我慢できずにモナドに手を出して感染する事例が後を立たない
モナドは自粛すべきと何度も言われているのに
屁理屈をこねて手を出す者が多すぎる

本当にHaskellに副作用がないのだと詭弁を弄せずごり押しするのならば
絶対にモナドをやるべきではないと言われている
0232デフォルトの名無しさん
垢版 |
2020/04/18(土) 19:32:57.82ID:DCiZBX2v
モナドを「やる」ってなんだよｗ
モナドを禁止薬物か何かと勘違いしてるのか？

すべての人間は二分される
すなわち「モナドである」人間と、そうでない人間、だ
俺はモナド
お前はモナドではない

「上」で待ってるで
0234デフォルトの名無しさん
垢版 |
2020/04/18(土) 20:52:26.11
C言語プログラムなどを実行するとストレスの影響で毛髪への副作用が発生するからな
脱毛を抑え人間本来の自然な論理を書けるのがhaskell
0237デフォルトの名無しさん
垢版 |
2020/04/19(日) 01:35:32.46ID:WM8Q0HWB
[状態モナド](https://wiki.haskell.org/State_Monad)を
[随伴](https://en.wikipedia.org/wiki/Adjoint_functors) on Rails
に乗せてみる。

``` code
type W x a b = (a, x) -> (b, x)
type S x a b = a -> x -> (b, x)

in_away :: W x c d -> W x b c -> W x a b -> W x a d
in_away cd bc ab = cd . bc . ab

in_home :: S x c d -> S x b c -> S x a b -> S x a d
-- in_home cd bc ab = to_home $ in_away (to_away cd) (to_away bc) (to_away ab) where
-- in_home cd bc ab = ext cd . ext bc . ab where
in_home cd bc ab a = new a %>>=% ab %>>=% bc %>>=% cd where
(%>>=%) = flip ext
ext = to_home_fmap . to_away
new = to_home id
to_home_fmap = (.)
to_home = curry
to_away = uncurry
```

`to_home`が[記事](https://en.wikipedia.org/wiki/Adjoint_functors)での`Phi`
に、`ext`が[Kleisliのスター](https://en.wikipedia.org/wiki/Kleisli_category)
に対応する。`in_away`は通常の関数の合成で、`in_home`はそれを黒魔術に
翻訳している。
[継続モナド](https://wiki.haskell.org/Continuation)も随伴で書ける。
0238デフォルトの名無しさん
垢版 |
2020/04/19(日) 01:36:44.08ID:WM8Q0HWB
``` code
type O x a b = (b -> x) -> a -> x
type C x a b = a -> (b -> x) -> x

in_away :: O x c d -> O x b c -> O x a b -> O x a d
in_away cd bc ab = cd %.% bc %.% ab where (%.%) = flip (.)

in_home :: C x c d -> C x b c -> C x a b -> C x a d
-- in_home cd bc ab = to_home $ in_away (to_away cd) (to_away bc) (to_away ab) where
-- in_home cd bc ab = ext cd . ext bc . ab where
in_home cd bc ab a = new a %>>=% ab %>>=% bc %>>=% cd where
(%>>=%) = flip ext
ext = to_home_fmap . to_away
new = to_home id
to_home_fmap = flip (.)
to_home = flip
to_away = flip
```

厳密には、`flip`は随伴ではないが、`Set^op (a, b)`と`Set (b, a)`が集合
として同型になることを使うと、実質的な随伴の役割を果たす。
0239デフォルトの名無しさん
垢版 |
2020/04/19(日) 23:13:07.04ID:hRJ8C0Os
その話題は伸びない。このスレにはHaskellerいないからコード貼ったって誰も読めないし圏論を理解してるやつなんかいないから
0242デフォルトの名無しさん
垢版 |
2020/04/20(月) 12:33:40.11ID:KoBCLV49
ここには数学とプログラミング両方できる人がいるようだからお聞きしたいのだけど
プログラミングのクロージャーってトポロジーのクロージャーから引っ張ってきた用語なの？トポロジーの方の定義を眺めてみてもイマイチつながりが理解出来なくて
0244デフォルトの名無しさん
垢版 |
2020/04/20(月) 12:40:47.15ID:gGVXVDIS
量子化とかもおいおいって思う
0249デフォルトの名無しさん
垢版 |
2020/04/21(火) 21:16:16.93ID:JxCMv4cD
この言語って純粋に理論的な側面に興味を感じてしまって、アプリ制作進まなくなるわ
0250デフォルトの名無しさん
垢版 |
2020/04/23(木) 00:29:18.48ID:wNzYQ5IM
それよりメモリ管理の理論に興味を感じないか
static変数のようなものを使えばメモリ管理と無縁のアプリ製作ができるのだが
0252デフォルトの名無しさん
垢版 |
2020/04/23(木) 03:15:59.03
メモリ管理に興味を感じないか？　→　メモリ管理と無縁の～ができるのだ

？？？？？？
メモリ管理するんじゃなかったのか？
0257デフォルトの名無しさん
垢版 |
2020/04/24(金) 01:31:48.04ID:Zatb8XkV
低俗なねらーにはHaskellはら難しすぎたんや…
0258デフォルトの名無しさん
垢版 |
2020/04/24(金) 23:19:15.10ID:FUZNUOcv
メモリ管理の様な世俗的な因習に捕らわれず神の領域を安らかたらしめん為の関数型言語では無かったか
0259デフォルトの名無しさん
垢版 |
2020/04/25(土) 01:04:25.27ID:7jpIjPuc
現実のハスケラ達は評価順やサンク潰しの制御のテクニックを競ってマウンティングし合ってるよ
0262デフォルトの名無しさん
垢版 |
2020/04/25(土) 05:14:26.69ID:n1+IBCwB
簡単に言えば、安全で明確でテストしやすいプログラムが書ける。

IOモナドの関数は中でどんなIOアクションでもできてしまい危険だ。
大事なファイルを上書きしようが、大音量でビープを鳴らそうが。
Polysemyに代表されるエフェクトシステムを使うと、
関数の中で使えるIOアクションの内容を関数シグネチャで制限できる。
ファイル読取アクションを宣言した関数の中では、書込や画像表示など他のIOアクションは一切できず安全だ。

また、ビジネスロジックのコードではどんなアクションをするのか(what)というレシピだけを書き、
そのアクションを実際のIOを使ってどの様に実現するか(how)は別のコードで書くことになる。
whatとhowがしっかり分かれ明確だ。

なので、ビジネスロジックのコードは純粋関数で書け、テストしやすくなる。
howのコードだけをモックに変えることもでき、これもまたテストを容易にする。

と言うようなことを例を交えて分かりやすく説明しているのが >>260 の記事だ。
0263デフォルトの名無しさん
垢版 |
2020/04/25(土) 08:08:07.66
目を通しました（理解できたとは言ってない）
粒度の粗い物を制限してもっと細かくして、その組み合わせで書き直すことで間違いを排除する、
（手を入れられない）既存ライブラリに対して、ぼくのかんがえたさいきょうのリファクタリングをエミュレートする基盤となるものですか？
0264デフォルトの名無しさん
垢版 |
2020/04/25(土) 10:58:51.70ID:n1+IBCwB
>>263
前半はその通り。

が、すまん、後半は意味が分からない。
リファクタリングをエミュレートするってどういう事？
初めて聞いたフレーズだ。

リファクタリングをする事と、リファクタリングをエミュレートする事の違いを教えてくれ。
0265デフォルトの名無しさん
垢版 |
2020/04/25(土) 12:04:03.93
真のリファクタリングは、設計しなおしてソースコードも書き直す事が含まれるとすると
標準ライブラリであるIOモナドの設計やソースコードを直接弄ることはできませんから、ポリ蝉版は本当にIOを再設計したわけではなく、
リファクタリングを疑似的に再現したという解釈はできないでしょうか
リファクタリングの真似事なのでエミュレートと言いました
0267デフォルトの名無しさん
垢版 |
2020/04/25(土) 13:20:46.87ID:n1+IBCwB
>>265
なんか、私と貴方の間にリファクタリングという言葉に齟齬があるような・・・

今までIOモナドを直接使っていたコードをPolysemyを使うようにリファクタリングすることはできるよ。
エフェクトシステムの設計者たちはそれを推奨している。

でもそれは、IOライブラリのコードが弄れないから、仕方ないので、Polysemyで擬似的に弄ったように見せましょう、
という話では全くないよ。
0269デフォルトの名無しさん
垢版 |
2020/04/25(土) 18:29:06.56ID:n1+IBCwB
>>268
名前が違うんだし、そりゃ別物だよ。
同じエフェクトシステムというカテゴリの一員ではあるが。

どう違うかは >>260 を読んで判断してくれ。
短い記事だからすぐ読める。
0270デフォルトの名無しさん
垢版 |
2020/04/26(日) 08:52:10.51ID:K9Hk9jTV
IOは副作用じゃなくて作用だからハスケルは副作用が無いんだなんていってるやつ初めて見たんだけど
0271デフォルトの名無しさん
垢版 |
2020/04/26(日) 09:58:35.47ID:igL2TSix
あらかじめ宣言した型に従う作用じゃなくて
宣言していないことを勝手にやるのが副作用の弊害だから
Haskellにはこの弊害が無いんだな
0272デフォルトの名無しさん
垢版 |
2020/04/26(日) 10:22:30.54ID:FBxVgLTh
>>271
そう言うこと。

でもIOは実質なんでもできちゃうから、かなり不安だよね。
もっとeffectを安全に取り扱いたいよね。
その解のひとつがPolysemyだよ、という話しだ。


>>270
PolysemyのブログPart1を読んで思うところがその嘲笑だけなら、
英語ドキュメントの読解にはちょっと向かないかな。
0273デフォルトの名無しさん
垢版 |
2020/04/26(日) 11:39:57.10ID:K9Hk9jTV
ブログを観る限り素人の書いたクソ記事だな
読む価値なし
0277デフォルトの名無しさん
垢版 |
2020/04/27(月) 14:12:58.96ID:AM55pzUu
「Prelude>:browse」の実行結果をテキストファイルにリダイレクトする方法
browse.hsという名前のファイルに:browseを記入して保存
保存したファイルのあるディレクトリでコマンドプロンプトを立ち上げて以下を実行
stack ghci < browse.hs > browse.txt

Redirecting Haskell GHCi output to text file [duplicate]
https://stackoverflow.com/questions/14688119/redirecting-haskell-ghci-output-to-text-file
0278デフォルトの名無しさん
垢版 |
2020/04/27(月) 17:47:14.78ID:AOepTdHn
このスレで延々と副作用やモナドの話ばかりされてるのなんか既視感があると思ったら、物理学板の相対論スレでポアンカレ群やリーマン幾何の話は一切せず
モノの本で読んだようなマイケルソン・モーレイの実験の話に関する持論をひたすら展開して相対論は間違ってる！って騒いでる連中に似てる
0279デフォルトの名無しさん
垢版 |
2020/04/27(月) 17:48:43.80ID:l27UEbbh
相対性理論も量子力学もどっちも間違ってる
0281デフォルトの名無しさん
垢版 |
2020/04/27(月) 19:40:47.96
最新 stack で 7.8.4 をセットアップしようとしたら realgcc.exe を使おうとしてコケる
新しい GHC にはあるみたいだけど古い GHC には mingw\bin に存在しないようだ
なのに使おうとしている
なぜ古いのを入れようとしてるかというと競プロサイトのGHCが古いからだ
最新版で通るコードが向こうで弾かれたりして苛ついたから、じゃあそっちの環境で通るコードを提出してやるよとなってインストールを試みたのだ
スタックで古いバージョンのセットアップに自身ニキ、助けて
0282デフォルトの名無しさん
垢版 |
2020/04/27(月) 21:15:06.74ID:6TeRc6dT
静的型付けの話は一切せず
実行時の振る舞いに関する持論をひたすら展開してモナドがーって

これ半分オブジェクト指向だよ
型はオブジェクトではないから型の話を一切しないんだよ
0284デフォルトの名無しさん
垢版 |
2020/04/28(火) 00:09:34.24ID:Bz0WEXXQ
>>281
複数のバージョンを使い分けたいのなら、
Windowsは向かないと思います。

あくせくしてゴチャゴチャになるくらいなら、
さっさと仮想環境にlinux入れてそっちで環境構築した方が
楽で早いのではないでしょうか。
0287デフォルトの名無しさん
垢版 |
2020/04/28(火) 01:57:21.75ID:zsCbc70d
>>285
嫌うという表現は置いておくとして、
純粋関数と副作用の伴う関数とをあれほど切り分けたがるのは、
その方がメンテし易いというのが大きな理由の一つだと思う。
0288デフォルトの名無しさん
垢版 |
2020/04/28(火) 12:53:37.93
よしわかった。ならばWSL Ubuntu を導入だ。stackをインストールし、古すぎるので最新版stackに替え、stack setup 7.8.4

The GHC located at /home/devlin/.stack/programs/x86_64-linux/ghc-7.8.4/bin/ghc-7.8.4 failed to compile a sanity check. Please see:

http://docs.haskellstack.org/en/stable/install_and_upgrade/

for more information. Exception was:
Received ExitFailure 1 when running
Raw command: /home/devlin/.stack/programs/x86_64-linux/ghc-7.8.4/bin/ghc-7.8.4 /tmp/stack-sanity-check47/Main.hs -no-user-package-db
Run from: /tmp/stack-sanity-check47/
Standard output:

[1 of 1] Compiling Main ( /tmp/stack-sanity-check47/Main.hs, /tmp/stack-sanity-check47/Main.o )
Linking /tmp/stack-sanity-check47/Main ...
Standard error:

/usr/bin/ld: -lgmp a??e|?a??a??a??a??a???
collect2: error: ld returned 1 exit status


神はどうあっても試練を与えようというあああああ！！！！
0289デフォルトの名無しさん
垢版 |
2020/04/28(火) 17:08:37.94ID:yBopWDZB
言語仕様はHaskellでもいいけど実装は、電池が入ってるインタプリタがいい
コンパイラをコンパイルするのも、ネットのサービス終了も嫌だ
0290デフォルトの名無しさん
垢版 |
2020/04/28(火) 22:24:50.85ID:fQrwEc0Y
F#ならスクリプト使えるよー
モナドの代わりにコンピューテーション式も使えるよ
副作用も使いまくりだよー
ライブラリーは.NETつかえるよー
GUIはちょっと苦手　でも、ワンレンボディコンのボインちゃん

シャッチョサン、シャッチョサン
シャッチョさんのことだからまけにまけて０円　　もってけどろぼー
0295デフォルトの名無しさん
垢版 |
2020/04/29(水) 09:36:37.62ID:TuLha3Ht
F#スレ落ちてるね
0298デフォルトの名無しさん
垢版 |
2020/04/29(水) 15:25:39.64ID:Cpi+Il5+
>>288
漏れは、Windows 10, WSL, Ubuntu 18.04 で、
Linux側には、日本人が作った、バージョンマネージャーのanyenv で、rbenv, nodenv を使って、
ruby 2.6.6, node 12.16.2 を入れた

yarn は、Windows側に入れて、WSL から、拡張子なしのyarn コマンドを呼べる。
これは、#!/bin/sh で始まるシェルスクリプト

Windows側で、VSCode の拡張機能、Remote WSLも使う

Haskell のhsenv は、使えないのか？
0299298
垢版 |
2020/04/29(水) 15:39:17.08ID:Cpi+Il5+
ちなみに、Ruby on Rails の場合、コンパイルに必要なパッケージは、

sudo apt-get update
してから、

sudo apt install -y build-essential

build-essential には、
gcc(GNU C compiler), g++(GNU C++ compiler), libc6-dev(GNU C Library), make などが入っています

次に、openssl, readline, zlib のパッケージをインストールします。
sudo apt-get install -y libssl-dev libreadline-dev zlib1g-dev

データベースの、libsqlite3-dev, sqlite3 をインストールします。
sudo apt-get install -y libsqlite3-dev sqlite3
0302デフォルトの名無しさん
垢版 |
2020/04/30(木) 17:28:15.60
>>298-299
んにゃぴ・・・んまぁ、そう、よくわかんなかったです

>>300
それでようやく原因が判りました
Stack no longer supports Cabal versions below 1.19.2,
but version 1.18.1.5 was found.
This invocation will most likely fail.
To fix this, either use an older version of Stack or a newer resolver
Acceptable resolvers: lts-3.0/nightly-2015-05-05 or later
stack will use a sandboxed GHC it installed
For more information on paths, see 'stack path' and 'stack exec env'
To use this GHC and packages outside of a project, consider using:
stack ghc, stack ghci, stack runghc, or stack exec

7.8.4 のCabal は 1.18.1.5 であるんですが、最新版 stack は 1.19.2 以降のCabal しか対応しない
というわけで諦めました。いうほど 7.8.4 使いたいかって気分になってきて、エラー出たらその都度古いコードに書き直せばいいじゃんってなったんで
このイシューは閉じます。ありがとうございました。
0305デフォルトの名無しさん
垢版 |
2020/05/02(土) 09:29:59.76ID:S0jsNVj+
haskellのライブラリ管理ツールはずっとクソ。
pythonのも大概だけど、haskellはそれを遥かに凌ぐレベルでくそ。
0307デフォルトの名無しさん
垢版 |
2020/05/02(土) 12:50:23.34ID:F6qz2woZ
ライブラリ管理ツールって何をするためのモノなんだ？
ユーザーから何を期待されてるんだ？
0308デフォルトの名無しさん
垢版 |
2020/05/02(土) 13:54:24.62ID:QDKxMZyf
シェルスクリプトで管理ではなく
そろそろxmlとかyamlとかの時代を期待されてる説
0310デフォルトの名無しさん
垢版 |
2020/05/04(月) 16:45:39.46ID:R0S0SfqY
ocamlはせっかく盛り返してたのに失言でだいなし
0314デフォルトの名無しさん
垢版 |
2020/05/07(木) 10:57:00.07ID:zCrpEpjK
書籍「関数プログラミング 珠玉のアルゴリズムデザイン」で分からない所があります。

2ページ目3行目
xsに含まれない最小の数は、filter (<= n) xs に含まれない最小の数ということになる。

ここで < ではなく、<= なのは何故でしょうか。
< を使って条件を厳しくしても、

xs = [0], n = 1 ===> filter (<n) xs = [0]
　　[0] に含まれない最小数 = 1
xs = [1], n = 1 ===> filter (<n) xs = []
　　[] に含まれない最小数 = 0

このように問題無いように思えます。
0315デフォルトの名無しさん
垢版 |
2020/05/07(木) 16:47:46.68ID:/pjDMUqX
事実を述べているだけに見えるが
何故あの事実ではなくこの事実を切り取ったのかを知りたがるのが面白い
0316デフォルトの名無しさん
垢版 |
2020/05/07(木) 17:22:10.29ID:mCGt79kv
>>314
その直前に

[0..(length xs)] の範囲にある数の少なくとも1つはxsに含まれていない

とあるので(鳩の巣原理)、その自然な帰結として

length xs より大きい数は、たとえxsに含まれていたとしても探索の対象にする必要はない

ということで filter (<= n) xs (where n = length xs) が出てくるのだと思う
そこで filter (<n) xs では意味がわからない(自明ではない)
0318デフォルトの名無しさん
垢版 |
2020/05/08(金) 17:29:16.16ID:3cwUCrUk
>>309
表紙すごい買う気失わせる感じだけどほしいな
かむｂりぷｂのだーたアルゴリは名著多いし面白いのだといいな(´・ω・｀)
0323デフォルトの名無しさん
垢版 |
2020/05/23(土) 00:35:45.46ID:PUmkxvlF
次のように、一つのモナドを遅延的に無限に評価できる関数 repM は定義できるでしょうか？

repM :: (Monad) => m a -> m [a]

xs <- repM (return 1)
print $ take 3 xs -- [1, 1, 1]

ys <- take 2 <$> repM (return 1)
print ys -- [1, 1]
0325デフォルトの名無しさん
垢版 |
2020/05/23(土) 01:44:01.25ID:m+h1wlWJ
あ、コッチの方がかっこいいのか？
でも可読性を犠牲にしだすとperlみたいになるから良くない？

repM = (>>=(return.repeat))
0326デフォルトの名無しさん
垢版 |
2020/05/23(土) 01:56:13.86ID:PUmkxvlF
>>324
>>325
それはひとつのモナドを3回評価しているのではなく、
ひとつのモナドの中の値を3回評価しているのではないでしょうか？

例えば repM (getLine >>= print) を評価すると、
1回しか getLine >>= print を評価しません。

ちなみに、IOモナドに限れば unsafeInterleaveIO 関数が使えます。
また、リストではなくいわゆるストリームなら出来ました。
ですが今はモナド全般に適用でき、リストのモナドを返す関数を求めています。
0327デフォルトの名無しさん
垢版 |
2020/05/23(土) 02:01:15.20ID:PUmkxvlF
>>324
すいません。
補足です。

a <- take 3 <$> repM (getLine >>= print) を評価すれば、
3回の副作用 getLine >>= print が実行され、
a は [(), (), ()] を束縛していて欲しいのです。
0328デフォルトの名無しさん
垢版 |
2020/05/23(土) 12:08:02.84ID:eKnPDQS2
module Main where

import Control.Monad.IO.Class (MonadIO, liftIO)
import Control.Monad.Trans (lift)
import Data.Conduit (ConduitT, runConduit, yield, (.|))
import qualified Data.Conduit.List as CL

repIO :: (Monad m, MonadIO m) => IO () -> ConduitT () () m ()
repIO io = do
x <- liftIO io
yield x >> repIO io

repM :: Monad m => m o -> ConduitT i o m r
repM m = do
x <- lift m
yield x >> repM m

main :: IO ()
main = do
x1 <- runConduit $ repIO (getLine >>= print) .| CL.take 3
print x1 -- [(),(),()]
x2 <- runConduit $ repM (getLine >>= print) .| CL.take 3
print x2 -- [(),(),()]
let x3 = runConduit $ repM [1,2] .| CL.take 3
print x3 -- [[1,1,1],[1,1,2],[1,2,1],[1,2,2],[2,1,1],[2,1,2],[2,2,1],[2,2,2]]
let x4 = runConduit $ repM [] .| CL.take 3
print (x4 :: [[Int]]) -- []
let x5 = runConduit $ repM (Just 1) .| CL.take 3
print x5 -- Just [1,1,1]
let x6 = runConduit $ repM Nothing .| CL.take 3
print (x6 :: Maybe [Int]) -- Nothing
0330デフォルトの名無しさん
垢版 |
2020/05/24(日) 19:39:02.80ID:A0PpU4F1
HaskellのフレームワークってGHC拡張たくさん使われてるから、基本的な文法だけ知ってても、エラーが出たら意味分からなくなるという初心者泣かせな言語だな。地道にコツコツ知らないことを勉強してってるわ。
使いこなしてる人ホンマ羨ましい。
0332デフォルトの名無しさん
垢版 |
2020/05/25(月) 14:19:28.47ID:HRWjfAZ+
>>330
そういう悪い所を悪いと言えないのが初心者で
初心者の甘い評価がなければ持続不可能なのがGHCじゃないか
0334デフォルトの名無しさん
垢版 |
2020/05/26(火) 13:27:47.52ID:w7oGlmub
haskellのフレームワークとやらが具体的に何を指しているのか分からん。
YesodやServantなどのWebフレームワークしか思いつかんが。

いずれにしても、そもそも初心者がフレームワークに頼るべきではない。
初心者を抜けて、さぁ本格的なアプリでも作ってみるかとなった時に使えばいい。

初心者は15パズルやTODOツールみたいな簡単なアプリをフルスクラッチで作ってみて、
言語拡張の必要性や、有用なライブラリの使い方を少しずつ学ぶことを奨める。
0336デフォルトの名無しさん
垢版 |
2020/05/27(水) 13:16:13.81ID:SIsgBJ88
>>335
初心者が面白いと思える学べる題材ってなんかあるかな？

C#だとゲームとかGUIとか簡単なのになぁ
Pythonだって色々思い浮かぶのに
0340デフォルトの名無しさん
垢版 |
2020/05/29(金) 07:22:48.07ID:mJaFRwIH
GoとRustが無かった時代には長所がいっぱいあったんだろう
もし、その時代のコードを変更することなく今使えるならそれも長所だが
0341デフォルトの名無しさん
垢版 |
2020/05/29(金) 07:54:35.82ID:7l9AMad4
>>338
長所は難しいことをより難しく書けること
短所は簡単なことでも難しく書かざるを得ないこと

本質的に純粋関数だけじゃリリースできないことも大問題ではある
切り分けで対処しても破壊を含むコードは必ず走る
理想が現実に敗北したような体系だから手を出さないほうがいいよ
0342デフォルトの名無しさん
垢版 |
2020/05/29(金) 08:30:23.80ID:wwuYcwOw
>>338
長所は、宣言的に分かりやすく書いたプログラムが意図通りにちゃんと動くことです。
何をするのかと、どのようにするのか、この二者をきっちり分けてプログラムできるのがHaskellの大きな魅力です。
(できると言っても、初心者が簡単にできることではありません。 その方向に正しく精進する必要があります。)

短所は、少し上のレスでも言及されていますが、入門を抜けた後に何に取り組めば良いのか分からなくなることです。
始めから何か目的があってHaskellを学び始めたのでしたら良いのですが、そうでなければ、
魅力的な題材の無さに愕然とし、路頭に迷うことになるでしょう。
実はgithub等を漁れば先輩方の様々はジャンルの非常に参考になるプログラムを数多く拝見でき、
自分も取り組んでみたくなる題材がたくさん見つかるのですが、逆に言えばそうやって努力して探さないと見つかりません。
0343デフォルトの名無しさん
垢版 |
2020/05/29(金) 09:57:17.22ID:zRWEM9Qa
>>341
後半、そういう批判よくあるけど毎回何言ってんのかよくわからん
お前達は何を批判してるの？
0344デフォルトの名無しさん
垢版 |
2020/05/29(金) 10:24:25.66ID:mJaFRwIH
過激派と思ってた奴に中道の仕事を奪われる
理論的にありえないと思っていた中道と中道の対立が現実になる
0345デフォルトの名無しさん
垢版 |
2020/05/29(金) 11:22:41.66ID:xO3kN7Ry
どんなに多くの短所があろうが
それらに勝る長所が一つあれば好きになる

人でもプログラミング言語でも
0346デフォルトの名無しさん
垢版 |
2020/05/29(金) 11:35:07.26ID:OBuVVMWP
>>338
Haskellに対して懐疑的だった初学者がParsec使ってパーサー書いてみた感じだと

長所
バグ皆無のパーサーをBNFを書き写すように簡潔に書ける
(自分はCやrubyでは書けなかった)
問題に応じて言語内言語を作れるので、コードの量を極めて少なくできる
短所
yaccやbisonより学ぶのにかなり時間がかかりそう
言語内言語を作れてしまうので、ぱっと見ただけではコードを理解できない
(数式を理解するには記号の意味を理解している必要があるのと同じ)

yaccやbisonを使った経験は無い
だが、Haskellの方が応用が利き問題の解決の仕方が美しいので学びたいとは思わなくなった

解決したい具体的な問題があり、自分が学んできた言語だとコードが大きく複雑になりそうで、新しい概念を学ぶ余裕と覚悟があるなら良いと思う
ただ便利そうなのを探してるとか興味があるってだけだと挫折するかも
Haskellを参考にしたより新しい言語を学ぶ方がスマートかもしれない
自分みたいにHaskellに懐疑的で徹底的に学んで悪口書いてやろうと思っているならマジお勧めｗｗｗ
0347デフォルトの名無しさん
垢版 |
2020/05/30(土) 19:36:21.64ID:/U1uledC
>>338
長所： 多くのバグをコンパイル時に潰せる
短所： 手続き型プログラミングにおける既知の資産(アルゴリズムなど)が活用しにくい
0348デフォルトの名無しさん
垢版 |
2020/06/01(月) 05:07:50.77ID:seoK/8uJ
Ocamlを使わないといけなくなっていじり始めたけど、あれもこれも出来なくて不便だな
やたら冗長になるし…
0349デフォルトの名無しさん
垢版 |
2020/06/01(月) 07:39:57.03ID:L1Mt0gVE
書くのが不便になる代わりに、ぱっと見ただけで理解できるコードになる
という軍師の言葉をぱっと見ただけで信じる者だけがOCamlを使いなさい
0351デフォルトの名無しさん
垢版 |
2020/06/02(火) 01:46:24.39ID:UWOmEsh4
>>328
>>329
やはり純粋なリストだけでは望む仕組みは作れないという結論に達しました。

逆に言えば、そういう事が容易にできるのがストリームの利点の一つなのだと理解しました。

ありがとうございました。
0352デフォルトの名無しさん
垢版 |
2020/06/05(金) 23:44:13.56ID:aqmhehrv
memptyってなんでmunitやmidとかじゃないんだろうな？
emptyの心がよーわからん

文字列のように意味的に空なモノイドもあるが、
空じゃない例の方が圧倒的に多く一般的じゃないか？

ま、どうでもいいんだけどな
0354デフォルトの名無しさん
垢版 |
2020/06/10(水) 18:32:52.39ID:vPvQB3B1
top level の型の指定についての質問です。
haskellのルールでtop levelでないところでは曖昧な型で型推論してくれて通るけど、top levelでは一意に型が決まらないとダメとかなんとかそういうルールがあって、
それでハマって苦労した記憶があるんですが、今その事ふっと思い出したんですが、詳しい内容が思い出せません。

haskell ambiguous top level

とかでグクってもそれらしい話しが出てこないんですけど、なんか思い当たる方おられませんか？
0356デフォルトの名無しさん
垢版 |
2020/06/11(木) 23:57:59.62ID:oU50Re4d
>>355
レスありがとうございます。
当時なんかのプログラム組んでてハマったんですが、どんな例だったかは思い出せません。
しかし制限の名前はわかりました。
monomorphic restriction (単相性制限) という奴でした。
ググってみると多相性を無制限に認めてしまうとメモ化の実装が難しくなるようで性能に影響してしまう事を避けるための制限のようです。
こまめに型宣言書くようにするか、性能を犠牲にしてもよいなら制限をなくすオプションとかもghcとかには用意されてるので実害は無いんですけど、昔ハマって原因突き止めるのにエライ苦労したのでなんだったかふっと気になってお聞きしました。
お騒がせしました。
0359デフォルトの名無しさん
垢版 |
2020/06/23(火) 00:33:49.50ID:2ZCsz0wY
次の2つの関数の型の違いを説明していただけないでしょうか。

f :: C a => T a -> b -> b
g :: T a -> (C a => b) -> b

関数gのようなconstraintの使い方にはこのような効果や意味がある、
とはっきり説明できず、モヤモヤしています。

また、このようなconstraintの使い方には特別な用語があるのでしょうか。
webで検索して調べてはいますが、適切なキーワードが思いつかず、苦労しています。
0360デフォルトの名無しさん
垢版 |
2020/06/27(土) 16:04:56.51ID:FJC3hMrg
Haskell用語だけでは説明できない気がする
C++用語で
a -> bのaとbはtemplateを実体化する引数
C a => bはtemplateの宣言であって実体化ではないのでgは意味がわからない
0362デフォルトの名無しさん
垢版 |
2020/06/28(日) 10:31:17.77ID:hu4PmWPn
>>360
レスありがとうございます。

すいません、C++に精通していないため、templateの実体化や宣言の意味がよく分かりません。

件の関数型は次のブログにありました。
Introduction to Singletons (Part 1)
https://blog.jle.im/entry/introduction-to-singletons-1.html#going-backwards
ここの Going backwards の節です。
(昔、別のWebページでも見て、その時も不思議に思っていたのですが、どこのページだったか忘れてしまいました)

そこでは
withSingDSI :: SingDS s -> (SingDSI s => r) -> r
という型です。

確かに SingDSI s => のconstraintを外すと、この関数を呼び出すところで型エラーとなってコンパイルできません。
代わりに、型シグネチャの先頭に SingDSI s => を書いたとしても、です。
しかし、なぜ型が合わないのか理由が分かりません。

何かしらの意味があるはずなのですが・・・
0363デフォルトの名無しさん
垢版 |
2020/06/29(月) 23:47:59.12ID:MeiET0BU
>>362
のリンク先の話は中々勉強になるなぁ。
自分でこんなの使いこなせるようになるとは思えないけど。
0364デフォルトの名無しさん
垢版 |
2020/07/02(木) 23:40:38.85ID:Rg/xVuvf
>>359
Haskell勉強中で答えられるほどの知識無いけど
constraintの意味から察するに、右の引数の型が正格評価されていないうちには受け入れないということでは
遅延的に型を選択して返すような関数は作れるけど、それを明示せずに正格評価の関数に渡せてしまうと追跡困難になる
引数の型を決定しておかないと渡せないようになってるんじゃないかな
つまり、前者は第一引数の型を指定してて、後者は第二引数の型を指定しているというだけだと思う
知らんけど
0365デフォルトの名無しさん
垢版 |
2020/07/04(土) 23:44:16.95ID:LjgILXlp
すごいブログを見てしまった後では気が引けるが、前に書いた随伴をhtmlにした
[デフォルトの名無しさん](https://pastebin.com/WTvqXjnT)
なんか動いているな、程度の確認しかしていないのでバギーだと思う
サイズが大きいけどほとんどがcss
パット見、jsは、require, jquery, mathjaxぐらい
実行環境はihaskell
0366デフォルトの名無しさん
垢版 |
2020/07/27(月) 22:40:30.17ID:XpS4ozgV
遅延評価のありがたみよくわからんかったけど
なんとなく分かった

使うか使わない情報、ひとまとめに定義したいんだけど
使わないのなら、情報取りに行くだけ無駄

でも、遅延評価なら、無駄と思える情報も定義できる
なぜなら、使って初めて情報を取りに行くのだから
なるほどね　と思った
0368デフォルトの名無しさん
垢版 |
2020/08/13(木) 17:57:45.06ID:AeuuY+wz
圏論入門 Haskellで計算する具体例から
雪田修一 (単行本)
という本が近々出るので、Haskellの予習のためにHaskellの本を買いました。

プログラミング環境は何をインストールするのがおすすめでしょうか？
OSはWindows 10を使っています。
0369デフォルトの名無しさん
垢版 |
2020/08/13(木) 18:55:01.02ID:AeuuY+wz
Haskell Platformというのがいいみたいですね。
でもダウンロードしようとしたら、まず、Chocolateyとかいうのをインストールしなくちゃいけないんですね。
大丈夫ですか？これ？
0370デフォルトの名無しさん
垢版 |
2020/08/13(木) 21:17:46.02
Windows Subsystem for Linux 2 (WSL for short)を有効化してWSL用ディストリビューション（Ubuntu 20.04 LTSなど）をWindows ストアからインストールすることで、Windows内で仮想的にリナックスを使ってそこでHaskellを始めるのが良いです
0371デフォルトの名無しさん
垢版 |
2020/08/13(木) 21:24:06.64ID:AeuuY+wz
Windowsと比較してリナックスの利点は何でしょうか？
大きなアドバンテージはありますか？
0372デフォルトの名無しさん
垢版 |
2020/08/14(金) 06:03:07.79ID:OycuixUd
>>369
今のHaskell Platformのインストールってそういう感じになってるんだな
Chocolatey自体はWindowsでそこそこよく使われているパッケージマネージャなので一応信頼してよい
0373デフォルトの名無しさん
垢版 |
2020/08/14(金) 08:46:51.97ID:XgOd4/dA
>>370
Windowsにそのままインストールしちゃいました。



Windows PowerShellから起動する以外の使い方はないでしょうか？
GHCiというのもグラフィカルユーザーインターフェースのソフトはないのでしょうか？
0374デフォルトの名無しさん
垢版 |
2020/08/14(金) 12:57:45.74ID:XgOd4/dA
リストとタプルについてなんですが、Pythonでのリストとタプルとは違いがあるようです：

let a = [1,2,3]
drop 1 a

としてもa == [2,3]とはなりません。

let b = (1,2,3)
drop 1 b

とするとエラーになります。

Pythonの場合は、a = [1,2,3]に要素を追加できましたが、b = (1,2,3)にはタプルがイミュータブルであるため追加できませんでした。
ですが、b[1:]とすれば、(2,3)というタプルが得られたと思います。

どう考えればいいのでしょうか？
0375デフォルトの名無しさん
垢版 |
2020/08/14(金) 17:17:33.31ID:58KQIAkg
>>374
副作用のあるコードの書き方を見せるのは簡単だけど、関数型が初めてなら
まずはHaskellのチュートリアルを読んで関数型の考え方を出来るようになったほうがいい
0376デフォルトの名無しさん
垢版 |
2020/08/14(金) 17:46:17.87ID:XgOd4/dA
>>375
ありがとうございます。
「すごいHaskellたのしく学ぼう！」という本の第1章を読み終わりました。この本を読んでいこうと思います。
0377デフォルトの名無しさん
垢版 |
2020/08/14(金) 20:54:14.09
なぜエラーになるかといえば、タプルにdropはないからです
リストは『全て同じ型』の要素の片方向リストです。要素数は可変です。C++のforward_listをイメージしてください

タプルは『それぞれ好きな型の組み合わせ』であり、リストではありません。要素数は固定です

両者は本質的に内部実装が異なります。リストは要素と、次に辿る先の情報を組にしたデータ構造、一方でタプルはその数だけデータを納めるのみのデータ構造です

抽象的には、リストは２要素のタプルであり、一項目に要素、二項目は（再帰的に）リストを保有します。
こうすることで、二項目を見れば（リストなので）『要素と、二項目にまたリスト』が格納されています
そのリストの二項目を見れば・・・となって単方向リストが実装できている事が理解できます

タプル(,)は二項関数であるとみなせます。コンマの左側と右側に一つずつ何かを取って入れる関数です。
リストでは実際は『:』という二項関数が二項タプルと同じ役目を果たします。つまり
要素 : リスト
のように書き
(要素, リスト)
と抽象的に同じであると気づくことができます。
0378デフォルトの名無しさん
垢版 |
2020/08/14(金) 23:21:17.25ID:OycuixUd
>>374
コンパイルエラーの文章を読んでぐぐる癖をつけよう
覚えはじめの頃に出会うエラーは大抵は文法ミスか型エラーだろうから
ぐぐれば「何が悪いか」はだいたい解決する
「なぜ悪いか」はすごいHaskellあたりを読み進めていけば習得できるはず
0380デフォルトの名無しさん
垢版 |
2020/08/16(日) 18:14:55.92ID:tHIsB9jz
Haskellの本を読んでいると静的型付けだとか出てきます。
単にHaskellの仕様を理解するだけでなくもっと深く、どういう考え方でHaskellというプログラミング言語が設計されたのかにも興味があります。
プログラミング言語論みたいな本でおすすめの本はないでしょうか？
0381デフォルトの名無しさん
垢版 |
2020/08/16(日) 21:18:57.26ID:EuDMb00g
Haskellはある日突然に誕生したわけではなく、
その前身のMirandaとKRCという関数型言語から
多くの特質を受け継いでいます
これら言語に関してはW*k*p*d*aで簡潔に解説されてるので、
まずそちらを一読したのちに参考文献に当たるべきでしょう
以下ではW*k*p*d*aで欠けている日本語の文献を紹介します

Miranda
[1] 第7章 Miranda, p139-163,
　新しいプログラミング・パラダイム, 共立出版, 1989年
　ttps://www.am*z*n.c*.j*/dp/4320024931
　Mirandaに関する包括的な解説
[2] 関数プログラミング, 近代科学社, 1991年
　ttps://www.am*z*n.c*.j*/dp/4764901811
　Mirandaを用いた関数型プログラミングの入門書
　モナドを含む圏論の応用/発展が誕生する以前の時代に書かれた貴重な教科書

KRC
[3] 4. 関数型言語 KRC, p36-47,
　新世代プログラミング, 共立出版, 1986年
　ttps://www.am*z*n.c*.j*/dp/4320022599
[4] 6.2 KRC (Kent Recursive Caluculator), p132-142,
　プログラミング言語の新潮流, 共立出版, 1988年
　ttps://www.am*z*n.c*.j*/dp/4320023773
　[3], [4] ともKRCに関する包括的な解説
　KRCはすでにインデントベースの構文/純粋関数型/ パターンマッチ/リスト内包表記
　といった特質を備えた動的型付け関数型言語でした
0382デフォルトの名無しさん
垢版 |
2020/08/16(日) 21:54:00.05ID:jqjR96Dg
>>380
まず、Types and programming languages とSteve Awodey の Category Theory 読んでからや。

Haskell の話するのは。
0383デフォルトの名無しさん
垢版 |
2020/08/16(日) 22:04:09.80ID:mrCar2cd
Haskellは魔窟の巣窟や　近寄るものは内臓から食い散らかされるデー

初心者はPythonが最適やろ～
0384デフォルトの名無しさん
垢版 |
2020/08/17(月) 17:36:03.87ID:CFLjXFs2
>>381-382
ありがとうございました。

Types and programming languagesというのが比較的新しい本なので、興味を持ちました。
0385デフォルトの名無しさん
垢版 |
2020/08/17(月) 18:54:59.27ID:CFLjXFs2
クイックソートを行う関数を作ったのですが、エラーが出ます。どこが間違っていますか？

quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
quicksort (x:xs) = (quicksort [t | t <- xs, t <= x]) ++ [x] ++ (quicksort [t | t <- xs, x < t])
0386デフォルトの名無しさん
垢版 |
2020/08/17(月) 19:01:32.08ID:QJrG17W6
>>385
Haskell初心者に限った事柄ではないけれど、
こうした場で質問する者の心構えとして
出てしまったエラーメッセージをコピペする
といった、当たり前の行動は身につけるべきだと思うよ
0387デフォルトの名無しさん
垢版 |
2020/08/17(月) 19:03:19.26ID:CFLjXFs2
>>386
ありがとうございます。
エラーメッセージは以下です。

Prelude> :r
[1 of 1] Compiling Main ( baby.hs, interpreted )

baby.hs:153:1: error:
parse error (possibly incorrect indentation or mismatched brackets)
|
153 | quicksort :: (Ord a) => [a] -> [a]
| ^
Failed, no modules loaded.
0388デフォルトの名無しさん
垢版 |
2020/08/17(月) 19:05:47.77ID:CFLjXFs2
インデントも間違っていないと思いますし、カッコも問題ないと思うのですが。
0392デフォルトの名無しさん
垢版 |
2020/08/19(水) 15:58:22.36ID:FHOhxH/M
(1)と(2)で同じ関数だそうです。

add :: Int -> Int -> Int
は
add :: Int -> (Int -> Int)
と等価だそうです。

だとするならば、

(1)のほうが理屈の分かる書き方のように感じます。
(2)はadd' :: Int -> Int -> Intであると宣言しておきながら、その中身の表現を見ると、2つのInt型の引数を受け取ってその和を返す関数にしか見えません。
それにもかかわらず、add' 1は1引数の関数で引数に1を足す関数を表しています。非常に違和感を覚えるのですが、(2)は一体どういうことなのでしょうか？
わかりにくいです。

(1)
add :: Int -> Int -> Int
add n = \x -> x + n
(2)
add' :: Int -> Int -> Int
add' n m = n + m
0393デフォルトの名無しさん
垢版 |
2020/08/19(水) 15:59:38.45ID:FHOhxH/M
単なる表現方法と割り切ればいいのでしょうか？
0394デフォルトの名無しさん
垢版 |
2020/08/19(水) 16:07:34.77ID:FHOhxH/M
nに対して、「mにn+mを対応させる関数」を対応させる関数の表記法として、
add' n m = n + m
を採用するというのが非常に不自然に思います。
0395デフォルトの名無しさん
垢版 |
2020/08/19(水) 16:24:31.96ID:amUamLwq
入門書のカリー化の箇所を読めばいいんじゃね
haskell内での関数は一変数関数として扱えて、
add' n m = (add' n) m
というだけ
0396デフォルトの名無しさん
垢版 |
2020/08/19(水) 16:31:52.13ID:FHOhxH/M
>>395
ありがとうございます。
(1)の表記法だけ許してほしいと思うんです。(2)だけみたらまるで2変数関数のように見えますから。
0397デフォルトの名無しさん
垢版 |
2020/08/19(水) 20:35:34.21ID:1ghAy1sC
（今は結合性と優先順位は無視していいので）
n + m
は
(+) n m
と同じ意味になる。

つまり(2)は
add = (+)
に変数を明示して右辺の演算子を中置記法に戻しただけ

むしろ変数増やしたのが見にくい原因
0398デフォルトの名無しさん
垢版 |
2020/08/20(木) 07:58:20.18ID:mQjEXV61
>>392
(1) の展開は中途半端で、ちゃんと書くならこう

(0)
add :: Int -> Int -> Int
add = \n -> \m -> n + m

これを(1)や(2) のように書いてもよいというのはHaskellの決め事
慣れないうちは常にこう書いていてもよいが
書くのも読むのも段々面倒になってくると思う
慣れればあまり意識せずに読み替えられるので

ついでに言うと
真の2変数関数が必要ならタプルを用いてこう書く
add'' :: (Int, Int) -> Int
add'' (n, m) = n + m

これらは確かに厳密には区別しなくてはいけないが、
ゆるく同一視しておくほうが便利なことも多いので
Haskellでは(2)のような書き方が許されている、と自分は理解している
0399デフォルトの名無しさん
垢版 |
2020/08/20(木) 08:57:36.69ID:LuBKaaMH
>>397-398
ありがとうございます。
>>398
(0)
add :: Int -> Int -> Int
add = \n -> \m -> n + m
この書き方が本質的で一番わかりやすいですね。
ありがとうございます。
0400デフォルトの名無しさん
垢版 |
2020/08/20(木) 11:51:35.78ID:LuBKaaMH
圏論入門 Haskellで計算する具体例から
雪田修一 (単行本)

図書館に購入リクエスト済みです。楽しみです。
0401デフォルトの名無しさん
垢版 |
2020/08/20(木) 14:53:48.13ID:uVfTx7sc
>>1 simulationライブラリで純粋な関数式プログラミングをする ttp://x0000.net

学術の巨大掲示板群 - アルファ・ラボ ttp://x0000.net
数学 物理学 化学 生物学 天文学 地理地学
IT 電子 工学 言語学 国語 方言 など

VM + ASM を書いた (C#, DX) * x86 ではない!
simulationライブラリで純粋な関数式プログラミングをする
UIライブラリ (C#, 2D) を作ったよ
連続と離散を統一した！
4Dエンジン
matrixのライブラリ
ある強力なFor関数
SQLライブラリ

VM + ASM のダウンロード
ttp://up.x0000.net/files/TSimulang.zip
0402デフォルトの名無しさん
垢版 |
2020/08/21(金) 10:45:55.90ID:VIa1N6p8
関数の合成をする関数(.)を以下のように誤って書きました。
(x -> f (g x))はラムダ関数なので(\x -> f (g x))と書かないといけないと思います。
ですが、以下のコードでちゃんと動作しました。なぜでしょうか？

(.) :: (b -> c) -> (a -> b) -> a -> c
. = \g -> f -> (x -> f (g x))
0403デフォルトの名無しさん
垢版 |
2020/08/21(金) 11:35:07.30ID:VIa1N6p8
あともう一つ質問があります。

「すごいHaskellたのしく学ぼう！」に「関数合成は右結合なので、一度にたくさんの関数を合成できます。f (g (z x))は(f . g. z) xと等価です。」
と書いてありますが、左結合だったとしても、同様に一度にたくさんの関数を合成できるはずです。
左結合だったとしてもf (g (z x))は(f . g. z) xと等価であることに変わりはないはずです。

これは一体何が言いたいのでしょうか？
0406デフォルトの名無しさん
垢版 |
2020/08/21(金) 20:51:03.06ID:3LvfPoDL
通常の関数適用は左結合だから
f g z x は ((f g) z) x と同じ意味になって
コンパイルエラーになっちゃうけど
関数合成演算子を使うと括弧が減るよ、ということが言いたいはず

関数合成自体は結合的だからそこの向きは確かに関係ないね
0407デフォルトの名無しさん
垢版 |
2020/08/21(金) 22:34:08.88ID:nqLClnr+
>>403
単純に
>f (g (z x))は(f . g. z) xと等価です。
は、数学と同じ優先順位ですよってことじゃない？
それ以上の疑問は抱かんかったけど

試してないけど、俺も>>404に同意
多分整数演算で除算演算の関数を関数合成すれば、いくつか試せば同一にならないのは簡単に見つかるはず
引数をたくさん試すだけでも見つかりそう　めんどこっいのでやらないけど
0408デフォルトの名無しさん
垢版 |
2020/08/21(金) 23:19:07.20ID:nqLClnr+
>>405
それってそうなの？

俺は、数学の本好きで読んでるんだけど、そこまで基本的なことは突き詰めてないｗ
写像の合成が結合則を満たす　ものもたくさんありそうだけど、
写像の合成は必ず結合則を満たすものなの？そこから疑問に思った方がいいんじゃない？
数学の本読んでると、右XXと左XXと区別するものが多いんで、普通に満たさないと思ってたｗ
いや、俺が間違ってるかもしれんから、そこから調べてくれると俺もうれしい

ちなみに、大学数学レベルなのが　１＋１＝２　の証明。俺は調べたくないｗ
0409デフォルトの名無しさん
垢版 |
2020/08/22(土) 00:32:18.31ID:75MjfSAz
>>408
位相空間論の入門書には大抵書いてあるよ
あと「Haskellによる関数プログラミングの思考法」にも(証明は無いが)言及があった

((f . g) . h) x
= (f . g) (h x)
= f (g (h x))
= f ((g . h) x)
= (f . (g . h)) x

この等号は計算結果が等しいという意味で
途中の時間・空間計算量の違いは気にしていないので念の為
0410デフォルトの名無しさん
垢版 |
2020/08/22(土) 00:48:03.06ID:66roH7xF
>>408
しらんけど、位相空間って連続写像仮定してないか？
プログラミング言語でいう写像とは違う
位相空間論で一般的に言われているのならその定理を示した方がいいんじゃない？
個人的には位相空間論の書籍に限定しているのが気になる。どちらかと言うと代数学の方が一般的と思うが。

＞あと「Haskellによる関数プログラミングの思考法」にも(証明は無いが)言及があった
こっちはたぶん書籍持ってるかな？ページ数教えてくれる？
四則演算というか群論でいう、逆元を仮定しているとかそんな感じやない？しらんけど

数学ではよくあるけど、仮定が大事　それを無視するから、結論を間違えるのはよくある
貴方が間違えたかどうかは知らんど
写像の合成で結合則が必ず成り立つのなら、そのような記述はどっかの書籍に必ずある
自分は見たこと無い。あるとすれば、なんらかの仮定で限定されている。
0412デフォルトの名無しさん
垢版 |
2020/08/22(土) 01:40:43.87ID:75MjfSAz
>>410
> 個人的には位相空間論の書籍に限定しているのが気になる。どちらかと言うと代数学の方が一般的と思うが。
位相空間論の～っていうのは言い方が悪かったかな、「集合と位相」みたいなタイプのやつ
大抵最初の方で一般の集合論をやるのでそういうつもりで言った

仮定が大事というのはその通りで
もちろん連続性も全単射も仮定しない一般の写像に対する定理

集合A, B, C, D と写像 f: C->D, g: B->C, h: A->B に対して
(f . g) . h = f . (g . h) が成り立つ

> ＞あと「Haskellによる関数プログラミングの思考法」にも(証明は無いが)言及があった
> こっちはたぶん書籍持ってるかな？ページ数教えてくれる？
P.30 第1章 練習問題Eの解答
こっちはあまりにも簡素に書いてあるので見ても何の参考にもならないかもだが…

ただしHaskellには全域でない関数があるから(headとかtailみたいな例外を返し得るやつね)
そういうのが絡むと結合性が怪しいケースはもしかしたらあるかもしれない
0414デフォルトの名無しさん
垢版 |
2020/08/22(土) 13:18:34.82ID:g0O87mtN
空気読まずに有限集合でやってみる。

``` code
#{-# LANGUAGE ExistentialPython #-}
import math;
import random;
import string;
def none ():
dot = lambda bc, ab: {a : bc [b] for a, b in ab.items ()};
make_map = lambda a, b: dict (zip (a, random.choices (b, k = len (a))));
A = tuple (range (5));
B = random.sample (string.ascii_lowercase, 10);
C = random.sample (string.ascii_uppercase, 8);
D = (math.nan, math.inf, None, (), 'hello', 'world');
ab = make_map (A, B);
bc = make_map (B, C);
cd = make_map (C, D);
assert dot (cd, dot (bc, ab)) == dot (dot (cd, bc), ab);
return ((A, B, C, D), (ab, bc, cd));
out = none ();
```

自分の知る限り、素朴な写像の描像が描けないガジェットに対して「写像」という
言葉は使わないので、写像が結合的かどうかという議論に意味があると思えない。
0415デフォルトの名無しさん
垢版 |
2020/08/22(土) 13:19:16.92ID:g0O87mtN
``` code
#{-# LANGUAGE FunctionalJupyter #-}
import IPython.display as display;
def none (node, edge):
f = lambda col, a: {key : (row, col) for row, key in enumerate (a)};
nodes = {};
for val in [f (j, a) for j, a in enumerate (node)]: nodes.update (val);
edges = [];
for xy in edge: edges += [(nodes [x], nodes [y]) for x, y in xy.items ()];
node_out = r"""<text class='clazz' x='{x}' y='{y}'>{z}</text>""";
edge_out = r"""<line class='clazz' x1='{x_0}' y1='{y_0}' x2='{x_1}' y2='{y_1}'/>""";
out = '';
w, h, dw = 100, 20, 20;
for key, val in nodes.items (): out += node_out.format (x = w * val [1], y = h * val [0], z = key);
for a, b in edges: out += edge_out.format (x_0 = w * a [1] + dw, y_0 = h * a [0], x_1 = w * b [1] - dw, y_1 = h * b [0]);
style = r"""<style> text.clazz { dominant-baseline: middle; text-anchor: middle; } line.clazz { stroke: black; fill: none; } </style> """.strip ();
svg = f"""<svg width='400' height='300' viewBox='{-20} {-20} {len (node) * w + 20} {max (map (len, node)) * h + 20}'>{out}</svg>""";
display.display (display.HTML (style + svg));
return None;
none (*out);
```
0416デフォルトの名無しさん
垢版 |
2020/08/22(土) 13:31:18.86ID:DGMheHKA
それで？
会話や食事の中の唾液飛沫の3次元シミュレーションが出来るんですか？
0417デフォルトの名無しさん
垢版 |
2020/08/22(土) 13:35:02.20ID:j3K8XBr1
>>402
あれ、これ今日コンパイルしたらエラーが出た。
単にコンパイルしていなくて、ghciで用意されている(.)を使ってテストしていただけみたいです。

以下の合成関数のコードはおそらく正しいと思います。
comp :: (b -> c) -> (a -> b) -> a -> c
comp = \f -> \g -> (\x -> f (g x))
0418デフォルトの名無しさん
垢版 |
2020/08/22(土) 13:36:18.12ID:j3K8XBr1
圏論入門 Haskellで計算する具体例から (日本語) 単行本 ? 2020/8/19
雪田 修一 (著)

この超人気の本を読んだ人いますか？
0419デフォルトの名無しさん
垢版 |
2020/08/22(土) 13:41:29.64ID:j3K8XBr1
>>417
この関数の書き方を一度書いたら、
func a b = …
みたいな書き方は気持ち悪くて嫌になりますね。
0420デフォルトの名無しさん
垢版 |
2020/08/22(土) 13:45:41.47ID:j3K8XBr1
すごいHaskell、やっと5章まで読み終わりました。
この辺りから難しくなりますか？
0421デフォルトの名無しさん
垢版 |
2020/08/22(土) 21:29:49.29ID:YtG8IJDk
難易度竹。
0422デフォルトの名無しさん
垢版 |
2020/08/22(土) 21:45:32.55ID:j3K8XBr1
すごいHaskellの6章を読んでいますが、いきなり難しくなりました。

find :: (a -> Bool) -> [a] -> Maybe a
のMaybe aというのは探している要素が見つからなかった場合に返されるNothingが属するような型を用意したかったからですか？
0423デフォルトの名無しさん
垢版 |
2020/08/22(土) 21:46:48.62ID:j3K8XBr1
もしそうだとして、質問なんですが、Nothingはあらゆる型に属すると約束すればいいだけの話ではないんですか？
0424デフォルトの名無しさん
垢版 |
2020/08/23(日) 07:53:38.79ID:m55Vd3Cb
「null安全」でググれ
かつて、あらゆる型に属するnullを導入していた言語が、
nullのない型を別途導入する方向に動いている
0425デフォルトの名無しさん
垢版 |
2020/08/23(日) 10:09:34.95ID:ts+Zp8he
ヌルポはどこにバグがあるかを教えてくれるが、
ボトポにはそれさえない。

``` code
bottom :: a
bottom = bottom

dangerous_find :: (a -> Bool) -> [a] -> a
dangerous_find _ [] = bottom
dangerous_find pred (a : as) = if pred a then a else dangerous_find pred as
```

ただ役に立たないというだけでなく、
危険なほど役に立たない関数も作りたければ作れる。
0426デフォルトの名無しさん
垢版 |
2020/08/23(日) 11:59:38.54ID:PT3WAMjf
>>403
これ、左結合が出来ないからじゃない
考え方としては左結合はありなんだろうけど、
実質無いということ

f.g.h x　で左結合やろうとしても、

関数適用と合成の優先順位で関数適用の方が優先される
結果として右結合にしかならない。
0427デフォルトの名無しさん
垢版 |
2020/08/23(日) 12:29:03.24ID:hbFjgy0U
学術の巨大掲示板群 - アルファ・ラボ ttp://x0000.net
数学 物理学 化学 生物学 天文学 地理地学
IT 電子 工学 言語学 国語 方言 など

VM + ASM を書いた (C#, DX) * x86 ではない!
simulationライブラリで純粋な関数式プログラミングをする
UIライブラリ (C#, 2D) を作ったよ
連続と離散を統一した！
4Dエンジン
matrixのライブラリ
ある強力なFor関数
SQLライブラリ

VM + ASM のダウンロード
ttp://up.x0000.net/files/TSimulang.zip
0428デフォルトの名無しさん
垢版 |
2020/08/23(日) 13:32:54.91ID:41ZiKAKU
>>426
「関数合成は、一度にたくさんの関数を合成できます。f (g (z x))は(f . g. z) xと等価です。」
だったら、違和感がないんですが、
「関数合成は右結合なので、一度にたくさんの関数を合成できます。f (g (z x))は(f . g. z) xと等価です。」
には違和感を感じます。

一度にたくさんの関数を合成できる理由が関数合成が右結合だからというのはやはりおかしいと思います。
0429デフォルトの名無しさん
垢版 |
2020/08/23(日) 13:36:29.73ID:41ZiKAKU
Function composition is right-associative, so we can compose many functions at a time.
The expression f (g (z x)) is equivalent to (f . g . z) x.

これが原文です。翻訳がおかしいわけではないようですね。
0430デフォルトの名無しさん
垢版 |
2020/08/23(日) 13:53:55.24ID:PT3WAMjf
関数適用を合成より優先順位上げる条件のもと
合成を左結合でλ式に落とし込こんでみればいいんじゃない

出来るのなら俺の間違い　出来ないのなら
左結合では合成が出来ないのだから、文章も間違ってない

と思っただけ
0432デフォルトの名無しさん
垢版 |
2020/08/23(日) 16:16:46.30ID:41ZiKAKU
>>424
ありがとうございました。検索してみようと思います。

>>425
ちょっと何を言っているのか分かりませんでした。
0433デフォルトの名無しさん
垢版 |
2020/08/23(日) 23:06:04.74ID:ts+Zp8he
ごめん、関係ないと書いておくべきだった。
今後は、自分の投稿は全て無視して欲しい。
誰かの質問に答えているつもりはなくて、
プログラミングのネタを拾っているだけ。

ついでなので、前回のペーストビンにアップしたネタについて書く。

まず、タプル、状態、継続以外の随伴はちゃんとしていない。
アウェイの圏をちゃんと書こうとすると泣きが入る。Haskellは集合の圏では
超強力だが、それ以外の圏に対しては並になる。中は見てないが、
[species](https://hackage.haskell.org/package/species)では、
圏をほぼフルスクラッチで作っているんじゃないかと思う。
で、コードにする段階でウソをついているのだが、素直にウソをつけば、
上手く行くことがあるということがあそこで得た教訓。

あそこに書いたモナドでパラメーター対象を２つ持つモナドは全て`R p (L p a)`
という形をしているが、コードでは型宣言を省略しているので、結局、
非対角成分を含めた`R p (L q a)`という形の関手についてのKleisli合成が
得られている。それがレンズが出てきた理由の一つ。
書いたときは知らなかったのだが、非対角成分を含めた関手を
[インデックスモナド](https://stackoverflow.com/questions/28690448/what-is-indexed-monad)
というらしい。パラメーター対象をもつ随伴からKleisli合成を計算すれば、
自然とインデックスモナドになってしまう。ただし、圏論プロパーに
インデックスモナドと言っても通じないと思う。Haskellでの専門用語だと思う。
0434デフォルトの名無しさん
垢版 |
2020/08/25(火) 10:01:02.60ID:d4SFWo3v
Data.Mapについて質問です。

キーがOrd型でないといけないという制約があります。

これは、Mapの実装でキーのデータ構造がハッシュではなく、２分探索木のようなものだからでしょうか？
0437デフォルトの名無しさん
垢版 |
2020/08/27(木) 10:07:06.62ID:TufIdPw/
Jupyter NotebookでHaskell使うならこれ
環境構築の手間が省けるのでおすすめ
Chromebook、iPad、Windows 10 Sモードなどで使えるかは知らない
https://mybinder.org/v2/gh/gibiansky/IHaskell/master

IHaskell
https://github.com/gibiansky/IHaskell
＞ You can now try IHaskell directly in your browser at CoCalc or mybinder.org.
Alternatively, watch a talk and demo showing off IHaskell features.
0439デフォルトの名無しさん
垢版 |
2020/08/28(金) 11:44:03.31ID:8bIwySwM
ついにメンテのされてないgladeが最新のghcじゃビルドできなくなった
シコシコGUI作るの面倒くさくて意気消沈
0441デフォルトの名無しさん
垢版 |
2020/08/28(金) 12:57:36.50ID:lCzdfIoX
デスクトップGUIアプリの大半はWebブラウザアプリで代替できる。
これを機に、一度こだわりを捨ててみるのも良いかも。
0442デフォルトの名無しさん
垢版 |
2020/08/28(金) 13:05:48.93ID:LLs1s+XQ
Webブラウザアプリの大半はデスクトップGUIアプリの方が使い易い。
0446デフォルトの名無しさん
垢版 |
2020/08/30(日) 11:24:16.79ID:uCpf8zkM
質問です
次のプログラムが走りません
Ratio Integer型の割算です
mainの最後の行を受け付けてくれません

import Data.Ratio
import Data.Complex

(///) (x:+y) (z:+w) = let
d = z^2 + w^2
in ((x*z-y*w)/d):+((x*w+y*z)/d)

x :: Ratio Integer
x = 1%1
y = 3%1
z = 2%1
w = 4%3

main = do
print $ (x:+y) /// (z:+w)
print $ x / (z^2+w^2)
print $ (x:+y) /// ((z:+w) + (x:+y))
0447デフォルトの名無しさん
垢版 |
2020/08/30(日) 11:24:49.92ID:uCpf8zkM
エラーメッセージは以下です
何がダメかどなたかわかりませんか？

Haskell Online Compiler [ghc-8.4.4]
Copyright (c) The University of Glasgow

Compiling your program...

[1 of 1] Compiling Main ( prog.hs, prog.o )

prog.hs:23:25: error:
• No instance for (RealFloat (Ratio Integer))
arising from a use of ‘+’
• In the second argument of ‘(///)’, namely ‘((z :+ w) + (x :+ y))’
In the second argument of ‘($)’, namely
‘(x :+ y) /// ((z :+ w) + (x :+ y))’
In a stmt of a 'do' block:
print $ (x :+ y) /// ((z :+ w) + (x :+ y))
|
23 | print $ (x:+y) /// ((z:+w) + (x:+y))
| ^^^^^^^^^^^^^^^
0448デフォルトの名無しさん
垢版 |
2020/08/30(日) 11:27:13.14ID:uCpf8zkM
あ、11行目は
in ((x*z-y*w)/d):+((-x*w+y*z)/d)
でした
でも同じエラーメッセージ出てきます
何故でしょう？
0449デフォルトの名無しさん
垢版 |
2020/08/30(日) 14:19:38.49ID:ubwYKL6u
>>446
自己レスです
もしかしてこの型制限ですかね？

RealFloat a => Num (Complex a)

Complex a型がNumクラスに入れるのはaがRealFloat型の時しかダメだからでしょうか？
この制限はなんでこんなにキツイんだろ
足したり引いたりしたいだけなのに
0450デフォルトの名無しさん
垢版 |
2020/08/30(日) 15:28:05.73ID:0W5gc2Gs
>>449
自作のComplexクラスをNum型クラスのインスタンスにしてみようとすると気づくんだけど
Numってなぜかabs関数を実装しないといけないんだよね
それで複素数の妥当な絶対値関数を書くにはsqrtが必要だけど
Numだと計算できないので…という理屈のはず

Haskellの標準の数値型に対する不満はちょくちょく見かけるけど
歴史的経緯もあって現状はしょうがないということになってるはず
0451デフォルトの名無しさん
垢版 |
2020/08/30(日) 15:32:06.86ID:mGp/4vHZ
>>449
https://downloads.haskell.org/~ghc/latest/docs/html/libraries/base-4.14.0.0/src/Data-Complex.html
でData.ComplexのソースコードでNumクラスのインスタンス定義を見たところ
メソッドabsとsignumの実装に
magnitude :: (RealFloat a) => Complex a -> a
を使ってるからみたいだね

本当に足したり引いたりしたいだけならNum制約は強すぎる
数のクラス体系の問題点について詳しくは
https://blog.miz-ar.info/2016/06/haskell-num-class/
0453デフォルトの名無しさん
垢版 |
2020/08/31(月) 00:20:32.36ID:XlY0VH6O
Complex RationalにNumのinstance宣言できないかと思って以下のようにしてみました

instance Num (Complex Rational) where
(x:+y) + (x':+y') = (x+x') :+ (y+y')
(x:+y) - (x':+y') = (x-x') :+ (y-y')
(x:+y) * (x':+y') = (x*x'-y*y') :+ (x*y'+y*x')
negate (x:+y) = negate x :+ negate y
abs z = undefined
signum z@(x:+y) = undefined
fromInteger n = fromInteger n :+ 0

結果以下のようにそれは無理と怒られます
何かてはないでしようか？

Haskell Online Compiler [ghc-8.4.4]
Copyright (c) The University of Glasgow

Compiling your program...

[1 of 1] Compiling Main ( prog.hs, prog.o )

prog.hs:7:10: error:
• Illegal instance declaration for ‘Num (Complex Rational)’
(All instance types must be of the form (T a1 ... an)
where a1 ... an are *distinct type variables*,
and each type variable appears at most once in the instance head.
Use FlexibleInstances if you want to disable this.)
• In the instance declaration for ‘Num (Complex Rational)’
|
7 | instance Num (Complex Rational) where
| ^^^^^^^^^^^^^^^^^^^^^^
0455デフォルトの名無しさん
垢版 |
2020/08/31(月) 13:16:55.43ID:m1GQ7XMv
意味も分からずコンパイラの指示に従ってばかりいても、
初心者の域は抜けられない

でも、コンパイルできなきゃモチベーションが下がるから、
取りあえず従っとけ
0457デフォルトの名無しさん
垢版 |
2020/08/31(月) 17:10:43.28ID:rDcCtqL6
標準のhaskellだと

instance 型クラス 型構築子
instance 型クラス (型構築子 型変数1)
instance 型クラス (型構築子 型変数1 型変数2)
…

って形式のインスタンス宣言にしか対応してないからな

instance 型クラス (型構築子 型構築子)

って書きたいなら言語拡張使えって言われる

言語拡張使うか、あるいは、もっと一般的なインスタンス宣言
instance Num a => Num (Rational a)
とかにしたら？
0458デフォルトの名無しさん
垢版 |
2020/08/31(月) 18:26:13.20ID:mkAi3PX1
皆さんご助言ありがとうございます
実は家のパソコン壊れててHaskellはオンラインHaskellコンパイラというので当座を凌いでるんですがコレコンパイラオプションもインラインプラグマ？とかいうのも使えないっぽくてFlexible Instanceとか使いたくても使えないんです
Num Rationalは標準で入ってます
入れられなくて困ってるのはNum (Complex Rational)なんです
Num a=>Num (Complex a)
は二重定義でダメだと怒られます

prog.hs:55:12: error:
Duplicate instance declarations:
instance Num a => Num (Complex a) -- Defined at prog.hs:55:12
instance RealFloat a => Num (Complex a)
-- Defined in ‘Data.Complex’
|
55 | instance Num a => Num (Complex a) where
| ^^^^^^^^^^^^^^^^^^^^^^^^
0459デフォルトの名無しさん
垢版 |
2020/08/31(月) 18:28:35.47ID:mkAi3PX1
しょうがないのでとりあえずComplex Rationalを“カプセル化”してみました
複素座標0,3,4i,7/2+7/2iである4点が同一円周上にあるか確認するプログラムです
同じ事をComplex Floatとかでやると丸め誤差で誤判定してくれます
できるんですがちょっと不愉快ですね
0460デフォルトの名無しさん
垢版 |
2020/08/31(月) 18:28:47.62ID:mkAi3PX1
import Data.Ratio
import Data.Complex

data ComplexRational = CR (Complex Rational) deriving (Show,Eq)
instance Num (ComplexRational) where
(CR (x:+y)) + (CR (x':+y')) = CR $ (x+x') :+ (y+y')
(CR (x:+y)) * (CR (x':+y'))
= CR $ (x*x'-y*y') :+ (x*y'+y*x')
negate (CR (x:+y)) = CR $ negate x :+ negate y
abs = undefined
signum = undefined
fromInteger n = CR $ fromInteger n :+ 0
instance Fractional (ComplexRational) where
recip (CR (x:+y))= CR $ (x/(x^2+y^2)):+(-y/(x^2+y^2))
toComplex (CR x) = x

i = CR $ 0:+1

onCircle a b c d = (==0) $ imagPart $ toComplex $ ((a-c)/(b-c))/((a-d)/(b-d))

a=0
b=3
c=4*i
d=7/2+7/2*i

main = do
print $(1/2+3/4*i)/(5/6+7/8*i)
print $ onCircle a b c d

-----
CR (618 % 841 :+ 108 % 841)
True
0461デフォルトの名無しさん
垢版 |
2020/09/03(木) 16:35:31.39ID:VDk3Uebh
すごいHaskell、7章を読んでいますが、正直、重要ではあるが面白くない内容なので読むペースが遅くなってしまっています。
最後まで読み切ろうと思います。
0462デフォルトの名無しさん
垢版 |
2020/09/03(木) 16:55:07.23ID:VDk3Uebh
図書館にリクエストした以下の本を買ってもらうことができて、明日、借りられることになりました。
楽しみです。

圏論入門 Haskellで計算する具体例から
雪田 修一 (著)
0463デフォルトの名無しさん
垢版 |
2020/09/04(金) 20:26:41.82ID:zDdu0cA6
雪田著『圏論入門』を借りてきました。
圏論、難しい上につまらないです。
0466デフォルトの名無しさん
垢版 |
2020/09/05(土) 02:01:31.05ID:hzZ7uEzq
>>458
です
自己レスです
色々調べて一応Complex RationalにNumのinstance入れる方法見つけました
しかしかなり裏技というか、あまり関心しない方法かもしれません
やはり正攻法は>>460のようにカプセル化する方だと思いますけど、せっかく見つけたのでうpします
>>460と同じく0,3,4i,7/2+7/2iが同一円周上にあるか確認するプログラムです
ついでにabsも使えるようにしてあります
absがいらないならsqrt=の部分がなくても動作します
0467デフォルトの名無しさん
垢版 |
2020/09/05(土) 02:03:13.00ID:hzZ7uEzq
import Data.Ratio
import Data.Complex

instance (Integral a)=> Floating (Ratio a) where
sqrt = fromRational.toRational.sqrt
.fromRational.toRational
instance (Integral a) => RealFloat (Ratio a) where
floatDigits = floatDigits.fromRational.toRational
decodeFloat = decodeFloat.fromRational.toRational
scaleFloat k x = if k > 0 then x*2^k else x/2^(-k)
0468デフォルトの名無しさん
垢版 |
2020/09/05(土) 02:03:23.39ID:hzZ7uEzq
i = 0:+1%1

onCircle a b c d = id
$ (==0)
$ imagPart
$ ((a-c)/(b-c))/((a-d)/(b-d))

(a,b,c,d)=(0,3,4*i,7/2+7/2*i)

main = do
print $(1/2+3/4*i)/(5/6+7/8*i)
print $ onCircle a b c d
print $ ((a-c)/(b-c))/((a-d)/(b-d))
print $ abs $ 2+3*i
print $ abs $ 15+8*i
----
618 % 841 :+ 108 % 841
True
4 % 7 :+ 0 % 1
8118979690322419 % 2251799813685248 :+ 0 % 1
17 % 1 :+ 0 % 1
0469デフォルトの名無しさん
垢版 |
2020/09/05(土) 13:15:04.05ID:T3msgi7J
純粋に興味のみからすごいHaskellを読んでいるのですが、みなさんはなぜHaskellを使っているのですか？
0473デフォルトの名無しさん
垢版 |
2020/09/05(土) 17:37:30.47ID:acNOQ2m1
『Haskellによる関数プログラミングの思考法』って出たの３年前なのに書籍版はもう絶版なんだな
旧版を元にした『関数プログラミング入門』の方はまだ売ってるけど
0474デフォルトの名無しさん
垢版 |
2020/09/05(土) 18:22:32.54ID:r4XBIbpb
3年で消えてもらった方が新しい商品が売れるという実用的思考
永久保存など消費者の趣味だ
0481デフォルトの名無しさん
垢版 |
2020/09/07(月) 17:57:43.88ID:kXMphwO9
>>480
ベーシック圏論はどうですか？
0482デフォルトの名無しさん
垢版 |
2020/09/07(月) 18:10:28.73ID:oaoIrH3d
haskellのモナド理解するだけなら圏論いらないからね

ベーシック圏論は内容を限定して敷居の低い例を使っているので相対的には
読みやすいけど、基礎的な数学の知識がないと例が理解の助けにならないのは同じ
0483デフォルトの名無しさん
垢版 |
2020/09/07(月) 20:28:07.77ID:xmFuETjj
関手って圏が持つ「対象と射」同志の関連付けのことだよね？
なぜfmap関数を定義すると関手を実装したことになるの？
0488デフォルトの名無しさん
垢版 |
2020/09/09(水) 12:18:16.37ID:/Y+BdKRx
do記法が使えるようになる

モナド＝>モナド則を満たす＝>do記法はモナド則の別バージョン

結局のところ、モナドはdo記法を作りたかった。よって、先頭の話になる。
0489デフォルトの名無しさん
垢版 |
2020/09/09(水) 12:43:31.80ID:/Y+BdKRx
ちょっと嘘だな
488は既にあるモナドを使う場合の話で

自分でモナドを作ってみたいのなら
モナド則を満たしていることの確認が必要　
ってことで、モナド則の勉強も必要

個人的にモナドが一番分かり易かったのは、↓かな

サルでもわかるIOモナド①-③
http://hot-heart-cool-mind.seesaa.net/article/393131366.html
0490デフォルトの名無しさん
垢版 |
2020/09/09(水) 12:59:11.96ID:7PwBIIdR
モナドというのが何なのか知らないのですが、モナドが何か分かっていないとモナドは使えないものなんですか？
0492デフォルトの名無しさん
垢版 |
2020/09/09(水) 18:46:46.75ID:7PwBIIdR
>>490
それともHaskellという言語は何でもかんでもある数学的に説明できるように設計されていて気持ちがいいというだけのことでしょうか？
0493デフォルトの名無しさん
垢版 |
2020/09/09(水) 18:50:44.11ID:N/YnHGom
低学歴の数学弱いなのに、頑張ってHaskellで開発の会社に潜り込んで仕事してる人も居るから。
0495デフォルトの名無しさん
垢版 |
2020/09/09(水) 19:44:40.13ID:7PwBIIdR
仕事でHaskellを使っている会社があるのですか？
実用面でのHaskellの利点があるということですか？
0496デフォルトの名無しさん
垢版 |
2020/09/09(水) 19:58:00.07ID:7PwBIIdR
「Haskellの美しさを知っている人は、人生に絶望することはない。Haskellで世界を変えたい。」などと表紙に書かれているHaskellの本が
ありますが、そんな大げさなものでしょうか？

単なる一プログラミング言語ではないんですか？
0497デフォルトの名無しさん
垢版 |
2020/09/09(水) 20:15:19.85ID:+oYkcMI9
型システムが強力ってだけで実用上有利
現実、型がしょぼい言語よりバグ減るし、
型から関数探せるから既存プログラムの再利用性高いし、
ウェイがノリで作る「イケてる」オレオレライブラリなんかにも型の合うある程度まともな設計が求められるし
0504デフォルトの名無しさん
垢版 |
2020/09/12(土) 10:38:44.00ID:A2+hHxph
[分数モナド](https://ncatlab.org/nlab/show/Grothendieck+group+of+a+commutative+monoid)

日常生活でも目にする`2 / 3`のような分数表記はモナドになっている。
吸収元の問題があるので、ネタとしては引き算`2 - 3`の方が扱いやすいが、
引き算の場合、`2 - 3 = - 1`のように計算してしまった結果が使われ、
日常生活では生々しいモナド表記はあまり使われない。その点、分数では、
直積からのコンストラクターをもろに使った漢な表現が
日常生活の中で使われている。

分数は、モナドを使うことと、モナドを理解することは別腹という
良い例になっている気がする。分数がモナドになっていることが生きてくるのは、
システムがそれなりに複雑になってからじゃないかと思う。抽象化には
コストがかかるので、そのコストに見合った見返りが必要になるが、
システムが簡単だと、抽象化のコストをペイできない。

分数モナドは有名な例なので、何処かのブログで紹介されていると思うが、
見たことがないので、書いてみた。ホームが可換モノイドの圏なので、
オレオレモナドになってしまうが、モナド則の`QuickCheck`はできるので、
圏論の練習になるかもしれない。
0506デフォルトの名無しさん
垢版 |
2020/09/13(日) 08:12:50.88ID:Tso/1gLY
ひ？何言ってんの
0509デフォルトの名無しさん
垢版 |
2020/09/13(日) 21:12:53.92ID:Tso/1gLY
ふ？何言ってんの

可換モノイドの圏は集合の圏の
[部分圏](https://ncatlab.org/nlab/show/subcategory)だが、
集合の圏ではない。したがって、分数モナドは、
Haskellの`Monad`のインスタンスにならない。
例えば、次のような実装を考えると、

``` code
newtype Bunsu a = Bunsu {
runBunsu :: (a, a)
} deriving (Show, Functor)

instance (Eq a, Semigroup a) => Eq (Bunsu a) where ...
instance (Semigroup a) => Semigroup (Bunsu a) where ...
instance (Monoid a) => Monoid (Bunsu a) where ...
instance (Monoid a) => Group (Bunsu a) where ...

bunsu_pure :: (Monoid a) => a -> Bunsu a
bunsu_pure = ...
```

縛り`Monoid a`が邪魔をして、`Bunsu`は`Applicative`のインスタンスに
できない。それでも、通常の関数の形でなら`bunsu_pure`と`bunsu_join`は
書けるので、モナド則のチェックはできる。ただし、`Bunsu`は、
可換モノイドの圏でのモナド則は満たすが、集合の圏でのモナド則は満たさない。

質問への直接の答えは避けるが、可換モノイドの圏で考えないと
答えは得られない。
0510デフォルトの名無しさん
垢版 |
2020/09/13(日) 23:57:07.12ID:Tso/1gLY
へ？何言ってんの

もしかすると、何言ってんのが前の投稿にかかっちゃったかもしれない。
何も考えずに、何言ってんのおじさんプレイを楽しんでいるだけなので、
気にしないでほしい。

ついでなので。
`return x = x / x`という選択は、集合の圏では、取りうる唯一の選択肢かも
しれない。自分も他に思いつかない。しかし、可換モノイドの圏では、
他にも選択肢がある。それも含めて、
[記事](https://ncatlab.org/nlab/show/Grothendieck+group+of+a+commutative+monoid)
に全て書いてある。他人事なので断言してしまうが、この記事より詳しい
分数モナドの解説は地球上には存在しない。しかし、悲しいかな、
Haskellの解説記事と同じで、

* わかる人にはわかるが、
* わからん人にはなるほどわからん

といういつものパターンになっていると思う。解説案件の宿命かもね。
0513デフォルトの名無しさん
垢版 |
2020/09/14(月) 16:41:03.56ID:TxRaIMAU
Monad という概念が数学の圏論の Monad から来るのはよく解説が見つかるんですが、Applicative (≒Monoidal) については数学からの意味付けが見つかりません
コレ数学的にはなんなんですか？
0514デフォルトの名無しさん
垢版 |
2020/09/14(月) 23:29:35.74ID:XfiH3m4/
そのままじゃん　アプリカティブファンクター
なんだから、そのまま日本語訳でよくね
つまり、関手　プログラマーにとって使いやすくしただけ

ところで、”Applicative (≒Monoidal)”なのか？
こっちの方がい意味不明なんだが
モノイドって意味なら、≒モナド　の方

モナイド則＝モノイド則　モナドの方は、自己関手って条件が付くだけ

しらんけど
0515デフォルトの名無しさん
垢版 |
2020/09/15(火) 00:17:11.21ID:wUKRYY2O
>>514
まだ自分でハッキリ確かめたわけじゃないんですけど
Applicative と Monoidal は同型なんだそうです

https://qiita.com/Guvalif/items/7f893d9a078e03c9e425

まだこっちはどういう意味で“同型”になるのかわかってませんけど
数学的な意味でのMonadは英語のwikiに詳しく説明が載ってて↓
https://en.m.wikipedia.org/wiki/Monad_(category_theory)
このFormal DefinitionがまさにHaskellのモナド則に繋がっていくのは確かめました
問題はApplicativeは圏論のどの概念に該当するのかの説明がサッパリ見つからないんです
0516デフォルトの名無しさん
垢版 |
2020/09/15(火) 02:19:25.61ID:PObv6BQ8
(a -> b) -> (m a -> m b)
m (a -> b) -> (m a -> m b)
(a -> m b) -> (m a -> m b)
こいつらは中央の->と左右の->を区別してないから数学的な意味が見えない

returnとjoinは->が一つしかないから問題ないが
0517デフォルトの名無しさん
垢版 |
2020/09/15(火) 10:15:51.98ID:TeSbfrM9
>>516
そう、Haskellの圏論がらみの話はその“冪対象”(exponential object)が絡むのがややこしい
しかしFunctorは当然としてMonadも冪対象を用いないで形式化されてる(というより計算論の世界への応用のずっと以前からある)
Applicative(=Monoid?)はどやねんという話なんです
圏論の世界ではなかったものが計算論の世界に導入されてから考え出されたもんなんですかねぇ？
0519デフォルトの名無しさん
垢版 |
2020/09/16(水) 22:12:52.40ID:CfmtxJKj
モノイド圏とかモノイド対象とかあんのだけど、モノイド(モノイダル)関手ってのもあんのね

読む気は無いんだけど、アプリカティブ関手とモノイダルＸＸが同型ってのは無いと思うが
っておもったけど、関手同士なんだから、いくつか条件つければモナドとモノイドみたいな関係もありうるんかな？

あとは、カン拡張、随伴、普遍性（極限だっけ？）　どれかから相互に変換出来るだっけ？みたいなもん？

どちらにしろ、定義の話で面白みは無いとは思うのだが
0520デフォルトの名無しさん
垢版 |
2020/09/17(木) 10:32:26.07ID:2a8IoKJu
見つけた

https://qiita.com/Guvalif/items/7f893d9a078e03c9e425

このサイトの人がまとめたpdfに書いてある
とは言ってもやはりclosed categoryは仮定してる
やっぱりapplicativeはmonadと違って“内部ホム”を持たない圏では定義できないんだろな
“内部ホム”もつ圏でmonoidal functorに<*>を定義するのはわりと簡単だけど↓
F(X) × F(Y^X)
→F(X×Y^X) (coherence)
→F(Y) (F(eval))
https://en.m.wikipedia.org/wiki/Monoidal_functor
pureが全然できんなぁと思ってたら“strong”という条件からpureが作れるんだな
まぁHaskellて圏の話するときはHASKて言えればいいんだからコレでわかったことにしよ
0522デフォルトの名無しさん
垢版 |
2020/10/14(水) 04:31:41.26ID:+VLXbnA3
>>20
ワードカウントのロジックが不思議ちゃんだと思ったけどワードと空白の関係が
"abc dd "みたいな行儀が良い書式じゃないとだめなんだな
" "一文字スペースでワード数が1になってしまうみたいな
countFile :: String -> (Int, Int, Int)
countFile s =
let (cs, ws, ls, _) = foldl' go (0, 0, 0, False) s
in (cs, ws, ls)
where
go :: (Int, Int, Int, Bool) -> Char -> (Int, Int, Int, Bool)
go (cs, ws, ls, wasSpace) c =
let addLine | c == '\n' = 1
| otherwise = 0
addWord | wasSpace = 0
| isSpace c = 1
| otherwise = 0
in (cs + 1, ws + addWord, ls + addLine, isSpace c)
0523デフォルトの名無しさん
垢版 |
2020/10/31(土) 09:11:59.11ID:UJYxitvT
http://walk.northcol.org/haskell/adts/
>代数的データ型（algebraic data type）とは，図のように木構造で表現される値からなるデータ型のことです．

必ず木構造に限定されるんだろうか？
OOPではオブジェクトグラフがありネットワークになりうるが、
Haskellでは絶対に木と考えて良いの？
0524デフォルトの名無しさん
垢版 |
2020/10/31(土) 12:29:50.75ID:cEs7BAmA
いいんじゃない？
型の全体は文脈自由文法で規定されるクラスだから木になる希ガス
0525デフォルトの名無しさん
垢版 |
2020/10/31(土) 12:34:33.57ID:fxcwqRC2
この木なんの木きのこる木
0527デフォルトの名無しさん
垢版 |
2020/10/31(土) 13:17:41.17ID:cEs7BAmA
でもよくよく考えたらHaskellのデータ型って「展開できる表現がひとつもないデータ型」もありうるんだな
無限の木になる

data InfiniteSequence = IS {car :: Int, cdr :: InfiniteSequence}

arithSeq a d = IS a $ arithSeq (a+d) d

term 0 (IS x y) = x
term n (IS x y) = term (n-1) y

main = print $ term 10 $ arithSeq 5 3
----
53
0528デフォルトの名無しさん
垢版 |
2020/10/31(土) 13:26:01.44ID:UJYxitvT
再帰的なデータ型はグラフにできるのでは？
0529デフォルトの名無しさん
垢版 |
2020/10/31(土) 13:37:30.03ID:B0ELcd4k
最終的に暴走しないで展開が停止するものだけをデータ型と呼ぶならそうだけど、iterate (+4) 5 ですら無限の木になってしまう
0531デフォルトの名無しさん
垢版 |
2020/10/31(土) 22:07:18.29ID:XiPKdEPZ
foldrなどの引数のことを代数的と言っていたような気がする
引数は(:)と[]でもいいし
(+)と0でもいい

引数を渡すと関数 [a] -> b が返ってくるが
これは関数というよりOOPの継承関係のような印象
0532デフォルトの名無しさん
垢版 |
2020/10/31(土) 22:34:53.43ID:B0ELcd4k
Haskell のデータ型は再帰を許すからな
どうしても「終端記号(大文字から始まるData constructet) を木構造に並べたもの」という説明をしたいなら無限グラフを使わざるをえない
0535デフォルトの名無しさん
垢版 |
2020/11/01(日) 09:15:58.91ID:v6ASK7zT
>>533
>
> １）foldr (+) 0 [1, 2, 3]
> (+)とカッコがつく理由は？

+ がないと+は中置演算子で
(foldr + 0) [1, 2, 3]
になる
(+)があると普通の関数としてfoldrの因数として解釈される

> ２）map' f = foldr (\x a -> f x : a) []
> xは[]の各要素？aは何？

[]はfoldrの第3因数と同じ型の空集合
a は無名函数(\x a -> f x : a)の第2因数
定義に従ってmap' sin [] [5,6]] はわかりやすく(\x a -> sin x : a)を中置演算子++++で書くと(すなわちx ++++ a = (sin x) : aとすると)

map' sin [] [5,6]
= 5 ++++ ( 6 ++++ [] )
= 5 ++++ ( (sin 6) : [] )
= 5 ++++ [ (sin 6) ]
= [ (sin 5) : [ (sin 6) ]
= [ (sin 5) , (sin 6) ]

となる
0537デフォルトの名無しさん
垢版 |
2020/11/01(日) 10:21:30.53ID:Srz4hpJo
1)
foldr + 0 [1,2,3]
と書いた場合、「+」より関数適用のほうが優先順位が高いので、
foldr + (0 [1,2,3])
と解釈される。
つまり、0という関数を[1,2,3]という引数に適用したものと、foldrを足し算するという意味となる

2)
具体例
map' f [1,2,3] = foldr (\x a -> f x : a) [1,2,3]
3番目の値
(\x a -> f x : a) 3 [] = f 3 : [] = [f 3]
2番目の値
(\x a -> f x : a) 2 [f 3] = f 2 : [f 3] = [f 2, f 3]
1番目の値
(\x a -> f x : a) 1 [f 2, f 3] = f 1 : [f 2, f 3] = [f 1, f 2, f 3]
0538デフォルトの名無しさん
垢版 |
2020/11/01(日) 10:25:40.23ID:Srz4hpJo
おっと、具体例の「foldr (\x a -> f x : a) [1,2,3]」は
「foldr (\x a -> f x : a) [] [1,2,3]」の誤り
0545デフォルトの名無しさん
垢版 |
2020/11/01(日) 15:22:11.82ID:N8AW169o
引数を「ひきすう」と読むのは、同音異義語との混同を避けるための慣用読みだと思ってた
化学（ばけがく）、鼻腔（びくう）みたいな
0546デフォルトの名無しさん
垢版 |
2020/11/01(日) 15:24:45.41ID:BdB3gM+x
返り血
0550デフォルトの名無しさん
垢版 |
2020/11/02(月) 00:43:34.64ID:TnMF05Pn
質問です
このサイトでNum instanceをDerivingする話が出てました

https://qiita.com/HirotoShioi/items/8a6107434337b30ce457

実際このページの次のコードはうちの環境でも通ります
Haskell Online Compiler [ghc-8.4.4]
Copyright (c) The University of Glasgow

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

newtype Quantity = Quantity Int
deriving (Eq, Ord, Num, Show)

a = Quantity 2
b = Quantity 6

totalQuantity :: Quantity
totalQuantity = a + b
-- Quantity 8

しかし次は通りません
通す事はできますか？

import Text.ParserCombinators.Parsec
import Text.Parsec (Parsec)

newtype ParserInt = PI (Parser Int) deriving (Num)
0551デフォルトの名無しさん
垢版 |
2020/11/02(月) 00:43:43.72ID:TnMF05Pn
---- エラーメッセージ
Haskell Online Compiler [ghc-8.4.4]
Copyright (c) The University of Glasgow

Compiling your program...

[1 of 1] Compiling Main ( prog.hs, prog.o )

prog.hs:6:47: error:
• No instance for (Num (Parser Int))
arising from the 'deriving' clause of a data type declaration
Possible fix:
use a standalone 'deriving instance' declaration,
so you can specify the instance context yourself
• When deriving the instance for (Num ParserInt)
|
6 | newtype ParserInt = PI (Parser Int) deriving (Num)
| ^^^
0552デフォルトの名無しさん
垢版 |
2020/11/02(月) 21:44:04.17ID:aBc5dqas
こうすりゃ無理やり通すことはできるけど、
そもそもパーサ同士の足し算等々でどう動いて欲しいのか分からんから
まともなインスタンス宣言が書けん

{-# LANGUAGE FlexibleInstances #-}
instance Num (Parser Int) where
　x + y = x
　x * y = x
　abs x = x
　signum x = x
　negate x = x
　fromInteger n = return 0
0553デフォルトの名無しさん
垢版 |
2020/11/02(月) 23:56:16.57ID:Zq9JUsOb
>>552
元は別スレに出てた問題で
「与えられた文字列の中で“trickと"treat”どっちが先に出てくるか判定せよ」
なんです
とりあえずparserを与える関数として
makeP = mconcat . map ( manyTill anyChar . char )
でできました
コレを例えば"abc"にapplyするとmtl = manyTill、ac=anyCharとして
(mtl ac $ char 'a') <> (mtl ac $ char 'b') <> (mtl ac $ char 'c'>
というparserになりコレにhiajklbcnという文字列をparseするとhijklとabcが出現するするまでに読み飛ばした文字列を返してくれます
それでお題の答えとしてparseの結果を
lastInd x s = case ( runParser ( makeP x ) () "" s ) of
Left _ -> ( [ 2, 0 ] , x )
Right y -> ( [ 0, length $ x ++ y ], x )
のようにしてlengthで数えたんです
しかしちょっと冗長なかんじがします
そもそも読み飛ばした文字列なんか欲しいわけではなく読み飛ばした文字数が欲しいだけだからほんとは
Parser String 型ではなく例えば
length <$> ( manyTill anyChar ( char 'x')
とかのParser Intで十分です
問題はコレをどうやって繋げて総和を返すコンビネータを作ろうかというところなんです
Parser Stringはmonoid型を持ってるのでmconcat一発で繋げられるんですがParser IntはNum持ってないのでsum一発で繋げるというわけにはいかないんです
なんとかできないかと探してみるとなんか「Numをderivingする」という記事を見つけて、お、コレでいけないかと色々やってみたんですがやはりParser Intにderiving一髪でNum入れる方法見つからなくてなんとかならんもんかと
0554デフォルトの名無しさん
垢版 |
2020/11/03(火) 01:59:40.73ID:WdkpFDBO
わざわざNumのインスタンスにしなくても、これでいいのでは
makeP = fmap sum . mapM ( fmap length . manyTill anyChar . char )
0555デフォルトの名無しさん
垢版 |
2020/11/03(火) 10:26:04.44ID:qaG2IpUi
>>554
うん、まぁ別にNumのインスタンス入れなくてもこの問題の話だけならいくらでも方法はあると思うんだけど、そもそもモナドってもこういう時のためにあるんじゃないのかなと思って
例えば(+)なら Num a,Functor f のとき Num (f a)は自然には導出できない、なぜなら fmap (+) は f a -> f ( a - > a ) になってしまう
しかし Applicative f なら lifaA2 (+) がピッタリ f a -> f a -> f a になって自然にキレイに Num (f a) が導出できる
だからすごく理論的には自然なのに方法がないのは何故なんだろうと
というかderiving (...) の (...) にかけるやつとダメなやつの基準がわからない
実用本位でよく使うやつだけ用意されてるに過ぎないのかな？
0556デフォルトの名無しさん
垢版 |
2020/11/03(火) 11:32:34.46ID:WdkpFDBO
一応、Num (f a)は導出できるけど、それで定義した(+)だと
交換則(x + y = y + x)が成り立つ保証がないからじゃないかねぇ
(パーサの順番を入れ替えた場合を考えるとわかりやすい)

{-# LANGUAGE FlexibleInstances #-}
instance (Num a, Applicative f) => Num (f a) where
　x + y = (+) <$> x <*> y
　x * y = (*) <$> x <*> y
　abs x = abs <$> x
　signum x = signum <$> x
　negate x = negate <$> x
　fromInteger n = pure $ fromInteger n
0557デフォルトの名無しさん
垢版 |
2020/11/03(火) 11:50:57.17ID:hn8kPJNe
>>556
なるほど、文法的に通っても意味的に文法には出てこない"Num rule"が補償されないからダメって事なのかな？
まぁ今はclassのメンバ関数の自分が利用するやつだけ定義する必要無くなったみたいだから手で書いてもいいんだけど、>>550の例だと

newtype Eval a = Eval (ReaderT Env (ExceptT String Identity) a)
deriving (Functor, Applicative, Monad, MonadReader Env, MonadError String)

とかはmonad translater越しにできるし

newtype Quantity = Quantity Int
deriving (Eq, Ord, Num, Show)

もできるのになんで Parser (Int) はあかんねんと
なんかプラクマつけたらいけんもんかと
Num くらいならいいけど Floating とかだと惨劇になってしまう
0558デフォルトの名無しさん
垢版 |
2020/11/03(火) 18:12:46.66ID:oSP8TPsC
この話の面白いところは
Parser Intという型を宣言する言語と
そもそも型を宣言しない言語
どっちが生産性高いかってことだよ
0559!id:ignore
垢版 |
2020/11/06(金) 20:16:57.19ID:uZSEyxFl
stackくんさぁ、コンパイラのダウンロードが200MB強あるんだから、低速回線は途中で切断されるとかよくありそうなことじゃん
サスペンド・レジューム機能搭載は必須じゃないのかね
きょうびyoutube-dlでさえ向こうに切断Forbiddenされても今までダウンロードした分は残ってて、再度ダウンロードを開始した際には途中から残りの部分をダウンロードすように始まるってのにさ
仮に205.86 MiB / 205.87 MiBまで来て切断された場合
リトライすると0 MiB / 205.87 MiB からだなんてお互い不幸になると思わないのか？
こっちは成功するまで永遠に繰り返すんだぞ？　むしろそっちの方がそちらにとっても迷惑じゃん
それとも低速回線は死ねっていう差別的思想を持っているのかね？
0561デフォルトの名無しさん
垢版 |
2020/11/08(日) 13:05:47.79
パターンガードの変数の束縛は局所的なのですが、全ての場合で共通して使用してほしい束縛はどうやりますか？
0562デフォルトの名無しさん
垢版 |
2020/11/09(月) 01:15:49.21ID:4MQyK7K1
>>561
質問の意味がよく分からないのだが、コード例を出せる？
こんな風に書けたらいいのに、みたいな。
0563デフォルトの名無しさん
垢版 |
2020/11/09(月) 19:55:38.03
rootsInternal :: Quadratic -> Double -> Roots

rootsInternal q d

　= let

　　　　two_a　　　= 2.0 * (a q)

　　　　realpart　　= - (b q) / two_a

　　　　dside d　　= (sqrt d) / two_a

　　　　dpart　　　= dside d

　　　　complexpart = dside (-d)

　　in if d==0

　　　　then　　　-- Discriminant is zero, (single) root is real

　　　　　　Root $ realpart :+ 0

　　　　else

　　　　if d<0

　　　　then　　　-- Discriminant is negative, roots are complex

　　　　　　Roots (realpart :+ complexpart) (realpart :+ (-complexpart))

　　　　else　　　-- Discriminant is positive, all roots are real

　　　　　　Roots ((realpart + dpart) :+ 0) ((realpart - dpart) :+ 0)


のlet ～ in みたいなのを

rootsInternal q d
　|　d==0　　　= ...
　|　d<0　　　　= ...
　|　otherwise　= ...

みたいな書き方の時にもやりたいんです
0567デフォルトの名無しさん
垢版 |
2020/11/11(水) 19:20:13.76ID:qheOKxfd
正格評価について質問です

ひとつの引数しかない関数 f を正格評価するときには

f $! x

でよいようですが2引数の場合はどうするんですか？

( f $! x ) $! y

で x, y を先に展開してくれますか？
良さげなんですがどう確かめたものやら
なんか正格評価と遅延評価で格段に計算量が変わる f の例ってありますか？
0568デフォルトの名無しさん
垢版 |
2020/11/11(水) 21:38:04.29ID:TR1bVb0l
遅延評価がなくてもGCはメモリ解放を遅らせている
GCをいじるにはIOが必要

$!を使うのにも少なくともモナドが必要と考えるのが自然なのでは？
x' <- return $! x
y' <- return $! y
return $! (f x' y')
0569デフォルトの名無しさん
垢版 |
2020/11/11(水) 22:07:05.86ID:F87BSTFR
>>568
そうなんですか？
とりあえずモナドで試してみます
兎にも角にも正格評価と遅延評価でこんなに計算の回数が違ってくるってのなんかご存知ないですか？
例えばdpの例でFibonacciを

f 0 = 0
f 1 = 1
f n = (f $ n-1) + (f $ n-2)

と

f' 0 = (0,1)
f' n = (a+b,a) where (a,b) = f' (n-1)
f = fst . f'

で比べると目に見えて計算量が違うみたいな奴で「正格評価が効いてる」って目に見えてわかるような例があるとありがたいんですが
0570デフォルトの名無しさん
垢版 |
2020/11/12(木) 14:57:12.09ID:+Y5HOlnE
正格評価と遅延評価で計算量が変わるといえばtaraiじゃね？
0573デフォルトの名無しさん
垢版 |
2020/11/13(金) 12:04:46.50ID:oAmrFI5R
みなさん情報ありがとうございます
今んとこヒマな時にやってみた実現は

cube x = x*x*x

a x = case x of
0 -> 0
1 -> 1
_ -> ( a $ x -1 ) + ( a $ x - 2 )

main = do
tA <- getCPUTime
print $ cube $ a 38
tB <- getCPUTime
print $ tB - tA

と

print $ cube $ a 38 → print $ a 38

の比較
結果
----
59722225363795389930809
3801127096000
----
39088169
3514055718000

この程度だとコンパイラが勝手にメモ化してくれるようで差がでないorz
まだタライとかは試して見てません
取り急ぎご報告まで
0574デフォルトの名無しさん
垢版 |
2020/11/16(月) 23:33:39.07ID:bCg5e61i
>>567
もうとっくに解決したかもしれませんが、評価の順は trace 関数でも確認できます。

import Debug.Trace

g :: Int -> Int -> Int
g x y = trace ("g") (x + y)

main :: IO ()
main = do
let a = trace ("a") 1
let b = trace ("b") 2
let c = (g $! a) $! b
putStrLn $ show c

これを実行すれば、b a g 3 の順に出力されます。
正格評価されていると言えます。

ちなみに、($!) を ($) に変えれば、g a b 3 の順に出力されます。
0576デフォルトの名無しさん
垢版 |
2020/11/21(土) 23:31:14.57ID:ak7brOTq
Haskellはライブラリの中身を覗くと
Template Haskellを駆使した
グッチャグチャの実質別言語みたいなコードがザラなのがなぁ・・・
水面下の白鳥状態じゃねーか
0578デフォルトの名無しさん
垢版 |
2020/11/22(日) 17:19:45.03ID:MRtbpg3I
在学中か学校出たての経験浅い奴しか担い手がいないのだろうからそんなもんなんだろう

純粋関数型言語は学生がかかるはしかみたいなもので
やがて計算機科学の現状に絶望し去ってゆく
現在のコンピューターは手続き型に最適化されているのだ
0581デフォルトの名無しさん
垢版 |
2020/11/23(月) 02:58:53.25ID:v8DPq2Nr
イヤ、まぁ純粋に速度とか効率とか考えたら手続き型言語の方が優位なのはその通りでしょ？
だって現在の計算機がノイマン型の手続き型の処理をするために設計されてるんだから
そりゃバリバリにチューニングしたら手続き型言語には絶対勝てない
その時代時代の最新の計算機の性能をフル活用しないとできないような処理は当面関数型言語の出番は回ってこない
しかしそこまでの処理でないならやはり関数型言語の活躍できる場面も出てはくるだろうけど、しかし例えそうなったとしても手続き型言語も関数型言語も両方臨機応変に使いこなせるようになるとなると中々難しいから、結局どちらか選ぶなら手続き型言語という事になってしまう
しばらくは関数型言語が実務の場面でバリバリ使われるようになるのは中々難しい
当面研究者とか、サンデープログラマーの趣味の世界でしか出番ないかもしれない
0584デフォルトの名無しさん
垢版 |
2020/11/23(月) 12:02:25.91ID:B9DSaA3p
居飛車と振り飛車というのは危機感が足りない
ガソリン車と電気自動車だ
個人の就職じゃなくて会社が丸ごと潰れるリスクを想定するための研究だよ
0588デフォルトの名無しさん
垢版 |
2020/11/23(月) 14:40:17.74ID:B9DSaA3p
新しいなんて嘘つくより古いものは古いものとして扱う歴史や古文の方が正しい
0590デフォルトの名無しさん
垢版 |
2020/11/23(月) 21:33:53.00ID:B9DSaA3p
みんなが数学好きで自己啓発嫌いなのは処理速度じゃなくて
嘘をつかないかどうかの問題
0593デフォルトの名無しさん
垢版 |
2020/11/24(火) 21:00:48.17ID:BgPUrN9t
速度は実はそこまで重要じゃない
飛行機からメンテナンスハッチ取り除いて何kg軽量化しましたって言ったところで、仕事好き定量評価好きなにわかが、わかりやすい数字見て喜ぶだけで、実際はそんな嬉しい話じゃない
というかそもそももっと遅いスクリプト言語は流行ってるし
0595デフォルトの名無しさん
垢版 |
2020/11/24(火) 21:44:37.33ID:2dUwtFIm
>>594
死滅の意味がよく分からんが、問題なく使える。
stackageにもあるでしょ。

それはそうと、なんで初めから難しいFRPを使おうとするの？
普通に素直に設計して作ってみればいいのに。
0599デフォルトの名無しさん
垢版 |
2020/12/02(水) 00:25:53.39ID:E6FeESB6
ここで聞いていいのかわからないけど…
Nixのいいチュートリアルとかってある？
0601デフォルトの名無しさん
垢版 |
2020/12/05(土) 12:39:37.62ID:Na39OKS5
ブログ書いてたら彼女と無料で海外留学という名のデートに行けた話【影響力やばい】
https://www.youtube.com/watch?v=Y8Q1z3Mi7BQ
若いうちから人を雇ったり、任せるクセをつけるべき理由とは？
https://www.youtube.com/watch?v=6yAvDQxhldI
【対談】インフルエンサーマーケティングに300万円突っ込んでみた結果...
https://www.youtube.com/watch?v=AMjWD0F8PLQ
収入を上げたければ、自分の影分身を作るべし
https://www.youtube.com/watch?v=V3Kc-lUxH88
勉強のために10日間で21個のアプリを作った話【初心者時のプログラミング学習】
https://www.youtube.com/watch?v=JkN5kmR9dgk
学校では教えてくれないことの中にはお宝が眠っている
https://www.youtube.com/watch?v=oq92u9nJ7FY
ブロガーからステップアップしていくために必要なスキル
https://www.youtube.com/watch?v=F6qsOyRIaQE
0602デフォルトの名無しさん
垢版 |
2020/12/05(土) 23:01:31.80ID:gIoCKCst
>>600
すごい良さげ。ありがとう
0605デフォルトの名無しさん
垢版 |
2020/12/08(火) 09:15:41.98ID:VKXi32Vk
実際にちょっとしたプログラム書いてみると
メモリ周りの最適化が困難なんだよなこの言語。

しかも最適化の方向性がアルゴリズムの改良ではなく
言語特有のボトルネックの回避がメインになるから
コードを見ても最適化の意図が分かりにくくて
一見無駄に冗長に記述してるだけに見えるコードが出来上がる。
0606デフォルトの名無しさん
垢版 |
2020/12/08(火) 11:08:46.52ID:EAPrHNYX
最適化の意図なんてPythonと同じでいい
ライブラリは全部Cで書いてmainだけHaskellで書け
0607デフォルトの名無しさん
垢版 |
2020/12/08(火) 12:02:52.73ID:mZ7rlOd+
一時期あんなにモナドの記事とか書かれまくったのに、最近盛り上がりに欠ける
Haskell製アプリも企業が採用したって話もほとんど聞かないけど、気のせい？
尖ったところで使われてるんかな
0608デフォルトの名無しさん
垢版 |
2020/12/08(火) 13:07:23.14ID:EAPrHNYX
言語関係なく企業が作ったアプリを買ったことがほとんどない
個人が書いた本を買うことはある
0609デフォルトの名無しさん
垢版 |
2020/12/08(火) 13:30:45.48ID:xvXTXIvz
まぁなんだかんだHaskellは実用性というより、やはり数学研究の一貫の色合いが強いからなぁ
0612デフォルトの名無しさん
垢版 |
2020/12/09(水) 01:52:25.38ID:6n7tUtuW
Haskell自体は面白くて本や記事も読むけど、なんか書く気起きないんだよな
でも他の言語で関数型由来の機能が追加されたときに「あ、これHaskellでやったところだ！」ってなれる
0613デフォルトの名無しさん
垢版 |
2020/12/17(木) 17:53:27.84ID:9eI2x+Uu
Haskellでx = x + 1をIORef使わず擬似的に再現。
(実際には代入では無く、結果をラムダ式の同名の変数に渡してるだけ)

main = do let x = 0
print x
x <- inc x
print x
x <- inc x
print x

inc n = return (n + 1)

モナド式の書き方だとこうなる。

main = do let x = 0 in print x >> inc x >>= \x -> print x >> inc x >>= \x -> print x

inc n = return (n + 1)

さらに>>=演算子を()で囲んで関数にするとこうなる。

main = (>>=) ((>>=) (do let x = 0 in print x >> inc x) (\x -> print x >> inc x)) (\x -> print x)

inc n = return (n + 1)
0614デフォルトの名無しさん
垢版 |
2020/12/17(木) 17:53:45.49ID:9eI2x+Uu
モナド無しだけど、Cで再現するとこんな感じ。(スタック消費するけど)

#include <stdio.h>

int inc(const int);
int f(const int);

int main(void)
{
const int x = 0;
printf("%d\n",f(f(x)));
return 0;
}

int inc(const int x)
{
return (x + 1);
}

int f(const int x)
{
printf("%d\n",x);
return inc(x);
}
0615デフォルトの名無しさん
垢版 |
2020/12/18(金) 19:59:30.35ID:PXMujPNr
目的が実用だろうが研究だろうがIORefは使っていいぞ
IORefは手段なので、具体的な目的に依存しない
0616デフォルトの名無しさん
垢版 |
2020/12/19(土) 08:53:57.33ID:56QZYgov
気持ちはよくわかる。自分も初めてdo式の定義を見た時、おぉぉぉとなった。
というわけで、いつdo式パラダイスが登場したのかアヒル体験してみた。
[When was do-notation introduced?](https://www.reddit.com/r/haskell/comments/8rkrgq/)

> Haskell 1.3 adopted Jones’s “do-notation,” which was itself derived
from John Launchbury’s paper on lazy imperative programming (Launchbury, 1993).

自分の場合、Haskellを知る前に、Moggi大先生の論文体験を一撃で敗退した時に
おぉぉぉした覚えがある。

* Notions of computation and monads
in [Eugenio Moggi Publications](https://person.dibris.unige.it/moggi-eugenio/publications.html)

宗教上の理由で、シーケント図が書かれた書物体験はできないが、幸いなことに、
最初のシーケント図にdo式らしきものが書いてある。ナウなヤングの言葉では
次のようになると思う。

``` haskell
kleisli_extension :: (Monad t) => (a -> t b) -> (t a -> t b)
kleisli_extension f c = do
x <- c
f x
```

今も論文に何が書かれているかわからないが、その時は、<em>おぉぉぉ、
プログラミング言語って数学的に捉えられるんだ</em>体験をした記憶がある。
一般に、紙上のプログラミング言語と実働するものとの間には万物の長城が
あるので、Haskellのdo式もすごい発明と思うが、その技法の骨子は、既に
[同時多発的](https://www.youtube.com/watch?v=FMmCJ6-uu3M)に発見されて
いたのかもしれない。歴史絵巻体験では、
[A History of Haskell](https://misreading.chat/2020/10/27/)も面白かった。
0617デフォルトの名無しさん
垢版 |
2020/12/20(日) 18:18:16.88ID:FMam64CT
ネタを拝借して、次のコードを考える。

``` haskell
inc :: (Applicative f) => Int -> f Int
inc n = pure (n + 1)

lhs :: (Int -> () -> String) -> Int -> IO String
lhs dump x = do
y <- inc x
z <- print y
pure $ dump y z

rhs :: (Int -> () -> String) -> Int -> IO String
rhs dump x = inc x >>= \y -> dump y <$> print y

lhs ((.) show . (,)) 123 >>= print
rhs ((.) show . (,)) 123 >>= print

lhs (const . const "hello") 123 >>= print
rhs (const . const "hello") 123 >>= print
```
0618デフォルトの名無しさん
垢版 |
2020/12/20(日) 18:18:58.94ID:FMam64CT
IOモナドを恒等モナドに差し替えて、Rに移植する。

``` {r raskell}
do = pure = id = function (a) a;
const = function (a) function (ab) a;
`%.%` = function (bc, ab) function (a) bc (ab (a));
`%$%` = function (ab, a) ab (a);
`%>>%` = function (a, ab) ab (a);

inc = function (n) n + 1;
caty = function (a) cat (a, "\n", sep = "");

lhs = function (dump) function (x) do ({
y <- inc (x);
z <- caty (y);
pure %$% dump (y) (z);
});

rhs = function (dump) function (x) {
inc (x) %>>% (function (y) dump (y) %$% caty (y));
};

lhs (function (y) function (z) list (y, z)) (123) %>>% print
rhs (function (y) function (z) list (y, z)) (123) %>>% print

lhs (const %.% const ("hello")) (123) %>>% print;
rhs (const %.% const ("hello")) (123) %>>% print;
```

Rは関数の引数を問答無用に遅延評価するので、最後の`rhs`だけがHaskellと
異なる動作をする。Rの遅延評価の例としては煩雑過ぎるが、HaskellのIOモナド
とサイドバイサイドに比較できる例になっている。
0619デフォルトの名無しさん
垢版 |
2021/01/05(火) 09:39:14.86ID:b/Fw/Z0P
ふと思った。

a型の2次元配列が必要になった時、
[[a]] や Array (Int, Int) a ではなく、
(Int, Int) -> a が真っ先に思い浮かぶなら、
そいつは関数型にどっぷりハマってるな、と。
0620デフォルトの名無しさん
垢版 |
2021/01/08(金) 14:54:16.81ID:QDat+Qoy
関数型は並列処理に強いという話を聞くけど
fpgaの高位合成がC言語で行われている理由は何ですか？

haskellでの高位合成やgpgpuはどうなっていますか？
実用されていますか？
0622デフォルトの名無しさん
垢版 |
2021/01/08(金) 15:22:31.00ID:QDat+Qoy
Haskellはアカデミックな言語だっていうけど
アカデミックな人がやることが多い機械学習でPythonが伸びた
並列処理に強いなら機械学習の行列処理がHaskellで行われても良かったんじゃないの？
0623デフォルトの名無しさん
垢版 |
2021/01/08(金) 18:33:26.91ID:rDTYcDTI
Haskellは並行並列を楽に書けるのであって速く書くのに向いているわけではない（滅茶苦茶向いていない訳でもないがハードウェアに近い組には速度で勝つのは大変）
そしてDNNは内部処理がテンソル演算でこそあるけどインターフェイスでそこまでむき出しのテンソル演算をするのは多くない

なによりアカデミックは一枚岩ではなく当然色々幅が広くて
Haskellがアカデミックと呼ばれる所以は言語処理系や型理論、その実装の分野
並行並列が楽に書けるってのはその流れからくる、関数の純粋性とソフトウェアトランザクショナルメモリの成果
機械学習系の源流になる内の画像処理系ではC++やmatlabが、統計系はRやmatlabが使われててnumpyと共に徐々にPythonに移行してきた
ちょっと下のレイヤーのBLASやシミュレーションではC++とFortran、後にGPGPUの独擅場で今ではPythonから呼ばれる形で使われてる訳だ
0624デフォルトの名無しさん
垢版 |
2021/01/09(土) 00:06:52.64ID:cFb9Tw8T
機械学習はどっぷり工学分野だからアカデミックという印象は少ないイメージあるが
0625デフォルトの名無しさん
垢版 |
2021/01/09(土) 16:47:47.44ID:gjIQ6YZR
haskellについて調べてるんだけど
関数の合成は関数Aの返値と関数Bの引数の型が一致するとかの条件が必要？
解説記事に「関数はファンクタです」とか書かれてるんだけど
任意の関数を合成できるわけじゃないよね？
0626デフォルトの名無しさん
垢版 |
2021/01/09(土) 17:24:37.63ID:Xoihvk5Y
>>625
関数合成のシグネチャを見れば分かる
(.) :: (b -> c) -> (a -> b) -> a -> c
"bからcへの関数"と"aからbへの関数"を受け取り、"aからcへの関数"を返す関数が関数合成
0627デフォルトの名無しさん
垢版 |
2021/01/10(日) 13:23:32.27ID:/oGn2fPm
・Functorは高階カインドのクラスです
・二変数の型構築子(->)を部分適用したものがFunctorのインスタンスになります
この説明を省略したら意味がわからないよね
0629デフォルトの名無しさん
垢版 |
2021/01/11(月) 11:54:49.85ID:TrSsUTEh
>>625
関数合成可能性の話と関数が関手であることは全く関係ないぞ
0630デフォルトの名無しさん
垢版 |
2021/01/11(月) 13:43:32.73ID:nJc/cTVc
Haskell　　　　圏論
=====================
関数　　　　　　射
Functor　　　　関手
Reader r 　　　Hom関手
0631デフォルトの名無しさん
垢版 |
2021/01/11(月) 16:14:02.10ID:nJc/cTVc
H本終えたくらいの初心者が、中級上級それ以上を目指すためのロードマップって大体こんな感じ？
わたしは全部マスターしたわけじゃなくて、界隈でよく聞くのでなんか重要そうくらいのノリw

中級
・Freeモナド
・Profunctor optics
・コモナド
・Custom Prelude

上級
・型レベルプログラミング
・Extensible Effects
・Indexed Monads
・Template Haskell
0632デフォルトの名無しさん
垢版 |
2021/01/11(月) 23:19:18.98ID:N3ahWSVP
まず何より先にアプリ作ろうよ。
先人たちはアプリを作りまくる過程で、
役立つテクニックや概念を編み出してきたのだから。
0634デフォルトの名無しさん
垢版 |
2021/01/12(火) 01:04:23.78ID:exO7rD20
>>632
ここでの問題はHaskellの鉄人になるためのロードマップであって、
Haskellでアプリを作れるようになるためのロードマップではない
0637デフォルトの名無しさん
垢版 |
2021/01/12(火) 10:08:30.41ID:fccMRI32
何かを生まなければならないというのは道徳か？
その道徳から全てが始まるのか
0640デフォルトの名無しさん
垢版 |
2021/01/13(水) 10:21:18.95ID:8kUJEegp
Haskell でカッコよく速いプログラム書きたいんですが、どう言う分野が向いてますか？
0643デフォルトの名無しさん
垢版 |
2021/01/14(木) 00:13:44.79ID:JY+VfWVO
でも先入観のメリットはスピードだから
速度の最適化みたいな建前を用意すれば知性と知性の対等な関係にはなる

建前はキモいとか本音がカッコイイとか言い出さない限り
0646デフォルトの名無しさん
垢版 |
2021/01/14(木) 10:42:33.32ID:ApYxPV7C
音やリズムをデザインしてるのか
音読できない言文不一致言語があれば、デザインと論理的構造を分離できそう
0648デフォルトの名無しさん
垢版 |
2021/01/15(金) 10:43:33.32ID:l3Q+U92p
関数型を信じるというよりオブジェクト指向を疑うべき
オブジェクト間の通信がただの関数呼び出しから軽量スレッドに変わったらどうなるか等
0650デフォルトの名無しさん
垢版 |
2021/01/16(土) 10:01:48.97ID:fPN57ROF
fix関数は least-defined な不動点を見つけるそうだけど、
この least-defined ってどういう意味？
0652デフォルトの名無しさん
垢版 |
2021/01/20(水) 07:45:01.78ID:0A31ygkk
多分できないんだろうなと思いつつ質問です
あるページで乱数をいっぱい調達する方法でこんなのありました

randIntsList = let
getOne rec = ( return . ( : rec ) )
=<< ( randomIO :: IO Int )
in iterate ( >>= getOne ) ( return [ ] )

main = do
a <- ( return . head ) =<< randIntsList !! 100
print a

コレはもちろんうまく行きました
でもコレちょっと不愉快です
IO [ Int ] とかで例えば

randInts :: IO [ Int ]
randInts = do
hd <- ( randomIO :: IO Int )
tl <- randInts
return $ hd : tl

main = do
a <- ( return . head ) =<< randInts
print a

とかであらかじめ使う数を指定しないで好きなだけとってくるとかできないもんでしょうか？
上のはGHCで参照すると実行時エラー出ます
0653デフォルトの名無しさん
垢版 |
2021/01/20(水) 14:24:39.71ID:7SUaJKsz
ついさっき関数的プログラミングの話題してたが
やっぱり通じないな

関数？そりゃ関数くらい普通に書くよねw
副作用？必要なら出ないように書けばいいんじゃないの？どうでもよくない？
純粋関数の考え方？そんなのいらないよねw
部分適用？今までそんなの必要になったことないなあw そんなの何に使うんだ？

まあ言われてみれば誰にでもわかるような利点を提示できないってのは確かにあるが・・
利点がないなら好みの範囲で片付けられちゃったな
0655デフォルトの名無しさん
垢版 |
2021/01/20(水) 16:39:30.61ID:IzsyJlfZ
>>652
これでどうかな？
randInts2 :: [IO Int]
randInts2 =
iterate ( >>= const (randomIO :: IO Int) ) (randomIO :: IO Int)
main :: IO ()
main = do
a <- head randInts2
print a
0656デフォルトの名無しさん
垢版 |
2021/01/20(水) 17:07:44.96ID:aAR5bcpB
>>653
いわれてみればhaskell触るまでこういう特徴が泣くほどうれしいなんて思ってなかったなぁ……
0657デフォルトの名無しさん
垢版 |
2021/01/20(水) 17:39:40.94ID:kKr2IDUq
>>653
利点を提示っていうかLispとHaskellの違いを提示する必要がある
Lispの利点を再現するだけならPythonで十分な気がする

しかしHaskellを再現できるものがまだ出てこない
それは関数型じゃなくて静的型の説明をしないと意味が分からないと思うけど
0658デフォルトの名無しさん
垢版 |
2021/01/20(水) 18:38:17.88ID:apYLuAz7
>>655
ありがとうございます
そうなんです
今のところそれしか解決策ないんです
しかし希望では IO [ Int ] であって欲しいんです
イメージとしてはこうです
ある関数 f があって乱数で挙動が変わって欲しい
もちろん最終的にはIOモナドを使わないとしょうがない
しかし色々いじってる段階ではモナド被せないで代わりに擬似乱数無限配列 psuedRand :: [ Int ] みたいなのを食わせて

f a b c psuedRand

みたいに呼び出して色々頑張って、最後の最後にIOモナドで実地に

　( return . f a b c ) =<< realRand

に切り替えるみたいな事ができないかなと思ったんです
f が使用する乱数がある程度わかるので別に無限列でなくてもいいっちゃいいんですけど
今一歩モナドに包まれてる関数いっぱい出てくるの好きじゃないんですよ
通のホムペとか見てるとむしろバンバンモナドでくるんどいた方がいいみたいなのもみるんですけどねぇ
0661デフォルトの名無しさん
垢版 |
2021/01/20(水) 20:02:19.54ID:kKr2IDUq
headやtailの戻り値の型はIOではないって宣言してるから
リスト処理中にrandomIOができなかったとしても不思議ではない
型を宣言するってそういうことよ
0662デフォルトの名無しさん
垢版 |
2021/01/20(水) 21:15:09.40ID:jArj32vs
>>658
やりたい事の本質がいまいち分かりません。
2点確認します。

ひとつめ。
結局のところ今は [a] 型の乱数を返す関数を作りたいのでしょうか。
それとも、IO [a] 型の乱数を返す関数を作りたいのでしょうか。
はたまた、両方でしょうか。

ふたつめ。
開発環境では
> f a b c psuedRand

本番環境では
> 　( return . f a b c ) =<< realRand

という事でしょうか。
前者は純粋関数の式、後者は IO モナドを伴う式です。
これは、本番環境で IO モナドな関数を、開発環境では純粋関数で開発するという事ですよね。
開発環境を本番環境にする際には、後者の式を呼び出している外側の関数も、
純粋関数から IO モナドに書き換えるのでしょうか。
あまりお勧めしません。
本番環境で IO モナドな関数は、開発時も IO モナドで開発&テストした方が良いと思います。
環境が違ってもインターフェース(型シグネチャ)はそろえた方が良いです。
事情がおありなので、あくまで私は勧めないというだけですけど。
0663デフォルトの名無しさん
垢版 |
2021/01/20(水) 21:21:29.93ID:apYLuAz7
>>661
まぁそうですね
できんもんはできんのでしょうね
ただ出来るか出来ないかの判定がまだまだ自分の実力不足でできないのか、実際禁止されててできないかのか判断がつかないんです

>>662
やはりそうなんでしょうね
まだまだ初心者でいまひとつモナドで包まれてるの馴染みがないので避けれるなら避けたいと思ってしまいます
この場合はモナドで最終的にくるむなら避けられても避けるべきではないのでしょうね
0664デフォルトの名無しさん
垢版 |
2021/01/20(水) 21:52:28.04ID:kKr2IDUq
>>663
型を書かない言語も普通に存在するので、型を無視する方法があってもそれも不思議ではない
0666デフォルトの名無しさん
垢版 |
2021/01/21(木) 00:38:31.39ID:HkuQh/W6
>>653
副作用とか純粋関数の話は単体テストの話題と絡めたいね
それが通じなかったら知らん
部分適用というか高階関数の話は
コールバックとかイテレータのような「処理の抽象化」が
極めて書きやすくなるというような話でどうか
0667デフォルトの名無しさん
垢版 |
2021/01/21(木) 06:01:52.78ID:mwzMDOkA
Haskellで厳しく性能を最適化しようとすると
抽象的なところで実装を意識したコードを書くことになって苦労する
みたいなレビューがあった

Haskellはベンチ結果良いように見えて
その手の「実装を意識したコード」がベンチ用に書かれるからで
実際は割と遅めなんだな
0669デフォルトの名無しさん
垢版 |
2021/01/21(木) 06:30:57.22ID:mwzMDOkA
https://stackoverflow.com/questions/35027952/why-is-haskell-ghc-so-darn-fast
この辺
> thanks for the link.
80 lines is what I called "low-level style of programming not much different than
programming in C itself." . "the higher level code",
that would be the "stupid" fmap (length &&& length .
words &&& length . lines) readFile.
If that was faster than (or even comparable to) C,
the hype here would be totally justified then.
We still need to work hard for speed in Haskell as in C, is the point.

>>605もそんなことをかいてる
0670デフォルトの名無しさん
垢版 |
2021/01/21(木) 06:38:11.58ID:mwzMDOkA
以下の厳密というのは遅延評価じゃなくするという事だろう？
しかも「プロファイルを作成して改善」は一度アプリを書いてから実行の様子を観察して最適化していくという事だろう。
抽象的にHaskellらしく書いていきなり速いというわけではないという事だ。
プロファイラーでボトルネックを特定して特殊なコードに変えていけば速くなる、と。

＞はい、怠惰はおそらくナイーブなHaskellが遅い最大の理由であり、
最適化されたHaskellでさえ速度の点で信頼できない可能性があります。
そのため、パフォーマンスが重要なアプリケーションにはお勧めしません。
OCamlの方が適しています。繰り返しになりますが、
HaskellをBangPatternsなどで厳密にすることはそれほど難しくありません。
また、コードの読み取りや保守が難しくなることもありません。
したがって、パフォーマンスが望ましいが、遅いプロトタイプでも問題がない場合は、
Haskellが非常に良い選択です。うまく機能するものを一緒にハックしてから、
プロファイルを作成して改善します。
0671デフォルトの名無しさん
垢版 |
2021/01/21(木) 08:18:51.22ID:mwzMDOkA
こういう認識
・Haskellはコードだけでは最適化ポイントを見つけれない
・最適化したら変なコードになる
・普通のHaskellコードはベンチで他言語に惨敗する
0672デフォルトの名無しさん
垢版 |
2021/01/21(木) 09:21:08.07ID:mwzMDOkA
これも
・最適化の方法が処理系（GHC)次第で決まり、プログラマーの認識内に無い。
GHCに対してひたすらトライアンドエラー
0674デフォルトの名無しさん
垢版 |
2021/01/22(金) 00:20:12.86ID:IysdrbOG
HaskellとPythonは似ていないから両方使ってもDRYに違反しない

似たもの同士で馴れ合い、異質なもの同士を分断するやつは信用できないが
Pythonは似たもの同士でしっかり競争して生き残ったやつだから信用できる
0675デフォルトの名無しさん
垢版 |
2021/01/22(金) 01:34:45.31ID:Zh6FWeVu
pythonがなかったとしてもhaskellがそのポジションになることはなかっただろう
0676デフォルトの名無しさん
垢版 |
2021/01/22(金) 02:27:11.57ID:XLcorGPG
欲しかったHaskell
・型を最大限に活用、バグが無いことを保証しつつ自然にC言語並みの性能も出る
0678デフォルトの名無しさん
垢版 |
2021/01/22(金) 12:35:37.28ID:Erx3tlcS
醜悪な表現が得意な奴って、綺麗な表現だとポエムとか言われる恐怖を煽られた結果なのかなと
ふと思った
0679デフォルトの名無しさん
垢版 |
2021/01/23(土) 13:17:02.46ID:u7XOzuV6
>>665
ListT を使えばと思ったけどだめだった。
・参考
https://blog.mudatobunka.org/entry/2018/01/03/233314
・残骸
module Rand2 where

-- stack install list-t
-- stack exec ghci

import Control.Monad.IO.Class ( liftIO )
import ListT ( ListT, toList )
import System.Random ( Random(randomIO, randomRIO) )

t1 :: ListT IO Int
t1 = return 3

t2 :: ListT IO Int
t2 = liftIO (randomIO :: IO Int)

t3 :: ListT IO [Int]
t3 = repeat <$> t2

output :: ListT IO [Int] -> IO ()
output t3 = do
li0 <- toList t3
print $ take 10 $ head li0
0680デフォルトの名無しさん
垢版 |
2021/01/23(土) 22:12:27.68ID:u7XOzuV6
>>679
できたー！
module Rand2 where

-- stack install list-t
-- stack exec ghci

import Control.Monad.IO.Class ( liftIO )
import ListT ( ListT, toList, cons, take )
import System.Random ( Random(randomIO) )

t2 :: ListT IO Int
t2 = liftIO (randomIO :: IO Int)

t3 :: ListT IO Int
t3 = do
x <- t2
cons x t3

output :: IO ()
output = do
li <- toList $ ListT.take 10 t3
print li

{-
*Rand2> output
[7616927328998369033,6970782903781268443,-1509938769401207081,-2789264750098693865,-6524417077297424569,8403979199680420436,-3097298192134792937,-2736699795503652525,-4754186463647322678,5658901448509988002]
-}
0681デフォルトの名無しさん
垢版 |
2021/01/24(日) 10:57:12.77ID:EEhZoft7
自分の理解が根本的に間違ってるかもしれんけど
haskellは宣言型で実効順序が定まっていないみたいな話を聞いたんだけど
do記法は普通に上から下に実行されるというイメージになるの？

main = do
x <- readLn
x2 <- readLn

こういう風に書いた場合、最初に入力したものがxに入り、その順番は入れ替えれないはず
do記法はほとんど命令型じゃないの？

IOモナドとかに入力されていくアクション列はその順番を入れ替えれないよね？
どんな感じでコーディングされてるか知らないけど
副作用があるところでは順番を入れ替えれないはず、即ち命令型と大差ないはず
0682デフォルトの名無しさん
垢版 |
2021/01/24(日) 12:14:30.84ID:3w4a632B
>>680
おお、できるんですか！？
すげー
残念ながらいまListT使えないので環境整理してやってみます
0683デフォルトの名無しさん
垢版 |
2021/01/24(日) 13:21:27.07ID:vsDmG4Mq
>>681
do記法という言語機能は、上から下への命令の実行を記述するものではない
モナドの組み合わせ方を宣言しているだけ
IOのようなモナドの定義に対してはたまたま命令型言語のようになるだけ
言語レベルで命令を上から下へ実行しているわけではない
0684デフォルトの名無しさん
垢版 |
2021/01/24(日) 15:49:32.04ID:EEhZoft7
じゃあ標準入力から来た文字列の1行目と2行目を分けて扱うにはどう書くの？
0685デフォルトの名無しさん
垢版 |
2021/01/24(日) 16:19:42.60ID:QSDOehpN
ListT.toListの引数には有限のリストしか渡せないんだろう多分
現に
li <- toList t3
print (take 10 li)
ではなく
li <- toList $ ListT.take 10 t3
print li
と書いてある
0686デフォルトの名無しさん
垢版 |
2021/01/24(日) 16:51:40.79ID:o8L11MsB
>>685
> ListT.toListの引数には有限のリストしか渡せないんだろう多分
> 現に
> li <- toList t3
> print (take 10 li)
> ではなく
> li <- toList $ ListT.take 10 t3
> print li
> と書いてある

確認したところ、おっしゃる通り、
前者では応答が返ってきませんでした。
（ListT.repeat でも同じ結果だったので、t3 が悪いのではないです）

> ListT.toListの引数には有限のリストしか渡せないんだろう多分
これで合っていると思います。
0687デフォルトの名無しさん
垢版 |
2021/01/24(日) 23:50:31.64ID:3w4a632B
やっぱり無理なんですかねぇ？
例えば以下は通るので ”IO 無限リスト” が原理的に無理なわけではないとは思うんですけど

list = return $ repeat '3'

main = do
x <- list
print $ take 10 x

何がどう違うもんなんでしょう？
0688デフォルトの名無しさん
垢版 |
2021/01/25(月) 09:17:23.58ID:xOoQiCMv
すいません
無限ランダム整数列の件ですが方法がありました
というかSystem.Randomの中に最初から用意されてました
自作でランダム有限列作っておられた方のブログ見つけたので無限列なんて用意されてないとすっかり思い込んでました
以下の方法で1～10の長さ100の乱数列が簡単に作れるようです
第一引数に値の範囲、第二引数に乱数の種を仕込みます
乱数の種は
mkStdGen :: Int -> StdGen
や
getStdGen :: IO StdGen
newStdGen :: IO StdGenSource
で作成すれば良いようです
乱数の型はIntだけでなくDoubleなどでも作れるようです

----
import System.Random

randomInts :: StdGen -> [ Int ]
randomInts = randomRs (1,10)

main = do
ris <- ( return . randomInts ) =<< getStdGen
print $ take 100 ris
0693デフォルトの名無しさん
垢版 |
2021/01/27(水) 00:16:50.20ID:UiZI3fhW
dp の質問です
haskell でdynamic programing する方法の例でFibonacci数列の計算を

fib = 0:1:( zipWith ( + ) ( drop 0 fib ) ( drop 1 fib ) )

で計算させるというテクニックを紹介しているページがあってなるほどなぁと感心しました
で同じテクニック使ってcomb6 !!i !! jが二項係数C[i, j]になる配列

comb6 = ( ( 1 : ( repeat 0 ) ) : )
$ zipWith ( zipWith ( + ) ) comb6 ( map ( 0 : ) comb6 )

を作ってみました
コレはうまくいきます
comb6 !! 2000 !! 1000
とかも一瞬で計算してくれます
でcomb7 !! i !! j が二項係数C[ i+ j, i ]となる配列comb7を

comb7 = ( ( repeat 1 ) : )
$ zipWith ( zipWith ( + ) )
( comb7 )
( tail $ map ( 1 : ) $ comb7 )

と定義してやってみると、compileまでは通るのですが実行comb!!1!!0すると<<loop>>と言われて止まってしまいます
しかし手計算で展開してみてもloopしてないと思うんですけどどこがおかしいのかわかりません
どなたかわかりませんでしょうか？
0694デフォルトの名無しさん
垢版 |
2021/01/27(水) 11:32:01.04ID:fGEABlaN
comb7 = x : xs
xs = zipWith f comb7 ys
ys = tail zs
zs = map g comb7
zs = map g (x : xs)
= g x : map g xs
ys = tail (g x : map g xs)
= map g xs
xs = zipWith f comb7 (map g xs) -- ここで(map g xs)のパターンマッチができない
0695デフォルトの名無しさん
垢版 |
2021/01/27(水) 12:36:29.90ID:UiZI3fhW
>>694
ありがとうございます
しかしどうもパターンマッチに失敗してるようではないようです
実際コンパイラは型推論に成功してるように見えますし、明示的に
comb7 :: [[ Int ]]
を入れてもダメです
実行時のエラーメッセージも
Non-exhaustive patterns
ではなく
prog : << loop >>
が表示されています
0696デフォルトの名無しさん
垢版 |
2021/01/27(水) 13:52:31.92ID:fGEABlaN
こういう時は自分の考えに自信を持つことも必要
誰かがエラーメッセージを見ている（または見ていない）のを見たからといって簡単に考えを変えない方がいい
0697デフォルトの名無しさん
垢版 |
2021/02/02(火) 01:48:19.32ID:yyMOWUoH
fixの定義は fix f = let x = f x in x となっていますが、
この x 自体は再帰的に定義されていると言えますか？
0698デフォルトの名無しさん
垢版 |
2021/02/02(火) 16:19:31.38ID:ErrealWs
>>693
xs0 = repeat 1
xs1 = zipWith (+) xs0 (0:xs1)
xs2 = zipWith (+) xs1 (0:xs2)
xs3 = zipWith (+) xs2 (0:xs3)

こんな感じに個別に定義すれば確かに計算できるので、
comb7 !! 1 を計算するのにcomb7 !! 1 が必要だぞという点を
怒っているような気がするのだが確かなことは言えない、すまぬ

comb6 !! n は計算するのに comb !! (n-1) の情報だけで十分なところが違うので
0699デフォルトの名無しさん
垢版 |
2021/02/02(火) 17:58:42.89ID:AZLuBdJH
>>697
再帰的と言うのは木構造を想定している気がする
そのコードはグラフ簡約のためにそうなったので木構造でも再帰的でもないと思う
0700デフォルトの名無しさん
垢版 |
2021/02/02(火) 22:40:39.64ID:LQ6cge6d
>>698
ありがとうございます
私も多分それが原因かなと思い始めてます
一回目のcomb7 !! 1 と二回目では続く添字が! !!2 から !!1 に減ってるのですがHaskellはそんな事は勘案せずに「comb7 !! 1の展開の中にcomb7 !! 1が出てきたからアウト」と言ってるのかなと
つまりはこの手の二重漸化式はHaskellはそのままズバリでは読んでくれないんでしょうね
0701デフォルトの名無しさん
垢版 |
2021/02/03(水) 00:23:45.54ID:QKvl77B6
comb7 !! 1 を計算するには length comb7 >= 2 のようなものが必要だぞ
でも長さは1かもしれないからアウトという判断は正しい
オーバーランするよりよっぽどいい
0702デフォルトの名無しさん
垢版 |
2021/02/03(水) 14:08:13.61ID:mxabq2OH
求めてないかもですがこんなふうならかけますね。
module Main where
import qualified Data.Array.Unboxed as AU
main = do
print $ comb6 !! 2000 !! 1000
print $ comb7_1 !! 1000 !! 1000
print $ comb7_2 1000 1000 AU.! ( 1000, 1000 )
comb6 = ((1 : (repeat 0)) :) $ zipWith (zipWith (+)) comb6 (map (0 :) comb6)
comb7_1 = (repeat 1 :) $ ([ 1 .. ] :)
$ (map (\x -> scanl (+) 1 $ tail x) $ tail comb7_1)
comb7_2 :: Int -> Int -> AU.Array ( Int, Int ) Integer
comb7_2 ly lx = comb7_2_table
where
comb7_2_table = AU.array ( ( 0, 0 ), ( ly, lx ) ) $ concatMap(\i -> map (f i) [ 0 .. lx ]) [ 0 .. ly ]
f 0 x = ( ( 0, x ), 1 )
f y 0 = ( ( y, 0 ), 1 )
f y x = ( ( y, x ) , comb7_2_table AU.! ( (y - 1), x ) + comb7_2_table AU.! ( y, (x - 1) ))
0703デフォルトの名無しさん
垢版 |
2021/02/04(木) 22:24:53.84ID:w5MK0dgi
>>702
ありがとうございます
参考にさせていただきます
そうですね
もう一つ可読性が欲しい感じがします
元々の問題意識としては私は可読性の高いコードが要求されることが多いのです
例えばFibonacci数列であれば

f n = ( f $ n -1 ) + ( f $ n - 2 )

に可読性においてまさるものはないのですが、もちろんこれでは遅くて使い物になりません
なので実用性も多少はなりとも求めるならある程度は可読性を犠牲にせざるを得ないのですが、どういう方法がいいのだろうというのがテーマなのです
でたまたまFibonacciの場合に
f = 0 : 1 : ( zipWith ( + ) f $ tail f )
というのを見つけてコレ中々いいなと、dpで計算してるのに“メモ”をするための不要な手続きを書く必要がなく、Haskellの“call by need”の機能をうまく利用してdp計算させてるところにちょっと唸ったもので
でどれくらいコレでいけるのかなと二重数列をやってみたらうまくいかなくて、どうしたもんかなと
まぁコレはしょうがないのかもしれませんけど
0704デフォルトの名無しさん
垢版 |
2021/02/05(金) 00:47:44.85ID:hZ1aOePg
>>703
方向性違うかなと思いつつ書いたんですがやっぱり違いましたね。失礼しました。
今更どうでもいいですがちょっと間違えたので訂正だけさせてください。
comb7_1 = (repeat 1 :) $ (map (scanl (+) 1 . tail) $ comb7_1)
0705デフォルトの名無しさん
垢版 |
2021/02/05(金) 01:12:53.20ID:gzN36RyX
読むという目的
可読性の低いコードを、読むことなく却下するという手段

この目的と手段がすぐ入れかわってしまう現象もまた深刻な問題だ
0707デフォルトの名無しさん
垢版 |
2021/02/05(金) 19:44:21.42ID:DBOaHn9B
>>703
その遅くて使い物にならない計算を、
可読性をあまり犠牲にしないで爆速にする方法に、
メモ化(memoization)というテクニックがあります。
(その代わり、当然メモリを使います)

メモ化関数 memoize が用意されていれば、
n 番目のフィボナッチ数を求める関数 fib は
次のように書けます。

-- メモ化
fib :: Int -> Integer
fib = fix (memoize . fib')

-- フィボナッチ計算の本体
fib' :: (Int -> Integer) -> Int -> Integer
fib' f 0 = 0
fib' f 1 = 1
fib' f n = f (n-1) + f (n-2)

メモ化関数を提供するパッケージは色々あります。
また、メモ化の仕組みの基礎や本質を学びたいのなら、
次のごく短いブログ記事がおすすめです。
https://kseo.github.io/posts/2017-01-14-memoization-in-hasekll.html
この記事の最後の fibMemo 関数について、
適当な小さな値に適用させたものを
自分でノートに展開してみるといいです。
0708デフォルトの名無しさん
垢版 |
2021/02/05(金) 20:00:27.08ID:DBOaHn9B
>>707
すいません。
肝腎の memoize 関数の定義を書き忘れました。

memoize :: (Int -> a) -> (Int -> a)
memoize f = (map f [0 ..] !!)

先に紹介した記事にこれを導く過程や、
より速くより一般化する方法を学びたい人へ向けた
URL紹介が載っています。
0709デフォルトの名無しさん
垢版 |
2021/02/06(土) 09:10:00.64ID:8eeMDweD
>>707
解説ありがとうございます
やはりメモ化するしかないんだと思います
問題はそれがプログラマが明示的に自分でやらないといけないのか、コンパイラが自分でやってくれるのかの差なんだと思います
Haskellは純粋なcall by nameではなく、call by needのシステムの中にメモ化を備えていてプログラマがメモ化するように書いてなくても勝手にメモ化できるものをメモ化してくれるのがすごいとこだと思うんですけど、例えば>>703の2番目の例で最初見た時「なんでこの定義式でメモ化が効くんだ？」とさっぱりわからなかったのが、実はHaskellのcall by needのシステムをうまく利用してるらしいとわかったのが最初なんです
で二重の漸化式だとうまくいかないなと
もちろん二重の全炊きでも上手くsuffixの取り方を変えたりすると同様の方法でメモ化できるんですけど、それでは結局「Haskellの機能を利用して明示的にメモ化を指定することなく高速化した」事にはなりません
まぁコレはしょうがないんでしょうね
どんな計算も常にメモ化して常に同じ評価式を2度扱う事を防いでたらそんなの逆に使い物になりませんからね
0710デフォルトの名無しさん
垢版 |
2021/02/06(土) 20:56:07.58ID:tGZHMqQF
Haskellが「ヤバそう」って偏見だけで敬遠されてるのかなしい…
同級生にも布教したい
0711デフォルトの名無しさん
垢版 |
2021/02/06(土) 21:00:00.51ID:xuEfQm7n
>>710
布教という言葉自体、独善的で押し付けがましく感じられる原因になってると思うよ。
相手がいやがらない程度にhaskellの良さや面白さを伝えてそれでも相手が興味をひかれないなら、それ以上はやめときな。
0712デフォルトの名無しさん
垢版 |
2021/02/06(土) 21:12:54.72ID:HlAr7yEc
>>709
今回の話の本質ではないので、へーそうなんだ、
程度に聞いてくれればいいのですが、

>>703 の2番目の例とは、

f = 0 : 1 : zipWith (+) f (tail f)

のことでしょうか。
もしそうなら、これはメモ化ではないですよ。
(このテクニックをなんと呼ぶのかは知りませんが)

メモ化というのは簡単にいえば、
関数の同じ引数に対する2度目(以降)の適用に備えて、
その引数に対する1度目の関数の値をその引数とペアにして
どこかにメモしておくことです。

ポイントは、2度目以降に備えることではなく、
引数と関数値のペアをメモしておくことです。

それを踏まえて、>>703 の2番目の例において、
では何が関数で、引数と関数値のペアはどこにメモされているか、
考えてみてください。


ただ、言葉の意味は時代と共に変化していくものなので、
今はこれも広義にメモ化と言うことになっているのでしたら、すいません。
私の方が勉強不足です。
0713デフォルトの名無しさん
垢版 |
2021/02/07(日) 08:28:27.99ID:kgbg5mk/
>>707の方がzipwith使ったものより読みやすくて遥かにいいな
こっちの書き方の方がもてはやされてほしいわ
0714デフォルトの名無しさん
垢版 |
2021/02/07(日) 10:58:25.84ID:nblMEePQ
久しぶりにHaskell(Servant)触ってみたけど
相変わらず呪文のようなテンプレートマクロとかコンパイル通すためだけの幽霊型とか表に出てきているのね
こういうの後ろに隠した実装がほちい(･ัω･ั)
0715デフォルトの名無しさん
垢版 |
2021/02/07(日) 19:10:10.31ID:Ae+USThM
>>714
試しに作ってみればいいのでは？

そういう気に入らない幽霊型を
とりあえず1つだけ後ろに隠してみて、
使いやすいか試してみればいいと思う。

良さそうなら、ここや GitHub で提案するとか。
0717デフォルトの名無しさん
垢版 |
2021/02/08(月) 03:22:56.40ID:lr3qr0Kv
>>699
レスが遅くなりましてすいません。
xの定義にx自身を参照していますが、それだけでは
再帰的に定義されているとは言えないということですか。

例えば次の関数 f は再帰的に定義していると皆が言います。
f n = if n == 0 then 1 else n * f (n-1)

これと >>697 の x とは何が違うのでしょうか。
0720デフォルトの名無しさん
垢版 |
2021/02/08(月) 12:31:08.86ID:hFpKnaPX
>>707
リスト使ったメモ化の理解にはいいんですけど、その例も実は遅いんですよね。!!がO(n)なので。
module Main where
import Data.Function
import qualified Data.Vector as V
main = do
let memo = fibMyMemo 50000
print $memo 50000
print $fibMemo 50000
fibMyMemo l = fib
where
fib = ((V.map f $ V.enumFromN 0 (l + 1)) V.!)
f 0 = 0 :: Integer
f 1 = 1
f n = fib (n -1) + fib (n -2)
memoize f = (map f [0 ..] !!)
fib f 0 = 0
fib f 1 = 1
fib f n = f (n - 1) + f (n - 2)
fibMemo = fix (memoize . fib)
0721デフォルトの名無しさん
垢版 |
2021/02/08(月) 18:33:31.66ID:USGkiU7i
>>717
マジョリティとマイノリティの違いとか、合法とグレーの違いのようなものだと思えばいいだろ

再帰的な関数と再帰的な型はよく知られている
一方、関数でも型でもないケースは未知のウイルスのようなもので
既存のものと同じだとすぐ決めつけるのは判断が早過ぎる極論
0724デフォルトの名無しさん
垢版 |
2021/02/10(水) 10:35:38.44ID:tXb64EJq
法律や善悪の判断の正しさを疑うのと同じレベルの懐疑的な思考が
数学やデバッグにも必要ということかな
0725デフォルトの名無しさん
垢版 |
2021/02/10(水) 11:17:11.88ID:tXb64EJq
静的型は最強とかガベコレは最強とかいう考えが
疑われるようになったのは半分ぐらいHaskellが原因だよね
0729デフォルトの名無しさん
垢版 |
2021/02/11(木) 16:56:32.70ID:zBw+qxbZ
ねえ、購入厨
ひょっとしてHaskellは、きみが同じ地獄を繰り返す毎に
強力なフリーソフトになっていったんじゃないのかい
0730デフォルトの名無しさん
垢版 |
2021/02/13(土) 21:17:16.21ID:kqsb0S1y
悪役キャラには著作権等のコンプライアンスを意識させると邪気が抜けてしまう
豆知識
0732デフォルトの名無しさん
垢版 |
2021/02/14(日) 20:59:33.34ID:2j5v2BhK
>>731
ネットの差別発言を排除する努力すらやらない人がいるから
ワードサラダとやらを排除する努力なんて誰もやらないのは当たり前だぞ
こんな簡単なことがなぜ理解できないんだ
0733デフォルトの名無しさん
垢版 |
2021/02/14(日) 21:27:29.30ID:A1oxlP1a
731はワードサラダなレスうぜぇなぁくらいの意味しかなくワードサラダなレスが存在してしまう理由を実際に疑問に思っているわけではないという簡単なことが何故わからないのか
0734デフォルトの名無しさん
垢版 |
2021/02/14(日) 21:49:22.17ID:2j5v2BhK
731は、うぜぇなぁ以外何も考えてなかったというのか
それは差別意識しかない絶対悪じゃないか
0735デフォルトの名無しさん
垢版 |
2021/02/15(月) 01:08:13.78ID:Qrz9kKC+
もっと危機感を持ったほうがいいよ
母国語の特徴までネチネチいじられたら外国語はこわくて使えないだろう
英語ができないとプログラミングもできない
0736デフォルトの名無しさん
垢版 |
2021/02/15(月) 17:23:26.09ID:Mv5LolEs
なんかこのスレ会話が噛み合わないよな
>>732←こいつとか明らかに頭おかしいし
こういう人外化け物がうじゃうじゃいるから「特技はコミュニケーション能力です」みたいなゴミ文系が社会で調子に乗り始めるんだろうな
0737デフォルトの名無しさん
垢版 |
2021/02/15(月) 18:24:29.13ID:Qrz9kKC+
コミュ力の悪用を止める方法で一番使えそうなのは制限時間を無くすことだ
5秒で答えさせるような問題でも時間のルールを無視してしまえば
そのゴミ文系ってやつの能力を擬似的にコピーできる
0741デフォルトの名無しさん
垢版 |
2021/02/16(火) 12:56:19.11ID:VICwQMLs
質問なんですが,
https://levelup.gitconnected.com/functional-dynamic-programming-with-haskell-top-down-and-bottom-up-7ccade222337
の一番上のコード内23-25行目の
iMinusOne <- cdRecursiveTD (i-1) stArr
iMinusTwo <- cdRecursiveTD (i-2) stArr
writeArray stArr i ( (i-1) * ( iMinusOne + iMinusTwo ) )
の部分を添え字使って
for j = 1 to 2
xs !! j <- cdRecursiveTD (i-j) stArr
writeArray stArr i ( (i-1) * ( sum xs ) )
みたいに書く方法ってありませんかね？
0742デフォルトの名無しさん
垢版 |
2021/02/16(火) 15:13:16.20ID:VICwQMLs
すみません自己解決しました
一応結果貼っておきます
cdRecursiveTD i stArr = do
____v <- readArray stArr i
____when (v == -1) $ do
______xsm <- newSTRef []
______forM_ [1,2] $ \j -> do
________x <- cdRecursiveTD (i-j) stArr
________modifySTRef xsm (x:)
______xs <- readSTRef xsm
______writeArray stArr i ( (i-1) * ( sum xs ) )
____readArray stArr i
0743デフォルトの名無しさん
垢版 |
2021/02/16(火) 15:27:24.80ID:twhDC3NA
xs <- mapM (\j -> cdRecursiveTD (i - j) stArr) [1 .. 2]
writeArray stArr i ((i - 1) * sum xs)
これでよくないですかー？
0745デフォルトの名無しさん
垢版 |
2021/02/17(水) 14:02:08.57ID:YPZ4jTJ4
map f [1,1,1,2]のように重複の多いリストがあったら
fの実装を変える勢力とリストの構造を変える勢力の争いをどうやって解決できるか気になる
0748デフォルトの名無しさん
垢版 |
2021/02/17(水) 22:40:59.85ID:0SJ3Yct4
>>745
具体的な問題状況(例)が示されなければ、次のような何にでも当てはまる
至極当たり前のつまらない回答しかできないと思うが。

目的、開発リソース(時間や設備、資料、費用など)、
開発者の能力やモチベーション、メンテの容易さなどを、
優先順位を考慮したうえで出来るだけ客観的に評価し決定する。

争うということは、優先順位や評価基準が定まっていないということなので、
まずはそれらを話し合って、あるいは上の立場の者がバシッと決める。
0749デフォルトの名無しさん
垢版 |
2021/02/18(木) 09:29:03.36ID:8Wc99cSo
なんかしょうもない話なんですけどウチの環境で次が通ります

test x = case x of
_ | odd x -> 1
oyherwise -> 0

main = do
print $ test 123
print $ test 456

なんか笑ってしまいました
0751デフォルトの名無しさん
垢版 |
2021/02/18(木) 10:58:11.75ID:jy6gqPJ4
>>748
客観的な目的というのは難しすぎて誰にも分からない
例えば個人的な借金を減らすことと国の借金を減らすことはどちらが客観的目的か

そうではなく、目的は主観で決めてOKというなら
それは結構面白い答えであって、つまらない答えではない
0752デフォルトの名無しさん
垢版 |
2021/02/18(木) 11:50:05.23ID:6bd12mxo
>>751
言葉が足りず、誤解させたようで申し訳ない。

客観的に行うのは、目的を定めることではなくて、
今やろうとしている事が定めた目的に合っているのか評価すること。

fの実装を変えることが目的に合っているのか、
それともリスト構造を変える方がより合っているのか。

目的というのは様々あるよね。
見聞きした新しい技術をラフに評価するための
トイプログラムを作ることが目的だったり、
次のリリースでメモリ使用量を10%削減することだったり。

客観的に評価することを意識しないと、気分や雰囲気に流されて、
メモリ使用量を抑える目標が、いつの間にか処理速度向上にすり替わってたりする。

また、目標は評価する一項目にすぎない。
リリース時期を守る方が優先順位が高い状況もある。
だから、もろもろ含めて客観的に評価する。

逆にそうじゃないと、fとリストどちらを変えるのかなんて、決めようがないと思う。
0753デフォルトの名無しさん
垢版 |
2021/02/18(木) 15:29:22.47ID:jy6gqPJ4
>>752
気分や雰囲気に流されまくるまで想定しておくのが良い作戦だよ
流されないように対策するので想定する必要はないみたいな理屈は危ない
0754デフォルトの名無しさん
垢版 |
2021/02/25(木) 20:48:36.35ID:zWeVIvWn
ある対象がモノイドかどうかを問う質問です。

2つのリストのうち要素の少ない方のリストをそのまま返す、
同じ要素数ならば左側のリストをそのまま返す関数 f :: [a] -> [a] -> [a] があるとします。
ここで、ある型aのリスト全体の集合[a]と、その上の二項演算fとの組([a], f)はモノイドを成すでしょうか。

私は次のように、これはモノイドではないと考えます。

このモノイド性を考えるとき、その単位元の候補として、
もし集合に無限リストを含めないのならば最大要素数のリストを、
無限リストを含めるのであれば無限リストを取ります。
他に考えようがありません。

しかし、どちらにしても単位元の一意性が証明できません。
xs、ys 共に最大要素数のリスト、あるいは無限リストであり、かつ xs /= ys を満たすものは(型aによっては)いくらでもあります。

よって、([a], f) はモノイドではないと考えますが、これは正しいでしょうか。

モノイドの定義に照らし合わせるのではなく、
モノイドならば証明できるであろう定理が証明できないことに因っているのが、
なんとも気持ち悪いのですが・・・

そもそもモノイド性を問うには ([a], f) の定義が曖昧なのでしょうか。
0756デフォルトの名無しさん
垢版 |
2021/02/26(金) 01:35:18.34ID:7R2bTCy0
リストには同じ要素が何個も入ってもいいんだから単位元になり得るのは無限リストだけでしょ
ある無限リストを単位元eとするしかなさそう
ここでもう1つ無限リストaを用意してf a eしたらa返さずに要素の個数比較する時点で⊥になるからモノイドにならないと思う
0757デフォルトの名無しさん
垢版 |
2021/02/26(金) 02:07:21.86ID:Drny41hT
型は集合ではない
値は元ではない
プログラム上の関数は数学的な意味での関数ではない

Haskellは数学ではない
0758デフォルトの名無しさん
垢版 |
2021/02/26(金) 10:03:43.32ID:W2dsUZYE
モノイドでも集合論でも、公理が多過ぎて公理が偽になるなら
公理を減らせばいいじゃん
0759デフォルトの名無しさん
垢版 |
2021/02/26(金) 10:24:37.14ID:nFSf/y++
>>754
まず単位元の定義から、esが[a]の単位元であるなら、任意のxsに対して
f es xs == xs
f xs es == xs
を満たす、というところはいいよね(ゆえにesは、任意のxsより要素数が大きくなければいけない)

このことから直接非存在を言う方がこの場合は明快だと思うけど、
「ある要素が単位元ならばそれが一意である」はすぐに言えるから
背理法により単位元が存在しない、でも正しい論証だと思う

もしこの演算fに対してモノイドを構成するなら、
(>>756とほぼ同じことを言うが) length es == ∞ なる要素を1つ決めて
(全ての有限リスト) ∪ {es}
みたいな集合の上でなら言えそう
ちゃんと見てないけど結合律もそれっぽく振る舞ってそう
0761デフォルトの名無しさん
垢版 |
2021/03/18(木) 15:12:33.23ID:4AdjqCpZ
なんか最近プログラミングの情報ネットで漁ってると数学基礎論の記号らしきもの、横棒の上になんか命題らしき文字列が並んでる奴がめちゃめちゃ出てくるんですけど、完全に乗り遅れました
なんかあの記号の意味解説してるいい教科書とかサイトとかありませんか？
0762デフォルトの名無しさん
垢版 |
2021/03/18(木) 19:10:51.45ID:lKavXNN6
>>761
このような式ですか？

P -> Q P
--------------
Q

これは、横線の上の論理式(この例の場合は2つの論理式)を前提とすると、
いくつかの推論規則を使えば横線の下の論理式が導ける、
という意味です。

論理学の教科書(的な解説サイト)ならレベルの高低に関わらずどれでも載っていますが、
どれでも式自体の意味についてはこの程度の説明しか無いと思いますよ。
例えば
https://abelard.flet.keio.ac.jp/person/takemura/class/2013/3-print-nk.pdf

知りたいことが違っていたらごめんなさい。
0763デフォルトの名無しさん
垢版 |
2021/03/18(木) 19:28:09.20ID:wWeTTUcP
>>762
ありがとうございます
ギリギリその図形の意味はわかります
問題はそれとプログラミングの理論がどう関わってるかのとこなんです
多分カリーハワード対応というやつだと思うんですが
コレなんか役に立つもんなんですかねぇ？
0764デフォルトの名無しさん
垢版 |
2021/03/18(木) 20:21:41.37ID:lKavXNN6
>>763
めちゃめちゃ出てくるという事ですので、
そのページのURLをいくつか挙げてくれませんか。

そうすれば、もしかしたら、どう関わっているの把握できて、
説明、あるいは解説ページや書籍の紹介ができるかもしれません。
0766デフォルトの名無しさん
垢版 |
2021/03/18(木) 23:49:21.36ID:wWeTTUcP
>>764
そうですね
例えばcall by nameとcall by needの違いを調べようと思った時に出てきた

https://reader.elsevier.com/reader/sd/pii/S1571066104000222?token=1C1ACCAE69D33669B7D36179C932FC14DD80723B2FD5B3080E3B1EDED9228FC6A9A6AC347668843625B7154C276B7B4C

なんかバリバリ出てきます
なんのこっちゃと

>>165
coqもよく聞きますよね
なんかおすすめの教科書とかありますか？
0767デフォルトの名無しさん
垢版 |
2021/03/19(金) 00:48:13.30ID:H+hZ3f68
カリーハワード対応って要は
True => True = True
True => False = False
False => True = True
False => False = True
が
{単集合->単集合}=単集合 (単集合から単集合への写像は一通りだけ)
{単集合->空集合}=空集合 (単集合から空集合への写像は存在しない)
{空集合->単集合}=単集合 (空集合から任意の集合への写像は一通り(空写像))
{空集合->空集合}=単集合 (上に同じ)
と対応してるって感じと捉えれば良いのかな？
wikipedia読んでもあんまり理解できない
0769デフォルトの名無しさん
垢版 |
2021/03/19(金) 02:07:37.96ID:FHn+Zz2I
>>766
結局のところ知りたいことは何ですか？

カリーハワード同型対応とプログラムとの関係性ですか？
それとも、カリーハワード同型対応がプログラムの何に役立つのかですか？
それとも、call by name と call by need との違いですか。
それとも、その論文の内容ですか。
(その場合、PDFの5ページ目まで、つまり横線の式が登場する部分まではちゃんと理解できていると思っていいのですか？)

それとも、全く別のことですか？

とりあえず知りたいことをピンポイントに小さく一つに絞り、
それを具体的に質問していただけると助かります。


ところで、>>768 は元の質問者さんですか？
0770768
垢版 |
2021/03/19(金) 02:15:59.36ID:MuA020tT
>>769
ごめんなさい
僕は別人で割り込みです
0771デフォルトの名無しさん
垢版 |
2021/03/19(金) 03:08:33.55ID:FHn+Zz2I
>>770
遅延評価を実現する評価戦略の中に、必要呼び出し(call by need)と名前呼び出し(call by name)があります。

必要呼び出しはhaskellが採っている戦略で、
一度評価した値を使い回して無駄な呼び出しを防ぐものです。

一方、名前呼び出しは同じ遅延評価でも、評価した値を記憶せず、必要なら何度でも同じ評価処理をするものです。
0772デフォルトの名無しさん
垢版 |
2021/03/19(金) 09:49:18.16ID:pEtEADGt
>>769
そうですね
多分対応自体はわかると思います
しかし実際カリーハワード対応で基礎論の世界に持って行くことの効用がよくわかりません
基礎論の世界に持っていって基礎論でよく知られたなんかの定理が使えるとかいうわけでもなさそうですし
最初はcall by needの実装の話、すなわちcall by needでは展開された評価式に同じexpressionが出たとき、その内容を保持して同じ評価を何度も繰り返すのを防ぐらしいですが、もちろんどんな評価でも何でもかんでもメモするわけではないようなので、結局自分で手前でメモ化する必要がでたりします
どういう時はcall by needのメモ化が効いてどういう場合は効かないのかよくわからないので現状は“やってみる”しかないし、やってみて上手くいかなくても、なんか上手い書き方すればやってくれるのか、はなからだめなのか、その判別もつきません
0773768
垢版 |
2021/03/19(金) 11:58:13.56ID:f7aaFMxN
>>771
ありがとうございます

このときの「名前」なのですが、識別子のようなものでなく、評価・簡約前の「式の字面」的な意味なのですかね
0774デフォルトの名無しさん
垢版 |
2021/03/19(金) 13:27:51.17ID:5FIf9nG9
静的型のアイデアは
実行時の世界でやっていたことをコンパイル時の世界に持って行くことだから
このアイデアが常識にならない限り動的型の時代は終わらないだろう
0775デフォルトの名無しさん
垢版 |
2021/03/20(土) 08:58:16.14ID:Hmrg9tvu
>>772
プログラムの世界において、ある事柄の性質や、事柄Aと事柄Bの間の関係を調べたいとき、
プログラムの世界の中ではなかなかうまく見えてこない場合がある。
そんなとき、 カリーハワード同型対応によって問題を論理の世界に移すと、
見通しが良くなり、調べやすくなることがある。
そういう意味では役立ちます。
質問者さんが例示した論文がまさにそれです。

一方、何かを作るためにプログラムをする(現場の)人たちにとっては、とくに役立つことは無いと思います。
役立った話を一切聞きません。

質問者さんが、名前呼び出しなどの「性質や関係」を学術的に深く知りたくて調べているのであれば、役立つと思います。

自作のプログラム言語で名前呼び出しを実装したくて調べているのであれば、役立ちませんね。
別の論文に当たった方がいいと思います。
0776デフォルトの名無しさん
垢版 |
2021/03/20(土) 09:35:36.64ID:IEpiSEKy
>>775
そうなんですか
難しいですね
haskell の call by need のシステムがどういう具合に実装されてるか調べようとするとほぼ確実にカリーハワード対応が出てきます
ボチボチ勉強するしかなさそうですね
そもそもcall by needのメモ化の話はhaskell コンパイラの実装の話なのでhaskellの言語自体のレギュレーションにはひとつも載ってない(つまりghcではメモ化が効いて早いけど別のシステムでは遅いという事もありうるし文句言えない)ので効くか効かないか試してみるしかないのが不愉快なんですよねえ
0778デフォルトの名無しさん
垢版 |
2021/03/20(土) 10:28:51.32ID:Hmrg9tvu
>>773
すいません、call by name という名称の由来は分からないです。
いままで気にしたこともなかったです。
0779768
垢版 |
2021/03/20(土) 12:05:15.57ID:WUxvQvbt
>>778
ありがとうございます
こちらこそ、たびたびすみません

マンガのセリフのことを「ネーム」というらしいので、書いた字面をいうのかなと考えたり
name を和英・英英辞典で調べても、結局しっくりきませんでした

スレ汚しすみませんでした
0780デフォルトの名無しさん
垢版 |
2021/03/20(土) 14:58:31.86ID:5ytd1i+3
カリーハワード同型対応とかって、機械学習だのアーキテクチャだのネットワークだのアルゴリズムだのといった工学的で応用的で目的意識の定まった何かの役に立つために発明されたものというよりも、理学的で基礎的な単なる重要な事実という雰囲気ある気がする
0781デフォルトの名無しさん
垢版 |
2021/03/21(日) 00:15:43.04ID:5CEWIvha
貴金属と期限つきポイントの対立煽りにたとえる
使用期限がないのは使用目的がないと言っているようなもの
だが期限がない方もメリットがあるのは工学的にも否定できない事実
0782デフォルトの名無しさん
垢版 |
2021/03/22(月) 13:52:42.80ID:gNDsQT3i
>>777
graph refuctionですか
調べてみます
しかしともかく、じゃあGHCとかではどう実装されてるのかとかいう資料はかなりの割合で結局カリーハワード対応使ってる文献しか出てこないのがなんとも
当面は“やってみる”でやり過ごすしかなさそうです
0783デフォルトの名無しさん
垢版 |
2021/03/22(月) 15:09:38.98ID:UycYSiaC
call by name(仮)の正式名称がgraph reductionだったら
カリーハワード対応(仮)にも正式名称がありそうだけど
訂正することで利益が出せるようにならなければ正式名称の価値も分からん
0784デフォルトの名無しさん
垢版 |
2021/03/22(月) 19:37:04.72ID:TV/B7jf8
>>782
私にはむしろカリーハワード同型対応を陽には使っていない資料しか見当たらないです。
検索キーワードや調べ方が違うのかもしれませんね。
(カリーハワード同型対応がさす意味がお互いに違っている可能性もありますが)

この資料はどうでしょうか。
遅延評価をする関数型言語一般の実装方法です。
https://www.microsoft.com/en-us/research/uploads/prod/1987/01/slpj-book-1987.pdf
0785デフォルトの名無しさん
垢版 |
2021/03/22(月) 20:29:59.10ID:UycYSiaC
例えばmonomorphism restrictionとかいうアレだったら
実行時の挙動ではなく型の話になるんじゃないか
0786デフォルトの名無しさん
垢版 |
2021/03/23(火) 01:01:29.12ID:HzbeYy7B
>>784
ありがとうございます
十章ですね
今度時間を見つけて読んでみます
そうですね
やっぱり私はGHC関連の資料をあたる事が多くて、やはりそこでは数学よりの資料が多いんでしょうね
でもやはりcall by needの実装方法はHaskellのレギュレーションには含まれていない実装依存のところなのでGHC userの私はどうしてもGHC関連の資料から当たりたくなってしまいます
GHCでのインプリメントは最新の成果が全て反映されてるとは限らないし、あるいはあまり一般的でない手法を用いているかもしれないし、そこはGHCそのものの資料が一番頼りになります
ただ一つの問題はあまりにも数学村(の計算論畑)の言葉で書かれててサッパリわからんとこorz
0787デフォルトの名無しさん
垢版 |
2021/03/23(火) 03:42:25.12ID:VKgh9sH5
>>786
余計なお世話だとは思いますが、どの章もその前までの章の積み重ねなので、
第10章だけを読んで理解するのは難しいと思います。

かなり古い資料を提示したのは、基礎の基礎から学んだ方が良いと思ったからです。
この資料は本当に分かりやすく基礎から説明されているので、
急がば回れの精神で、腰を据えてじっくりと学んでみることをお勧めします。
それこそ数ヶ月かけて。


なんかこう、数学で例えるなら、集合論や解析学の基礎があやふやなまま、
位相空間論の必要な部分だけを都合よく学ぼうとしているような、
そんなきらいがあるように見えます。
0788デフォルトの名無しさん
垢版 |
2021/03/23(火) 05:16:41.87ID:EMfQwUjX
そうですか
残念ながら当方計算論はウルマンホップクラフトや西岡先生の教科書しか読んだことないのでかなり知識が数学サイドに寄ってます
仕事もかなり数学よりで計算論はあくまで趣味なのであまり本腰入れて勉強したことはないのでもしかしたら専門に勉強されてる方から見ればそうかもしれません
まぁ本職に悪影響与えない範囲で時間見つけてボチボチ勉強します
0789デフォルトの名無しさん
垢版 |
2021/03/23(火) 07:32:33.02ID:e41TIwig
はっきり言うと評価戦略だとか推論規則だとかカリーハワード同型対応だとかの話は、まともな情報系の学部なら習う基礎基本
大学の講義資料が易しいと思われ
0790デフォルトの名無しさん
垢版 |
2021/03/23(火) 20:57:46.65ID:zFHE0Fu5
情報系とかいう言い方をする奴は言語から逃げてるね
「数学村の言葉で書かれ」た資料が存在するのも
C言語で書かれたOSの話をしないのも
言語から逃げた結果じゃないかな
0793デフォルトの名無しさん
垢版 |
2021/04/05(月) 18:23:16.33
関数の名前が被るとき、このモジュールのそれだと修飾しますが、
今書いてる翻訳単位のそれだと伝えるには今書いてるモジュール名で修飾するしかないのですか？
それが長大な場合惨めな気持ちになります

qualified 今書いているモジュール名 as 短い名前
にするような事はできないのですか？
0794デフォルトの名無しさん
垢版 |
2021/04/05(月) 21:28:27.96ID:DOv0Oh8v
idrisを使った型駆動設計の話を聞いて、凄いなぁと思いました。
でもこの型駆動設計って、依存型が開発言語のあるのが前提の方法なんでしょうか？
0795デフォルトの名無しさん
垢版 |
2021/04/05(月) 22:48:33.31ID:RKVG1ya/
>>793
今書いている翻訳単位で import しているモジュールを qualified で装飾すれば、
今書いている翻訳単位内で定義している同名の関数は修飾せずとも使えると思うのですが、どうですか？

module Main where

import qualifued Data.List as L

transpose :: (Int, Int) -> (Int, Int)
transpose (x, y) = (y, x)

main :: IO ()
main = do
let a = L.transpose [[1, 2], [3, 4]]
let b = transpose (1, 2)
putStrLn $ show a ++ " / " ++ show b
0796デフォルトの名無しさん
垢版 |
2021/04/06(火) 12:32:00.21
>>795
値コンストラクタ名に被りがあった場合、それができないようなのです
import モジュールの側の同名値コンストラクタを、qualifiedして修飾しましたので今書いてるモジュールの方を修飾なしで書いたのですが
それはAmbiguousだと怒られます
0797デフォルトの名無しさん
垢版 |
2021/04/06(火) 20:13:47.61ID:sYlI8eNJ
ホントだ
怒られた

import qualified Data.Bool as B

data MyBool = True | False

instance Show MyBool where
show Main.True = "MyTrue"
show Main.False = "MyFalse"

main = do
print B.True
print Main.True
--print True ←ダメだって
0801デフォルトの名無しさん
垢版 |
2021/04/06(火) 21:08:36.42ID:sYlI8eNJ
しかし>>795は怒られない
関数とか値コンストラクタとかclass名とかそれぞれの名前空間でちょっとずつ管理法がずれてるんだな
理由は知らんけど
0802デフォルトの名無しさん
垢版 |
2021/04/06(火) 22:30:07.58ID:sYlI8eNJ
いや>>800さんの言う通りだったかな？
コレ↓は通る
BoolがダメだったのはPreludeで読んでたからだな
ちゃんと修飾なしの場合Main moduleのコンストラクタが選ばれてる

import qualified System.Exit as S

data MyExitCode = ExitSuccess | ExitFailure Int

instance Show MyExitCode where
show ExitSuccess = "MyExitSuccess"
show ( ExitFailure x ) = "MyExitFailure " ++ ( show x )

main = do
print ExitSuccess
print S.ExitSuccess
print $ ExitFailure 12
print $ S.ExitFailure 12
0804デフォルトの名無しさん
垢版 |
2021/04/07(水) 15:24:37.74
module BinaryRepresentation.Word8 (
　　BiRep8( Rep)
)
where
import Data.Word( Word8)


newtype BiRep8 = Rep Word8

instance Show BiRep8 where
　　show a = show' 8 a ""
　　　where
　　　　show' 0 _ s = s
　　　　show' count (Rep w8) s =
　　　　　let
　　　　　　(q,r) = w8 `quotRem` 2
　　　　　in
　　　　　　show' (count-1) (Rep q) (r `shows` s)
---------↑binary_representation8.hs-----------------------------
0805デフォルトの名無しさん
垢版 |
2021/04/07(水) 15:24:59.63
module BinaryRepresentation.IPAddress(
　　IPv4Address,
　　BiRepIPv4Address( Rep),
　　makeIPv4
) where
import Data.Word( Word8)
import Data.List( intersperse)
import BinaryRepresentation.Word8( BiRep8( Rep))
import qualified BinaryRepresentation.Word8 as Bi8


newtype IPv4Address = A (Word8, Word8, Word8, Word8)

ipshow::Show s=> (Word8->s) -> [Word8] -> String
ipshow f list = concat . intersperse "." $ (show . f) <$> list

instance Show IPv4Address where
　　show (A (_1,_2,_3,_4)) = ipshow id [_1,_2,_3,_4]


newtype BiRepIPv4Address = Rep IPv4Address

instance Show BiRepIPv4Address where
　　show (Rep (A (_1,_2,_3,_4)))
　　　=
　　　　ipshow Bi8.Rep [_1,_2,_3,_4]


makeIPv4::Word8 -> Word8 -> Word8 -> Word8 -> IPv4Address
makeIPv4 _1 _2 _3 _4 = A (_1, _2, _3, _4)
-----------↑binary_representation_ipv4.hs------------------------
0806デフォルトの名無しさん
垢版 |
2021/04/07(水) 15:25:15.94
[2 of 2] Compiling BinaryRepresentation.IPAddress ( binary_representation_ipv4.hs, binary_representation_ipv4.o )

binary_representation_ipv4.hs:24:11: error:
　　Ambiguous occurrence ‘Rep’
　　It could refer to
　　　either ‘BinaryRepresentation.Word8.Rep’,
　　　　　　　imported from ‘BinaryRepresentation.Word8’ at binary_representation_ipv4.hs:8:36-47
　　　　　or ‘BinaryRepresentation.IPAddress.Rep’,
　　　　　　　defined at binary_representation_ipv4.hs:21:28
　 |
24 | 　　show (Rep (A (_1,_2,_3,_4)))
　 |　　　　 　^^^
------------------------------------------------
意図：Word8 値を01表記で表現するモジュールを作り、それを用いてIPv4アドレスを01表記で表現する
問題：binary_representation_ipv4.hs のRepが、binary_representation8.hs のRepと被りAmbiguousである
判明しているワークアラウンド：24行目のRep を BinaryRepresentation.IPAddress.Rep という糞ダサコードへ書き換える
望む事：修飾せずに済ますか、短い修飾で済ませたい
0808デフォルトの名無しさん
垢版 |
2021/04/07(水) 18:16:48.26
はわわ。。。通りました
下手にimport書いたせいで通らなくなるとかあるんですね
蛇足importと名付けて教訓にします。ありがとうございました
0812デフォルトの名無しさん
垢版 |
2021/04/16(金) 21:38:11.49ID:gUR6Epkt
>>794
型駆動開発(TDD)はidris作者が本出してるけどそれのことかいな？

であれば予想してるように依存型前提よ
パターンマッチはデータ構築子に沿って分解してるだけだから
(x:xs)だけじゃなくて(xs++[x])でパターンマッチできるようにSQLよろしく型レベルのウインドウ関数つくりましょう
IDEにコード生成させましょう
とかって大変楽しい本だった
0813デフォルトの名無しさん
垢版 |
2021/04/17(土) 18:14:21.16ID:+4ymujjn
リストを使って漸化式
r_n = max_{1 <= i < n} (p_i + r_{n-i}), r_0 = 0
を解くプログラムを書いたのですがリストをArrayに変えたとたん動かなくなりました
どうやらmax'にifが使われているのが原因のようなのですが動かなくなる理由が分かりません
どなたか分かる方いますか？
プログラムは以下の通りです
import Data.Array

p = [1,5,8,9,10,17,17,20,24,30]

max' (i,q) (i',q') = if q < q' then (i',q') else (i,q)

solver p = array (0,length p) $ (0,0):[ -- 動かない
　　foldr1 max' [(i, p !! (i-1) + rs ! (j-i)) | i <- [1..j]]
　　| j <- [1..length p]
　] where rs = solver p

solver' p = (0,0):[ -- 動く
　　foldr1 max' [(i, p !! (i-1) + (snd $ rs' !! (j-i))) | i <- [1..j]]
　　| j <- [1..length p]
　] where rs' = solver' p
0814デフォルトの名無しさん
垢版 |
2021/04/17(土) 18:16:48.86ID:+4ymujjn
動かないと言うのはghciに入力すると結果がいつまで経っても出力されない状況を指します
0816デフォルトの名無しさん
垢版 |
2021/05/09(日) 13:13:30.99
すいません、Microsoft TrueSkill レーティングシステムのHaskell実装を探しているのですが見つかりません
イロレーティングとグリコレーティングしかありません
TrueSkillを実装したライブラリを知ってる方がいたら教えてください
0817デフォルトの名無しさん
垢版 |
2021/05/09(日) 22:22:49.79ID:HZ/HWpqa
Haskellでアプリ作ろうにもopenglくらいしかまともなバインディングないんじゃなかったっけ？
じぶんでラップするのだるいし
おれはもうf#で作ることにしたよ
0819デフォルトの名無しさん
垢版 |
2021/05/10(月) 00:08:10.35ID:fW0+gsWX
パターンマッチでRustみたいに
match x {
Some(SeqCst)=>true,
Some(Relaxed)=>true,
_=>false
}
を
match x {
Some(SeqCst|Relaxed)=>true,
_=>false
}
って感じで書く方法ってある？
0822デフォルトの名無しさん
垢版 |
2021/05/11(火) 11:48:38.64ID:cKOIjnA7
あ、matchって正規表現のmatchじゃなくて？
質問内容がふわふわしすぎで何がしたいのかさっぱり分からん
0824デフォルトの名無しさん
垢版 |
2021/05/14(金) 16:46:12.69
時期に ARM CPUを載せた端末で 走る Haskell 製ソフトを公式に吐き出せるようになるんです？
0825デフォルトの名無しさん
垢版 |
2021/05/15(土) 10:53:50.63ID:NqYfkIUy
CPUとHaskellって
まるで中世からいきなりポストモダンに飛んでるみたいな世界観だな
0826デフォルトの名無しさん
垢版 |
2021/05/15(土) 11:35:40.38ID:DozosAnh
たとえばC言語習いたての難しいと思う理由は、
コンピューターならこれくらいできるだろうと思ってた所に全然届いてなくて
そこを全部自分で埋めなきゃならないことを認識するのに時間がかかること
代数的なHaskewllがデフォならすんなり学習できるかもな
逆に今はCに適応しすぎてHaskellに苦労する
0827デフォルトの名無しさん
垢版 |
2021/05/15(土) 12:48:56.18ID:NqYfkIUy
>>826
これくらいできるだろうというのは楽観的すぎて苦労するパターンだ
悲観的な方が認識に時間がかからない

Cに適応しすぎているという認識は本当に正しいのか？
ここでも楽観と悲観が対立する
0828デフォルトの名無しさん
垢版 |
2021/05/21(金) 15:54:58.85
長く時間がかかるプログラムを走らせた時、タスクマネージャーを眺めると、少数のコアに高負荷、残り全コアに低負荷がかかってるみたいなのですが
実行時に使用コア数は指定していないことから推測すると、ガベコレは全コアで稼働するってことでしょうか？
0830デフォルトの名無しさん
垢版 |
2021/05/22(土) 20:46:21.69
え、じゃあなんで全コア低負荷になったんだろ・・・
数分毎に階段のようにRAM使用量が数GBずつ増えて行って
長い処理が終了する直前に全コアフル稼働になって、直後に処理終了になったから
ガベコレが関与してると思ったんですがね
0831デフォルトの名無しさん
垢版 |
2021/05/22(土) 21:35:55.30ID:aaz7cUPO
サンクが溜まってって最後に遅延してそれらを評価したのでは
というかパフォーマンスの話は変に予測立てたり先入観あったりするとろくなことないからもっと詳細にプロファイリングしたほうが
0832デフォルトの名無しさん
垢版 |
2021/05/22(土) 21:58:08.22ID:Up5XEM4X
ガベコレ以外に考えられる原因が2つぐらいあったら
ガベコレが原因である確率は1/3ぐらいだから
2/3の方が勝ちそう
0833デフォルトの名無しさん
垢版 |
2021/05/29(土) 14:13:39.92ID:SnGl3AHf
win10でstackとかghcそのものは正常に入るんたけどパッケージのコンパイルが絡んでくるとどうも文字コードが原因でコケる
LANG=asciiにすると挙動が変わってくるんだけど、何にしとくのが正解なんだろ
0834デフォルトの名無しさん
垢版 |
2021/05/29(土) 16:46:49.24ID:1zrkc3qO
100万要素の配列の1要素を更新するために配列の再作成が必要？
https://www.quora.com/Is-Haskell-as-fast-as-C++-If-not-why-not/answer/James-Hollis-19
> Haskell naturally operates on lists, but is rather awkward with arrays. Pure functions do not modify their input, so a pure function that changes one element of a million element array will copy 999,999 elements into a second array and return that. You can get around this with monads, but you end up writing imperative code in something that is less flexible than real imperative code.

これをモナドとアクションで解決できる？どうやるのか？
0836デフォルトの名無しさん
垢版 |
2021/05/30(日) 22:25:02.60ID:F1Ogq3BP
Unsafe でok
所詮物理的にはハードウェア上で動いてるのだから、
副作用なしなんてただの幻想よ
0838デフォルトの名無しさん
垢版 |
2021/05/31(月) 10:43:40.87ID:xvi5eoqv
Rustと同じように、どうにかして型を弱くすれば副作用は好きなだけ使えるよ
0839デフォルトの名無しさん
垢版 |
2021/06/01(火) 02:01:57.33ID:4I1ndF8a
IOモナドやSTモナドの中でファイル操作したり現在時刻取って来たりしても問題無いわけだしわざわざ型犠牲にしなくても良いんじゃない
0840デフォルトの名無しさん
垢版 |
2021/06/01(火) 10:15:13.07ID:UuHFoCEt
書き方が何通りもあってコンパイルが通るのは客観的事実だよ
そんな書き方しなくても良いというのはまあ政治的にはそうなるわけだが
コンパイルエラーにならないのに、バラモンみたいな人間に色々言われると混乱しやすい
0842デフォルトの名無しさん
垢版 |
2021/06/03(木) 20:42:08.53ID:/+9iJa2F
>>833
自己解決
language-javascriptパッケージのソースのコメントに∉記号がutf8で入ってて、環境によっては違うエンコードで読み込んでエラーになるっぽい
誰かが開発者にワークアラウンドとしてコメントをasciiで書き直してくれとリクエストしてたけど、ビルド環境を整えるのはstackの仕事だから俺は知らんと一蹴されてた
まぁそりゃそうなんだけどさ...
0844デフォルトの名無しさん
垢版 |
2021/06/05(土) 12:32:22.17ID:aDKd5nip
プログラミング最大の罠のひとつ
自分で創作するよりも他人のソースを読む方が難しい
0848デフォルトの名無しさん
垢版 |
2021/06/07(月) 22:55:42.12ID:OC0V43xk
ここ1, 2年で自分が書いたソースが回ってくることがあるけどほとんど覚えていなかった
今から振り返るともっといいやり方が思いつくけど、他人が書いたコードより遥かに行儀が良くて読みやすかった
0849デフォルトの名無しさん
垢版 |
2021/07/01(木) 09:54:29.98ID:yiVYCTXd
Hmatrixはcabalで入れたのにghciから:m Numeric.LinearAlgebraや
import Numeric.LinearAlgebraで行列演算モジュールを入れようとすると、

<no location info>: error:
Could not find module ‘Numeric.LinearAlgebra’
Perhaps you haven't installed the "dyn" libraries for package ‘hmatrix-0.20.2’?
Use -v to see a list of the files searched for.

とエラーが出るのだけど、よく分からない。ホームディレクトリにHmatrixのファイルっぽい
ものを置いてもダメ。Numericのフォルダをホームディレクトリに置いてもダメ

分かる人、教えてくださいm(_ _)m

古いパソコンの仮想linuxに入っている奴はimport Numeric.LinearAlgebraで
通常通り動くけど、その他のPCでは動かないんだよね。前は動いていたのもあったけど
ファイル関係いじくり回してたら、設定が狂ったようで動かなくなった

関数型言語で行列演算さえ、導入にこれだけ苦労するとは、どういうことだいｗ
0850デフォルトの名無しさん
垢版 |
2021/07/01(木) 13:56:29.22ID:m444U3IV
> ファイル関係いじくり回してたら、設定が狂ったようで動かなくなった
ちゃんとドキュメント読んでないよね？
0851デフォルトの名無しさん
垢版 |
2021/07/01(木) 18:53:55.58ID:dccggDtp
ghciでimportを複数すると、プロンプトが
Prelude Data.Monoid Data.Traversable Data.Foldable>
と長くなってしまうので、importしたの表示しないようにするにはどうしたらいいのですか？
0854デフォルトの名無しさん
垢版 |
2021/07/02(金) 03:41:23.49ID:aoQxpJoS
>>849
ghciのコマンドライン引数に、使用したいパッケージを指定するものがなかったっけ？
baseパッケージ以外はちゃんと引数で明示しないとghci上で使えなかったような気がする。
0855デフォルトの名無しさん
垢版 |
2021/07/10(土) 00:45:51.28ID:FlY7oUIG
すいません
質問させて下さい
Ghc.Types というのを眺めてたんですが
謎の#が入ってるコンストラクターがいっぱい見えます

data {-# CTYPE "HsInt" #-} Int = I# Int#
data {-# CTYPE "HsDouble" #-} Double = D# Double#
newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))

などなど
なんですかコレ？
一方でたとえばDoubleはReal classに属してるのでsinとかlogとかの処理をどこかでやってると思うのですがどこにも見つけられません
もちろんこんなプリミティブな演算はHaskellではなくCとかに丸投げしてるんでしょうけどその手の宣言なりなんなりはないもんなんですか？
0857デフォルトの名無しさん
垢版 |
2021/07/10(土) 09:09:34.41ID:Qo9dk8cs
>>856
なるほど
まだよくわかってないですけどunboxed typeというやつなんですね
後半もどなたか分かりませんか？
実は事情で“多倍長の浮動小数点”を自作したいのです
そのためにはReal型にしなくてはならずsinとなlogとか結構ある数の関数を実装する必要があります
どこかに参考にできるライブラリ転がってませんか？
性能は求めないので多倍長精度の計算ができるReal型を実装してる例が欲しいです
0863デフォルトの名無しさん
垢版 |
2021/07/11(日) 06:49:31.34
リストのシャッフルは、２値ランダムと分割統治法で構成できるという境地に至った
0865デフォルトの名無しさん
垢版 |
2021/07/16(金) 17:38:36.16
あののののの！　なんで型コンストラクタ名が被ったらいけないんですか！
型が違うならそのコンストラクタ名くらい被ったっていいじゃないですか！
0866デフォルトの名無しさん
垢版 |
2021/07/16(金) 23:35:14.79
Esqueleto では SELECT ～ FROM ONLY an_table ～　みたいに ONLY を付けることで継承テーブルを対称から外すように指示することはできないんですか？
生SQLを書くしかありませんか？
0867デフォルトの名無しさん
垢版 |
2021/07/17(土) 15:02:59.17ID:eTC1af8g
>>864
ちょまどは鳳唐好きだって言ってた
0868デフォルトの名無しさん
垢版 |
2021/07/17(土) 17:39:27.65ID:44fEdIj7
私は、MBAを取るために、ハワイにある伝統的なビジネススクールに通っていたとき、どこかの大企業で
働く中間管理職が教えるマネジメント「論」や経済「論」を学ぼうとしている自分に気付いた。
ビジネス経験のない先生は、学校制度の外に一度も出たことがない人だ。つまり彼は、5歳で幼稚園に入ってから
ずっと学校制度の中にいるにもかかわらず、学生たちに実社会について教えようとしていることだ。
とんだお笑い草だと思った。
講師陣や中間管理職や教師のほとんどは、ゼロからビジネスを立ち上げるのに何が必要なのかについては何も知らなかった。
ロバートキヨサキ「人助けが好きなあなたに贈る金持ち父さんのビジネススクール」P６２～６３

彼らのほとんどは、学校という象牙の塔を出ると、企業社会という象牙の塔に入った。
安定した仕事と給料に依存していた。つまり、素晴らしいビジネス論をもっている人は
たくさんいたが、現実の世界でビジネスをゼロから立ち上げ、大きな富を蓄えるのを可能にする、
素晴らしいビジネススキルのある人はほとんどいなかったということだ。
彼らのほとんどは給料なしで生きていけなかった。
ロバートキヨサキ「人助けが好きなあなたに贈る金持ち父さんのビジネススクール」P６３
0870デフォルトの名無しさん
垢版 |
2021/07/18(日) 08:48:06.51ID:p5uFvWrN
まあ、生きていけないぞー死ぬぞーってのが机上の空論の中でも最悪の論だよな
実際には死なない人が多い
0871デフォルトの名無しさん
垢版 |
2021/07/18(日) 22:53:21.56
すいません、僕がスレを軽率に上げてしまったばっかりにワードサラダBOTの餌食なってしまうとは・・・
0874デフォルトの名無しさん
垢版 |
2021/07/26(月) 04:08:52.62ID:FlIQ/SVE
ttps://cognicull.com/ja
Haskellやるのにこの辺は履修済みであることが求められるの？
Obj-Cだとほぼなくてもアプリは書けるけども
Haskellって数学じゃないのに数学のフリしてるところあるよね
利用者も然りで余計混乱を招いてる気がする
0875デフォルトの名無しさん
垢版 |
2021/07/26(月) 12:01:28.04ID:nPPC7Onz
>>874
うーん、書きたいプログラムの内容によるとしか言えないかな
こうしたことがわからないとHaskellのプログラムが書けないということはない
そのあたりはObjective-Cと同じ
0878デフォルトの名無しさん
垢版 |
2021/07/27(火) 15:27:28.97ID:6BJr6nx6
>>874
フリじゃなくて実際、他のメジャー言語よりは数学的裏付けがされてると思う
利用者も然りなのはむしろ良い傾向
他言語はhaskell以上に、ウェイがノリで書いたようなゴミライブラリが流行ってたり、侍エンジニアレベルのゴミ文献が蔓延ってたりする阿鼻叫喚状態
0880デフォルトの名無しさん
垢版 |
2021/07/30(金) 13:54:44.53ID:kX7UidPf
>>874
Haskell書いてるときにそういう系統の知識が要求されたことはないなぁ、いくつかの概念の出自が圏論だと聞いたことはあるが
0881デフォルトの名無しさん
垢版 |
2021/07/30(金) 14:32:21.44ID:yBIo03BR
すごいHaskellに素晴らしい数学の解説書ってレビューがついてた時はクスっと来たけど
0882デフォルトの名無しさん
垢版 |
2021/08/02(月) 07:34:32.07ID:Rllz2LO9
例えばOOPの継承関係を否定する
否定するなら対案を出せと言われる
この過程は数学ではないけど結果的には半順序関係とか圏とか出てくる
0883デフォルトの名無しさん
垢版 |
2021/08/16(月) 04:30:28.47ID:aZY1/RTa
純粋関数型でキャッシュは実装可能？

例えばＯＯＰでは計算に時間がかかる値はキャッシュしておいて次の読み取りで
キャッシュから返すという事ができる。
このキャッシュの管理をＯＯＰらしいカプセル化によってまともに実装できる
0885デフォルトの名無しさん
垢版 |
2021/08/18(水) 20:19:16.73ID:MamsdVYI
>>66
オブジェクト指向プログラミングにおける Smalltalk 的な位置づけに来るんじゃないかな。

ガッチガチだから強制的に「その概念」に染まれる。
0886デフォルトの名無しさん
垢版 |
2021/08/19(木) 00:24:27.59ID:anV9aH6F
低級言語でインタプリタを作れそうなシェルスクリプト的な位置づけだよ
単一の高級言語を強制されない
0887デフォルトの名無しさん
垢版 |
2021/08/19(木) 16:00:36.29ID:IKqVi/r3
関数型言語ってリストとかツリーみたいな再帰的なデータ構造扱うのは得意だけど
有向・無向グラフ(のアルゴリズム)扱うの難しくない？
0888デフォルトの名無しさん
垢版 |
2021/08/19(木) 18:40:13.11ID:JntO5v5E
>>887
難しいと感じるかどうかは本人の気持ちなので何とも言えません。

ただ、haskellでのグラフ理論の扱いに関しては、
カジュアルな解説もフォーマルな論文もたくさんあります。
ライブラリもあります。

扱ったことはないけど、何となくイメージだけで
難しそうだ、
haskellの苦手分野だと思っているのであれば、
自分に読めそうな記事にいくつかトライしてみてはどうでしょうか。
0889デフォルトの名無しさん
垢版 |
2021/08/19(木) 21:01:34.14ID:anV9aH6F
>>887
Erlangのようなメッセージ送信を考えればわかるが
メモリを共有していない相手にも送れるデータ構造が得意

メッセージとして文字列ばかり使ってるとカプセル化も型情報も無駄になる
だから文字列に似ているが異なるデータ構造が役に立つ
0890デフォルトの名無しさん
垢版 |
2021/08/25(水) 21:36:21.14ID:NimliznV
Applicativeの(*>)演算って何の意味があるの?
第一引数はどうせ捨てられるんでしょ。
0891デフォルトの名無しさん
垢版 |
2021/08/25(水) 23:09:37.51ID:SkXNk2uR
確かに左辺 :: f aで言うところのa型の値は捨てるが
Maybeとか[]みたいな直和型でどの値コンストラクタを使って構築されたかの情報は影響するよ
0892デフォルトの名無しさん
垢版 |
2021/08/26(木) 21:35:42.38ID:Wv9PZvrP
>>891
それは第1引数をパターンマッチすることで、たとえ第2引数が同じ値でも、
(*>)の計算結果を変えられることに意味があるってこと？

Sum型やProduct型もApplicativeのインスタンスになってるけど、
これらだと(*>)には意味がない？
(当然(<*>)など他の演算には意味があると思うけど)
0894デフォルトの名無しさん
垢版 |
2021/09/01(水) 17:56:43.60
ぼくようメモ：
OpenSUSE でPostgreSQLを使用した開発をしていてstack buildで
postgresql-libpq パッケージを途中にビルドする際
pg_config が無いと言われコケることがある

背景： OpenSUSE は postgres-devel から pg_config を削除した。我々は libpq.pc を代わりに使うべきである。
ソース： https://redmine.lighttpd.net/issues/2965

解決法：

stack build --flag postgresql-libpq:use-pkg-config
としてビルドする
0895デフォルトの名無しさん
垢版 |
2021/09/08(水) 22:14:55.40
そうか！Trueskill のHaskell実装がなくて論文読んで自分で実装する力がなくても
Haskellから実行時にbash 呼び出してPython3　のTrueskillライブラリに標準入力でPythonコードを流し込んで
演算結果を文字列で貰ってきて、それをParserCombinatorで作った字句解析器で読み取ってHaskellのデータに戻せばいいじゃん
あたいったら天才ね！
0897デフォルトの名無しさん
垢版 |
2021/09/10(金) 01:55:27.29ID:bkZL74IR
関数定義の左辺の部分的で、関数名と仮引数名の後の | と = の間の部分って何て名称だっけ？

f x y | x < y = ...

これの x < y の部分。
あるいは関数定義をこう書く方法の呼び方とか。

この文法や制限などをネットで調べたいんだけど、
名称が思い出せず検索に難儀してる。
できれば英語でお願い。
0900デフォルトの名無しさん
垢版 |
2021/09/22(水) 10:43:55.15ID:02VLVXq+
パターンの質問です

Rational型の数が平方数であるかどうか判定するプログラムで

isSquare r = r >= 0 && r == ( sqrtR r )^2
sqrtI = truncate . sqrt . fromInteger
sqrtR r = let
( a, b ) = ( numerator r, denominator r )
in ( sqrtI a ) % ( sqrtI b )

というのを書きました
もちろんこれはうまくいきます

しかし numerator, denominator をいちいち取り出すのが鬱陶しいので

sqrtR ( a :% b ) = ( sqrtI a ) % ( sqrtI b ) ------- ①

と書きたかったのですがうまくいきません
0901デフォルトの名無しさん
垢版 |
2021/09/22(水) 10:44:01.62ID:02VLVXq+
ネットで調べると

{-# LANGUAGE PatternSynonyms, ViewPatterns #-}

numDenum :: Integral a => Ratio a -> (a,a)
numDenum x = ( numerator x, denominator x )

pattern ( :% ) :: Integral a => a -> a -> Ratio a
pattern a :% b <- ( numDenum -> ( a,b ) )
where a :% b = a % b

というおまじないがstack exchangeで見つかってコレつけるとうまく行きました
うまくいったんですがサッパリわかりません
コレ何者ですか？
そもそも①はなんでうまく動かないんですか？
0902デフォルトの名無しさん
垢版 |
2021/09/22(水) 11:58:51.92ID:Sp73Mnte
計算結果をパターンマッチさせようとして失敗してるのでは

値を値コンストラクタにばらしてその値コンストラクタに応じて処理を変えるのがパターンマッチ
(マッチさせる対象がList aなら、：なのか[]なのかに応じて「先頭：後ろ」か空リストかが束縛される)

で、計算結果をマッチさせたいならビューってのを定義してあげないといけませんよって話のような
0903デフォルトの名無しさん
垢版 |
2021/09/22(水) 18:38:05.18ID:02VLVXq+
>>902
レスありがとうございます
原因わかりました
ご指摘の通り「計算結果にはパターンマッチさせられない、パターンマッチに入っていい関数はコンストラクタのみ」なのでRatio a型のコンストラクタである( :% )を使ってたのでそこは問題ないと思ってたんですが肝腎要の( :% )が定義されてるGHC.Realをimportしてませんでした
Data.Ratioをimportしたら自動的に(:%)も使えるもんだと思い込んでいました
Pattern synonymsについては

https://qiita.com/as_capabl/items/d2eb781478e26411a44c

でちょっと理解できました、が、そもそも使わなくても良くなりました
ご協力感謝です
0904デフォルトの名無しさん
垢版 |
2021/09/22(水) 20:18:48.06ID:02VLVXq+
備忘録がてら調べてわかった事書いておきます
Pattern Synonyms は今回のようにライブラリの提供者が型のコンストラクタを提供してない、しかしパターンマッチは使いたいとかの場合に使える拡張のようです
{-# LANGUAGE PatternSynonyms, ViewPatterns #-}
を使うと

pattern ( マッチさせたい表現) <-
( その型から取り出したい値を取り出す関数)
-> ( 取り出した値にマッチさせるパターン) )
( where さらにコンストラクタシノニムとしても使いたい場合の逆変換関数 )

の形で使うようです
例えばInt型でxが偶数であった場合にdiv x 2をパターンマッチで拾うために

pattern TwiceOf x <-
( ( \t -> ( div t 2 , even t ) ) -> ( x, True ) )

のように定義しておいて

main = do
case 2 of { DoubleOf x -> print x; _ -> print "odd" }
case 3 of { DoubleOf x -> print x; _ -> print "odd" }

のように利用できるようです
TwiceOf はあくまでパターンマッチの表現のみで使える“仮の”コンストラクタですがpattern文にwhere句を

pattern DoubleOf x <-
( ( \t -> ( div t 2 , even t ) ) -> ( x, True ) )
where TwiceOf x = 2*x

のように追加するとあたかもInt型の新しいコンストラクタが追加されたように振る舞い“DoubleOf 2”のような表現が許されるようになるようです
今回の場合はどうすべきか悩みどころです
ライブラリの開発者が低レベルの(:%)を公開しない理由もわかるので無理クリ(:%)を使うのもどうなんつて気もするし、かと言ってまだHaskellの標準として認められてない、GHCでしか使えない拡張使うのもどうなんという気もするし
0905デフォルトの名無しさん
垢版 |
2021/09/23(木) 10:16:50.52ID:F+2SAjcM
>>904
> かと言ってまだHaskellの標準として認められてない、GHCでしか使えない拡張使うのもどうなんという気もするし

まさかGHCの言語拡張はすべて使わないつもりですか？
せっかくの表現力が著しく落ちますよ。

今あるいは将来 GHC 以外のツールでコンパイルする計画があるのなら仕方ありませんが、
そうでなければ言語拡張の使用を躊躇する理由が見あたりません。

私なら、
・プログラムが意図した動きをし、
・かつソースコードが読みやすくなる
なら言語拡張を積極的に利用します。

意図通り動くけど可読性が落ちるなら、そこで初めて迷いますね。
0907デフォルトの名無しさん
垢版 |
2021/09/26(日) 07:18:33.81ID:m/60KM4j
Stack Overflow に面白い質問が投稿されていた。
要約すると return 1 getLine という式の型は Num t => t で、その値は 1 らしいんだが何で？ というもの。
質問者は勘違いして、何で return と getLine が互いに打ち消し合うのかと訊いていたが。
https://stackoverflow.com/questions/69325169/haskell-a-return-before-is-cancelled-out-by-a-monad-after-how

なかなか興味深い。
考えてみると haskell の理解がいっそう深まる。
0908デフォルトの名無しさん
垢版 |
2021/09/26(日) 19:38:43.50
最近並列処理を齧り始めました

ランダム値の生成にmwc-random パッケージの System.Random.MWC.createSystemRandom で生成した GenIO を、全体を通して利用する環境として Reader モナドに入れて使いまわしていたとします
ここにSTM で並列処理機能を新規に追加する場合、forkIO したスレッド内で一々そのスレッド専用に GenIO を生成し直すべきでしょうか？
というのは、それをしないと
各スレッドで共通の GenIO がコピーされ使用される場合、各スレッドで同じ値が生成されていってしまいランダムの意味をなさないのではないかと思うからです
ではこの疑似ランダム生成器を TVar に入れるかとなると、資源の取り合いになって、１スレッド時よりパフォーマンスが低下して元も子もないではないかという懸念があります
ここまで思考実験すると、やはり forkIO したスレッド毎に一々、その中で専用の疑似ランダム生成器を新調する必要があるという考えに至りました
スレッド数が多くなると疑似ランダム生成器を作るコストがバカにならなくなっていくでしょうが、その辺は頑張るしかないよということで、ぼくの考えは合っていますか？
0910デフォルトの名無しさん
垢版 |
2021/09/27(月) 16:47:57.85
>>909
実験してみたら、各スレッドで別の値が生成されていました
しかしドキュメント見ると It uses mutable state so same generator shouldn't be used from the different threads simultaneously.と書いてあるんですが
これはどう受け取ったらいいんですかね
各スレッドで別の値が生成されているなら用を為してる（ように思える）からいいじゃないかとも思うのですが
何か別の理由があって、そう思えてもやはり使うなという事なんでしょうか？
0912デフォルトの名無しさん
垢版 |
2021/09/27(月) 20:38:39.08ID:MDVYajz0
>>910
パフォーマンスの実験もね。
理論上パフォーマンスが落ちると分かっていても、実用上は問題ない場合も多い。
0914デフォルトの名無しさん
垢版 |
2021/09/30(木) 07:09:39.49ID:N1l0weLI
>>907
セミコロンを書かない言語ではすべからく改行直後に
(getLine)と書くとどうなるか問題が出てくる
0916デフォルトの名無しさん
垢版 |
2021/09/30(木) 09:22:48.41
>>911
具体的にどういうケースでどういう問題が起こるか解らないので、取り敢えずドキュメントにスレッド間で共有はやめろとある以上、大人しく従うことにします

>>912
STM版が、3950Xエコモードシングル500分の処理が30スレッド割り当てで220分くらいになりましたが
CPU使用率も75%前後で残念でした

競合するリソースが多過ぎたからではと思い、競合を避ける事を考えていると
そもそもSTMを使わず、スレッド毎にローカルにデータを貯めて処理して最後に各スレッドで部分的に仕上げたデータをChanで流して
、受信した側でデータを総括する、初歩的な方式を思いついたので書き換えました

getChanContentsを使いましたが、EOFみたいな最後の通知方法が判らずに、全スレッドの処理が終わりもう誰もデータを流すことのないチャネルから性懲りもなく読みだそうとしてしまい
例外が発生して困っていました
幸いスレッドの数は判っているのでチャネルからtakeする数をスレッド数ちょっきりとして切り上げた所、遅延評価が幸いしてその先を読もうとしなくなり例外は発生しなくなりました（本質的解決かは判りません）
これにより処理が18分で終わりました
スレッド毎にcreateSystemRandomするように書き換えると21分かかるようになりました
オーバヘッド込みでも500分かかっていた時代から驚異的な進化を遂げました

憧れだった Software Transactional Memory は期待程速くなくがっかりしました
STMは最初に検討するべきではなく、巧く競合が発生しないように書けないときの最後の手段なのかなと思いました
0917デフォルトの名無しさん
垢版 |
2021/09/30(木) 16:59:33.11ID:Ai6xyiAS
物理cpuが四つとかの擬似マルチスレッドではそんなに早くならないと思ってたけど、ものによってはそんなにも早くなるもんなんだな
0919デフォルトの名無しさん
垢版 |
2021/10/05(火) 23:20:55.55ID:75xrYyRf
>>907
型注釈してないのに、インスタンスとして関数モナドが選択されるのはどうしてですか？
getLineが影響していますか？
0920デフォルトの名無しさん
垢版 |
2021/10/06(水) 01:58:31.84ID:3ymQugFf
>>919
return 1 getLine は (return 1) getLine だから、
(return 1) が関数(a->b) じゃないと型が合わないんじゃないかな？
0921デフォルトの名無しさん
垢版 |
2021/10/06(水) 22:57:04.48ID:MRfRTuXd
関数モナドと同じように、引数一つ取るモナド作ったらambiguousって怒られるかなと思ったんだけど、コンストラクタ書かないとならないからうまくいかない。
この値は関数モナドにしか解決されないのかな
0923デフォルトの名無しさん
垢版 |
2021/10/17(日) 18:41:32.26ID:DQz0YbVB
なんｊでめんだこって言う女装子がhaskell勉強していてdao of functional programmingっていう海外の人が書いた文献がわかりやすいってことでそれ読んでいるらしいが
ここの人にもそれ読んでいる人いる？
0925デフォルトの名無しさん
垢版 |
2021/10/17(日) 20:37:14.39ID:DQz0YbVB
>>924
すまんリンク探させてしまってすまない
ワイが貼るべきやった
ワイは圏論わからないから読まずじまいだったわ
いつか圏論習得できたらその際に読もうかなって思ってる
0926デフォルトの名無しさん
垢版 |
2021/10/17(日) 21:08:39.75ID:LTEsEtXo
プログラミングの本質を学ぶには圏論について学ぶ必要があるということらしい
学んですぐ役立つというものではないようで、すぐ役立つ知識がお望みなら他をあたってくれ、とか
0927デフォルトの名無しさん
垢版 |
2021/10/17(日) 23:35:51.47ID:QqhGhKAl
見せてもらおうか、圏論とやらを。
0929デフォルトの名無しさん
垢版 |
2021/10/18(月) 02:49:04.06ID:mrfOLNSK
また圏論か
もういいよ
0932デフォルトの名無しさん
垢版 |
2021/10/22(金) 12:14:30.91ID:9P3eVRHd
Free monad とは何か？ の、シンプルかつ的を射た説明がsrackoverflowにあった。
(John Wiegley の回答)
https://stackoverflow.com/questions/13352205/what-are-free-monads

これを読んでから他の色んなFree monadの記事を読むと、すんなり理解できる。

これ、本質がよく解っている人の回答だよね。
こんな格好良く回答ができるよう精進したい。
0933デフォルトの名無しさん
垢版 |
2021/10/22(金) 21:20:57.92
UTF-8 のHaskell ソースコードに書き込んだ日本語文字列を通信先に渡す為に Shift_JIS の String にしたいのですが


module Main where

import Data.Text.ICU.Convert as ICU
import Data.Text as T
import Data.ByteString.Char8 as BS

main :: IO ()
main = do
　　conv <- open "Shift_JIS" Nothing
　　let
　　　　utf8txt = T.pack "皆は、赤ちゃんしゅきぃ？"
　　　　sjis_bs = fromUnicode conv utf8txt

この sjis_bs をどうしたら Shift_JIS の String になるんですか？
BS.unpack だと
ﾂ皆ﾂづ債、ﾂ静板つｿﾂづ｡ﾂづｱﾂつｵﾂづ｣ﾂつｫﾂつ｡ﾂ？
になってしまいます
0934デフォルトの名無しさん
垢版 |
2021/10/22(金) 23:18:21.74ID:5ielnrPe
haskellってpythonに影響与えてるんやな
どおりで雰囲気似てる感じするんか
0935デフォルトの名無しさん
垢版 |
2021/10/23(土) 01:09:52.51ID:o3xA5lbA
レイアウトと呼ばれるインデントスタイルは、Pythonが1991年に最初にリリースであり、85年以前にあった
Mirandaを参考に1990年にHaskellは登場したはず。
0936デフォルトの名無しさん
垢版 |
2021/10/29(金) 12:55:32.45ID:SqmTIce6
不動点演算子がわからなくて泣ける
再帰呼び出しになってないのに再帰になってるのはわかるんだけど
0938デフォルトの名無しさん
垢版 |
2021/10/29(金) 18:40:46.51ID:uCUCIWXe
>>937
なんでわかるんや？
才能か？
後不動点定理がわからん
勉強しろって言われてるけど
0939デフォルトの名無しさん
垢版 |
2021/10/29(金) 20:05:05.45ID:1mMf/Evz
遅延評価の才能がないと x = f x を思いつかないんだよな
y f = f (y f) しか分からない
0940デフォルトの名無しさん
垢版 |
2021/10/29(金) 21:04:54.17ID:ZN5Hp6rJ
>>936 の何もかもが、こちらには分からない。
愚痴を言いたいだけなのか、それとも何か質問をしたいのか。
後者なら、質問内容は何か。

>>938
> 後不動点定理がわからん
それだけなら、勉強してくださいとしか言いようがない。

勉強しろと言われているのなら、何か資料が配られたり、
参考文献が挙げられたりしていないのか？
そういうのが既にあるのなら、取りあえず全てに当たって、
今分かる部分と分からない部分を徹底的に細かく仕訳してみればいいのでは？
0941デフォルトの名無しさん
垢版 |
2021/11/05(金) 06:38:08.04ID:UB8UVAT8
>>936
分からないのは何故再帰処理してるのかじゃなくて（そこは定義的に明らかだし）、
どうして無限ループせずに終了するのかでいいのかな
0944デフォルトの名無しさん
垢版 |
2021/11/15(月) 02:14:35.96ID:jBQU3T8q
>>943
Applicativeクラスにpure関数があるから。
Monad則やApplicative則を満たしてるなら、
まず間違いなく pure = return だから片方で充分。

それにreturnって名前があまりに実態とかけ離れてるしね。
0945デフォルトの名無しさん
垢版 |
2021/11/15(月) 12:46:13.83ID:KyLp+2Ep
初歩的な質問ですが、複数の設定ファイル読み込みするのに
readFile で全体取得してから処理するのと
withFile で hGetLine しながら処理するのではどちらがいいとかありますか?
主に処理速度の点について聞きたいです。
0947デフォルトの名無しさん
垢版 |
2021/11/15(月) 21:51:56.85ID:NLyY6NK4
>>944
Applicativeにpureがあるのはなんで？
Monadのreturnだけにするのは変ですか？
零元がApplicativeの責務なのがピンときてないんです。Monadだと何と合わないんでしょう
0948デフォルトの名無しさん
垢版 |
2021/11/16(火) 02:22:00.49ID:EE8p/B0u
>>947
できるだけ一次情報に当たりましょう。
>>942 のリンク先の Planned: remove return from Monad の項目の
Proposal のリンク先を読んで下さい。
(更にその先の dudcusdion なども)
それが最も正確で、かつ、分かりやすいです。
0950デフォルトの名無しさん
垢版 |
2021/11/16(火) 22:40:31.75ID:t6DDIn3B
読んでみたけどよくわかんないなあ。AMPを満たすためにApplicative m => Monad mが必要ってことは書いてあるようだけど
Monadからreturnを削除して、pureに統一する理由って書いてあるかな？
読み飛ばしたかもしれんけど。

return = pureだから、統一しても同じっていうのは分かるんだけど、Applicativeにpureが必要な理由がわからない。
Applicativeの4つのルールを満たすためにpureが必要なことは、Applicativeの定義に書いてあるけど、圏論わかんないから、このルールが何で必要なのか分からん。

Monoidal Functor？とかいうやつの表現のために単位元(零元じゃなかったね)が必要なんだろうけど、圏論わからんないから分からん。

Monoidと関係あるんだろうか。それなら加法のために単位元が必要なのはわかるんだけど。
0952デフォルトの名無しさん
垢版 |
2021/11/17(水) 06:46:33.09ID:4zMdVbrs
より抽象度の高い方であるApplicativeのpureを生かすのは
私はごく自然に感じるけど

mappendと<>も機能的にダブってるから
将来Monoidからmappendが消えるよって
Monoidのドキュメントに書いてあるけど
もしかしてそれも疑問だったりする？

Semigroupの方から<>を消して、
Monoidのmappendを残すんじゃダメなの？ って
0953デフォルトの名無しさん
垢版 |
2021/11/17(水) 08:05:13.47ID:fLzDfeGp
>>950
圏論は一切関係なく、いかに誤りの無いプログラムが書けるか、
またソースコードが読みやすくなるかという実用的な理由です。
そういう観点でもう一度読んでみてください。

Haskellは実用的な汎用プログラミング言語であることを目指して作られました。
なので、今回のような理由での提案は個人的にはすごく納得できるし、大賛成です。
0954デフォルトの名無しさん
垢版 |
2021/11/17(水) 12:44:32.78ID:f9gix7Cx
コメントありがとです。
Semigroupは半群、Monoidは単位元付きの半群ですよね。
言われてみると、<>に統一してmappendは消しても自然な気がする。
すごいHでログ文字列がmappendで追加されていく、サンプルを読んだことがあるので、Monoidは受け入れやすいんです。
Semigroupに単位元がないことは不思議に思わないです。半群というものを聞いたことがあったのと、
ログの例に戻ると、文字列なしのログはありえないと考えれば、単位元がないMonoidがあってもあまり不思議に思わないです。

言ってることが上と変わってきてるかもしれないですが、Applicativeが不思議に思うのは、ここに単位元？(というか単位元を生成する)pureがあること。
Applicativeの結合<*>って持ち上げられた型だけで構成されてます: f (a -> b) -> f a -> f b。
圏論何も知らないで言いますが、単位元pureは持ち上げられた型f aが自然な気がするんです。a -> f aではなく。
雰囲気でそう感じてるだけですが。

そんでもって、a -> f aが登場するのって、Monad.(>>=)だよなあってことで、だったら、returnがMonadにあるのは自然なんじゃないかな、と思うわけです。
そうすると、pureってなんのためにあるんだろう。同じ型ならMonadだけあるほうが自然だなと感じたわけです。

たぶんこれは圏論を知っていれば、変に思わないのかなと思って、そう言ったわけです。
推敲できてない感ありますが、伝わりますかね？
0955デフォルトの名無しさん
垢版 |
2021/11/17(水) 12:50:22.84ID:f9gix7Cx
ちなみに自分は、自分の価値観に反してるから却下すべきだと言ってるのではなくて、
どうしてこういう構造が正しいの？実際の理論やコードでの利用例に照らしてどんな利点や意味があるのと知りたいだけです。
0956デフォルトの名無しさん
垢版 |
2021/11/17(水) 15:59:19.97ID:oGkdvxh0
そもそもapplicativeなるものが数学の圏論的に何意味するかよくわからんのだよな
monadの方はwikiのmonad (category theory)の項があってキッチリ解説されてるし

https://en.m.wikipedia.org/wiki/Monad_(category_theory)

Tがcategory C上のmonadであるときfmap Tをμ｡η_Tで定めればコレがfunctor C→Cを定義するのもわかるんだけど、applicativeについておんなじような解説が中々見当たらない
どっかでDescartes closed categoryがどうたらいうのを見た事あるんだけど誰か知りません？
0959デフォルトの名無しさん
垢版 |
2021/11/30(火) 20:23:52.94ID:SegqCGCa
haskell勉強しようかなって思ってるんですけどおすすめ書籍ってなにかありませんか？
ちなみにocamlでプログラム書いたことあります
型システム入門を原文で7割ほど読破しました
ちなみに大学受験の数学はそこそこ自信あります
一階述語論理の記号扱って解いていました
圏論の知識はありません
0960デフォルトの名無しさん
垢版 |
2021/11/30(火) 20:27:04.88ID:SegqCGCa
ちなみにモナドは日本語版wikipediaの記事を読んだのみです
型クラスはわかります
MaybeまではわかりましたがIOモナドで躓きました
ocamlとは違って参照型がない言語だってことは意外に思いました
0961デフォルトの名無しさん
垢版 |
2021/12/02(木) 00:19:03.82ID:c82IwjxK
(>>=)がただのデータコンストラクタだったらモナドはただの構文木なのに

data M b = Bind (M a) (a -> M b) | ...

みたいな定義ができない型システムだから
代数的データ型を使わないでラムダをたくさん使うことになってみんな躓く
0962デフォルトの名無しさん
垢版 |
2021/12/02(木) 13:13:42.19ID:kpMV/tat
そりゃそうやろ？
データコンストラクタと展開されるべき関数の違いをプログラマが指定しなければ処理系は与えられたexpressionをどこまで展開すべきか決定できんやろ？
0963デフォルトの名無しさん
垢版 |
2021/12/02(木) 14:49:59.14ID:ISSe07L0
>>959
Haskellを始める前に仕入れたそのような知識やOCamlの経験が、
Haskellの学習にいったいどんな影響を与えるのか、
楽にするのか、それとも邪魔にしかならないのか、正直まったく分からん。
Haskellで何をしたいのか、目的や目標も分からんし。

なので、Haskell入門者という観点だけで次の2点をすすめる。

さっと要点を学んで早くアプリを作り始めたいのなら、薄い入門書で十分。
「Learn You a Haskell for Great Good!」
が良いと思う。

ガッツリ学びたい、かつ、時間と根気があるのなら、
「Haskell Programming from first principles」
がおすすめ。

詳しくはどちらも公式サイトを参照して。

なにで学習するにしても、手や頭を動かす(プログラミングする)のが主で、
本やドキュメントを読むのは従であることを忘れずに。
0964デフォルトの名無しさん
垢版 |
2021/12/02(木) 17:56:37.45ID:35Q5ApkZ
>>963
すみません
関数型言語って敷居が高そうなイメージあってやるにはある程度数学の素養が求められるのかなって思っていろいろ自分なりの知識があるところ挙げてみました
特に型システム入門は型推論の理論とか分かっていたほうがいいのかなと思って読んでいました
まずはLearn youの方を読んで見ようと思います
ありがとうございました
0965デフォルトの名無しさん
垢版 |
2021/12/02(木) 20:33:40.95ID:c82IwjxK
>>962
ただし、IOモナドは「展開」できない方がいい
そうすれば処理系がexpressionをどれだけ「展開」しても副作用がない
0968デフォルトの名無しさん
垢版 |
2021/12/14(火) 12:34:07.62ID:iFoIKYew
IQ145の人？
0969デフォルトの名無しさん
垢版 |
2021/12/14(火) 12:57:57.79ID:IE9oyXDX
>>968
よく覚えてるな
最近はkensmoothってアカウントを連番で取得して、ネトウヨムーブを連発してたんだけど全部凍結されて今のアカウントになってる
あのネトウヨ投稿はなんだったんだろう
0971デフォルトの名無しさん
垢版 |
2021/12/14(火) 17:39:35.08ID:iFoIKYew
>>966
なにこの一覧
0972デフォルトの名無しさん
垢版 |
2021/12/14(火) 18:35:50.33ID:SgMFGeMD
岡部健、Twitter再開してたのねw
Newbieとはご無沙汰してたから知らんかったわw
0973デフォルトの名無しさん
垢版 |
2021/12/14(火) 19:46:12.10ID:oL+i1N1M
ツイッター再開おめでとうございます！
来年はべーやんの年になる！
と良いですね！
0976デフォルトの名無しさん
垢版 |
2021/12/14(火) 22:22:42.89ID:oL+i1N1M
べーやんは論客なんだな。
0978デフォルトの名無しさん
垢版 |
2021/12/14(火) 22:53:00.93ID:oL+i1N1M
たまたまでは？
0979デフォルトの名無しさん
垢版 |
2021/12/14(火) 23:06:41.51ID:dwtzMOq3
Quoraでいろいろ回答しているがモナドの解説は見事だぞ
0981デフォルトの名無しさん
垢版 |
2021/12/14(火) 23:42:04.31ID:iFoIKYew
>>979
ハラデイ
0982デフォルトの名無しさん
垢版 |
2021/12/15(水) 00:16:47.05ID:Xb4w9/yA
「モナドについて学んでいるのですが、mapやflatMapは圏論ではどの概念にあたるのですか？」
具体的に例示していてわかりやすい。
0983にしやま@大阪大学
垢版 |
2021/12/15(水) 07:25:32.70ID:/l12wr0Z
嘘つきケンちゃん、相変わらずですねww
久々にわたくしも腹筋がミシミシと鍛えられました
しばらくわたくしも加勢いたします
0984デフォルトの名無しさん
垢版 |
2021/12/15(水) 08:55:33.56ID:fP8nqGj3
Hugs> take 10 fibs where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
[0,1,1,2,3,5,8,13,21,34]

GHCi
Prelude> take 10 fibs where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
<interactive>:6:14: error: parse error on input ‘where’
言語仕様が微妙に異なる？

オレメモ、バッチファイル
stack ghci
を目的のディレクトリ下(例、e:\haskell)に作ってディスクトップにはバッチファイルへのリンクを作っておくと
ghci起動後カーソルが消えない

貴重なHaskellスレがもう過ぐ1000行く
0985デフォルトの名無しさん
垢版 |
2021/12/15(水) 10:41:42.68ID:BDga5vqT
>>966
ぎゃっはっはっはっは
0986デフォルトの名無しさん
垢版 |
2021/12/16(木) 08:29:00.48ID:kVJbCKwy
令和の時代に毛の壁ふたたび
0987デフォルトの名無しさん
垢版 |
2021/12/16(木) 21:29:13.60ID:k4b05O9+
自分でキャラ演出してるだろ
0988デフォルトの名無しさん
垢版 |
2021/12/16(木) 21:38:27.93ID:Y2CVy/MB
https://togetter.com/li/773846
ちょまど氏が首突っ込んでるけど、社名背負ってよくこんな書き込み出来るもんだと、驚いた。
0989デフォルトの名無しさん
垢版 |
2021/12/16(木) 21:46:42.96ID:OBc86cw8
他の人も叩いているから便乗して死体蹴りしようか的な精神が見て取れる
0991デフォルトの名無しさん
垢版 |
2021/12/16(木) 21:55:47.51ID:Y2CVy/MB
それはマイクロソフト社の公式見解ですか？って突っ込み入れて欲しいわ。
0992デフォルトの名無しさん
垢版 |
2021/12/16(木) 22:06:47.71ID:Y2CVy/MB
教祖だの洗脳だの言いがかりも甚だしいし、「学術的な真理ではないし」云々という自身の書き込みがそのままブーメランだと思うけど。
これを社名背負ってやるんだから頭おかしいわ。
0993デフォルトの名無しさん
垢版 |
2021/12/16(木) 22:08:34.93ID:OBc86cw8
誰か次スレ立てろよ
0994デフォルトの名無しさん
垢版 |
2021/12/16(木) 22:42:52.47ID:k4b05O9+
結局モナドってなんなのかわからんということにすべて起因してる希ガス
話題になってからもう二十年くらい立つのに結論でないし、数学者でもない限り一生わからんのだろうな
0995デフォルトの名無しさん
垢版 |
2021/12/17(金) 13:01:29.30ID:NPioGyUL
新スレを立てました。当スレ(Part33)が埋まってからの利用をお願いします。

関数型プログラミング言語Haskell Part34
https://mevius.5ch.net/test/read.cgi/tech/1639713446/
0996デフォルトの名無しさん
垢版 |
2021/12/18(土) 00:42:46.36ID:om0zr0Am
>>994
結論だせる個人は存在するけど
組織になるとなぜか、結論だせない奴が代表者を気取ってるだけじゃん
0997デフォルトの名無しさん
垢版 |
2021/12/18(土) 11:05:05.98ID:1fj0JYV9
>>996
結論出せる個人て岡部氏のことっしょ？
そういう勢いでどうこうじゃなくって皆を納得させるような結論はないっていうこと
0998デフォルトの名無しさん
垢版 |
2021/12/18(土) 11:23:52.39ID:9ehaErM5
納得が遅い
1000デフォルトの名無しさん
垢版 |
2021/12/20(月) 09:52:54.51ID:ZumN5JOf
また誹謗中傷してるので通報よろ
10011001
垢版 |
Over 1000Thread
このスレッドは１０００を超えました。
新しいスレッドを立ててください。
life time: 678日 15時間 35分 18秒
10021002
垢版 |
Over 1000Thread
5ちゃんねるの運営はプレミアム会員の皆さまに支えられています。
運営にご協力お願いいたします。


───────────────────
《プレミアム会員の主な特典》
★ 5ちゃんねる専用ブラウザからの広告除去
★ 5ちゃんねるの過去ログを取得
★ 書き込み規制の緩和
───────────────────

会員登録には個人情報は一切必要ありません。
月300円から匿名でご購入いただけます。

▼ プレミアム会員登録はこちら ▼
https://premium.5ch.net/

▼ 浪人ログインはこちら ▼
https://login.5ch.net/login.php
レス数が1000を超えています。これ以上書き込みはできません。
ニューススポーツなんでも実況