Rust part26

レス数が1000を超えています。これ以上書き込みはできません。
1デフォルトの名無しさん
垢版 |
2024/09/20(金) 22:18:38.38ID:c48cFuZJ
公式
https://www.rust-lang.org/
https://blog.rust-lang.org/
https://github.com/rust-lang/rust

公式ドキュメント
https://www.rust-lang.org/learn

Web上の実行環境
https://play.rust-lang.org

※Rustを学びたい人はまず最初に公式のThe Bookを読むこと
https://doc.rust-lang.org/book/

※Rustを学ぶ際に犯しがちな12の過ち
https://dystroy.org/blog/how-not-to-learn-rust

※Rustのasyncについて知りたければ「async-book」は必読
https://rust-lang.github.io/async-book/

※次スレは原則>>980が立てること

前スレ
Rust part25
https://mevius.5ch.net/test/read.cgi/tech/1722354386/

ワッチョイスレ
プログラミング言語 Rust 4【ワッチョイ】
https://mevius.5ch.net/test/read.cgi/tech/1514107621/
2デフォルトの名無しさん
垢版 |
2024/09/20(金) 22:19:18.10ID:c48cFuZJ
Rust The Book (日本語版)
https://doc.rust-jp.rs/book-ja/
Rust edition guide (日本語版)
https://doc.rust-jp.rs/edition-guide/
Rust by example (日本語版)
https://doc.rust-jp.rs/rust-by-example-ja/
Rust cookbook (日本語版)
https://uma0317.github.io/rust-cookbook-ja/
Rust API guideline (日本語版)
https://sinkuu.github.io/api-guidelines/
Rust nomicon book (日本語版)
https://doc.rust-jp.rs/rust-nomicon-ja/
Rust async book (日本語版)
https://async-book-ja.netlify.app/
Rust WASM book (日本語版)
https://moshg.github.io/rustwasm-book-ja/
Rust embeded book (日本語版)
https://tomoyuki-nakabayashi.github.io/book/
Rust enbeded discovery (日本語版)
https://tomoyuki-nakabayashi.github.io/discovery/
Rust Design Patterns (日本語版)
https://qiita.com/Yappii_111/items/4ccc3a8461cdd4035651
https://qiita.com/Yappii_111/items/654717e6a6a980722189
Rust API guideline (日本語版)
https://sinkuu.github.io/api-guidelines/
3デフォルトの名無しさん
垢版 |
2024/09/20(金) 22:22:15.11ID:c48cFuZJ
Rust Reference Book
https://doc.rust-lang.org/reference/
Rust Standard Library
https://doc.rust-lang.org/std/
Rust rustc Book
https://doc.rust-lang.org/rustc/
Rust rustdoc Book
https://doc.rust-lang.org/rustdoc/
Rust rustup Book
https://rust-lang.github.io/rustup/
Rust Cargo Book
https://doc.rust-lang.org/cargo/
Rust unstable Book
https://doc.rust-lang.org/nightly/unstable-book/
Rust macro Book
https://danielkeep.github.io/tlborm/book/
Rust CLI (Command Line Interface) apps Book
https://rust-cli.github.io/book/
Rust Future Book
https://cfsamson.github.io/books-futures-explained/
Rust async-std Book
https://book.async.rs/
Rust tokio Book
https://tokio.rs/tokio/tutorial
Rust serde Book
https://serde.rs/
Rust Performance Book
https://nnethercote.github.io/perf-book/
4sage
垢版 |
2024/09/21(土) 06:46:43.45ID:C8ZSf1Mw
>>1
O2
2024/09/21(土) 10:38:37.60ID:LGjZocUf
アンチの人はRustスレの邪魔をせずに
こちらへどうぞ

Rustアンチスレ
https://mevius.5ch.net/test/read.cgi/tech/1509028624/
6デフォルトの名無しさん
垢版 |
2024/09/21(土) 11:45:15.28ID:FOWjpCKL
変な質問かもしれないけどRustでもUMLのクラス図みたいなものって有効?
必要なケースとしては、プログラムの設計を他者と共有する必要があり、かつ相手は時間をとってコードを詳細に読むわけでなないという場合

今どきUMLという感じかもしれないけど、社内の他のプロジェクトではUMLを (常にではなく、必要に応じて時々) 使っている
Rustのプロジェクトでもこれを求められた場合にどう対応すれば良いのか
型同士の関係 (1対多などの数量関係や呼び出し関係) を説明するくらいはできるけど、継承などオブジェクト指向を意識したところがあるから、Rustのコードの設計を説明するのに必ずしも向かない気もする
こういう、設計を共有するのってみんなどうしてる?
2024/09/21(土) 12:11:46.71ID:3vskc6nv
>>6
トレイトをインターフェイスとみなせば (わかりやすいかどうかは置いといて) 一応は成立すると思う。
だけどそういう図を見るくらいなら cargo doc を読んでいくほうがわかりやすいんじゃないかなぁ。
UML が有用なのはシーケンス図とか、抽象度の高い用途のほうでしょ。
8デフォルトの名無しさん
垢版 |
2024/09/21(土) 12:37:38.28ID:FOWjpCKL
開発者が相手ならCargo docは有効だと思う
だけど、説明したいのは構造体やメソッドの使い方じゃなくて、ドメイン側のロジックが適切な型として表現されてるか、それに抜け漏れがないかといった点
それを視覚的に示せるということでクラス図を例に出した
相手はRustのコードに直接触れるわけではないけど、ドメイン側の知識を持ってて、そういう観点からのレビューをしたいという場面

書いてて思ったけど、Rustのenumで表現されてる型がやや表現しづらい?
OOPだとICommandのようなインタフェースを継承させてたけど、その代わりにenum Command にしてるケース
UMLに合うようにRust側のコードをトレイトを使って書き直すのも本末転倒な感じがする
2024/09/21(土) 12:53:36.90ID:3vskc6nv
>>8
プログラムとしての合理性とドメイン側のロジックがそれほど一致しないのは普通のことなのでそういう形でレビューする事例は全然聞いたことないな。
特に専門的でプログラマの理解が追っつかないレベルだとドメイン側のロジックに忠実にやるしかないのだろうけど……。
2024/09/21(土) 13:19:40.34ID:EbQ+iJJK
経験的にRustの構造体はデータベース設計のER図が合いそう
ライフタイムの関係で
・構造体のDrop≒レコードのdelete
・参照≒行ロック
みたいなイメージがしやすくて実装とのギャップを減らせると思う
enumはER図だとsubtypeに相当する
2024/09/21(土) 13:46:07.48ID:MXmAIymZ
テンプレートメタプログラミングに対応してないなら、C++ですら使えないと思う
2024/09/21(土) 14:16:16.53ID:EbQ+iJJK
メタコードでも最終的に具現化されるから大丈夫でしょ
メタの部分はメタのままモデル化しとけばいい
2024/09/21(土) 15:26:24.58ID:WvtGOXLQ
>>6
自分も相手もUMLに慣れてるのならUML使えばいいと思う
リバースエンジニアリングで図を書くのでなければ別に困らない

>>8
>Rustのenumで表現されてる型がやや表現しづらい?
<<enum>>や<<enumeration>>のマーカーをつけるだけ
2024/09/21(土) 16:07:13.97ID:6ZRew6VN
VS CODEとrust-anlayzerでrustを書いてるんだけど、
if文を1行でこう書きたいんだけど、自動整形で改行されちゃうんだけど、↓を許容する設定の仕方知っている人いたら教えて~
if 1 == 1 { true } else { false }
2024/09/21(土) 16:47:05.18ID:LGjZocUf
rustfmtを使って整形しているのならば
#[rustfmt::skip]
2024/09/21(土) 16:52:58.13ID:EbQ+iJJK
(if 1 == 1 { true } else { false })
let foo = if 1 == 1 { true } else { false };
みたいにカッコで囲むかletで値を受けるならrustfmtのsingle_line_if_else_max_widthが効きそうだけど
裸のifだと設定では無理かも

#[rustfmt::skip]
if 1 == 1 { true } else { false };
でskipするしかない

rustfmtの設定はrustfmt.toml(Cargo.tomlと同じ場所)で
single_line_if_else_max_width = 80
とか書けばいい
参考:github.com/rust-lang/rustfmt/blob/master/Configurations.md
2024/09/21(土) 17:16:34.53ID:MXmAIymZ
設計図と実物のギャップに比べたら改行がちょっと多い程度の差は
人体に無害だ
だが科学的に無害だとしても人の機嫌を損ねることは許されない
2024/09/21(土) 18:16:59.29ID:3vskc6nv
>>14
短絡評価込みだとこれと同一になるはず。
1==1 && true || false;

この形でも長くなりすぎると改行されちゃうけどね。
2024/09/21(土) 18:24:23.07ID:mSwTwwna
>>18
それ結果がboolのとき限定だし流石に……

(1 == 1).then(|| true).unwrap_or_else(|| false)

うーん、ないな
2024/09/21(土) 19:05:43.59ID:wwpfBAxB
boolならif else必要ないやろ
2024/09/21(土) 19:52:13.10ID:shE6x/5+
trueのときの値,falseのときの値って意味で書いてんじゃねえかな
2024/09/21(土) 20:44:43.28ID:6ZRew6VN
>>15
>>16
ありがとう。やっぱり無理かー
InteliJ Ideaではできたのにな。RustRoverはまだ発展途上だし
Zedに期待したいけど、どこまでできるのか

>>21
そういうことです。とはいえbool限定で別の1行書き方があるとしても↓の書き方を1行に整形してほしいということで

> if 1 == 1 { true } else { false }
2024/09/21(土) 22:18:19.38ID:bd1za6rG
>>9
それを一致させるように努力するのが本来のDDDよ
それを放棄したプロジェクトはいわゆる軽量DDDというアンチパターン
2024/09/21(土) 22:31:50.56ID:klppfUZq
>>21
マジかよ
そんな書き方したらあかんやろw
2024/09/21(土) 22:52:39.16ID:MXmAIymZ
逆に、一致しないように努力させられるのが特許とか知財か
どっちも嫌な努力
2024/09/22(日) 11:14:51.14ID:xF9HTLBc
どちらの書き方が簡潔に分かりやすいですか?

let result = match () {
_ if 場合1 => 値1,
_ if 場合2 => 値2,
_ if 場合3 => 値3,
_ if 場合4 => 値4,
_ if 場合5 => 値5,
_ => 値その他,
};

let result = if 場合1 {
値1
} else if 場合2 {
値2
} else if 場合3 {
値3
} else if 場合4 {
値4
} else if 場合5 {
値5
} else {
値その他
};
27デフォルトの名無しさん
垢版 |
2024/09/22(日) 11:48:01.54ID:PvCJsxAv
そのifの判定内容はマッチで扱えないものという認識で良い?
例えば値の範囲なら以下のように書く
let b = match(a) {
 // x if x < 0 とも書けるけど冗長
 ..0 => "nagative",
 0..10 => "small",
 _ => "many",
}

ifが必要なら、個人的には「その分岐が変数の値に応じて決まる」という意味合いが強ければmatchを、そうでないならifを使う
元のレスだとmatchに渡すものが空だけど、これが単にレスする際に省略したものでなく本当に () をmatchさせようとしてるなら、ifの方が分かりやすいと思う
2024/09/22(日) 12:58:59.11ID:/54VtYWL
だね
条件の中身次第
2024/09/22(日) 13:05:19.87ID:ZXycigsN
>>26
matchが短く見やすく可読性も良いかな
並んで順に判定することもわかりやすい
2024/09/22(日) 13:13:51.09ID:/54VtYWL
内容次第では条件と値のセットを辞書的なもの(BtreeMapやArray)で管理する形にすることもよくある
2024/09/22(日) 15:11:30.55ID:qDPlQN9o
複おじ君 Rust を 2 年かそこらやっててまだこんなことにこだわってるの
2024/09/22(日) 15:20:32.79ID:m7FeuQS9
たとえば、動的にメソッドを定義するコードが
どこにも書かれていないことを確認するためにソースコード全体を読む必要はほとんど無いが
妙な書き方をすればそれが必要になる
2024/09/22(日) 15:36:11.10ID:btdG9v7k
でその妙な書き方かどうかはどうやって判定すんの
2024/09/22(日) 16:08:33.07ID:m7FeuQS9
正しくないかもしれない値段で物を売り買いする自由があるんだから
うっかり正しくない判定をしても大して問題ないよね
2024/09/22(日) 16:16:50.01ID:btdG9v7k
こう簡単に矛盾すること書けるやつのソースコード見てみたいわ
36デフォルトの名無しさん
垢版 |
2024/09/22(日) 19:42:13.27ID:H8Oyc8fk
矛盾したコードを書いた時、Rustなら検知してくれる
2024/09/22(日) 20:01:27.84ID:yQGPuEok
コンパイラのレイヤーしか頭に無いバカ
38デフォルトの名無しさん
垢版 |
2024/09/22(日) 22:58:14.23ID:e8rvHKs3
コスプレイヤーのケツしか頭に無い
2024/09/23(月) 00:01:32.19ID:oQXZb2Vk
リスクを取るとか失敗を恐れないことと、矛盾を限りなくゼロに近づけることって
相性悪いよな
2024/09/23(月) 00:43:24.10ID:PF2EKTHS
ポエ味が過ぎる
2024/09/23(月) 05:09:03.45ID:oQXZb2Vk
そのレベルの判定基準で売ったり買ったりキャンセルする自由がある
2024/09/29(日) 17:53:03.81ID:sipqHiuG
全然普及してないね
誰が使ってんの?
2024/09/29(日) 18:08:13.96ID:qvWHVENG
https://response.jp/article/2024/08/08/385006.html
ドイツのVectorとHighTec EDV-Systemeは、RustアプリケーションとCベースのAUTOSAR Classic基本ソフトウェアの統合に成功した、と発表した。
これにより、自動車業界でのプログラミング言語「Rust」使用における最後の障害が取り除かれたという。
2024/09/29(日) 18:13:50.86ID:tjPAZIUB
トヨタもRust技術者を募集してるね
2024/09/29(日) 22:22:20.01ID:KrHhoDGX
「The Rust Foundation」は、人命や財産に関わるような安全性が決定的に重要になるシステムのために、
Rust言語を責任を持ってサポートするためのコンソーシアム「Safety-Critical Rust Consortium」の設立を発表しました。
設立には日本からWoven by Toyotaが参加
46デフォルトの名無しさん
垢版 |
2024/09/30(月) 04:31:41.35ID:MBUAekwy
Rustは良い言語だと思うけど
> 人命や財産に関わるような安全性が決定的に重要になるシステム
に効果的なのかはやや疑問

自動運転は詳しくないから財産の方で書くけど、例えばみずほ銀行のシステム障害や仮想通貨取引所からのコインの流出といった問題はRustだと防げてたか?というとそんなことはないと思う
プログラム上のバグは防ぎやすくなるけど、仕様策定時の想定不足や運用の問題までは防げない
2024/09/30(月) 07:15:29.93ID:2iAXb7P5
プログラム上のバグを防ぎたいと思うからこそ
MISRA C みたいなルール作ってチェックしてるわけで
それを言語仕様で防げるRustを使いたいというのは当然だと思うけど
仕様バグが防げないからといって他のバグも入ってよいわけではない
2024/09/30(月) 07:34:00.91ID:ZUdMvCYc
>>46
プログラミング言語がカバーしない領域の問題を持ち出して来て「Rustはこの問題を防げない!」と主張するバカがときどき現れる
頭が弱いんだろうな
2024/09/30(月) 08:45:28.66ID:awlfHXQ+
>>48
そういう領域をわざと曖昧にして騙す詐欺師もいるからなんとも。
2024/09/30(月) 09:16:22.72ID:V027xTjy
ああ、>>42みたいなのって定期的に現れてたけどこれも例のネタ振りだったのか
終わりやなあ
2024/09/30(月) 10:02:54.61ID:ZUdMvCYc
>>49
プログラミング言語ではカバーできない領域の問題をわざわざ出して来て
「Rustはこの問題を防げない!」と主張するのが詐欺師
他の言語でも防げないのだからRustにおける問題ではない
52デフォルトの名無しさん
垢版 |
2024/09/30(月) 10:32:26.16ID:6dAxEhDV
>>46
言語機能からくるバグと仕様のバグを区別できてなさそう
2024/09/30(月) 10:54:40.07ID:UCbUt9Ji
Rustで他国の技術者を疲弊させる作戦なのかもな
2024/09/30(月) 11:04:51.09ID:SMM9cNDM
たしかにTesla/SpaceXが言語選択を前面に出して安全性アピールしたこと無いな
55デフォルトの名無しさん
垢版 |
2024/09/30(月) 11:30:05.30ID:EGgxkIqY
言語を全面に出してアピールするのは使える言語しかアピールするものがないカスだけ
他にアピールするものがある人はそっちをアピールする
言語は乗り換える時はしれっと乗り換える
2024/09/30(月) 11:36:23.02ID:t+tf/aOj
TeslaもSpaceXもRustエンジニア結構募集してるから社内ではしれっと使ってるんだろう
2024/09/30(月) 11:51:09.07ID:i18xvUH/
そだねTesla公式ではなさそうだから小規模だったのかと

今の自動運転関係はc/c++/python見たい
Experience programming C/C++ software, including modern C/C++ (C++14/17/20)
Write fleet queries and Python scripts to source new datasets
2024/09/30(月) 12:28:38.91ID:gLA7Cs9H
自分の人生が上手く行かないことを何もかもC++のせいにしてる人がいる気がするよ。
他者を批判することは誰でも簡単に出来るから。
2024/09/30(月) 12:33:20.09ID:bcszdPho
SOの愛され言語がまさにその通りで普及している言語は憎まれ役
逆もしかり
2024/09/30(月) 12:41:53.28ID:mH6ZmITw
Teslaの様な近視眼的な利益優先の成長企業は次世代言語投資なんてギャンブルしないでしょ
2024/09/30(月) 15:25:54.70ID:v3grkyeY
言語に詳しいことを技術力と勘違いしてるやついるよな
そんなの大した価値ないから
2024/09/30(月) 16:37:10.99ID:wQrzuM5L
そろそろポエム来そう
63デフォルトの名無しさん
垢版 |
2024/09/30(月) 18:16:36.18ID:Kh4w53R0
>>61
Ruby検定ぇ…
2024/09/30(月) 19:11:24.24ID:pFl0L+A9
>>43のRustから基本ソフトウェアが使えるようになったAUTOSARはテスラ以外の各国の自動車メーカー・部品メーカー・ソフトウェア会社などによって成り立っている
2024/09/30(月) 19:30:44.32ID:aeg7B5kC
ポエム来たw
2024/09/30(月) 19:40:13.57ID:V027xTjy
全部ポエムだろ
67デフォルトの名無しさん
垢版 |
2024/09/30(月) 21:02:02.50ID:ELpL9+R5
そろそろポエム来そう


……


ポエム来たw
68デフォルトの名無しさん
垢版 |
2024/09/30(月) 21:05:21.65ID:MBUAekwy
>>52
その違いを区別した上で「現実の問題は仕様や運用から来るものも多く、それについてRustは他の言語以上の力を発揮するものではない」と書いてるんだが
2024/09/30(月) 21:15:05.58ID:ZUdMvCYc
プログラミング言語でカバーできない領域の話をこのプログラミング板で議論しても無意味
一方でその問題のうち言語でカバーする領域の話については反論もないことから様々な点でRustが最善なのだろう
70デフォルトの名無しさん
垢版 |
2024/09/30(月) 21:51:49.87ID:Luv3/LPz
「様々な点」というならそれこそプロジェクトの特性によるだろ
研究者がPythonを使うのや大規模プロジェクトでC#やJavaを使うのだって、それぞれ理由があるわけで
2024/09/30(月) 22:09:35.06ID:SVrZ1+QI
>>69
>プログラミング言語でカバーできない領域の話をこのプログラミング板で議論しても無意味
プログラミング板はプログラミング言語板ではないのだよ、複トン君。
2024/09/30(月) 22:28:02.74ID:pFl0L+A9
>>70
今回の件のプロジェクトは「人命や財産に関わるような安全性が決定的に重要になるシステムのため」と明記化されているので
もしRustより相応しい言語があるならば、その言語と根拠を参加しているトヨタやIT企業たちに教えてあげればいいんじゃないかな
73デフォルトの名無しさん
垢版 |
2024/09/30(月) 22:37:41.53ID:Luv3/LPz
まず「最も良い言語」というものがあるという考え自体が幻想だと思うぞ
だから自分はRustより良い言語があるだなんて言わない
言語に限らず技術選定というもの全般に言えるけど、それはそれぞれのチームやプロジェクトにおいて判断すべきものであって、言語が先に来るものではない
2024/09/30(月) 22:48:21.43ID:ZUdMvCYc
>>73
それはおかしい
現状Rustが最善であると言語が先に来た上で、足りない所があれば改善や補強などしていくコンソーシアムだぞ
少なくとも言語については他を検討しようにもまともな言語がない
2024/09/30(月) 23:03:53.20ID:JxqgGnHQ
幻想なのは当たり前。
その上で The Rust Foundation は Rsut がベストだという「ことにする」という前提を置いてる。
やってみて駄目だったら前提が間違ってることがわかるだけだ。

やる前にわかるなら苦労しないよ。
比較的マシそうなものでやってみて成功したり失敗するのが進歩ってものだろ。
2024/09/30(月) 23:07:52.86ID:pFl0L+A9
>>73
その技術選定をした各企業がRustに対して人とお金を出すプロジェクトなのだから言語が先に来るのは当たり前じゃないかな
目的も明確になっているプロジェクトだからもしRustより相応しい言語があるならば各企業に理由と共に教えてあげればいいんじゃないかな
2024/10/01(火) 00:52:01.25ID:4qcfGokc
みんな複おじと遊ぶのが大好きなんだねえ
78デフォルトの名無しさん
垢版 |
2024/10/02(水) 10:16:15.34ID:XbzwGALZ
境界値検査しない言語が境界値検査する言語より遅い訳が無い
2024/10/02(水) 12:09:34.85ID:rIuWzLtH
>>78
ロジハラ禁止
2024/10/02(水) 18:27:24.18ID:k2dgX62+
>>78
RustとCやC++の速度比較するベンチマークテストは
全く当てにならない。
実験すれば全て正しいということにはならない。
なぜなら、実験というものは実験条件を整える
のにその科学現象の深い理解が必要であり、
その条件で測定したこと自体は正しくても、
それが本当に知りたいことを測定しているとは
限らないから。
2024/10/02(水) 18:29:04.37ID:k2dgX62+
>>80
あくまでも、細かい条件まで含めて完全にその条件で
実験するとその結果が得られた、というだけであり、
「その言語におけるある目的Aを達成するための速度」
を表しているとは限らないから。
2024/10/02(水) 18:31:40.53ID:k2dgX62+
実験しなくても、最適化で差が付く以外ではC言語が
最速である、とい事は理屈からも分かっている。
これも理解するためには数式を使った論理を正確
に理解する必要が有り、大体の勘で言っている
ようなことではない。
2024/10/02(水) 18:31:41.82ID:k2dgX62+
実験しなくても、最適化で差が付く以外ではC言語が
最速である、とい事は理屈からも分かっている。
これも理解するためには数式を使った論理を正確
に理解する必要が有り、大体の勘で言っている
ようなことではない。
84デフォルトの名無しさん
垢版 |
2024/10/02(水) 20:34:56.49ID:192UGWkp
C++でいう非型テンプレートってRustでできる?
std::array<int, 4> の4の箇所のように、型ではなく数値や文字列をジェネリクスに使うやつ

Rustでも配列はコンパイル時にサイズが決まるし、似たような仕組みはありそうに思えるんだけど、見つからなくて
ジェネリクス型の中に配列を持たせるなら Vec などの可変サイズ型が必須?
2024/10/02(水) 21:02:06.37ID:qmniBqed
>>84
だいぶん前から出来るよ。
const キーワードを使う。
https://doc.rust-lang.org/reference/items/generics.html
ただ、現在の C++ よりは制限がきつい。
86デフォルトの名無しさん
垢版 |
2024/10/02(水) 21:08:54.46ID:AFS53MaU
>>81
横からだけど、そういうベンチマーク結果ってなくない?
同じアルゴリズム、同じPC上での結果なんて、ブログ記事で見るかどうかレベル。

大抵順位が出てるのは他人がバラバラのアルゴリズムで(同じ目標の)コード書いて、同一鯖上でベンチマークした結果ばっかりな気がする。
2024/10/02(水) 21:34:49.26ID:qmniBqed
それぞれの言語で自然な書き方で比較するのもそれはそれでフェアな条件の付け方じゃない?
実際問題としてそれぞれの言語で完全に同一のアルゴリズムで同一の構造になるようなことはないんだから言語の通常の習慣を曲げてまで条件を揃えるのが本当にフェアなルールだとは思わないな。
「普通にやったらこうなる」という比較のほうが日常的なユースケースでは意味のある比較に思える。

処理系を作る側が改善箇所を探す用途のベンチマークだったらまた事情は違うかもしれないけど。
88デフォルトの名無しさん
垢版 |
2024/10/02(水) 21:35:48.88ID:192UGWkp
>>85
サンクス
自分はThe Rust Program Language の日本語訳を参照してたけど、こちらには同様の説明が見当たらなかった (単に見落としかも?) ので、適切なリファレンスへのリンクは助かります
2024/10/02(水) 22:06:25.68ID:ufu02mt0
>>88
公式読めよ
2024/10/02(水) 22:11:54.22ID:qmniBqed
>>88
そのへんはたぶん英語版でも書いてないと思う。
The Rust Program Language は入門とか紹介という立場なので言語機能を網羅的に説明しているわけではないよ。
2024/10/02(水) 22:13:09.56ID:F+8Yq1v3
>>78
昔とは異なり
必要な境界値検査はプログラミング言語が責任を持って行わなければならない
この必須の機能を持たないC/C++は危険な言語として米ホワイトハウスも安全な言語への置き換えを推奨すると表明している
92デフォルトの名無しさん
垢版 |
2024/10/02(水) 23:30:25.01ID:U5iz23L2
単純なforで初期値と終了値が確定してるなら
境界超えは有り得ないんだから
そんなのまで境界チェック入れるのはナンセンス
2024/10/02(水) 23:32:21.66ID:5rx4Z4Pt
>>92
そこに着目して各個別の境界チェックを無くしてCと同じ速さが出るようにしたのがRustだね
2024/10/02(水) 23:52:48.74ID:iTWoI127
>>93
そうじゃない例が多くてなあ
同じLLVMのZigがRustより早かったしな
2024/10/02(水) 23:59:36.32ID:iTWoI127
あった、前スレ930

Zig 0.107
g++ 0.115
Rust 0.129 (bit-vect)
clang++ 0.131
Go 0.202 (godropbox/container/bitvector)
Rust 0.284 (Vec<bool>)
Go 0.326 ([]bool)
2024/10/03(木) 00:25:43.29ID:ooCKJPq8
>>94
Zigは境界チェックをしていないダメな言語側なので論外
2024/10/03(木) 00:29:43.46ID:Zb2tT7+Y
オプションで境界チェック消すのはRustと一緒じゃん
2024/10/03(木) 00:36:59.84ID:Zb2tT7+Y
>>95
よく見たら、これはインデックスでのランダムアクセスが必要なアルゴリズムだから
Rust側はオプションで境界チェック消さないとclangにも追い付かない

ダメな言語側避けると、RustとGoが同レベルなんじゃないかな
99デフォルトの名無しさん
垢版 |
2024/10/03(木) 01:45:50.92ID:dz5L3Xqm
>>87
>「普通にやったらこうなる」という比較のほうが
>日常的なユースケースでは意味のある比較に思える。
SNSでRustとC++でベンチマークを書いている人、
C++では、「普通のやり方」が書けてないケースが
ほとんど。
そもそも、C++がCよりも数%を超えるような
大幅に遅い結果が出ている時点で書き方がおかしい。
2024/10/03(木) 01:56:21.29ID:03B8BtDx
>>99
妄想じゃないなら参考までに2,3見繕ってくれよ
2024/10/03(木) 01:58:36.94ID:dz5L3Xqm
Rust信者は自分が間違っていることに気付かない。
2024/10/03(木) 01:59:28.46ID:ooCKJPq8
>>97
Zigは-O ReleaseSafeかDebugの時を除いて境界チェックをしないため危険
Rustは常に境界チェックをするため常に安全
もちろん安全に境界チェックを取り除ける場合は消える
2024/10/03(木) 02:04:50.11ID:03B8BtDx
>>102
>>95のRust&clang++場合は、本当は安全だけど境界チェックを取り除けなかったんだろうな
2024/10/03(木) 02:06:36.38ID:03B8BtDx
C++でもborrow checkerがcompiler explorerで動いてるし色々動き出すな

Safe C++ Proposal P3390R0
2024/10/03(木) 02:09:42.83ID:ooCKJPq8
>>103
妄想でないならソースコードとその時の生成コード例を出してみて
2024/10/03(木) 02:15:34.65ID:/vd3aRJZ
?
前スレで出てたgithubとタイム見ただけだから自分で確かめてよネ > 105
2024/10/03(木) 02:15:50.14ID:dz5L3Xqm
先生に対して、仕事を要求する馬鹿な生徒。
2024/10/03(木) 02:16:52.99ID:dz5L3Xqm
>>107の指摘は、>>103 に対することだが。
2024/10/03(木) 02:20:51.39ID:/vd3aRJZ
Rust関係なさ過ぎて熱が冷めたからSafe C++ Proposal P3390R0に移るかな
2024/10/03(木) 02:20:55.67ID:dz5L3Xqm
Rust信者は自分が優秀だと思い込んでいる人が多いらしい。
しかし、実態はそうでもない。
2024/10/03(木) 02:24:53.89ID:/vd3aRJZ
それは良くないw
数時間前のHaskellスレを見てしみじみ思ったw
2024/10/03(木) 02:29:35.48ID:dz5L3Xqm
>>108
>>103」ではなく「>>100」や「>>105
だった。スマン。
手間がかかることを人に要求し、それが提示されない
事を持って、相手がうそつきだと認定する手法を
使っている。
詭弁の一種だ。
2024/10/03(木) 02:31:10.25ID:/vd3aRJZ
safecpp.org/P3390R0.html
2024/10/03(木) 02:32:32.82ID:dz5L3Xqm
Rust信者は、どんどんどんどん、間違ったベンチマークや
間違った情報を発信してくる。
それに対していちいち正すことはできない。
次から次へと間違ったうそ情報を垂れ流し続ける相手に
対して、どうして優秀な人材が貴重な時間を割いて正さなきゃ
ならないのか。
それは世界的損失だ。
2024/10/03(木) 02:39:54.40ID:/vd3aRJZ
C++/CLI/CXのかほりがする

>>112
まともな議論はもう無理ぽ
2024/10/03(木) 02:43:43.51ID:/vd3aRJZ
>>114
一人の作者が複数言語書くと熱意に偏りが出るね

その意味ではちょっと前だけどJavaで始まった1brcが他言語にも波及してそれぞれの達人が競い合ってた
Rustはルール違反取られたけどねw
2024/10/03(木) 02:54:00.24ID:ooCKJPq8
言語によって標準ライブラリの範囲が異なり意味がないのにこのルールだからね

[Rules and limits]
No external library dependencies may be used. That means no lodash, no numpy, no Boost, no nothing. You're limited to the standard library of your language.
2024/10/03(木) 02:58:26.34ID:ooCKJPq8
Rustでは普通によく使われるこのあたりのライブラリすら使ってはいけないことになる
https://github.com/tumdum/1brc/blob/main/Cargo.toml
2024/10/03(木) 02:58:57.45ID:dz5L3Xqm
最悪のケースだと、こういうところで、最初間違った
ことを散々書いていて、痺れを切らした優秀な人
に時間をかけて情報を提示させ、しれっと
それを論文にまとめて自分の手柄にしてしまうような
不届き者が出てくる。
2024/10/03(木) 06:10:20.97ID:2hL7NSan
各IT大手だけでなくホワイトハウスや国防総省までC/C++を捨ててRustへ移行と言っている
少なくともRustと同レベルの安全性を備えない限りこの流れは止まらないだろう
121デフォルトの名無しさん
垢版 |
2024/10/03(木) 07:37:36.99ID:xd7ZayaC
>>118
一つ上のレスのルールを見る限り当たり前じゃね?
「皆が当たり前に使うライブラリ」ならC++のBoostやPythonのnumpyだってそうだろ
しかも >>118 はバージョン1未満のものもあって、それは同じコードが将来動かなくなる可能性があるわけだし
2024/10/03(木) 07:48:32.16ID:2hL7NSan
Rustでコードが将来動かなくなる可能性はない
ましてやバージョン1未満かどうかなんて関係ない
2024/10/03(木) 10:29:08.64ID:J18SNG72
バージョンや環境を塩漬けにしてただ動けばいいだけという話じゃないだろ
コードの変更を伴わずに継続的に本番運用できる期間の長さが重要

rust自身やstdのAPIの後方互換性の保証だったり
脆弱性対応の修正数の少なさだったりはいいけど
3rd partyライブラリはそうもいかない

1.0未満はもちろん1.0以降でも
永久に過去バージョンの対応ができるわけでもない
124デフォルトの名無しさん
垢版 |
2024/10/03(木) 10:48:04.49ID:Z/ktGrzU
>>99
Cは速いけどC++はどちらかと言うと遅い言語の部類に入る
125デフォルトの名無しさん
垢版 |
2024/10/03(木) 10:55:54.38ID:Z/ktGrzU
>>110
本当に優秀ならRust使う必要無いもんな
126デフォルトの名無しさん
垢版 |
2024/10/03(木) 11:00:18.13ID:Z/ktGrzU
>>119
chatGPTのことですねω判りますωωω=2πf
127デフォルトの名無しさん
垢版 |
2024/10/03(木) 11:06:17.98ID:Z/ktGrzU
>>122
Cargoで管理してればある程度はそうだけど
それも暗黙のルールに期待した場合の話に限るから
絶対描き換えなしで動き続けるかというとそうでもない
最低でもCargo.tomlの描き替えが必要だったりする
この辺はRustの責任ではないがCargoにもRustのメモリ安全ωの姿勢を見習って欲しい
2024/10/03(木) 12:14:17.60ID:ooCKJPq8
バージョンを指定した
上でCargo.tomlを書き換えなければ
自分で書いたソースコードは外部ライブラリに影響されずに永久に動くところがRustの利点なんだよ
129sage
垢版 |
2024/10/03(木) 12:33:12.38ID:Z/ktGrzU
>バージョンを指定した上でCargo.tomlを書き換えなければ
>自分で書いたソースコードは外部ライブラリに影響されずに永久に動く

version = "0.1.0"
じゃなくて
version = "=0.1.0"
と描いた場合に限る
130デフォルトの名無しさん
垢版 |
2024/10/03(木) 12:34:26.98ID:Z/ktGrzU
version = "0.1.0"
だと
外部ライブラリに影響される

外部ライブラリに影響されないのは
暗黙のルールに期待した場合の話に限る
131デフォルトの名無しさん
垢版 |
2024/10/03(木) 12:36:20.68ID:Z/ktGrzU
もちろん
version = "=0.1.0"
と描くのは現実的ではないが
>バージョンを指定した上でCargo.tomlを書き換えなければ
を満たすための矛盾

従って"暗黙のルールに期待した"Cargoは糞
2024/10/03(木) 13:08:08.08ID:fMIIfXl3
繰り返し構文の直前だけで行うように最適化されたにしろ
Rustだと配列の範囲をはみ出してないかの検査が
リリース版アプリでも入り続けるのだろうが、
それで不合格になるとアプリはダウンするから、
自動運転では人が死ぬので意味無い。
2024/10/03(木) 14:18:38.46ID:J18SNG72
>>131
>>128の文章が足りてないだけで
そこはCargo.lockの担当範囲やろ
2024/10/03(木) 18:08:46.17ID:vqUXT4xx
おまいら愚痴ってないでcode書け
書いて書いて書き捲れ
135デフォルトの名無しさん
垢版 |
2024/10/03(木) 21:40:37.20ID:xd7ZayaC
>>124
C++で遅いというなら「どちらかというと速い言語」って何が残るんだ
2024/10/04(金) 17:31:48.28ID:8BYffXd4
ざっくり速い遅いとか言ってるやつは雑魚でしょ
相手しなくていい
2024/10/04(金) 22:11:50.25ID:DHhd1aGk
十倍とか百倍とかいうレベルで露骨に差があるものならざっくりした比較でいいよ。
細かい数値が必要になるのは差が微妙だからで、その微妙な差を素人が適切に評価できるんかって話だわ。
データを出したってどうせそのデータを適切に読み取るのは無理だ。

そりゃ Rust が実行時にも境界チェックをする場合がある (実行コストが上がる) のは本当だけど、
Rust のほうが C++ より最適化しやすい (エイリアス解析がやりやすいので) というのはあるし、
その一方ではまだ C++ の処理系のほうが歴史の積み重ねが多くて強いというのもある。

ざっくりは無意味だが細かい数値も要因が絡み合いすぎてどうせ意味わからんから無意味。
2024/10/04(金) 22:21:16.42ID:JAupTFkx
>>136が言ってるのはそういう「ざっくり」ではないと思われ
2024/10/04(金) 22:40:51.60ID:jgzzZHCa
ざっくりどころか明白にC++はCより遅いしRustはさらにもっと遅い
140デフォルトの名無しさん
垢版 |
2024/10/04(金) 22:59:19.40ID:VBc4dd6u
C以外を全て「遅い部類」というならもうそれ部類って言葉が合わないんじゃないかな
2024/10/04(金) 23:37:34.19ID:cfR7b6v5
ほとんどのケースでRustはCと同程度の速さを出せる
安全性はもとよりモダンな抽象による開発効率と保守性の高さによりRustへの移行が進められている
142デフォルトの名無しさん
垢版 |
2024/10/05(土) 10:53:01.80ID:RULYnmJH
BoxやVecって、データを一旦スタックに書いてからヒープに渡されるよね
Bnx::new(でかい構造体)
のようなことをやる際に、直接ヒープに構築したいんだけど、unsafeを使えばできる?
2024/10/05(土) 11:04:55.83ID:tM0+DMRb
>>142
box演算子を使う
2024/10/05(土) 13:18:05.42ID:YtzMlx/f
>BoxやVecって、データを一旦スタックに書いてからヒープに渡されるよね
うそーん?
そのくらいは最適化されるやろ?
2024/10/05(土) 14:23:20.89ID:ntqlGNr5
>>141
そんなこと言う人は多いけど、その人たちはアルゴリズムを理解してない。
2024/10/05(土) 15:12:54.52ID:u1hwkRNd
Rustは境界検査ある分Cよりは遅くなるよね
境界検査オフにしたらベンチマークのスコア上がったみたいな記事がZennにあった気がする
2024/10/05(土) 15:18:00.36ID:Whmox1cd
そんなことしたらコーダーが勝手に最適化()するから駄目だろ。
2024/10/05(土) 16:20:58.85ID:SPb9kptA
>>146
Rustに境界検査オフにするオプションはないからそれは別の言動の話でしょう
Rustでは常に行われますが論理的に安全だと判定できる場合に最適化されて消えます

一方で境界検査がない言語では必要な境界検査をプログラマーが手動でする必要があります
それを忘れると深刻なセキュリティホールになる可能性があります
レアな特殊な状況が揃って初めて発生することもあるためサニタイザーでは見つけることが困難です
149デフォルトの名無しさん
垢版 |
2024/10/05(土) 17:01:50.15ID:RULYnmJH
>>143
詳しく
"box operator" のような単語でググってみたけど、それらしいものを見つけられてない
2024/10/05(土) 17:08:36.51ID:7dJZ4c51
>>148
get_uncheckedとかあるやろ
2024/10/05(土) 17:33:09.63ID:MY6FIQ9N
>>149
少なくとも stable には無い。
現時点では box が予約語扱いになってるが、将来に使用するための予約であって現時点では使ってないと名言されてる。
https://doc.rust-lang.org/reference/keywords.html

以前に検討したけど取り下げた記録はある。
https://rust-lang.github.io/rfcs/0809-box-and-in-for-stdlib.html
今はどうなってるんやろね?
2024/10/05(土) 17:40:46.65ID:MY6FIQ9N
× 名言
〇 明言
2024/10/05(土) 17:53:26.30ID:YGXhd2d0
>>146
分かりやすさから境界検査だけの遅さは分かっている
人が多いが、実は境界検査は些細な違いに過ぎない。
それ以上の事は言わない。各自で考えろ。
分かる人だけが分かっていればいい。
2024/10/05(土) 22:25:00.84ID:nBMiTSwQ
https://github.com/rust-lang/rust/pull/97293
https://github.com/rust-lang/rust/pull/108471
現状なんかな?
2024/10/05(土) 23:58:02.93ID:aBfTO+dT
たしかbox記法をやめて
#[rustc_box]へ変えたはず
2024/10/06(日) 02:23:22.08ID:Fc/J32B0
>>142
今は
let mut b = Box::<BigStruct>::new_uninit();
とする
2024/10/06(日) 02:59:36.25ID:Uy2TM6oP
ボツになった box キーワードを使ったやりかただと C++ でいう new みたいなのを想定していたんだと思う。
同じコンストラクタでスタック上にもヒープにもオブジェクトを構築できるようにってことね。
今の Rust の stable 内でやろうとすると未初期化のヒープ領域を確保してからそれに書き込むという段階を踏む必要があって同じ生成関数をキーワードひとつで切り替えてつかうということは出来ない。
そういうちょっとした不恰好さを呑む必要はある。
2024/10/06(日) 10:41:43.35ID:pGBP5yto
>>156
コンパイラや標準ライブラリの開発者は#[rustc_box] + Box::new()を使うのに一般開発者はBox::new_uninit() + unsafeブロックで手動初期化しなきゃいけないというのはなんとも微妙だね
2024/10/06(日) 11:07:22.09ID:jCq2z3ec
>>153
わかってないやつが言っても説得力ないよ

境界検査を外す話はこれかな
https://proc-cpuinfo.fixstars.com/2019/09/rust-wins-cpp/
2024/10/06(日) 13:00:12.28ID:RTiROZJD
>>159
実行毎に数十msはブレる処理でC++より数ms速くなりましたとか微妙すぎるな
2024/10/06(日) 14:13:57.31ID:WBd7Gzjc
>>160
同感、20~40msはぶれる

>>159
Rustシングルスレッド版のcommit:23807a67df266ac8c6ba065801616a4012555344に戻して
単一実装毎に10回計測した最速値

SequentialNative, PreProcess, 3.328, Solve, 767.845, PostProcess, 0.521 <- C++/g++
SequentialNative, PreProcess, 3.679, Solve, 785.951, PostProcess, 0.502 <- C++/clang++
Rust, PreProcess, 3.407, Solve, 796.38, PostProcess, 0.599 <- Rust
2024/10/06(日) 14:32:01.49ID:SXFzPwbD
一番下の方にリンクしてあるQiitaの追試記事も読むといい
2024/10/06(日) 14:47:13.76ID:x2YI0jj4
>>159
「検査例外は些細な違いに過ぎない」
と言ったのは、Rustには、もっと非効率な部分があるからだぞ。
逆に捉えた人がいるかもしれないが。
2024/10/06(日) 14:48:25.28ID:x2YI0jj4
>>163
誤:検査例外
正:境界検査
2024/10/06(日) 22:43:06.06ID:yDkn3TVj
Rustコンパイラが通常の機能として論理的に安全と解析できた時は境界検査を省略しているのに加えて
プログラマーがさらにヒントを与えることで境界検査を安全に無くしたり減少させたりする方法もありかなりをカバーできる
それでもカバーできない範囲は人間が安全性を保証する形でunsafeを用いて関数やモジュール内に閉じ込める最後の手段がある
プログラムのそれ以外の部分は依然としてRustが安全性を保証するためRustを用いたほうが断然に有利
2024/10/06(日) 22:58:46.94ID:xpAyDRS+
相変わらず非論理的やな
2024/10/07(月) 01:41:44.93ID:q99irmJP
基本をどっち側に倒してるかって話だわな。
チェックするのを基本にする (けど必要ならチェックを除くことも出来る) のか
チェックしないのを基本にする (けど必要ならチェックすることも出来る) のかって話で、
やりやきゃどっちも出来るんだから場合によって自分で判断しろよ。
2024/10/07(月) 02:43:52.62ID:X74uBgxx
これはさすがに釣りだよね
2024/10/07(月) 04:55:29.89ID:JLiQrglj
もしかしてRustってコンパイルめちゃくちゃ遅い?
2024/10/07(月) 10:41:01.74ID:AsZpJSRX
一回コンパイル済みなら、2回目はそれなりの時間

初回のsdk-ec2は遅すぎて何度中断しようかと思ったわ
171デフォルトの名無しさん
垢版 |
2024/10/07(月) 15:40:05.30ID:m+p7ApSZ
cargo update するとすぐ破綻する
2024/10/07(月) 16:27:42.48ID:meOfPwUY
sccacheで二度目以降はもう少し改善した
コンパイル速度はC++同様遅い部類だと思う
2024/10/07(月) 17:01:46.54ID:89HfDe1C
>>163
それの具体例を示せてない時点でね…
2024/10/07(月) 23:19:03.68ID:TZwLk8HD
安全に境界検査不要をassert!でRustコンパイラに伝える方法が意外に効くね
2024/10/07(月) 23:26:15.84ID:dfTx2VFf
>>173
馬鹿には示す必要ない。
2024/10/08(火) 08:44:17.05ID:eFef5p6V
>>174
詳しく
2024/10/08(火) 09:34:58.32ID:+McDiVVz
自分で定義してないtrait(T)を自分で定義してないstruct(S)に定義したい
impl T for S {
}
2024/10/08(火) 10:04:39.98ID:A/U5l8w3
>>177
できないのでどちらかをwrapして下さい
2024/10/08(火) 10:36:24.86ID:8N0aYuJN
>>177
orphan rule と呼ばれる制限。
どうしてこの制限が必要なのか、対処法のイディオムなどはググればいっぱい説明されてるよ。
180デフォルトの名無しさん
垢版 |
2024/10/08(火) 21:24:47.85ID:pQ+vP70p
>>175
知らないだけw
2024/10/08(火) 21:26:47.09ID:CJF5aBIv
>>180
やっぱり本当に馬鹿なんだな。
それに説明しても理解できない。
2024/10/08(火) 23:19:20.44ID:0gkuNx2u
>>176
https://nnethercote.github.io/perf-book/bounds-checks.html
2024/10/09(水) 08:10:07.07ID:6t9Q00Al
>>182
thx
184デフォルトの名無しさん
垢版 |
2024/10/09(水) 14:24:59.18ID:SE80KZZv
慈円乙
2024/10/09(水) 18:17:45.48ID:9TrJQGOx
>>175
あーあ,反ワクが自分で調べてくださいっていうのと同じか
自分で説明するとボロが出るから
2024/10/09(水) 21:57:24.09ID:O1I2MdzM
実験と質問の境界がなくなりかけている
質問なら自己解決もありうる
実験の場合、自分で考えた実験結果というのはただのデータ改竄
2024/10/09(水) 22:10:40.53ID:cHg2rcow
>>185
もしかして7回も打ってるの?
2024/10/09(水) 23:54:32.05ID:uqNnLm2k
米ホワイトハウス「ソフトウェアはメモリ安全でなければならない」との声明を発表:「C」「C++」よりも「Rust」などの言語を推奨
https://atmarkit.itmedia.co.jp/ait/articles/2403/18/news045.html
2024/10/10(木) 02:18:50.02ID:zQjmpUKF
>>188
Rustには権力による圧力が入ってきている。
市場経済、自由選択への権力介入だ。
2024/10/10(木) 02:21:09.33ID:zQjmpUKF
コンピュータの分野は権力介入が少なかったので、面白かったのに、
政治家やマスコミが入り込んできてめちゃくちゃになってきている。
2024/10/10(木) 07:08:10.03ID:UwcyK+WZ
与党が介入するなら野党に投票すればいい
192デフォルトの名無しさん
垢版 |
2024/10/10(木) 09:15:33.28ID:bwO1aVtU
コンピュータープログラムのアルゴリズムごときでノーベル賞とか
最近はホント可笑しい
2024/10/10(木) 09:54:14.90ID:UItC3qRM
ソフトウェア特許がろくでもないのでノーベル賞みたいな形のほうがマシだと思う。
良いとは言えんが。
2024/10/10(木) 21:54:50.97ID:7tvKCAT1
>>189
米政府は危険なC/C++を早く捨てて安全なプログラミング言語を使うことを推奨するとして、Rustを含めた複数の安全な言語を挙げているので大丈夫だよ。
ただしRust以外はガベージコレクション言語なので、C/C++と同等の速さやメモリ使用量を望むならばRustしか安全な言語の選択肢がない。
2024/10/11(金) 00:11:00.19ID:anwjy38M
AIと人間が競争するみたいな文脈では危険といえば相手に負けることしか思いつかなくなる
それ以外の安全性がどうでもよくなる
2024/10/11(金) 01:44:19.33ID:TjHLE0iw
>>194
結局、C/C++だけが潰される。
2024/10/11(金) 09:35:58.81ID:4zAbwXut
rustはガベコレはないけど、オブジェクトのライフタイムをコンパイル時にチェックして c++でいう deleteを自動でセットしてくれるのですか?
コンパイラはそんな複雑なことができて、結果も信頼できるのでしょうか
それとも、開発者が自由に書けないくらい、書き方に制約を設けてコンパイラにとって既知のパターンとなるようにしているのですかね
2024/10/11(金) 10:48:59.08ID:KVaSEz2e
>>197
まずはChatGPTにでも聞いて概要を理解しろ
2024/10/11(金) 13:50:24.29ID:fZFoy1Go
>>197
これはプログラム経験が浅いマネージャに聞かれそうな質問
まずC++のデストラクタを理解してるかどうかがポイントだな

「c++でいうdeleteを自動でセット」というフレーズから不穏なオーラを感じる
2024/10/11(金) 13:54:54.08ID:W/ZPwHBO
>>197
別に複雑なことはしていない
所有権の移動に厳密なだけ
2024/10/11(金) 14:05:51.40ID:anwjy38M
喩え話や類推で理解できてしまったら驚き屋の仕事が奪われるだろ
2024/10/11(金) 14:16:31.54ID:A4LeYzGx
>>197
言語機能は全部が絡み合って機能するので単純には言えない。
入門の文書が用意されてるんだから読みなさいよ。
きちんと使いこなそうと思わずに流し読みするくらいなら一日で読めるから。
2024/10/11(金) 14:26:39.61ID:onrBNldo
アメリカは、自由や市場経済を大事にする、と謳っておきながら、C/C++言語除外を官製強制するような国。どこが自由や市場経済なんだか。
2024/10/11(金) 16:56:32.95ID:Go9IkusF
せいぜい政府調達から外すとかでしょ
気にしすぎ
2024/10/11(金) 17:49:21.57ID:anwjy38M
足し算の交換法則なんかは永久に守られるのになぜC++の文法を守らないのか
これ需給とか政府とかチャチなもんじゃなくてもっと怖ろしい強制力だろ
2024/10/11(金) 18:19:53.55ID:A4LeYzGx
>>203
政府が顧客の一人として言ってるだけで、市場に対する強制じゃないよ。
影響力が強くはあるけども。
2024/10/11(金) 21:39:44.20ID:52UfM0Gk
民間は先行して既に自らRustへシフトが進んでいる状況を踏まえて
政府が報告書をまとめたものだから
2024/10/11(金) 23:15:15.82ID:anwjy38M
ルールの例外を理解すれば自由度が上がる
たとえば猫と牛の違いが分かった奴は牛肉を食べる
分からん奴は菜食主義を強制されていると思い込むかも
209デフォルトの名無しさん
垢版 |
2024/10/12(土) 00:34:02.68ID:qdhjRNO+
交換法則は人間の関与の余地がない
C++の文法は所詮は禿が定義したもの
Rustも含めて換えて良い
2024/10/12(土) 01:14:45.15ID:gm00SVZq
「Security状問題である」と言われると人間には逆らえなくなる法則を利用し、
「衰退させたいライバル商品」を市場から消す商法がアメリカでは多用されている。
2024/10/12(土) 01:21:49.75ID:gm00SVZq
>>210
Security状 --> Security上
2024/10/12(土) 01:28:42.28ID:gm00SVZq
強力なC++開発環境が生まれる兆しを感じ、それを抑えるためにRustを推奨し出したのかもしれない。
213デフォルトの名無しさん
垢版 |
2024/10/12(土) 01:29:35.88ID:qdhjRNO+
Rustもそのうち排除されるよ
2024/10/12(土) 01:29:58.11ID:gm00SVZq
SNSでは、Wasmが、Rustと組み合わせる場合だけが強調される。
それは、そうでないと都合の悪い何かが出現したからではないか。
2024/10/12(土) 01:32:52.29ID:gm00SVZq
しかも、RustはJSやPythonやC#などを置き換える可能性も有るにもかかわらず、
C++の置き換えだけが強調されるのは、C++を絶対的に排除しなければならない
何かが彼らの中で起きているのではないか。WasmとC++の組み合わせが特に
排除されようとしている。
2024/10/12(土) 05:10:31.55ID:RKNycNvy
思い込み激しすぎ
2024/10/12(土) 06:57:43.97ID:IpPc9zS0
>>215
>RustはJSやPythonやC#などを置き換える可能性も有る

c++より学習難易度高いのに、置き換える可能性があるわけ無いだろ。
2024/10/12(土) 07:44:30.22ID:MfW7RByH
採用はRFPに記載されるようになってからだよね~
指定が無いからと言って、「Rustで書きます。生産性良く無いのでC++の1.n倍の費用がかかります!」
の提案書が通るとは思えない。
219デフォルトの名無しさん
垢版 |
2024/10/12(土) 07:50:17.08ID:qdhjRNO+
RustがC++の置き換えになるとかほざいてるのは
RustもC++も使えないアホだけだろ
2024/10/12(土) 07:51:04.20ID:DET419zt
blog.rust-lang.org/2024/09/05/impl-trait-capture-rules.html
> We surveyed crates on crates.io and found that the vast majority of cases
> involving return-position impl trait and generics had bounds that were too
> strong and which could lead to unnecessary errors (though often they were
> used in simple ways that didn't trigger an error).

わはは、結局大部分はちゃんと理解してないし使いこなせてもいないってこった
221デフォルトの名無しさん
垢版 |
2024/10/12(土) 07:51:41.07ID:qdhjRNO+
>>c++より学習難易度高い

これはC++の闇を知らんから言えるんだ
2024/10/12(土) 07:51:53.90ID:DET419zt
あ、やっと書けた
なんか最近5chはよく分からん規制入れとるね
2024/10/12(土) 08:03:30.55ID:MfW7RByH
せやな
2024/10/12(土) 08:20:08.48ID:hSwwQxA2
>>217
学習難易度が高いのは無駄に仕様が大きすぎるC++
Rustはモダンな抽象化も綺麗にまとまっていて仕様も小さい
2024/10/12(土) 09:32:07.50ID:DTlX8R5X
闇が嫌なら使わなければいい
使わない自由にこだわる理由がこれ

だが闇を認識できなければ、使うか使わないか検討する自由はほぼない
ないものをあると誤認しているだけ
元々自由がない状態なら、政府が介入しても、ないものを奪い取る心配はないってこと
2024/10/12(土) 10:14:12.54ID:o9Hly54Z
>>224
公式も認めている激烈絶壁の学習障壁を、あえて言わずにその主張をするのは詐欺ですな。

初心者向けのまともな学習書は出たのかしらん?
2024/10/12(土) 11:04:13.10ID:DTlX8R5X
学習時間が固定相場ならまともにはならない
昔の人がいうように修行は10年かかるとかいうレベルで時間が変動することを認めないと
2024/10/12(土) 11:56:03.05ID:pKFLyiMR
Rust 2024 editionっていつ出るの?
2024/10/12(土) 12:06:55.87ID:PWeoTkee
C++ のあかんところはわかってても間違う (間違いをコンパイラやランタイムサポートが検出しない) ところ。
わかってないときに自分がわかってないということに気づけないところ。

このつらさと難易度を天秤にかけたら Rust のほうがマシ。
2024/10/12(土) 12:33:44.48ID:qdhjRNO+
>>225
ごめんなにいってるかわかんない
Rustの闇の話?
231デフォルトの名無しさん
垢版 |
2024/10/12(土) 13:30:21.66ID:2nOFyk8I
中学生が好みそうなワード
2024/10/12(土) 14:53:53.79ID:DTlX8R5X
C++は完成品だという前提を強制してから自由に選ばせるのが闇だ
もしかして未完成なんじゃないかという解釈は必要
その解釈は誹謗中傷だという解釈もあるだろうが
未完成だったことにして完成品を作ってみたのがRustだとしたらやはり必要なことだった
2024/10/12(土) 14:55:04.31ID:BAZEi6Kk
c++もrustもどっちも使えたらええだけやろ
所詮言語ごときで何を騒いどんねん
2024/10/12(土) 15:40:11.45ID:3DzBYfs0
rust

消えてく言語なの?
2024/10/12(土) 16:05:55.21ID:91OPX9l9
Rustは一番嫌われている言語。
2024/10/12(土) 16:12:40.29ID:0WcQlR1j
普通10言語以上覚えて使い分けるだろ。
237デフォルトの名無しさん
垢版 |
2024/10/12(土) 16:55:23.16ID:2nOFyk8I
使い分けてるのは言語じゃなくてIDなんだよなあ
2024/10/12(土) 19:05:36.19ID:C7MzjPxF
Rustの安心安全でいいんだけど
一つだけ欠点があって、それは誰も使ってないってことなんだよな
2024/10/12(土) 19:31:25.97ID:PWeoTkee
んなこたない。
crates.io に登録されてたり github に上がってる大量のコードを誰が書いてるんだって話になるじゃないの。
他の言語との差はあるにしても誰も使ってないというほど少ないということもない。
2024/10/12(土) 20:05:40.69ID:Vo4EHhVz
Rust Surveyの回答者が1万人だからある程度熱心な人はそれくらいいて、全体で5-10万人ってとこかな
2024/10/12(土) 20:37:41.94ID:hSwwQxA2
ネットインフラが次々とRust製へ変わっていってるように
絶大な効果を発揮している
242デフォルトの名無しさん
垢版 |
2024/10/12(土) 22:46:05.65ID:2nOFyk8I
> ネットインフラが次々とRust製へ変わっていってる
具体的にどういうのがあるの?
無知なだけかもしれないけど自分はあまり実例を知らない (自分が知ってるのはFirefoxとDiscordくらい)
2024/10/12(土) 22:58:36.02ID:hSwwQxA2
ネットインフラが次々とRust製へ変わっていってるニュース記事ソース

例1
>【クラウド世界トップシェアAWS】
https://japan.zdnet.com/article/35183866/
>Rustで構築されたAWSサービスの例としては、
>コンテナーアプリ用のサーバーレスプラットフォーム「Lamba」を支える「Firecracker」、
>「Amazоn Simple Storage Service(S3)」、
>「Аmazоn Elastic Compute Cloud(EC2)」、
>コンテンツ配信ネットワーク「Аmazоn CloudFront」、
>LinuxベースのコンテナーOS「Bottlerocket」などがある。

例2
>【CDN世界トップシェアClоudflare】
https://www.publickey1.jp/blog/22/cloudflarenginxrusthttppingoracdncpu31.html
>CDNプロバイダのCloudflareは、同社のグローバルなCDNの基盤として長らく利用してきたNGINXに代えて、
>同社自身がRust製のHTTPプロキシである「Pingora」を開発し利 用していることを明らかにしました。
2024/10/12(土) 23:11:32.64ID:O1A52KxC
使えないって言ってるやつは頭が悪いだけ
2024/10/13(日) 00:02:47.57ID:bsYTaHhv
Linuxの時と同じような感じだな。熱狂的信者とアンチとの戦い方が。
結局、Linuxの場合、普及したのはサーバーサイドだけで、Desktopは5%程度にとどまることになった。
Rustの場合は、安全性重視の分野では天下をとるかもしれないが、安全性がそれほど重要でない分野はC++のままなのではないか。
2024/10/13(日) 00:05:30.88ID:bsYTaHhv
>>245
熱狂的信者は視野が狭く、アンチとは見ている世界が違う。
Linuxの場合も、信者は「Linuxは十分に普及した」と真顔でいまだに主張している。
しかし、アンチはDesktopを想定しているから話が合わない。
それと似たことがRust vs C++でも起きてくるのではないか。
2024/10/13(日) 00:07:58.43ID:bsYTaHhv
>>246
Linuxの場合も、20年経過した後、信者は「ほら普及したよね?」
アンチは「やはり普及しなかったな」という様相を呈している。
つまり、想定している「普及」や「勝利」の概念すら違っているのだ。
Rust vs C++でもそうなのではないか。
2024/10/13(日) 00:08:15.95ID:uHcnNqHT
>>245
セキュリティホールなど脆弱性があってもそれほど重要でない分野ってある?
2024/10/13(日) 00:20:19.98ID:bsYTaHhv
>>248
WordやExcel、画像エディタ、3Dモデラ、CADなどの一般アプリや、ゲームが
それに当たる。
2024/10/13(日) 00:20:21.18ID:bsYTaHhv
>>248
WordやExcel、画像エディタ、3Dモデラ、CADなどの一般アプリや、ゲームが
それに当たる。
2024/10/13(日) 00:23:13.27ID:URUAnEKd
草w
2024/10/13(日) 00:34:31.04ID:Lrm9f5J1
メモリ安全性や脆弱性に対する知識が皆無なんだろ
2024/10/13(日) 00:47:36.22ID:uHcnNqHT
>>249
それらは脆弱性があっては困る分野だ
2024/10/13(日) 00:51:33.48ID:9IW5Js7R
word文書保存すると無くなるってニュースが出ていたな
VSSもソースロストするって有名だったし

ま現物が無くなればアリストテレスでも論破不能だよね
2024/10/13(日) 09:21:11.59ID:2a75wgGc
普及とか繁殖の定義が違うと言われても困るな
理解できないのは定義の違いではなく
一体なぜ繁殖を定義しようと思ったのかを理解できない
2024/10/13(日) 12:12:14.31ID:UZT3uuKD
>>239
crates.io や github に上がってる Rust のプロジェクトって
もうだれもメンテしてませんってのも多いよね
C/C++ でもそういうのあるけど
257デフォルトの名無しさん
垢版 |
2024/10/13(日) 12:14:41.71ID:UZT3uuKD
>>246
>信者は「Linuxは十分に普及した」

スマホに限ってはそうだね
もちろん観てる世界が違う結果そう観えてる訳だね
2024/10/13(日) 12:17:07.38ID:UZT3uuKD
>>255
自分の世界で普及していないものは普及していないって言い張るタイプの人は一定数居る
2024/10/13(日) 15:16:40.73ID:9IW5Js7R
OpenCASCADE をRustに移植してくれる勇者は居らぬか?
2024/10/13(日) 16:07:57.49ID:OnT8jRlg
>>259
こういう感じ?
https://github.com/ricosjp/truck
2024/10/13(日) 16:54:43.62ID:2a75wgGc
視点を変えるだけで生存者が死者に変わるというのは極端過ぎる
生命にたいする侮辱を感じる
2024/10/13(日) 18:09:40.09ID:RQflUxIg
>>258
Unixの世界はもともと異なるメーカーのUnix規格に沿ったOSがあったわけだから、
無料のLinuxが普及するのは当たり前であって、ことさら強調されても意味が分からん
わけだよ。今で言うPC/AT規格やかつてのMSX規格の互換製品を作っても売れるのは
当たり前であって。
263デフォルトの名無しさん
垢版 |
2024/10/13(日) 18:11:20.56ID:RQflUxIg
>>262
MSXやPC/ATは互換性の有るものを非常に沢山のメーカーが当たり前の様に作っていた。
Unixもそれと同じ。誰でも作れるOSを無料化しただけみたいな。
264デフォルトの名無しさん
垢版 |
2024/10/13(日) 21:33:21.80ID:cfTcGRh7
Rustの話してよ
2024/10/13(日) 21:40:56.59ID:svBHWCr7
>>243
知らぬ間に我々が間接的に使ってるインフラが続々とRust製になってるんだな
身動きが取れない古くからの大きな遺物を除くと近い将来Rust製一色になりそうだ
2024/10/13(日) 22:30:12.40ID:wYeF4p9P
>>262
一々突っ込まないけどいっちょかみには
UNIXの歴史はそんなふうに見えてるんだなあ
2024/10/13(日) 23:37:02.43ID:2a75wgGc
補給と撤退はできて当たり前という伝統的価値観はunixの伝統とは全然関係ない
2024/10/14(月) 10:09:10.28ID:NZxYCisA
属人性排除は難易度が無限小という意味ではない
難易度がfnでもmutでもないだけ
それと、正解が複数あるのではなく誤解がいっぱいあるだけ
269デフォルトの名無しさん
垢版 |
2024/10/14(月) 10:31:37.38ID:9n6nFJIZ
いや正解は複数ある
誤解もいっぱいあるけど
270デフォルトの名無しさん
垢版 |
2024/10/14(月) 12:41:22.19ID:frzdEHtE
Haskellと同じ道をたどってる
271デフォルトの名無しさん
垢版 |
2024/10/14(月) 12:55:36.56ID:PAao37O/
Haskellよりは盛り上がってるでしょ
ライブラリとか割とあるし
2024/10/14(月) 13:34:21.16ID:Tepyp1Xi
エリート主義的で一般ウケしなかった関数型言語というレッテルを貼って一方的にぶん殴ってもいい存在がほしいなら、Scalaのほうが適任なんじゃね
知らんけど
2024/10/14(月) 13:37:01.70ID:9n6nFJIZ
Eiffelの再燃とか無いのかな
2024/10/14(月) 13:56:15.30ID:b6A9/4cN
>>270
大手IT企業のほとんどがRustを用いている
そして>>243の例のようにITインフラがRust製へと置き換わっていってる
2024/10/14(月) 14:13:01.64ID:UHTCVsGQ
このスレはバカ話が永遠に続くな
2024/10/14(月) 14:31:11.38ID:Tepyp1Xi
中途半端にまともな話ができそうな雰囲気を出されるより
最初からバカ話に全振りしてくれてる今の状況がありがたい
2024/10/14(月) 14:47:08.94ID:6F/WzjOb
だれも Rust の話してないよねこのスレ
2024/10/14(月) 17:04:57.32ID:AQF6byo6
なにが一番みたいな論争するやつは軒並みアホだよね
いつまで厨房やってんだか
2024/10/14(月) 17:39:30.59ID:jiIXwm87
定期的にどこそこが採用しただの、アメリカ政府が推薦したという話が出てくる
が、具体的にコードを示して優位性を説いたりはしない
2024/10/14(月) 19:35:56.02ID:Tepyp1Xi
https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=0bb08fd2d76e4ceb6cfa93c9b7fcf946
2024/10/15(火) 15:25:40.98ID:xmb61fZ8
play.rust-lang.org 死んでるのか
2024/10/15(火) 16:19:54.80ID:ljjOrbgX
>>279
ある時からコンピュータソフトの分野に権威性を持ち込む人が増えた。
283デフォルトの名無しさん
垢版 |
2024/10/15(火) 20:41:46.23ID:7T7mXQAC
>>270
HaskellがRustみたいにinterface(雑誌)で連載持ってたら普及してたかもしれないね…。
いあ、GC有る時点で組み込み専門誌に連載なんて持てないんだが。
284デフォルトの名無しさん
垢版 |
2024/10/15(火) 21:39:59.36ID:kUMekxil
関数型由来の考えもあるけど関数型言語ではない、というのがバランス的に良かった気がする
関数型に振ってたらRustもScalaやF#くらいのポジションに収まってたかも?
2024/10/16(水) 01:15:48.39ID:OzuoU4nz
firefoxってホントにRust使ってるの?ってくらいメモリ管理ダサい
286デフォルトの名無しさん
垢版 |
2024/10/16(水) 06:29:19.89ID:J5oRWUb2
火狐と言えば、これってRustで開発してることに関係あるのかな?

ゼロデイ脆弱性の報告から解決までたった25時間 ~Mozillaが対応の早さをアピール
「Firefox」、「Thunderbird」、「Tor Browser」を最新にしよう
https://forest.watch.impress.co.jp/docs/news/1631133.html
287デフォルトの名無しさん
垢版 |
2024/10/16(水) 06:33:37.57ID:J5oRWUb2
>>284
関数型言語の普及を願ってる人からすればショックだろうけど、Haskell好きな自分も現実解はその方が良いとは思う。
そういう意味じゃScalaも良いところまで行ってたんだけど、理由忘れたけど自滅したってのは覚えてる。
2024/10/16(水) 07:16:03.45ID:Rxxbhur+
ScalaはScalazとかで関数型を推しすぎたのと、標準ライブラリに破壊的変更バリバリ入れて過去のコードが動かなくなったせいだと思う
2024/10/16(水) 08:13:07.22ID:TssvwW2w
>>284
言われてみればjsもそれに近いな
2024/10/16(水) 09:44:47.18ID:IRnMzRmI
Rustで開発してたらゼロデイ脆弱性なんて起こりません(キリっ
2024/10/16(水) 09:46:37.48ID:IRnMzRmI
Scalaの失敗はJavaをベースにしたこと
2024/10/16(水) 11:03:29.32ID:TpBdArw+
https://xtech.nikkei.com/atcl/nxt/column/18/00692/042700054/
2024/10/16(水) 11:05:35.24ID:TpBdArw+
>>292
>> GoogleおよびMicrosoftはセキュリティー脆弱性の70%がメモリー安全に関するバグに起因すると述べている。
>> C/C++を使う限りこれらを根絶するのは不可能と考えて、Rustを採用するに至ったというわけだ。
2024/10/16(水) 11:06:00.19ID:RoKRQLvT
中国製やロシア製のクレート使ってるとまずいの?
2024/10/16(水) 11:24:30.99ID:iczv67yq
Rustの一番の特徴はスタックフレームを意識して言語仕様の下敷きにしていることかと。ライフタイムとかスコープとか。結果として再帰構造を取り込んでいるから言語として強い。

関数型プログラミングを前面に出すとHaskellみたいになりそうだから止めてほしいところ。
296デフォルトの名無しさん
垢版 |
2024/10/16(水) 11:35:27.63ID:k6iNMcvo
副作用がないとかは嬉しいけど、関数型信者はデータ構造をなんでもリンクドリストにしようとするキチガイだから関わりたくない
2024/10/16(水) 11:40:53.10ID:9ExG49iw
>>296
んなことはない。
LISP 系ですらプロトタイプが終われば積極的に固有の型を定義しまくる。
そうなってないのはただカスなやつが書いてるだけ。
2024/10/16(水) 12:33:07.98ID:ru3N7GME
>Rustの一番の特徴はスタックフレームを意識して言語仕様の下敷きにしていることかと。
こういう発言を見ると無駄にRust推してるやつのレベルの低さに呆れる
299デフォルトの名無しさん
垢版 |
2024/10/16(水) 12:34:03.40ID:kfN83BOA
>>297
Lispは関数型もどきってHaskellが言ってた
2024/10/16(水) 12:49:23.38ID:IRnMzRmI
過去スレのこの辺からの流れ思い出してしまった
https://mevius.5ch.net/test/read.cgi/tech/1692105879/423-
2024/10/16(水) 16:38:38.84ID:1LoW/zWh
スクリプト言語上がりからするとスタックフレームを意識するのは斬新なんだろ
2024/10/16(水) 17:01:37.45ID:+2+Nhw/8
lispはlispを操作してlispを吐き出すための言語であって
それ以外の機能はオマケだから
2024/10/16(水) 17:34:30.78ID:9ExG49iw
>>299
関数型がどうとかは重要ではなくて「リストを多用しがちと思われているLisp」という意味
2024/10/16(水) 17:48:29.96ID:1LoW/zWh
普通に多用するだろ
lisp使っててそこを認めないやついるのに驚き
2024/10/16(水) 17:54:09.44ID:jR87Fk4R
C言語もリンクリストの権現みたいな存在だったんだよ。
2024/10/16(水) 17:56:35.94ID:jR87Fk4R
リンクトリストで、一番初期に有名になったのが、LISP。
それを分かりやすくしたのがC言語、みたいな感じ。
リンクトリストは、8MHz程度の16BIT-CPUにおいて、
動的配列に比べてとても効率が良かったので、人気が出た。
2024/10/16(水) 18:07:55.38ID:1LoW/zWh
lispのリストとcでリンクリストが作れることは次元が違う話
lisp知らんやつに言っても理解できんだろが
だいたいリンクリストの権現って何だ?w
2024/10/16(水) 18:11:33.23ID:jDyVYSBS
ごん‐げん【権現】 の解説
1 仏・菩薩 (ぼさつ) が人々を救うため、仮の姿をとって現れること。
2 仏・菩薩の垂迹 (すいじゃく) として化身して現れた日本の神。本地垂迹説による。熊野権現・金毘羅 (こんぴら) 権現などの類。
3 仏・菩薩にならって称した神号。東照大権現(徳川家康)の類。

ありがたや🙏🙏🙏
2024/10/16(水) 18:13:29.12ID:qBTeykyO
Cって、プログラムがリストになってるん?
lisp系以外で、こういうのってない気がするんだけど。
2024/10/16(水) 18:39:06.97ID:jR87Fk4R
>>309
Cの場合は、データ構造のみの話。

>>307
LISPは、プログラムもリンクトリストみたいだった
から、Cよりも権現といえるだろうけども、
Cもリンクトリストと密接な言語だと言われていて、
Cの速さはリンクトリストのおかげだった。
2024/10/16(水) 20:06:13.28ID:IdjFDmt0
>>285
Firefoxの一部はレンダリング部分などRustになっているけど
そのメモリ管理部分を含めて本体はC++のままだよ
いずれにしても各アプリケーションによるメモリ管理部分は使用言語C++/Rustのメモリ管理とは別レイヤなので各言語の問題ではないね
2024/10/16(水) 20:08:26.05ID:IdjFDmt0
>>295
ライフタイム導入でスタックフレーム上への参照と変数が管理するヒープへの参照を区別せず安全に扱えるようになっただけで意識するしないは別問題じゃないかな
そのためコストの高いヒープを回避できる機会が増えて高速化に寄与しているのは間違いないけど
2024/10/16(水) 20:11:56.13ID:IdjFDmt0
>>306
今はパイプラインとキャッシュによりほとんどの利用ケースでリンクリストよりベクタが速くなってしまったね
元々メモリ使用量や多段間接参照になる点でリンクリストが不利だった点に加えて追い打ちをかけるように
2024/10/16(水) 20:13:18.48ID:IdjFDmt0
>>310
Lispは言語としてcond, car, cdrがあるからリンクリスト言語だけどC言語は明確に違うね
Cはリンクリストもベクタもその他のデータ構造も実装できるというだけの平等な立ち位置かな
2024/10/16(水) 20:21:57.12ID:jR87Fk4R
>>313
>今はパイプラインとキャッシュによりほとんどの利用ケースでリンクリストよりベクタが速くなってしまったね
典型的な間違い。
2024/10/16(水) 20:27:30.93ID:RoKRQLvT
リンクリストは不変コレクションだから、副作用にこだわる関数型言語では特別な地位がある

ちなみにScalaではVectorという名前のもう一つの不変コレクションが多用されているんだが
これのRust版あるのかな? 中身は1ノード32要素のトライ木
2024/10/16(水) 20:48:00.68ID:jDyVYSBS
ゆーてClojureとかHylangとか今ドキLisp女子はlist processingナニソレって感じのやつばっかやん
318デフォルトの名無しさん
垢版 |
2024/10/16(水) 21:41:36.61ID:NMNSAXL7
やっぱりこのスレ関数型言語わかる人多いの?
C/C++系から入った自分としてはサッパリわからん
2024/10/16(水) 22:33:14.93ID:9ExG49iw
>>318
パラダイムは実際にはグラデーション的で、要素が混ざり合ってる。
明瞭に線を引いて分類できるわけではない。
ML 系とか LISP 系とかは関数型みたいに言われることは多いんだが実際には関数型要素が強めのマルチパラダイムって感じで、 C++ を使いこなせる人なら入門書をちゃんと読めば使えるくらいの難易度。

誰もが文句なく関数型に分類するメジャーな汎用プログラミング言語は Haskell くらいだと思う。

パラダイムは脇に置くとして、 ML 系はインデントで構造を表す文法だったり LISP 系は丸括弧ばかりで構造を表すという外観の違いの段階で忌避感を持っちゃう人は結構いるかも?
320デフォルトの名無しさん
垢版 |
2024/10/16(水) 23:59:33.67ID:NMNSAXL7
Rustで使うもの (式指向という考え方, match式, 代数的データ型, リストやOptionへのmap, filterなどの操作等) は理解できてるし、良いなと思って使えてる
それでも Lisp や Haskell は難しいという印象があるんだよね
指摘の通り見た目の見慣れなさで抵抗感があるだけなのかもしれない
2024/10/17(木) 00:17:27.82ID:CZAZeUbm
> ML 系はインデントで構造を表す文法

Haskell や F# が人気なのは分かるけど、OCaml や Standard ML を差し置いて勝手に ML 系の代表ヅラしないでくれますかね……
2024/10/17(木) 00:25:33.00ID:NeG4778y
元々は研究用の言語でコンパイラ開発とか特定の用途以外だと実用性低いし
ほとんど趣味の領域だから無理に手を出さなくていいよ
Haskellの知識があるとRustのtraitとか?演算子(Result戻し)に馴染みやすくなるけど
そのためにHaskellを勉強するほどではない
2024/10/17(木) 00:26:57.93ID:SxNRrx7E
>>321
Hakell は ML 系ではない扱いだろ。
2024/10/17(木) 00:55:24.22ID:yABRuexK
>>319
関数型の定義は何?
325デフォルトの名無しさん
垢版 |
2024/10/17(木) 01:12:31.87ID:WrCN832N
>>296
Haskellは好きだけど、他の言語でそんな事しねーわw
郷に入っては郷に従えが基本。

パフォーマンスと人間関係を犠牲にしてまでする事じゃない。
326デフォルトの名無しさん
垢版 |
2024/10/17(木) 01:44:33.23ID:WrCN832N
>>299
関数型プログラミングが提唱される前の言語だから、関数合成とか考慮されてないからとか?

Lispは歴史的にLisp以外に関数型言語が無い時代があるので、手続き型言語をお手本にコードが書かれてloop使いまくりの手続き型言語っぽいLispコードが多かったとは聞いている。
327デフォルトの名無しさん
垢版 |
2024/10/17(木) 01:57:40.19ID:WrCN832N
>>318
多分、変数がイミュータブル(不変)だと何がありがたいのかは何かしら関数型言語触らないと分からないと思う。

なので、Rustに飛びつく人は(全員ではないにしろ)関数型言語を触ったことがある人が多いとは思う。
2024/10/17(木) 03:22:22.09ID:FXzuQNl3
rustは関数型言語の特徴を一通り搭載しつつ、あえて数学用語はあまり使わない所が良い。関数型というとプログラム作らずに圏論の話に明け暮れる人が多すぎ。
rustはプログラムを書くために実用的な機能にまとめましたって感じでいい。
2024/10/17(木) 03:29:08.36ID:FXzuQNl3
lispが読めないって人はテキストエディタでカッコを全部スペースに置換してしまえばいい。
そしたらインデントだけ見えるようになる。
カッコを見ないのが正解。
自分はカッコの表示on/off機能をエディタに入れてる。
2024/10/17(木) 06:58:43.79ID:yABRuexK
関数型言語とは何かを定義せず雰囲気てわ分類するなよ
よくそんなオツムでプログラミングやってんな
2024/10/17(木) 07:48:34.04ID:ETsUhebR
ユーザー視点なら、単なる「関数型言語」というラベルくらいでいいんじゃない?
バズワードみたいなもの。

そもそも「関数」「計算可能関数 」を理解しているやつはどれくらいいるんかしらん。
2024/10/17(木) 08:51:31.65ID:SxNRrx7E
>>324
関数の入出力でプログラムを構成するスタイルってくらいのふわっとした定義しかない。
それをサポートする言語機能が多いか少ないかでグラデーションになってる。

クロージャがあれば関数型っぽいし、関数合成があればもっとだし、カリー化があればいかにもぽいぽい。
2024/10/17(木) 09:44:28.22ID:Dr9I7rOm
>>311
firefoxでも全然使われてないRust
2024/10/17(木) 12:07:14.38ID:wG5d2OUn
知りもしないことを知ったかぶりして書くやつが多いスレだこと
2024/10/17(木) 15:01:11.80ID:HAj7NAac
きみらRustでVecとかC++でvectorとか使ってんの?
なんでLinkedList使わんの?
336デフォルトの名無しさん
垢版 |
2024/10/17(木) 15:05:42.63ID:HAj7NAac
>>328
>関数型というとプログラム作らずに圏論の話に明け暮れる人が多すぎ。

わかる
そういう人ばかりじゃないと思うけどそういう人が悪目立ちするのは事実鬱陶しい
337デフォルトの名無しさん
垢版 |
2024/10/17(木) 16:50:02.90ID:hLaeUZg0
>>335
アンロールドリンクドリストならベクターより良いよ
338デフォルトの名無しさん
垢版 |
2024/10/17(木) 20:18:17.74ID:9pxlHN7V
>>324
普通はこういう風に説明される
https://web.sfc.keio.ac.jp/~hattori/prog-theory/ja/functional.html

1. プログラムは関数定義の集合であり、関数呼び出しによってそれらを組み合わせる。
2. 関数は first class object である。
3. 文という単位は無く、プログラムの実行とは式を評価することである。
4. 参照透過性がある。

主に、2が便利だから、rustにも部分的に採用されている
2024/10/17(木) 20:46:18.51ID:yABRuexK
>>338
1と2で意味被ってんじゃん
なにその頭悪い定義
自分でコピペしてて疑問に思わないのか?
340デフォルトの名無しさん
垢版 |
2024/10/17(木) 21:11:20.46ID:9pxlHN7V
>>339
1と2って全然違うこと言ってるんだけど、旧帝大の工学系ならみんな習うんだわ
専門学校卒か?涙拭けよ
2024/10/17(木) 21:25:15.67ID:zXjn5afM
>>338
ウケるw
2024/10/17(木) 21:25:56.56ID:zXjn5afM
>>339
さらにウケるw
343デフォルトの名無しさん
垢版 |
2024/10/17(木) 21:46:24.33ID:WrCN832N
>>328
Haskellerの一部しか圏論言ってないと思うけど…。
(確かに声は大きいが)

モナドで躓く人や、モナドの理解がまだ浅い人は圏論言わないし、OCamlやF#、SMLな人も圏論言わない。
(そして、モナドを深く理解した人でも全員が圏論言うわけではない)

Lisp系の人は言わずもがな。

関数型言語を使ってる人の中でも圏論言う人はごく少数。
(繰り返すが、一部の人の声が大きいのは認める)
2024/10/17(木) 21:51:50.24ID:yABRuexK
>>340
そこで具体的に説明すればワンパンで終了なのにしないんだよ
おれは知ってるの匂わせだけ
そういうヘタレいらーねから
345デフォルトの名無しさん
垢版 |
2024/10/17(木) 21:58:01.60ID:WrCN832N
>>338
Rustの説明としては弱いかな。
2はJavaもC#も持ってるし。

自分は4に重きを置いた手続き型言語って位置付けだな。
マルチスレッドプログラミングで4が重要。
(ただし、Haskellは遅延評価なので4を生かしきれず、Idris2の様な正格評価版Haskellを生み出した)

あとは、C並みに速いだけだったらOCamlやSMLも同じこと言ってるので、2,4を満たしつつGCが無いのがRustの特徴だと思う。
2024/10/17(木) 22:51:01.11ID:C0hMoyx0
言語が生き残るかどうかは
ある程度の広さがある分野においてその言語が必須かどうかで決まる
例えば広まってるOS環境での主開発言語と公式で定められたりウェブブラウザのように特定言語が強いられるような環境における利用必須もあれば
C言語のように速さと省メモリ性で他とは大差の唯一性による必須もある

つまり関数型によるメリットなんて二の次なのだ
C言語と同等の速さと省メモリ性を持ちつつ様々な安全性も保証するRustはCに替わって広い分野での必須言語となりつつある
そのRustがたまたま関数型の特徴を多く兼ね備えて非常に使いやすいというだけにすぎない
2024/10/17(木) 23:33:24.78ID:784LeBrK
突然の演説
2024/10/18(金) 00:37:38.20ID:eikO6PmP
>>346
>C言語と同等の速さと省メモリ性
誇大広告を鵜呑みにする集団幻覚。
349デフォルトの名無しさん
垢版 |
2024/10/18(金) 03:49:07.30ID:5Kk3482a
>>344
おまえが馬鹿なだけ
普通の頭があれば匂わせで全部判る
2024/10/18(金) 08:02:39.80ID:Zig2xljb
えっAPLもっ?
2024/10/18(金) 08:57:56.68ID:phux1vRq
>>340
旧帝大の工学系ってこんなにレベル低いのか
日本終わっとるな
352デフォルトの名無しさん
垢版 |
2024/10/18(金) 09:16:52.85ID:zss9wXA+
いやまあ>>338 の1と2は全然別のことを言ってるだろ
これで説明が足りないと感じる人はFirst class objectの意味を知らないとかか?
353デフォルトの名無しさん
垢版 |
2024/10/18(金) 09:31:39.70ID:ady3VKii
関数を組み合わせるってコンビネーターがないと組み合わせられないからね
ファーストクラス関数がないとコンビネーターは無理だからな
354デフォルトの名無しさん
垢版 |
2024/10/18(金) 09:32:07.67ID:zss9wXA+
解説したらワンパン終了というが、こう言う時の解説って案外難しいんだよな
相手が「first class object」の意味を知らないのか、「関数」の意味を知らないのか、日本語の文法を知らないのか、それとも文を読む気がないのか、はたまたレスバで勝ちたくて因縁付けてるだけなのか
相手の状態によって適切な解説は異なる。相手の知識をエスパーして解説を始めても意外とフィットしなくてワンパンで終わらない

掲示板でそこまでの手間をかけても、相手がレスバで勝ちたいだけだったら何も得られない。だから馬鹿にして去るのが最適解になってしまう。
2024/10/18(金) 11:13:30.31ID:wVDH4S6Q
>相手の知識をエスパーして解説を始めても意外とフィットしなくて

レスバが目的なら判らないフリしてるだけだからフィットする訳がない
2024/10/18(金) 11:20:18.93ID:/SvZNagR
>>348
その文言に騙されたヤツはほんと多いと思う
357デフォルトの名無しさん
垢版 |
2024/10/18(金) 13:34:55.49ID:io02HZIQ
>>339
例えばC言語の場合は関数は第一級オブジェクトじゃないけど、それは知ってる?
2024/10/18(金) 13:52:02.38ID:xbVzWiEk
>>353
「プログラムは関数定義の集合であり、関数呼び出しによってそれらを組み合わせる」と書いてあるようにコンビネーター前提とした関数の組み合わせの話ではないでしょ

それにコンビネーターなくても関数合成も可能だし関数がファーストクラスじゃなくてもファーストクラス関数風に扱える言語要素があればコンビネーターを使える

そもそも>>388の引用元が関数型の定義でも関数型言語の定義でもなくて関数型言語と呼ばれるものに多く見られる特徴の一部を列挙してものでしかないから関数型(言語)の定義だと思って読んではいけない
2024/10/18(金) 14:00:22.06ID:xbVzWiEk
>「1. プログラムは関数定義の集合であり、関数呼び出しによってそれらを組み合わせる。」

関数型言語でも関数定義以外にもモジュールや型や変数の定義があるので
関数定義の集合というと言い過ぎ

厳密な話ではなくプログラムの捉え方のようなざっくりした話であれば
C言語で書いた手続き型的なプログラムでも1は成り立つので
結局何が特徴だと言いたいのかわからない残念な文章
2024/10/18(金) 14:26:18.56ID:at3pRl/S
パラダイムはプログラムの構成の話なので、 C でオブジェクト指向的なプログラムを書いてもいいし関数指向的に書いてもいい。
言語としてクロージャがなくても構造体と関数の組をクロージャと見做して構成することも出来る。
ただ、なるべく直接的に言語の機能としてサポートがあるに越したことは無いし、常識的には言語が想定している形でプログラムを構成したほうが楽ってだけの話だ。

言語の機能での分類は「だいたいこっち寄り」くらいのことしか言えない曖昧なもんだわ。
2024/10/18(金) 17:16:35.88ID:0JUhcpKJ
>>358
一連のレスで唯一CSの教養を感じるわ
そのとおりであれは定義でもなんでもなく、手続き型言語に関数風味をつけた言語の紹介文でしかない
1,2が当然のように別物といってるやつは計算基礎論履修してないわな

それでも1をエスパーすると関数の集合でなく合成と訂正すればまぁ理解できる
となると関数がビルディングブロックなので2の説明は不要となる

あとファーストクラスオブジェクトってのも怪しい名称だわな
手続き型言語でインラインで関数定義できる程度のことをかっこつけて言ってるだけしか聞こえん
2024/10/18(金) 17:47:07.37ID:72lp8MJn
>>361
さすがにその理解で他人をけなすのは……

第一級オブジェクトはwikipedia参照したほうがいいな。意味としては「関数の定義域・値域として他のオブジェクトと同様に使える」ということだから、単にプログラマが使えるということでは無いよ。

>>338の1は関数の集合を定義域値域にできるとは言っていない。
2は関数集合(の部分集合)を定義域・値域にできるという話だから、基本的に1とは別の話。
363デフォルトの名無しさん
垢版 |
2024/10/18(金) 18:29:51.87ID:ady3VKii
>1. プログラムは関数定義の集合であり、
>関数呼び出しによってそれらを組み合わせる。
関数定義の集合はプログラムってことだから
例えば{fの定義,gの定義}はプログラムだろ
fの定義が f (x) =fの式 でgの定義が g (x) =gの式とすると
fの引数xにgを入れてを呼び出して f (g) =fの式の中のxをgに置き換えた式 になって
f ( g) =f式の中のxをgに置き換えた式 も関数定義だから
{fの定義、gの定義、fgの定義}もプログラムってことでしょ
3によってプログラムの実行とはfgの式とかを評価することでしょ
2024/10/18(金) 19:42:44.39ID:v0IxkFYT
>>362
それは手続き型言語の考え方
定義域、値域とかいいだしたら論理が循環する
365デフォルトの名無しさん
垢版 |
2024/10/18(金) 19:55:50.08ID:ndvmbteL
363が全然判ってなくて草
366デフォルトの名無しさん
垢版 |
2024/10/18(金) 21:19:37.07ID:6b0+FHXo
>>357
関数ポインタはあるじゃん
クロージャみたいに環境を持った関数は作れないけど
367デフォルトの名無しさん
垢版 |
2024/10/18(金) 21:27:21.74ID:Yil/SvXx
first class objectってのは、無名で扱える、関数の引数に渡せる、関数の返却値として返せる、を満たすものだよ
C言語の関数は必ず関数名を与えないといけないからfirst class objectではない

学部レベルの講義で独自理論なんか扱うわけない。>>338 で引用した説明が通説になっている
それを迂闊にも否定した >>339 は反省しろってことだな
2024/10/18(金) 21:33:52.38ID:v0IxkFYT
>>367
ラムダ算法をベースに考えた場合ファーストもくそもねーんだよ
全部関数
まじCSの教養ないぞお前
369デフォルトの名無しさん
垢版 |
2024/10/18(金) 22:19:50.60ID:VQpP6XIE
>>348
んでも、上で書いた通りOCamlやSMLも誇大広告してたし、さらに言えばJITコンパイラ出した当初のJavaやC#も似たような誇大広告してたんだけどね。
2024/10/18(金) 22:55:23.05ID:36/T9R8D
「関数型プログラミング」にも「第一級オブジェクト」にも言語の垣根を超えた一般的な定義というものはない
「オブジェクト指向」を自称する言語たちがそれぞれ微妙に異なるオブジェクトを実装しているのとほぼ同じ
2024/10/18(金) 23:00:20.33ID:36/T9R8D
てかどうでもいいけどfirst-class objectって英語圏ネイティブからするとどういう印象を受ける言葉なんだろうね
masterとかblacklistなんかとは比べ物にならないレベルで明確にpolitically incorrectな気がするけど
372デフォルトの名無しさん
垢版 |
2024/10/18(金) 23:10:22.32ID:Py1NdU9l
>>364
それは流石に関数に対する理解が浅いかと。

関数は要素と像のペアの集合なんだから、定義域と値域は関数に必ず存在する重要な性質だろ。
それを無視するのは関数の本質を無視するようなもの。

「定義域、値域とかいいだしたら論理が循環する」と言うなら、>338 に関連して定義域、値域よりも関数の定義に近い重要な性質って何よ?
373デフォルトの名無しさん
垢版 |
2024/10/18(金) 23:28:21.46ID:6b0+FHXo
理解不足かもしれないけど「『副作用の無い、単に写像として表現できる関数』を中心に組み立てる」くらいの認識じゃだめなの?
数学的な意味での定義域はプログラミングでは成り立たない気がする
引数の型がi32なら、その関数には32ビット整数の取り得る値すべてが入るわけだし
ゼロ除算は数学上は定義できないけど、プログラムとしては書けてしまうから「考慮しない」わけにはいかず、エラー処理が必要なわけで
2024/10/18(金) 23:35:59.34ID:cbeCWz4D
ガロア体の話?
2024/10/18(金) 23:56:20.42ID:US/DDn9d
モダンな関数型プログラミングのサポートもメモリ安全性も今では必須の前提になっている
そのうえでC言語と同等の速さと省メモリ性を兼ね備えたRustだけが核心部でも使われ生き残るのさ
2024/10/18(金) 23:59:05.04ID:x/LLoMNV
>>375
>そのうえでC言語と同等の速さと省メモリ性を兼ね備えたRust
ダウト
377デフォルトの名無しさん
垢版 |
2024/10/18(金) 23:59:21.56ID:6b0+FHXo
プログラミングの上ではある程度の割り切りはしてると思う
例えば「入力の文字列を2回繰り返した文字列を返す (例. ABC -> ABCABC) 」関数は、理想的には任意の文字列を渡せるけど、PCのメモリを食い尽くすほど長い文字列を与えたらプログラムが停止するよね
だからといって「この関数は純粋ではない」とは言わなくて、それでも実用上は関数として扱う、といったところはあると思う
378デフォルトの名無しさん
垢版 |
2024/10/19(土) 01:37:07.63ID:/2TSLe1L
>>373
大雑把に言えばそうだけど、Lisp系を関数型言語に含める人と含めない人(MLの系譜の言語だけが関数型言語)で意見が食い違って争いというか、Lisp系含めない人は比較的若い人が多いので、(関数型言語の条件にパターンマッチは必須じゃないなどと)訂正される。

若い人でも情報系の学校でLispを関数型言語って習うと思うが、世間一般に普及してるとは言い難い。
2024/10/19(土) 02:59:24.38ID:zdwsITl3
ぶっちゃけLispってもう年寄りしか使ってないよね
2024/10/19(土) 03:38:52.89ID:OaEQIxry
Lispは使うとか使わないとかじゃない
言語オタク度が一定のレベルに達すると常にそこにあることが見えるようになるものだ
2024/10/19(土) 05:03:40.93ID:pGZZ/Z6D
Erlangですねわかります
2024/10/19(土) 07:03:26.74ID:09S67de8
昨日リリースされたRust 1.82で、やっと Box<T>::new_uninit() が安定化された

これ、前にトラブってた、bindgenにC++のコンストラクタを作らせるとデータが壊れる件の解決策になるやん!
と思って、喜び勇んでbindgenのリポジトリ見に行ったら、特に対応予定はないみたいだった
2024/10/19(土) 10:54:30.72ID:3T8uATjn
Erlang の OTP に相当するのって Rust では何?
2024/10/19(土) 13:15:37.02ID:ZlmyUR62
>>383
OTP は役割が広すぎる。
どういうことを期待して「相当」と言ってるのかもうちょっとくわしく。
2024/10/19(土) 15:16:05.33ID:914NuxWA
>>383
tokio
2024/10/19(土) 16:54:27.33ID:zdwsITl3
今ってtokio一人勝ちってことでいいの?
他のランタイムに勝ち目ある?

tauriはtokioだけど、一応抽象化して直接見えないようにしてる努力は感じられた
でも実際にtokio以外を混ぜたらどうなるのかな? バグるなら抽象化した意味がないが
2024/10/19(土) 19:34:22.94ID:/3C3bE8g
>>372
定義域とか値域とか言い出してるあたりCS修めてない匂いプンプンするけど
百歩譲ってお前が言ってるのは型理論の範疇
型無の関数型がありえる以上関数型の定義とは直接関係ない
2024/10/19(土) 20:35:05.03ID:11v9Pc45
>型無の関数型がありえる以上

ちょっと待って、それって「関数型」の定義が与えられてなけりゃ言えないことでしょ。
2024/10/19(土) 22:16:54.49ID:/3C3bE8g
関数型言語
390デフォルトの名無しさん
垢版 |
2024/10/20(日) 02:22:08.35ID:IoIIyUOe
>>387
「関数」と「関数型」をごっちゃにしていない?
一連の話は「関数」の話で「関数型」じゃないよ.

そもそも「関数型」が一級オブジェクトの言語って存在するっけ?
391デフォルトの名無しさん
垢版 |
2024/10/20(日) 07:51:49.41ID:Rpp5gjxc
横からだが、全ての関数型言語は関数型も一級オブジェクトだよ。
意味が無いから無いだけで、map関数の逆バージョン(関数と値の立場逆転)も作れる。

pam _ [] = []
pam x (f:fs) = f x:pam x fs

pam 1 [(+1), (+2), (+3)] = [2,3,4]
392デフォルトの名無しさん
垢版 |
2024/10/20(日) 08:53:33.20ID:vZg//j7Z
そうなのよね。CS振りかざして偉そうにしてるヤツは単に分かってないだけで的外れ
393デフォルトの名無しさん
垢版 |
2024/10/20(日) 09:40:05.16ID:IoIIyUOe
>>391
関数型自体をオブジェクトにして保存したり実行時解釈したりってできたっけ?
Rustならジェネリック関数の型引数を変数に保存して使うイメージ.
C++ならテンプレート関数のテンプレート引数を変数にして実行時解釈する感じ.

スクリプト言語とかならできるかな?
Rubyはできた気がする.Pythonはどうだったっけ?
JavaScriptはプロトタイプチェーンだからできるか.JavaScriptのプロトタイプオブジェクトを型と言って良いのか微妙だけど.
2024/10/20(日) 09:41:59.72ID:N14K/WsC
>>286
言語は関係なしにプログラマが優秀なだけだろ
2024/10/20(日) 10:01:17.80ID:KK2kuO2o
>>391
その例は単に関数がfirst classというだけじゃん

Idrisとかなら関数の型を受け取って別の関数の型を生成して返すような関数が作れるので関数の型もfirst classと言える
396デフォルトの名無しさん
垢版 |
2024/10/20(日) 10:37:31.29ID:LzrvAVJD
歯透ける厨と同じ臭いがプンプンする
2024/10/20(日) 13:32:41.76ID:AQmfmnaz

どこからか「関数型」が指すのがfunctionalからfunction typeにすり替わってないか
2024/10/20(日) 14:28:18.13ID:xF+HnWMo
すり替わってるわけではない
>>390の最後の行から違う定義の話に逸れただけ
おかけで関数型を理解してない人が炙り出されて結果オーライ
399デフォルトの名無しさん
垢版 |
2024/10/20(日) 14:45:25.09ID:Rpp5gjxc
>>393
関数型言語はオブジェクト指向じゃないのでオブジェクトは無いが…。
(OCamlならやCommon-Lispならオブジェクト指向もサポートしてるので、出来るかもしれないが)

というか、「全ての関数型言語は」と書いたのに、あなたの出す言語に一個も関数型言語は入ってないのだが…。

普通にできるジェネリック関数とか区別せずに、全ての関数でできる。

f = (+1)
g = print
h = g.f
h 1 =
2
と出力

mapM_ h [1..3] =
2
3
4
と出力

sequence_ [h 1, h 2, h 3] =
mapM_の時と同じ結果

(sequence_.tail) [h 1, h 2, h 3] =
3
4
と出力
400デフォルトの名無しさん
垢版 |
2024/10/20(日) 14:51:20.54ID:Rpp5gjxc
あ、Haskell意外だと副作用のある関数の扱いは分からんが、普通の関数なら全ての関数型言語はできる。
むしろ、それがFP(関数プログラミング)で提唱されていること。
2024/10/20(日) 17:34:13.10ID:xPa/dMaC
そして誰もツッコミすらしなくなった・・・
402デフォルトの名無しさん
垢版 |
2024/10/20(日) 17:43:19.05ID:IoIIyUOe
>>398
「関数型」言い始めたのはその前の>387からだろ.
>390はその流れを受けているだけ.

>>393
もともとの話が>338(1,2,が同じことを言っているのか別のことを言っているのか)の話なんだから,その文脈での"Object"だよ.
とりあえずWikipediaの「第一級オブジェクト」あたりを下敷きにすればいいんじゃね?
ja.wikipedia.org/wiki/%E7%AC%AC%E4%B8%80%E7%B4%

> 普通にできるジェネリック関数とか区別せずに、全ての関数でできる。
ということだけど,Haskellとかの関数型言語って,mapとかの高階関数そのものを引数にしたり戻り値にしたりできたっけ?
2024/10/20(日) 17:45:10.88ID:PyTRrFhl
そろそろRustの話しろよ
2024/10/20(日) 17:58:45.35ID:2ZyMYwfA
>ということだけど,Haskellとかの関数型言語って,mapとかの高階関数そのものを引数にしたり戻り値にしたりできたっけ?
そらできるだろ
逆に関数がファーストクラスの言語でできないやつあるの?
2024/10/20(日) 18:04:59.62ID:jAtz6juv
そもそもスレチで鮨
https://srad.jp/comment/135132
2024/10/20(日) 18:07:49.61ID:gkezQsQG
>>402
>>387の言ってる関数型はfunction typeじゃなくてfunctional programming (languages)でしょ
「型無の関数型(言語)」の意味が通じてなさそうだからわざわざ言い直してるんじゃない?
407デフォルトの名無しさん
垢版 |
2024/10/20(日) 18:16:41.15ID:Rpp5gjxc
>>402
高階関数そのものを?
普通にできる。

f mf f xs = mf f xs

f map (+1) [1..3] = [2,3,4]
408デフォルトの名無しさん
垢版 |
2024/10/20(日) 18:20:10.46ID:IoIIyUOe
>>406
もともとの話が>338(1,2,が同じことを言っているのか別のことを言っているのか)の話なんだから,その文脈での"関数"だよ.

> 「型無の関数型(言語)」の意味が通じてなさそうだからわざわざ言い直してるんじゃない?
「意味が通じてなさそう」とか言われても,「型無の関数型」自体が>387初出だから.>372に対してではなく自分に対して言い直しているのかしらん?

>407
できるのね.ありがとう.
そろそろ苦情が出てるしレスやめるわ.
409デフォルトの名無しさん
垢版 |
2024/10/20(日) 18:26:43.67ID:Rpp5gjxc
カリー化してxsを見た目上消すのは関数を返すとみなせる。

f mf f = mf f
410デフォルトの名無しさん
垢版 |
2024/10/20(日) 18:27:17.94ID:Rpp5gjxc
あいよ
2024/10/20(日) 18:37:12.50ID:+u+XD+zR
実現方法はキャプチャしたクロージャとかでもいいんだろ
他にも構造体とそれ用のメソッドを用意する形でも実現できる
関数という名に囚われて関数自体を返さなければいけないわけではない
2024/10/20(日) 23:14:31.47ID:Bo7WX30F
>>406
そりゃねえ、関数型言語の定義の議論をしているところにいきなり「型無の関数型(言語)がありえる」なんてのを
根拠に持ち出したら意味が通じないわ。
2024/10/21(月) 09:54:32.14ID:WDt/GORo
もう病気の類なんじゃないのかなこの人は
アスペを認めるとザワザワして発狂してしまうの?
2024/10/21(月) 14:02:30.37ID:n20TdxL4
>>392
話の流れは追ってないけど、東大文系学科中退のホリエモン、
(もともと所属学科が存在しない)ハーバード大で法律と数学
の単位を取って中退したビルゲイツと、Fラン大学でcs学科
専攻した人を比較するのはおかしいと思うな。
2024/10/21(月) 22:09:07.40ID:SnMtmJ3l
>>378
パターンマッチ有り無しとか些末すぎる
lispマクロがなぜ強力なのかを理論的に説明できないやつは関数型言語が何かを理解できてない
2024/10/21(月) 22:49:21.88ID:/PsiTyLC
>>415
Lispのマクロは健全なマクロ(hygienic macro)ではない
2024/10/21(月) 23:05:26.66ID:hCFqhCaa
>>415
Lispではコードもデータも全部同じS式なので
S式で書かれたコード片をそのままデータとして扱えるから
というのがLispのマクロが強力な最大の理由

でもこれは関数型の話とはあまり関係と思う
418デフォルトの名無しさん
垢版 |
2024/10/22(火) 00:53:30.71ID:OQZ/hYZy
>>415
lispマクロと関数型言語は関係なくね?
2024/10/22(火) 02:07:57.31ID:auCI67yl
>>417
それがあのシンプルな言語仕様で実現できるのはラムダ計算を計算モデルに持つから
それが関数型言語のパワーを端的に表している
420デフォルトの名無しさん
垢版 |
2024/10/22(火) 06:02:08.36ID:rwk9TcPR
>>415
lispマクロってCommon-Lispのマクロだよね?
SchemeやarcなどLisp系にも色々あるのに、Common-LispがいかにもLisp全体であるかのように言わないでいただきたい。
421デフォルトの名無しさん
垢版 |
2024/10/22(火) 21:51:40.07ID:f0BQn25L
ここはLispスレ?
2024/10/22(火) 21:54:55.10ID:I9yNs4FT
はい、そうです
2024/10/22(火) 21:59:52.45ID:nxkbQsPd
>>416
その点Rustは健全なマクロ(衛生的なマクロ)だから優れてるな
2024/10/22(火) 22:50:58.38ID:yMGUdyDA
>>419
ラムダ計算をベースとしてるのはLispに限った話じゃないので
Lispのマクロが他に比べて強力な理由にはならないよね?
2024/10/22(火) 23:33:18.43ID:yd5fGGcj
ラムダ計算が計算モデルに持つとは、例えば自然数やcons cellなどの値がすべてチャーチエンコーディング等の手法を利用してラムダ項による表現を持つという意味でしょうか
不可能ではないかもしれませんが、esolang以外ではあまり聞きませんな
2024/10/23(水) 00:17:49.94ID:+ikzunZs
型無しのラムダ計算だと
|f| f(f)
で自分に自分を渡すみたいな気持ち悪い事ができるけど
一般的な関数型言語の型付きラムダ計算だと無理なんだよね

macro_rules! combinator { ($f:expr) => { ($f)($f) }; }
とかしてもコンパイルできるcombinator!(f)が存在しないはず
何か裏技あるかもしれないけど
2024/10/23(水) 00:50:41.84ID:uXSdyuX/
>>426
https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=4e875602eb434b87811e7f8043069df1

別に裏技っぽいことは何もいらないが……
2024/10/23(水) 00:54:14.76ID:XMcvf1I0
>>423
健全なマクロは健全にしか出来ないんだよ。
意図的に衝突させるという自由は奪われる。
普通にしてたら健全なマクロになりつつ必要なときにはそうじゃない選択もあって欲しい。
健全なマクロが優れているということはない。
状況による。
2024/10/23(水) 01:19:20.88ID:wus7H+cg
>>428
常に健全なマクロが優秀
https://ja.wikipedia.org/wiki/%E5%81%A5%E5%85%A8%E3%81%AA%E3%83%9E%E3%82%AF%E3%83%AD
2024/10/23(水) 08:51:56.69ID:4l11/KhE
>>429
そういうなら根拠を提示しなよ
2024/10/23(水) 09:46:54.15ID:reDRncMZ
まあ「コーダーのミスを許さない」というRustのコンセプト的には、余計な束縛をしない健全マクロのほうがビックリネタ減るわな。
2024/10/23(水) 12:28:40.45ID:wus7H+cg
>>430
健全なマクロが優秀である根拠は>>429で示した
2024/10/23(水) 12:55:59.93ID:E1QNIy5A
>>427
macro_rules! combinator { ($f:expr) => { ($f)($f) }; }

macro_rules! combinator { ($f:expr) => { (($f)($f)) }; }
にしないと抜け道があるなw
これだからマクロは苦手
2024/10/23(水) 13:44:18.19ID:uXSdyuX/
>>433
変えても何も変わらないし、関係ない
マクロで定義してるこのcombinatorを関数にして型を付けようとすると、Haskellで言うRank2Types拡張相当のリッチな型が必要で、それは必ずしも「一般的な関数型言語の型」ではないという話なら分かる
435デフォルトの名無しさん
垢版 |
2024/10/23(水) 14:16:45.58ID:CetgrrtL
>>423
proc_macro2 は
2024/10/23(水) 15:08:29.40ID:XMcvf1I0
>>432
書かれてないぞ。
どの部分のことを言ってる?
437デフォルトの名無しさん
垢版 |
2024/10/23(水) 15:49:07.30ID:CetgrrtL
お前らなんか作ってんの?
2024/10/23(水) 18:08:14.82ID:XMcvf1I0
身バレするから詳しいことは言えないんだ。
匿名前提のコミュニティの制約だからしょうがない
2024/10/23(水) 20:22:42.34ID:cjlpqfP+
>>428
Rustのmacro_rulesで宣言されるマクロは健全なマクロだけど
敢えてローカルスコープでマクロ宣言すれば不健全にローカル変数をそのまま使えるため両対応しているよ

>>435
手続きマクロは解析木を入力に自在だね
2024/10/23(水) 22:12:20.50ID:IFkNXH06
>>426
untypedのラムダ計算をベースにしてる言語は
Lispだけでも関数型の言語だけでもないよね

>>415で言ってたLispのマクロが強力さっていうのは
Lisp特有の話じゃなかったってことでいいのかな?
だとしたら俺の考える強力さとは違ってた
2024/10/24(木) 07:52:11.99ID:ZozkKVrc
>>440
ASTを生成するコードを作れるのは大抵強力だろ。
全然別のアプローチとしてFORTHのIMMEDIATE POSTPONEみたいなのもあるけど。
2024/10/24(木) 10:38:00.79ID:nzvp2PCa
>>441
>ASTを生成するコードを作れる
若干意味が曖昧だけどASTをいじれれば強力ということなら
それはLispに限らないし関数型言語にも限らないので
関数型言語や関数型の定義との関連は薄い
2024/10/24(木) 10:45:57.96ID:EC4ipT+P
Rustは、ASTを使ったマクロが書けるということみたいですが、
それについて詳しい書籍は有りませんか?
2024/10/24(木) 11:20:06.71ID:Izj+Eszj
AST操作ができるという意味では、Lispマクロと同等の能力を持つマクロを持つ言語は他にもあれど
AST自体がS式で非常に簡潔だからマクロを書くために追加で学習する事項はほとんどないし、言語実装側もかんたん、というのがLispマクロの特色と言えるかもね
2024/10/24(木) 11:46:01.90ID:oHvtQW/4
>>443
本は知らんけどネットの情報だけで充分に学習出来た(経験談)
2024/10/24(木) 12:02:07.13ID:nzvp2PCa
>>443
本じゃないけどdtolnayのprocedural macros workshop
本ならManningのマクロ本
2024/10/24(木) 14:32:18.09ID:dQJ9Pscb
>>442
だからそういうことでしょ。

マクロは関数型言語・関数型プログラミングと直接関係無いし、Lispマクロが強力なのはASTを直接操作するメタプログラミングだからであって関数~~と直接関係無い。
2024/10/24(木) 16:46:48.00ID:zniBHQh+
昔CommonLispでゲームサーバーとか作ってたけどね。マクロ書くのが楽なのは良かったね。
どちらかというと稼働中なサーバー止めずに関数単位でビルドできるとか型を指定して最適化しやすいってのがいい所だったけど真っ当なlispはAllegro Commom Lisp ぐらいしかないし、高くて勧められない。
今はもうrustの方が圧倒的に便利だし、マクロも必要十分と思ってる。s式だけに拘る理由はないよ。
2024/10/24(木) 17:02:46.99ID:zniBHQh+
マクロで抽象度高めるのはいいけど、やりすぎると自分以外に分からないDSLになる。程々でいいのよ。
Rustは頑張ればなんでも書けるマクロがあるけど、クレート分けたりちょっと面倒なんで程々で収まる。素人が手を出さない。ライブラリ作るような人だけ頑張ればいいの。
450デフォルトの名無しさん
垢版 |
2024/10/24(木) 17:49:54.17ID:H1OVOnXq
乱数が標準ライブラリーで使えないなんて言語ある?
2024/10/24(木) 18:03:21.93ID:Vyb04yis
>>450
RandomStateが標準ライブラリにある
用途が極少数ならそのまま使ってもよい
用途が多数なら枯渇するためシードとして用いる
シードからの生成アルゴリズムはその性質に応じて無数にあるため標準ライブラリの対象外
2024/10/24(木) 19:26:04.63ID:Izj+Eszj
>>451
RandomStateで乱数生成やったことないんだけど具体的にどうやるの?
2024/10/24(木) 19:51:11.78ID:Vyb04yis
use std::hash::{BuildHasher, RandomState};
let random_seed: u64 = RandomState::new().hash_one(0_u64);
あとはこのシードからお好みのアルゴリズムで生成
2024/10/24(木) 20:30:14.64ID:Izj+Eszj
>>453
結局標準ライブラリでは乱数生成できないってことね、OK
2024/10/24(木) 20:46:28.29ID:Vyb04yis
>>454
乱数値を得られていることを理解できない?
シードは乱数値
別のものだと思った?
456デフォルトの名無しさん
垢版 |
2024/10/24(木) 21:26:15.04ID:AJVkLJ3Q
いやシードと乱数は違うでしょ
「テスト用の適当な数値が欲しい」くらいの用途には使えないこともないけど
2024/10/24(木) 21:35:49.51ID:Vyb04yis
理解できない人向けにどうぞ
use std::hash::{BuildHasher, RandomState};
let random_value: u64 = RandomState::new().hash_one(0_u64);
ここで得られる値は乱数値

(シード値としても使えることを書いただけで混乱して理解できなくなる人がいるとは想定できずにごめんね)
2024/10/24(木) 22:02:47.28ID:2EUVLZAU
さすが複オジクオリティw

>>454
素直にrand使ってね
2024/10/24(木) 22:11:35.63ID:wLVwsEMS
そんなんでごまかせるわけないだろw
ワロタ
460デフォルトの名無しさん
垢版 |
2024/10/24(木) 22:18:39.07ID:g+5KBp/6
>>457で得られる値はgetrandomシステムコールや/dev/urandomから得ているので正真正銘の乱数値
461デフォルトの名無しさん
垢版 |
2024/10/24(木) 22:40:22.29ID:BfhK7+JQ
なんでこの程度の内容で議論が発生して第三者の解説が必要になるんだよ
2024/10/24(木) 22:41:20.63ID:wLVwsEMS
なんかnightlyにあったわ、つい最近のやつじゃん
そのゴミ生成器片付けとけよ

https://doc.rust-lang.org/nightly/std/random/index.html
https://github.com/rust-lang/rust/issues/130703
463デフォルトの名無しさん
垢版 |
2024/10/24(木) 22:52:15.99ID:g+5KBp/6
Rustの標準ライブラリはHashMapなどで使われる安全なハッシュをサポートするために各OS環境から正真正銘の乱数を得ていてそれが>>457
2024/10/25(金) 01:03:47.43ID:Y++YkFSY
>>462
これまで、標準ライブラリで乱数をサポートしないのがRustらしさだと擁護してきた信者の気持ちを踏みにじるような機能追加だな
2024/10/25(金) 01:53:32.00ID:xvw9KCma
>>464
あれはただの現状追認主義者だから、今日以降同じことを聞かれたら何食わぬ顔でstd::randomがnightlyにあるぞと言い始めるんだろう
まったくくだらない手合いだ
2024/10/25(金) 02:10:41.48ID:SHu6FAIt
それが複オジクオリティw
467デフォルトの名無しさん
垢版 |
2024/10/25(金) 11:31:42.20ID:fr1AC94B
Rust信者はRustが素晴らしいという前提から出発しているから、どんな現状でも追認するしかないんだよね
2024/10/25(金) 11:40:01.29ID:1Wl1tm3d
信者てここには一人しかおらんやん
乱数とハッシュ値の違いも分からん信者wだけど
2024/10/25(金) 20:43:07.49ID:Mvi3fEJ3
iOS/Androidに対応した「Tauri 2.0」が公開 ~「Rust」が使えるアプリフレームワーク
https://forest.watch.impress.co.jp/docs/news/1628498.html
2024/10/25(金) 21:10:43.49ID:jlqDauPO
くやしいのうwくやしいのうw
2024/10/25(金) 22:12:28.52ID:HbwYxM+j
話題を変えて無かったことにして欲しいらしいw
追い裏金の話を闇バイト強盗の話で誤魔化そうとしてもダメだろ〜
2024/10/25(金) 22:52:21.52ID:JoNG8t7V
>>454
できる
デフォルトハッシャーでも使っている
2024/10/25(金) 23:39:25.27ID:wDVIpXT3
乱数は用途によって必要な性質が違うのであまり標準に入れて欲しくないが
インターフェイスは標準で決めて欲しいとは思う。
2024/10/25(金) 23:45:41.75ID:7THBsPfL
乱数を標準ライブラリに入れてない頭おかしい言語って他にもあるの?
2024/10/26(土) 00:10:22.27ID:zGz4kG9y
あっても使い物にならないのとかあるしなぁ。
ECMAScript (JavaScript) とか C とかの乱数は使いものにならないから実質的に無いのと同じだし、意味のないものを入れるくらいなら入れないほうがマシ。
2024/10/26(土) 00:22:27.42ID:zGz4kG9y
>>474
言語仕様に書かれていないという意味では、メジャーな言語で言えば Haksell とか Scheme とか。
「標準ライブラリ」というのがどこまでの範囲を指すかにもよるので微妙な話だが。
2024/10/26(土) 00:32:15.24ID:YgyN66sk
本当に頭のいい人たちが検証を重ねて世に送り出したモノが使い物にならないとはどういうところを言うのですか?
2024/10/26(土) 00:44:55.37ID:IoqxjKuL
本当に頭のいい人たちが検証を重ねて世に送り出したモノではないというところですね……
2024/10/26(土) 01:00:53.03ID:YgyN66sk
そう言う自分も、無批判には使わずに一様性を検定するなどしてから使うけど、信頼してないからではなく
480デフォルトの名無しさん
垢版 |
2024/10/26(土) 02:13:26.68ID:w49K9FL/
>>473
同意
2024/10/26(土) 08:44:00.93ID:jdoQvLux
>>476
言語仕様と標準ライブラリの区別もつかんのかーいw

言語仕様に乱数生成ライブラリの定義がある方がむしろ珍しいだろ
2024/10/26(土) 10:04:40.94ID:zGz4kG9y
>>481
標準ライブラリは言語仕様と不可分だ。
規格に書いてあるか、公式に standard library という用語で呼んでいるのが標準ライブラリだと考えている。

ただ、変な経緯を持つものや事実上の標準のように扱われるものはあるから……。
C++ では STL (Standard Template Library) は言語仕様に取り入れられる前から STL と名乗ってた。

Haskell や Ruby のように特定の処理系が一強の場合は規格を論じるのがあまり意味ない場合もあるし。
2024/10/26(土) 10:53:28.94ID:hjzg/CzG
>>469
Tauriはゴミ
2024/10/26(土) 11:44:59.52ID:OlAES+Uo
Rustはライブラリをあまり取り込まない方針じゃなかったっけ?
変わったの?
2024/10/26(土) 12:24:14.18ID:+FwZ39pi
>>482
言語仕様と標準ライブラリ仕様の区別がついてないだけでなく規格と言語仕様の区別もついてないんだな
2024/10/26(土) 12:27:05.83ID:Q0mTv4/1
>>473
物凄い支離滅裂な主張に感じるのは俺だけか?
2024/10/26(土) 12:34:35.45ID:zGz4kG9y
>>484
Rust の標準ライブラの基礎理念はエコシステムの基盤として最小限かつ実践的であること。
肥大化させるのは良くないが、だからといって有用なものまで避けたりはしない。

常識的に考えて主要なデータ構造は標準ライブラリに入れるし、
ハッシュテーブルのハッシュには乱数を使う (いわゆるソルト) のでどうせならそれをユーザ向けに公開したってよかろうという感じ。
RandomState が std::hash の下にあるのはそういうこと。

ハッシュをかき乱す要素を入れないと意図的にハッシュが衝突するデータを入力する攻撃が成立する可能性があるので、
それを避けるために乱数を混ぜ込むものなんだよ。
2024/10/26(土) 12:36:36.70ID:zGz4kG9y
>>485
区別を付けてるから言葉を使い分けてる。
2024/10/26(土) 12:43:45.54ID:zGz4kG9y
>>486
Rust ならライブラリのインターフェイスはトレイトの形で決められるだろ。
トレイトを標準ライブラリとして用意して実装は外部のクレートに任せればよいという意味だが、なんか不自然なところある?
スレッド関係とかはそうなってるのもあると思うが。
2024/10/26(土) 12:58:01.15ID:IoqxjKuL
>>489
スレッド関係というのは具体的にはFutureのことか?
あれはasync/awaitのために必要だけど、今のところ乱数にはそれと同レベルの必要性はないじゃろ
2024/10/26(土) 14:44:24.24ID:82EWlGrQ
>>487
ハッシュテーブルのハッシュにソルト必要か?
492デフォルトの名無しさん
垢版 |
2024/10/26(土) 15:08:22.43ID:hjzg/CzG
saltは乱数ではないよ
2024/10/26(土) 21:33:32.55ID:QHYclvz0
乱数は2種類ある
1つは擬似乱数で与えられたシード(初期値)から出発して各アルゴリズムで順に生成していく
同じシードなら同じ生成列になってしまい時刻情報などをシードとして用いても推測されると生成列がバレてしまう
そこでもう1つの自然乱数をシードとして用いることで問題を解決できる
この自然乱数は計算ではなく外部のエントロピーなどから得る
これは各OS環境などでバラバラに提供されている
2024/10/26(土) 21:36:01.18ID:QHYclvz0
Rustがstd::randomで提供しようとしているのは擬似乱数ではなく自然乱数の方
もちろん自然乱数も様々なものが使える環境もあるためtrait RandomSourceを用意している
そして各環境毎に標準的に使えそうな実装をDefaultRandomSourceとして提供している
2024/10/26(土) 21:40:12.79ID:QHYclvz0
つまり擬似乱数の各アルゴリズムを実装しているクレートなどの本体部分はこれまで通り
それらの中でシードのために利用する自然乱数の取得を各環境別に書いていた部分がstd::randomを利用できるようになる
このために自然乱数の提供を標準ライブラリに入れようとしている
2024/10/26(土) 21:43:58.25ID:QHYclvz0
ちなみにHashDos攻撃を避けるために標準ライブラリのHashMapは以前から自然乱数を利用するコードとなっている
そのため我々は以前から>>457のコードの形で現行の標準ライブラリでも自然乱数を間接的に得ることができる
いずれstd::randomが安定化すると自然乱数を直接的に得られるようになる
2024/10/26(土) 22:18:58.17ID:j2ddNQEF
今日一日勉強した成果がこれかぁ

>>493
前半の話はPRNG(deterministic)とCSPRNG(unpredictable and non-deterministic)の違いで
PRNGのシードもほとんどのケースは自然乱数(真の乱数)ではなくCSPRNGを使った疑似乱数

>>494
std::randomが提供しようとしているのはCSPRNGだけでなくPRNGも検討されている
https://github.com/rust-lang/rust/issues/131606

つまり…
>>495の結論は間違いだらけ
がんばれ〜
2024/10/26(土) 22:23:14.55ID:IoqxjKuL
長々と書いてるがやっぱりまだ「シード=乱数値」と思っていそうな、それを再確認するためにチェリーピッキングしたフシがあるように読めるな……

>>496
https://doc.rust-lang.org/src/std/hash/random.rs.html#67
RandomState::newで「自然乱数」を読むのはTLSにあるKEYSを初期化するときただ1回きりなのだが、それは特に問題だと思っていないという認識で良いか
2024/10/26(土) 22:37:43.22ID:j2ddNQEF
>>498
自然乱数ではないのは>>497で書いた通り

HashDos対策的にはHashMap等の各インスタンスにつき1回しか読まないので十分
それに複数回読んだら同じ入力値に対してハッシュ値が変わるのでHashMapが機能しなくなる
2024/10/26(土) 22:46:16.13ID:IoqxjKuL
>>499
???
あんたには聞いてないし、何から何まで間違っとるよ
501デフォルトの名無しさん
垢版 |
2024/10/26(土) 22:56:45.07ID:sdYu6ROK
>>497
その決めつけはおかしいな
自然環境ノイズに基づく自然乱数が得られる環境では自然乱数が使われているよ
例えばLinuxやMac含めてUnix系ならば/dev/randomと/dev/urandomやシステムコール化したgetrandomがあり
Rustでも用いているよ
2024/10/27(日) 02:58:36.94ID:ovJMtE5q
>>501
getrandomはハードウェアから得られた値を直接返してるんじゃなく
それらをシードにして生成した疑似乱数を返してるんだよ
503デフォルトの名無しさん
垢版 |
2024/10/27(日) 09:03:06.72ID:b1uLb42O
そもそも外部のエントロピーで自然乱数列を生成出来るなら
わざわざそれをシードにして別の自然乱数列を造る必要無くね?
504デフォルトの名無しさん
垢版 |
2024/10/27(日) 11:20:29.17ID:0ovc+IwP
crates古いのしか無いと不安になるなω
sfmt 3年前
mersenne_twister (github dcrewi) 7年前
mersenne-twister (github mztikk) 1年前
rand_mt 数ヶ月
2024/10/27(日) 12:31:48.22ID:Den/VAK2
>>503
randomあたりのman
506デフォルトの名無しさん
垢版 |
2024/10/27(日) 14:02:01.43ID:j7g6Rtfs
自然乱数はランダムになるまで時間がかかるからな
短い間に何度も乱数が欲しいような時には使えない
2024/10/27(日) 16:44:26.48ID:mkB59Ft+
酷いスレだなあ
2024/10/27(日) 17:40:01.62ID:wWZS6c6H
嘘800系おじさん達のスレだから
2024/10/27(日) 19:13:29.29ID:xAbk2B9K
>>504
もうメルセンヌ・ツイスタの時代じゃないでしょ
過去のアルゴリズム
今はもっと性能の良いものがある
510デフォルトの名無しさん
垢版 |
2024/10/27(日) 21:33:13.60ID:e6AmFL8t
enum Data{
Id(usize),
}

fn main() {
let data = &Data::Id(1);
match data {
Data::Id(i) => println!("{}",i)
}
}

これでなんでData::Id(i)で参照型であるはずの値にマッチできてしかもiの型が&usizeになるのか理解できない
誰か教えて
2024/10/27(日) 21:47:12.93ID:rfQndDpU
match ergonomicsってやつ
https://github.com/rust-lang/rfcs/blob/master/text/2005-match-ergonomics.md
2024/10/27(日) 22:08:05.31ID:e6AmFL8t
>>511
ありがとうございます
一種の構文糖衣なんか
rustってこういう知ってないとわからない要素が多すぎる
2024/10/27(日) 23:41:52.09ID:Tg9DDiAK
>>497
>> std::randomが提供しようとしているのはCSPRNGだけでなくPRNGも検討されている
>> https://github.com/rust-lang/rust/issues/131606

そこ見るとChaCha8を用いようとしているから十分に強力なCSPRNG(暗号論的擬似乱数生成器)だ

>>502
擬似乱数といってもピンキリで
getrandomはまずハードウェアから十分なエントロピーを生成取得した上で
それをシードとしてChaCha20という暗号論的擬似乱数生成している
これはハードウェアからの自然乱数と同等レベルになる
514デフォルトの名無しさん
垢版 |
2024/10/27(日) 23:46:47.80ID:9kUvwHn+
自分は 512 じゃないけど関連する質問をさせてください
>>511 のリンク先を見て初めて ref というキーワードを知ったんだけど、これってどういう場面で使うの?
自分がこれまで書いた範囲では & だけで済んでて、ref が必要になったケースが多分無いんだけど、ref で無いと解決できない場面としてどういう例があるのか知りたい
(あるいは、言語のアップデートの中で必要性が薄れていったという感じ?)
2024/10/28(月) 14:20:37.64ID:ehQdeP61
>>510
こうすれば理由が判る

enum Data{
Id(usize),
Hoge(f64)
}

fn main() {
let data = [&Data::Id(1), &Data::Hoge(2.5)];
for datum in data {
match datum {
Data::Id(i) => println!("{}", i),
Data::Hoge(i) => println!("{}", i)
}
}
}


https://paiza.io/projects/BeHrG-AymCq-pMnm8S4C7g
2024/10/28(月) 15:36:29.99ID:F96bVlEH
>>513
内部で利用しているストリーム暗号方式が暗号学的に安全とされているものだからといって
それを使った乱数生成器が自動的に暗号学的に安全となるわけではないんだよ

>ハードウェアからの自然乱数と同等レベルになる
この同等レベルという意味が真の乱数と計算量的に区別不可能(computationally indistinguishable)という意味ならそれはCSPRNGの定義なのでその通り
本当に同等レベルかというともちろん違う
2024/10/28(月) 15:44:53.20ID:F96bVlEH
>>514
>(あるいは、言語のアップデートの中で必要性が薄れていったという感じ?)
↑これ
昔はThe Bookでも解説されてた
https://doc.rust-lang.org/1.33.0/book/ch18-03-pattern-syntax.html#legacy-patterns-ref-and-ref-mut

構造体の一部をborrowして一部をmoveしたいというときに必要って言われてるけど
個人的にそうしたいと思ったことがないので基本的に使ってない
2024/10/28(月) 15:56:42.93ID:F96bVlEH
非公式日本語訳にはまだ残ってた
丸6年以上も更新されてなのかぁ
https://doc.rust-jp.rs/book-ja/ch18-03-pattern-syntax.html#refとref-mutでパターンに参照を生成する
519デフォルトの名無しさん
垢版 |
2024/10/28(月) 21:38:31.01ID:duvMwVsG
>>517 >>518
サンクス
英語版のBooksの方だと過去に必要だった理由や、現在はレガシーであること等も書いてあって分かりやすかった
2024/10/28(月) 23:57:53.34ID:wC5Gxvqx
>>510
それはパターンマッチングのバインディングモードという機能
Rust公式リファレンス
https://doc.rust-lang.org/reference/patterns.html#binding-modes
状況に応じてデフォルトのバインディングモードが変わる
例えば同じ型同士だとデフォルトはムーブが適用される
片方だけ参照をマッチさせると(記述しなくても)refが自動適用される
可変参照ならref mutが自動適用される

>>514
フィールド毎に指定を変えたい時にrefを使う
例えばref自動適用は全てのフィールドに適用される
2024/10/28(月) 23:59:12.24ID:wC5Gxvqx
例えばよくあるこんな構造体を値とするHashMapがあったとして
struct Person { name: String, age: u32, }

このvalues()が返すのは&Person型なのでこう書く必要がある
for &Person { ref name, age } in hashmap.values() {
 println!("{name}: {age}");
}

ところが片方だけ参照にするとrefを記述しなくてもよくなる
for Person { name, age } in hashmap.values() {
ただしageも参照&u32になる

同様に片方だけ可変参照にするとmut refを記述しなくてもよくなる
for Person { name, age } in hashmap.values_mut() {
2024/10/29(火) 00:30:06.99ID:YvE8kkoz
rustはOSやデバイスドライバなどを作る人が使うもので、ふつうに業務アプリなどを書くには敷居が高すぎるというか、習熟のためのコストが高すぎるというか、勿体無いというか
凡人には無用(無理)なのかな
学んでいて得るものは多いけど、そういった点でHaskellに似ていると思いました
523デフォルトの名無しさん
垢版 |
2024/10/29(火) 07:09:02.81ID:LPWWq4s4
OSやデバイスドライバよりも上位の、例えばCLIアプリやバックエンドの開発にも役立つ言語だよ
Rustの利点は「低レイヤで必要なメモリ周りの管理ができる」ことだけでなくて、型による表現力の高さや、借用のなどのルールによるバグの防ぎやすさなどの強みもある
マルチスレッドだと、デッドロックは防げないけど、データレースなどの問題はコンパイル時の検査でほぼ防ぐことができる (個人的にはこれがすごく助かる)

業務アプリだと割に合わないというのは同意
Rustを理解してる人がチームに1人はいて、他の人に教えられる体制になってないと難しいと思う
習得時間をかけられなかったり、あまりレベルの高くない人もアサインするようなプロジェクトだとたぶん厳しい

簡単な言語ではないけど、Haskellほど難しくはないし、凡人には無理ってこともない (自分はRustを書いてるけど、自分だって凡人だし)
個人的に勉強しつつ、使えそうな機会があれば試しにRustで書いてみるというのはアリだと思う
2024/10/29(火) 09:24:33.94ID:G3xxa4mJ
習熟が難しいのは確かだけど、どこでコストを考えるかだと思う。開発期間が増えてもバグ取りの工数は減るとか、サーバー負荷の削減で運営費が安くなるとか。今はAIでコード生成も出来るし、難しさが必ずしもデメリットとは思わない。
2024/10/29(火) 10:26:21.77ID:2QinlXet
Rust は清書用
526デフォルトの名無しさん
垢版 |
2024/10/29(火) 12:21:21.00ID:dZcxKFDp
清書とかいう概念、実際やってるのみんな
2024/10/29(火) 12:25:27.38ID:7GiGHo3I
早くfirefoxを清書してほしい
2024/10/29(火) 12:27:45.80ID:o5unV1rL
Servo落ちまくりなんだけど、Rustの品質が低いせい?
2024/10/29(火) 13:11:11.67ID:Swi66pRZ
>>526
清書というから不思議なだけで、リファクタは常識かと。

Rustも、とりあえず動く段階からきっちり清書するまでシームレスにリファクタできればいいんだけどな。
2024/10/29(火) 14:12:45.77ID:i62m9hCf
Rustを関数型扱いするやつは
Rustも関数型もまるで理解してない
だから誰も真面目には相手してくれない
2024/10/29(火) 14:14:12.62ID:i62m9hCf
Rustほどリファクタリングに向いてない言語は無いな
2024/10/29(火) 14:45:53.32ID:IsdOq2r9
>>522
Haskell は言語自体は普段使いしやすいと思うが……。
しんどいのは副作用が存在しない (一般的に副作用とされるものが作用としてやりとりされる) という純粋関数型の部分で、このパラダイムの違いが外のシステムとの接続をやりづらくしてる。
いろんなライブラリやフレームワークの支えなしに業務システムを書くのは割に合わないし、辻褄合わせのラッパーライブラリを自分で書くのも面倒くさい。
(既にラッパーがある状況ならそんなにしんどくないけど。)
それと副作用のない世界でチューニングするのもしんどい。
必要なら仕方ないが他の言語ならしなくてよい苦労をする感じがするのがつらい。

Rust は C に ML 風の型システムを付けたくらいのごく普通のパラダイムなので、今まで業務アプリを作っていたくらいのスキルがある人にとってそんなにハードルは高いとは思わないな。
初心者が最初に手を付けるのはやめといたほうが良いとは思うが。
2024/10/29(火) 15:33:28.84ID:XrFhUcNT
>>528
コードの品質が低いんだろ
RefCellとかでちょっとしたメモリ競合リスクを検知してすぐに落ちるRustと
多少のメモリ競合リスクは無視して動き続けるC++の比較は品質というより好みの問題
2024/10/29(火) 17:51:59.87ID:sGMbaaCI
多くの人がOCaml選ばずRust選ぶ理由を知りたい
Rustより明らかに簡単
2024/10/29(火) 18:39:05.10ID:g6F4huNS
>>532
>このパラダイムの違いが外のシステムとの接続をやりづらくしてる。
あんまり関係なくね?

パラダイムの違いはHaskell自体の習得には大きく関係あるけど
そこを超えてる人ならFFIでCのコードを呼ぶのは
C#やSwiftからCのコードを呼び出すのと大差ない

Rustの場合はFFIでもコンパイラがメモリ安全性を
保証できるように注意深くAPIを設計する必要があるから
FFI書くのはHaskellよりもややハードル高い
2024/10/29(火) 20:13:57.88ID:tvwTcBQI
>>517
refをレガシーとするのは間違っているため何年も前にその記述はBookから消されている

>>519
それは古いBookなので参考にしてはいけない
現在のBookにrefをレガシーとする記述はない

>>520
その公式リファレンスの記述が正しい
パターンが「その同型値・その参照・その可変参照」それぞれと束縛される時に
パターン内の変数に対してデフォルトの挙動が「移動・参照(ref)・可変参照(ref mut)」となる
これは人間工学的に自然な動作なので無意識に恩恵に授かれる
2024/10/29(火) 20:19:56.52ID:fLzNkWkm
Firefoxでもなぜか全然使われないrust言語
538デフォルトの名無しさん
垢版 |
2024/10/29(火) 21:06:17.79ID:LPWWq4s4
Rustで多くの人が躓くのは借用やムーブのルールだと思う
ポピュラーな言語だと

fn foo(a: Vec<i32) {}
let a = Vec::default();
let b = a;
foo(b);

のような書き方でも単に参照が増えるだけだし、変数が消費されることもないから、
ここでコンパイルエラーになる時点で理解の壁がある
参照を学び始めたときも

fn bar(a: &mut Vec<i32>) {}
let mut a = Vec::default();
let mut b = &a; // これが正しい可変参照の書き方?
let c = &mut a; // それともこれ?
bar(c); // ここは bar(&mut c) じゃなくて良いの?

とかで迷う (自分はだいぶ時間がかかった)
この壁は言語のディープな部分に触れ始めたときじゃなくて、学び始めの頃にぶつかるから挫折しやすいように思う
この後もライフタイムなんかがあるし

OptionやResult, enumやパターンマッチは比較的理解しやすいし、利点も分かりやすい
539デフォルトの名無しさん
垢版 |
2024/10/29(火) 21:24:17.23ID:ZM2aHeIN
>>534
Rustに興味を持つきっかけが「表現力の強さ」ではなく「GC無しかつメモリ安全」という人が多いからじゃない?
自分の場合はC++で仕事をしてて、その次の選択肢となるとRustということで触り始めた
当時の自分は関数型言語というものを知らなかったし、Rust以外ではGoに行ってた可能性はあるけど、OCaml (あるいはHaskellやScalaやF#) は選択肢に無かったと思う
2024/10/29(火) 21:24:34.03ID:crM0J6Sa
>>538
それはどの言語でも同じ
4種類あり全て異なる

変数は不変 参照先も不変
【Rust】 let ptr: &i32 = ...
【C/C++】 const int* const ptr = ...

変数は可変 参照先は不変
【Rust】 let mut ptr: &i32 = ...
【C/C++】 const int* ptr = ...

変数は不変 参照先は可変
【Rust】 let ptr: &mut i32 = ...
【C/C++】 int* const ptr = ...

変数は可変 参照先も可変
【Rust】 let mut ptr: &mut i32 = ...
【C/C++】 int* ptr = ...
541デフォルトの名無しさん
垢版 |
2024/10/29(火) 21:29:47.89ID:Ck0fVC7d
循環参照が必要になるのは
設計者が頭悪しだからだよ
542デフォルトの名無しさん
垢版 |
2024/10/29(火) 21:46:14.89ID:LPWWq4s4
>>536
英語版の最新のBookでレガシーという記述が消えてるのは確認したけど、refの記述自体も消えてた
大抵の場合は >>520 でうまく行くけど、場合によっては必要ということか
具体的にどういう場面で必要になるかがまだわかってないけど
2024/10/29(火) 22:09:07.44ID:G3jJz52W
>>542
レガシーではないという理由で記述が削除されたのではなくて他にもレガシー化したパターンがある中でrefだけ特別にThe Bookに載せる必要はないという判断で削除されただけだよ

match ergonomics 2024のmotivationに書いてあるいくつかがrefの出番
https://github.com/rust-lang/rfcs/blob/master/text/3627-match-ergonomics-2024.md#motivation
2024/10/29(火) 22:15:46.31ID:o5unV1rL
>>533
Rustで書けば品質の高いソフトウェアができる、と言い張る奴がいたら
Servoを見せれば論破できる
545デフォルトの名無しさん
垢版 |
2024/10/29(火) 22:39:28.16ID:LPWWq4s4
>>543
サンクス
2024/10/29(火) 22:53:06.91ID:My11LZdL
Rustは関数型と主張しすぎないのが良かった。
gc無しでc++並みに速いから置き換え候補に入る。

scalaとかF#とか多少便利でもjavaやc#より遅いのでは乗り換えるメリットが少ない。

C++と比較すればrustは便利機能山盛りでメリットの方が目立つ。コードの書き方に違和感を持たせないまま関数型要素に慣らせるという戦略は上手く行ってると思う。

そこまで速度が必要なプロジェクトを組んだこと無い人には伝わりにくいのは仕方のない所。
2024/10/30(水) 08:09:26.08ID:dz8lXyhf
>>541
そういうことを言っているから、設計を動かさない枯れた技術向けの清書用言語になるんだよ。
2024/10/30(水) 10:17:17.44ID:rzL9XqtY
循環参照が必要になる話なんて誰もしてないよね?
>>541はなぜに唐突に循環参照の話をしたのか?
549デフォルトの名無しさん
垢版 |
2024/10/30(水) 14:04:48.00ID:DhwGc29G
循環参照が必要になる話は >>541 がしてるやん
2024/10/30(水) 14:55:34.14ID:B8Em1SPB
循環参照が必要だと思ったのは
書込者が頭悪しだからだよ
2024/10/30(水) 18:39:18.26ID:MMvZ6qnB
>>531
「Rustはリファクタリングしやすいか?しにくいか?」議論&投票
https://www.reddit.com/r/rust/comments/17jeezg/so_is_rust_easy_to_refactor_or_bad_to_refactor/
投票総数858件
643件 Rafactoring in Rust is Easy
215件 Refactoring in Rust is Hard
結果76%の人々がRustはリファクタリングしやすいとの結果に至った
552デフォルトの名無しさん
垢版 |
2024/10/30(水) 19:07:03.61ID:Fmew5Rd7
循環参照後から無くすって、ちょっとしたリファクタリングのレベルを超えているだろ
そのレベルの清書をマジでやるのか?
やらずにそのコードをそのままバグバグしい負債としてプロダクトに直接埋め込むんだろうどうせ

なら最初から循環参照なしで始めておこう
2024/10/30(水) 19:41:43.03ID:kddcnuFp
循環参照の問題は意図せず起こってしまうことだと思うが
リンクリストとか特定のデータ構造はたいした問題じゃない
なんかポイントがずれてないか?
554デフォルトの名無しさん
垢版 |
2024/10/30(水) 20:10:19.86ID:uApvZesn
>>522
でも速くて安全なんてキャッチフレーズ持ってるから、経営者が希望しそうな言語ではあるので将来的に現在のJavaみたいな立場の言語になりそうなのよね。>Rust
(そういえば、当時のJavaも…ゲフンゲフン)
2024/10/30(水) 20:14:02.88ID:1vbcRrkY
>>534
OCamlはRustよりもライブラリ揃っていなくてcargoのような簡易な環境もなくてコミュニティも小さくて実行速度も遅くて今から導入するメリットがなくてね
2024/10/30(水) 20:23:49.98ID:MMvZ6qnB
>>554
クラウド時代となってCPUとメモリ両方の利用リソース量がコストに直結するようになったのも大きい
オンプレミスでもハード削減や電気代減少となるため速く動く言語への移行は進むだろう
以前は扱いやすく安全な速い言語がなかったところにRustが現れた
2024/10/30(水) 20:23:51.06ID:rkQwQTjo
implするときにtrait側の境界より厳しい境界を設定するとE0276エラーになるけど、緩くても特に何も言われないんだな
しかし別にそのトレイトメソッドを緩い条件で呼べる訳ではないという
なんかlintないんかねこれ
2024/10/30(水) 20:39:06.44ID:o3z0lAnP
>>556
ほんとそれ。
昔はマシン一台あたりの I/O (通信やデータベース) に対して CPU やメモリが余ってたから実行速度なんてそんなに気にしてなかった。
クラウド時代になって使ったリソース分で課金されるようになると削れる部分は削らざるをえなくなるよな。
なにせ金額は経営陣にも理解できる数値だから。
2024/10/30(水) 21:54:35.32ID:WNH1hJk/
>>523
>>522 です
リプありがとうございました

その後の他のレスも併せて、もう少し粘って学習を続けてみようと思いました
大変励みになりました
ありがとうございました!!
2024/10/30(水) 22:39:28.15ID:aKzR4n7A
超大規模のシステムを運用してるんじゃなければ
Rustを使うことによるクラウド費用の削減効果なんて
人件費で軽く吹き飛んで負債になりまくりだろ
2024/10/30(水) 23:07:53.41ID:1vbcRrkY
そう思う人は遅い言語を使ってクラウド料金たくさん払えばよい
2024/10/30(水) 23:47:20.95ID:k59ANI4a
CPU時間と実メモリ使用量で課金されるのはFaaS系だけって話前にもしたじゃん
2024/10/30(水) 23:59:51.69ID:qFWovamr
>>562
タイムシェアリングシステムではCPU時間で課金される
2024/10/31(木) 03:34:36.66ID:DLPRJH+s
自分の所は年間億単位のサーバー費用がかかるし開発も数年かかるんでrustに置き換えるのは十分元取れる。皆c++組めるんでrust教えるのも難しくない。

既に稼働中の部分を組み直す価値があるかは難しい所。Googleのように新機能の部分からrustで書いていくのがいいかな。
565デフォルトの名無しさん
垢版 |
2024/10/31(木) 12:55:27.39ID:POJr+rF8
541 が循環参照されてる
566デフォルトの名無しさん
垢版 |
2024/10/31(木) 14:32:08.16ID:OWKccF9V
Tokioチュートリアルをやっているんだけどさ
チュートリアルの本題とは違うものの、TcpListener::bind()やOSの仕組みがわからなくてすまんが教えてくれねえか
https://tokio.rs/tokio/tutorial/spawning
ここで出てきたんだけど、これってアドレスにリスナーをバインドしただけではなぜnetstat -aの結果には出てこないの????
2024/10/31(木) 14:46:55.34ID:baPJOvwr
https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=220e62ef9b9cbfa9a15d1cdd2547de6b

ぜんぜんわからない
俺たちは雰囲気でライフタイムを書いている
2024/10/31(木) 14:57:44.52ID:baPJOvwr
https://github.com/rust-lang/rust/issues/100728

あっこれかあ
fn(T) -> Uとかimpl Fn(T) -> Uはいいけどトレイトオブジェクトにすると全部非変になっちまうのか
ダルいなあこりゃ
569デフォルトの名無しさん
垢版 |
2024/10/31(木) 15:19:43.08ID:z7RNZZm9
循環参照が無いなら
UAFは無くなるからだよ
馬鹿専用言語だと思った
2024/10/31(木) 15:41:44.65ID:rdZbiqu1
C言語だと、伝統的にはポインタを多用することで高速化が図られている。
その場合、循環参照はよく起きる。但し、その事に配慮してメモリーブロック(オブジェクト)を
destruct するようにしてあるので、特に問題ないし、馬鹿な設計でもない。
その方が速度効率が上がるためだから。
2024/10/31(木) 17:20:18.37ID:ZEhuzsit
参照カウントの場合の循環参照の話だから
C言語じじいは無理して入ってこなくていいよ
2024/10/31(木) 18:04:25.22ID:rdZbiqu1
>>571
参照化カウント方式のポインタで循環参照させる人は、そりゃ珍しいだろうよ。
2024/10/31(木) 22:06:07.79ID:sM0Z2pjW
>>570
そのまとめてブロックでメモリ確保して一気に返す方法はRustや他の言語でも使われている普通の方法
2024/10/31(木) 22:08:28.63ID:sM0Z2pjW
まとめて解放するため循環参照があってもまとめて解放される
2024/10/31(木) 22:57:51.93ID:DLPRJH+s
C言語で出来る事はRustでも出来るよという事がイマイチ浸透していない気がする。
カスタムのメモリアロケーターも作れるし、GC欲しければ自分で実装するか、人が作ったクレート使えばいいし。
循環参照の管理が難しいならそういうシステム最初に作るでしょ?
576デフォルトの名無しさん
垢版 |
2024/10/31(木) 23:23:13.46ID:iDB9JYHh
GC自作とかいう大二病しぐさは大学生のうちに卒業しておけよ
2024/10/31(木) 23:37:38.88ID:DLPRJH+s
>>576
仕事で普通に使うぞ。
用途決まってれば別に特別でもない。
2024/10/31(木) 23:50:49.71ID:Vd3VQsE1
まとめてメモリ解放の究極版として
常駐プログラムでないなど単発処理プログラム対象だと
Rustはleak()を使ってライフタイムの'static化つまりプログラム終了まで解放しない宣言することでプログラミングが簡易になるよ
Cで一部をfreeしないのと同じことだね
2024/11/01(金) 00:52:09.22ID:YZO2XE1P
C言語で出来ることの大部分は実はRustでは出来ない。
2024/11/01(金) 00:52:09.90ID:YZO2XE1P
C言語で出来ることの大部分は実はRustでは出来ない。
2024/11/01(金) 01:18:56.49ID:MT2bV/S9
longjmpとか?
2024/11/01(金) 01:28:27.65ID:YZO2XE1P
いや。ほとんどのデータ構造とアルゴリズムが、Rustでは効率良く使用不可能。
2024/11/01(金) 01:34:16.91ID:3Qm9+gDD
>>578
おいおい、Cでexitするときにfreeすべきか否かの論争はまだ決着がついてないぞ
勝手に決めつけるな
2024/11/01(金) 03:23:25.98ID:eE8SKVMG
rustのgcって型に情報はみ出てんじゃん
ローカルでしか使えんし
585デフォルトの名無しさん
垢版 |
2024/11/01(金) 05:52:59.83ID:0qsWeWDL
RustにGC無いよ
2024/11/01(金) 08:50:35.34ID:wlON8pP2
>>579
激遅でいいんならRustで出来るだろ
2024/11/01(金) 09:12:07.99ID:gzsDik24
libcクレート使えば、CとそっくりのRustプログラムできるでしょ
588デフォルトの名無しさん
垢版 |
2024/11/01(金) 11:20:36.22ID:7FgA9x/Y
>>577
作りたいから作ってるだけだろ
仮に委託先がGC作成費用請求して来たらブチ切れて契約切るわ
2024/11/01(金) 18:44:17.66ID:DQt7FtoO
>>579
名前空間が無いからってマクロで識別子を生成するのはもう勘弁してください
2024/11/01(金) 18:49:49.50ID:I9IxltIy
GCついてるRustが欲しい
rustのtraitシステムは好きだが静的メモリ安全性まではいらない
2024/11/01(金) 19:00:04.84ID:0wzgx2ON
>>590
ちょっと探したらGc機能を提供するクレートたくさんあったよ。
どれが良いのかは知らん。
592デフォルトの名無しさん
垢版 |
2024/11/01(金) 19:25:45.68ID:FTeJ4swx
まともなGCライブラリなんかないよ
おとなしくRustらしいコードを書くか、Rustをやめるかだ
2024/11/01(金) 21:49:04.02ID:lqBEgicJ
>>583
freeやdeleteは不要
freeせずにプログラムが終了したり落ちたりしてもメモリリークは起きない
2024/11/01(金) 22:49:51.10ID:XWaTPxZT
>>592
だよな
2024/11/01(金) 23:32:34.62ID:Y/NQYWW3
>>593
メモリリークするかどうかはOSやアロケータ依存
2024/11/01(金) 23:58:44.68ID:zgZjB7HD
>>593
お前、組込みソフトの開発したことないだろ

あ、俺もなかったわ
2024/11/02(土) 00:41:46.39ID:3NvQMTDb
>>593
メモリリークチェッカーが反応してしまうから、今時きちんと解放処理書くから
不要とかそういうのは前時代的だぞ
2024/11/02(土) 01:36:59.35ID:tAgBVlMI
Tと&TとRc<T>を区別できるのは静的型付けの成果なんだよな

LispがすべてをGCの対象にするのは型を宣言しないからだし
それに、副作用のある関数とない関数を「型」で区別できなかったから
すべてが純粋な関数だったら (動的型でも) 分かりやすいという話になった
2024/11/02(土) 04:46:39.55ID:3NvQMTDb
成果でもなんでもない
言語的にそうせざるをえないだけ
型で区別するのはいいことばかりじゃない
2024/11/02(土) 07:03:08.78ID:tAgBVlMI
技術の話をたまにしかしない人達に
技術は善いことばかりじゃないと説教するのは的外れすぎるだろ
2024/11/02(土) 07:06:40.35ID:3NvQMTDb
技術的な話をしてるから的外れ
型の弊害の経験ないからピンとこない
2024/11/02(土) 09:53:55.89ID:+GKIPsT4
enumで解消
2024/11/02(土) 14:38:12.14ID:tAgBVlMI
とりあえず両極端を経験してみるのはじつは拙速で、巧遅でも清書でもない
どっちも弊害があると語る第三者が最も遅いのだ
2024/11/02(土) 23:52:01.28ID:aIv/CPhG
>>595
それはむしろ逆
freeを完全にすることでメモリリークを防ぐことはできない
freeはアロケータが管理するメモリバッファへ返還する動作しかしない
malloc/free交互にするたびにそのバッファをゼロにするためOSやその他システムへバッファを返還する非効率をしない
アロケータが管理するバッファはfree後も常に一定量が残っている
つまりバッファを完全にシステム側に返還する責務をfreeは持たないしfreeで実現は無理だ
そこは各システムが別の機構として責務を持っている
普通のOSならプロセス終了でバッファ含めて使用メモリ全体を自動解放することになる
組み込みシステムでもそのプログラム終了時に少なくともバッファ部分を解放する仕組みを持たなければならない
freeを忘れてもあるいはfreeせぬまま異常終了となってもその仕組みによりメモリリークは起きない
2024/11/03(日) 01:07:42.39ID:GP4mHnVt
>>604
君が想定している仕組みや振る舞いが
あらゆるOSやアロケータに当てはまるわけではないんだよ

>>595に戻る
606デフォルトの名無しさん
垢版 |
2024/11/03(日) 08:19:11.87ID:OLDVpvrl
まともなOSならfreeせずに終了しても問題が起こらないように作ってあるよ
そうしないと異常終了のようなケースでリークし続けることになるし
(古いものやマイナーなものも含めた全てのOSがそうだとは言い切れないけど)

その上でだけど、上記はOSの動作の問題であって、言語のルールとしては「mallocしたら対になるfreeを呼ぶこと」だろうから、自分の好みとしてはfreeをちゃんと呼ぶよう作りたい派
「OSが解放するから問題ない」というのは「プログラマが責任をサボっても問題は起こらない」という感じがしてて、行儀の良いコードでないように感じる
2024/11/03(日) 08:27:05.14ID:vgT2G1ym
mallocしたら対になるfreeを呼ばずに終了するのはマナー違反
目上のOSに対して失礼に当たる
2024/11/03(日) 08:32:32.56ID:muWl0Gle
こういうやつに限って問題が起きると「想定外でした」と恥ずかしげもなく言うんだよな
609デフォルトの名無しさん
垢版 |
2024/11/03(日) 08:32:33.64ID:W/WQS3jI
メモリリークが問題になるのは、むしろ終了させずに長期間稼働させ続ける場面でのことだと思うが…。
特に鯖とか医療機器・自動車組み込みなど、経済・人命に影響が大きい分野。
2024/11/03(日) 08:37:43.84ID:vgT2G1ym
>>609
そういう分野では、そもそも動的にメモリ確保しない
2024/11/03(日) 09:04:30.66ID:DnnuC4NT
動的確保をしないものもあればするものもある
自分の知ってる範囲が世の中の全てだと勘違いしないことだな
612デフォルトの名無しさん
垢版 |
2024/11/03(日) 09:25:18.11ID:OLDVpvrl
医療機器や自動車ほど重要なものではないけど、自分の仕事だと組込みでも動的確保を使うよ
Windows EmbeddedやUbuntuようなOSが入ってるし、それなりのリソースがある環境での話だけど
「大きなバッファはプログラムの最初に1度だけ確保する」ことはするけど、それ以降のヒープ確保をしないとか、static領域のみを使うとかまではしてない
(Rustスレでいうのもなんだけど現状はC++)

一般化できる話かは分からないけど、例えばカメラを使う機器かつ複数種類のハードウェアを扱うプログラムなら動的確保は必要じゃない?
想定するカメラ画像のうち最も大きいサイズに合わせたメモリを静的確保する作りでも良いと思うけど、プログラム起動後にハードウェアに問い合わせて、それを元に必要分のバッファを確保する作りも多いと思う
2024/11/03(日) 10:22:36.62ID:e8fWHn4Q
>>612
確実にメモリ不足が起こらないこと保証できるのそれ?
まあ動くっしょ?ダメなら再起動で、みたいな感じ?
品質に対する意識すごいね
2024/11/03(日) 11:21:00.89ID:wZ/A1hEq
mallocが駄目ならsbrkを使えば良いじゃない。by マリー
2024/11/03(日) 11:34:52.74ID:8jL1esrh
> malloc/free交互にするたびにそのバッファをゼロにするためOSやその他システムへバッファを返還する非効率をしない

なんやこの悪文は
2024/11/03(日) 11:49:46.99ID:kGU90lSm
>>609-610
手術中にGC走り出したら困るもんなー
2024/11/03(日) 11:52:19.67ID:kGU90lSm
>>615
chatGPTに聴いて造らせたような文章だな
2024/11/03(日) 13:59:19.14ID:yWge6Gp+
ChatGPTはそんな変な文を作らない。
2024/11/03(日) 16:50:47.89ID:zQdSfX4F
MS-DOSですら、free忘れようが何しようが、
プロセス終了時にちゃんとOSがプロセスが確保した
メモリーを解放してたよ。
2024/11/03(日) 17:05:19.83ID:zQdSfX4F
なんせ、MS-DOSのように「意味的には」ページングして無い場合には、
メモリー解放はOS目線で見れば簡単と言えば簡単だからね。
for ( プロセスが確保していたメモリーブロックを全て巡る ) {
 (そのメモリーを解放);
}
みたいなロジックであって。
WindowsやLinuxのようなOSでは、ページングや色々なこと
してるから複雑だけど、それでもOSは頑張って解放するよ。
621デフォルトの名無しさん
垢版 |
2024/11/03(日) 17:20:04.38ID:X/+mpRk0
素人質問で大変恐縮ですが、CPU/GPUのファームウェアをrustで書くことは可能?
622デフォルトの名無しさん
垢版 |
2024/11/03(日) 17:46:00.06ID:OLDVpvrl
>>613
>確実にメモリ不足が起こらないこと保証できるのそれ?
それは悪魔の証明に近くないか?
保証はできないけど、普通に使う分には使えてるものだよ
人命に関わるような分野ではない&長時間 (例えば24時間以上) 連続で動かす機器ではないという条件だけど

「組込みでは動的確保をしてはならない」と言うなら、例えば組込みJetsonなんて製品が世に存在するわけがないでしょ
あれはNVIDEAのGPUを積んでて、CUDAを使った処理などを行える機器だけど、組込み向けとして売られてる
GPUメモリの確保は当然動的確保になるわけで
623デフォルトの名無しさん
垢版 |
2024/11/03(日) 18:50:54.75ID:W/WQS3jI
>>621
デバイスドライバって意味なら書ける。
https://qiita.com/lalafell/items/be50f696a35fc6dbce62

win以外
ラズパイのキーボードファームウェアの記事。
https://zenn.dev/nazo6/articles/keyball-embassy-rp2040

こんな調子でCPUやGPUも理論的には行けるはず。
Googleはある程度道筋経ててるみたいね。

C/C++からRustへ:Googleが示すファームウェア進化の道筋
https://xenospectrum.com/google-revamps-firmware-with-rust/
Googleは最近、Android仮想化フレームワークの保護された仮想マシン用ファームウェアをRustプログラミング言語で書き直し、その経験をもとに他の開発者にも、“メモリセーフ”な言語である、Rustへの移行を強く推奨し、ブログでその詳細を解説している。
624デフォルトの名無しさん
垢版 |
2024/11/03(日) 18:52:21.77ID:XxnHrPnR
Linuxなんて勝手にプロセス殺して知らんぷりする糞OSですし
625デフォルトの名無しさん
垢版 |
2024/11/03(日) 18:56:19.56ID:W/WQS3jI
>>619
話聞いてた?
free忘れで問題になるのは、そのプロセスを数か月/数年単位で終了させない時に出る。
終了時にメモリ解放されるのは当たり前。
626デフォルトの名無しさん
垢版 |
2024/11/03(日) 19:43:19.04ID:X/+mpRk0
>>623
ありがとうございます
2024/11/03(日) 20:51:25.90ID:e8fWHn4Q
>>622
動的確保をするなではなくメモリ不足にならないことを保証しろだ
お前の周りの組み込み機器でメモリ不足エラー見たことあるか?
まともな会社でまともなスキル身につけたほうがいいぞ
2024/11/03(日) 21:09:49.26ID:X/+mpRk0
Staticこそ至高
629デフォルトの名無しさん
垢版 |
2024/11/03(日) 21:34:55.27ID:OLDVpvrl
>>627
書いた通り、大きなメモリ (主に画像用) は最初に必要分を確保して使い回してるし、当然そのサイズは機器の搭載RAMサイズを考慮しているよ
処理によっては一時的なメモリ確保は生じるけど、適切に解放してるしメモリリークしてるわけでもない

組込みって分野が広いし、あくまでこれは自分の分野の話だというのは念頭においてくれ
メモリが32KBしかないマイコンと、8GBや16GBのメモリを積んでる機器とでは条件が全然違う
リソースが限られていたり、24時間360日動くような機器なら動的確保を避けろというのはその通りだと思う
630デフォルトの名無しさん
垢版 |
2024/11/03(日) 21:46:04.58ID:OLDVpvrl
>24時間360日
これは365日の誤字
2024/11/03(日) 22:22:34.29ID:etptyyzP
>>607
普通のプログラマーが対象とする普通のOS環境においてfree()とOSは関連がない
そしてfree()せずにプログラムが終了してもメモリリークは起きない
関係するのプログラム動作中にメモリの再利用ができないことでメモリを使い果たさないかどうかのみだ

つまりGCに頼る言語でGCが起きる以前にプログラム実行が終わってしまうようなタイプのプログラムなら同様にfree()を行わなくても構わない
起動時にまとめてメモリを確保して終了時まで放さないタイプでもfree()を行なう必要はない
free()を行なわないことでプログラミングをより平易かつ安全にすることができる
2024/11/03(日) 22:34:17.00ID:tj8/H5Bl
結論:
複オジが対象としているタイプのプログラムではfree()を行なわないことでプログラミングをより平易かつ安全にすることができる
以上。
633デフォルトの名無しさん
垢版 |
2024/11/03(日) 22:50:04.49ID:JgJhJeSd
freeしないコードのコードレビューはしたくないな
こだわりが強そうだし、本当に安全なのか確かめるのも大変
634デフォルトの名無しさん
垢版 |
2024/11/03(日) 23:14:53.65ID:/IbdFPbo
>>633
freeしなければダングリングも多重解放なども起こらないから絶対に安全だよ
freeしていると安全なのか確かめるのが難しくなる
2024/11/04(月) 01:39:27.51ID:nRSMDwEy
freeを使ってないがreallocは使ってるみたいな
敵視してない敵がいる
つまり敵味方は自由に選べないので、同意してないコストを強制されることもある
636デフォルトの名無しさん
垢版 |
2024/11/04(月) 02:53:23.37ID:Bn72OgcT
Rustの話を、しよう
2024/11/04(月) 14:38:06.42ID:dJ1Yp7fe
>>634
安定の複オジ品質
草草草
2024/11/04(月) 14:59:59.47ID:IyJSMCPH
お話してから、しましょう
2024/11/04(月) 16:28:27.25ID:613UlU6B
>>637
いや俺はそいつとは違うが絶対安全なのは事実
2024/11/04(月) 17:33:20.85ID:Jcd4tSdQ
何が絶対安全なの?
2024/11/04(月) 17:41:55.51ID:P+qabS46
>>639
いや完全に脳みそ複オジでしょ
2024/11/04(月) 18:04:13.97ID:mBJjb45a
>>566
亀レスだけどアドレスにリスナーをバインドすればnetstat -aの結果にLISTEN状態で出てくるぞ
2024/11/04(月) 18:21:55.56ID:613UlU6B
>>641
型システム入門って読んだことないん?
13章で確保した参照を絶対解放しない言語考えてその型安全性(つまりメモリ安全)証明しているけどこれ言っても理解できん?
2024/11/04(月) 18:36:09.56ID:+Zn5uplp
そんなイキれるほど頭のいいこと言ってないから
freeしなきゃ安全!
はずいわ
2024/11/04(月) 18:36:26.40ID:0co8NUe7
そりゃ安全ではあるけど別の大問題を生むし……
わざわざそれを言ってるのって「Cであえて解放しないようにするとC++/RustでRAIIに任せるのと比べて(誤差レベルで)早い」って意見に対してくだらない意地張ってるだけじゃないですか
2024/11/04(月) 18:45:22.71ID:UYP+oEN0
>>643
#include <stdio.h>

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

↑freeしてないけどメモリ安全ではないよ
何が安全なのか知らんけど
2024/11/04(月) 19:51:08.05ID:3WEWZAvC
>>644
引用文献載せるだけの行為に過剰反応するとかコンプでもあるんかな?
帰納法とか理解できないからこの本読めなくて可哀想w
2024/11/04(月) 19:52:09.07ID:3WEWZAvC
>>645
俺は寿命が短時間なのか想定されるプログラムで敢えてfreeしないアプローチを取るのは賛成やが
2024/11/04(月) 19:52:59.06ID:3WEWZAvC
>>646
この本ではdangling pointerのエラーについては発生しないこどメモリ安全だと主張している
2024/11/04(月) 21:16:42.38ID:nRSMDwEy
RAIIより単純なアプローチがもしあればRAIIは非科学的だぞという
このオッカムの剃刀自体が、科学的な実験やデータを必要としない哲学の思想だ
2024/11/04(月) 21:43:03.80ID:C+a/rILf
>>636
Rustでももちろん意図的に解放しない有用な方法を公式にサポートしている
これはヒープ領域の一部を解放しないことにして例えばスタティック領域のようにみなすことができる
つまりライフタイムを'staticにできるため構造体メンバーに制約なく組み込めて関数からも自由に返せるようになる
この機能はsafeなRustの標準ライブラリとして提供されている
2024/11/04(月) 22:47:38.24ID:pw9M2oNL
>>649
そりゃ「確保した参照を絶対解放しない言語」ならdangling pointerは発生しないだろ
でもC言語はそうじゃないしはfreeしなくてもdangling pointerは発生するから全然安全じゃない

結局「freeしなければ絶対安全」の正体は
「freeしなければfree起因によるdangling pointerは発生しない」というだけ
当たり前すぎて泣けてくる
2024/11/04(月) 23:29:15.46ID:nRSMDwEy
政治起因による制約さえ無くなれば経済が偉大になるという謎理論があるからな
2024/11/05(火) 22:33:43.60ID:foggTYfW
>>652
Rustなら色々な安全性を全て保ったまま扱えるよ
所有者と所有権を消滅させることと引き換えに&'static mut Tを得ることも安全に行われている
2024/11/05(火) 23:42:46.08ID:fXJW6BJV
&'static mut Tに何か代入したらどうなるの
代入前の値にdropが定義されてたら呼び出される?
それは実質的にfreeしてるのと同じなのでは
2024/11/06(水) 00:29:29.78ID:40oev9+T
>>655
デストラクタはその型の値に対して行われるものであって
一般的にはヒープメモリとは関係がない
たまたまその型(の一部)がヒープメモリを所有すれば当然解放される

一方で&'static mut Tの元はBox<T>そして&'static mut [T]の元はVec<T>
つまり解放されないのはBoxやVecという入れ物でありTの話ではない
2024/11/06(水) 07:25:52.71ID:wYgAHnia
構造体メンバーに!Copyを入れれば制約が生じる
Box<T>が!Copyだとしても&'static TはCopyだから制約がなくなった
ように見えるが、ヒープとか解放とかいうクソどうでもいい条件が増えてるんだよな
2024/11/06(水) 08:04:15.27ID:40oev9+T
&Tにスタック領域かヒープ領域かスタティック領域かの区別はなく意識することさえ必要ない
唯一の制約はライフタイムであり
staticでない&'a Tは所有者である'a Tより延命できない制約がある
一方&'static Tはプログラム終了時まで永遠に生きるため制約がない
2024/11/06(水) 23:12:54.20ID:wYgAHnia
同時に意識しろとはいわないが
少しずつでも森羅万象を意識しないと客観的にならない
660デフォルトの名無しさん
垢版 |
2024/11/07(木) 22:29:40.21ID:/292LLXT
>森羅万象

いわばまさに、だーらば
2024/11/07(木) 22:47:47.58ID:SSxPh9YO
static変数へ入れてしまう場合もプログラムの最後までヒープ解放しないよね
例えば以下は正規表現わざわざ使うまでもない簡単な例だけど
ヒープ領域を確保して内部に持つRegexを何度も作り直すムダを避けるためにstaticに持つよくあるパターンとか
それを解放するきっかけは最後までやって来ないよね

fn yyyymmdd(s: &str) -> Option<(u32, u32, u32)> {
const YYYYMMDD: &str = r"(\d\d\d\d)/(\d\d)/(\d\d)";
static RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(YYYYMMDD).unwrap());

if let Some((_, [year, month, day])) = RE.captures(s).map(|caps| caps.extract()) {
let year = year.parse().ok()?;
let month = month.parse().ok()?;
let day = day.parse().ok()?;
Some((year, month, day))
} else {
None
}
}
662デフォルトの名無しさん
垢版 |
2024/11/08(金) 07:27:08.10ID:6g9EuKad
RustにJAVA厨が流れ着いてるのか
2024/11/08(金) 08:29:50.38ID:b6NZ3Dbv
}
else {
2024/11/08(金) 10:14:50.92ID:3hecOEMV
汚ジコード乙
2024/11/08(金) 12:15:41.38ID:F9yTI1pl
毎回初期化を避けるためにstatic←JAVA脳
ローカル変数やauto変数にいちいちstatic描かなくても一回しか初期化されない←関数脳
2024/11/08(金) 12:28:38.12ID:spBkjUqU
>>665
JavaだけでなくCでもRustでもどの言語でも同じだろ
2024/11/08(金) 15:26:29.46ID:/u/AnA38
regex literalのある言語を知らないとか原始人かよw
2024/11/08(金) 17:32:32.77ID:3z6JS0FZ
>>667
regex literalのある言語でもパターンが変数により変わる場合は別途生成になる
その場合に正規表現からオートマトンへのコンパイル結果をキャッシュする責務はプログラマー
それを何らかのオブジェクトに入れて毎回持ち回るのか避けてstatic変数などに入れてしまうかの話ではないか
2024/11/08(金) 18:37:15.71ID:cYDKHcpz
>>668
マジでregex literal知らんのだな
raw string literalとは違うのだよ!
2024/11/08(金) 19:37:52.69ID:/iMoAsCH
今確信したけどここまでの流れを見て断言するけど
Rustが主流の言語になることはないわな
2024/11/08(金) 20:12:43.27ID:3z6JS0FZ
>>669
正規表現パターンに変数やその式を使ったことないのかい?
それら式を用いるとコンパイル結果を自分でキャッシュ管理しなければならなくなる

具体的にはregex literalの有無で
(1) 無い言語の例としてPythonは効率化のためにはre.compile(パターン, ...)結果のキャッシュが必要
(2) 有る言語の例としてRubyは式を含む場合のみ毎回評価し直すためキャッシュが必要
(3) 有るがパターンに式を書けない言語の例としてJavaScriptはnew RegExp(パターン, ...)結果のキャッシュが必要

いずれもregex literalの有無に関わらずコンパイル結果のキャッシュが必要となる
2024/11/08(金) 20:55:31.49ID:Me1tPYCI
ものによるが暗黙にキャッシュする (プログラマが保存しないでよい) 言語処理系は存在するよ。
2024/11/08(金) 21:02:51.24ID:yNVczeuC
むしろ、コンパイルしてないほう(Arc<String>)をキャッシュする
そのStringが生きている間だけコンパイル結果を生かしておく

キャッシュが必要ならArcが必要と判明したせいでGC界隈の常識が覆された
2024/11/08(金) 21:23:43.02ID:3z6JS0FZ
>>672
暗黙にキャッシュは固定文字列パターンの時だけではないか?
パターン内の式の値が毎回替わりうる可能性があるから
言語側としては>>671のように毎回評価し直す仕様や
regex literalを用いず明示的にコンパイルする関数を呼ぶ仕様になっている
2024/11/08(金) 21:40:49.75ID:Me1tPYCI
>>674
いや、キャッシュというかいわゆるメモ化かな。
入力される値は変わりうるが、同じ入力に対しては同じ結果であることは保証される (かつ現実的な用途では同じ値が入力される可能性が高い) ので値とセットで記憶しておく方法で十分に処理コストを減らせる。
2024/11/08(金) 21:58:06.73ID:HF5jYlyP
全く異なるユースケースを持ち出してまで
「どの言語も同じ」ということにしたいらしい
2024/11/08(金) 22:27:14.73ID:Jmd1EJmL
>>674
Pythonのreなら直近の512個まで自動的にキャッシュされてるよ
2024/11/08(金) 22:28:21.24ID:Me1tPYCI
ワンライナーみたいな使い方をする言語では (結果的に無駄になってでも) 暗黙に色々やっといてくれるほうが便利ってこともあるからどんな言語でも Rust と同じ方式のはずとは言えんわな。
2024/11/08(金) 23:01:18.69ID:spBkjUqU
>>673
Arcは要らない
何度も使う固定の正規表現ならその関数かモジュールのstatic変数で十分
変数部分を持つ正規表現それぞれを何度も使い回すならその呼び出したい元の構造体フィールドに入れておけば十分

>>675
そんな一般的なメモ化は論外
ハッシュマップ相当のコストがかかる上に再利用しないものや不要になったものを持ち続ける愚かさ
2024/11/08(金) 23:54:55.29ID:B3hB3UkR
>Arcは要らない
ふーん

https://docs.rs/regex/latest/src/regex/regex/string.rs.html#101-104
2024/11/09(土) 00:23:52.73ID:3a9p/42P
それはRegexの内部実装なので無関係だね
CloneできるようにArcを使ってるよくある手だよ
2024/11/09(土) 01:08:06.88ID:CKaEi0Af

内部実装の話をしてるんではないのか
2024/11/09(土) 01:20:28.66ID:3a9p/42P
再コンパイルを避けるためにstaticで持ったりオブジェクトメンバーで持ったりと利用プログラマー側の話でしょ
その時に必要ならCloneもできるということ
2024/11/09(土) 01:27:01.06ID:NTU1NPwJ
何の話をしてるのか、誰か一人でも分かってるんだろうか
2024/11/09(土) 04:13:52.23ID:MgyqC3I+
>>679
「言語はどれも正規表現のコンパイル結果を記憶する処理はプログラマの責任」に対しての「そうではない」という実例が挙げられたのであって、良し悪しを論じる文脈ではない。
なにが言いたいのだ?
2024/11/09(土) 05:26:31.68ID:tGFuX1+9
話の流れが良く分からないけど、つまり正規表現をconst文脈でコンパイルできないRustはクソってこと?
2024/11/09(土) 09:50:01.85ID:V8dNW5L0
単に複オジがクソだってこと
2024/11/09(土) 12:02:14.96ID:6/tB/poi
いわゆるlet over lambdaがなかった時代には
static over fn
だったという話
2024/11/09(土) 12:56:57.97ID:Z6VLqth0
コーディング時に確定できる静的な正規表現と
実行時にならないと確定できない動的な正規表現は
用途も違うしプログラム内での扱い方も全然違うよね

前者が他言語なら正規表現リテラルでRustならstaticを使う分野
後者は普通staticは使わない(immutableなのかmutableなのかでまた少し違う)

Javaでstaticというのは前者だろうな
後者でも使えなくはないけど純Java脳の人は違うやり方をするはず
2024/11/09(土) 13:21:26.67ID:F1r07c7a
いつになったら、Rustで正規表現をconst文脈でコンパイルできるようになるの?
原理的に見込みない話?
2024/11/09(土) 14:07:10.40ID:6/tB/poi
ヒープの話に戻るが、サイズが静的に確定すればヒープを一切使わない保証もできる
2024/11/09(土) 14:59:50.94ID:JFkCBQN+
>>690
マクロ使えばできるが大変なので誰も作らない
言語に組み込まれるのは良くて20年後やろな
2024/11/09(土) 15:06:22.46ID:CKaEi0Af
>>690
https://github.com/rust-lang/regex/issues/913
クソ面倒なうえに劇的な効果があるわけでもなさそうだからやらねーとのこと
2024/11/09(土) 15:09:47.03ID:F1r07c7a
>>693
失望した
別の正規表現クレートが誕生するのを待つしかないのか
2024/11/09(土) 17:12:28.10ID:bFGQ+yoR
>chronoのようなほとんどのプログラムで使われない機能を
こういうことを書くやつに限って>>661みたいなコードを書いちゃうんだよなぁ
そういう時代じゃねぇだろっつーの
2024/11/09(土) 17:13:55.79ID:6/tB/poi
願望は笑いものになるが失望はそうでもない
前者は単独犯で後者は不特定多数だからだ
2024/11/09(土) 17:22:40.75ID:IbVEcqQg
正規表現の単なる説明例じゃないのか
しかも正規表現自体も単なる例でstaticに突っ込む話の説明例だろ
そもそもの話はヒープをプログラムの最後まで解放しなくていい話でstaticはその一例として出てきただけだよな
一番どうでもいい末節の正規表現で騒いでいて違和感
2024/11/09(土) 17:29:31.37ID:8+qKiGsp
>>693
読んでみたが機能充実(制限)と実行速度とバイナリサイズのどれを優先するかもしくはどの二つまで両立させるかで
どのエンジンやどんな中間表現やどこまで機能制限を行なうかのバリエーションが多すぎるようだ
万人の矛盾した要求を全て満たす万能なものを実現するのは不可能だから別々に叶えるしかないな
2024/11/09(土) 18:03:48.00ID:LybhxYMR
>>690
RustのconstってC++のconstexprだよな
どうやってヒープ領域を返すんだ?
C++だとconstexprの計算中はnew/deleteでヒープを一時利用できるけど
deleteせずに返すのはできないよな
2024/11/09(土) 18:14:19.13ID:6/tB/poi
正規とか文脈自由とかいうのは仕様のバリエーション
実装のバリエーションなど知ったことではない
2024/11/09(土) 22:22:44.34ID:bFGQ+yoR
>>697
例として出したものが
正規表現リテラルの代替策な上に
内部実装の都合上ヒープを確保してるだけで
本来はヒープである必然性もない

機能不足の代替策として
プログラムの最後まで開放しないような
ヒープの使い方もあるだろうという話なのか?
2024/11/09(土) 23:06:21.72ID:6/tB/poi
ロックして解放してロック解除しなければいい
2024/11/09(土) 23:11:14.97ID:Dc7LpAyZ
>>701
基本的な知識を身に着けろよ
正規表現を内部コードにコンパイルして持つ役目がRegex構造体
可変長になるのでVecで持っていて当然ヒープは必須
2024/11/10(日) 00:07:10.13ID:QiolRTDD
>>703
それは現状の内部実装上の都合の話
本質的にヒープが必須という話ではない
文字列リテラルにヒープが必須でないのと同じとでも言えばわかるかな?
2024/11/10(日) 02:33:30.98ID:OGC8ujy2
は~~~~キレそう
2024/11/10(日) 02:34:34.55ID:OGC8ujy2
なんの意味があんねや、このスレ
2024/11/10(日) 02:36:54.54ID:OGC8ujy2
Rustプログラマにとって有益な情報はこれ以上出ないし、まともなRustプログラマは全員逃げたことが確定して久しいので
次スレあたりから「Rust vs 世界中の全言語 Part27」とか「複製おじさんと遊ぼう Part27」とかにしましょっか
他にもスレタイ案募集
2024/11/10(日) 06:48:35.70ID:xIqOi7JH
>>704
おまえバカだろ
正規表現パターンは実行時に確定してコンパイルサイズも実行時に確定し上限サイズはわからない
ヒープは必須だ
709デフォルトの名無しさん
垢版 |
2024/11/10(日) 11:17:24.55ID:dkv1a77w
入力がコンパイル時に確定してるならサイズも確定するでしょ
理屈としては以下のようなものは作れると思う

struct CompTimeRegex<const N: usize> {
 data: [u8; N]
}

// 正規表現オブジェクトをコンパイル時に計算
// サイズは入力に応じて変わる
// 入力はリテラルのみ
let r = make_regex!("+\\d");

面倒だし、それでパフォーマンスが劇的に良くなるわけでも無いだろうから必要性は微妙なところ
詳しくないけど、手続きマクロの中なら計算のためにヒープを使うこともできるよね?
2024/11/10(日) 11:58:38.78ID:WMkhj3nA
BurntSushiのベンチ結果見た?
2024/11/10(日) 12:03:57.56ID:xIqOi7JH
それは入力固定で出力の型も別仕様の別の話だな
regex::Regexは実行時に正規表現が作られてもよく
それをコンパイルするためヒープが
使われている
2024/11/10(日) 12:23:01.33ID:mfp7bShs
正規表現をコンパイルするのと比べてヌル代入を許容するのは極めて容易で
ヌルを代入すればヒープが解放される
2024/11/10(日) 12:27:06.24ID:z1ldQRPb
const文脈って、実際今なんか有効な活用されてるの?
2024/11/10(日) 12:30:28.79ID:z1ldQRPb
ちなみにzigの似た機能は有効活用されまくり
2024/11/10(日) 12:38:27.50ID:OGC8ujy2
ぐちゃぐちゃできるとかできない言ってるが自分で実装する気のある人間は一人もいねえんだろ???
だったら終わりだよ
2024/11/10(日) 13:02:04.64ID:OGC8ujy2
>>711
だから>>709はCompTimeRegexという従来のRegexではない型を作って話を展開してるわけ
ちゃんと読めてる?
2024/11/10(日) 13:06:11.38ID:OGC8ujy2
意図的な誤読、ストローマン論法、誰もがわかりきった説明を脈絡無く貼って議論を拡散させる
マジで不毛
2024/11/10(日) 13:11:04.55ID:OGC8ujy2
結局さ
ヒープは全部開放しなさい派閥は>>661のコードでRegex内部のArcが未解放のままプロセス終了するのは、ええんか??ええんか??どうなんだオラ??って話ってことでええんよな
2024/11/10(日) 13:16:48.60ID:xIqOi7JH
>>716
全く別の話であり、これまでのregex::Regexについての話への言及・反論にはなっていないことを自覚できているならそれでよろしい
2024/11/10(日) 13:18:41.74ID:nOHdM7oG
>>718
Rustの標準ライブラリstdは
プログラム終了時に自動的にメモリが解放されるようなまともなOS環境を対象にしていて区別しているので大丈夫
OS無しの組み込み環境では#![no_std]を宣言してcoreライブラリのみサポートされる中でのプログラミングを行なう
2024/11/10(日) 14:48:06.15ID:AfmJKCJ3
>>707
みんな何処に逃げた?
2024/11/10(日) 15:04:06.89ID:qC3Ky4ZL
>>661
スコープを外れた場合と同じようにモジュールがアンロードされる際にデストラクトされる
2024/11/10(日) 16:19:33.44ID:OGC8ujy2
>>720
OS側でプロセスを終了させる際にメモリマップを捨てる処理のことを「解放」って呼んでるから君と君以外で話がすれ違うんだと思うよ
2024/11/10(日) 16:24:01.76ID:OGC8ujy2
あと、ええんかオラ?ってのは俺の直接の質問ではない、それに答えられてもへえそうですか
元の議題は>>661、さらに遡れば>>593であって、議題内容はそれでよいか?という確認をしているだけだ
2024/11/10(日) 16:26:17.63ID:OGC8ujy2
>>721
非匿名でまともな交流ができるコミュニティかもね
rust-jpのzulipとか、あるいは英語を頑張って公式コミュニティとかに行ったか、発言しなくてもROM専してるかも
726デフォルトの名無しさん
垢版 |
2024/11/10(日) 16:30:14.58ID:dkv1a77w
5chで聞くよりもChatGPTの方が適切な回答をくれると思う
Rustに限らず他の言語でも
2024/11/10(日) 16:34:57.50ID:OGC8ujy2
ChatGPTもついでにCopilot Chatもゴミだよ
省略されたライフタイムの展開が自分でやったのが合ってるか自信がなくて、試しにやらせてみたらメチャクチャなことばっか言いやがった挙げ句、キレてthe Refrenceのelision rulesのところをペタペタ3回くらいコピペしたらすみません間違っていました、何度も申し訳ございません言いながらやっと正解を返してくれた
決定論的な問題を解かせるのにはまったく向いてない
2024/11/10(日) 16:36:43.08ID:z1ldQRPb
>>727
最初からキレて始めればいいのでは?
2024/11/10(日) 16:39:08.93ID:OGC8ujy2
英語が話せる人はこっちに移住しよう!!! できない人もDeepL片手にカモン!!!
https://www.rust-lang.org/community

日本語コミュはこちら!!!ってかいい加減放置されきった翻訳版の責任者のケツ叩きに行こうぜ!!!
https://rust-lang-jp.zulipchat.com/
2024/11/10(日) 16:41:30.83ID:tFJCBt9m
>>728
キレるはともかく最初からelision rules貼ればよかった説は確かにそう、残念ながら二回目の機会がないが次はそうしてみるぜ
でもよお……こんなのrust-analyzerが完璧なinlay hint実装してくれりゃやらなくて済む話でもあるんだぜ
2024/11/10(日) 16:42:25.60ID:OGC8ujy2
およ? ID変わった
ID:OGC8ujy2=ID:tFJCBt9mです
2024/11/10(日) 16:53:56.32ID:ES+o9VJl
>>722
staticはdrop呼ばれない
2024/11/10(日) 17:11:30.76ID:a6nPaG4v
C++ で static オブジェクトの初期化順 (解体順) は問題を起こしがちだし、いっそそのへんは取り扱わないというのも妥当な判断のひとつではあるわな。
2024/11/10(日) 17:43:15.44ID:mfp7bShs
自動化をあきらめることは賛成
だが手動で解放する技術を不要な技術と見なすことには反対する
735デフォルトの名無しさん
垢版 |
2024/11/10(日) 18:43:44.99ID:dkv1a77w
StringやVecみたいなヒープを使う型をstaticで管理させた場合って、valgrindみたいなメモリリーク検出ツールに引っかかったりする?
dropが呼ばれなくても終了時に一応はメモリ解放してるのか、それとも本当に何もしていないのか
2024/11/10(日) 19:15:15.74ID:xIqOi7JH
>>733
Rustならstatic変数初期化はOnceLockやLazyLockでマルチスレッド競合を含めて安全に初期化できる
static変数でdropはプログラムの終了時も起きないがメモリ解放問題は普通のOS環境では関係ないため問題ない
どうしてもdropしたいなら例えばOptionで包んでtake()で取り出すなどで手動drop()が可能

>>735
手動dropしないならばヒープ領域を持っていても解放されない
これはBox::leak()などで意図的にメモリを解放しないようにした場合でも同様
普通のOS環境ならこれでも問題は全く起きないが
組み込み環境などで確実にメモリ解放したいならば用意するメモリアロケータで対応する
つまりプログラム終了時にメモリアロケータを呼び出して管理している全メモリを解放させればよい
2024/11/10(日) 19:59:43.87ID:tFJCBt9m
質問の答えになってないし、組み込み環境で「プログラムが終了」したり、「管理している全メモリを解放」できるアロケータが必要などとまで言い出した

いやはや
2024/11/10(日) 20:16:38.46ID:tFJCBt9m
>>735
>>661に適当にこれだけのmain足してvalgrindかけてみた

fn main() {
let s = "2021/07/04";
let (year, month, day) = yyyymmdd(s).unwrap();
println!("{}-{}-{}", year, month, day);
}

https://pastebin.com/UN84vEFb

まあ、リーク扱いで出るよね
こういうのがあんまり多いとマジのリークと区別付きづらくて大変そうだけど、なんかアノテーションみたいなので対策できたりするのかな?
739デフォルトの名無しさん
垢版 |
2024/11/10(日) 20:28:05.31ID:dkv1a77w
>>738
サンクス
過去にC++で似たようなケースで顧客から「あなたの所のライブラリを使うとメモリリークが検出されるんだけど?」って指摘されたことがあって気になった
説明して伝わる相手なら良いけど、そういう面倒な人からのクレームを避けたい場合はstaticは避けたほうが良さそうだな
本質的には重要な問題でないと思うけども
2024/11/10(日) 20:28:35.21ID:xIqOi7JH
>>737
組み込み環境であろうとなかろうと各プログラムは終了する
さらにOS環境でOS内であっても各カーネルモジュールのプログラムはアンロードで終了する
一方でもし完全にモノリシックな一つのシステムなら終了後をそもそも考える必要がない

メモリアロケータについては自作したことあるなら管理してるメモリの全解放なんて楽勝だと理解できるだろ
割り当て用に確保しているバッファを返却するだけだ
2024/11/10(日) 20:52:25.18ID:Qvjt9L31
お前ら、Rustでプログラム書いた後にvalgrind ってるの?
もうそういうの終わりにしたいからRust使ってるんじゃないの?
2024/11/10(日) 20:53:16.70ID:tFJCBt9m
相変らず単語ひとつひとつが独自用法すぎて解読が困難だね

mallocみたいなグローバルアロケータを自分で実装しようという話をしているのか?
それとも(allocator_apiがいまだにunstableなせいでボイラープレートモリモリ書かされる)typed_arenaやbumpaloのようなカスタムアロケータの話をしているのか?

前者だとしたらバッファという言葉が出てくるのがまず分からない、もしかしてヒープ領域全体のことをバッファと呼んでいて、確保/解放はsbrkのことを言っているのか?
後者だと「管理してるメモリの全解放」ですべての内容のDropしないといけなくて……って考えるとどう考えてもゲロクソむずいけど、全オブジェクトをManuallyDropに包んで返して責任放棄するのかな……
2024/11/10(日) 20:56:00.86ID:tFJCBt9m
>>741
できねーもんはできねーんだから適切な道具を使うんだよ、笑うならそこの嘘吐き宣教師を笑うんだな
2024/11/10(日) 21:08:26.24ID:xIqOi7JH
>>742
プログラム本体終了後のメモリ解放のためにdropは必要ない
プログラム全体終了後のメモリリークが組み込みなどで困るケースが対象なのだからそれらメモリを返却するだけでよい

sbrkのあるOS環境ならsbrkでOSへ全メモリを返還できるのはその通りだが
それをしなくてもプログラム終了後にメモリリークは起きないので普通のアロケータでは行われていない
メモリリークが起きうる特殊なOSや組み込みならアロケータが借りてるメモリを全返却すればよい
2024/11/10(日) 21:16:26.31ID:tFJCBt9m
>>744
んでどっちのアロケータの話をしてるの?って
2024/11/10(日) 21:22:25.58ID:xIqOi7JH
>>745
普通の仮想メモリOS環境ならstaticでもBox::leakでもプログラム終了後にメモリリークは起きないから対策の必要がない
そうでない特殊なOSや組み込み環境ならばそれ用に用意するメモリアロケータをプログラム終了直前に呼び出して全メモリ返却させればメモリリークは起きない
2024/11/10(日) 21:35:16.61ID:tFJCBt9m
>>746
グローバルアロケータの話をしてんのか、カスタムアロケータの話をしてんのか、って聞いてんだよ

自分の頭の中の理屈をダンプするんじゃなく、言葉の定義をすり合わせる努力をしろ
2024/11/10(日) 21:41:49.64ID:tFJCBt9m
少なくともvalgrindとかperfmonみたいなやつは、プログラム終了時にヒープを辿って解放済みマークの無い場所を見つけたらリークって報告するんだし、一般的にはそれがリークだよ
プロセス終了時にメモリマップの割り当てが解除されるとか、どうでもええわ
2024/11/10(日) 21:48:10.22ID:xIqOi7JH
>>747
Rustでは#[global_allocator]指定でカスタムなグローバルアロケータを使える
プログラム終了後にメモリリークが起きうる組み込み環境なら対応した自作のアロケータを実装してそのように指定して用いる
750デフォルトの名無しさん
垢版 |
2024/11/10(日) 22:10:00.14ID:E3OFY7Tp
>>729
May I talk about the ownership reproduction in the formal community web page?
2024/11/10(日) 22:15:02.72ID:tFJCBt9m
> プログラム終了後にメモリリークが起きうる組み込み環境
組み込みやったことないから知らんけど、そんな環境があんの?
2024/11/10(日) 22:27:44.25ID:tFJCBt9m
https://github.com/rust-embedded/embedded-alloc

組み込みの典型的なコードってこのREADMEのサンプルコードみたいなんでいいのかね
プログラム(main)は終了しない
ヒープの「解放」処理も無い
合ってるよな?

自由に使える物理アドレス空間の一部を実行時アロケーションのために使用するってだけなら、使い終わりにやる「解放」の処理というのは何の話を言ってるんだ? って思ってたけど
そんなものはない、で合ってるのよな?
2024/11/10(日) 22:31:44.37ID:tFJCBt9m
>>750
search first
2024/11/10(日) 22:33:46.00ID:xIqOi7JH
>>751
そういう特殊な環境を出してるのは俺ではないからね
すべてを明示的に解放しなくても我々が普通に使っている仮想メモリ利用では問題ないよという話と
組み込みだとそんな仮定はできなくてメモリリークしていく可能性があるよという話の両方が出ているから
後者でも対応したメモリアロケータを用意すれば対応できるよと解決策を示した
755デフォルトの名無しさん
垢版 |
2024/11/10(日) 22:41:08.35ID:E3OFY7Tp
>>753
What do you mean? What I want to do is talking and having a discussion, not searching.
2024/11/10(日) 22:48:01.15ID:tFJCBt9m
>>754
> そういう特殊な環境を出してるのは俺ではないからね
あれ、そうだっけって思って辿ってみたら言い出してたの>>604だったわ
やっぱお前じゃねーか複おじ

プロセスにしろ組み込みのプログラムにしろ、OSだかシステムファームウェアだかの外部の管理者的存在が行儀の悪いやつのケツを拭いてくれてるだけのことを、
常識的のあるプログラマは「リークしていない」とは言わないんだよ
2024/11/10(日) 23:04:28.91ID:nOHdM7oG
プログラムの最後に行儀よくbrkやsbrkでOSへメモリを解放しているアロケーターを見たことないな
OSにとってはどうでもいいことだからそんな行儀よさは不要なのだろう
ましてやアロケーターの内部でフラグなどをオフにするだけのfree()はプログラムの最後にいらない
実行中に再利用できるようにするかどうかが本質だろうね
2024/11/10(日) 23:16:52.46ID:tFJCBt9m
えーではリークの定義に関して直接的反論はなしということで
以下はすべて誤りであったということでよろしいですね
対戦ありがとうございました

>>593「freeせずにプログラムが終了したり落ちたりしてもメモリリークは起きない」
>>604「freeを忘れてもあるいはfreeせぬまま異常終了となってもその仕組みによりメモリリークは起きない」
>>631「そしてfree()せずにプログラムが終了してもメモリリークは起きない」
>>744「sbrkのあるOS環境ならsbrkでOSへ全メモリを返還できるのはその通りだがそれをしなくてもプログラム終了後にメモリリークは起きない」
>>746「普通の仮想メモリOS環境ならstaticでもBox::leakでもプログラム終了後にメモリリークは起きない」
「そうでない特殊なOSや組み込み環境ならばそれ用に用意するメモリアロケータをプログラム終了直前に呼び出して全メモリ返却させればメモリリークは起きない」
2024/11/10(日) 23:26:36.38ID:mfp7bShs
static mutは明らかにunsafeなわけだが
紙一重でunsafeとは言えないstatic変数のことを
警戒するかそれとも無駄な警備を極限まで捨てた合理主義の皇帝みたいに思うか
そういう対立はよくある
2024/11/10(日) 23:33:02.28ID:xIqOi7JH
プログラム終了後にメモリリークが起きるとすればOSが面倒をみてくれない環境だけだから
そういう環境では特殊な専用のメモリアロケータを用意するしかないだろうね
それならその自作のメモリアロケータをプログラム終了時に呼んで後始末させればメモリリークは防げる
Rustのstaticでヒープを持つ型を使っても最後まで使うメモリをBox::leak()で確保してもメモリリークは起こらないので安心していい
2024/11/11(月) 00:17:42.59ID:4hLj+VPf
Windows/Linux/macOSあたりなら
ファイルハンドルを閉じずにプログラム終了しても
OSが閉じてくれるから何の問題もない
的な主張?
2024/11/11(月) 00:20:13.67ID:VUm74iyn
> プログラム終了後にメモリリークが起きるとすればOSが面倒をみてくれない環境
また実在しない環境の話し始めた
2024/11/11(月) 00:28:54.94ID:VUm74iyn
間違いを認めなくても勝手にすりゃいいけど、そんなんじゃ誰とも意思疎通できないままだぞ
いくら長文を書き連ねても一緒
2024/11/11(月) 00:56:28.26ID:If7GINDb
2種類ある

OSレベルのclose (例えばC言語でのシステムコールを呼ぶclose()) ならばOSが処理してくれるので異常終了含めてプログラム終了時にcloseしていなくても構わない
ただし各言語ライブラリのバッファリングなど他の機能を持つcloseはプログラム終了までに自分でcloseしないとその機能が完遂しない

一方でメモリ解放の場合
OSレベルのメモリ解放 (例えばbrk/sbrk) ならばOSがそのプログラムの仮想メモリ全体を無効にするのでプログラム終了時に解放していなくても構わない
メモリアロケーターライブラリのレベルのメモリ解放 (例えばfree()) もOSにとっては全く無関係な話なのでプログラム終了時に解放していなくても構わない
2024/11/11(月) 01:04:17.69ID:S8QwpOFj
組み込みは詳しくないんだが今ってOSを使わない
組み込みでRustとか使うの?
Rustのターゲットって多分何らかのOSありきだよね
2024/11/11(月) 01:08:33.73ID:BN15+aOP
>>765
語尾にオジを付けな
2024/11/11(月) 01:10:52.04ID:S8QwpOFj
マ板久々なので意味がわからないww
2024/11/11(月) 01:11:20.28ID:S8QwpOFj
webassemblyもなんか微妙な感じだしもったいない
2024/11/11(月) 01:13:05.34ID:BN15+aOP
>>767
そっか、じゃあ過去のRust本スレを4年分復習してきな
あとここはム板だボケジジイ
2024/11/11(月) 01:16:21.72ID:S8QwpOFj
すまんのうww
2024/11/11(月) 01:27:50.38ID:If7GINDb
>>765
OS無しにも対応している
Rustの標準ライブラリstd::はOS前提の機能も入っていてOS無しだと機能しないものもある
Rustの必須な言語機能はcore::ライブラリに部分に分離してまとめてあるので
ベアメタルな組み込みなどではstd::を使わない#![no-std]を指定してcore::を使う
core::では数値型や配列やスライスに文字列(str)およびその複合型が使えるがヒープは対象外なのでVecやStringは標準機能としては使えないといった違いがある
2024/11/11(月) 01:31:24.31ID:If7GINDb
>>768
Wasm自体ブラウザ内も外もどんどん利用が増えてる
もちろんRustで記述が定番化してる
2024/11/11(月) 01:32:59.90ID:BN15+aOP
>>771
とこういった感じの書き込みをするRust信者が複おじ
このスレを読む上での必須知識だから覚えておくように
2024/11/11(月) 07:39:38.28ID:P9CdfRTw
>>732
これ本当?
そうだとするとstatic使った動的ライブラリをアンロードしたら本物のリークが起きる可能性があるが。
2024/11/11(月) 09:19:55.92ID:S9DN3uey
>727
rustの質問するならclaude ai 3.5 sonetが圧倒的に優秀よ。
776デフォルトの名無しさん
垢版 |
2024/11/11(月) 12:55:36.23ID:Bg57iHzA
In the rust forum, we have to use English. How can I say “複おじ”? “Reproduction codger”?
777デフォルトの名無しさん
垢版 |
2024/11/11(月) 13:34:10.78ID:RXw/cl7Z
>>727
ほんまにごみ
数学的な(結論出てる)質問しても平気で間違う
2024/11/11(月) 13:55:19.20ID:kpiTidm5
RustというかCargoの質問なんだけど
crates.ioにリリースしてるもので
一つのcrateでバージョンがいくつかあって
最新のバージョンだけ残して他全部yankedにしてるのに
閲覧回数レポート(crateトップページの下の方の折れ線グラフ)で
yankedされてるバージョンがいつまでもアクセスがあって増え続けて
最新の方がそっちの勢いほどには増えてない
どういう原因が考えられる?
2024/11/11(月) 14:34:31.51ID:xigD4A3Y
>>778
単純にyankされたバージョン使ってる(つまりCargo.lockにそのバージョンが載ってる)ユーザが多いってだけでは?
yankしたからといって既存のユーザが使用禁止になるわけではないので
780デフォルトの名無しさん
垢版 |
2024/11/11(月) 22:49:05.67ID:MbvyOF01
>>551
Rustはリファクタリングや機能拡張保守などに適した言語と言われている
強力な静的型付け、借用チェック、参照競合チェック、メモリ競合チェックなどによりコードが思わず壊れることを防ぐとともに
問題点を実行時エラーや実行時デバッグへと遅らせてしまうことを最も少なくしてくれる言語である
そのため全体の開発変更時間が他の言語より短く済んでいる

また、トレイトとトレイト境界による自然なジェネリック化がレイヤー分離独立と最小限の変更での機能追加を容易にしている
どうしてもトレイト設計をし直さなければならない大規模改修の場合でも、上述のように盤石に機能するコードとするまでが早い
781デフォルトの名無しさん
垢版 |
2024/11/11(月) 22:59:26.02ID:8PeapwRR
借用まわりで質問させてくれ

struct Foo {
 data: Option<Vec<u8>>
}

impl Foo {
 fn do_something(&mut self) -> &mut [u8] {
  if let Some(x) = &mut self.data {
   return x;
  }

  // `self.data` is assigned to here but it was already borrowed
  self.data = Some(vec![0u8; 10]);
  self.data.as_mut().unwrap()
 }
}

これで self.data への代入の際に「既に借用されている」というエラーが出るんだけど、これって回避できない?
最初の借用が if let Some(x) = ... の箇所で行われていることは理解できるんだけど、
if let のスコープを抜けても借用された状態が続く (以降のコードでの借用ができない) のが腑に落ちない
782デフォルトの名無しさん
垢版 |
2024/11/11(月) 23:19:09.36ID:PqwBaVS/
>>781
fn do_something(&mut self) -> &mut [u8] {
if self.data.is_none() {
self.data = Some(vec![0u8; 10]);
}
self.data.as_mut().unwrap()
}
2024/11/11(月) 23:31:21.84ID:VT05MWRT
>>774
Static items do not call drop at the end of the program.
https://doc.rust-lang.org/reference/items/static-items.html

Drop types placed in statics WILL leak.
https://github.com/rust-lang/rfcs/pull/1440
784デフォルトの名無しさん
垢版 |
2024/11/11(月) 23:46:08.88ID:8PeapwRR
>>782
ありがと、これで回避できた
けど借用のルールはまだいまいち分かってない…
785デフォルトの名無しさん
垢版 |
2024/11/11(月) 23:52:53.38ID:PqwBaVS/
staticはモジュールアンロードする可能性があるなら始末する時に手動dropできるように対処するしかないな
アンロードしないなら問題なし
2024/11/12(火) 00:02:28.18ID:h5v4AbHm
>>782
えーとOptionがnoneのとき値を入れたいという場合はもっと簡単に書けて

fn do_something()->&mut [u8] {
self.get_or_insert(vec![1,2,3])
}

という感じ。
2024/11/12(火) 00:12:38.06ID:syNPHnUf
>>781
&mut self.dataにも所有者がある
この匿名の所有者の寿命を'a
型を&'b mut T
とする
'bは'aより長いから'aがいくら短くても、借用された状態が続く

匿名をやめて名前をつければその名前でアクセスできる
2024/11/12(火) 00:13:32.91ID:crz7XiUG
なるほど、リークしちゃうんだ。
2024/11/12(火) 00:50:59.75ID:d/AkYtUw
get_mut OR (insert AND get_mut)を
1ステップにまとめるのは気持ち悪いな

1ステップにまとめていいなら
最初からデフォルト値を入れといてもいいのでは?
2024/11/12(火) 02:10:28.31ID:9at7I+bi
>>787
さすが複オジ
ぶっ飛んでるな
2024/11/12(火) 03:23:50.67ID:SFBl6mVs
>>781
この辺のルールかなって思ったけど正直分からん
https://doc.rust-lang.org/reference/destructors.html

return x;をpanic!()に変えるとコンパイル通ってしまうのはどこかに明確な説明があるかね……
2024/11/12(火) 03:24:11.27ID:SFBl6mVs
>>781
drop scopeの決定時に制御フローは考慮されないってことなのかなって思ったけど正直分からなくなってきた
https://doc.rust-lang.org/reference/destructors.html

return x;をpanic!()に変えるとコンパイル通ってしまうのはどこかに明確な説明があるかね……
793デフォルトの名無しさん
垢版 |
2024/11/12(火) 07:26:38.88ID:7hmoxDUg
>>789
複おじの発想が気持ち悪い
2024/11/12(火) 10:15:49.34ID:m541/0mz
>>781
省略せずに書くと
fn do_something<‘a>(&’a mut self) -> &’a mut [u8]

return xするとxのライフタイムは’a
xは&mut self.dataの一部なので&mut self.dataのライフタイムも’a
‘aのライフタイムに渡って&mut self.dataを借りておく必要があると解釈されるので
self.data = Some(vec![0u8; 10]);はエラーになる

マッチしない場合は借りないようにしてくれよと思うのはわかるが
これは今のバージョンのボローチェッカーの制約
nightlyで使える新しいボローチェッカーならエラーにならない

詳しいのは↓ここ
https://rust-lang.github.io/rfcs/2094-nll.html#problem-case-3-conditional-control-flow-across-functions
2024/11/12(火) 10:22:11.79ID:m541/0mz
if self.data.is_some() {
return self.data.as_mut().unwrap();
}

if let Some(ref mut x) = self.data {
return x;
}
でも
エラーにならない
2024/11/12(火) 10:23:41.85ID:m541/0mz
>>793
複おじではないよ
2024/11/12(火) 11:06:54.00ID:POGIqTjB
>>794
新しいボローチェッカーって-Zpolonius=nextのことでいいの?
付けても通らなかったけど、これが通せることを目標にしてるって意味?
2024/11/12(火) 11:26:31.07ID:syNPHnUf
仇討ちして英雄になりたいのか
とんでもねえ話だなこれ
2024/11/12(火) 13:38:59.51ID:DUnFCq7X
>>797
-Z poloniusで通る
2024/11/12(火) 14:07:23.60ID:SFBl6mVs
>>799
おっいけたわありがとう
-Zpolonius=[legacy|next]だと思ってたらいつの間にやらon/offフラグになってたのね
801デフォルトの名無しさん
垢版 |
2024/11/12(火) 18:29:56.22ID:03t9MEqY
>>781
左右の型が一致しない(右だけ参照)この部分を
if let Some(x) = &mut self.data {
昔からの正規にrefを使って左右の型を一致させて
if let Some(ref mut x) = self.data {
こう書けばコンパイル通る点は興味深いな
802デフォルトの名無しさん
垢版 |
2024/11/12(火) 22:58:43.29ID:lrdX5dtV
どうしてこのプログラムがコンパイル通るのかがわからん
明らかにyの寿命はxより短いはずなのに、xより長生きすることが仮定された引数にyを渡したらエラーになるはずでは?
x,yの型をどういうのに変えたらこれをエラーにすることができる?
fn test<'a, 'b:'a> (_x:&'a (), _y:&'b ()) {
}
fn main() {
let x = ();
{
let y = ();
test(&x,&y);
}
}
2024/11/13(水) 00:44:01.02ID:on0r5hse
貸し借りの実態を操作したつもりが、「借りられるのに誰も借りてない」状態が続いただけで
実態が変わらなければエラーも起きない
2024/11/13(水) 01:07:05.96ID:04hNMT1D
Rust信者って、説教くさいよね。
2024/11/13(水) 01:22:28.48ID:DQQnUk/3
急にどしたの?
806デフォルトの名無しさん
垢版 |
2024/11/13(水) 02:11:38.53ID:lxEAsUm8
>>802
test画最適化されて消えてるんだろう
807デフォルトの名無しさん
垢版 |
2024/11/13(水) 08:18:30.90ID:DDTh9MDd
>>803
変更を加えるとしたらどうしたらいいですか?
2024/11/13(水) 08:30:57.78ID:xIctxtN4
国内では生成AIに話題を奪われてハイプがめっきり落ち着いた感があるな
世界的には中華圏を中心にまだまだ上昇の余地がありそうだが、国内では残念ながら一部のアーリーアダプタが騒いだだけの言語で終わりそうだ
809デフォルトの名無しさん
垢版 |
2024/11/13(水) 08:46:31.60ID:18dRnPdZ
米ホワイトハウス「ソフトウェアはメモリ安全でなければならない」との声明を発表:「C」「C++」よりも「Rust」などの言語を推奨
https://atmarkit.itmedia.co.jp/ait/articles/2403/18/news045.html

米国国防総省のDARPA、CからRustへのコード変換を自動化する「TRACTOR」プログラムを開始
https://atmarkit.itmedia.co.jp/ait/spv/2408/14/news045.html
2024/11/13(水) 09:16:26.38ID:T0htHWVn

refの出番あるじゃん
コンパイラのsuggestちゃんとしてくれよ
2024/11/13(水) 09:17:25.81ID:T0htHWVn
>>807
変更を加えるには変更を加えれば良い
2024/11/13(水) 09:19:24.12ID:T0htHWVn
>>808
國内の外注プログラマは二次請け三次請けで
コーディングの実態はインドやバングラ
日本人需要はもう無いかもな
2024/11/13(水) 09:22:11.31ID:on0r5hse
>>807
出題者の期待を裏切るような変更しかなさそうだね

微調整だけで解決してほしいとかリセットはやめてほしいとか
そういうのを裏切る
2024/11/13(水) 09:43:08.15ID:QAOz5ViO
>>802
x,yのスコープと&x,&yのライフタイムを混同してるように見える

fn test<'a, 'b: 'a>(x: &'a (), y: &'b ()) -> (&'b (), &'b ()){
(x, y)
}
とすれば’a: ‘bがなければ関数単体でエラー

fn test<'a, 'b: 'a>(x: &'a (), y: &'b ()) -> (&'a (), &'a ()){
(x, y)
}
fn main() {
let x = ();
let result: (&(), &());
{
let y = ();
result = test(&x, &y);
}
println!("{:?}", result);
}
↑のように&yのborrowをyのスコープを越えて利用すればエラー
でもこの場合の関数定義は’bを使わず全部’aにしても何も変わらない
2024/11/13(水) 17:49:14.41ID:6VxXcvJp
>>727
最近上がった孫さんの動画だと最新のchatgptはいいみたいだよ
2024/11/13(水) 19:43:07.11ID:hOqFwLmf
コードの生成なら Claude ai にしておけって。
2024/11/14(木) 00:17:38.18ID:KXRqkFBN
>>815
こないだ試してみたら、さほど良くなってないみたいだったが。
818デフォルトの名無しさん
垢版 |
2024/11/14(木) 04:49:13.06ID:yxSXUQjo
Claude ai 無料でも有能で笑った
2024/11/14(木) 09:48:02.77ID:ftI5Ceve
>>817
それはバージョン o1 だった?
2024/11/14(木) 17:17:13.60ID:9ejC22ly
>>819
ChatGPTではなく、OpenAI o1 のことかいな?
2024/11/14(木) 20:42:25.26ID:ftI5Ceve
すまん、違うものだったか
孫さんの動画でGPTの次のバージョンのような扱いしてたので同じかと思ってた
2024/11/16(土) 05:20:14.39ID:Heg70qiV
アメリカ政府が「安全な言語を強制する」姿勢は、
「規制」だね。それによりC/C++だけが排除される。
ずる賢い連中だ。日本の半導体もそれで駄目になった。
823デフォルトの名無しさん
垢版 |
2024/11/16(土) 06:03:12.01ID:KjVWfR2g
>>822
C/C++のようなクズ言語は早く消えたほうがいい
今はZigやRustなど代替できる良い言語が色々ある
2024/11/16(土) 06:40:57.58ID:Oydl0g71
時間ライブラリ、chrono使いにくいなーと思ってtimeに乗り換えたけど
メンテ状態がいまいちだし、変な仕様がいくつもあるなーと悩んでた

今日 jiff を見つけて試してみたら、とても使いやすい
設計のベースがjsのTemporalということもあり、変な独自仕様が少なそう
作者が有名人だし、今後も期待できる
ただちょっとバイナリサイズが大きめかな
2024/11/16(土) 09:37:53.01ID:buoPSpZk
>>822
規制と言うより新陳代謝。
c/c++にいくら新機能入れても無理が来てる。
ライブラリの都合上まだ仕方なく使ってるけど。徐々に置き換わって行くよ。
2024/11/16(土) 14:25:13.85ID:YZsYA2TA
プロが一番使っている言語であるところのC/C++だけが、
アメリカ当局の鶴の一声で潰されようとしている。
827デフォルトの名無しさん
垢版 |
2024/11/16(土) 14:55:20.01ID:KjVWfR2g
欠陥言語C/C++が一掃されるのは良いこと
無知と怠惰が欠陥言語にしがみつく
2024/11/16(土) 15:50:00.42ID:YZsYA2TA
市場やソフトウェア業界のプログラマや個々の経営者が決める
べきであり、政府が強制すべきではない。
829デフォルトの名無しさん
垢版 |
2024/11/16(土) 16:25:18.89ID:/+LxZ+59
サイコパスは「痛みを伴う失敗」から学習できない!
2024.11.15
nazology.kusuguru.co.jp/archives/165730
「パワハラ上司が生き残る条件」みんな●●だった!
2024.07.12
nazology.net/archives/156599
2024/11/16(土) 16:50:05.47ID:vdtMtO4q
>>828
アメリカ政府は顧客のひとつとして Rust の積極的導入を要望しているのであって市場に対する規制なんてしてないよ。
結果的に影響力が大きくはあるけどな。
2024/11/16(土) 16:59:51.39ID:YZsYA2TA
>>830
「メモリー安全で無い言語は使うべきではない」
などと言ったそうだが。
2024/11/16(土) 18:31:49.86ID:Pw6hvHrk
欠陥言語使わないといけない世界は改善したほうが良い
2024/11/16(土) 18:48:21.70ID:buoPSpZk
>>828
別に法律で何時までにどうしろと決めたわけでもないので好きにすればいいけど、技術力が無い会社は置いてかれる、それだけの事よ。
834デフォルトの名無しさん
垢版 |
2024/11/16(土) 20:55:43.27ID:KjVWfR2g
全盛を極めていたプログラミング言語たちが情勢の変化により落ちていった
今回はC++の番
2024/11/16(土) 21:01:25.26ID:ri7JcYNG
特定の言語使うことを技術力と思うのは勘違いな
たいした価値を生まない
836デフォルトの名無しさん
垢版 |
2024/11/16(土) 21:26:15.37ID:M8rnPwhr
Rustの採用って実のところ、既存の資産を捨ててゼロベースで書く、キャッチアップのためにコストをかける (慣れてる言語よりも時間がかかることを許容する) とかの思い切りの問題だと思う
2024/11/16(土) 21:37:25.08ID:vdtMtO4q
それはそう。
C++ が良い言語ではないことに C++ の設計者は自覚的で、それでもなお「今」目の前にある問題に対処可能であることを理念にしてる。
まだ不十分だけど良い言語だなんてのは実務者にはなんの救いにもならない。
汚くてもなんとかする方法はあるほうがありがたい。
ただ、無限に汚くなり続けることは許容できないのだから、どこかで新しいものが生まれてリセットする必要はあって今がその時なんだろう。
でもまあ現実に使われるものは汚いものだよ。
だって現実が汚いものだから。
Rust もいずれ汚くなって次のなにかに置き換わる。
それが半世紀くらい後だとよいね。
2024/11/16(土) 22:52:16.06ID:yOVM5XGF
C/C++しか使えないダメ人間だと他の言語に手を出したり習得したりするハードルも高くそんなスキルもないんだな
普通に色んな種類の言語をやってきていればすぐに対応できるようになる
2024/11/17(日) 00:10:11.34ID:QnncDtq4
C/C++ を「ちゃんと」使えているならかなり能力は高いはず。
あの無茶苦茶なのを把握してるわけだからな。
でもちゃんと理解せずに使っているやつもそれなりに多いのもそう。
2024/11/17(日) 01:01:11.07ID:XcYTf0nE
アメリカ政府がRustが欠陥言語であることに気づいて無いだけだ。
841デフォルトの名無しさん
垢版 |
2024/11/17(日) 09:50:13.04ID:e6wbF7Sw
>>840
欠陥の無い言語教えれ
842デフォルトの名無しさん
垢版 |
2024/11/17(日) 10:45:30.77ID:tn0ahmRj
RustはCの置き換えには最適だが
C++からRustはノーチャンス
843デフォルトの名無しさん
垢版 |
2024/11/17(日) 11:09:03.35ID:LOC+6QAG
>>842
過去資産を除くと
C++の利点は無いと思う
2024/11/17(日) 12:57:50.30ID:QnncDtq4
>>843
まあその過去資産がクソデカだって話なんだけどな。
845デフォルトの名無しさん
垢版 |
2024/11/17(日) 13:22:59.92ID:dobbbVxQ
現実的なことを言うとRustの仕事は多くないからな
世の中的にはC++の方が多いし、それよりもC#やJava、JavascriptやPythonの方が多い
現状Rustを書ける人が少ないから組織としても採用しづらい、みたいなところもある
2024/11/17(日) 14:04:38.06ID:+vBbiqfq
Rustは欠陥が多すぎる。
847デフォルトの名無しさん
垢版 |
2024/11/17(日) 14:14:43.13ID:LOC+6QAG
>>846
C++と比べても桁違いに欠陥ない
2024/11/17(日) 14:17:04.13ID:+vBbiqfq
>>342
>RustはCの置き換えには最適だが
そんなことない。むしろ置き換えに適さない。

>>843
そんなことない。
2024/11/17(日) 16:20:28.69ID:QnncDtq4
Rust に (まだ) 足りないものはあるという意味では欠陥はあるが、設計が間違ってて改善の余地がないような欠陥は少ないだろ。
C の場当たり過ぎる設計に比べれば Rust はだいぶん綺麗だわ。
850デフォルトの名無しさん
垢版 |
2024/11/17(日) 17:47:06.07ID:ZjcPAB2G
C++は多段に増築して要らないものも多く
新しい仕様は良いけど広まっていなくて
標準ライブラリのインターフェイスを新たな仕様にすることもできなくて
初心者にとってC++はRustの何倍も複雑で学習難易度も高いのよ
Rustはシンプルに高機能でプログラミング効率もいいね
2024/11/17(日) 21:11:05.44ID:8SN0eeCN
C++はBoostあたりまでは良かったけどそれ以降は機能のゴミ箱
上品な言い方をすればキッチンシンク担当になった
2024/11/17(日) 21:56:59.22ID:/B1+r+jF
>>849
そうでもない。
2024/11/17(日) 22:25:57.84ID:rGJZLWmT
mordern c+で随分楽になったけど
2024/11/17(日) 22:26:17.33ID:rGJZLWmT
modern
2024/11/17(日) 22:37:46.32ID:lBJAP2+3
CをRustで置き換えたら劇遅になるから重要な部分は無理じゃね
2024/11/17(日) 22:55:33.70ID:HbSpYeRV
>>855
デバイスドライバを両方で実装して速度がほぼ変わらないことが立証されている
2024/11/17(日) 23:02:46.96ID:/B1+r+jF
>>856
それは、一般にデバイスドライバはシンプルなアルゴリズムしか使ってないからだよ。
858デフォルトの名無しさん
垢版 |
2024/11/17(日) 23:11:47.34ID:vlQbYPk+
同じアルゴリズムでRustが遅い例プリーズ
2024/11/17(日) 23:14:29.54ID:/B1+r+jF
>>858
unsafeを使わない限り、ほとんどのアルゴリズムがそれに当たる。
なぜなら、ほとんどのアルゴリズムが使えないから。
860デフォルトの名無しさん
垢版 |
2024/11/17(日) 23:19:43.73ID:ZjcPAB2G
>>859
ウソつき
861デフォルトの名無しさん
垢版 |
2024/11/17(日) 23:25:29.83ID:dobbbVxQ
安全側に寄せる部分でRustの方が基本的にコストかかるんじゃないの?
グローバルな可変状態はMutexが無いと書けない (アクセスの度にロックが必要) とか、Cellは実行時に借用チェックするとか、配列は基本的に範囲チェックされるとか

コンパイラは利用側を知り得ない (複数スレッドから呼ばれる可能性があると想定せざるを得ない) からMutexが必要だけど実際は無いと想定して良い、みたいなケースはありそう
2024/11/17(日) 23:28:19.03ID:/B1+r+jF
>>860
あなたも含めたここの連中は理解力が低い。
なお、俺には丁寧に説明する義務は無い。理解できない人はそのままでいい。
俺には関係無い。
863デフォルトの名無しさん
垢版 |
2024/11/17(日) 23:34:51.20ID:vlQbYPk+
>>859
unsafe使えば同等になるなら、どこかの誰かさん以外はRustが遅いとは思わないのでは?
とりま、unsafe使わない遅いコードさらしてみては?

ここの優秀な方々が「unsafeでもこうすればCと同等の速さだ!」ってコードを返してくれるかもしれん。
2024/11/17(日) 23:37:27.94ID:HbSpYeRV
>>861
そこはどの言語でも同じ
スレッドローカル変数を使う
RustでもMutexの必要はない
865デフォルトの名無しさん
垢版 |
2024/11/17(日) 23:41:13.09ID:8NoNC7dP
他のレスに「あなたは正しくない」とだけ書けば自分が賢いということになるなら、それほど楽なことは無いな
スマホさえ持ってれば小学生でも同じことはできるわけだし
2024/11/17(日) 23:53:16.59ID:wVREKDBU
100点オジと複オジはいつまでたっても進歩がないな
2024/11/18(月) 00:24:33.99ID:GfaceI2A
基礎的なデータ構造に unsafe が必要になるのは本当だ。
基礎は std で提供されるのでその上では unsafe の仕様が少なくなるように巧妙に設計されている。
std を使えないときに std と同等なものを作らなければならないような状況だと C とあまり差はない。
逆に言えば unsafe を含む下回りをかっちり作りさえすれば Rust のほうが優秀だよ。
2024/11/18(月) 02:14:46.19ID:Ui+tF1gu
あゝこんなときRustにもextern "C"があれば平和が訪れるのに
869デフォルトの名無しさん
垢版 |
2024/11/18(月) 04:44:45.38ID:IRvDm3R2
>>840
「欠陥のない言語は存在しない。だがデバッグの不可能な言語もまた存在しない」
2024/11/18(月) 07:01:58.78ID:rC7K9dh5
おれの作った言語はデバッグ機能ないけど?
871デフォルトの名無しさん
垢版 |
2024/11/18(月) 07:06:12.01ID:INV+aJIp
【ナゾロジー】サイコパスは「痛みを伴う失敗」から学習できない! [すらいむ★]
http://itest.5ch.net/egg/test/read.cgi/scienceplus/1731838156
2024/11/18(月) 08:33:03.50ID:boZQ3aHy
>>868
あるやる
2024/11/18(月) 09:04:25.28ID:92FA8ffy
>>867
>逆に言えば unsafe を含む下回りをかっちり作りさえすれば Rust のほうが優秀だよ。
そんなことない。
unsafeがライブラリ関数の外に染み出てくるから。
2024/11/18(月) 09:13:51.03ID:92FA8ffy
>>865
ここに書かないのは、「企業秘密的」な意味も有るんだよ。
875デフォルトの名無しさん
垢版 |
2024/11/18(月) 09:30:27.68ID:IRvDm3R2
>>862
競プロでもやってんの?
2024/11/18(月) 09:41:47.81ID:7J3JrtFR
>>873
RustがC/C++に勝利した一番大きな要因は
メモリ操作など基本的にunsafeにたどり着く様々な操作を
中身でunsafeを使っていてもそれを外へ染み出さないsafeなインターフェイスを提供して実用的に使えることを示した点にある
これがRustの標準ライブラリの中核であり
同様にしてunsafeが外へ染み出さないsafeなライブラリを作ることもできる
2024/11/18(月) 10:43:14.43ID:92FA8ffy
>>876
馬鹿発見。
878デフォルトの名無しさん
垢版 |
2024/11/18(月) 12:57:29.84ID:0TuJxtFY
>>873
unsafeの何が悪い
unsafe{
下回りもunsafe
利用者側もunsafe
皆で使おうunsafe
}
2024/11/18(月) 13:58:30.56ID:DtxKjacA
unsafeが染み出すとか言っているの本気?
意図的に出さないと出てこないよ?

// 意図的なunsafe
pub unsafe fn dangerous_operation() {
// 何らかの危険な操作
}

// 利用者側
unsafe {
dangerous_operation(); // ここでunsafeが必要
}

普通はこう書く

// ライブラリ側
pub fn safe_wrapper() {
unsafe {
// 内部で危険な操作を行うが、
// 安全性を保証する条件をすべて満たしている
}
}

// 利用者側
safe_wrapper(); // unsafeは不要
2024/11/18(月) 20:31:59.79ID:7J3JrtFR
>>877
事実を目の当たりにして具体的な反論や反例を出せない気苦労は理解するが
それでも具体的にRustのコードを示すのがよいかと
881デフォルトの名無しさん
垢版 |
2024/11/18(月) 21:05:40.46ID:K2lQU8l5
>>874
説明は求めないけどね?
「自分は知ってるが説明する義理はない」なんて第三者からみれば「俺は分かりません説明できないです」と書くのと変わらないじゃない
分からないならスルーすればいいのに、それをわざわざ書くのはダサくない?
882デフォルトの名無しさん
垢版 |
2024/11/18(月) 21:41:56.71ID:K2lQU8l5
実際にはunsafe使わないRustはCよりもいくらかオーバーヘッドが生じるとは思う
Cでなポインタのコピーで済むけどsafe RustだとArcが必要だからcloneの際にロックのコストがかかるとか、配列へのインデックスでのアクセスで境界チェックされるとか
Rustでは安全側に寄せる分のコストはかかるはず
2024/11/18(月) 21:52:16.61ID:k3+/8xDm
>>882
本当に各チェックを安全に外せる場合
つまり安全なインターフェイスを提供できる場合
Rustでもそれを安全なライブラリとして提供すればよいですね
実際にそのようにしてRustの標準ライブラリが作られて来ていますから
2024/11/18(月) 22:05:29.90ID:1mdid6am
>>879のコード例だと本当はアウトなのに屁理屈でセーフという俺ルールでねじ曲げてるだけに見える
それunsafeやない、アウトや!
2024/11/18(月) 22:35:51.22ID:SToHXvxk
計測して本当にunsafeにする価値がある部分だけ暴走覚悟でunsafeにすればいい
満たさないと危なくなる条件はdebug_assertしておくと気休めになる
886デフォルトの名無しさん
垢版 |
2024/11/18(月) 22:46:47.54ID:r0p6egBs
>いくらかオーバーヘッドが生じるとは思う
そんなレベルじゃないだろw
2024/11/18(月) 22:49:05.04ID:7J3JrtFR
>>882
安全のためのオーバーヘッドはどちらの言語も同じです

Rustも&TならばCopy実装型なのでコピー出来ますからC言語と同じです
Arcのcloneはロックフリーです
ロックされるのはその中で用いるMutexなど
C言語でも排他制御が必要なところではMutexが使われます
ヒープを使うデータをポインタで指す人数が変化していくならば最後の人が解放するためにリファレンスカウント管理が必要です
実際にC++ではそれがshared_ptrとしてArcと同様なものが提供されています
2024/11/18(月) 22:53:38.18ID:+RZAZC6X
よかった、RustとCではオーバーヘッドは同じがRustの方が少ないんだね
2024/11/18(月) 22:59:47.77ID:x8ZZBVl/
前提条件大杉
2024/11/18(月) 23:17:10.99ID:tFghvvKh
>>888
複おじ、幼稚すぎw
2024/11/18(月) 23:40:55.05ID:k3+/8xDm
Rc相当がなくArc相当のshared_ptrしかないC++はオーバーヘッドが大きい
2024/11/18(月) 23:52:07.17ID:dSfvQiDe
C++でポインタいじってる時も特定の前提条件の時まともに動くだけで、そこから外れたらすぐバグるから。安全性のレベルを合わせたら結局どちらも同じようなコードになるよ。条件チェックしてるのとしてないのを比較して速い遅い言われても。
あと、rustの方が型で前提条件弾いて全域関数を作りやすいから。下手なC++よりは最適化される場合もある。何にせよ最初ほ安全に振っておいて、そこからプロファイラかけて遅いところだけ変えて行くほうがいいと思うけどね。
893デフォルトの名無しさん
垢版 |
2024/11/19(火) 00:32:35.22ID:GSnhfwF9
参考までに聞きたいんだけど、画像処理みたいなタスクってunsafe無しでもC/C++と同等の速度を出せるの?
フィルタのように周辺画素の値を使う処理や、処理対象の画素 (もしく行) を複数スレッドに分割するような処理を想定してる

自分の知識だと、可変かつマルチスレッドのような場合はsafe Rustだと難しい気がしてる
unsafeを使うなら、オーバーラップしないように範囲を分割して、そのポインタを渡して処理させることはできるけど、safe Rustだと可変借用のルールが問題になる気がしてる
それこそunsafeを使うべき場面だというなら納得するし、safe Rustでもうまくやれるなら知っておきたい
2024/11/19(火) 00:50:32.75ID:FW/CGHup
>>893
rayon crateというデーター並列処理のライブラリを使う。チャンクに分割されたパラレルイテレータを回すだけ。フィルター処理とかは割と簡単。
2024/11/19(火) 01:54:46.13ID:FW/CGHup
use image::{ImageBuffer, Rgb, RgbImage};
use rayon::prelude::*;

fn to_grayscale(img: &RgbImage) -> RgbImage {
let (width, height) = img.dimensions();
let mut output = ImageBuffer::new(width, height);

output.par_chunks_mut(3).zip(img.par_chunks(3)).for_each(|(out, pixel)| {
// RGB to グレースケール変換の重み付け
let gray = (0.299 * pixel[0] as f32 +
0.587 * pixel[1] as f32 +
0.114 * pixel[2] as f32) as u8;

out[0] = gray;
out[1] = gray;
out[2] = gray;
});

output
}

fn main() -> Result<(), image::ImageError> {
let img = image::open("input.jpg")?.to_rgb8();
let gray_img = to_grayscale(&img);
gray_img.save("output.jpg")?;
Ok(())
}
2024/11/19(火) 02:09:20.81ID:FW/CGHup
サンプル書いてみた。
RGB画像をグレースケールに変換する。
imgが入力画像、outputが出力画像のバッファ。
イテレータで回してクロージャー呼んでる。

per_chunks_mut、per_chanksでチャンクのサイズ指定。今は1ピクセルrgbで3バイトずつ取り出してクロージャーの引数として渡される。スレッドの並列処理は自動で行われてる。
例えばチャンクサイズをwidth×3とかにすれば1ラインずつデータが渡される。width×3×2とかにすれば2ラインずつ。ある程度のサイズにしたほうが高速になる。
チャンクのサイズを変えたらクロージャーの処理も変えるのを忘れずに。
2024/11/19(火) 02:14:25.94ID:FW/CGHup
これをC++で書けと言われたらやりたくない。
rustなら安全で分かりやすく書けるし、イテレータは並列処理の最適化が効く。
898デフォルトの名無しさん
垢版 |
2024/11/19(火) 07:54:11.15ID:126iZ9C9
rayonが出たついでの質問なんだけど、rayonのイテレーター (par_iterなど) ってグローバルなスレッドプールでなく、ThreadPoolBuilder::build で作ったスレッドプール上で実行できる?
以前調べた際によく分からなかった
899デフォルトの名無しさん
垢版 |
2024/11/19(火) 08:24:41.51ID:0JKwCmNc
ところでこのスレって業務で実際にrust使ってるよーって人います?
2024/11/19(火) 08:27:40.98ID:FW/CGHup
スレッド数を自分で設定したいって意味でいいのかな?
rayon::ThreadPoolBuilder::new().num_threads(8).build_global().unwrap();
2024/11/19(火) 08:32:14.22ID:FW/CGHup
use rayon::ThreadPoolBuilder;

// カスタムスレッドプール作成
let pool = ThreadPoolBuilder::new()
.num_threads(4) // スレッド数指定
.build()
.unwrap();

// スレッドプールで特定の処理を実行
pool.install(|| {
output.par_chunks_mut(row_size)
.zip(img.par_chunks(row_size))
.for_each(|...| {
// 処理
});
});
902デフォルトの名無しさん
垢版 |
2024/11/19(火) 14:47:04.76ID:9IiXc5Vb
>>892
>下手なC++

templateですね判ります
2024/11/19(火) 15:24:29.64ID:+UtMc6V6
>>897
なんで主語がrustとc++なの?
便利なライブラリがあるってだけでしょ?
c++でも同様のライブラリを作るのは可能だと思うけど
2024/11/19(火) 15:42:39.43ID:s9mRA7mb
Rustが勝利した原因はrayonやtokioなどのマルチスレッドを便利に安全に活かすライブラリの存在が大きいが
C/C++は数十年の年月を重ねてもそれに匹敵するものが完成しなかった
2024/11/19(火) 16:37:47.00ID:Yysxm38B
>>903
発端はrustでc++みたいなフィルター処理書ける?って話。c++でも書けるかもしれんが自分は面倒なんで誰かコード書いてくれ。
906デフォルトの名無しさん
垢版 |
2024/11/19(火) 22:42:01.95ID:126iZ9C9
>>901
ありがたい
やりたいのは「明示的に指定した場合のみ並列処理をする」プログラムで、データとしては Option::ThreadPool みたいなものを持ってるから、その中で実行したいという話

よく分かってなかったのは install の動作で、これに渡したクロージャーはプール内のスレッドで実行されると思ってたから、例えば4スレッドの場合に「スレッド1がpar_chunksを含むコードを呼びだす、それを受けてスレッド2-4が並列実行する (スレッド1はinstallに渡したクロージャの終わりでブロックされる) 」みたいなことになったりしないか…って思ってた
(公式のリファレンスは Executes op within the threadpool. という説明)

問題なさそうなら使わせてもらいます
907デフォルトの名無しさん
垢版 |
2024/11/19(火) 22:46:22.71ID:jmJ5BpPK
C++で並列とかようやらんわ
SendもSyncもないとかもう考えられん
908デフォルトの名無しさん
垢版 |
2024/11/19(火) 22:49:56.47ID:126iZ9C9
違うかも?
>>906 のスレッド4つの例だと、クロージャー自体はプール内のスレッド(スレッド1とする) で実行されて、スレッド1はpar_iterで並列処理を開始した後すぐ抜けて par_iter の仕事に加わるということ?
2024/11/20(水) 00:33:04.50ID:shrZYon3
例えばスレッドプールを4で設定するとワーカースレッドが4つになります。でそれとは別にメインスレッドがあるわけで、このパラレルの処理をするときはメインスレッドもワーカーとして参加します。なので5個で回る感じ。
2024/11/20(水) 00:36:52.89ID:ijtcomF1
pool.installとpool.scopeでメインスレッドがワーカーとして参加するかしないかが変わるみたい。
2024/11/20(水) 00:42:34.33ID:e0+ziHsU
>>907
C++にasyncがあるぞ。
2024/11/20(水) 00:47:56.81ID:ijtcomF1
いずれにせよパラレルイテレータを回しているときは処理が終わるまで待つことになるんで、メインスレッド止めたくないときは別スレッドで立てる感じ。
fn non_blocking_example() {
let (tx, rx) = mpsc::channel();

std::thread::spawn(move || {
let pool = ThreadPoolBuilder::new()
.num_threads(4)
.build()
.unwrap();

pool.install(|| {
// 並列処理
});

tx.send("Done").unwrap();
});

// メインスレッドは他の処理を継続可能
println!("Doing other work");

// 必要なタイミングで結果を受信
match rx.recv() {
Ok(msg) => println!("Processing complete: {}", msg),
Err(e) => println!("Error: {}", e),
}
}
2024/11/20(水) 01:09:41.69ID:ijtcomF1
>>911
asyncは全然別の話。
rustでは型に対してsendやsyncといった属性を付けるようなイメージ。sendが付いてなければ別スレッドにデータ渡せないとかsyncが付いてなければ同時に使えないとか、そういうスレッド対応してないものを使うとコンパイラに怒られる仕組みになってる。
914デフォルトの名無しさん
垢版 |
2024/11/20(水) 08:50:31.70ID:yTy4Ahlp
>>912
詳しい説明ありがとう
scope と install については自分でもちょっと調べてみます
2024/11/20(水) 09:59:28.14ID:MYLVUJ4i
最近のCPUは速過ぎるから第三者から見れば「速さ」は見えない
バグなら見える

それで無人の機械で速さを計測するから
第三者などという人間は不要だと分かる
2024/11/20(水) 11:26:15.05ID:W8mVvsIh
Cが早くてRustが劣っていると仮定して
その差が問題なることなんてない
自分では何も生み出せないベンチ回マニアくらいだろ
2024/11/20(水) 12:43:18.25ID:/wT43F1g
>>914
フィルター系のプログラムだとCPUのSIMD命令がかなり効くと思うんでそちらも検討するといいかと。
コンパイラが自動でやってくれる可能性もあるけど、明示的に書くと確実。
標準だと std::simd がそのうち実装される予定。
その他クレートもあるんで探してみて。
2024/11/20(水) 13:08:23.05ID:LXAOodJ8
一般的なサイズの画像の全ピクセルをO(N)で舐める程度ならシングルスレッドで十分じゃね?まあSIMDはアリだが
ガチで速度出したいのって多数のファイルをバッチ処理するようなケースが多いから、
そういうときは結局ファイル単位で並列処理した方がスループット高かったりするんだよね
タスク内の並列化の方が技術的にはチャレンジングだからやりたくなる感情は理解するけどね
2024/11/20(水) 14:17:41.03ID:nL8S8oi5
>>879
馬鹿。
2024/11/20(水) 14:56:07.23ID:ytG52ull
>>918
横からだが、画像フィルタは単なるわかりやすい例として出てるだけだろうから画像サイズなどは関係ない
一般的に多量のメモリ上でのある程度の計算処理が必要で、それがエリア分けして並列可能なら、並列化の検討余地が出てくる

ファイル処理などの件はIOバウンド特にリモートだとIO待ちが顕著になり別の対策が必要になってくる
一番極端な場合はtokioを使って並行並列化が最も速くなりうる
つまり1件に対して1スレッドではなく、1件に対して1タスク(async軽量タスク)を割り当て、1スレッドで複数のタスクが同時に並行に動く形になる

rayonのケースでもtokioのケースでも、利用する並列スレッド数は物理コアスレッド数を上限とする形
2024/11/20(水) 21:20:24.03ID:LXAOodJ8
>>920
高説ごもっともだけど、多数のファイルのバッチ処理をするときには分割しないで1スレッドの方がスループットが高い説自体は間違ってはいないでしょ
SIMD含めスレッド内での最適化は尽くしていて単一プロセッサを100%使い切っているのであれば、
マルチスレッドに伴う諸々のオーバーヘッドやアルゴリズムの複雑化を避けられるから自明
もちろんシングルスレッドだとプロセッサ数に対して件数が十分に多くなきゃスループット落ちるしレスポンスも当然劣るから、一般にどちらが良いということではないが
2024/11/20(水) 21:35:21.34ID:5+HdYMGb
>>921
>>分割しないで1スレッドの方がスループットが高い

おかしい
どういう意味と根拠?
2024/11/20(水) 21:38:51.35ID:5+HdYMGb
>>921
>>マルチスレッドに伴う諸々のオーバーヘッドやアルゴリズムの複雑化を避けられる

ここもおかしい
対象件数があればマルチスレッド起動のオーバーヘッドは誤差
各々に対するアルゴリズムは変わらない
924デフォルトの名無しさん
垢版 |
2024/11/20(水) 21:52:13.97ID:jFXLNFvp
パフォーマンスチューニングは実際の条件によるからね
4Kや8Kの画像に対して重ための非線形フィルタをかける場合ならマルチスレッド化の恩恵はあるだろう (より高速化するならGPU)
多量の画像をバッチ的に処理したいケースもあれば、カメラ画像のように、入力は常に最新の1枚だけという場合もある

それはそれとして、タスクの種類を問わない一般的な話として、Rustにおける (CPUバウンドな) 並列処理についての話が出たと思えば有益な情報だと思う
2024/11/20(水) 22:00:47.56ID:V/GV/ca9
>>923
スレッド起動以外にもマルチスレッドのオーバーヘッドはあるし、マルチスレッド化できるけど効率が悪化する画像処理アルゴリズムなんていくらでもある
それを誤差レベルとして無視できるかどうかはタスクや状況次第だが、いずれにせよゼロではない
2024/11/20(水) 22:03:31.92ID:ytG52ull
>>921
前提と何をするかによって変わりうるかな
例えばちょっと見方を変えるとそれと同種の、多数の人たちから色んなリクエストが来て処理して返す場合、つまりHTTPなどの各種サーバー類の場合
tokioを使ったマルチタスク・マルチスレッドが最も効率がよい
1つのCPUで最も多くの人数を同事に捌くことができる方法になると実証されている
2024/11/20(水) 23:45:54.40ID:5+HdYMGb
>>925
複数の対象があると最初に言ってるのだから
個々の処理がマルチスレッドに不向きなアルゴリズムであっても
複数の対象を並列化すればよい
なぜアルゴリズムが複雑化すると思うのか?
アルゴリズムはそのままでいい
既出のrayonのコード例でも同じ処理(アルゴリズム)が並列に動くだけでありアルゴリズム部分に手を入れずに並列化できている
2024/11/21(木) 00:43:39.12ID:7teRxqa+
コードのサンプルはもっと複雑なのも考えたけど、ここじゃ載せきれないからシンプルにしたよ。この程度ならシングルスレッドでもすぐ終わるのはたしか。
でも複雑な画像処理ならCPUキャッシュのヒット率の方が処理速度に影響するんでキャッシュ溢れないように1つの画像をマルチスレッドで処理した方が速いかもしれない。
非同期が効くのはI/Oメインの処理の場合。何事も用途によりけりだよ。
2024/11/21(木) 00:47:13.55ID:iDAcMnOY
DllMainの引数を確認するべきじゃね?
スレッド起動毎に呼ばれるんだからオーバーヘッドが誤差は言い過ぎ
2024/11/21(木) 01:16:58.88ID:7teRxqa+
ここで言いたかった事は所有権や借用やunsafeの取り扱いで困るのはforループで書こうとした場合で、rustはイテレータ中心で考えると解放される場合が多いという事。配列だけでなくツリー構造でも。
なのでもっとイテレータ使いましょう。
931デフォルトの名無しさん
垢版 |
2024/11/21(木) 23:03:30.15ID:OGNNDR4U
V8とRustをベースとしたJavaScript/TypeScriptランタイム環境「Deno」v2.1.0 ほか
https://forest.watch.impress.co.jp/docs/digest/1641518.html
2024/11/22(金) 06:49:29.53ID:VaeItC08
>>931
Rustで作ると遅いんだよな
933デフォルトの名無しさん
垢版 |
2024/11/22(金) 10:51:02.29ID:vbb23urH
The Rust Programming Language:
Enums and Pattern Matching
Data Science Learning Community Videos
934デフォルトの名無しさん
垢版 |
2024/11/22(金) 16:45:26.57ID:ssbKhBDs
>>870
デバッグ *機能* とデバッグ(作業)の可否は別だろ
935デフォルトの名無しさん
垢版 |
2024/11/22(金) 16:52:08.57ID:ssbKhBDs
>>882
Rustでロック必要なケースはC言語でだって必要だろ。
C言語の場合は手動で明示的にしてやる必要がある。
必要なチェックや排他制御のコード入れないでコンパイル通っただけで安心するやつは仕事でコード書かないでくれ。
チェックや排他制御が不要と言えるなら、それこそunsafeにすればいいじゃん。
2024/11/22(金) 18:39:10.11ID:y0TICFrd
そのキーワードをunsafeではなく「ハイリスクハイリターン」にでも
変えれば生霊が成仏するような気がする
リスクを100倍にすればリターンも100倍になるってのはただの物語にすぎないと個人的に思うが
科学だと思ってる人間がいても別に驚かない
2024/11/22(金) 18:50:58.98ID:MEPFF+NK
>>882
C/C++/Rustのオーバーヘッドは同じ
メモリ管理もポインタで別主体の複数箇所から指すならC++のshared_ptrやRustのRc/ArcのようにCでも参照カウンタを持つしか安全に解放できない
938デフォルトの名無しさん
垢版 |
2024/11/22(金) 22:18:31.82ID:TcJB6S+5
>>935
部分借用のケースあるじゃん
スレッド1がバイト列の前半を、スレッド2が後半を書き換える場合
これは理屈上はロックが要らないけどsafe Rustだとルール上ロックが要るケース
2024/11/22(金) 22:39:33.83ID:y0TICFrd
a 形式だけで安全といえる
b 中身をよく見れば安全といえる
c 形式も中身も危険

unsafeの部分はbとcが混ざっている
(bの価値がaより高いとは言ってないし安いとも言ってない)
2024/11/23(土) 06:30:53.82ID:phMWL2Cw
>>938
Rustでもロックは不要
例えばバッファをエリア8分割して8つのスレッドで書き換え並列処理

use rayon::prelude::*;

const BUF_SIZE: usize = 1 << 16;
const NUM_OF_AREA: usize = 8;
const AREA_SIZE: usize = BUF_SIZE / NUM_OF_AREA;

fn main() {
let mut buf: Box<[i64]> = (0..BUF_SIZE as i64).collect();

buf.par_chunks_mut(AREA_SIZE).for_each(|area| {
println!("DEBUG: {:?}", std::thread::current().id());
area.iter_mut().for_each(|n| {
*n = *n * *n;
});
});
}
941デフォルトの名無しさん
垢版 |
2024/11/23(土) 10:31:17.67ID:ljLqVKjZ
外部クレートな上にイテレーターにしか使えないものでしょ
例えばこんな構造体

struct {
 a: Vec<u8>,
 b: Vec<u32>,
}

に対してスレッド1と2がそれぞれaとbを操作する場合は?とか、メモリ的に連続しないものを扱う場合は?とか、回避できないものはある
(後者は例えば、4動画を並列に処理し、それを上下左右に並べた1つの動画にする場合)

元のレスの「Rustでロックが必要なケースはC言語でも必要」という主張は必ずしもそうでない
(総合的には事故を防げるメリットの方が大きいし、「必要な場合のみunsafeを使う」というRustの方が良いと思ってるので、言語に対する批判ではないと思って欲しい)
2024/11/23(土) 11:04:40.44ID:AT4bo2Ti
RustでもCでもロックが不要な例を出してはいけない

また「Cでは不要」の部分だけを自分で検証して残りは他責にするのは
近似としては悪くないが厳密には悪い
2024/11/23(土) 14:25:42.64ID:ZNzlTdzo
struct Test {
a: UnsafeCell<Vec<i32>>,
b: UnsafeCell<Vec<i32>>
}

// 手動でスレッドセーフであることを宣言
unsafe impl Sync for Test {}

impl Test {
fn new() -> Self {
Test {
a: UnsafeCell::new(Vec::new()),
b: UnsafeCell::new(Vec::new())
}
}
fn get_a(&self) -> &mut Vec<i32> {
unsafe { &mut *self.a.get() }
}
fn get_b(&self) -> &mut Vec<i32> {
unsafe { &mut *self.b.get() }
}
}
2024/11/23(土) 14:28:48.33ID:ZNzlTdzo
使う側はこんな感じ。

fn main() {
let test = Test::new();

// 2つのスレッドで別々のフィールドにアクセス
std::thread::scope(|scope| {
scope.spawn(|| {
let a = test.get_a();
a.push(1);
});

scope.spawn(|| {
let b = test.get_b();
b.push(2);
});
});
}
2024/11/23(土) 14:37:46.12ID:ZNzlTdzo
c++はunsafeの部分を区別せずにやっちゃってるだけで、危険性があるのは変わらんのよ。rustの場合そこが明示的になってる分分かり易いというだけ。
2024/11/23(土) 17:18:14.36ID:iTmIV0ch
>>943
これsafeにしたらダメでしょ
2024/11/23(土) 17:57:14.51ID:AT4bo2Ti
その石ころはパンに変化しなかった
はい論破
人は論破のために生きる
2024/11/23(土) 18:44:09.87ID:phMWL2Cw
>>941
それならrayonを使うまでもないけど
使えばシンプルにこう書ける

struct Foo {
a: Vec<u8>,
b: Vec<u32>,
}

fn main() {
let mut foo = Foo {
a: vec![1, 2, 3],
b: vec![11, 22, 33],
};

rayon::join(
|| {
println!("DEBUG: a: {:?}", std::thread::current().id());
foo.a.push(4);
},
|| {
println!("DEBUG: b: {:?}", std::thread::current().id());
foo.b.push(44);
},
);

assert_eq!(foo.a, [1, 2, 3, 4]);
assert_eq!(foo.b, [11, 22, 33, 44]);
}
2024/11/23(土) 18:47:58.14ID:phMWL2Cw
>>948をrayonを使わずに書くと

std::thread::scope(|scope| {
scope.spawn(|| {
println!("DEBUG: a: {:?}", std::thread::current().id());
foo.a.push(4);
});
scope.spawn(|| {
println!("DEBUG: b: {:?}", std::thread::current().id());
foo.b.push(44);
});
});

>>943
そんなことしなくても大丈夫
2024/11/23(土) 20:57:00.22ID:h7mzZyhg
>>948
フィールドが可視なこと前提にしちゃっていいの?
2024/11/23(土) 21:58:14.47ID:phMWL2Cw
>>950
そんな話までやるの?
どの言語でも同じ
必要なアクセスメソッドを用意するだけ

impl Foo {
pub fn new(a: Vec<u8>, b: Vec<u32>) -> Self {
Foo { a, b }
}
pub fn a_and_b_mut(&mut self) -> (&mut Vec<u8>, &mut Vec<u32>) {
(&mut self.a, &mut self.b)
}
}
2024/11/23(土) 22:17:13.62ID:h7mzZyhg
>>951
>>941が言ってるのは外部クレートの構造体で可視性にしろメソッドにしろ勝手にいじれないって前提での話だと理解してたんだけど
違うの?
2024/11/23(土) 22:29:09.24ID:wvnRoJ4J
>>952
可視もアクセスもない外部の構造体のフィールドを!
フィールド毎に別スレッドで並列に書き換えたい!
ってことかよ
ワロタ

>>941もそこまでバカげた無茶を求めてない
求めてることは既に解決しただろう
2024/11/24(日) 01:29:38.03ID:4sDepkd+
スライスの内部を弄るのはunsafeだけど
その構造体の内部は安心安全だからunsafeがどこにも現れないんだな
2024/11/24(日) 01:59:38.19ID:J3183MXo
Vectorの標準機能
好きなところで2分割する方法
スレッドでま利用可能

fn main() {
let mut vec = vec![1, 2, 3, 4, 5, 6];
let mid = vec.len() / 2;
let (left, right) = vec.split_at_mut(mid);

println!("left: {:?}", left); // [1, 2, 3]
println!("right: {:?}", right); // [4, 5, 6]

// 両方のスライスを同時に変更可能
left[0] = 10;
right[0] = 40;

println!("vec: {:?}", vec); // [10, 2, 3, 40, 5, 6]
}
2024/11/24(日) 02:07:14.81ID:J3183MXo
vecの機能
chunks_mutを使用する方法(等分割)
指定したサイズで複数個のスライスの可変参照

fn main() {
let mut vec = vec![1, 2, 3, 4, 5, 6];
let mut chunks = vec.chunks_mut(vec.len() / 2);

if let (Some(left), Some(right)) = (chunks.next(), chunks.next()) {
println!("left: {:?}", left); // [1, 2, 3]
println!("right: {:?}", right); // [4, 5, 6]

left[0] = 10;
right[0] = 40;
}

println!("vec: {:?}", vec); // [10, 2, 3, 40, 5, 6]
}
957デフォルトの名無しさん
垢版 |
2024/11/24(日) 17:24:11.96ID:0kQqDut1
Rustで書いたら危険だけどCなら安全に書ける例を教えてくれ
2024/11/24(日) 18:13:55.87ID:I2rtYfjq
>>941
rayonは確かに標準ではなく外部だが
C/C++では今も作り出せていないrayonやtokioなどの基盤ライブラリを
Rustが生み出すことができた勝因は
標準ライブラリを最小限にして外部のクレートに多くを託す方針をとったため

それでもなお標準ライブラリだけに拘るならば
その>>940の例はrayonを使わずに以下のように書くことができる

std::thread::scope(|scope| {
let mut rest: &mut [i64] = &mut buf;
while let Some((area, new_rest)) = rest.split_at_mut_checked(AREA_SIZE) {
rest = new_rest;
scope.spawn(|| {
area.iter_mut().for_each(|n| {
*n = f(*n);
});
});
}
});
2024/11/24(日) 18:18:22.12ID:ZV7M8h6P
rayonってCから使えないの?

最近はたまにCから呼び出せるようにしたRustのクレートを見かけるよな
以前とは逆向きだ
960デフォルトの名無しさん
垢版 |
2024/11/25(月) 09:33:08.05ID:SsaYg1Am
科学 + ンニュース 5ch

保守派もリベラル派も「自分の政治的信念に合致したニュース」を信じやすいという研究結果 [すらいむ★]
https://itest.5ch.net/egg/test/read.cgi/scienceplus/1732447647

コメントも含めて読むと
陰謀論が収まら無い理由が判明する
961デフォルトの名無しさん
垢版 |
2024/11/25(月) 15:15:08.59ID:TQeBxjwA
>>957
Rustは安全なものでもunsafe付けたら危険になる言語
2024/11/25(月) 17:19:35.66ID:HD3K11z8
>>958
結局、全体の可変参照&mutがある時
・structは各フィールドの&mutを同時に安全に得られる
・スライスはsplit_at_mut_checkedで任意に分割したサブスライスの&mutを同時に安全に得られる
つまりunsafeの必要なく安全に同時に書き換え可能ということだね
2024/11/25(月) 17:20:53.69ID:HD3K11z8
>>961
unsafeは危険という意味ではなくて
C/C++と同じようにプログラマーがその部分のコードの安全性の責務を持ちなさい、という意味だよ
もしそれを危険と呼ぶならC/C++のコードは常に全てが危険
2024/11/25(月) 17:46:18.55ID:VupnR4Dz
よくrustと他の言語で比較するときに条件を揃えてないのが多すぎる印象。
パフォーマンスで差が出る部分でHashMapがある。デフォルトのハッシュ関数が安全に振られてるからちょっと遅い。高速化するなら下記のような感じ。

use std::hash::BuildHasherDefault;
use std::collections::HashMap;
use rustc_hash::FxHasher; // より高速なハッシュ関数

// FxHasherを使用したHashMap
type FastMap<K, V> = HashMap<K, V, BuildHasherDefault<FxHasher>>;

fn main() {
// 高速なハッシュマップの作成
let mut fast_map: FastMap<i32, String> = FastMap::default();
fast_map.insert(1, "fast".to_string());
}
2024/11/25(月) 17:55:45.25ID:VupnR4Dz
昔、PHPでHashDos攻撃でサーバーが止まるという問題があった。特定のハッシュ値を生成するようなパターンで速度が著しく低下する。なので今はwebで外部からデーターが送られて来る時は安全なハッシュ関数を使う。
このハッシュが安全かどうかで処理速度が変わるのだけど、他の言語では昔のままのが多い。それでrustとC++を比較して遅いとか言われる事がある。安全か速度か選べるから両方揃えて比較してくれ。
966デフォルトの名無しさん
垢版 |
2024/11/25(月) 18:58:14.92ID:1VAZLaev
FxHash使うと結構速度変わるんだよな
967デフォルトの名無しさん
垢版 |
2024/11/26(火) 10:38:32.10ID:OrSHBPPk
rustとかでi32とかVecとかHashMapとかにmethodを勝手にimplして使うことについて問題とかないですか?
2024/11/26(火) 10:56:47.14ID:+wgmkm+f
coherenceの縛りがあるから勝手にimplすることはできない
2024/11/26(火) 11:04:59.40ID:MMcFc6BZ
なんらかの trait を impl するという意味なら好きなようにやって構わないが、複数の型に impl する必要がある場合 (多相性を利用することを想定する場合) を除いては関数として定義したほうが良いことも多い。
2024/11/26(火) 12:22:11.23ID:qH2nLRZc
>>967
まず技術的にはRustは孤児ルール(orphan rule)により他へ影響を与える汚染を防げる仕組みがあるのでコンパイルが通るなら大丈夫
新たなメソッドを増やすには自分で用意したトレイトの中で行うことになるのでその自作トレイトをuseしない限り他への汚染の影響は無し

したがってあとは有用性と可読性の問題かな
例えばジェネリックに処理するためのトレイト境界とその新たなメソッドを用意するのは有用かつ必須でよく行われる
単に自作型に変換したいだけならば新たなトレイトとメソッドを用意せずとも
impl From<既存型> for 自作型 して
let x: 自作型 = 既存型値.into(); など
971デフォルトの名無しさん
垢版 |
2024/11/26(火) 12:32:30.35ID:OrSHBPPk
>>970
ありがとうございます
他のライブラリー影響する気がしたので聞いてみました
972デフォルトの名無しさん
垢版 |
2024/11/26(火) 19:48:39.21ID:/2XIgpnc
Traitのimplが出来るのは型を定義したcrateかtraitを定義したcrateだけだから、他のライブラリには影響しない
メソッドの名前が被っていてもそのtraitをuseしないと使えないし、最悪useすることになってもtraitを指定してメソッドを呼べる
973デフォルトの名無しさん
垢版 |
2024/11/27(水) 16:06:33.32ID:ddkklZcJ
「ツールの使い方覚えるだけ」

まさにそれ
2024/11/29(金) 21:54:35.06ID:/9dKvjaK
こうすれば実行時に確定する値を&'staticにできるね
static HOME: LazyLock<String> = LazyLock::new(|| std::env::var("HOME").unwrap());
let home: &'static str = &*HOME;
2024/11/30(土) 00:45:06.70ID:6Z2K+eju
unsafeとは危険という意味で合ってるが、魔女のようなものを狩る行動を意味しない
信念と行動が合致しない方が得だから合致しない
2024/11/30(土) 18:20:12.51ID:D1SGYlac
所有者をスタック上に置くからライフタイム管理が必要になる
それを避けて&'staticするには3つの方法がRustで提供されている
(1) 所有者を最初から持たない
(2) 所有者をスタックに置かない
(3) 所有者を捨てる
2024/11/30(土) 19:42:09.81ID:g3xetMDU
データをRustの外に置けば、ライフタイム管理から逃れられる
たとえばファイルに書いてしまう
2024/11/30(土) 23:10:39.19ID:D1SGYlac
(1) コンパイル時に値が確定して静的に配置されるものが該当
(2) 実行時に値が確定してstatic変数に遅延配置させるものが該当
(3) 実行時に値が確定してleak()させるものが該当
いずれも&'staticで安全に参照できる
2024/11/30(土) 23:33:27.96ID:6Z2K+eju
C++もスマートポインタがあるからポインタ管理を推進する側の勢力だった
だからC++を使わなくてもCで十分という意見に説得力があった
今では、管理に反対する奴も賛成する奴もどっちもC++に不満を感じている
980デフォルトの名無しさん
垢版 |
2024/12/01(日) 21:53:13.54ID:IuCKzQHf
let や let mut を見たとたん、「だーめだ、こりゃあ。数値計算に使えねえ。fortranの方が余程ましだ。」
と思った。大体、letなんてBasicで出てきそうなワードを「変数束縛」という深刻な概念に結びつけている
時点で作った奴はセンスねえと思うわ。
2024/12/01(日) 22:06:15.87ID:s/x9f/ll
ブラックフライデーで複オジポエムが続いてたかと思えばさらに輪をかけた常識知らずが来たw
982デフォルトの名無しさん
垢版 |
2024/12/01(日) 22:10:53.24ID:IuCKzQHf
そうか? 俺にはお前の額に馬と鹿が見えるが
2024/12/01(日) 22:44:04.77ID:iESkoZBr
>>774
アンロードが起きうるstatic変数は制御下に置くためスレッドローカルに置く
thread_local! {
static VAR: RefCell<Foo> = RefCell::new(Foo::new());
}
ちゃんとdropするためメモリリークは起きないことが確認できる
impl Drop for Foo {
fn drop(&mut self) {
println!("DEBUG: drop Foo");
}
}
2024/12/02(月) 13:25:55.50ID:SvUnxJQd
>>980
大丈夫か?比較対象がfortranやbasicでは歳が知れるぞ。今時の言語知らんのかい?
2024/12/02(月) 13:32:19.67ID:3neKGwU7
変数束縛とかいきってるとこにセンス感じないのは同意
2024/12/02(月) 13:38:57.47ID:5A4jg9rQ
ML 系言語が基礎になってるから用語もそっちで一般的なものが使われてる。
2024/12/02(月) 13:43:46.67ID:3neKGwU7
>>986
ML知ってるならより奇妙に感じるはずだよw
2024/12/02(月) 14:01:48.04ID:SvUnxJQd
lispや初期のMLからletの使い方は変わってないと思うけど何がしたくて何が出来ないと言ってるのか分からん。
2024/12/02(月) 14:48:33.18ID:XKXSk/VC
伝統的には、引数とグローバル変数を区別せず自由変数とする
自由ではない変数は束縛されている
ただし関数がネストするなら、引数は束縛変数とするほうが需要に合致する
2024/12/02(月) 18:48:24.16ID:jQxoP1Z8
free variables/bound variablesのbindingと
name bindingのbindingは無関係ではないけど使われる文脈も意味も違う
letの話は後者

それに昔々のThe Bookではvariable bindingsという用語が使われてたが
わかりにくいという理由でかなり前にvariablesという用語に変更されてる
2024/12/02(月) 18:54:23.80ID:UThkx+wo
>>739
メモリリークとは実行中に使用していないメモリが解放されないことでメモリ使用量が膨らんでいくことだから
実行を終えた時にメモリ解放するか否かはどうでもいい話でそれをメモリリークとは呼ばない

Box::leak()でも実行を終えた時にメモリは解放されないがRustでは普通に使われている
例えばcargo crateでもleakさせまくっているが何ら問題ない

cargo-0.84.0/src/cargo/core/package_id.rs: let inner = Box::leak(Box::new(inner));
cargo-0.84.0/src/cargo/core/source_id.rs: let inner = Box::leak(Box::new(inner));
cargo-0.84.0/src/cargo/util/interning.rs: let s = str.to_string().leak();
2024/12/02(月) 20:05:14.90ID:4EvznkF/
最近勉強始めたけど
::で躓いて脱落しそう
2024/12/02(月) 20:19:44.41ID:GZbY5KmK
ダブルコロンは他の言語C++からPHPまで使われており
Rustでもそれらと同様に名前空間を示すpathの区切り文字として使用されている
https://doc.rust-lang.org/reference/paths.html
2024/12/02(月) 20:22:50.81ID:SvUnxJQd
>>990
えーとletという用語に文句言ってるだけで、プログラムの機能的には問題ないということでいいの?
2024/12/02(月) 20:39:13.67ID:B3Y6W1wC
ら、ら、ラストー🦛
2024/12/02(月) 20:39:36.01ID:B3Y6W1wC
ら、ら、ラストー🦛
2024/12/02(月) 20:39:59.86ID:B3Y6W1wC
ら、ら、ラストー🦛
ら、ら、ラストー🦛
2024/12/02(月) 20:40:22.73ID:B3Y6W1wC
ら、ら、ラストー🦛
ら、ら、ラストー🦛
2024/12/02(月) 20:40:45.44ID:B3Y6W1wC
ら、ら、ラストー🦛
ら、ら、ラストー🦛
ら、ら、ラストー🦛
2024/12/02(月) 20:41:08.42ID:B3Y6W1wC
ら、ら、ラストー🦛
ら、ら、ラストー🦛
ら、ら、ラストー🦛
10011001
垢版 |
Over 1000Thread
このスレッドは1000を超えました。
新しいスレッドを立ててください。
life time: 72日 22時間 22分 31秒
10021002
垢版 |
Over 1000Thread
5ちゃんねるの運営はUPLIFT会員の皆さまに支えられています。
運営にご協力お願いいたします。


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

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

▼ UPLIFT会員登録はこちら ▼
https://uplift.5ch.net/

▼ UPLIFTログインはこちら ▼
https://uplift.5ch.net/login
レス数が1000を超えています。これ以上書き込みはできません。