Rust part24

レス数が1000を超えています。これ以上書き込みはできません。
2024/05/27(月) 06:41:26.82ID:T4AFD1f4
公式
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 part23
https://mevius.5ch.net/test/read.cgi/tech/1708677472/
2024/05/27(月) 06:42:29.23ID:T4AFD1f4
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/
2024/05/27(月) 06:43:12.56ID:T4AFD1f4
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/
2024/05/27(月) 08:12:23.89ID:8cya6pTK
Cloudflare、HTTPプロキシ開発用RustフレームワークPingoraをオープンソース化
ttps://www.infoq.com/jp/news/2024/03/cloudflare-open-sources-pingora/
5デフォルトの名無しさん
垢版 |
2024/05/27(月) 19:41:54.75ID:SG55qLTi
>>1
2024/05/27(月) 21:05:50.42ID:DNPKhjhD
なんで黙ってワッチョイスレのリンク消したの?
2024/05/27(月) 21:10:59.53ID:uDjd5cKa
>>1乙ust
2024/05/27(月) 23:31:45.00ID:NihCR1ik
rust-lldって魔法?
2024/05/28(火) 23:01:09.87ID:r9uY5dzk
「Sudo for Windows」はRustで開発されている!
メモリ安全が重視される分野で採用が広がるRust言語
ttps://forest.watch.impress.co.jp/docs/serial/yajiuma/1594981.html
次期大型更新「Windows 11 バージョン 24H2」に
搭載されることが確定した「Sudo for Windows」が、
Rust言語で開発されていることがわかった。
2024/05/29(水) 09:39:32.15ID:YfGaww9I
完全にRustは残る言語になってしまったね
2024/05/29(水) 11:05:17.42ID:frLAIx0l
言語の生き残るか否かもWindows次第かな
12デフォルトの名無しさん
垢版 |
2024/05/29(水) 13:45:30.43ID:6x6vV3tF
この言語を支持してるやつは総じてデバッグ能力が低い
2024/05/29(水) 13:56:47.79ID:HitYRPv5
なるほどそれはもうやるしかないね
14デフォルトの名無しさん
垢版 |
2024/05/29(水) 14:07:58.08ID:377og/WO
今更こんなのだけで一喜一憂するの?

ちなみにAzureCLIもRustだぞ
MacでHomebrewでインスコする時にRustのコンパイル始まって凄く時間掛かる
2024/05/29(水) 14:55:30.35ID:0Pyy6QQw
ʕ◔ϖ◔ʔ
2024/05/29(水) 16:53:17.15ID:bMu5OGl6
>>12
テスト走らせるんじゃあかんの?
17デフォルトの名無しさん
垢版 |
2024/05/29(水) 17:06:12.76ID:643EHPjo
>>9
これ仕組み上、console APIやTUIは動作しない
(それと肝心なところのほとんどがunsafeなのは見なかったことに)
2024/05/29(水) 19:19:21.66ID:AbIsIlhD
そういや、sudoとかの引数のバッファオーバーフローとかって、std::env::args_os使っていれば安全なのかな?
2024/05/29(水) 22:46:32.28ID:b7HyT2Iv
unsafeはRust外のFFI/API境界でのやむを得ない出現か
unsafeを使うことで効率的かつ安全なパターンになる時のいすれかだが
後者のパターンは特定のプログラムから切り離してsafeなインターフェースを提供する汎用ライブラリに閉じ込めるのが好ましく
標準ライブラリはそのようにして出来ている
2024/05/30(木) 12:31:47.54ID:D8KcVhgB
つまりwindowsクレートはsafe interfaceの提供をサボってるということ?
2024/05/30(木) 12:33:13.48ID:VdmPCECN
Rustと外側との境界はunsafeにせざるを得ないのは当たり前なのに肝心なところはunsafeと言われてもなぁ。
レビューすべき箇所が局所化されるだけでも十分なメリットだろ。
2024/05/30(木) 14:46:49.26ID:YCUWE+u3
>>20
>>21
どちらも正しい
Rustとその外側の境界部分で必ずunsafeが生じるからそこを問題にすることはない
ただしその部分は安全なインタフェースを提供するモジュールかできればクレートとして分離するのが好ましい
2024/05/30(木) 16:38:16.78ID:YSwCBZpR
Rust製Webサーバーで一番使われてるフレームワークって何だろ
MySQLと親和性高いなら使ってみたい
2024/05/30(木) 18:56:43.74ID:d8P/nzpp
>>23
axumとsqlx
2024/05/30(木) 21:16:17.01ID:YSwCBZpR
>>24
ありがと、試してみよう
2024/05/31(金) 21:36:08.12ID:PEZeXgnU
コンパイル前にcargo sqlx prepareでDBサーバからデータの型を得ておくことで静的型チェックできる仕組みなんだね
2024/06/01(土) 10:39:11.44ID:8vnvDrFp
へー、便利そう。
だけどこういう仕組みってカラム追加時のDBのマイグレーション辺りが入ってくるととたんに難しくなるんだよなぁ。
2024/06/01(土) 22:15:15.67ID:hl1xX5EU
>>27
そういうDBテーブル構成変更するとどんなプログラミング言語でも何らかの対応が必要となるよ
Rustでsqlx利用ならばDB構成変更した時にcargo sqlx prepareで型をDBから入手し直せばコンパイル時に静的に型チェックされるから楽で安全だね
2024/06/01(土) 22:32:36.24ID:M7bbwRO6
DBの構成管理をどこで行うかという話
その辺の道具類は他言語に比べてRustはまだまだなので
DB側のツールで管理しておくという昔ながらのやり方が現状のベスト
2024/06/01(土) 22:35:04.27ID:25uf1xqx
スクラッチのPHPみたいにSQL直書きからのexecuteはナシ?
2024/06/01(土) 22:44:45.41ID:azEYwwHp
>>30
Rustのコード内にSQL直書き文字列を書ける
その上でデータベースとの静的な型チェックもされるのがsqlxのメリット
2024/06/01(土) 22:51:53.44ID:l8IWJadP
それで実行計画も取れるの?
2024/06/01(土) 23:58:30.16ID:K7NGQLE/
実行計画はDBのデータではないから型チェックは意味ないような
2024/06/02(日) 09:14:40.51ID:plnJaR5e
>>21
機械語に近い部分がunsafeなのは当たり前だけど
それを手書きしていることを納得させるのが難しいんだろう
一番自動化されてるフレームワークを使ってみたいんだろ
2024/06/02(日) 12:55:11.71ID:vGgRDkgp
接続相手の仕様が形式化されたデータとして存在すれば
Rust 上の関数との対応付けを自動化できることもあると思うけど
形式化されたデータは誰かが準備しないといけないことには変わりないからなぁ。

Windows では API の仕様記述を WinMD と呼ばれる形で標準化してるけど
それだって WinRT (ちょっと高級な API) が前提になっているのでそんなに万能ではない。

あらゆる仕様を記述できるほど自由度 (複雑さ) のあるフォーマットにしたら結局は
プログラムを書くのとそんなに変わらんようになるので自動化できる部分は自動化して
ややこしい場合は手書きするという割り切りしないと仕方ない。
2024/06/02(日) 23:32:50.95ID:JYjUVuWd
Unix系システムコールとの共通部分は
ファイルシステムなど標準ライブラリとして安全なインターフェイスを提供できてるね
Windows特有部分も同じようにMicrosoftがsafeなライブラリを公式に用意することが望ましいのかな
2024/06/03(月) 08:58:28.03ID:DC3aHaSn
>>35,36
なるほど。結構時間経ったと思うが厳しい。

Microsoftがsafeなライブラリを公式に用意するまで、
プロダクションでのRust採用は様子見するのが良さそうだ。

Linux特有の機能が必要な場合も同様に様子見するのが良さそうだ。
2024/06/03(月) 09:53:26.77ID:oYPTQzXH
>>37
Windows クレートはもうかなり充実してるよ。
メタデータからの自動生成なので網羅的だし、 safe でいけるメソッドは safe になってる。
unsafe なのは本質的に unsafe なのでどうしようもないし。

Readme に書いてある例が古い Win32 API を使うスタイルの書き方だから印象が悪いのかなぁ……。
2024/06/03(月) 12:15:09.36ID:xZhYxepu
>>37
LinuxでRustで困ってることないよ
様子見しなきゃいけないことがあるのならば具体的に挙げてみたら?
2024/06/03(月) 15:47:20.28ID:8wxJn/St
>>38
>本質的に unsafe
良いキーワード出た、深掘りしてくれ

これとか
github.com/tokio-rs/io-uring

io_uringが本質的にunsafeだとでも思ってるのかな?
2024/06/03(月) 16:27:42.41ID:PBVPy7rj
本質的にC++な機能といえば多重継承
多重継承は他の言語に移植できない
万一できたとしたらそれは自動生成ではなく手作業で工夫されたコードだろうね
2024/06/03(月) 17:17:59.54ID:/dTVE8NF
Win32APIを素で提供しようと思ったらunsafeなのは仕方ないので、もう一枚ハイレベルなラッパーかませてsafeにしてほしいところではある。
2024/06/03(月) 19:27:13.29ID:oYPTQzXH
だからモダンな WinRT に移行しようね!
2024/06/03(月) 20:11:34.31ID:/dTVE8NF
WinRTってWin32のAPI網羅できてるの?
モダンなAPIが古いのを機能的に網羅できてないから仕方なく使ってる気持ちなんだけど。
2024/06/03(月) 20:49:12.70ID:oYPTQzXH
WinRT は「おおよそ」には Win32 API の機能を網羅しているが
根本的なパラダイムが違っていて単純には置き換えられない場合はある。
最初から WinRT を前提として作っていれば Win32 API 抜きで行けることは多いよ。
ゼロではないところがイライラするかもしれんけど。
2024/06/03(月) 21:57:04.03ID:7I637fUw
>>41
クラス多重継承は問題多すぎなダメな機能なので多くの言語で禁止している
クラス継承そのものが問題を多く抱えているため各機能のインターフェースなどを実装するのが望ましい
Rustならば複数のトレイト境界を指定することでそれら複数のトレイト機能を実装した任意の型を対象に抽象的なプログラミングができる
47デフォルトの名無しさん
垢版 |
2024/06/04(火) 07:49:08.27ID:YQQ4Gdo/
かきを最新AIに重箱の隅をつつく用意尋ねましょう
全ての電磁波は強い低周波も高周波も被爆する?
電磁かいが強い場所は20Hzと55Hzは磁気閃光これも被爆している.?
音波も強い場合は被爆する?
※自然界の化学科学の観測結果論文と人間の人工物で可能な化学と科学論文を読み込ませておく
是者と校舎を別々で回答する用意する
さらに制度を挙げるなら
グレーゾーンの論文をできるともいえるしできないともいえる用意認識させる

現在の科学が正しいのならなら電磁波攻撃はこのグレーゾーンの論文を使用しているので逃亡できている?

統合失調症電磁は音波なら周囲の者被爆している!?
寿命が短いのと免疫力低下起きて当然
48デフォルトの名無しさん
垢版 |
2024/06/04(火) 20:02:17.33ID:JvLx0o4/
GPT4-Vの100分の1のサイズで同等の性能を誇るマルチモーダルモデル「Llama 3-V」が登場、トレーニング費用はたった8万円
2024年05月29日 14時00分
OpenAIがサム・アルトマンCEOを含む「安全・セキュリティ委員会」を設置、さらにGPT-4後継モデルのトレーニングを開始
2024年05月29日
「毒杯飲む直前どんな気持ちだった?」ソクラテスと対話できるAIを開発!
2024.06.04
※対象者【被害者】そっくりの返答が可能
たった数秒の音声データから音声合成が可能な「VoiceCraft」
2024年04月16日 07時00分
OpenAIがわずか15秒の音声からクローン音声を生成できるAIモデル「Voice Engine」をリリース
2024年04月01日
会話相手を数秒見つめて声を登録するだけでその人の声だけを聞くことができるAIヘッドホンシステムが開発される
2024年05月30日
※対象者の声を個別に録音
2024/06/04(火) 21:25:19.75ID:iVGm+TdX
std::ptr::addr_eqでdyn同士やdynと通常参照を比較してもいいんだよね
2024/06/05(水) 02:32:30.56ID:asdywUyB
比較の方法が複数あるとして
最も優秀な方法に依存するのではなく抽象に依存するのが定石だよな
51デフォルトの名無しさん
垢版 |
2024/06/05(水) 13:57:39.45ID:nZd9x5hF
>>17
>肝心なところのほとんどがunsafe

当たり前やん
そもそも観なかったことにするための機能なんだし
2024/06/05(水) 14:16:34.14ID:VxlYmTlG
言語のパラダイムでどれだけ頑張っても言語の外はその規則に従ってくれないよ。
そこらへんの境界線でおおよそどこでも信頼できるインターフェイスは ABI だけ。
根本の部分が C の影響下にある状況のほうは変えようがない。

一応 unsafe rust という選択肢が登場した分だけだいぶんマシになってんだよ。
2024/06/05(水) 14:19:53.54ID:wo6YIDEn
>>38,52
>本質的に unsafe

本質的にunsafeの定義、早う
2024/06/05(水) 14:28:05.14ID:vQWinlMd
C/C++のコード全体が常にunsafeすなわち自動的な安全保障なしなのに対して
Rustはsafe部分のコードが自動的に安全保障されるという明確な違いがある
2024/06/05(水) 14:33:58.97ID:jddDZazx
>>38,54

定義するとは何かすら知らないレベルでRustやってるのかよw
56デフォルトの名無しさん
垢版 |
2024/06/05(水) 15:41:52.55ID:NMAS1RiM
定義するとは何かも知らなくても書けるのがRustの良いところ
2024/06/05(水) 18:13:30.31ID:asdywUyB
なぜ定義なんだ
喩え話では駄目な理由を考えるとすぐ思いつくのは、喩え話は非○○的だから駄目なんだよね
2024/06/05(水) 19:11:15.28ID:ubKPmxXH
>>49
dynはアドレスとvtableの対なので使える

use std::fmt::Display;
let i = 12345;
let r = &i;
let d: &dyn Display = &i;
// assert!(eq(r, d)); // 型が不一致でコンパイルエラー
assert!(addr_eq(r, d)); // アドレスが一致

文字列strはアドレスと長さの対なのでこのように比較できる

use std::ptr::{addr_eq, eq};
let s1 = "abcdef";
let s2 = &s1[..3];
let s3 = &s1[3..];
assert!(!eq(s1, s2)); // 長さが異なるので不一致
assert!(addr_eq(s1, s2)); // アドレスが一致
assert!(!addr_eq(s1, s3)); // アドレスが不一致

文字列をバイト列に読み替えたときにも使える

let b1 = s1.as_bytes();
// assert!(eq(s1, b1)); // 型が不一致でコンパイルエラー
assert!(addr_eq(s1, b1)); // アドレスが一致
2024/06/05(水) 19:38:28.12ID:VxlYmTlG
>>53
safe にするのが不可能(少なくともそれ単体は)というシンプルな意味で使ってるつもりだが
2024/06/06(木) 22:14:32.57ID:Gs5l9pj8
fn 単純にこの比較も<T>(slice: &[T], index: usize) {
 let p = &slice[index];
 let q = &slice[index..];
 // assert!(eq(p, q)); // 型不一致
 assert!(addr_eq(p, q));
}
61デフォルトの名無しさん
垢版 |
2024/06/07(金) 12:52:26.48ID:tQZH7Tnk
グーグル、資料のわからないところを最新AIに質問できる「NotebookLM」日本版公開
https://ascii.jp/elem/000/004/202/4202481/
2024/06/07(金) 23:50:20.38ID:liF+4tB0
as *const ()でupcastして比較しているだけなのか
2024/06/08(土) 04:40:43.01ID:j2N7L69L
Option<String>型のxがある時に
x.as_ref()とするとOption<&String>が得られ
x.as_deref()とするとOption<&str>が得られることがわかりました

Option<&String>型のyがある時に
y.as_deref()としてもOption<&String>のままになりました
yからOption<&str>を得るにはどうすればいいのでしょうか?
2024/06/08(土) 09:07:24.88ID:Kcr3cAzI
let tmp = Some(y.unwrap().clone());
let hoge = tmp.as_deref();
65デフォルトの名無しさん
垢版 |
2024/06/08(土) 09:09:50.82ID:Kcr3cAzI
cloneしたくなかったら
let hoge = Some(y.unwrap().as_str());
2024/06/08(土) 10:33:13.95ID:9nPXIyFb
unwrap()は基本的には使ってはいけない。

使ってもよい場合は論理的にNoneが絶対に来ないことが保証されてる場合で、
直前にNoneではないことをチェックしていて明白な場合と、
構造的にそこにNoneが来ないことをコメントで明記している場合のどちらか。
2024/06/08(土) 10:34:38.61ID:9nPXIyFb
もう一つは簡易プログラミングをする場合で、
そこにNoneが来た時に処理続行の意味がなく、
パニックという形でプログラムを終わらせても構わない場合。
これは本来はきちんとエラー処理対応するのが好ましい。
2024/06/08(土) 10:39:31.95ID:9nPXIyFb
ドキュメントのサンプルでは、
エラー処理は邪魔なので簡易的にunwrарが多用されているが、
それをそのまま用いるのがマズい理由は上述のため。
69デフォルトの名無しさん
垢版 |
2024/06/08(土) 10:45:50.57ID:TRqvICLK
「毒杯飲む直前どんな気持ちだった?」ソクラテスと対話できるAIを開発!
2024.06.04
リコーと理研、技術の実用化の“兆し”を察知するアルゴリズムを開発
2024/06/05
グーグル、資料のわからないところを最新AIに質問できる「NotebookLM」日本版公開
2024年06月06日
70デフォルトの名無しさん
垢版 |
2024/06/08(土) 11:07:47.98ID:Kcr3cAzI
>構造的にそこにNoneが来ないことをコメントで明記している場合

これはexpectのことを言ってるのかな?
panic!することには変わりないが
2024/06/08(土) 11:13:56.61ID:wxBkz9QQ
truckに手をだす勇者はいないのか?
https://github.com/ricosjp/truck
2024/06/08(土) 11:35:42.10ID:91vCCt9S
>>63
y.map(|s| s.as_str())
or
y.map(String::as_str)
2024/06/08(土) 11:44:51.45ID:91vCCt9S
>>70
単にunwrapでpanicさせるんじゃなくて
unwrap_orやunwrap_or_elseなどを使ってfallback valueを返す

>構造的にそこにNoneが来ないことをコメントで明記している場合
個人的に↑これには賛同しかねる
コードが脆弱になるから
2024/06/08(土) 12:33:54.09ID:JruRF9Uj
構造的にNoneでないことを期待しているロジックならチェックしたところでどうせリカバリできないんだし
単にパニックでいいと思うけどな
2024/06/08(土) 12:53:40.15ID:dp0B2cJQ
事前条件・事後条件に反するときは panic するのが推奨されてなかったっけ?
要するにそういうことが一度でも起きたらバグが含まれているプログラムということだから修正するという前提がついてる。
あらゆるルートを想定するのも無意味だし、想定しないルートに入ったまま続けてもろくなもんじゃないので変なところがあったら止まったほうがいい。

ライブラリとして提供するなら expect にするに越したことは無いが
ただの panic でもスタックトレースは出せるし、
発見するのが自分 (またはチーム内などの身内) で修正するのも自分なら多少は雑でもよかろ。
2024/06/08(土) 13:02:44.03ID:m8p9RP7E
>>68
サンプルでrust unwrар好きだなと思っていたんだが、そんな理由で多用だったのか
2024/06/08(土) 13:06:19.28ID:nAguSD5l
パニックさせるということはNoneかどうかをチェックしているということ
そしてパニック用のコードもそこに含まれるということ
そのため高速化がシビアなケースではunwrap_unchecked()が使われている
unsafeなので確実な監視対象となる点でむしろ好ましいケースもありうる
とはいえ特殊な場合を除き非推奨です
2024/06/08(土) 14:06:17.67ID:dp0B2cJQ
ロジック的に None でありえないことをコンパイラが見抜ける状況でなら最適化で余計なチェックが消えることもあるし、分岐予測で速度的ペナルティはどうでもよくなることもある。
チェックするにしたって単発ではナノ秒単位の処理なので速度的に足を引っ張ることはまずない。
動画処理とか機械学習とかいった計算量が大きいものならチューニングが必要になることはあるかもね。
2024/06/09(日) 00:14:30.88ID:FH5YvHUC
例えばここにある`self.front.as_mut().unwrap()`や`front.next_kv().ok().unwrap()`のunwrapの使い方は妥当?
https://github.com/rust-lang/rust/blob/master/library/alloc/src/collections/btree/navigate.rs#L79-L80
2024/06/09(日) 00:37:45.34ID:84HY0iaQ
>>79
if self.is_empty() {
 None
} else {
 以降にあるから内部構造ロジックにより問題なし
2024/06/09(日) 00:50:28.83ID:84HY0iaQ
でもmatch self.front.as_mut() {
 Some(x) => で書けるならunwrap無い方がいい
2024/06/09(日) 01:03:57.65ID:84HY0iaQ
例えば>>65ならば
match y {
 Some(s) => s.as_str(),
 None => None,
}

そのNone => Noneの時はmapに簡略できる
y.map(|s| s.as_str())

それをメソッド記法でなくフルに書くと
y.map(|s| String::as_str(s))

ここで|s| f(s)はfと簡略できるためこうなる
y.map(String::as_str)
83デフォルトの名無しさん
垢版 |
2024/06/09(日) 08:02:48.25ID:GyoPGP3N
全ての波【電磁波】で下記の症状が起きる
理由は電磁波が強いために起こるか電磁波が通過すれば磁気が生じて鉄分が振動して間接的に鼓膜などが振動する
マイクロ波聴覚効果を用いた音声伝送に関する検討
2018/03/05
https://www.bookpark.ne.jp/cm/ieej/detail/IEEJ-ZT181039-PDF/
マイクロ波聴覚効果 Wikipedia
https://ja.wikipedia.org/wiki/%E3%83%9E%E3%82%A4%E3%82%AF%E3%83%AD%E6%B3%A2%E8%81%B4%E8%A6%9A%E5%8A%B9%E6%9E%9C
>>マイクロ波を照射された被験者は、クリック音やブザーのようなうなり音が聞こえる
早大、物質中の創発磁気モノポールに起こる集団振動現象を理論的に発見
2024/06/04
https://news.mynavi.jp/techplus/article/20240604-2958879/
理研、電子ビームの電子回折をアト秒で制御できる技術を開発
2024/06/06
https://news.mynavi.jp/techplus/article/20240606-2960578/
※電磁波も振動させれると記載あり
最低でも下記ノ電磁波の威力が必要なら行っている者全員補足されている
GPSの電波は超微弱
https://gigazine.net/news/20240421-gypsum-gps-receiver/
[22]米国特許5868100号
【GPS位置情報を使用した動物コントロール・システム】
一例ですが年々受信機の感度は向上している
東工大、磁束集中器を用いない高感度「ダイヤモンド量子センサ」を開発
2024/06/07
https://news.mynavi.jp/techplus/article/20240607-2961238/
電磁波音波攻撃をされている部位ごとにホルモンや異常物質などの観測
パーキンソン病の原因物質、脳内の可視化に成功
2024年6月6日 0時00分
https://www.asahi.com/articles/ASS652V7RS65ULBH00GM.html
2024/06/09(日) 22:41:10.47ID:YI6R90yo
今はOptionにas_slice()があるんだな
Some(x)なら[x]でNoneなら[]のスライス
アドレスは同じで長さが1か0なのか
85デフォルトの名無しさん
垢版 |
2024/06/10(月) 07:48:45.58ID:QAB9rEB/
AIの性能が上がれば世界情勢が見えてくる
にゅーーすで話していることもそれらしきことを話すようになる

まづボイス・トォ・スカルが存在している場合としていない場合を問う
そのあとに人間の行動をどのように行動するかを問う

交友関係全てわかる範囲で入力しておく
社会っ情勢を知るにはさらにどういった役職等も調べておく


自分が使用しているボイス・トォ・スカルを本物か偽物化も割り出せる
2024/06/10(月) 12:58:47.18ID:GcV83QCC
>>80
本当に内部ロジック上問題がないのかを確認するために見る必要のある範囲が広すぎるのが問題

>>81
if self.is_empty()を生かしたままという意味なら
不変条件を満たしてないコードが埋もれるのが問題
if self.is_empty()を無くすという意味なら
コードで表現したい意図から乖離するのが問題
87デフォルトの名無しさん
垢版 |
2024/06/10(月) 13:47:20.88ID:QAB9rEB/
不眠症にカップ麺やスナック菓子などの「超加工食品」が関係しているという研究結果
https://gigazine.net/news/20240610-insomnia-linked-ultra-processed-foods/

インターネットの都市伝説「The Backrooms」の起源となった画像の正体はどうやって判明したのか?
https://gigazine.net/news/20240610-origin-of-the-backrooms/

GoogleのGeminiとMicrosoftのCopilotが過去のアメリカの大統領選挙を含めた世界中の選挙の結果を正常に返していないことが判明
https://gigazine.net/news/20240610-google-microsoft-chatbots-election-questions/
88デフォルトの名無しさん
垢版 |
2024/06/10(月) 20:09:22.20ID:QAB9rEB/
ボイス・トォ・スカル
電磁波音波攻撃が判明する
人間は電磁界を発生させている
※被害者の身体に痕跡あり
パーキンソン病の原因物質、脳内の可視化に成功
2024年6月6日 0時00分
東工大、磁束集中器を用いない高感度「ダイヤモンド量子センサ」を開発
2024/06/07
名市大、頭蓋内全体の脳脊髄液の動態をマクロ的に観測する手法の開発に成功
2024/06/07
早大、物質中の創発磁気モノポールに起こる集団振動現象を理論的に発見
2024/06/04
理研、電子ビームの電子回折をアト秒で制御できる技術を開発
2024/06/06
分子研など、金ナノ粒子が円偏光の左右選択性を70倍に高めることを発見
2024/06/06
弾性乱流と古典的なニュートン乱流との共通点を発見――弾性乱流を記述する数学的理論の開発に寄与 OISTら
2024-5-29
京大、テラヘルツ波の照射で超伝導体の臨界電流を制御できることを実証
2024/05/28
産総研など、1000個以上の量子ビットを制御可能な超伝導回路の原理実証に成功
2024/06/05
名大など、水素原子の約1/20の超高精度で収差補正できるX線顕微鏡を開発
2024/05/09
89デフォルトの名無しさん
垢版 |
2024/06/10(月) 20:09:43.09ID:QAB9rEB/
細胞の内部を鮮明に観察できる蛍光顕微鏡技術を開発 阪大など
2024/05/07
OIST、有機電気化学トランジスタのON時に生じるタイムラグの原因を解明
2024/05/07
並行世界でタイムリープを繰り返す!?効率的な新しいシミュレーション技術
2024.05.22
東大、電子回折パターンの減少とエントロピー増加の対応を実証
2024/06/03
理研など、「スキルミオンひも」の観察とその詳細な融解過程の記録に成功
2024/05/23 19:29
東大など、金属3Dプリント中の2D画像から3D多孔質構造を予測する手法を開発
2024/06/03
2024/06/10(月) 23:46:59.09ID:gkT1iazs
>>84
スライスだから&[x][..]だね
91デフォルトの名無しさん
垢版 |
2024/06/11(火) 05:30:39.25ID:7n9sgmId
男性の精子の減少、携帯電話の使用と関係か 最新研究
2023/11/02
https://www.cnn.co.jp/fringe/35211064.html
放射線と被曝
https://www.kan-etsu-hp.ne.jp/wp-content/themes/kan-etsu-hp/assets/kanetsu-hospital/department/pdf/radiology/radiation.pdf
>>エネルギーが極端に大きくなると X 線やガンマ線と呼ばれる放射線の一種になります。
※電磁波音波攻撃被爆している?

MrIは強力な磁場を利用しているので被爆しない

冷凍した人間の脳組織を解凍した後も正常に機能する技術開発
2024.05.12
https://karapaia.com/archives/52331859.html

1立方ミリメートルの脳の断片をハーバード大学とGoogleの研究者がナノメートル単位で3Dマッピングすることに成功
2024年05月10日
https://gigazine.net/news/20240510-human-brain-mapped-in-spectacular-detail/
幼児期の脳活動から18歳時点でのIQを予測できるという研究結果
2023/09/09
https://gigazine.net/news/20230909-brain-activity-toddler-predict-18-iq/

パーキンソン病の原因物質、脳内の可視化に成功
2024年6月6日 0時00分
https://www.asahi.com/articles/ASS652V7RS65ULBH00GM.html
東工大、磁束集中器を用いない高感度「ダイヤモンド量子センサ」を開発
2024/06/07
https://news.mynavi.jp/techplus/article/20240607-2961238/
92デフォルトの名無しさん
垢版 |
2024/06/11(火) 05:31:04.86ID:7n9sgmId
日常的な蓋内全体の脳脊髄液の動態をマクロ的に観測する手法の開発に成功
2024/06/07
https://news.mynavi.jp/techplus/article/20240607-2961214/
細胞の内部を鮮明に観察できる蛍光顕微鏡技術を開発 阪大など
2024/05/07
https://news.mynavi.jp/techplus/article/20240507-2941335/

脳が鮮明に見える!世界最強の磁束密度で脳をスキャンするMRI「イズールト」
2024.04.05
https://nazology.net/archives/148090
※5分で全身スキャン完了するのかな
93デフォルトの名無しさん
垢版 |
2024/06/11(火) 06:55:26.94ID:3zjiFVVb
電磁波兵器の特許情報/Google検索で下記が判明
電磁波過敏症 低周波騒音被害 の症状が出現

設立 1998年 テクノロジー犯罪の撲滅
Https://media.toriaez.jp/s2972/32686.pdf
P77-身体・運動機能が遠隔から操作される P78-五感が遠隔から操作される
ギャングストーキングと電磁攻撃 - 広島修道大学学術リポジトリ
https://shudo-u.repo.nii.ac.jp/record/3395/files/SG63205.pdf


下記を頭部などで再現

人間の「第六感」 磁気を感じる能力発見
2019/03/19
https://www.sankei.com/article/20190319-6UGPQVLP4BLEDJYGVSX3WW6A4A/
髪の毛ほど薄いのに音を75%カット!MIT開発の「革新的防音カーテン」
2024.05.13
https://nazology.net/archives/149896

言葉に出さずとも内なる声を解読する、脳の読み取り装置が解発される
2024.05.20
https://karapaia.com/archives/52331884.html
2024/06/11(火) 22:42:05.37ID:r1NSY/4p
>>90
配列でもベクタでも[..]を付ければスライスへ変換されるわけか
95デフォルトの名無しさん
垢版 |
2024/06/11(火) 23:50:24.15ID:3zjiFVVb
【AI】IQ100超えを達成したAIモデルのClaude 3は「いい性格」を持つようにトレーニングされている [すらいむ★]
https://egg.5ch.net/test/read.cgi/scienceplus/1718025035/l50
2024/06/12(水) 00:41:51.20ID:wUm4+4hy
ゼロから学ぶRust システムプログラミングの基礎から線形型システムまで (KS情報科学専門書)

Kindleで本日のみ¥500
2024/06/12(水) 13:31:07.00ID:6YNIMY/v
Rustの作者と対話をしなくてもRust上級者になれるのは
作者の心を正確に読めるからではなく
あまり正確ではない当てずっぽうと試行錯誤が嫌いではないからだと思う
98デフォルトの名無しさん
垢版 |
2024/06/12(水) 17:47:51.37ID:D5Lyqx4l
はじまた
https://www.youtube.com/live/GiVA0MiHCV0
2024/06/12(水) 21:31:56.44ID:t2XH+QPZ
>>94
どちらもstd::slice::SliceIndexによるものだが
その前にVecはstd::ops::Derefでsliceに変換されるのに対して
配列はstd::marker::Unsizeが実装されていて
std::ops::CoerceUnsizedでsliceに変換される点が異なる
100デフォルトの名無しさん
垢版 |
2024/06/13(木) 02:53:52.72ID:PAaiBuyr
人間に匹敵する知能を持った汎用人工知能を開発した研究者に総額100万ドルの賞金を授与するコンテスト「ARC Prize」が開催
2024/06/13(木) 08:11:01.44ID:xJ4qiDeD
zlib-rsの0.2.0きたね
ttps://github.com/memorysafety/zlib-rs
2024/06/13(木) 08:58:47.14ID:gxf+efas
>>99
Vecはヒープに依存し、かつスタックに移動するのが不可能
「サイズ」を定義できないデータは(スタックに)移動できない

個人の感想です
が、これが「知能」だと思うよ
103デフォルトの名無しさん
垢版 |
2024/06/13(木) 11:16:55.93ID:fHN6F3J2
>>95
IQ=2x偏差値
104あぼーん
垢版 |
NGNG
あぼーん
2024/06/13(木) 19:06:39.65ID:LjZDtVfU
>>101
元のzlibとの速度差はどれくらい?
2024/06/13(木) 19:19:21.58ID:bPri26wi
>>104
ガンガンポイント増えるな
2024/06/13(木) 19:53:32.56ID:jsa1Mw5+
zlib-rsはzlibと比較してまだ圧倒的に足りてないからパフォーマンス評価のしようがない
ttps://github.com/memorysafety/zlib-rs/issues/49
2024/06/13(木) 21:05:44.12ID:V9qdE8Kb
>>107
先は長いね
2024/06/13(木) 21:29:59.05ID:/G8REiwP
RustはC/C++に置き換わるのか?
2024/06/13(木) 21:36:14.88ID:1OdwwcYl
無理無理かたつむり
2024/06/13(木) 21:37:00.52ID:gxf+efas
計画も陰謀もないんだよ
2024/06/13(木) 21:59:02.47ID:5nBUoDRv
>>104
めっちゃ面白そう
 
2024/06/13(木) 22:16:54.37ID:jsa1Mw5+
>>109
時間さえあれば
2024/06/13(木) 23:52:05.18ID:zLnkTNXF
>>109
C/C++がRustに置き換わっていってる
2024/06/14(金) 08:05:53.63ID:5fkgUscQ
>>109
その前にSafe Rust相当のsafe c++とか出るんじゃない?
標準化できるかわからんが。
2024/06/14(金) 08:11:27.55ID:n78hEtXN
C++はUTF-8の扱いを何とかして欲しいね。
2024/06/14(金) 08:28:16.67ID:Rk5MFfRB
>>115
C++をいくら強化してもそれは不可能だと皆がわかった
既存C++資産メンテ用限定としてはCarbonがある
それ以外は全てがRustへの移行に向かっている
2024/06/14(金) 08:44:54.37ID:5fkgUscQ
>>117
別のサブセットを作るだけだよ。
unsafe rustに対するsafe rustみたいなもの。
2024/06/14(金) 08:53:45.79ID:Rk5MFfRB
>>118
それは無理だとわかったので誰も進めていない
2024/06/14(金) 08:54:29.15ID:/xTQkr0X
C++やってればそれが不可能なことくらいわかると思うんだけどな
2024/06/14(金) 08:56:27.95ID:ZAmC1x49
聖地に向かっている者だけが地政学を信じている
122デフォルトの名無しさん
垢版 |
2024/06/14(金) 09:19:59.81ID:g3k7S7zc
>>109
現在進行形だけどC/C++が絶滅するわけじゃなさそう
2024/06/14(金) 10:01:07.05ID:lj8dYX/x
>>115
C++のロードマップを見てくると良いよ
2024/06/14(金) 11:03:03.69ID:GO4uoc83
今考えられてるアノテーションではmaybe safer C++になるだけで根本的にsafeではない

既存資産を活用するという最大のメリットを捨てて非互換新言語を作れば可能だけどRustがある現状で誰もそんな事に投資しないから実現不可能
2024/06/14(金) 11:28:58.36ID:O+avA7Kj
>>117
carbonとか完全に忘れてたわ。あれ絶対c++やRustより先に無くなるやろ
126デフォルトの名無しさん
垢版 |
2024/06/14(金) 17:00:20.45ID:wrlhIGAu
https://imgur.com/a/layer-A7vGJjY
使い分けは
こんなイメージ
2024/06/14(金) 17:29:32.96ID:97A5EwfU
C++を安全にしようとすると標準ライブラリの各インターフェースから全て作り直しとなり
標準でないライブラリも同様なので既存のコード資産は使えず全面書き直しとなってしまう
それだけでは済まなくて互換性のない言語仕様も取り入れないといけない
なんとか手間暇かけてそこまで頑張って安全なC++ができあがっても何の意味もメリットも無くなってることに誰もが気付いた
2024/06/14(金) 17:31:19.78ID:stz6yx5w
色使いが目にunsafeすぎる
2024/06/14(金) 18:01:13.88ID:PWCt6Qaf
zlib-rsで移植のほぼ完了したdeflateを見ればよくわかるけどすごくメモリ安全だぞ
現実を見ろ
130デフォルトの名無しさん
垢版 |
2024/06/14(金) 18:18:31.44ID:49Oug44p
>>109
ゲーム分野のC/C++は置き換わらない
2024/06/14(金) 18:24:39.72ID:lj8dYX/x
ゲームなんざ脆弱性があろうが最悪クラッシュさせりゃいいからな😁
まともなゲームエンジンフレームワークのないRustを使う意味がない
それよかクラッシュしたら人死の出るようなところのRust化が優先
2024/06/14(金) 19:04:14.04ID:1kqNSQLr
ネットワーク対戦ゲームだと細工したパケット送ると
バッファーオーバーフローで云々とよくある
脆弱性になるじゃん
2024/06/14(金) 19:13:14.40ID:65JFUBxW
>>132
そんなつまらない欠陥じゃなくてC++ではなくRust選ぶ利点になりえる脆弱性を言ってよ
2024/06/14(金) 20:42:46.16ID:ZAmC1x49
今すぐ物を作るのは損
10年後20年後に作れば得
これがインフレだが
本当はどちらか一つだけ選ぶのは損で両方選ぶのが得だと思わないか
2024/06/14(金) 21:29:25.97ID:1kqNSQLr
>>133
あなたがつまらんかどうかが評価軸じゃないので
2024/06/14(金) 22:51:10.89ID:SfJORH/f
>>134
>今すぐ物を作るのは損
>10年後20年後に作れば得
>これがインフレだが

違う
前提が間違ってるので議論が成り立たない
137デフォルトの名無しさん
垢版 |
2024/06/14(金) 23:07:33.93ID:B5keN8zV
C++書くのダルイんよ
Rustのゲームエンジン来るの待ってる
138デフォルトの名無しさん
垢版 |
2024/06/14(金) 23:46:55.69ID:49Oug44p
ゲームはまずdirectxやopenglとかがrustで書き直されないことには何も始まらんと思うわ
139デフォルトの名無しさん
垢版 |
2024/06/15(土) 00:13:27.25ID:W+2t+gug
この板はプログラムを作らない人のための板ですね
2024/06/15(土) 00:24:57.03ID:mfm3bm5o
作ると断言するが、時の指定まではしていない
2024/06/15(土) 04:55:57.02ID:ao0/TxVC
>>138
WebGPUの参照実装であるwgpuを知らんのか。
ライブラリ使う側のIFはだいぶsafeだよ。
まぁ、バックエンドは結局、valkanやOpenGLになるけど。
2024/06/15(土) 06:54:41.07ID:FwUehUa7
>>138
それらは書き直されてもunsafeばっかになって意味ないだろ
2024/06/15(土) 07:07:04.66ID:jiIbIudV
OSのシステムコールだって生ポインタを渡したりunsafeな仕様だけど
Rustはsafeなインターフェースのライブラリとして提供して安全に使われているよ
144デフォルトの名無しさん
垢版 |
2024/06/15(土) 08:12:25.38ID:h+pAIb35
AIに組み込まれた検閲による命令拒否を打ち消してあらゆる種類の質問に応答できるようにする「アブリテレーション」とは?
2024年06月14日
※自分の身近な人の嘘や陥れようかが話されたことと実際の動き【動画撮影含む】っを解析すれば判明
スポーツで動的シミレーションなどをする不正をしているや審判の判定がおかしいも判明
日常生活の動きも同時に併用されればボイス・トォ・スカルを使用しているかが判明

スマフォにAIが搭載されるので容易に判定
120フレームと8k【人間の網膜の解像度と同じ】あればかなり制度が上がる

相手の望まない手助けは数週間持続する高いストレスを与える!
2024.06.13
↕サイコパスはどう考えるのかな
使えない人」を排斥するとき周りの人の心は痛みにくいと判明
2021.05.22 SAT
ネット上で問題発言をする人は、暗い性格特性「ダーク・トライアド」かもしれない
2021.04.02 FRI
ナルシストは他の人よりも早くCEOの地位にたどり着く
2021.02.09 TUE
つい被害者を責めてしまう「公正世界仮説」とは何なのか?
2019.07.22 MON
「無能」でもOK? 社会的地位の高い人ほど信頼されやすい理由とは
2019.06.02 SUN
145デフォルトの名無しさん
垢版 |
2024/06/15(土) 08:12:46.55ID:h+pAIb35
「問題を指摘する人」に問題があると思い込む心理バイアス「自発的特性転移」が陰謀論を生んでいるという主張
2024年05
悪いニュースを伝えた人は理不尽に嫌われてしまうことが明らかに
2019.05.17
「恋人がサイコパス」だった時の見分け方とは
2018.12.09 SUN
ロンドン市民の娯楽だった?!近代イギリスの公開処刑
2023/12/17
スラップ訴訟
>>ある程度の発言力や社会的影響力のある、社会的に優位といえる立場の者が、特に発言力や影響力を持たない相対的弱者を相手取り訴訟を起こすこと。
巨大IT企業から「法的措置をちらつかせる停止通告書」を受け取った場合の対処方法とは?
2024年02月01日 08時00分
146デフォルトの名無しさん
垢版 |
2024/06/15(土) 10:23:21.15ID:sguIT4c6
サイバーエージェント、画像認識できる75億パラメーターの日本語LLM公開 商用利用OK
サイバーエージェントは6月13日、日本語大規模言語モデル(LLM)に画像認識機能を追加した大規模視覚言語モデル(VLM)「llava-calm2-siglip」を公開した。

「ChatGPT」画像を見ながら人間みたいに話せる新機能、今後数週間でリリースと予告
OpenAIは6月14日、同社の公式Instagramアカウントを通じ、ChatGPT(GPT-4o)に音声と映像を同時に理解する機能を追加し、今後数週間以内にリリースすると発表した。

画像生成AI「Stable Diffusion 3 Medium」公開 プロンプトの理解力が上がり、リアルな画像が生成可能に
Stability.aiは6月12日、同社が開発する画像生成AI「Stable Diffusion 3」シリーズの最新モデル「Stable Diffusion 3 Medium」を発表、無償の非商用ライセンスおよびクリエイターライセンスの下で利用可能だ。
サイバーエージェント、画像認識できる75億パラメーターの日本語LLM公開 商用利用OK
サイバーエージェントは6月13日、日本語大規模言語モデル(LLM)に画像認識機能を追加した大規模視覚言語モデル(VLM)「llava-calm2-siglip」を公開した。

「ChatGPT」画像を見ながら人間みたいに話せる新機能、今後数週間でリリースと予告
OpenAIは6月14日、同社の公式Instagramアカウントを通じ、ChatGPT(GPT-4o)に音声と映像を同時に理解する機能を追加し、今後数週間以内にリリースすると発表した。

画像生成AI「Stable Diffusion 3 Medium」公開 プロンプトの理解力が上がり、リアルな画像が生成可能に
Stability.aiは6月12日、同社が開発する画像生成AI「Stable Diffusion 3」シリーズの最新モデル「Stable Diffusion 3 Medium」を発表、無償の非商用ライセンスおよびクリエイターライセンスの下で利用可能だ。
2024/06/15(土) 11:03:47.63ID:8Y+G0brA
>>143
それなら既存のRustラッパーでよくね?
148デフォルトの名無しさん
垢版 |
2024/06/15(土) 12:50:26.14ID:lxZB8+rK
根っこの技術がc/c++製でガワだけrustで、それでc++を置き換えたと言えるのか?
2024/06/15(土) 12:55:07.64ID:pv+Dr0CG
>>148
置き換える意味があるかないかの問題でしょ
ほぼシステムコールなグラフィックAPIのRust実装の有意義性はあるのか
2024/06/15(土) 13:06:53.11ID:I+z8iAZu
>>148
根っこを捨ててpure Rust で再構築したとして
それは置き換えたんじゃなくて
別のものを似せて造り治しただけじゃないのか
2024/06/15(土) 13:08:57.41ID:I+z8iAZu
>>149
完全に pure Rust の OS があったとして
その上で動くアプリケーションは全て Rust で描かないといけない世界が良いのか
Rust OS の上でも C/C++ で開発したい(API は C 相当)のかで意見が変わる
2024/06/15(土) 13:33:19.67ID:mfm3bm5o
完全に純粋に一人で打席に立つことは
そいつの年収やそのカネの所有権を定義するのに必要みたいな感じでしょ
2024/06/15(土) 15:03:07.44ID:jiIbIudV
勘違いしてる人が多いようだけど
Rustの目的は全てをRustで書くことではなく安全にすることなんだよ
だからOSシステムコール呼び出しもRust(と最小限の各アーキテクチャ毎のレジスタ積み等)で頑張るのではなくCで書かれたlibcを用いている
つまりRustのunsafe部分を最小限にするとともに、unsafeだが枯れて安全なlibcを活用している
154デフォルトの名無しさん
垢版 |
2024/06/15(土) 15:11:35.25ID:W+2t+gug
勘違いしてんのはここでまともなRustの話ができると思ってるお前だよ
2024/06/15(土) 15:51:53.03ID:uRWofhsS
概論でいいんならこれ貼るよ

オブジェクト指向を学ばなかった話
https://qiita.com/adaiimps/items/e04ae03371435aeffe87
2024/06/15(土) 15:54:39.14ID:I+z8iAZu
自分は pure Rust に全然拘っていないし
むしろ unsafe 大好きだが
pure Rust に拘ってる人や
unsafe 絶対無くせって言ってる人も居るのを知ってる
後者は基地外
2024/06/15(土) 16:13:09.69ID:uRWofhsS
use std::io::{self, BufRead, BufReader};
const FULL_BITS: u32 = (1 << 26) - 1;
fn main() {
 let mut shortest: Option<String> = None;
 for line in BufReader::new(io::stdin()).lines() {
  let line = line.unwrap();
  let mut bits = 0;
  for b in line.as_bytes() {
   let index = match b {
    b'A'..=b'Z' => b - b'A',
    b'a'..=b'z' => b - b'a',
    _ => continue,
   };
   bits |= 1 << index;
  }
  if bits != FULL_BITS {
   continue;
  }
  if let Some(ref shortest) = shortest {
   if shortest.len() < line.len() {
    continue;
   }
  }
  shortest = Some(line);
 }
 if let Some(shortest) = shortest {
  println!("{shortest}");
 } else {
  eprintln!("ERROR: no matched lines");
 }
}
2024/06/15(土) 17:55:06.95ID:uRWofhsS
ソースコードのコピペで止まるスレ
159デフォルトの名無しさん
垢版 |
2024/06/15(土) 20:29:16.21ID:x7/eMzge
ソースコード貼るなんて暴力ですよ!
2024/06/15(土) 21:06:34.26ID:uRWofhsS
コピペしただけなんだけどね

http://mevius.5ch.net/test/read.cgi/tech/1691038333/6
2024/06/15(土) 21:09:34.98ID:jiIbIudV
>>156
unsafeは好き嫌いというよりも
最下層のCPUとメモリもしくは境界のFFIで必須な存在とみるべきではないかな
ただしそこだけにunsafeを閉じ込めて一般プログラマーはsafeなインタフェイスのみを使う
2024/06/15(土) 21:10:47.55ID:uRWofhsS
一行のコードも書かずに形而上学みたいにプログラミングを学ぶ贅沢はいいね
2024/06/15(土) 21:54:03.45ID:uRWofhsS
Rust「で」作るんじゃなくてRust「を」作る秘密が知りたいんだよね
すべてのソースコードがコンパイル時に手元にあったとして、メモリの使途を解析してしまえるなんて普通は思わないからね
この点を「たまたま思いついた天才がいた」で済ませたくない
2024/06/15(土) 22:10:08.33ID:uRWofhsS
Copy型とそうでない型。よろしい
Copy型の自動変数みたいにそうでない型もスコープを抜けると解放。それはよろしい
しかしそんなものは遥か実用に遠い
2024/06/15(土) 22:29:19.17ID:uRWofhsS
いったい何がきっかけでメモリの使途を把握してしまえるかもと思ったか
それが分かるまでごくごくゆっくりとしか勉強しないよ
2024/06/15(土) 22:33:28.01ID:mfm3bm5o
ヒープを一切使わないパラダイムは昔に戻っただけ
スタックの安全性だけを考えてヒープはライブラリに任せる
2024/06/15(土) 22:46:06.16ID:uRWofhsS
全部スタックでやってるって本当の話なの?
2024/06/15(土) 22:51:02.34ID:uRWofhsS
allocaとかとっくにあったよ?
2024/06/15(土) 23:22:17.89ID:uRWofhsS
逆のものを想像してんだけどな
スタックでなくヒープにあっても同じなのがRustじゃないの?
2024/06/15(土) 23:47:36.34ID:mfm3bm5o
参照の寿命が尽きても参照元のデストラクタは呼ばれない
だから参照元がヒープにあろうがなかろうが参照の寿命はスタックに基づいて決めてしまえば良い
2024/06/16(日) 00:42:56.54ID:DhqUa2Zy
>>170
「参照元」は誤用か
参照先と言うべきだったか
2024/06/16(日) 00:50:00.04ID:+a7ueRP7
>>169
スタック上への参照とヒープ上への参照をRustでは区別しない
ライフタイムさえ満たしていればどこを指していても区別なく参照を扱う
そのため、従来行われてきた「安全にヒープ上でに領域を確保してヒープ上への参照を返す」をしなくても
ライフタイムさえ満たしていればスタック上への参照を安全に渡したり返したり自由にできるようになった
そのため、従来はヒープ上に確保していていたケースがRustではスタック上に置くことができるようになり、その点でも高速化に寄与している
2024/06/16(日) 01:00:26.12ID:d8h4GcS0
複オジのレスはいつも通り8割は嘘だな
2024/06/16(日) 01:15:13.88ID:dwkxcYMW
>>172
別にC言語だってallocaの返したポインタとmallocの返したポインタを区別しないけど
2024/06/16(日) 01:25:03.80ID:J8bJz9x+
誰が解放するか責任もなく解放忘れや多重解放を生むC言語は論外だろ
解放されたスタックフレームやヒープエリアを指し続けているポインタが残ったりな
2024/06/16(日) 01:32:46.10ID:dwkxcYMW
C言語と違って区別しないわけじゃないし、C言語と違って高速ってわけでもない
2024/06/16(日) 01:39:48.74ID:dwkxcYMW
C言語同様に区別しないし、C言語同様に高速なんでしょう
2024/06/16(日) 01:45:22.24ID:sswa3N72
そろそろ自己隔離しとけザコども

結局C++とRustってどっちが良いの? 9traits
ttps://mevius.5ch.net/test/read.cgi/tech/1701997063/
2024/06/16(日) 03:32:45.56ID:dwkxcYMW
へえ、コピーじゃなくて移動をデフォにしちゃうのか
2024/06/16(日) 04:03:11.69ID:WxpyLfm8
>>174
mallocで得たポインタとallocaで得たポインタは明確に区別しなければならない
mallocで得たポインタのみfreeの対象としなければならない
この区別はCプログラマーの責務でありミスると破綻する
2024/06/16(日) 04:10:20.19ID:dwkxcYMW
>>180
コンパイラが区別してくれるわけじゃないからそう書いた
今はRustコンパイラの秘密を探ってるんだし
2024/06/16(日) 04:28:58.35ID:QdGU/f8s
Rustはヒープで確保したメモリ領域も完全自動で安全にメモリ解放されるからプログラマーの負担がなくていいよね

ヒープへの参照とスタックへの参照に区別がないだけでなく
それらをたとえ混ぜて関数間で渡したり返したりたらい回しにしても安全で
もし安全でない使い方をした時はライフタイムが切れてコンパイルエラーになるから自由と安全が両立されてるね
2024/06/16(日) 04:37:34.79ID:qe+k+ZN3
解放されたスタックフレームが残って、どうやって呼び出し元に帰るつもりなんだろう。😱
2024/06/16(日) 04:43:29.58ID:dwkxcYMW
メモリはコピーじゃなくて(所有権の)移動がデフォ
所有者がスコープを抜けるとメモリは解放
所有者に別の値が代入された際もメモリは解放
代入元は所有権が移ると未初期化の扱いになる

これだけでもかなり面白いね
185デフォルトの名無しさん
垢版 |
2024/06/16(日) 04:50:45.28ID:/uiI2ckT
>>183
C/C++/Rustすべて関数が呼び出し元に戻るときにスタックフレームは自動解放されます
もしその破棄されたスタックフレーム上を指すポインタ(参照)がどこかに残っていた場合、
C/C++ではそのポインタ使用でそこをアクセスしてしまい気づかないバグや穴となるでしょう
Rustではコンパイル時点でライフタイムエラーとなるため問題が起きないです
186デフォルトの名無しさん
垢版 |
2024/06/16(日) 05:46:32.57ID:Jxkkspwa
正体不明のボイス・トォ・スカル
マイクロ波聴覚効果の機能より

神の声兵器は機器の場所が割れているので
ハッキング下と奪取後に器機を複製できた音を宣言していた

電磁波音波なのでむやみに器機に仕掛けると誰かが攻撃しているとすぐに設置したものは察知するが
その監視網をかいくぐるということは一発で危機をジャックしたことになる

そして機器の性能は年々よくなるので自分に行って見分けがつかないくらいになると器機使用者が幻覚を見ていると錯覚し始める
2024/06/16(日) 06:03:13.93ID:dwkxcYMW
メモリはそれ自体は無論のこと、それを指すポインタもひとつしかないわけだ
2024/06/16(日) 07:56:02.10ID:dwkxcYMW
この発想は正直なかったわ
ひとつのメモリをあちこちから参照すればするほど高効率みたいな思い込みがあるからね
2024/06/16(日) 10:08:57.93ID:R4/urzCg
>>167
>全部stack
そういう描き方をすればそうなるってだけで
そういう描き方ならCでも出来る
2024/06/16(日) 10:11:02.64ID:R4/urzCg
>>169-171
CにBoxを導入すれば解決
2024/06/16(日) 10:13:30.02ID:R4/urzCg
>>173
ほんそれ
2024/06/16(日) 10:32:48.33ID:dwkxcYMW
で、配列の要素だったり構造体のメンバだったりは「移動済み」にできない?
2024/06/16(日) 10:36:59.18ID:dwkxcYMW
とにかく&をつければアドレスを借用できて、その生存規則違反はコンパイラがはじく、と
2024/06/16(日) 10:41:20.79ID:irw16nD2
新参に教えといてあげると
172, 175, 180, 182あたりはすべて複製おじさん(通称 複オジ)という同一人物だよ
知ったかぶりで出鱈目ばかり書いて全く反省しないという
悪い意味で有名な人ので騙されないように注意してね
2024/06/16(日) 10:51:27.98ID:DhqUa2Zy
1日10行推敲するより1日1万行書いた方が数値化に貢献しやすいからしょうがない
2024/06/16(日) 11:21:38.24ID:dwkxcYMW
ボローチェッカーは作るのも使うのも難しそう
よくこんなこと可能だと思ったもんだ
2024/06/16(日) 11:48:19.48ID:dwkxcYMW
Rustの中ではつまらないというか泥臭い部分だね
2024/06/16(日) 12:06:57.33ID:0Wwb3VFz
>>196
ライフタイムについてまじめに知りたいなら(ある程度Rustには慣れた前提として)NLLのRFCを読むのをおすすめしたい
ttps://rust-lang.github.io/rfcs/2094-nll.html

そろそろこれよりいい資料は出ないもんかね……というかReferenceに明記してもらえんかね
なんか1.79でも地味にルールが拡張されたようだし
2024/06/16(日) 12:23:11.10ID:dwkxcYMW
ええっと、メモリの所有者が
・スコープを抜けること
・別の値が代入されること
・別の変数に所有権を移動させること
はもともと検出できる前提なのだよね
ボローチェッカーと言ってもその3つの組み合わせに毛が生えた程度なのかどうか
2024/06/16(日) 12:27:02.82ID:EH7/X6SF
>>198
全ての言語仕様を「仕様書」としてまとめる提案は出ているんだけど何年も動きがないんだよね……
201デフォルトの名無しさん
垢版 |
2024/06/16(日) 12:30:31.60ID:M/AsARsj
>>174
allocaで得たポインタfreeしてそうなコメントだな
2024/06/16(日) 12:32:49.98ID:EH7/X6SF
>>199
メモリとかアドレスとか言ってる時点で正確な理解から遠いと思う。
変数はメモリではないし、参照はアドレスではない。
処理系の実装としてはそのように対応するという想定はあるだろうけど機械語レベルの事情と言語のルールはレイヤが違う。
2024/06/16(日) 12:33:46.16ID:dwkxcYMW
>>201
機械語知ってるからそんな心配はない
2024/06/16(日) 12:36:26.13ID:dwkxcYMW
>>202
そうだね。Rustは高級アセンブラってわけではまったくないね。勘違いしてた
2024/06/16(日) 12:42:20.38ID:dwkxcYMW
代入だったり関数呼び出しの引数だったりはコピーじゃなくて移動がキホンって時点で機械語ともC言語とも違う
2024/06/16(日) 12:51:16.07ID:G6A3UH2o
>>205
代入と考えるよりもパターンマッチングと考えるといいかな
=や引数などで複雑なパターンを書いてもマッチングしてくれるよ
それがたまたま1対1の時が昔からの代入に相当してマッチングして移動
2024/06/16(日) 13:26:09.91ID:Crm/SwBu
あえて機械語レベルでも考えるとするなら概念的には移動でも (最適化を別にすれば) ビットパターンはコピーしている。
所有権を失った変数にはアクセスできないように静的に制限されるから所有権が移動したように見える。
借用は (借用が存在している間は) 移動を許さない権利として捉えることができる。
2024/06/16(日) 13:35:38.29ID:wnp+0tyF
>>200
現状だとここを見ておくのがいいかも
https://public-docs.ferrocene.dev/main/specification/index.html
ISO 26262の認定通すために書かれたものだからかなりちゃんとしている
2024/06/16(日) 15:11:48.05ID:xaMJYqDm
>>208
C/C++はISO認定だからな
一方、Rust連中はほんぽん仕様変える(変えたい)から、そんなISOレベルの仕様書書く意味がないって感じじゃないのか
2024/06/16(日) 15:51:37.66ID:Crm/SwBu
>>209
C++ だって三年ごとに更新する制度になってるし、その間の議論でも仕様の文面をどう変えるかという形式をとる。
頻繁に変えるつもりがあるならなおさら今どうなってるのかの全体像を把握できる仕組みがないと困る。
2024/06/16(日) 15:52:59.06ID:sKPbV2Nu
RubyもISOになったことあるし
212デフォルトの名無しさん
垢版 |
2024/06/16(日) 15:57:39.35ID:sswa3N72
15.4:16 ??? (this should describe the order of borrowing and when the borrow is returned)

わろた
2024/06/16(日) 16:23:56.88ID:dwkxcYMW
NLLというくらいだからもともとLL
2024/06/16(日) 16:49:41.43ID:dwkxcYMW
まあ一応(ボローチェッカーというものが)可能そう
2024/06/16(日) 17:20:46.77ID:dwkxcYMW
コンパイラはプログラム中の全ての参照型に対してライフタイムを割り当てる、と
2024/06/16(日) 17:45:29.17ID:WRdAUcGE
言語にISO標準を求めるのって相当なお爺ちゃんでしょ
もうそういう時代じゃないですよ
2024/06/16(日) 17:52:05.41ID:fzWVLbYH
>>215
所有者がどのスタックフレーム(の中のどのブロックスコープ)にいるかだけの話だよな
そこより先なら参照は生きて
そこより元なら参照も死ぬ

もちろんそんな神の絶対的な視点を実行前のコンパイル時点で静的に持つことはできない
しかし各関数内での出入り(引数がinで返り値がout)は静的にわかるから
相対的な視点で有効か無効かわかることになると
2024/06/16(日) 17:55:19.72ID:Crm/SwBu
>>216
ISO 規格が必要なんて話はしてないだろ。
仕様書が要るって話をしてるんだぞ。
2024/06/16(日) 18:05:26.18ID:0Wwb3VFz
複製おじさんと遊ぼうスレ
2024/06/16(日) 18:43:24.33ID:hxwMVp5d
>>218
>仕様書が要るって話をしてるんだぞ。
別に全然要らないぞ
逆になんで要るんだ?
2024/06/16(日) 18:44:48.95ID:dwkxcYMW
ひとつしかない所有者がスコープを抜ける、もしくは所有者に別の値が代入されると、そこから先にはメモリはもうない
2024/06/16(日) 18:57:47.09ID:dwkxcYMW
なんとなく、所有者はスタックの根元の方に、参照はスタックの枝葉の方にいそうなイメージ
2024/06/16(日) 19:01:15.44ID:4AvHozuz
>>221
有効な参照(借用)が存在したまま移動や破棄は起きない
これは静的に判定されコンパイルエラーとなる
2024/06/16(日) 19:08:46.55ID:dwkxcYMW
>>223
つまり所有権も静的に解析できる?
2024/06/16(日) 19:26:50.69ID:0Wwb3VFz
ここは結局こんな感じなのでID:dwkxcYMWは本当のことが知りたいならrust-lang-jpのZulipにでも行くといい
ttps://rust-lang-jp.zulipchat.com/
2024/06/16(日) 21:12:46.18ID:Crm/SwBu
>>220
じゃあ言語の仕様をどうやって把握すんの?
何が出来ていれば Rust のコンパイラを実装できましたって言えるの?
2024/06/16(日) 21:13:16.76ID:Crm/SwBu
>>224
できるというか、それが Rust のキモやで。
2024/06/16(日) 22:06:19.67ID:DhqUa2Zy
ゴールポストを固定することが正しいという考えが衰退したんだよな
正しさを疑うことが常識になったから
2024/06/16(日) 22:29:00.55ID:Crm/SwBu
>>228
ゴールを設定したいという話じゃなくて「今」どうなっているか見えないと疑うべきものすら存在できないって話なんだよ。
2024/06/16(日) 22:37:41.81ID:ICtaqBL/
>>226
>じゃあ言語の仕様をどうやって把握すんの?
言語の仕様はリファレンスで把握しろよ

>Rust のコンパイラを実装できましたって言えるの?
言える必要性が全くないやろ
どうしても言いたければ公式が用意してるコンパイラと標準ライブラリのテストを全部通したらいいんじゃね?
2024/06/16(日) 23:02:11.93ID:Crm/SwBu
>>230
端的に言うと現状のリファレンスマニュアルで Rust の仕様の全てを読み取ることは出来ない。
そのことは >>198 あたりからの話題の流れ。
リファレンスマニュアルは仕様を書くものじゃないし。
232デフォルトの名無しさん
垢版 |
2024/06/17(月) 06:58:24.07ID:Yz55GwEO
【マイクロ波センサー】長距離でも壁があっても動きを検出!
↓2010年ごろには完成
高齢化社会を支える“見守りシステム”の開発に成功-カギを握った半導体ソリューションとは
↓2026年ごろにさらに性能工場
旭化成、ミリ波・マイクロ波帯の空洞共振器による微小金属検査システムを開発

男女関係なく陰部を撮影
一度でも盗撮されていれば正確な色合いの・・・
初期型は赤外線センサー【自動ドアのセンサなど】

子どもが言語を獲得していくのと同じようにAIモデルに学習させることに成功
AIを使って「赤外線カメラ画像のフルカラー化」に成功!

世界中で横行
233デフォルトの名無しさん
垢版 |
2024/06/17(月) 16:27:54.49ID:prlYSpwu
役に立たないどんぐり
2024/06/17(月) 21:23:17.19ID:McDpAz4n
卒業式でみんなで思い出を言うやつみたいだな

卒業生 「そして役に立たないどんぐり!」
卒業生一同 「どんぐり~」
2024/06/17(月) 21:51:46.63ID:McDpAz4n
卒業生A 「高速で動作しながら保たれる高いメモリ安全性」
卒業生一同 「安全性!」
2024/06/17(月) 22:06:12.81ID:JE6O5Al9
米ホワイトハウス「ソフトウェアはメモリ安全でなければならない」との声明を発表:「C」「C++」よりも「Rust」などの言語を推奨
https://atmarkit.itmedia.co.jp/ait/articles/2403/18/news045.html
2024/06/18(火) 00:33:44.73ID:Vx2LO8pn
卒業生 「みんなで借りた所有権」
卒業生一同 「所有権!」
238デフォルトの名無しさん
垢版 |
2024/06/18(火) 02:26:00.95ID:V90mUrMq
AIにC++とRustのコードを比較してもらった
https://nshinchan01.hateblo.jp/entry/2024/06/18/021159
2024/06/18(火) 08:51:41.62ID:Ee6IUiqA
見えない仕様書より見えているコロンブスを殴る
殴る
2024/06/18(火) 09:12:34.89ID:z6V+MJXC
>>238
sum()自体は使わないとしてこうかな

fn foo(input: impl IntoIterator<Item = i32>) -> i32 {
 input
  .into_iter()
  .filter(|x| x % 2 == 0)
  .map(|x| x * 2)
  .fold(0, |sum, x| sum + x)
}

fn main() {
 let numbers = vec![1, 2, 3, 4, 5];
 assert_eq!(foo(numbers), 12);
}
2024/06/18(火) 12:23:59.59ID:/B9kzKJY
Rustの仕様と実装の分離ができてないと、公式の実装が唯一になるから困る分野があるんだろうね。
Cとかコンパイラいっぱいあるじゃん。

Rustぐらい複雑で成長途上の言語で仕様を文書化して実装を交換可能にするなんて事実上無理っぽいけど、10年後ぐらいには問題でてくるのかもね。
2024/06/18(火) 12:31:26.48ID:28rDJLEQ
>>241
現在のRustの仕様は実用的なプログラミングをする上で十分なレベルとなっているけど
さらに便利にするための追加仕様がTODOリストに積まれていてそれらが少しずつ解決されて追加されていってる状況ですね
まだ当面しばらくは現状体制のまま成長させていくのが望ましいと思います
243デフォルトの名無しさん
垢版 |
2024/06/18(火) 13:47:06.59ID:4eNa7Q9X
実装が仕様でもいいけど、その場合はその実装のコアの部分を明確にした方がいいかもね
244デフォルトの名無しさん
垢版 |
2024/06/18(火) 13:51:40.72ID:LAg3uLnk
GPT-4oがAIベンチマークのARC-AGIで50%のスコアに到達、これまでの最高記録である34%を大幅に更新
2024年06月18日
※さらに最適化すれば70%以上も可能な模様

スマホに搭載可能な小型透視チップが開発される
2024年06月18日
245デフォルトの名無しさん
垢版 |
2024/06/18(火) 16:50:36.49ID:Q5+2E571
>>241
Cの標準化の更新なんて10年とかだろうが。
2024/06/18(火) 18:04:47.12ID:dU1vPCRC
>>241
>Cとかコンパイラいっぱいあるじゃん。
それは各チップでそれぞれ別のCコンパイラが必要なのと
クローズドソースでプロプライエタリのコンパイラを有償で販売できる環境があるからだよ

Rustだと各チップで必要になるのはLLVM対応であってRustのコンパイラではないし
リスクをとってまでプロプライエタリなコンパイラをわざわざ作るメリットもほぼない
それにコンパイラが乱立しないというのは今のところはエコシステム的にはメリットしかない
2024/06/18(火) 19:09:22.28ID:gzLiS43Q
gccが頑張ってるくらい?
2024/06/18(火) 19:12:43.09ID:1V33WRQR
団体がすべての主導権を握ってるならある日急にガラッと変えても誰も文句を言えない
実装が仕様です

C++や他の言語で規格がって言ってるのはコンパイラだけの問題じゃなくてコード利用してる側の都合でもある
2024/06/18(火) 19:12:43.05ID:mK8t8Wj0
Rust Foundation自身がrfc3355をmergeして仕様策定やります宣言してるのに
今更そんなこと言ってもね
2024/06/18(火) 19:36:21.60ID:mK8t8Wj0
そもそも、仕様を必要とするのはコンパイラだけじゃない

ttps://blog.rust-lang.org/2022/07/01/RLS-deprecation.html

少なくとも、公式がrustc依存のRLSを捨ててrust-analyzerへの乗り換えを宣言した時点から
「rustc実装が仕様」状態から脱却しなくてはならないという意識はRust Foundation内にもずっとあったと考えるべきだろう
2024/06/18(火) 23:19:40.06ID:AiI9Z/GF
Rustのコンパイラを作るために理解すべき仕様と
Rustを使うために理解すべき仕様を
仕様という言葉で一括りにするから話がおかしくなる
2024/06/19(水) 01:01:46.69ID:Xt21vW+E
>>248
>C++や他の言語で規格がって言ってるのはコンパイラだけの問題じゃなくてコード利用してる側の都合でもある
コードを利用してる側の都合というのは複数の実装が存在するけど
リファレンス実装やデファクトスタンダードが存在しないから規格がないと困るからでしょ

今も規格が生きてる言語というとC, C++, COBOL, Ada, Fortran, JavaScript, C#くらい
C#を除くと各ベンダーがクローズドソースでプロプライエタリなコンパイラを作ってた時代からの言語
C#はOSS/マルチプラットフォーム化されて必要性はもうなくなってる
2024/06/19(水) 01:08:50.95ID:8OfzU/dS
Javaも、本家SunとGnuとあったな。今は知らんが
254デフォルトの名無しさん
垢版 |
2024/06/19(水) 04:09:25.16ID:Z3xOIU7u
ボイス・トォ・スカル
スポーツで試用しているとそっく露呈

選手の動きを撮影してそれを2倍.4倍...スロー再生すれば明確に使用しているを見つけられる
通常の者でも動けなくとも音と動作は見えているのでそれをシミレーション【通常の者主軸】にあてはめて動作をみればよい
それにプラスΑでそれが可能な回数を数学を用いて算出【科Ⓚ立論や物理的法則の確率論】すれば明らかにおかしいが判明

人間の筋肉量などを基本にの運動能力を設定しておくこと
さらに公共の場で日常生活のⓀ感の鋭さを調べれば本人がその能力があるかがわかる

知力の方は根気よく罠にかけるように会話をしていけば露呈する
255デフォルトの名無しさん
垢版 |
2024/06/19(水) 07:18:12.06ID:Z3xOIU7u
レーザーで「トリウム原子核」を励起することに成功、原子核時計などの革新的技術への道が開かれる
2024年04月30日


量子もつれの伝達速度の限界を解明することに成功!
2024/04/02

世界初!「量子もつれ」の画像撮影に成功
2019/07/15

量子テレポーテーションとワーム・ホールの移動速度判明
地球上に幽霊も神も観測可能なのになぜ観測不能?
量子テレポーテーション中は量子のもつれがないので双方観測不能
など考えましょう
256デフォルトの名無しさん
垢版 |
2024/06/19(水) 10:09:36.86ID:Ml7xOhwE
ここもう、ちゃんと教えてくれる上級者を追い出し終えてしまったと思う
初心者が自分以下の初心者にマウント取るだけのスレになってしまった
最後まで我慢して付き合ってくれた上級者まで汚い言葉で追い出して。
そんなんだからいつまでも下手なんだろうし、しょうがないか
2024/06/19(水) 11:17:34.73ID:1p8aP5/l
上級者がいるとマウント取られてうざいから追い出し得だろ😅
2024/06/19(水) 17:53:51.50ID:LFDUaW3g
質問です
イテレータから"名前1", "データ1", "名前2", "データ2", ...と渡ってくるのですが
これを(名前, データ)のイテレータに変換する方法、または、そのように扱える方法ありますか?
2024/06/19(水) 18:29:49.29ID:sNVXKo+0
擬態初心者
2024/06/19(水) 18:44:02.73ID:ZD2dEKbK
>>248
気に入らないなら、フォークすれば良いじゃん
2024/06/19(水) 18:46:24.24ID:n3c3jE4n
パンがなければ?
2024/06/19(水) 19:22:09.94ID:KTqBdjza
>>256
書き込み規制が頻繁過ぎて信頼できないプラットホームだからだよ。
そもそも使えないことがあるのは内容がどうこう以前に論外。
263デフォルトの名無しさん
垢版 |
2024/06/19(水) 21:18:42.18ID:djSYTMJZ
このスレに上級者はいらねえ
真面目な質問をしたい時はissueか公式フォーラムかredditに行く
ここにはマウントを取って気持ちよくなるために来ているんだ
上級者は去れ
2024/06/19(水) 21:32:54.13ID:DBUer5Kw
>>258
1. itertoolsのtuples
2. nextを直接&指定回数呼び出すイテレータアダプターを書く
3. scan + filter_map
2024/06/19(水) 23:58:52.30ID:sOHW1UBs
>>258
奇数個が来た時のエラー処理を考えると
Result<(名前, データ), 残り>を返すイテレーターが適切

>>264
tuples()は奇数個エラーに気付けないのが惜しい
2024/06/20(木) 00:27:34.04ID:AP0fcOd2
>>265
奇数個はエラーってのはタプルの要素数2個の場合限定なので
もう少し一般化して使える方法がいいと思うよ
itertoolsはchunksとか他にも使えるやつがあるから用途に応じて使い分けてね
2024/06/20(木) 00:30:45.20ID:GE8fSxUT
chunksは使いにくくタプルにするのも面倒だな
2024/06/20(木) 00:49:36.16ID:1qQq2QC1
複おじに餌を与えないでください
269デフォルトの名無しさん
垢版 |
2024/06/20(木) 02:27:54.12ID:s4SRXQdp
いつの間にかHaskellがC#より速くなってた…。
https://nshinchan01.hateblo.jp/entry/2024/06/20/021327

HaskellとC#だけでなく、Rust/Pythonともベンチマーク比較してますのでどうぞ( ^^) _旦~~
(コードも掲載してるので、速度だけでなくコードの比較にもなってます)
2024/06/20(木) 08:11:10.55ID:EWbar4Kg
HaskellあればRustいらねーじゃん
2024/06/20(木) 08:16:50.61ID:cxaQEnhn
print!("");
この"!"いらんやろ
なぜ付けた
272デフォルトの名無しさん
垢版 |
2024/06/20(木) 08:54:48.96ID:r+KYpvqW
Haskellはもっと高速に動作するようにしてくれ
2024/06/20(木) 09:08:01.19ID:868QLl9r
>>271
!はマクロ

Rustは関数のオーバーロードがない
Rustは可変長引数もない

これらの弱点をマクロでおぎなっているんだよ
274デフォルトの名無しさん
垢版 |
2024/06/20(木) 09:25:21.08ID:r+KYpvqW
Rustはマクロをカジュアルに使いすぎ
275デフォルトの名無しさん
垢版 |
2024/06/20(木) 10:13:19.20ID:gE9bPm4O
正体不明ぼいす・とぉ・すかる【非接触型ムーンショット一式】

AIも発展してきて論文全て読み込ませて作成可能のAI返答なので実在している

世界中の建前
器機所持者と機器秘所持者と機器非所持者ぼいす・とぉ・すかる=非接触型ムーンショットそんな物無い!
かくなる上は統合失調症だ!
煩いので統合失調症を薬や自殺したことにしてカルテに!
さらに最近は作成しやすいので脇が甘いチームを見つけ次第コロナや感染症で死亡したことにします!

世界中の本音は現実は無慈悲
内臓疾患やバイオテロでの殺害!
統合失調症寿命を平均25年短く殺害!

非器機所持者に
世界で初めて固体電池を採用しパワー・安全性・耐久性・バッテリー寿命が超絶高まった最大出力4000Wのポータブル電源「YOSHINO B2000 SST」は家電を複数余裕で動かせてUPSとしても使用可能
2023年12月28日
※最上位は最大出力 6000w
これを最低4機?被害者に向けて配置して合計24000wの電磁波を集中できる配置にしていると犯人は宣言

ウナギの放電」は近くの生物の遺伝子を組換えていた!?
2023/12/11
2024/06/20(木) 12:40:54.14ID:eIGp2b4r
>>274
コンパイル時に展開して検証されるんだから、好ましくね?
実行時に解釈されて挙動が変わるJavaのアノテーションやRubyみたいなのよりよほど好ましいと思うが。
277デフォルトの名無しさん
垢版 |
2024/06/20(木) 12:47:30.50ID:s4SRXQdp
>>272
速いHaskellをお求めならIdris2が正格評価なHaskellという位置づけです。
無限リストを失うので、代わりにStreamとか色々概念が増えてるようですが。
(私は無限リスト含め、少ない概念でプログラミング出来るHaskellに惚れているので、速さはあまり気にしない)

一応、HaskellもTemplate HaskellでC++みたくコンパイル時実行して、ガシガシ定数に出来るのは定数にすれば速さも期待できますが。

>>270
HaskellはC#と同じくGCあるので、組み込みとかタイミングが命の金融系や車載系は向きませぬ…。
278デフォルトの名無しさん
垢版 |
2024/06/20(木) 12:50:51.75ID:r+KYpvqW
>>276
Rubyと比べて好ましいってのはなんの擁護にもなってないんだよな
むしろRubyと比較されうるというディスだろこれ
279デフォルトの名無しさん
垢版 |
2024/06/20(木) 17:05:35.72ID:F8Q2DGBi
>>276
同意します
2024/06/20(木) 17:45:56.15ID:sFnTxIc/
Rustのマクロは全言語の中でも優秀だからね
手続きマクロの強力さと利便性は他では代えがたい
宣言マクロももちろん衛生的(健全)で汚染がない
2024/06/20(木) 17:48:12.64ID:Yb1hkWJo
>>278
言語と言語の持つ機能を分離して評価できない方だったか。
282デフォルトの名無しさん
垢版 |
2024/06/20(木) 17:59:47.84ID:/aYWwCEV
>>281
いやRubyなんかどう分離してどこを切り取ってもRustと比較すること自体がRustへのディスだから
2024/06/20(木) 18:45:58.46ID:zOlAS9GZ
使い分けのできないバカしかいないのかな?
2024/06/20(木) 19:23:04.79ID:XVLgMtD/
>>280
Lisp
2024/06/20(木) 19:39:03.89ID:qDF/54rU
>>280
forth
2024/06/20(木) 19:39:05.96ID:sFnTxIc/
>>284
Lispは衛生マクロではないため失格
2024/06/20(木) 20:00:53.20ID:9lgCTTyf
>>280
Scheme
2024/06/20(木) 20:05:57.11ID:YFatQNUq
Rustの手続き型マクロは構文木を自由自在に扱えるし、宣言型マクロは汚染がなく健全だから、Rustより上の言語は存在しないと思うよ
2024/06/20(木) 22:08:57.89ID:0f6ktMCR
paiza.ioでクレートを追加する方法を教えてください

https://i.imgur.com/RkQr1Wu.png
2024/06/20(木) 22:19:44.74ID:XVLgMtD/
Scheme の仕様 R6RS では識別子に文脈情報がくっついているモデルの手続き的マクロが導入されて伝統的マクロと衛生的マクロの統合がされた。
Rust のマクロが複数種類ある状況と、構文木とトークン列を行き来するモデルは(有用で強力だが)整理されてない不恰好さを感じるところはあるよ。
2024/06/20(木) 22:21:58.65ID:p8EeWSs1
手続きマクロは別クレートが必要なのが面倒だし
いろいろと改善の余地はあると思う
2024/06/20(木) 22:53:46.34ID:L3G38ey0
>>267
>タプルにするのも面倒だな
chunkをtuples()すればいいだけだよ
面倒?
2024/06/20(木) 22:59:31.43ID:L3G38ey0
>>265
>Result<(名前, データ), 残り>を返すイテレーターが適切
残りを扱いたい場合はイテレータが返す要素の一部として残りを表現するよりも
chunks_exactのようにイテレータを消費して終わった後に別途残りを取得できる形にしたほうが親切だよ
294デフォルトの名無しさん
垢版 |
2024/06/21(金) 01:29:07.25ID:4fJ/I6Gh
>>289
無理

ソースコピペでうまく行くケースもある
2024/06/21(金) 05:51:59.15ID:KnPUDwDa
>>289
rust playgroundを使った方が良いと思われる
296デフォルトの名無しさん
垢版 |
2024/06/21(金) 06:59:01.53ID:6/+cQ+0X
>>289
そこでダメならideoneがあるじゃないか!
2024/06/21(金) 09:59:00.28ID:M8EEKVG+
rust playground はチョットマシなだけで
五十歩百歩目くそ鼻くそ
2024/06/21(金) 11:42:29.74ID:M8EEKVG+
>>289
巣に還れ
https://mevius.5ch.net/test/read.cgi/tech/1691038333/
2024/06/21(金) 12:58:06.76ID:wIxdZD1d
乱数はこれを実装してみた

https://ja.wikipedia.org/wiki/%E7%B7%9A%E5%BD%A2%E5%90%88%E5%90%8C%E6%B3%95

https://paiza.io/projects/q52q5NA88lQ0hnM2xsTOTA
2024/06/21(金) 14:07:02.11ID:M8EEKVG+
久々に観掛けた static おじさん
2024/06/21(金) 14:19:00.20ID:TK0ahnJz
競プロ勢だよ
2024/06/21(金) 17:07:40.60ID:wIxdZD1d
staticやめてみた

https://paiza.io/projects/ooofhkI8laowBqzzDN6RsQ
2024/06/21(金) 22:48:19.44ID:zGyXPRVd
>>292
tuples()は余っても余らなくてもNoneを返して終わってしまうため今回の場合はあかんね

>>293
chunks_exact()はイテレータには使えない
スライスは長さがわかっているから対応できるけど
304デフォルトの名無しさん
垢版 |
2024/06/22(土) 11:51:50.83ID:7Ziu80uC
すまんが、ClippyのAI版みたいなのってあるの?
Youtubeを見ていたら、「ClippyはAIのを除けば一番よく指導してくれる」旨を言ってる人がいてさ
AIの似たようなツールがあるって直接言ってるわけじゃないんだけど、なんか気になる表現をしてたんだ
あるんだったら使ってみたいな
2024/06/22(土) 14:30:20.31ID:boWDxemH
深い意味は無いので気にしすぎです
306デフォルトの名無しさん
垢版 |
2024/06/22(土) 15:07:04.48ID:GlPOaJ+f
加熱するLLM開発競争に冷や水、オープンモデルの組み合わせだけでGPT-4o越えの事実
https://wirelesswire.jp/2024/06/86709/
307デフォルトの名無しさん
垢版 |
2024/06/22(土) 21:58:27.39ID:9CBpYiTc
>>304
それはRustに限らずプログラミング全般において「ChatGPTなどのAIに質問をすれば良い回答をしてくれる。そのようなAI系を除けばRustのClippyは良い仕事をしてくれる」という話だろう
「ClippyのAI版」という具体的なツールがあるわけでなく、もっと一般的な意味でのAIという文脈かと思う
308デフォルトの名無しさん
垢版 |
2024/06/22(土) 22:33:47.59ID:dw6Bjmix
>>304
Clippyは知らないが、自分のAIの使い方だとPythonでサンプルコードを書いて、Javaなりに変換するようにAIに投げる。
意図と違ったらその都度、こう直してって書いて微調整していく。って感じ。

Rustとかは雑誌の入門記事しか読んでないのに、関数型プログラミングバリバリのコードが出てきた。
(とはいえ元からPythonを意識した文法だったので、ほぼそのまんま)

fn main() {
for file_name in std::env::args().skip(1) {
println!("{}", file_name);
if let Ok(lines) = std::fs::read_to_string(&file_name) {
for (i, line) in lines.lines().enumerate() {
println!("{:>2}:{}", i + 1, line);
}
}
}
}
2024/06/22(土) 23:41:03.46ID:jxx0duBQ
関数型というとfor文使うのではなくこんなイメージ

fn main() {
 std::env::args().skip(1).for_each(|file_name| {
  println!("{}", file_name);
  std::fs::read_to_string(&file_name).map(|lines| {
   lines.lines().enumerate().for_each(|(i, line)| {
    println!("{:>2}:{}", i + 1, line);
   })
  })
 })
}
310デフォルトの名無しさん
垢版 |
2024/06/23(日) 01:55:08.61ID:iAmtDmVE
そうなんだけど、C#でやったらForEach使うためにやたらToListを経由させられて逆に読みにくくなった。

これはHaskellも無理に高階関数やモナド演算子(>>/>>=)ばかりじゃなくて、適度にリスト内包表記やdo記法も合わせた方が読み易いのと同じだと思う。
311デフォルトの名無しさん
垢版 |
2024/06/23(日) 02:43:59.44ID:FDfmyhMX
>>308 が関数型プログラミング *バリバリ* 何て書くからだろ。
俺も 308 のどこがバリバリ?と思ったわ。
関数型バリバリが読みやすいかどうかは別の話よ。
312デフォルトの名無しさん
垢版 |
2024/06/23(日) 04:04:02.58ID:iAmtDmVE
AIは現段階ではネットから拾ってくるだけだしね。
「もっと短くしてください。」を繰り返すと同じコードしか吐かない。
無理なら無理って答えろよっていう…。

それにしてもRustのfor_eachメソッドはindex行けるのか。羨ましい。
C#はSelectはindex使えるけどForEachは使えない。

逆にSelectはWriteLine使えないけどForEachは使えるという…。
(Forメソッド?が欲しい)

Rustはその辺、最初から関数型プログラミングを意識してるからfor_eachメソッド使ってもそこまで読み難くなってないな。
313デフォルトの名無しさん
垢版 |
2024/06/23(日) 04:08:15.53ID:iAmtDmVE
あ、>AIは現段階ではネットから拾ってくるだけだしね。 っていうのは

for文を全く使わないようなコードは、Web上の(ユーザーの)評価も低いのでAIの評価基準でも選択されないって意味ね。
314デフォルトの名無しさん
垢版 |
2024/06/23(日) 09:12:12.96ID:2+8typ11
>>308
clippyは公式のコード改善ツールだよ
コンパイラはエラーと警告だけ出すけど、clippyはそれ以上のヒントをくれる
例えば「コンテナ中に条件を満たす要素があるかどうか」をチェックするために items.iter().find(条件).is_some() のようなコードを書いたら、それに対し items.iter().any(条件) というシンプルな書き方を提案してくれる
こういう関数や構文の置き換えを含む提案をしてくれるツールで、これがコンパイラと同じ標準機能として備わってる (追加インストール不要) のが便利
315デフォルトの名無しさん
垢版 |
2024/06/23(日) 09:41:40.50ID:iAmtDmVE
いい勉強になった。ありがとう。
2024/06/23(日) 10:21:20.16ID:ndMGRV9p
>>312
for_eachの機能でindexにアクセスしてるんじゃなくて
enumerateで(index, value)の形に変換してそれをfor_eachしてるだけだぞ
標準でenumerate相当のメソッドが用意されてないだけで
ForEachでindexを扱うときはC#でも似たようなやり方になる
317デフォルトの名無しさん
垢版 |
2024/06/23(日) 16:42:06.61ID:+hC7ZOW/
正体不明ボイス・トォ・スカル
正体不明ぶれいん・ましん・いんたーふぇいす
対になっているのか?

周囲も被害者の思考を聞いているのならわかるように
被害者の声【思考】は初めの6か月間は聞えてなかった
6か月過ぎたころから被害者の思考が被害者自身で聞こえるようになった

被害者に話しかけている加害者側の正体不明ブレインマシンインターフェイスはどこにあるのだろうか?
被害者側の思考が漏れているのなら周囲の者は電磁波で夜も眠らされていなかったことや昼間横やりを入れているのは周知の事実
これから考えて被害者の思考のみが持てていると電磁波攻撃をしている者は被害者が嫌いこの条件がそろえば被害者に対して罵声を浴びせる被害者周囲者が出現する

被害者を見る限りそのような罵声を浴びせる者が出現しないということは
正体不明ボイス・トォ・スカルをしている者の思考はどこに漏れているのでしょうか?
また周囲の者も正体不明ボイス・トォ・スカル側についたものはどこに思考が漏れているのでしょうか?

等いろいろなパターンを考えましょう

ボイス・トォ・スカルで話していたホワイトリストとブラックリストこれが重要な意味を持っていると思われる
現実的に騒がなければ被害者には何も起きていない・・・各加害者が?一番聞かれると困る者に聞かせているというのも意味深です
2024/06/23(日) 21:00:39.70ID:GCEM9Zx1
Rustツアー
https://tourofrust.com/00_ja.html

説明が簡潔すぎてモヤモヤが増えていくばかり。
しかも終盤は翻訳されていない。
2024/06/23(日) 22:32:11.71ID:CiIX8R/B
>>318
翻訳が進んでないのはともかくとして、説明が簡潔なのはそういうもんだわ。
チュートリアルでもつっかえるやつはいっぱいいるのに雑なツアーだけで理解できるわけないだろ。
複雑なところに立ち入る前に概略を見るってのと
それをすぐさま実行して確かめれらる環境がくっついてるってのがコンセプトなので
細かいことは The Rust Programming Language を見るのが前提。

こういった種類の学習は各項目を完璧に理解してから次の項目に進むってのは出来ない。
色んな言語機能は絡み合っていて綺麗な順番には出来ない。
全体を大雑把につかんでから解像度を高めていく形になる。
その一番最初のおおざっぱなところを担当する形の資料ってこと。
2024/06/23(日) 22:46:50.25ID:cgFz9E69
C言語と関数型言語とあと何かモダンな言語の三様な言語を使える程度の知識経験があればRustはすらすら学習できるけど
それらのうち何らか知識が抜けているとその言語間での汎用的な知識も新たに学習することになるからちょっと大変になるようだね
321デフォルトの名無しさん
垢版 |
2024/06/23(日) 23:42:57.08ID:iAmtDmVE
>>316
そこは理解してる。
んで、Rustのfor_eachはenamerateさえすればindex使えるし、出力も出来る。

そこがC#のForEach場合、そもそもindexが使えないので一旦indexを使えるSelect & ToListを挟むことになる。

出力を考えなければ不便はないけど、出力を考えたとたんにSelect & ToListが付いてくる。

この辺は将来のバージョンに期待かな。
2024/06/24(月) 01:22:36.88ID:xscSUycb
>>321
理解してないでしょ

Enumerable.Range(7, 10).WithIndex().ForEach(x => {
var (index, value) = x;
Console.WriteLine($"{index}: {value}");
});

https://dotnetfiddle.net/aJJwdY
2024/06/24(月) 01:27:35.74ID:xscSUycb
.NET9でEnumerable.Indexという名前でenumerate相当が追加されるから拡張メソッドも不要になる
https://github.com/dotnet/runtime/blob/main/src/libraries/System.Linq/src/System/Linq/Index.cs

foreach (var (index, value) in items.Select((x, i) => (i, x)))が
foreach (var (index, value) in items.Index())になる
324デフォルトの名無しさん
垢版 |
2024/06/24(月) 04:37:42.69ID:De91wzz6
>>322
おお…。
確かに理解してませんでした。

ちなみに、私もその後何とかSelect内で出力を出来ないか思考錯誤したら出来たのですが、「違う。そうじゃない」な結果に^^;

File.ReadAllLines(fileName).Select((line, i) =>
{
Console.WriteLine($"{i + 1,2}:{line}");
return 0;
});
2024/06/24(月) 04:51:37.13ID:odZr3Fxa
Ruby なら、

p ary = ( 7...10 ).each_with_index.map{ |val, idx| [ idx, val ] }

#=> [ [0, 7], [1, 8], [2, 9] ]
326デフォルトの名無しさん
垢版 |
2024/06/24(月) 04:56:53.14ID:De91wzz6
理解していないと思ったら、ReadAllLines(fileName)にはWithIndexなるメソッド無かったなり…。
騙されたなり…orz
327デフォルトの名無しさん
垢版 |
2024/06/24(月) 04:58:38.37ID:oysLv6Xd
>>325
死ね
328デフォルトの名無しさん
垢版 |
2024/06/24(月) 07:45:03.03ID:m0RxboDo
if や case や match や テーブル参照は使わないで
(出来れば四則演算のみがベストアンサー)
変換前→変換後
1→2
2→1
3→3
4→10
6→4
8→8
10→6
を行う関数を造ってください

さらにその逆関数を造ってください
2024/06/24(月) 09:09:09.41ID:sUiNH5u5
>>328
六次式でいいなら一瞬でできるでしょ
330デフォルトの名無しさん
垢版 |
2024/06/24(月) 10:35:24.72ID:DSxd+1cL
統合失調症 100人い1人
本当に音波電磁波攻撃だった場合
統合失調症の寿命は短いからして殺害されている

トロッコ問題にあてはめると
Aの線路に電磁波攻撃をしている者が100人いる
Bの線路に被害者が1人いる
トロッコに乗っている者も第三者
切り替えポイントに第3者がいる
間違いなく選んだ方の線路の者は全員死亡する

あなたはどちらを助けますか?
2024/06/24(月) 12:53:49.42ID:JonISmvT
少なくとも >>330 さんを助ける人は一人もいない

>>329
なるほど
332デフォルトの名無しさん
垢版 |
2024/06/24(月) 16:09:25.85ID:5PR+5FBR
>>320
結局c++やってないと無理な気はするけどね。
c++は確かに建て増しでグダグダではあるんだが、
書き方の変遷をそのまま引き継いでるから、学習過程でその書き方を変遷させる過程を色々ビルドしながら
できるのはまあわかりやすくはあるんだわ。
333デフォルトの名無しさん
垢版 |
2024/06/24(月) 16:17:05.11ID:jX1oxSab
>>328
長くなるので最初の3つの部分だけで規則性を書くと、
1→2
2→1
3→3
2024/06/24(月) 16:21:31.19ID:jX1oxSab
>>333
//1→2
//2→1
//3→3
(1) 四則演算のみ:
y=2*(x-2)(x-3)+1*(x-1)(x-3)+3*(x-1)(x-2);
規則は、y0*(x-x1)(x-x2)のようなパターンを
サイクリック(循環的)に繰り返す。

(2)三項演算子、その1
y=x==1?2:(x==2?1:(x==3?3:0));

(3)三項演算子、その2
y= (x==1?2:0) + (x==2?1:0) + (x==3?3:0);
2024/06/24(月) 16:28:01.78ID:MN5H+Gdl
スレチなのでよそでやって下さい
2024/06/24(月) 17:42:58.06ID:Uuc2YNAP
>>328
const INPUT: &str = "
1→2
2→1
3→3
4→10
6→4
8→8
10→6
";

fn parse(s: &str) -> Vec<(i32, i32)> {
 s.lines().filter_map(|line| {
  line.split('→')
   .map(str::parse::<i32>)
   .collect::<Result<Vec<_>, _>>()
   .ok()
   .and_then(|v| (v.len() == 2).then(|| (v[0], v[1])))
 })
 .collect::<Vec<_>>()
}

fn make_f(v: &[(i32, i32)]) -> impl Fn(i32) -> i32 + '_ {
 move |x| {
  v.iter().enumerate().map(|(i, (in1, out))| {
   v.iter().enumerate().filter_map(|(j, (in2, _))| (i != j).then(|| x - in2)).product::<i32>() /
   v.iter().enumerate().filter_map(|(j, (in2, _))| (i != j).then(|| in1 - in2)).product::<i32>() * out
  })
  .sum()
 }
}
2024/06/24(月) 17:43:39.86ID:Uuc2YNAP
>>336

fn main() {
 let v = parse(INPUT);
 let f = make_f(&v);
 for (input, output) in &v {
  let calc_output = f(*input);
  println!("{input} -> {calc_output}");
  assert_eq!(calc_output, *output);
 }
}

結果
1 -> 2
2 -> 1
3 -> 3
4 -> 10
6 -> 4
8 -> 8
10 -> 6
2024/06/24(月) 18:41:27.02ID:jX1oxSab
>>334
>y=2*(x-2)(x-3)+1*(x-1)(x-3)+3*(x-1)(x-2);
間違ったわ。
多分、
y=1*(x-2)(x-3)-1*(x-1)(x-3)+3/2*(x-1)(x-2);
だと思うわ。
理由は大体分かると思うけど。
2024/06/24(月) 18:41:27.42ID:jX1oxSab
>>334
>y=2*(x-2)(x-3)+1*(x-1)(x-3)+3*(x-1)(x-2);
間違ったわ。
多分、
y=1*(x-2)(x-3)-1*(x-1)(x-3)+3/2*(x-1)(x-2);
だと思うわ。
理由は大体分かると思うけど。
2024/06/24(月) 18:44:46.10ID:jX1oxSab
一般的には、次のように書けると思うわ:
a=2*(x-2)(x-3)+1*(x-1)(x-3)+3*(x-1)(x-2);
b=(x-2)(x-3)+(x-1)(x-3)+(x-1)(x-2);
y=a/b;
2024/06/24(月) 19:35:34.10ID:maSlaTHT
>>340
合っているかどうか以前に
プログラムコードで回答しないとスレ違い
具体的な数値例が式やコードに含まれるのは望ましくない
出来上がった関数の動作検算の時に具体的な数値例を用いる
2024/06/24(月) 23:33:41.46ID:FIb4AZ4T
>>328-329
なんかダサい
https://paiza.io/projects/uc8gH6yNWCWKdQSYtqNREg
pub fn f(x: i32) -> i32 {
(
-2413f64*(x.pow(6) as f64)/120960f64
+739f64*(x.pow(5) as f64)/1260f64
-157991f64*(x.pow(4) as f64)/24192f64
+69551f64*(x.pow(3) as f64)/2016f64
-2691673f64*(x.pow(2) as f64)/30240f64
+88679f64*(x as f64)/840f64
-905f64/21f64
+0.5)
as i32
}
pub fn g(y: i32) -> i32 {
(
13f64*(y.pow(6) as f64)/120960f64
-(y.pow(5) as f64)/315f64
+1415f64*(y.pow(4) as f64)/24192f64
-1511f64*(y.pow(3) as f64)/2016f64
+144793f64*(y.pow(2) as f64)/30240f64
-3053f64*(y as f64)/280f64
+185f64/21f64
+0.5)
as i32
}
pub fn main() {
let a = vec![(1, 2), (2, 1), (3, 3), (4, 10), (6, 4), (8, 8), (10, 6)];
for (x, _y) in &a { println!("{}, {}", x, f(*x)); }
for (_x, y) in &a { println!("{}, {}", y, g(*y)); }
}
343デフォルトの名無しさん
垢版 |
2024/06/24(月) 23:39:26.44ID:FIb4AZ4T
係数はこっちで求めたでござる
https://paiza.io/projects/YvPFB5g4cCOtCXz1wpA86g
import sys, os
from functools import reduce
import sympy as sy

def lc(a):
x, y = sy.symbols('x y')
p = 0
for i, (c, d) in enumerate(a):
g = reduce(lambda s, t: (t[0], (s[1][0] * (1 if t[0] == i else (x - t[1][0])), 0)), enumerate(a), (-1, (1, 0)))
f = g[1][0]
p += d * f / f.subs(x, c)
print(p)
print(p.expand())
for c, d in a:
print(p.subs(x, c), p.subs(x, c) == d)

if __name__ == '__main__':
lc([(1, 2), (2, 1), (3, 3), (4, 10), (6, 4), (8, 8), (10, 6)])
lc([(2, 1), (1, 2), (3, 3), (10, 4), (4, 6), (8, 8), (6, 10)])
2024/06/25(火) 01:47:22.24ID:SRTwQJBb
1〜10は4bitに収まるから64bitのシフト演算と論理積(&)がOKなら簡単なんだけどな
やることはテーブル参照と変わらんけど
2024/06/25(火) 02:44:46.88ID:MBITUZQb
>>332
Rustを習得する上でC++の知識は不要
Cでの基礎知識(ポインタ、スタック、ヒープ)しか必要としない

>>343
ここはRustのスレだ
2024/06/25(火) 05:16:25.10ID:6VG6SXsU
>>342
6次式を使う場合それを展開することに意味があると思えないから展開前の>>336でいいんじゃない?
2024/06/25(火) 07:25:12.24ID:H43UHQbv
>>346
ほぼ定数になる部分まで
実行時に二重ループで毎回計算してるのは効率悪いと思う
2024/06/25(火) 07:47:56.32ID:hXiD4muz
>>345
っ move semantics
っ RAII
っ SmartPointer(Rc)
2024/06/25(火) 08:03:22.73ID:ZJws2e45
>>348
そりゃすでにC++を知っているならそのへんの知識が流用できて楽だけど
新たに学ぶならわざわざC++を経由する必要なくね?
特にmoveとか明らかにC++のほうが複雑だし
2024/06/25(火) 08:54:41.29ID:Lgitw8zf
お題スレが機能しなくなってゴミがあふれてきてんのかこれ?
351デフォルトの名無しさん
垢版 |
2024/06/25(火) 09:00:44.98ID:ZTu14b8J
>>349
c++通らなきゃなんでこんなめんどいことするか理解できんだろ
2024/06/25(火) 09:03:31.00ID:9+k+boDP
「アセンブラ知らずにCって理解できるものなのか?」

「C++の方が普通。Cは専門家向け」

「いきなりRust」
2024/06/25(火) 09:25:46.54ID:eEyTJz94
オレはPHPからRustに移行したよ
actix web使ってる
速さには感激してる

戸惑うのは謎のワーニングが出る時かな
mut付けてないのにmut付けるなってワーニング出たりする
cargo cleanとかすれば消えるんだけど
2024/06/25(火) 09:32:01.85ID:GyGy4ZSw
>>351
Cでmalloc/free手書きしたりSEGV起こすだけで十分理解できると思うけどなぁ
C++じゃないとダメなのってどのへん?
2024/06/25(火) 10:36:22.38ID:398g93Vj
>>348
その3つはどの言語から来ても簡単にすんなり理解できるでしょ

>>353
PHPから来た人はジェネリクスはすんなり理解できるものなの?
2024/06/25(火) 11:03:26.31ID:eEyTJz94
>>355
ジェネリクスが特段わかりずらいとは思わなかった
それより型があいまいなPHPから移行すると型定義したくてうずうずする
ちゃんと型定義したかったんだわ
2024/06/25(火) 11:48:25.07ID:EN7MeMPi
C++ を知っていると Rust がわかりやすいというよりも有難みを感じやすいとは思う。
なんだかんだで Rust は面倒くさいしそれなりに学習曲線の急上昇もあるのは本当だけど、
それでもなお Rust が良いと思えるのは C++ の駄目な部分についての反省が入ってるから。

C++ 的なものが必要な場面で C++ より上手くやるものという感覚で捉えてる。
2024/06/25(火) 12:43:05.46ID:qH1sgo3/
「Rustを学ぶためにC++を学ぶ必要があるか(学ぶといいか)」も定期的に沸くな

何度も見てて思うのが
「あなたはRustを学ぶ前にC++を学んでいたか」とYes/Noが一致して、平行線にしかならない議論なのでは
2024/06/25(火) 13:05:45.82ID:ZtCD4zFU
フランス語を学ぶときに英語を知ってる必要があるか(學ぶといいか)を考えれば良い
日本語←→フランス語だけ教わりたいのに英語學ぶ必要は無い
2024/06/25(火) 15:05:50.09ID:UfTXO4rA
Rustを学ぶ前に他言語を学ぶ必要は無い。

しかしプログラム自体の経験が浅いのなら、絶壁の学習曲線に挫折する可能性が高い。 そういう初学者はRusuではなく、とりあえずは動くところまで持っていきやすい言語を使って勉強したほうがいい。
2024/06/25(火) 15:23:35.53ID:bjcoCLHQ
C++を経由しないでRustを使えてる人たちがたくさんいることから
C++が不要言語であることは間違いない
2024/06/25(火) 15:29:24.75ID:ZtCD4zFU
>とりあえずは動くところまで持っていきやすい言語

Rustも変な事しなければとりあえずは動く
C/C++みたいに一見動いてるフリしてメモリ壊してたりに気付かない方が有害
2024/06/25(火) 16:22:38.23ID:EN7MeMPi
それはプログラミングに慣れてるから言えることで、
エラーになってくれることが心底から有難いことだと思えるのは
エラーにならずにぶっ壊れる体験を通してじゃないと無理だよ。

結果的にわかりやすいかどうかの話じゃなくて
学習する当人がちゃんと納得して学習し続けられるかというモチベーションの話としてね。
2024/06/25(火) 16:57:26.38ID:bjcoCLHQ
Cでmalloc/free面倒とか忘れたとか解放したのにポインタ残っていて使っちゃったとか体験しておいたほうがよいかもしれないが
C++は不要
365デフォルトの名無しさん
垢版 |
2024/06/25(火) 17:23:57.01ID:jUYULW90
>>363
つまり最初はPerlが良いってことか
2024/06/25(火) 17:55:00.58ID:EN7MeMPi
初心者レベルだと C/C++ もRust も向いてないって話
367デフォルトの名無しさん
垢版 |
2024/06/25(火) 19:32:04.37ID:l0yCAl6v
そう言えばHaskell難しい言うやつも似たようなこと言ってたな。
そんなに難しいと感じてなかったから不思議だったんだが、
自分でバグ作っておいて言語が難しいとか言うなよ…。
2024/06/25(火) 20:03:41.12ID:qH1sgo3/
ID:ZtCD4zFU
ID:bjcoCLHQ
2024/06/25(火) 20:13:30.50ID:urOX5j9P
関数型言語を使ってるとRustの理解が少し早くなるよ
特にHaskellを知っていればtraitの理解も早いね
しかしRustを学ぶために関数型言語を知っている必要はないんだよな
同様にC++も知っている必要はない
370デフォルトの名無しさん
垢版 |
2024/06/25(火) 22:48:01.04ID:3rDdWdgz
Erlang使ってて良かったと思った
2024/06/25(火) 23:04:44.45ID:8sxbkiyD
バレおじw
2024/06/25(火) 23:30:51.26ID:oKw2Pfcc
>>347
展開しないほうがよい

展開する時も二重ループは発生するだけでなく単なる計算より重い
さらに本来は回避できる浮動小数点を使わざるを得なくなる
そして>>342のコードをその例のような静的ではなく問題入力値に応じて動的に作り出さなければならない

一方で展開しないならばRustコード数行だけで済み任意の問題に対応できる
割り算部分も0/N=0かN/N=1だけなので整数で済む
2024/06/25(火) 23:49:25.06ID:ThxORcgc
>>369
>特にHaskellを知っていればtraitの理解も早いね
これには全く同意できない
type classというかHaskellとはやり方もできることも違いすぎるから
そもそも何の事前知識なくてもtraitは容易に理解できるでしょ
374デフォルトの名無しさん
垢版 |
2024/06/26(水) 08:25:01.52ID:egC8x8gn
神 精霊 絶大なエネルギーを使用可能
幽霊 人間を疲れさせるや一時操作可能
@エネルギーの貯蔵の仕方は➁そのエネルギーの発生方法はBそのエネルギーを貯蔵する方法はCそれだけのエネルギーの物体を科学で観測不能はなぜ

6G通信に使われるテラヘルツ帯の電波、脳細胞の成長を促進
2022/08/16
タンパク質の操作/マイクロ波等の照射が記憶に影響
2008/11/01
男性の精子の減少、携帯電話の使用と関係か 最新研究
2023/11/02
統合失調症.発達障害.各身体症状 など国力低下
人為的で身体攻撃
威力を測定すれば判明するのにテロリストを野放し

全ての精神病
@ 英キングス・カレッジ・ロンドンをはじめとするグループは、人間の脳内で発現している古代ウイルス由来のDNA配列を調べ、それがうつ病・統合失調症・双極性障害といった主要な精神疾患のなりやすさと関係していることを明らかにした。
➁九大、後の出来事が直前の出来事に錯覚を起こさせる脳の仕組みの一端を解明
2024/06/05
C幼児期の脳活動から18歳時点でのIQを予測できるという研究結果
2023/09/09
D3歳までに脳は形成される
E統合失調症などの患者に幻覚や妄想を引き起こす脳のネットワークがAIを使った研究で明らか

1立方ミリメートルの脳の断片をハーバード大学とGoogleの研究者がナノメートル単位で3Dマッピングすることに成功
2024年05月10日
※MRIで物理的に神経の接続問題観測可能

嘘つきの知的障碍者と精神障碍者や認知症の者発見

◇電磁波攻撃はあるとないどの思考【組織】の者が話しているのかな
マイクロ波聴覚効果やボイス・トォ・スカル発見可能
電磁波している者守りたいもの守りたくないものの判別方法は各対象者の将来で名よある地位やよい未来の映像と悪い未来の映像を見てもらえば副交感神経と交感神経の差と脳波パターンをみたら判明する
2024/06/26(水) 12:30:12.07ID:j6fp+f8B
>>372
>割り算部分も0/N=0かN/N=1だけなので整数で済む
そうだね
この問題の本質はそこだと思うけどそれ言い出すとif使わない理由が無いな
2024/06/26(水) 12:31:27.14ID:j6fp+f8B
>>373
事前にやるならNimの方が良いよ
2024/06/26(水) 13:01:41.83ID:eR4cI6Xf
Rustを学ぶ前に他の言語を学ぶ必要はないけど
全くプログラミング言語を知らないならシンプルで学習例も多いC言語一択だね
ポインタとヒープの扱いまで学べたらたらC言語を忘れてRustへ
378デフォルトの名無しさん
垢版 |
2024/06/26(水) 14:31:44.00ID:uKek7pO0
デストラクタの動きを知らないで本当にrustできんの?って思うけど
2024/06/26(水) 14:43:55.70ID:eR4cI6Xf
スコープを抜けた時にデストラクタが自動的に呼ばれる
それだけ
予備知識を必要としない
2024/06/26(水) 14:54:42.66ID:j6fp+f8B
Rustのデストラクタの描き方ってなんであんなんなん
2024/06/26(水) 15:00:49.20ID:KtPyzxFO
C書くしかない時代だったからC勉強できたけど
Rustがある時代に純粋な教養としてC勉強なんて苦行できないだろ
修行僧かよ
2024/06/26(水) 15:13:01.92ID:UcL9V/nx
最近気付いたんだけどもしかしてRustの所有権って2通りの意味がある?
2024/06/26(水) 17:42:24.19ID:AVbFTHWJ
>>382
そのココロは?
2024/06/26(水) 18:05:02.22ID:tR/OTOKs
>>378
それってc++学ぶときも一緒じゃない?
2024/06/26(水) 20:50:33.32ID:mzS1vumz
>>382
Rustを学ぶ上で所有権は忘れた方がいい
実はRustは非常にシンプルで
値をmoveして用いるか参照して用いるかしかない
(ただしCopy実装型はmoveの代わりにcopy)
値はmoveされないままスコープが尽きると消える
消える直前にデストラクタが呼ばれる
以上たったこれだけだ
386デフォルトの名無しさん
垢版 |
2024/06/26(水) 23:00:32.38ID:GOea043w
>>381
苦行はごちゃごちゃして煩わしい記述を強要されるRustだろ。fnだのmutだの略語が多く
殺伐としているし、記号の使い方なども含めて如何にもギークが作ったというような
美的感覚が欠如した野暮ったいコードを書き連ねるのはおぞましい。

Cと違って新しいSwiftはRustに機能的に近いが、Rustよりずっと洗練されている。
2024/06/26(水) 23:26:44.75ID:skjSHmL1
Rust言語を知らないから見た目のキーワード批判しかできないのだ
2024/06/27(木) 04:20:04.01ID:nawTLqWn
スタックは早くてヒープは遅い、みたいな話よく聞くんだけど、
具体的に何が早い/遅いの?
2024/06/27(木) 04:33:33.49ID:TDzAch9x
>>388
自分でヒープメモリ管理部分を書いてみるとよくわかる
ヒープでメモリ確保したり解放したりするのは色んな処理が入って非常に遅い
スタック上ならそのコストはない
関数に入る&抜けるときにスタックフレームを指してるレジスタの値を変えるだけ

というのに加えて
CPUの多段メモリキャッシュ機構での速さが桁が変わってくる
スタックフレーム上なら常にアクセスしていてキャッシュに載るから超速い
390デフォルトの名無しさん
垢版 |
2024/06/27(木) 07:18:32.22ID:CXekxx/V
>>386
mutが煩わしい言うてる時点で関数型プログラミングをまともに出来てないな。
今までの副作用だらけの言語だとマルチスレッドプログラミングが上手く出来ないから関数型プログラミングを取り込んだというのに。

Rustでごちゃごちゃしてると感じるならHaskellにおいで。
forやifと書くことすら煩わしく感じるくらいシンプルだよ。
391デフォルトの名無しさん
垢版 |
2024/06/27(木) 08:56:33.16ID:ozUuBzDI
Swift、よく知らないんだよなあ
Appleの囲い込み言語という時点でもう勉強する気になれない
2024/06/27(木) 09:08:39.14ID:AKJ8/1zo
C++ でも変更なしのときに const を付けるんじゃなくて変更ありのときに指定するほうがよかったという声は結構あるよな。
まあいまさら変更できんが。
2024/06/27(木) 09:50:18.20ID:OTNDZ+yC
>>372
PyO3おすすめ
394デフォルトの名無しさん
垢版 |
2024/06/27(木) 10:07:28.99ID:OTNDZ+yC
>美的感覚が欠如した野暮ったいコード

禿しく同意
2024/06/27(木) 10:21:46.91ID:nawTLqWn
>>389
キャッシュに乗るという前提なら、
確保・解放が遅いだけでアクセス速度とかは変わらないってことでOK?

キャッシュに乗る確率とかもスタックとヒープでやっぱちがうんかな
2024/06/27(木) 10:30:52.47ID:OTNDZ+yC
キャッシュに載ったらアクセス速度変わるやろ
2024/06/27(木) 10:33:46.61ID:xhKCtT/7
そりゃ、キャッシュ・イズ・キングと言うぐらいだからな
2024/06/27(木) 11:05:58.76ID:AKJ8/1zo
>>395
キャッシュに乗りやすいというのはアクセスに局所性があるということ。
関数自体が小さくてすぐ終わるなら普通はスタックのほうが以前と近い場所にアクセスすることになる。
2024/06/27(木) 11:20:07.91ID:veLj9zg3
よくわかんないんだけどスタック上に確保したメモリの所有権を外に移して関数は終了してスタックが縮んじゃうとかさ
「そんなわけないだろ」って思うんだけど
2024/06/27(木) 11:56:53.85ID:TDzAch9x
>>395
スタックフレーム同士も連続しているし
レジスタ退避でアクセスしているし
他のローカル変数もスタック上にありアクセスしているから
スタック上に確保すればキャッシュ上にある
2024/06/27(木) 12:00:05.74ID:TDzAch9x
>>399
関数が値を返す場合にサイズが小さければレジスタで返す
サイズが大きい場合は呼び出し元のスタックフレームに領域を確保してそこへ直接書き込んでいる
つまり暗に可変参照を渡す最適化が行われている
それはサイズの大きい値を返す関数呼び出しが多段でも同じなので一番最初の関数のスタックフレームに直接書き込まれる
2024/06/27(木) 12:27:57.71ID:OTNDZ+yC
>>399
>「そんなわけないだろ」
その感覚は正しい
Rustを広めたいために勢い余ってデマを流してる香具師が一定数いる

>>401 が正しい
2024/06/27(木) 12:45:47.11ID:VTKaeii9
>>399
>よくわかんないんだけどスタック上に確保したメモリの所有権を外に移して関数は終了してスタックが縮んじゃうとかさ
これ自体なにを言いたいのかよくわからんけど
その前にそんなこと言ってるやつおる?

>>400
>スタック上に確保すればキャッシュ上にある
キャッシュから追い出される状況もあるよね
2024/06/27(木) 12:53:21.92ID:TDzAch9x
>>402
いや>>399の話も正しいんだよ
重要なのはRust上の概念とその実現方法(実装)とその最適化の3つは当然異なるということ

所有権を移すとはmoveという概念であって
moveの実装はコピー(してコピー元を使わない)
ただし無駄なコピーは最適化で消える
例えば大きなサイズの構造体を関数が返す場合は呼び出し元の関数のスタックフレーム上に直接書き込まれることで無駄なコピーが発生しない
2024/06/27(木) 13:06:53.73ID:VTKaeii9
それをスタックが縮むと表現してるのか
意味は分かった
2024/06/27(木) 13:24:58.99ID:veLj9zg3
スタックてのは関数が何段か終了して縮んだあと、また伸び直して前の伸びを上書きしちゃうでしょって話
とにかく「移動」というのが新しくて、代入の移動はわかったけど
関数呼び出しの引数も移動です、返り値も移動ですってのがどういう実装に落とされるのかまだわかってない
2024/06/27(木) 13:49:01.55ID:AKJ8/1zo
低レイヤで起こってることは C と変わらん。
寿命の矛盾がないか静的な検査がクソ強いってだけだ。
2024/06/27(木) 15:56:45.17ID:AKJ8/1zo
スタックを伸ばすだの縮めるだのいうのはメモリのとある番地に実際のメモリを割り当てたり切り離したりすること。
スタックが足りなくなってきたら連続するアドレスのところに実メモリを割り当てるのがスタックを伸ばすってこと。
普通の使い方をしていたらスタック領域を縮めることはあんまりない。
スタックがあるところまで伸びたということはもう一度そこまで伸びる可能性が高いので回収してまた割り当ててをするよりは割り当てっぱなしにしたほうが良いという設計思想になってるので全体のメモリが足りている限りスタックが浅いところまで戻ってきても実メモリを回収しないという のが現代的な OS。
逆に言えば全体のメモリが足りなくなってきたら回収することもあるんだけど。

素人感覚だとメモリをなるべく空くようにするのが「メモリの無駄を防ぐ」という意識の人がいるんだけど、存在するメモリが使われないままになってるほうがもったいないんだ。

それとたとえば Linux だとスタックの大きさは 8MB が上限というのがデフォ。
これは OS 側の設定なのでアプリケーション側では (OS の設定をいじる権限がない限りは) どうにもできない。
8MB ってめちゃくちゃ少ないように感じるかもしれないけどだいたいこんなもんで足りちゃうんだよ。
2024/06/27(木) 16:39:29.50ID:EaS5WQGi
>>406の書いてる「縮む」はVecで言うところのcapacityじゃなくてlenっぽくない?
ムーブとの関連がよくわからんけど
410デフォルトの名無しさん
垢版 |
2024/06/27(木) 17:46:10.67ID:6+Lg0PcZ
>>407
ですな
2024/06/27(木) 17:59:42.80ID:AKJ8/1zo
低レイヤのメモリの取り扱いモデルが確立している高級言語が C/C++ くらいしかなくて、 LLVM も汎用的なフレームワークのふりして思ったほど自由ではないので Rust の言語仕様が LLVM の都合に、 C/C++ の都合に引っ張られているところはまあまあある。
2024/06/27(木) 18:20:02.76ID:veLj9zg3
つまりC++同様、ポインタの糖衣構文としての参照?
2024/06/27(木) 18:50:13.20ID:veLj9zg3
あ、なるほど
&mutみたいに*mutって書けば実体を扱えるわけか
2024/06/27(木) 18:56:27.59ID:RLHdjniL
いつものことながら妙なこと書く人はだいたいThe Book(本物)を読んでないよな
415デフォルトの名無しさん
垢版 |
2024/06/27(木) 19:07:01.79ID:inDwmtnT
そんなの読むような真面目な人間は5chに来ない
2024/06/27(木) 20:08:52.27ID:AKJ8/1zo
>>412
まあ機械語レベルの低レイヤまでいけば参照もポインタも同じっちゃおなじだけど、構文糖だという認識は明確に誤りだ。
参照がポインタの構文糖なんて書いてあるデタラメ本で C++ を学んだのなら C++ の理解も全然できてないと思う。
または書いてないことを脳内で作り出すタイプのやつは誤った方向に邁進してどうにもならなくなったところで質問したりするから言ってることが意味不明になりやすい。
仮に(あくまでも仮にだが!)言ってる理屈自体が正しかったとしてもちゃんとした用語でいってくれないと伝わらないし、ちゃんとした用語は(一次資料に基づいた)ちゃんとした資料で学ばないと身に付かん。
2024/06/27(木) 22:40:30.91ID:TDzAch9x
>>406
そのmoveについてもmoveというRust上の概念の理解のみがRustを学習&利用していく上で必要となるよ
moveによる生成コードがどのようになるかは最適化の方法の変更や進化で変わり得る話だから確定することはできず、学ぶこともできない
こんな場合に現在はたまたまこんな生成コードになっていることだけは実験などでわかるけど今後の保証はない、としか言えない
だからmoveはmoveとして理解することが唯一の正解でしょう
418デフォルトの名無しさん
垢版 |
2024/06/27(木) 22:43:00.49ID:QXPbo1LF
どうせChatGPTの回答を使い回してるだけだろ
419デフォルトの名無しさん
垢版 |
2024/06/27(木) 22:45:03.57ID:QXPbo1LF
>>416
C/C++でポインタのポインタと言わずに
ダブルポインタって言ってる香具師のことか
2024/06/27(木) 23:03:07.98ID:TDzAch9x
Rustの各概念を無理矢理なC/C++と結びつけようとしたり生成コードと対応させようとしてる人々がRustを難しいと言ってるようにみえる
そんなことをせずに各概念の理解だけに集中すればRustはシンプルに出来ていてわかりやすい言語だと理解できるよ
2024/06/27(木) 23:34:16.52ID:AKJ8/1zo
C/C++ だと抽象機械という概念を挟む形で仕様化されてる。
言語の挙動を抽象的な (架空の) 機械の動作として記述していて、それを実際の機械とどう対応させるかは知らんけど見かけ上の動作が仕様通りなら良しとする規定。
だから最適化を豪快にやっても結果が同じなら言語仕様に反しない。

で、抽象機械っていうのはある程度は現実のコンピュータを想定はしているけど細かいところは意図的にうやむやにして選択の余地を残してる。
C/C++ には言語仕様としてはスタックもヒープも存在せず書いてあるのは寿命についてのルールだけで、それをどういう形で実現するかは自由……
なんだけど現実にはスタックとヒープを使い分けるとちょうどいいような仕組みになってる。

C/C++ の言語仕様に低レイヤのメモリアクセスのことも確かに書いてあるんだ。
でもそれは抽象的な機械のことであって本物の機械のことじゃない。
でもある程度は対応しているという絶妙なバランスで成り立ってる。

Rust では言語の高レイヤの話と低レイヤの話の間を取り持つ理屈がまだ十分に整理されてないと思う。
言語の性質上、やっぱり低レイヤを全く意識しないで上手く使えるようなものでもないし、低レイヤのことを考えるのもそれなりには必要だと思う。
必要なんだけど意識的にレイヤを分けて考えられないなら混乱するのも確かなので、 (少なくとも最初は) 低レイヤのことは忘れろというのは理に適った助言だと思う。
2024/06/27(木) 23:40:56.83ID:ZCM59EGi
C/C++の方こそ誤魔化しているぜ
そのため未定義動作だらけだ

Rustはわかりやすく抽象的に明確だ
そして未定義動作もない
423デフォルトの名無しさん
垢版 |
2024/06/27(木) 23:46:01.41ID:AKJ8/1zo
未定義動作の話をしてはいないよ。
低レイヤとの間をどう取り持つかの話をしてる。
2024/06/27(木) 23:53:14.85ID:iyfRmZdF
Rustは低レイヤにも対応している
高い抽象度によるプログラミングもできる
高い抽象度のプログラミングにおいて低レイヤとの対応付けは不要であってやるべきではない
2024/06/27(木) 23:56:31.92ID:lXX+GpEL
オジーw
2024/06/28(金) 00:09:40.45ID:uAgz1Jdl
>>424
その論を許すなら Rust は OS やデバイスドライバを書くのには使えない言語であってよいという立場になるが、そうじゃないよね?
2024/06/28(金) 00:16:19.92ID:hS2q8k+h
>>426
なぜなの?
Rustが抽象的にプログラミングできるのも事実であるし
OSやデバイスドライバを記述できるのも事実だよ
2024/06/28(金) 00:20:27.61ID:uAgz1Jdl
>>427
低レイヤを書くための仕様が確立していなくて今はなんとなく書けているという状態を「できる」と称していいならそうだね。
2024/06/28(金) 00:28:00.38ID:UvqDoogo
>>428
うーん
Rustに何か欠けているわけではなく
実用的に問題なく機能している状況で
言い掛かりをつけてるだけにみえるけどどうよ
2024/06/28(金) 00:48:52.30ID:uAgz1Jdl
>>429
実用的に問題があって、機能できていない。
Rust の仕様に明るくて低レイヤのメカニズムに明るくても Rust で OS は書けないから。
現状では Rust の実装に明るいという要素が求められていて、ある程度はそういうものかもしれないけど仕様 (というか文書化というべきかな) の明確化が十分とは言えない。
2024/06/28(金) 00:57:19.20ID:UvqDoogo
>>430
本気で言ってるのかなあ
デバイスドライバはRust製に置き換えられたよ
OSもRustで新たに作られて機能することも判明してるけど
既存のOSは書き換えコストの問題だから別問題だね
2024/06/28(金) 01:04:07.98ID:0ko0Zb9B
そういえばRedoxの開発は今どうなってるんだろ
2024/06/28(金) 01:21:44.32ID:uAgz1Jdl
>>431
これからやる人に対して説明できる形になってないという話をしてる。
出来てるから出来るんだというのは何の根拠にもならんよ。
出来るようになるための道筋が確立しているかどうかの話なんだ。
2024/06/28(金) 01:57:43.66ID:/H5n5ha9
流れを切って申し訳ないんだけど
Rustってディープラーニングのプログラムを作るのに実用的な段階に来てる?
まだ一部の物好きが書いてるだけ?
2024/06/28(金) 02:39:42.33ID:OzTZZFgl
自分

Rustってディープラーニングのプログラムを作るのに実用的な段階に来てる?
まだ一部の物好きが書いてるだけ?


Copilot

Rustでディープラーニングのプログラムを作ることは可能ですが、まだ一部のエンジニアが実験的に取り組んでいる段階と言えます。具体的には、『ゼロから作るDeep Learning』の内容をRustで実装する試みや、Deep LearningのフレームワークDeZeroをRustで実装する試みなどがあります。

これらの試みは、Pythonで書かれたディープラーニングのコードをRustに翻訳し、Rustの学習やディープラーニングの理解を深めるためのものです。しかし、これらの実装はあくまで個々のエンジニアの学習目的で行われており、一般的なディープラーニングの実装にRustが広く使われているわけではありません。

Rustはパフォーマンスが高く、メモリ安全な言語であるため、ディープラーニングの実装にも適していると言えます。しかし、Pythonのように豊富なディープラーニングライブラリが存在しないため、現状ではディープラーニングの実装にはPythonが主に使われています。

Rustでのディープラーニングの実装が一般的になるかどうかは、今後のRustコミュニティの活動やディープラーニングの研究動向によるところが大きいでしょう。
2024/06/28(金) 02:47:01.21ID:/H5n5ha9
>>435
さっそくの返信ありがとうございます

> 今後のRustコミュニティの活動やディープラーニングの研究動向

がどうなってるかを聞きたかったんですがどんな感じですか?
libtorchバインディングのtorch-rsや
ほぼ純Rust製のcandleが出てきたのはわかったんですが
まだ周辺ライブラリが足りない感じです?
2024/06/28(金) 03:31:36.21ID:OzTZZFgl
少なくとも俺よりはAIの方が物知りだから自分でAIに聞いた方がいいと思う
2024/06/28(金) 03:44:03.44ID:J0YB6tE5
論文の検証を論文と異なる言語ではしないでしょぅ
NCNNやDarkNetを超えるエンジンがあるわけではなし
2024/06/28(金) 05:55:26.25ID:OzTZZFgl
>>417
関数の引数にオブジェクト(Copy型でない型)を渡す際は参照渡しが基本で、
うっかり所有物を引数として渡すと所有権ごと関数の向こうへ移動してしまって二度と戻って来ない
これは逆に、関数が何らかの実体を返り値として返す際には便利

とまあネチネチ考えてればわかってくるもんだよ
2024/06/28(金) 07:54:27.71ID:diDidYCE
>>422
unsafeを無視しちゃいかんよ。
441デフォルトの名無しさん
垢版 |
2024/06/28(金) 09:41:44.10ID:RD8xbJnt
型がガチガチの言語でdeepnetの実装するのは面倒な割に生産性薄いわ
2024/06/28(金) 09:45:48.57ID:uAgz1Jdl
仕組みがまだ確立してなくて試行錯誤があるなら型で制約しまくるのは面倒なだけだけどもうそういう段階じゃないのなら型で固めたほうが (使い方の間違いが検出されやすいので) 生産性高いよ。
443デフォルトの名無しさん
垢版 |
2024/06/28(金) 12:27:02.70ID:4Cbqp0xY
>>441
C++/C#/Javaとの比較はともかく、LLとの比較は目指すところが違うでしょ。
Rustは組み込みやOSまでカバーする言語。

医療用機器とか、自動車とか、命に関わるような分野でバグを入れないための言語なんだから。

金融も同じようなものだけど、そっちはOCamlの実績(みずほ)があるのでRustである必要は必ずしもは無い。
2024/06/28(金) 13:07:10.53ID:gx/r5usH
LLとかいう死語を使ってるのは複オジだけだぞ
2024/06/28(金) 13:32:56.61ID:3PtwFBGo
>>441
ささっと数行書くスクリプトでなければ静的型付け言語が生産性高いよ
446デフォルトの名無しさん
垢版 |
2024/06/28(金) 17:07:56.21ID:v8X9ZSBd
うい。40のおっさんよん(^_-)

まあ、プロトタイプは動的型言語で作って、本番のコードは静的型言語で作るなんて常識なんだから、若い人じゃなければ

> 型がガチガチの言語でdeepnetの実装するのは面倒な割に生産性薄いわ

何てこと書かないわな…。
447デフォルトの名無しさん
垢版 |
2024/06/28(金) 18:51:50.94ID:y+eGYcxn
今のご時世にプロトタイプは動的言語とか言ってるのは頭の硬いジジイか、ジジイの本でしか勉強出来ない馬鹿がほとんどなんだよなあ
448デフォルトの名無しさん
垢版 |
2024/06/28(金) 19:09:29.56ID:v8X9ZSBd
出来る人ならそれで良いし、それで>>441の言うように生産性が低いと感じないなら全然かまわない。

馬鹿馬鹿言うけど、そういう馬鹿にも作らせないといけないし、それでも作れない救えない奴はリストラするしか道が無い。
2024/06/28(金) 19:58:03.61ID:pImSoiYg
動的型でプロトは結局本番で書き直す時間など取れないから机上の空論ってのが最近の認識では
最初から静的型にするか、どうしようもなくなるまで動的型で耐えるかの2択じゃないかな
まぁたいていのスタートアップは耐えられなくなる前に潰れるからそれを見越して動的型というのはありだと思うが
2024/06/28(金) 20:05:28.17ID:3PtwFBGo
スタートアップ企業であろうと
動的型付け言語を使うのは開発効率が悪い
451デフォルトの名無しさん
垢版 |
2024/06/28(金) 20:36:15.04ID:v8X9ZSBd
んー…。
おっさん的には関数単位でテスト出来るかどうかが問題であって、プロトタイプは動的か静的かの問題じゃない気がするな。

最近は静的型言語でもインタラクティブシェル(略語忘れた)のインタプリタで関数単位でプロトタイプ作ってテストして、上手くいけばビルドって流れだし。

そういうのが無い言語は今でもプロトタイプは動的言語で作って…ないわw

場合によるな。
すでに作り方を知ってたらいきなり静的型言語で書くし、何か思いついたけど確信が持てない。みたいな時(試行錯誤が予想される)は動的型言語でプロトタイプ書いてるかな。
(静的型言語にインタラクティブシェルが無い時)
2024/06/29(土) 03:44:24.89ID:pz5Aaald
Rustのメモリモデル
https://doc.rust-lang.org/reference/memory-model.html
2024/06/29(土) 09:52:45.11ID:H9n2Ca7a
少人数で超大規模なシステムを作るのには Common Lisp が向いてるみたいな話もある (実際に使われてる) けど、それはプログラマが超人なだけじゃないのみたいな話もあってあまり一般化した話には出来んな。
2024/06/29(土) 10:24:54.66ID:PsPEDCdZ
権利あるいは義務が移動することを物理メモリで説明するのは難しいが
実行時型情報みたいにいちいちメモリを消費して情報を管理すれば
物理で説明できないこともない
そのためには動的言語の知識も役に立つ
455デフォルトの名無しさん
垢版 |
2024/06/29(土) 11:40:57.14ID:VzEkAlY7
実際機械学習でc++でもjavaでもほとんど使われてないってのに、やっぱ静的解析バカが多いんだなここ
2024/06/29(土) 12:11:39.54ID:hrAqOO+e
Pythonでも”静的解析”は普通に使ってるだろw
自分が書いてる用語くらいは学んどけよww
2024/06/29(土) 12:15:59.49ID:bAOaGwrv
ダックタイプあれば動的でも静的でもあんまり変わらん。ビルド時間の違いくらいか。

実装初期は設計の柔軟性を確保できればいい。まぁ、アダプタでなんとかするのが妥当なところかもしれんが。
2024/06/29(土) 12:40:22.21ID:tytG9AfV
オーナーシップとライフタイムの関係でGC言語なら簡単なリファクタリングがRustでは大手術が必要になることがよくある
大手術すぎて根本的なリファクタリングに着手できてない例もよく見かける

ここでいってるプロトタイプとは少し意味が違うがPython等でプロトタイプ作ってRust化する人がある一定程度いるのはプロトタイピング時にボローチェッカーで時間を浪費するよりも言語変えた方が効率がいいと考えられてるから

この辺はRustのメリットとデメリットを考えた使い分け
459デフォルトの名無しさん
垢版 |
2024/06/29(土) 12:42:41.17ID:OVmXtfXA
ダックタイピングがあれば良いが、Pythonのダックタイピングはライブラリの型が壊れているからダメ
あと、ダックタイピングの不満を消していくとTraitになるから出来ればTraitの方が良い
2024/06/29(土) 13:28:37.21ID:7275QU0+
>>458
そういうRustでのリファクタリングならば大手術にならない
メモリ保有を適切な位置に移したり分解したりするなどの単純なリファクタリングで済んでいる
それにより保守性もデバッグ効率も上がるためリファクタリングコストは誤差に等しい
仮にGC言語で書いている時でも同様でその状態は各データが複雑に絡み合っている状態なのでリファクタリングしたほうが望ましい
2024/06/29(土) 13:38:30.46ID:xx5BdVU7
ダックタイピングがあるってどういう状態のことだろう
2024/06/29(土) 14:06:46.53ID:H9n2Ca7a
リファクタリングの原則のひとつとして外側から見たときに変わらないというのがある。
内と外を分ける境界線がどこなのかというのは場合によるので UI レベルで同じなら良しとすることもあるけど、普通は適当なモジュール単位でやるだろう。
「変わらない」ことの保証のひとつとして型やライフタイムアノテーションは頼りになるよ。
型システムがあてにならないほどの大改革ならどうせ全部書き直しなので足を引っ張られることもない。
463デフォルトの名無しさん
垢版 |
2024/06/29(土) 14:24:33.15ID:lbQtaoAJ
Rustはリファクタリングには全く向いていない
2024/06/29(土) 14:31:05.74ID:dyJ1RvLM
いつも汚いコードを貼り付けてた複オジがリファクタリングは簡単などと言い張ったところで全く説得力がない
2024/06/29(土) 14:38:55.22ID:pz5Aaald
数のイテレータで遊んで満足してる人に機械学習の文脈が理解できるわけないやん?
2024/06/29(土) 14:41:30.81ID:Kxp5xIIU
掲示板に貼れる程度の内容なら
リファクタリングしても知れてるでしょ
2024/06/29(土) 15:08:40.24ID:BT1eNZRh
>>463
Rustはリファクタリングに向いている言語だよ
リファクタリングで最も重要なことはその前後で同じ機能動作が保証されることだけど
そこで静的型付け言語が有利なことは当たり前としてRustのアクセス競合排他原則がさらに大きく効いてるよ
データ書き換え中の読み取りによるバクがリファクタリングによって入り込むことも防いでくれているね
2024/06/29(土) 15:23:13.20ID:PsPEDCdZ
デジタル小作人やめるレベルの大手術ではなく
地主との関係が変わらないことを保証したいんだな
2024/06/29(土) 15:34:20.66ID:KH8yb7Br
それまで参照を持たなかった構造体にメンバとして参照を持たせると、型にジェネリックライフタイムが付いて、その型の使用箇所全部でライフタイムを書く必要がある
さらに悪いことに、実際のところこれは必要ではなく、ライフタイムを書かなくても省略されていると見なされてコンパイルが通ることもある
しかしこれでは意図通りのライフタイムになっていないことが多く、その型の使用箇所を増やしたときに初めてそのことに気づくことになる

Rust特有のリファクタリングしづらさは、あるよ
2024/06/29(土) 15:52:41.67ID:jlQztVvs
ライフタイム関連に限らずRustのリファクタリングは
他言語に比べて波及する範囲が大きくなりやすいんだよね
それで作業量が多いからしんどい

しんどさと難しさは必ずしもイコールではないんだけど
サクサク変更できる言語を経験してると
Rustのリファクタリング時には精神的なエネルギーが相当必要
2024/06/29(土) 16:01:57.62ID:obFhbebh
>>469
リファクタリングの作業の大きさに対して、必要なライフタイム注釈を付けるだけの些細なことが障害になったことはないな。
ライフタイム注釈が'aになるか'_になるか省略できるかは、その必要性と省略ルールに基づくだけなので、そこで問題が発生することはないだろう。
2024/06/29(土) 16:03:28.89ID:obFhbebh
>>470
Rustでは様々なことをコンパイラチェックに任せられるため、リファクタリングで最も崩れにくく、人間の負担は他より小さい。
2024/06/29(土) 16:10:10.85ID:FxtNCeeF
糠に釘
暖簾に腕押し
複オジにRust
2024/06/29(土) 16:52:22.95ID:KH8yb7Br
>>471
「ライフタイム注釈が'aになるか'_になるか省略できるか」は、すべての使用箇所ごとに以下を検討したうえで決まる

* 追加するライフタイムは既存のライフタイムと同じであるべきか
* 既存と同じであるべきでないなら、そのライフタイムはどこで宣言すべきか(impl? fn? トレイトや構造体?)

それで1つの型がリファクタリングできたところで、

* トレイトや構造体にジェネリックライフタイムパラメータを追加した場合、そいつにも同じ作業がいる。最初から繰り返し

ここまでのすべての作業に尋常でない集中力が必要になる
繰り返しの中でライフタイムの宣言箇所の選択が誤っていたことに後で気づいたりすると悲惨だ
「エラーのあるコードをgit commitしない方が良い」という思い込みを捨て、選択を必要とするタイミングでgitに記録するようにして、
作業効率は安定はするようになったが、それでも作業を捨てるというのは気が滅入る
「あ、この関数の引数にライフタイム追加することになるけど、後で戻り値にもライフタイム追加することになるな」なんて思っても一挙に作業してはいけない
少なくとも自分の頭では作業の段取りを崩すだけだった

そしてここまでを全集中して完了してコンパイルを通すところまで持って行けても、クレート外の使用箇所でおかしなことにならないことは保証できない
ボローチェッカーは書かれている使用法が妥当であるかどうかしか検証しないからだ

こっちは体験談として言っているんだから、机上の空論を弄するのはもうやめなさい
2024/06/29(土) 16:58:20.78ID:KH8yb7Br
Rustはライフタイムさえ正しく書けていれば本当に有用な助けを与えてくれる
しかしライフタイムを正しく書くための助けはほとんど与えてくれないので、自分で書く必要があるときには上と同じような期待をしてはいけない
476デフォルトの名無しさん
垢版 |
2024/06/29(土) 16:59:51.95ID:TiydCxUm
知ったかぶりして間違ったこと書く
やんわり間違いを指摘される
反省せずに開き直る!

またこの流れ
ググればすぐわかるような間違いなのになんなんだろうな
2024/06/29(土) 17:06:14.07ID:HTwQ17U9
>>474
>>475
それは大きな誤解をしているなあ
ライフタイムアノテーションを間違って書いて矛盾が起きていればコンパイルエラーとなるよ
コンパイルが通れば正しく書けているからプログラマーがそこで困ることはないよ
2024/06/29(土) 17:17:23.37ID:KH8yb7Br
>>477
いいからこれでも読んでろ
https://github.com/pretzelhammer/rust-blog/blob/master/posts/translations/jp/common-rust-lifetime-misconceptions.md

> Rustのトレイトオブジェクトへのライフタイム省略ルールはどんな状況でも正しいというわけではない
> Rustはプログラムの意味についてプログラマよりも知っているわけではない
> Rustのコンパイラが吐くエラーメッセージでおすすめされる修正はコンパイルが通るようにするが、コンパイルが通り、 かつ プログラムへの要求をちゃんと満たしたものするわけではない
2024/06/29(土) 17:26:08.00ID:3fxfEuZj
それは省略ルールの結果が望むものと一致するかどうかは限らないという意味だぜ
間違っていると部分的にはコンパイルが通ったとしてもプログラム全体ではコンパイルエラーとなる
そのミスをコンパイラが見逃すことはない
2024/06/29(土) 18:07:09.50ID:PsPEDCdZ
言語を比較しなくても
&Tに比べてRc<T>はリファクタリングしやすいとかいう認識でいいよな

ただ進化論じゃないんだから&Tが淘汰されてRc<T>が生き残るということはない
言語を比較すれば淘汰される言語もありうる
2024/06/29(土) 18:13:00.59ID:E9RFAyQx
>>469
その逆のリファクタリングを影響範囲が大き過ぎて無理って話をcargoのissueで見たことある
cargoはそれ以外でも技術的負債が溜まってるけど影響範囲が大きくなるから簡単に手を入れられないってことを中の人がよくボヤいてるね
482デフォルトの名無しさん
垢版 |
2024/06/29(土) 18:24:11.81ID:bsok8bJg
C/C++をメモリ安全にするプロジェクト
https://www.itmedia.co.jp/enterprise/articles/2406/28/news084.html
Rustイラネになりそう
2024/06/29(土) 18:44:47.93ID:4ikwzvl0
>>482
それは自動で見つけられる脆弱性の範囲を広げる話
その種の脆弱性をゼロにするRustへと移行する流れはそのまま変わらず
2024/06/29(土) 20:21:20.41ID:U1RWDnMp
>>480
Rc<T>の比較対象はTやBox<T>
・Tの参照は&T
・Box<T>の参照は&T
・Rc<T>の参照は&T
どれも同じになり&Tは不要とならない

違いはスコープから外れたとき
裸のTはTがスタック上ですぐ消える
Box<T>はTがヒープ上ですぐ消える
Rc<T>はTがヒープ上でカウンタが最後のときだけ消える
2024/06/29(土) 20:23:11.41ID:KH8yb7Br
>>469
これか……
https://github.com/rust-lang/cargo/issues/7342

> I think the answer here is "Alex thought it was fun to avoid RefCell and Mutex", there's no real technical motivation.

「cloneを避ける/ロックを避ける/参照カウンタのコストを避ける」みたいなゼロコスト主義も節度を持ってやれってことね
とりあえず「型のジェネリックライフタイム引数を変更するのは多大なコストがかかる」という理解は合っていると思っておくことにするか
2024/06/29(土) 20:23:40.20ID:KH8yb7Br
>>481だった
2024/06/29(土) 21:57:07.55ID:PsPEDCdZ
問題は節度というより抽象化軽視
ゼロコストという損得勘定に強く依存するよりは高コスト抽象化の方がマシ
と判断できなくなる
2024/06/29(土) 22:55:28.22ID:xDrSJDK+
>>469
それは単にライフタイムに不慣れなだけじゃないかなと思った
構造体に参照を含むのはよくあることでライフタイムパラメタを付けるだけ
あとは関数で参照を含むデータを返す時にどの引数に由来するかを指定することなどしかすべきことはない
慣れてしまうと大したことはしていないよね

そこでもし間違えて指定してしまっても違反があればコンパイラが必ずエラーとするので安心して大丈夫
では何故コンパイラが自動で指定(解釈)してくれないのか?というと、複数の参照に対して別扱いするかどうかや複数の関係指定など各自に方針の余地があるため
489デフォルトの名無しさん
垢版 |
2024/06/29(土) 23:12:35.54ID:/LX7F2Md
C/C++だとそのへんを脳内の方針で逸脱しないように人間が監視しないといけない
Rustは楽
2024/06/29(土) 23:26:59.72ID:PsPEDCdZ
固定長配列をスライスに、BoxをRcに変換すると抽象度は上がる
失敗するかもしれないパターンマッチは抽象度を下げる
コンパイル時または実行時エラーかもしれないborrowも抽象度を下げる
2024/06/30(日) 02:58:29.53ID:CdZYHoVj
>>467
詭弁

>>469
++

>>474
++おまえもかが口癖になる
2024/06/30(日) 03:44:32.65ID:K2J9qaLk
>>474
ライフタイム初心者なだけだな
そんなことでは悩まなくなる
493デフォルトの名無しさん
垢版 |
2024/06/30(日) 05:54:25.07ID:WATrci3L
>>309
横からすみません。
C#を関数型っぽく書いたら、ここまではなったのでRustだったらどうなるのか聞いても良いでしょうか?

public static void Main(string[] args) { args.ToList().ForEach(f); }

static void f(string fileName)
{
Console.WriteLine(fileName);
File.ReadAllLines(fileName).Select(g).ToList().ForEach(Console.WriteLine);
}

static Func<string,int,string> g = (line,i) => $"{i + 1,2}:{line}";
2024/06/30(日) 09:33:23.06ID:L3wyoKVN
どうもならんよ
2024/06/30(日) 10:12:23.11ID:BLjMhwlM
リファクタリングのすごさは、外側から見たら何も変化しないことだからね
2024/06/30(日) 10:30:41.18ID:8eFU1ITU
>>493
何回ToListすんねんw
ReadAllLines含めて3回とも必要ないやろ
2024/06/30(日) 10:53:06.05ID:DQMdIUg4
あえて >>493 で頑張ると
https://paiza.io/projects/sk40IXUgPm0k_VgI1wsHBg

fn main() {
let cwln = |s| { println!("{}", s) };
let g = |(i, line): (usize, &str)| { format!("{:>2}:{}", i + 1, line) };
let f = |file_name: String| {
cwln(file_name.clone());
std::fs::read_to_string(file_name).map(|u8b| {
u8b.lines().enumerate().map(g).for_each(cwln)
}).unwrap()
};

std::env::args().skip(1).for_each(f)
}
2024/06/30(日) 10:54:12.53ID:BLjMhwlM
do記法のたぐいはラムダで実装しても命令型で実装してもどっちでもいい
外側から見れば同じだからだ
499デフォルトの名無しさん
垢版 |
2024/06/30(日) 11:17:03.52ID:msuugTQH
>>496
.net標準にはList型にしかForEachが導入されてないからやな。
C#ではチェインメソッドにしないほうがいいとされてる。
https://learn.microsoft.com/en-us/archive/blogs/ericlippert/foreach-vs-foreach
2024/06/30(日) 12:31:43.09ID:NR+aRvdr
>>499
「.ForEachしたいけど標準にないからToListする」という考え方が間違い
enumerable.ToList().ForEach()のパターンは最悪

それとそのEric Rippertの意見がMSやC#コミュニティのコンセンサスというわけではないよ
IEnumerable以外ではForEach等の副作用適用メソッドが標準で用意されてるものが多々あるしIEnumerableに拡張メソッド追加して使ってるところもごまんとある
2024/06/30(日) 13:08:54.78ID:7wkc/L2e
>>497
キツイ
2024/06/30(日) 13:13:35.11ID:6LaDfHu1
>>500
foreachとForEachくらいは好きなほうでやればいいわな
ものによっては最適化度合いが変わるからそこだけ気にしとけばいい
503デフォルトの名無しさん
垢版 |
2024/06/30(日) 13:41:54.85ID:L3wyoKVN
unwarpほんま糞ダサい
2024/06/30(日) 14:01:03.54ID:BLjMhwlM
「すべてはオブジェクトである」が糞ダサいのだ
いい感じの構文糖はたいていオブジェクトではない
2024/06/30(日) 15:34:51.28ID:iQS10/oI
>>497
エラー返しができていない
ファイル一括読み込みでなくバッファリングすべき
本当の関数型だとセミコロンを使うのは邪道
506デフォルトの名無しさん
垢版 |
2024/06/30(日) 16:34:51.56ID:WATrci3L
>>497
ありがとうございます。
u8b受け取ってるラムダ式を関数化したらスッキリしそうですね。

>>496
Selectもindexを受け取れるんですが値を返さないとダメで、
あえてvoidなメソッドの後にreturn 0を、入れてエラーが出なくなったと思ったら、
遅延評価なのかfor/foreach/ForEachじゃないと中身を実行してくれないんですよ…orz
(結論、Selectはデータ加工専用で入出力には使えない)
2024/06/30(日) 16:49:10.64ID:MSv8cbxu
Rustで関数型のように書くなら

use std::env;
use std::fs::File;
use std::io::{self, BufRead, BufReader};

fn main() -> io::Result<()> {
 env::args()
  .skip(1)
  .inspect(|file_name| println!("{file_name}"))
  .map(|file_name| {
   File::open(file_name).and_then(|file| {
    BufReader::new(file)
     .lines()
     .enumerate()
     .map(|(i, line)| line.map(|line| println!("{}: {line}", i + 1)))
     .collect()
   })
  })
  .collect()
}
508デフォルトの名無しさん
垢版 |
2024/06/30(日) 16:59:35.48ID:WATrci3L
質問です。

.map(|(i, line)| line.map(|line| println!("{}: {line}", i + 1)))

line.mapは文字列へのmapで1文字1文字に番号振ってる様に見えますが、違うのでしょうか?
素直に

.map(|(i, line)| println!("{}: {line}", i + 1))

とは出来ないのでしょうか?
2024/06/30(日) 17:13:06.42ID:MSv8cbxu
>>508
そこは手続き型で書くと
let line = line?;
のところ
最初のlineはio::Result<String>型
それをmapして次のlineがString型
2024/06/30(日) 17:55:47.01ID:2aLeyJWV
こうやって関数型を勘違いしたやつが量産されてるんだな
511デフォルトの名無しさん
垢版 |
2024/06/30(日) 18:10:42.55ID:WATrci3L
>>509
なるほど、最初のmapと内側のmapで型が違うのですね。
ありがとうございました。
2024/06/30(日) 18:12:41.76ID:aILYkgH6
さすが二つ名持ちの汚コーダー
ひと味もふた味も違う
2024/06/30(日) 18:28:40.79ID:MSv8cbxu
関数型のように書きたいならば基本はfor_eachを使わない
行き詰まりのfor_eachを使うと値もエラーも返せなくなる
2024/06/30(日) 18:46:14.08ID:DeiuUcf0
>>506
イテレータがどういうものか全然理解してないのな
試行錯誤もいいが最低限の座学知識は必要やぞ
515デフォルトの名無しさん
垢版 |
2024/06/30(日) 20:38:10.26ID:oQ6wZd+v
let a: [u32; 4] = [1, 2, 3, 4];
let s: &[u32] = &a[1..3];

a[5]; と書くとコンパイルエラーが発生しますが、
s[5]; と書くとコンパイルは通り実行時にエラーが発生します。

なぜ、 s[5]; が範囲外の領域へのアクセスであることをコンパイル時に見抜けないのでしょうか?

本を見ても、理由が書いてないです。
ただ、そうなるとしか書いてありません。
2024/06/30(日) 21:21:34.70ID:aS5UFAEb
見抜けるようになっていないから
a は array である一方で s は slice
array は型として長さの情報を持つ一方 slice は持たない
slice の長さはコンパイル時にわからないしわかろうともしないしチェックもない
2024/06/30(日) 21:23:59.76ID:MSv8cbxu
>>515
静的にサイズが定数だと静的に比較できるから事前にコンパイルエラーとなる
配列は静的にサイズが定数
スライスもこのように静的にサイズを定数にしてやれば事前にコンパイルエラーとなる
const X: &[u32] = &[1, 2, 3, 4];
let x = X[5];
2024/06/30(日) 21:57:28.27ID:6Q+TlIxj
🦀🦀🦀
2024/06/30(日) 22:10:02.00ID:BLjMhwlM
本といえども一方通行のメディアではなくなってるんじゃないか
読者の側がそれをどうしても知りたい気持ちを表明しなければならないのが双方向でしょ
2024/06/30(日) 22:48:34.24ID:NrRL076G
>>513
一体全体何を言ってるんだ?
2024/06/30(日) 23:09:55.43ID:MSv8cbxu
>>520
for_eachは値を返せない
関数は基本的に値やエラーを返す
イテレータ利用で値やエラーを返すためにはfor_eachではなくcollectやfoldなどを用いる

>>507のように表示するだけで値を返さない場合であっても
関数はエラーを返さなければならない
2024/07/01(月) 00:45:59.76ID:d9FHgeU6
>>521
>for_eachは値を返せない
for_eachはunitを返してるよ

>関数は基本的に値やエラーを返す
voidやunitやnilを返すものも関数だよ

>イテレータ利用で値やエラーを返すためにはfor_eachではなくcollectやfoldなどを用いる
try_for_each使ってね
file openやprintのような副作用をイテレータのmapで行うのは関数型の考え方からは程遠いよ
2024/07/01(月) 01:02:37.18ID:3Woy0c9R
値を()しか返せないのでは意味がない
2024/07/01(月) 01:19:54.94ID:CgZJmBCn
お前の人生よりは意味あるよ
525デフォルトの名無しさん
垢版 |
2024/07/01(月) 04:16:03.32ID:VTE9nWpJ
unwrapをmapで代用とかセンス無さ過ぎ
2024/07/01(月) 05:26:16.34ID:WAZyoaEd
見抜いたことを全て警告するコンパイラがあったらこんな感じになるのか
2024/07/01(月) 05:49:45.95ID:ppYg1fh2
Rustは清書用(キリっ
528デフォルトの名無しさん
垢版 |
2024/07/01(月) 05:51:10.72ID:D/wxxrcg
犯人不明ボイス・トォ・スカル被害者にしている者皆判明
AIで被害者が苦しんでいる映像を作成してそれで喜んでいる脳細胞を読み取れば使用しているかの判定
AIで自分が高みの見物ができるかどうかも判定
あとは下記を参考にして行えばよい

いじめで殺害したかも判明するので迷宮入り事件犯人を絞り込める
隠しカメラの場所も判明

忘れた記憶を再び思い出せるようにする脳細胞を発見!
2024.06.28
「あなたの一番古い記憶は?」人は覚えていても2歳以前の記憶にアクセスできなくなっている
2023.11.30
なぜ私たちは起こってもいない間違った記憶をしてしまうのか?
2023.11.27
自分でも気づいていない「記憶の間違い」を脳波で判断できると判明
2023.10.19
富山大、睡眠中の脳で行われている推論の演算を神経細胞レベルで解明
2024/06/26
サイコパスはためらわない?−−嘘つきの脳のメカニズム
2019/09/26

脳を刺激して特定の記憶を呼び戻す技術「記憶プロテーゼ」を開発
2024/02/21

「0」を”思う”ときの脳活動は「1」に近い!捕食者への恐怖がゼロの根幹だった?
2024.03.07
>>MEGを使うと、脳内でわずかに発生する磁場変化をとらえて、脳活動を記録することが可能です。
>>(※脳波計が脳の電気活動を読み取るのに対して、脳磁計は脳の磁気活動を読み取ります)

東工大、磁束集中器を用いない高感度「ダイヤモンド量子センサ」を開発
2024/06/07
>>日常的な検診や脳機能のより詳しい研究や、ブレイン・マシン・インタフェースの研究などへ大きく貢献できると期待されている。
2024/07/01(月) 06:29:11.19ID:XAeGvvJG
>>525
unwrapは使わずにmapでNone/Errを透過的に渡すのはRustの基本
2024/07/01(月) 07:19:14.88ID:WAZyoaEd
これmapメソッドでもmap関数でもない中立な勢力が勝つパターンだ
2024/07/01(月) 11:47:54.40ID:LZ9kVfeK
Functorのmapなんだよね
でもFunctorは定義されてなくて統一的に扱えないんだから
Result/Optionはfmapとか違う名前にしておいたほうがよかったと思う

どっちにしろmap/fmapで副作用はアンチパターン
2024/07/01(月) 11:55:40.56ID:14Z1Ksgh
fmapなんかflatMapと勘違いされるだろ
2024/07/01(月) 12:47:47.85ID:Z0Kzqg/U
そんな勘違いをする人にRustは無理
2024/07/01(月) 12:59:53.25ID:irzLgX5l
>>525
こう書くとresultがErrの時に返せずここでpanicになってしまう

 let val = result.unwrap();
 f(val)

そのためpanicしてもいいとか絶対にErrとならない特殊な場合を除けば
unwrapを用いてはダメでmapを使ってこのように書くんだよ

 result.map(|val| f(val))

ここで本当に関数fを呼ぶだけならresult.map(f)と簡略化できるけど
f(val)の部分は式やブロックの可能性もあるので簡略化せずに進めるね

これは以下と同等でErr(err)の時に保持してくれている

 match result {
  Ok(val) => Ok(f(val)),
  Err(err) => Err(err),
 }

ちなみにf(val)もResultを返すときは
mapの代わりにand_thenがある

 result.and_then(|val| f(val))

つまり以下の二つは同等

 result.map(|val| f(val))
 result.and_then(|val| Ok(f(val)))

この場合はもちろん簡素なmapを用いるべき
535デフォルトの名無しさん
垢版 |
2024/07/01(月) 13:41:34.54ID:JlB5uk0q
Rustを10年以上使ってるひとに質問です
Rust本体をバージョンアップしたときに
動かなくなった旧バージョン用のcratesや自分のプロジェクト(main.rsなど)は
どれくらいありましたか?
またdeprecatedやobsoletedにされた機能は
使えなくなるまでに実際何年くらい使い続けられましたか?
2024/07/01(月) 14:05:59.07ID:/HpLpXor
Rust 1.0からまだ10年経っていない
Rustは3年毎のedition制度があって後方互換性がない変化はeditionが変わるため安心
今も最初のRust 2015 editionがサポートされてる
さらにedition移行支援ツールもある
Rustは他言語と比べてかなり恵まれてる良い環境
2024/07/01(月) 14:11:38.44ID:JlB5uk0q
>>534
>ちなみにf(val)もResultを返すときは
の条件なら
>つまり以下の二つは同等
> result.map(|val| f(val)) // Resultを還さないf
> result.and_then(|val| f(val)) // Resultを還すf
じゃないんですかね(Ok(f(val))は蛇足)
2024/07/01(月) 14:22:14.04ID:seu0xN2c
Resultを返すか返さないか関係なくこれは常に成り立つね

>>534
> 以下の二つは同等
> result.map(|val| f(val))
> result.and_then(|val| Ok(f(val)))

例えばf(val)がOptionを返したとしても成立するよ
2024/07/01(月) 14:22:38.11ID:14Z1Ksgh
flat_map の関数名を and_then にしたのはどこの言語の文化?
2024/07/01(月) 14:43:32.98ID:WAZyoaEd
iostreamの記号をまるでセガサターンのように見下して英単語を推した文化
2024/07/01(月) 14:48:54.46ID:JlB5uk0q
and_thenはor_elseに対してのantitheseだと思った
2024/07/01(月) 14:51:31.68ID:seu0xN2c
result1.and(result2) がまずあって
result1.and_then(|ok1| return_result2(ok1)) が関数版だね
OptionでもResultでも同じ命名
2024/07/01(月) 14:59:21.90ID:3i64JhgU
iostreamの << をRustに導入しなかったのはなぜ?
2024/07/01(月) 15:05:11.12ID:kC5U6Id4
std::fmtで十分だから
2024/07/01(月) 15:05:34.52ID:YDWAPNrm
うるせぇやりたきゃShl実装しろ
2024/07/01(月) 15:30:41.32ID:wNG1bhSA
>>543
単純な二項演算子でやると書式指定の範囲を制御できないんだよ。
C++ ではストリームに対する書式指定は永続的な効果を持っていて、その効果を上書きするまで続く。
普通の方法で指定したらグローバルな影響を持ってしまうのは明らかにまずい。

iostream が出来たときは可変長引数の関数を型安全に扱う方法 (variadic template) が無かったし、
書式指定文字列をコンパイル時に解釈して安全に扱う方法 (constexpr) も無かったから
その範囲内で当時の知見で比較的マシな形にしたらああなったという程度のもんで、
今の考え方からすると iostream は真似したいようなもんじゃない。

むしろ C++ のほうが新しい仕様では Rust 風のやり方に寄せて来てる。
2024/07/01(月) 15:53:07.19ID:2HyCglUW
>>543
ダサすぎるから
2024/07/01(月) 15:56:35.04ID:iVgAAf6K
rustもprint時のstring interpolationはもう少しどうにかならんものかね
549デフォルトの名無しさん
垢版 |
2024/07/01(月) 18:51:52.61ID:r9fpSp0F
macroなんで自分で描き替えればええんやで
2024/07/01(月) 20:45:22.07ID:WAZyoaEd
自作した後の自己肯定を10年続けるまでがプログラム技術
2024/07/01(月) 23:04:21.05ID:3i64JhgU
昔、C++でprintf使ったら怖い人に怒られたのに
今じゃあれはクソ設計だったって評価に固まってるんだね、英語圏でも
552デフォルトの名無しさん
垢版 |
2024/07/01(月) 23:12:10.92ID:wNG1bhSA
>>551
C/C++ の printf は iostream 以上にカス。
型のチェックがガバガバだし、ちゃんと理解してないやつのほうが多いので常に問題を引き起こしていた。
ただ、記法としてはこれで良かった。
553デフォルトの名無しさん
垢版 |
2024/07/02(火) 02:06:02.53ID:bkJ9zxrb
今の C/C++ の printf はコンパイル時に型チェックして警告してくれる
2024/07/02(火) 05:00:17.05ID:VNjymWLQ
>>553
型チェックできて型がわかっているのに
なぜ%dや%fや%sなど指定しなきゃいけないのか理解できない
型がゆるゆるだった大昔の遺物にみえる
2024/07/02(火) 06:06:14.65ID:wHmBy3hI
>>554
みえる、じゃなくて完全に遺物だろ
2024/07/02(火) 06:44:02.90ID:VNjymWLQ
表示はRustのDisplayトレイト実装方式が洗練されていて使いやすくていいね
2024/07/02(火) 08:28:24.43ID:UD4Nu927
仕様書が聖書のようなものだから遺物だろうが仕様書に逆らうわけにはいかないじゃん
2024/07/02(火) 08:41:47.20ID:hGRi0mb2
>>544
C の関数は基本的にはちゃんと型はついてるが可変長引数は静的な型情報を捨てること実現してる。
もちろんそれを引き継いだ C++ も。
C++ は後に variadic template による安全な可変長引数を導入したが古いスタイルの可変長引数も廃止はしてない。
言語仕様を素朴に実装したら型はわからないんだよ。
printf などの一部の関数に限っては「関数の型情報によらずに」コンパイラが特別扱いでチェックしてる。
関数の型を元に検査してるんじゃなくて printf の仕様をビルトインして特別扱いしてるの。
2024/07/02(火) 10:27:11.96ID:LnXo4/R2
>>538
result.and_then(|val| Ok(f(val)?))
とか
result.and_then(|val| Ok(f(val).unwrap()))
じゃなくて
result.and_then(|val| Ok(f(val)))
で良いのはなぜ?
2024/07/02(火) 10:37:23.15ID:tsLlTVbC
Rust初めて使ったときは「println! みたいな基本的なものがマクロで?大丈夫かこの言語」みたいに思ったもんだが、
よくよく考えるとマクロにせずに、柔軟なシグニチャでなんとかしようとする他の言語のほうがよっぽど醜いもんな。
2024/07/02(火) 10:55:15.33ID:/ZI4FWA6
>>559
上2つはResult<T>
最後のはResult<Result<T>>かResult<Option<T>>
ネストが一つ深くなる
2024/07/02(火) 11:50:20.39ID:hGRi0mb2
>>560
C++ のライトユーザは関数テンプレートのことを誤ってテンプレート関数と呼ぶことが頻繁にある。
関数テンプレートが関数であるという誤解が言葉になって表れてるんだと思う。
単に使うだけなら関数みたいに見えてしまうからかもしれない。

関数テンプレートは関数を生成する元になるテンプレートだから関数テンプレートなので「生成する」というところに着目したらマクロで生成するのでも理屈はあまり変わらないかもしれない。

ただ、 LISP 系言語の経験から言うと構文レベルで制御されるマクロはエディタのサポートが受けづらいし、ドキュメントを型で表現できないのはやりづらい。
マクロ展開の失敗がどういう失敗なのかをきちんとエラーメッセージにするのも難しい。
デメリットもあるけど、どうせどこかに問題があるならこのくらいで良いという潔さは感じる。
2024/07/02(火) 12:37:13.61ID:UD4Nu927
仕様書がなくなっても
統合環境の支援の成功体験から逆算された縛りがあるんだな
564デフォルトの名無しさん
垢版 |
2024/07/02(火) 16:01:50.82ID:LnXo4/R2
and_thenってネストが深くても自動で中いじってくれるのか
565デフォルトの名無しさん
垢版 |
2024/07/02(火) 17:51:34.66ID:XMmeU2jA
Slint ってなんなん? javascript ?
conrod とどう違うん?
566デフォルトの名無しさん
垢版 |
2024/07/02(火) 18:31:45.59ID:W5A1QJhP
conrodならもう死んだよ
2024/07/02(火) 18:32:06.29ID:0AnHLV8o
>>559
Rustでそれらは全てmatchになるので置き換えて比較すれば理解は簡単
ちなみにmatchにすると記述が長くなるが同レベルで「?」オペレータ適用できるメリットがある

result.and_then(|val| f(val))
これはこう置き換えられる
match result {
 Ok(val) => f(val),
 Err(err) => Err(err),
}

result.map(|val| f(val))
これはこう置き換えられる
match result {
 Ok(val) => Ok(f(val)),
 Err(err) => Err(err),
}

つまり常にこれが成り立つ

>>534
> 以下の二つは同等
> result.map(|val| f(val))
> result.and_then(|val| Ok(f(val)))
2024/07/02(火) 18:34:46.10ID:0AnHLV8o
>>565
SlintはGUI部分だけ専用スクリプトで宣言して
プログラムはRustでもC++でもJavaScriptでも記述できる
2024/07/02(火) 22:09:25.08ID:PHqzDXJL
RustのGUIまわりは安定しない印象
conrodやdruidやorbtkのようにここ数年内に消えたものもあるし、いま人気のものも今後消えないとは言い切れない感じがする
2024/07/02(火) 23:44:50.93ID:sYgKhdog
RustでGUIならこの5つ
https://iced.rs/
https://slint.dev/
https://tauri.app/
https://www.egui.rs/
https://dioxuslabs.com/
方向性がそれぞれ異なるので目的に合わせて選ぶ
571デフォルトの名無しさん
垢版 |
2024/07/03(水) 03:55:17.90ID:aYT0CHki
tauri遅いな
eguiはサクサク
2024/07/03(水) 06:25:46.46ID:uJMJjlOC
>>570
tauriはその中に入れるべきじゃないだろ
あれはReact/JSだぞ
2024/07/03(水) 07:06:30.59ID:OX+N1U2y
>>572
無知すぎ
Reactは全く関係ない
併用可能な一つに過ぎない

TauriではJavaScriptを一切書かなくても利用可能
Rustによるプログラミングのみでも使うことができる
574デフォルトの名無しさん
垢版 |
2024/07/03(水) 09:04:55.71ID:TWMTGehv
rstkはどうなの?
2024/07/03(水) 20:03:02.84ID:zo80GwO2
しかしほんとにデスクトップアプリのライブラリってすぐ出ては消えていくな
自分で作ったほうが安定するんじゃないか
2024/07/03(水) 22:16:18.13ID:opT6Sw/L
クロスプラットフォームでいくならwinitとwgpuぐらいは頼らないと無理じゃないかな。
しかしその2つもまだまだブレイキングチェンジ激しい発展途上だけどね。
2024/07/03(水) 22:53:26.72ID:cnEeYmV/
>>574
*/Tkは30年以上の歴史と実績があるGUIライブラリ
rstkはそのRust版
2024/07/03(水) 23:54:41.68ID:nLMSU1jW
>>573
Yewのこと?ならそう書けよYewなんてくっそマイナーでReact使うのが普通なのに
2024/07/03(水) 23:56:15.32ID:nLMSU1jW
Yew使ったことあるけどゴミだぞまじで
2024/07/04(木) 00:31:14.93ID:gMzXB5nS
30年くらい前にTcl/Tkを使ったわ。
2024/07/04(木) 00:37:01.85ID:0fbU9cKr
>>575
利用者が集まらなきゃ結局のところ本番環境で使われないもんね
MAUIもだけど本番環境で使われなきゃ不具合修正すらされずにフェードアウトしていく
2024/07/04(木) 04:07:16.49ID:H+976rVP
>>570
eguiの公式サイト、オサレね
2024/07/04(木) 07:04:39.24ID:pjeQ5Ua2
サイト自体が見本なのな
584デフォルトの名無しさん
垢版 |
2024/07/04(木) 10:17:42.23ID:HAZY/W56
reactもこの10年でだいぶ変わったわな。
プレゼンテーション層はそういうもんかもなと思ってる。
585デフォルトの名無しさん
垢版 |
2024/07/05(金) 08:36:28.68ID:GQkuHNKI
銀河英雄伝説で考えるセキュリティ--将来の「帝国の双璧」が陥った罠とセキュリティ業界
https://japan.zdnet.com/article/35220819/
2024/07/05(金) 10:29:56.20ID:G0wJmtVU
>>574 >>577
rstk より tk ( https://crates.io/crates/tk ) の方が良いよ
2024/07/05(金) 18:22:04.62ID:cNWaNn+n
どちらも利用者少なくて数の差ではわからんな
2024/07/06(土) 04:04:15.80ID:MPM8/XaB
Tkは何十年も前のGUIで古いからね
589デフォルトの名無しさん
垢版 |
2024/07/06(土) 04:24:49.23ID:mF2Bv0pD
やりたいことを出来る範囲で最小限の道具を選ぶのが望ましい。
Tk で足りるときは Tk を使えばよい。
2024/07/06(土) 09:36:32.81ID:5g1fLWJR
UNIX系でGUIをどうしても使わないといけない場合にTk使ってたけど
今はhtmlでいいかなって
2024/07/06(土) 09:36:55.52ID:tDR9EaCv
wgpu最強だが変化速過ぎ
2024/07/06(土) 10:12:50.18ID:fehAbjyn
正直GUIをRustで書くメリットが思いつかない
ただの2DグラフィックでRustの実行速度を求めるってのはおかしな話だと思うもん
ロジックをRustで書いてGUIは安定してるReactでいいよ
2024/07/06(土) 10:14:23.55ID:5g1fLWJR
wgpuは三角を書きたい人向けでGUIとは関係ない
2024/07/06(土) 11:05:29.63ID:l5YBQ3zH
>>592
お前がそう思うならそうなんだろう
お前ん中ではな
2024/07/06(土) 12:27:12.12ID:KR8eM4HE
>>592
reactはデータリフトアップして上にまとめるのめんどい。状態管理だけにライブラリ導入とか無理あるんじゃねーの
2024/07/06(土) 12:35:51.52ID:5g1fLWJR
streamlitなどのHTML書かないでも作れるようなのがメジャーになればいいんだけど
2024/07/06(土) 12:47:45.00ID:5g1fLWJR
reactがパックされてて高度なページはjinjaみたいので中のデータだけいじれればなんでもいい気がする

通常のページの記述はhtmlではなく素のrustで簡単に書ける必要がある
2024/07/06(土) 13:00:47.32ID:mF2Bv0pD
ウェブ技術系は普段使いするにはリッチすぎるんだよな。
屋上屋を重ねまくった一番上でしょうもないことをするのは気が引ける。
2024/07/06(土) 13:56:26.87ID:5g1fLWJR
streamlitレベルでいいんだけどな
600デフォルトの名無しさん
垢版 |
2024/07/06(土) 14:33:03.19ID:+47S9kNa
rust版のstreamlit作れよ
601デフォルトの名無しさん
垢版 |
2024/07/06(土) 14:56:55.97ID:X3tW4qHs
タウリンなんていらん
eguiで充分
602デフォルトの名無しさん
垢版 |
2024/07/06(土) 22:06:51.02ID:PIuhFLFS
Rustってオブジェクト指向言語ではないということですが、それでも困ることはないんですか?

これが最後の言語だ!とRustって名付けたんですか?
603デフォルトの名無しさん
垢版 |
2024/07/06(土) 22:35:00.58ID:KApGuCzH
Rust触ってないから分らんけど、QtのRustラッパーライブラリは無いのん?
一応Android/iOS含めたソースコードレベルでのマルチプラットフォームライブラリに進化しているらしいが、Haskellにすらラッパーライブラリあるんなら、Rustにも探せばあるんじゃ?
604デフォルトの名無しさん
垢版 |
2024/07/07(日) 00:52:56.61ID:goRFIXq7
>>602
ネタにマジレスかもしれないけどRustはオブジェクト指向的なものも使えるよ
構造体にメソッドを持たせたり、インターフェースのようなものも扱える
継承はないけど、これはむしろ「その方が良い」というもので、同じくモダンな言語であるGOでも継承は無くしてる
2024/07/07(日) 01:50:01.52ID:NnH56+1c
オブジェクト指向プログラミングには
クラス継承という悪いやり方を用いるダメな方法と
クラス継承を用いない正しい方法があって
RustやGoなどのモダンな言語は後者の方法をサポートしている
606デフォルトの名無しさん
垢版 |
2024/07/07(日) 08:48:31.04ID:5sr/rOi5
>>603
ないわけじゃないけどまともに使えるレベルではないらしい。使ってないから知らんけど。
Qt自体QMLとか迷走してる感じあるし結局JSでやるならもうReact使えばいいんじゃね?感ある
607デフォルトの名無しさん
垢版 |
2024/07/07(日) 09:17:14.13ID:7aG8TPof
>>604-605
ありがとうございました。
「継承」って良いからオブジェクト指向言語の機能になっていたのではないんですか?
なんか時代とともに、昔は良いとされていたものが今ではダメになったりするんですか?
なぜそんなに揺らぐのでしょうか?
言語の設計の学者はぼんくらばかりなんですか?
2024/07/07(日) 09:17:45.74ID:LJE8DJUz
継承がないほうが「正しい」というのは行きすぎた思想だよ。
正しく使えないカスばっかりだという現実に敗北しただけ。
2024/07/07(日) 09:49:42.70ID:Qx35uTG5
何がダメかというと「ある型(クラス)が別の型(クラス)の実装を継承してしまうこと」でこれが依存関係となり負の連鎖をもたらす
クラスの継承はこれに該当するから使ってはいけない
Rustにも継承とみなせる機能はあるけれど上記に該当しないため大丈夫
そこが決定的な違い
2024/07/07(日) 10:06:45.11ID:rz+I+TB4
>実装を継承してしまうこと」でこれが依存関係となり負の連鎖をもたらす
実装継承を使えないレベルの人はだいたいこういうふわっとした認識だよね
2024/07/07(日) 10:11:15.42ID:Eha1J0DV
暗殺術を正しく使える賢者がいる国なんてあったら嫌だなあ
正しく使える者など絶対存在しないという思想は行き過ぎではなくむしろ穏健派
2024/07/07(日) 10:27:32.62ID:nRN7u0+P
全部が悪いと言う話じゃないけど

既存部分をただ継承させるだけならいいけど一部を上書きしたりして
それが全ての箇所で矛盾のない正しい挙動になるか判定が難しいか不可能な場合がある

結果実装コスト以上に考えざるを得ない…残念なことに本当に楽をしたのかどうか不明な場合がある
継承がないとそれは避けられるから使うな!と言う人が出てくる
2024/07/07(日) 10:29:57.11ID:nRN7u0+P
変数などに細かいアクセス制限のない言語は特に陥りやすい
制限があったところで制作者がそれを適切に選ばなければならない

どうしても経験や思考時間を必要とする
ガチ勢にはそれが無駄に思えるんだろう
2024/07/07(日) 10:32:06.74ID:syATK/7U
実装継承は問題を引き起こすだけでなく
代わりの継承機能を提供することで
実装継承は全く不要になったことが大きい
そのためRust、Zig、Nim、Goなどモダンな言語はいずれも言語仕様からクラスを追放している
2024/07/07(日) 10:33:57.16ID:nRN7u0+P
それをやっても実質オーバーライド問題は解決されていないけどな
2024/07/07(日) 10:45:17.84ID:4XBGKwNL
>>607
実装継承はすごく便利だからオブジェクト指向言語では誰でも使いやすい機能としてサポートされてた
でも便利すぎて乱用されたからその経験と反省から不便でも乱用されにくいようにした方が得策という考えに至った言語開発者が増えたというのが2010年代
だから今は実装継承は上級者向けの機能という扱い
GoでもRustでも一般的なオブジェクト指向言語よりもわざと使いにくくすることで利便性と問題点を理解して実装方法を選択できる上級者向けの技術になっている
2024/07/07(日) 10:46:54.77ID:RLTFRTn6
>>615
それは(実装継承となる)クラスでのみ問題となるよな
2024/07/07(日) 10:53:40.16ID:suA6qkkI
>>616
デタラメを書くなよ
問題となる機能の代わりに便利で問題を起こさない機能を導入したのがRustだ
頭の固いクラス原理主義の人だけが使いにくいと主張してるが
クラスの洗脳から解き放たれた普通の人たちはRustが便利で使いやすいとの理解に至っている
2024/07/07(日) 11:05:57.49ID:nRN7u0+P
>>618
それは違うかなw
Rustで具体的に他と何が違ってて便利になってるか明言できるか?

Rustでも本質は変わってないのでなんも考えないでコピペ(継承)は避けましょうね
ぐらいのレベルでしかない
620デフォルトの名無しさん
垢版 |
2024/07/07(日) 11:21:22.62ID:goRFIXq7
>>607
当時は良いと考えられてたものが後から振り返って「あれは良くなかった」と分かる例はプログラミングに限らず多くあるだろ
Cの時代にRustを設計しろというのは無理で、その間にC++やJavaを経験し、そこで生まれた課題意識がないとGoやRustは生まれなかった
ニュートンの時代に古典力学を超えた量子力学を発見しろみたいなもの
2024/07/07(日) 11:23:38.24ID:E46Yge5y
>>619
コピペを避けるためにあるのが継承
ただし継承には2種類あって
>>609に説明がある実装継承とそうならない継承がある
実装継承の典型例がクラス継承
実装継承は他の型(またはクラス)に実装を完全に依存してしまっているために硬直化や崩壊などを招いてしまう
解決方法は単純で実装継承とならない継承機能をRustのようにサポートすればよい
2024/07/07(日) 11:31:52.81ID:Eha1J0DV
当初から、算数の四則演算の型を継承で説明できないことを
知りながら無理を通したぼんくらが流行らせたのだ

難しい算数よりも布教しやすい教義を優先するほうが儲かるという判断
その判断が合理的と思うかどうかは人それぞれ
2024/07/07(日) 11:55:49.26ID:nRN7u0+P
根本的に継承だけの問題じゃない
結局可視であろうがなかろうが関数自体の挙動が理解しないといけない

addがあってもリストの一番前に追加するか後ろに追加するかと言う機能の違いが合って
コーディングする側がそれを統一的に扱って思った場所に追加されずにバグになる
そういう話だからトレイトだからとか継承亡くしたからとかどうとか関係ない
2024/07/07(日) 11:59:33.31ID:kX4AKaVh
継承はなくても良いがあると便利 vs 継承はあってはならない
C++は知らなくてもいいが先に知っておくと理解が速い vs C++の理解はいらない

こういう境界線のビミョーな議論だと「まだ結論は出てない」と嘯きやすく続けやすいんだろうか
2024/07/07(日) 13:43:23.71ID:7CPxEWjC
interfaceはおっけー、abstractは隠蔽されるからだめってことだよ
継承全てが悪というわけではない
2024/07/07(日) 13:46:30.77ID:7CPxEWjC
kotlinでもabstractクラスはコード自動生成するときしか書かないもん
rustはtraitで十分だし
2024/07/07(日) 14:05:34.19ID:nRN7u0+P
rustにも派生はあるじゃん
628デフォルトの名無しさん
垢版 |
2024/07/07(日) 16:52:52.64ID:7aG8TPof
大きなプログラムを実際に書かずに、本を読むだけで、この言語のこの仕様は悪いとか良いとか判断できるようになりますか?
2024/07/07(日) 17:13:03.91ID:KUDE2scl
継承はいらん。

理想(のひとつ)はダックタイプで、継承は実装上の都合でそうなっている妥協の産物でしかない。
2024/07/07(日) 17:36:36.74ID:h+XkpNj2
今まで築いてきた価値観を繰り返し短い言葉で否定して徹底的に壊すというのが洗脳の基本

「継承は悪」「モダンな言語に継承はない」「Rustでは継承による問題は発生しない」(※全部嘘ですよ)

最初に洗脳をはじめた人と違って
洗脳者に洗脳された人は本質を理解していない
そればかりか真実かどうかなんてもはやどうでもよく
自分が信じてることだけが真実だと思っている
だから議論しようという気もなく一方的に同じことを繰り返し書くだけ
掲示板界隈では身近によくあることなので気をつけようね
2024/07/07(日) 18:10:28.88ID:rdCPsToy
継承はプログラミングで絶対に必要な重要な機能で重複コードを避けることができる
ただし継承といっても複数の方法があって実装継承だけは害を招いてしまう

実装継承とは別の型の具体的な実装をそのまま継承してしまうことを指す
つまり実装継承をすると二つの型の間に不必要に強力な依存関係が生じてしまう

クラス継承でプログラムを書くと自然にこの害悪な実装継承となってしまう
そのため様々な異なる方針のモダンな言語が同じ結論に達してクラスを言語仕様から無くした

Rustではトレイトを使うことで健全な継承機能のみを使うことができる
特にトレイトのデフォルト実装はどの型にも依存しないため実装継承にならずに健全な継承のメリットを最大限に享受することができる
2024/07/07(日) 18:53:59.08ID:0Udg54Yk
>>628
たくさん本を読み自分の頭で考える努力をすればある程度まではなれる
ただし実地の経験がなければ最終的には他人の受け売りを判断基準にするしかなく
経験のある人間に比べると妥当な判断ができない状況が多くなる

言語の仕様は一面的に良いとか悪いとかという判断を下せるものはほとんどない
長所短所を把握した上でどういう状況であれば他の仕様に比べて優れていて
逆にどういう状況であれば他の仕様に比べて劣るのかという
状況に合わせた判断が必要

つまり妥当な判断を下せる確率を上げるためには
言語の仕様を把握する力よりもそれが使われる状況を幅広く奥深く想定する力を身につけることが重要
これを本を読むだけで身につけようとしてもすぐに頭打ちになる
2024/07/07(日) 19:04:36.65ID:tn8SIXEe
>>622
>算数の四則演算の型を継承で説明できない
詳しく。
634デフォルトの名無しさん
垢版 |
2024/07/07(日) 19:34:52.42ID:goRFIXq7
>>628
他の言語での開発経験がある人が仕様を見て「この言語のこの仕様は好き/嫌い」と言うことはあると思う
どの言語も初心者という人だと無理
それに言語の良し悪しなんて点数で評価できるようなものでないし、好みの問題だったり、ライブラリなどの周辺環境だったり、作りたいもの次第だったりする
2024/07/07(日) 21:58:17.95ID:rdCPsToy
好き嫌いと良い悪いはしっかり区別つけなければならない
他の型との間で不必要に強力な依存関係が生じてしまう実装継承は悪い
この実装継承となってしまうクラス継承は悪い
Rustに実装継承はなくトレイトを用いることで健全な継承を活用してプログラミングできる
2024/07/07(日) 22:26:34.08ID:rVoIwJvq
受け売り知識しか持たないとこういう感じで論拠薄弱で空疎な意見しか書けなくなる
いい反面教師だね
637デフォルトの名無しさん
垢版 |
2024/07/07(日) 22:51:49.25ID:goRFIXq7
Rustが継承の問題を防げるのってトレイトだけじゃなくてenumの存在も大きいよね
静的ポリモーフィズムを自然に実装できるから、多態のために無理やりインタフェースに当て嵌めようとしたり、ダウンキャストが必要になったりといったものを防げる
本質的に違うものを抽象化しようとして失敗してる例を見たことのある人はそれなりにいるはず
2024/07/07(日) 23:03:31.83ID:Eha1J0DV
>>633
整数クラスは分数クラスを継承したいが、分母を表す変数は継承したくない

それと文字列 + 文字列が定義されている言語では
分数 + 整数の定義に必要な関数も継承したくない
その関数は文字列と無関係だから
639デフォルトの名無しさん
垢版 |
2024/07/07(日) 23:46:19.40ID:QlaAOMK5
>>638
>整数クラスは分数クラスを継承したいが、分母を表す変数は継承したくない
普通、C++だと、整数クラスを作っておき、
分数クラスはそれを継承せずに、
整数クラスを2つメンバに持つクラス
として定義しますよね。
その場合、整数クラスと分数クラスは継承関係を持ってない。
2024/07/07(日) 23:51:53.41ID:gwkq/Sum
>>635
クラス継承の問題はある程度の規模でプログラミングしてきた人の多くが体験してきて、
その根本的原因は実装継承にあることが多くのサイトで解説されている通りだけど、
従来の言語ではクラス継承に代わる手段が弱かったり不便であるため、
仕方なく欠陥のあるクラス継承を使い続けてきた不幸な歴史があるんだよ。
クラス継承を使わずにすむRustは恵まれてる。
2024/07/08(月) 00:13:34.95ID:dSFAEVvP
>>638
分数クラスを継承して整数クラスを作りたいという要求と
分母を表す変数は継承したくないという要求が矛盾してる

分数クラスを継承して整数クラスを作りたいということは
分数を特化したものが整数であるというモデルを
分数クラスと整数クラスの実装でも作りたいということ
そのためには整数クラスにも分母を表す変数が当然必要

矛盾した要求が実現できないのは実装技術の問題ではなく要求の不備
642デフォルトの名無しさん
垢版 |
2024/07/08(月) 00:24:32.58ID:aZihrzFg
>>607
コード メトリック - 継承の深さ (DIT)
https://learn.microsoft.com/ja-jp/visualstudio/code-quality/code-metrics-depth-of-inheritance?view=vs-2022

継承もやりすぎると毒になるってだけで、全くダメってわけじゃない。
2024/07/08(月) 00:26:00.53ID:wE6spjgC
>>638
不適切な継承の典型例だな
644デフォルトの名無しさん
垢版 |
2024/07/08(月) 00:36:15.98ID:aZihrzFg
>>638
数学では整数の組から分数作るけど、整数クラスが親クラスじゃないのは変じゃない?
(そもそも、継承より整数クラスのインスタンスを分子用と分母用の2個使う委譲スタイルの方が適切だと思うけど)

(n,m)とn/mは同型
2024/07/08(月) 01:24:33.08ID:QXtalhpf
どういう用途のためにクラスを作ろうとしているのか不明瞭な段階で
特定の実装方法が適切だと思い込むのは感心しない
2024/07/08(月) 05:17:42.23ID:9vKk3LiW
>>630
継承自体は悪くない
重複コードを回避できて保守性も向上する
つまり継承自体は良いもの

ただし実装継承だけは悪
異なる型同士に過度な依存をもたらし保守性を悪くする
クラス継承は実装継承となるため悪
モダンな各言語がクラスを排除した理由はそのため

Rustに実装継承はなく継承でそのような問題を起こさない
2024/07/08(月) 09:13:52.72ID:1Z2Y8mSg
継承で重複コードを回避できるのは実装も共有する継承だけ
つまり実装継承だけ

Rustスレでこんな初歩的なことを説明しなきゃいけないのはすごく悲しい
2024/07/08(月) 09:32:49.17ID:QAb8fFud
今回はいつまでやるの?
2024/07/08(月) 09:42:44.60ID:jJBNmhlI
>>647
実装継承の意味を理解したほうがいいんじゃね?
ある型Aの実装を別の型Bが継承することが実装継承と呼ばれているんだよ
これは不必要に依存関係が強すぎて片方を機能拡張しようとしたときなど破綻を招きがち
だから実装継承となるのは避けるべきと言われているね
2024/07/08(月) 10:06:04.28ID:eiH/KN8v
ワイの思う継承はenum_dispatch crate でやれるから困ったことないなぁ
お前らの心の中の継承は知らんがw
2024/07/08(月) 10:42:22.99ID:UCsocQnW
分数はバカっぽい
有理数と言え
2024/07/08(月) 10:42:53.94ID:29FzOd3r
>>647
Rustに実装継承はないけど
継承があり重複コードを回避できている
2024/07/08(月) 10:43:30.84ID:29FzOd3r
例えばどんな型でどんな内部構造でも
その型にトレイトのnext関数を実装するだけでイテーレータとして機能するが
その時に他のメソッド(nthとかmapとかfoldなど)のコードを自分で書かなくても自動的に継承されて機能する
2024/07/08(月) 10:44:27.48ID:29FzOd3r
これをデフォルト実装と言い特定の型の構造に全く依存しないコードのみを書くことができる
つまり問題を起こす実装継承とならず
Rustでは健全な継承が実現されている
2024/07/08(月) 10:55:22.37ID:6tgHXwg2
複オジの耳に念仏
まさに>>630
2024/07/08(月) 11:03:01.23ID:aq0ZJn08
デフォルト実装の制限のかけ方が成功の肝かな
トレイトなので各型のメンバーフィールドには一切アクセスできないため実装継承が上手く回避されてる
2024/07/08(月) 11:27:47.73ID:Qb4+6aEo
「実装は継承しているけど実装継承ではない」w
2024/07/08(月) 11:38:02.68ID:0gbetOzk
複オジ論法は無敵だな
2024/07/08(月) 11:49:10.64ID:aq0ZJn08
>>657
他の型の実装に実装が依存することが実装継承と呼ばれてる
2024/07/08(月) 13:25:29.85ID:QAb8fFud
継承の本当の問題は、LSPを満たさない部分型関係を作ってしまいがちということ
他の型の実装に依存するのが良くないというのはDIの話で、直接は関係ない
2024/07/08(月) 13:56:53.31ID:0on8bWSc
うそん
crate製作者サイドでCargo.toml内の
他のcrateへの依存関係の描き方がいい加減だと
割りと頻繁に詰む
人間が追跡して治して行けば使えなくもないが
cratesは破綻する可能性がある
2024/07/08(月) 15:03:24.53ID:HJF+848e
クレートdownloadでか過ぎ

どうみてもどんぐりです
ばいばいおさるさん
ころころす
2024/07/08(月) 17:42:30.38ID:NWN6grys
>>660
クラスを用いる言語では必ず満たすべきLSP(リスコフの置換原則)が頻繁に守られていない現実から
GoやRustなどモダンな言語はクラスそのものを廃止して改善したわけだ
他の型の実装に依存するのが良くないのも当たり前の話でそこは各型へ移譲しなければならない
2024/07/08(月) 18:36:24.36ID:jkhWqaDw
>>663
LSP全然理解してないんやな
クラスの有無とか全く関係ないぞ
2024/07/08(月) 18:41:05.12ID:BP+Tby1x
>>657
ジワジワくる
2024/07/08(月) 19:00:42.33ID:lBXxnkJT
>>657が実装継承とは何かすら理解できていなくて草
2024/07/08(月) 23:32:15.60ID:HOKpNi7I
所有権といい継承といいLSPといい
某オジは抽象概念を捻じ曲げるスキルが高すぎだろ
2024/07/09(火) 00:42:48.79ID:m6Akkl5N
>>660
LSPは派生型がその基底型を継承する時その振る舞いは同じで代替できるという当たり前な話なんだが
クラスはこの件でも欠陥があるため意識してプログラムを書かないとLSPに反してしまう
Rustはクラスがなくトレイトは枠組みだけで基底型ではないためLSPは全く関係ないぞ
2024/07/09(火) 02:24:36.95ID:ZNKPIxXk
>LSPは派生型がその基底型を継承する時その振る舞いは同じで代替できるという当たり前な話なんだが

0点
2024/07/09(火) 11:02:57.90ID:Gz8hLZg7
書けば書くほど無知をさらしてしまう複製オジさん草る
2024/07/09(火) 12:31:29.17ID:B8U2Xwe0
>>664
対象となるものはクラスしかないよね
2024/07/09(火) 12:39:43.65ID:YflJELWV
>>668
φ(x) を型 T のオブジェクト x に関して証明可能な性質とする。このとき、φ(y) は型 T のサブタイプ S のオブジェクト y について真でなければならない。

φは主に事前条件・事後条件・不変条件で、言語によっては例外条件も入ってくる。
この観点からはRustのTraitは力不足。なんでLSPを引き合いに出せるのかわからん。
2024/07/09(火) 12:57:46.02ID:aoAam1/W
>>672
自分でそれを書いておいて理解できていないのかよ
そこに明記されてるようにTもSもオブジェクトを持つ具体型についての話だ
Rustのtraitは具体型ではないため関係ないぞ
そしてtraitを実装する各型の間にはサブタイプの関係はないためそこも対象とならない
そこを理解できずに「RustのTraitは力不足」とデタラメを吹聴するのは恥ずかしい
2024/07/09(火) 13:01:26.64ID:YflJELWV
>>673
事前条件とかはどこ行ったの?
2024/07/09(火) 13:20:56.23ID:aoAam1/W
>>674
φ(x) のxはオブジェクトと明記されてるのが見えないのかね
さらにSはTのサブタイプと明記されている
Rustのtrait自体はオブジェクトを持たない
さらにtraitを実装する二つの型同士にサブタイプの関係は生じない
つまり対象外でφが存在しないため事前条件も何もない
2024/07/09(火) 13:35:41.29ID:YflJELWV
>>675
>明記されてるのが見えないのかね
>Rustのtrait自体はオブジェクトを持たない

それは「RustのTraitはLSPと関係ない」と言いたいの?

>φが存在しないため事前条件も何もない
事前条件も何も表明できないのは「力不足」そのものですな。
2024/07/09(火) 14:43:14.46ID:Tc+iYmTn
リファクタリングするとき
プログラム(CPU)の動作の副作用は起きないけど
コーディングの変更に対して副作用が大き過ぎるというか広過ぎる
2024/07/09(火) 15:17:32.29ID:l7dFkPpL
>>673
マジでLSP全然理解してないんやな
LSPは具体型かどうかなんて全く関係ないぞ
2024/07/09(火) 15:20:15.91ID:aoAam1/W
>>676
LSPに明記されている前提すら満たさない異なるものであるため
「RustのTraitはLSPと関係ない」で合っている
LSPが対象としている遺物における諸問題に悩まされずに済むように
新たな視点で整理されたより良いものとしてRustのTraitが提供されている
2024/07/09(火) 15:28:08.29ID:aoAam1/W
>>678
LSPは具体型のみが対象
抽象型を対象にしようとしても適用するにはそのいずれかの具体型となる
2024/07/09(火) 17:53:13.80ID:uNqr/AfO
https://x.com/shuzaibusoku7/status/1809567812555542920
リアル複おじ
2024/07/09(火) 20:23:57.43ID:YflJELWV
>>679
RustとLSPが関係ないのなら、LSPを引き合いに出すのは大嘘か。
知ってて言っているなら詐欺師だな。

そもそもTraitでpanic禁止にできない時点で「LSPが対象としている遺物における諸問題に悩まされずに済む」というのも大嘘だしな。
2024/07/09(火) 20:49:10.75ID:sTXYSGuF
簡単な話だよな
オブジェクト指向プログラミングで
例えばクラスを使うと
LSPに違反する二つの型のコード例を容易に作れてしまう
つまりクラスは本質的に欠陥品なんだよ

Rustのトレイトを使うと
LSPに違反する二つの型のコード例を作ることができない
つまりRustのトレイトは優れた方式なんだよ
2024/07/09(火) 21:07:20.42ID:YflJELWV
>>683
あるトレイトでpanic2を禁止しようとしました。事前条件(あるいは例外条件)でnopanicとしたかったけど、そんなのは無いのでとりあえずデフォルト実装でpanic禁止にしました。
しかしトレイトユーザーはそんなのお構い無しにunsafe rustでpanicを使います。ついにpanicが発生してシステムダウンしました。

LSPでケアしている問題はRustのTraitを使っている限り発生しないんじゃないんだっけ?
2024/07/09(火) 21:56:05.19ID:sTXYSGuF
Rustのトレイトは優れているため
LSPに違反するコード例を作ることができないんだよ
もしRustに文句をつけたかったら
LSPに違反する二つの型のコード例を作って示してごらん
Rustで違反例を作るのは不可能だよ
2024/07/09(火) 22:08:43.14ID:ZNKPIxXk
>>685
Rustに文句をつけたいとかではなく
>>660でLSPに言及された途端に実装継承とか言わなくなって「最初から自分はLSPを理由に継承のダメさを語ってましたけど」って態度でイキリ倒してるの(+結局理解してなさそうなの)がバカにされとるんやで
2024/07/09(火) 22:36:56.01ID:YflJELWV
>>685
>>684みたいに、
トレイトがpanicを禁止したいのに、ユーザーのトレイト実装がpanicを返す
というのはLSP違反だろ。
2024/07/09(火) 22:44:26.63ID:loMF79su
LSPはそんなことを要求していないよ
LSPをちゃんと読んで理解しようね
2024/07/09(火) 22:50:55.17ID:aoAam1/W
>>686
クラスは様々な問題点を抱えている
クラスでは実装継承となるため異なる型同士に不必要に過度な依存関係をもたらす硬直性も問題点の一つ
クラスはLSP(リスコフの置換原則)を満たさないプログラムが量産されてしまう問題点も別の一つ
どちらの問題点もRustならtraitを使うため問題が起きない
2024/07/09(火) 22:52:12.26ID:j8eVmrRh
猿ども落ち着いてください!

ここで論破合戦したところでなんの得にもなりません
691デフォルトの名無しさん
垢版 |
2024/07/09(火) 22:57:23.83ID:/lHavWP5
>>685
リスコフの置換原則は設計的な原則だから言語仕様で違反を防ぐことはできないぞ
悪名高い長方形・正方形の問題はトレイトがあっても起こり得る

trait Rectangle {
 fn set_width(&mut self, width: i32);
 fn set_height(&mut self, height: i32);
 fn width(&self) -> i32;
 fn height(&self) -> i32;
 fn area(&self) -> i32 { self.width() * self.height() }
}

struct Square { len: i32 }

impl Rectangle for Square {
 fn set_width(&mut self, width: i32) { self.len = width; }
 fn set_height(&mut self, height: i32) { self.len = width; }
 fn width(&self) -> i32 { self.len }
 fn height(&self) -> i32 { self.len }
}

fn func(x: &mut impl Rectangle) {
 x.set_width(3);
 x.set_height(4);

 // xが長方形であれば以下が成り立つはずだが、Square型を渡された場合に失敗する
 assert!(x.area() == 12);
}
2024/07/09(火) 23:17:09.97ID:dptasXVA
>>691
長方形がトレイトで正方形が構造体とか意味不明なんだが他の形はどっちにするんだ?
おかしいだろ
2024/07/09(火) 23:22:06.46ID:J+Fyw0mO
>>691
トレイトは機能を表します
2つの異なる長さを持つ(受け取る)機能を定義しているのならば
正方形はその実装型にはなりえません
694デフォルトの名無しさん
垢版 |
2024/07/09(火) 23:24:11.46ID:KAvgjhF7
>>692
IRectanble トレイトとかに読み替えてくれ
これは設計的に問題のある例を恣意的に示しているので不自然な点はあるけど、意図は伝わると思う

分かる人は分かると思うけど、問題は「そもそも正方形はwidthとheightという2つの値を扱うインタエースを持つべきでない」というところなので、Rectangleトレイトを作った時点で破綻している
けどそれは設計の問題なので、トレイトという仕組みによってコンパイラが防げるものではないということ
695デフォルトの名無しさん
垢版 |
2024/07/09(火) 23:30:16.52ID:KAvgjhF7
>2つの異なる長さを持つ(受け取る)機能を定義しているのならば
>正方形はその実装型にはなりえません
論理的にはそう
でも実際にそういうコードを書けばビルドは通る

>>685
>LSPに違反する二つの型のコード例を作って示してごらん
>Rustで違反例を作るのは不可能だよ
とあったので、これはその反例として示した
このような問題は設計の問題であり、まずい設計をする人が使えばRustでも問題は起こり得るということを言いたい
2024/07/09(火) 23:35:35.51ID:h2DmPYHm
>>691
君はLSPを理解できていない
LSPはis-aの関係を持つ二つの型に対して遵守すべきルールだ
Rustのtraitとその実装型はis-aの関係ではなくhas-aの関係を持つ
したがってtraitとその実装型は明らかにLSPの対象外となる
2024/07/09(火) 23:40:48.87ID:h2DmPYHm
>>695
LSPに違反する二つの型はis-aの関係を持つsupertypeとsubtypeでなければならない
>>691はhas-aの関係なのでLSPに違反する二つの型のコード例とはなっていない
2024/07/09(火) 23:56:35.46ID:ZNKPIxXk
>Rustのtraitとその実装型はis-aの関係ではなくhas-aの関係を持つ

すげーのが出てきたなこりゃw
2024/07/09(火) 23:59:12.82ID:loMF79su
LSPはis-a関係に対して守るべき原則
has-a関係に対してLSPの適用は論外
コード>>691はLSPの違反例となっていない
2024/07/10(水) 00:09:07.13ID:H4rrLaXL
メンバ関数名をそのままtraitの名前にしちまえば
そのメンバを持つ者とtraitの関係はhas-a
701デフォルトの名無しさん
垢版 |
2024/07/10(水) 00:10:24.05ID:HryWiaEt
過去に見た (rust以外の) プロジェクトの失敗例だと
・もともとFooというクラスがあった
・新しく作るBooクラスについて、Fooクラスと同じように扱えれば既存コードをあまり変更しなくても済むぞ!と誰かが気づいた
・その人物は Foo クラスのメソッドを元に IFoo インタフェースを定義し、それを Foo と Boo に実装させた
ことから混沌としたコードが生まれた例がある

この失敗をやらかした人は、Rustでも同じように「既存の Rectangle クラスを元に IRectangle トレイトを作り、それを Rectangle と Square に実装させる」ことをやりかねない

Rustではそれが不自然なパターンになりやすいし、起こりにくくはあるけど、本質的には設計の問題
702デフォルトの名無しさん
垢版 |
2024/07/10(水) 00:29:11.77ID:HryWiaEt
「Rustを書く人はみんな賢いからそのような問題は起こさないはずだ」というなら話は別たけど
実装者の設計能力は言語仕様によって担保できるものではない
2024/07/10(水) 00:33:23.92ID:L/ekmjSC
>>701
それらインタフェースやトレイトを用いている時点でLSPの対象外となっている
LSPを満たす必要がないどころかそんな制限があったら支障が出る
>>691のコードをLSP違反例として出してきたのは明確に間違い
おバカな設計例としてならば理解する
2024/07/10(水) 00:35:49.38ID:L/ekmjSC
>>702
おバカな設計を言語仕様で防げるなんて主張は誰もしていない
あなたが勘違い思い込みで暴走している
2024/07/10(水) 00:36:32.00ID:NGyo+F/O
LSPを全く理解してないばかりか
サブタイピングも理解しとらんのやな
よう継承継承言うたなぁw
2024/07/10(水) 00:53:28.80ID:ur6BKR72
クラスが問題だらけの欠陥品なことが災いを招いてるよね
モダンなプログラミング言語の多くがクラスを捨て去ってくれて感謝
2024/07/10(水) 01:13:16.99ID:1XduDtMr
>>688
>>679の言う「LSPが対象としている遺物における諸問題に悩まされずに済むように」するためには必要なんだよ。
LISKOVのA behavioral notion of subtyping でも「include exception」と言っているだろ。

まぁ、panicが例外にもなれないそびえ立つクソだからRustから排除すべき、と言うなら同意するが。
2024/07/10(水) 01:26:45.94ID:UJdk5M3g
>>707
LSPはsuperclassとsubclassといったような関係を持つ型同士について満たすべき話が書かれてるんよ
その前提を無視してpanicがどうこう言い出してるからズレとるんよ
2024/07/10(水) 01:45:22.45ID:1XduDtMr
>>708
それを言うなら>>682で言っている通り、RustのTraitでLSPに言及するのが大嘘なんだよ。

RustのTraitは同じTraitでも簡単に異なる振る舞いを実装できる(panicみたいな致命的な振る舞い含め)のに、「LSPが対象としている遺物における諸問題に悩まされずに済む」とかの大嘘が出てくるのは何ともアホらしい話。
2024/07/10(水) 02:13:28.47ID:1XduDtMr
>>698
RustのTraitとImplの関係はまさしくsubtypeだしis-aの関係なのにな。「継承しなければsubtypeじゃないしis-aにもならない」と間違って覚えているんかね。
2024/07/10(水) 02:30:31.13ID:GS4KrVsy
どこかで聞きかじっただけの「継承は悪」に辻褄を合わせようとしてどんどん変な理屈を積み重ねているだけでしょ
2024/07/10(水) 02:33:48.76ID:H5PXuDT2
>>707
LSPでは例外を返すなら基底型で返す例外とそのサブタイプのみに限られるとしか言及していない
例外で値をキャッチできなくなることや値を返す抜け道になることを防ぐためだ

ちなみにRustのpanic!では値を返すことはできなくてpanicメッセージのみ
そして普通のプログラムでpanicをキャッチすることはない点など前提が全く異なる
Rustで従来の例外を扱うケースはpanic!を使わずにResultの返り値で返す
したがってpanic!はLSPで出てくる例外の話に該当しないだろう
2024/07/10(水) 03:06:35.71ID:mzDH1NTP
>それらインタフェースやトレイトを用いている時点でLSPの対象外となっている
間違ってるよ
インターフェースだろうがトレイトだろうがサブタイピングは成立するよ
サブタイピングが成立すれば当然LSPの対象範囲だよ

>>691の例もLSPの違反例としては合ってるよ
間違った継承の使い方の例としてよく使われてるよね
2024/07/10(水) 04:10:08.62ID:xXJVwGE7
>>684
>panic禁止にしました。

たとえno_std環境であろうとpanicは禁止にできない

>unsafe rustでpanicを使います。

panicを引き起こすのも扱うのもunsafeを必要としない

>panicが発生してシステムダウンしました。

panic発生がそのままシステムダウンではない
何ら特別な設定をしない標準状態でもスレッド内で起きたpanicはエラーとして返るだけで他のスレッドは動き続ける
2024/07/10(水) 07:01:39.33ID:H4rrLaXL
>>710
型クラスのinstanceであると宣言すればsubtypeじゃないのは自明だぜ
じゃあtraitをimplすると宣言したら
自明だった問題が突如として最先端の未解決問題に変化するのか?
しないでしょ
同じでしょ
716デフォルトの名無しさん
垢版 |
2024/07/10(水) 07:02:08.59ID:HryWiaEt
>>704
ずっと「オブジェクト指向言語のクラスが抱えている問題はRustでは起こらない」と主張してる人がいるでしょ
それに対して、そんなことはないよと言ってるだけ
2024/07/10(水) 07:35:50.92ID:1hn7S5X0
>>716
あらゆる問題が解決されたという話は出てないでしょ
クラスが抱えてる問題でRustによって解決されてる様々な例が出ているだけで
2024/07/10(水) 08:46:54.18ID:1XduDtMr
>>714
だからLSPが対象としている諸問題はRustじゃ解決しないと主張しているんだよ。

>>715
implの実装次第なのに、
「LSPが対象としている遺物における諸問題に悩まされずに済む」と言っているアホが居るのよ。
そんな機能はRustのTrailには無いわな。

>>717
「遺物における諸問題に悩まされずに済む」と言っているアホが居るのよ。しまいにはRustとLSPは関係無いとか言うし。
そんなわけ無いだろと主張している。
2024/07/10(水) 12:00:16.62ID:GhKm8r1f
>>718
そのアンカ先は全部複オジだろ
LSPも知らない、サブタイピングも知らない、継承で起こりうる簡単な問題も知らない
にもかかわらず知ったかぶりして嘘を並び立てる
こんなやつがそうそういるわけがない
720デフォルトの名無しさん
垢版 |
2024/07/10(水) 12:37:44.86ID:1YSFCzN+
キチガイは1人見かけたら10人はいると思え
721デフォルトの名無しさん
垢版 |
2024/07/10(水) 13:29:52.02ID:kPG9kWdt
>>701
そのやり方がなぜ悪いのか理解できませんので、教えてください。
例えば、C++だと、以下の様にするのも別に悪いやり方ではないような
気がするのですが。
class Number {・・・};
Number add(Number &a, Number &b);
Number mul(Number &a, Number &b);
class Integer : public Number {・・・};
class Rational : public Number {・・・};
2024/07/10(水) 13:32:41.05ID:2GPD5dJ4
ChatGPTってモノシリなんですね?
723デフォルトの名無しさん
垢版 |
2024/07/10(水) 13:34:42.29ID:kPG9kWdt
>>721
改めて見てみると、add()やmul()の戻り値にNumberの実態を返しているのがおかしい気もしますが。
IntegerやRationalにadd()やmul()を仮想関数として定義するのが良いのかもしれません。
そのような点で改良の余地が沢山ありそうです。
2024/07/10(水) 13:47:33.33ID:2GPD5dJ4
>>720
色んな板の色んなスレをみて来ているが
どこにでもいるのは事実
2024/07/10(水) 14:42:18.00ID:H4rrLaXL
10人いると思ってる人自身が11人目になりやすいから気をつけなよ
数値の計測が抱えている問題は、そもそも計測していない人には起こらない
2024/07/10(水) 15:49:38.80ID:WriLZMcZ
>>721
add(integer, rational)できる?
2024/07/10(水) 16:24:23.57ID:2GPD5dJ4
ミイラとりがミイラになるのは昔から
2024/07/10(水) 16:42:16.40ID:aw6hROvm
>>712
>例外で値をキャッチできなくなることや値を返す抜け道になることを防ぐためだ
違うよ
勝手な想像でLSPを誤解釈しないで

substituteされる型Tに対して定義された仕様上(契約上)の振る舞いを
substituteする型Sが満たしてなければLSP違反
つまり仕様上panicを禁止したトレイトの関数を
panicする関数でimplしたらLSP違反

LSPではあくまで”仕様上定義された振る舞い”が問題
2024/07/10(水) 18:28:13.04ID:/bwWoePd
>>728
panicを禁止という概念も方法もなく不可能だよ
何をしたいの?
2024/07/10(水) 21:04:08.95ID:H4rrLaXL
catchするという対案がない
対案との比較が抱えている問題はそもそも対案がない言語では起こらない
2024/07/10(水) 21:42:13.36ID:DHf/HCo5
>>729
そいつはRust叩きで連投していた>>684
panicを禁止できると思い込み
unsafeを使うとpanicできると思い込んでいる
732デフォルトの名無しさん
垢版 |
2024/07/10(水) 22:01:49.20ID:HryWiaEt
>>721
「インタフェースを定義し、それに基づいて実装する」という設計なら問題ないのだけど、
これは「あるクラスに依存していたコード群が新しいクラスでも動くようにするため」という発想になっており、大規模な開発だとこのやり方はだいたい失敗するよという話

例を書きづらいけど、例えば「A社製の装置を制御するアプリ」があったとして、
新しく「B社製の装置も制御できるようにする」という追加の開発案件があったとする。
この時点ではまだADeviceControllerは抽象化されておらず、A社装置の仕様に強く依存したクラスであるとする。
これを「ADeviceController が持つメソッドを IDeviceController として取り出し、それを BDeviceControllerにも実装させる」とすると確実に事故る。
「B社装置にだけある機能Xを呼びたい」「A社装置にあった機能YがB社装置にはない」といった違いを吸収しきえれず、インタフェースがぐちゃぐちゃになったり、「呼んでも何もしない」とかの形で誤魔化したり、呼び出し元でサブクラスの判定が必要になったりする

こうならないようにするには
a. 具体的な機器に依存しない、機器の振る舞いを適切に抽象化したインタフェースを定義する
b. 代数的データ型を使う
という方法があり、 Rust では b. の方法も使いやすいので、個人的にはそこが良いなと思う
733デフォルトの名無しさん
垢版 |
2024/07/10(水) 22:15:46.44ID:b9m+kH0p
設計が悪いといえばその通りなんだけど、そのせいでインタフェースが崩壊しているプロジェクトは実際にあるし、RustやGoが継承を廃止した理由の一つでもあると思う
クラス継承だとこの問題はもっと簡単に起こりやすい
前述の例は (あくまでも見かけ上は) インタフェースを定義しており、クラスを継承してるわけではないので、Rustのトレイトでもやろうと思えば起こるけどね
2024/07/10(水) 22:19:25.73ID:FlmWdBd4
言語を選ぶにあたって継承の有無は選択肢に入らんし正直言ってどうでもいいわ
代替手段があるのにいつまで言ってんだ
2024/07/10(水) 22:32:22.87ID:dGMDZq55
>>729
仕様を定義するという簡単なお話がほんとにわからないのかな?

panicを例にすると頭がパニクるみたいなので
リスコフの論文にあるFIFO/LIFOの例で言い換えると
仕様としてLIFOの振る舞いを要求するトレイトの関数を
FIFOの振る舞いで実装したらLSP違反ってこと

簡単なお話でしょ?
2024/07/10(水) 22:40:16.17ID:H4rrLaXL
既に言語を選んだのにまだ、is-aとhas-aどっちにするか選べとか
catchするかしないか選べとか
言語の内部でいつまでも選択が繰り返されるシステムが謎なんよ

いつまで言われるかといえば謎が解けるまでだよ
2024/07/10(水) 23:21:18.85ID:visgGGe9
>>732
それは共通インターフェースと特定装置にしかないインターフェースをそれぞれ別で用意すべきだと思う
拡張メソッドや拡張トレイトも活用する

ただA社装置もB社装置も1つの共通したコードで扱うなら
サブクラス判定ではないにしても呼び出し元での分岐は何かしら必要
2024/07/10(水) 23:44:27.81ID:6pwTfhEs
>>733
RustやGoは違う方法で継承を行っているというだけで継承を廃止したというのは誤解
わざと誤解させてるという面もあるにはある
2024/07/11(木) 00:29:09.09ID:dTTJ6k+i
クイズ
JavaScriptのプロトタイプチェーンはis-a?
それともhas-a?
2024/07/11(木) 00:30:41.75ID:sJ7PGs8/
>>732
一般的に何らかの上位層と下位層があるときに
Rustではその界面にtraitを置いて
上位層はそのtraitを利用する側
下位層はそのtraitを実装する側
とSILIDのDIP (Dependency Inversion Principle)にするのがそのa.だね
もしクラスでやるときは抽象化を徹底した上で色んな注意が必要になるところ
Rustは自然にコーディングできてありがたいね
2024/07/11(木) 01:01:01.84ID:sJ7PGs8/
スマソ
SILIDはSOLIDのタイポ
2024/07/11(木) 01:26:06.15ID:sLOW5r2m
>>740
インターフェース知らないの?
2024/07/11(木) 01:37:36.53ID:sJ7PGs8/
>>742
インタフェースは各言語で付加仕様がバラバラ多種多様だから慎重に言うと
それ自体はフィールド変数など持たず完全に抽象化できつつ
実装必須メソッドとデフォルト実装提供メソッドがサポートされて
その中で利用可能な他のインタフェース(またはtrait)群による制約ができて
となるとどの言語が残るかな
2024/07/11(木) 03:34:06.04ID:huEwUyFV
それはたぶんDじゃなくてIかな……
745デフォルトの名無しさん
垢版 |
2024/07/11(木) 09:53:46.09ID:TzM2Jqw+
https://doc.rust-jp.rs/ 終了の件
2024/07/11(木) 11:33:08.04ID:gcQpVY2c
>>744
DもIも両方関係あるよ
2024/07/11(木) 11:36:08.08ID:gcQpVY2c
>>743
インターフェースが使えるメジャーな言語は全部残る
C#, Java, Kotlin, Swift, TypeScript, Dart
2024/07/11(木) 11:46:30.35ID:ITTQebkb
ʕ◔ϖ◔ʔ
2024/07/11(木) 12:31:18.41ID:QtPgEU0q
>>747
ウソはあかん
2024/07/11(木) 13:53:08.83ID:gabJiib7
>>747
サーバー用途で強いJavaは残るね
Kotlin/Swiftもモバイルアプリのネイティブ言語として残る
TSはJSで十分っていう風潮が漂いつつあるけどまあ残るだろう
死ぬのはC#とDartかな
2024/07/11(木) 14:12:48.49ID:0oGtZVd6
LSPで嘘ばっかりついてたのがバレたから
またしょうもない話をはじめてごまかそうとしてるのか
いい加減にしろよ
2024/07/11(木) 16:22:35.45ID:o6wwWo1Z
LSPに書かれていることすら読まずに
RustのトレイトがLSPの対象だと言い張ってたもんな
2024/07/11(木) 16:57:46.28ID:acwFdQNv
PartialOrdとPartialEqの一貫性とかLSPっぽいけど
Substitution(置換)とはちょっと違うんだよな
無理矢理Sに当てるならSurrogation(代用)あたりか
これをLSPに含めるかは定義重視vs意味重視で意見が分かれそう
2024/07/11(木) 17:15:40.81ID:HnhcW2rv
LSPはsupertypeのインスタンス(オブジェクト)とsubtypeのインスタンスの振る舞いを比較してそこで満たすべき原則を挙げていますから
Rustのtraitをsupertypeとしてみてもそのインスタンスが存在しないため振る舞いの比較ができないですね
traitはLSPとは関係ない立ち位置にいます
755デフォルトの名無しさん
垢版 |
2024/07/11(木) 20:33:40.77ID:eOImp5ti
ごちゃごちゃ難しいこと考えてるうちにエンバグしたりなんかして。
2024/07/11(木) 21:02:05.21ID:qBSAH7HU
>>750
サーバー用途こそJavaはRustとGoに蹴散らされて終わるだろ
2024/07/11(木) 21:30:58.09ID:wPVHCKh0
実際のところRustはサーバーサイドで使われてるの?
2024/07/11(木) 22:25:27.54ID:A0mL7vqg
実際は派生クラスの方が支持されていたとしても基底クラスを蹴散らしてはならない
とLSPは言っている
2024/07/11(木) 22:35:40.65ID:Z3SFRt47
>>757
使われてないよ
2024/07/11(木) 22:47:57.53ID:Wdw77EAw
>>757
Rust利用のトップがウェブのサーバー側
この件は過去スレでも何度も出ているので興味あるなら見るといいよ
その理由も明白でリソースコスト削減が最も効くため
2024/07/11(木) 22:50:39.98ID:wG+w8SXo
サーバーは常時稼働させるものだからねえ
2024/07/11(木) 23:16:00.08ID:liPsU6bJ
>>757
GAFAMとかCloudflareとかトラフィックの多いとこに入ってるから誰もが必ずお世話になってる程度には使われてる
日本でサーバーサイドの仕事が沢山あるか、という意味ならそんなことはない
2024/07/11(木) 23:24:11.59ID:b01V4j67
世界中で着実にRustへ置き換わっていってるね
特にクラウドを利用しているとランニングコストに直結するので
2024/07/12(金) 00:13:00.93ID:0qGKBZrU
>>753, 754
トレイトの場合はLSPで言うsupertypeやsubtypeになるのは
トレイトを利用して作られるimpl Traitやtrait objectの型だよ

PartialOrd/PartialEqやFn/FnMut/FnOnceのように
supertrait/subtraitの関係にあるやつも便宜的にトレイトで互換性が語られるけど
実際はそれらを利用して作られる型についての話なのと同じなんだよ
2024/07/12(金) 00:16:45.77ID:U8/iJiIO
>>764
真面目に相手してあげるの偉いな
2024/07/12(金) 00:19:01.43ID:iZsWh24v
>>764
いいえ
traitが実装される具体的な型は全てsubtypeに相当する兄弟同士であるため
親となるsupertypeの具体的な型はありませんはありません
2024/07/12(金) 00:19:49.06ID:iZsWh24v
>>764
いいえ
traitが実装される具体的な型は全てsubtypeに相当する兄弟同士であるため
親となるsupertypeに相当する具体的な型はありません
2024/07/12(金) 00:47:16.73ID:KyXC0KGT
トレイトにはフィールド変数が一つもなくてメソッドも各個別型で実装されるものだから事前条件・事後条件など比較もできなくてLSP適用は無理でしょ

>>764
supertrait/subtraitの場合に例えばある構造体についてそのインスタンスはどちらも同一になるからLSPの前提である二つのインスタンス間での差は論じられないでしょ
2024/07/12(金) 09:52:35.34ID:bw8b12Bg
>>757
Rustは殆どどこにも使われてないよ
770デフォルトの名無しさん
垢版 |
2024/07/12(金) 10:23:09.62ID:LuKbokrL
「C言語は分かる。機械語も分かる、回路もわかる。30万払うからRustのメモリ安全のからくりをサクッとレクチャーしてくれ」
みたいなニーズがあっさり無料で満たされているべきだと思うんだ
2024/07/12(金) 10:57:31.20ID:KyXC0KGT
誤解は色々あるけど「努力すれば必ずゼロコストになるカラクリ」が
あると思ってるならそれが誤解だね
クイックソートやハッシュテーブルと同じく、最悪の場合のコストは低くない
2024/07/12(金) 11:16:56.09ID:LuKbokrL
間違ってたら指摘してくれ

メモリは唯一の所有者を持つ
所有者たる変数がスコープを抜けた時、もしくは所有者たる変数に他の値が代入された時、メモリは自動的に解放される
Rustの、メモリに関する様々な文法はひとえにレキシカルライフタイムのためである
レキシカルライフタイムすなわち字句的寿命は、プログラムを走らせなくともコンパイル時に変数の寿命が把握できる仕掛けである
メモリの使途に矛盾が発生しているとき、Rustコンパイラはエラーを吐く
2024/07/12(金) 11:28:19.38ID:LuKbokrL
そもそも動的メモリ確保一般を知っていますかって話で、
この質問にイエスと答えられる人は横着ができるべき
2024/07/12(金) 13:01:13.97ID:KyXC0KGT
>>771
Rustのゼロコスト抽象化はそういう意味ではなくてRustの様々な抽象化仕様を実行時の追加コストゼロで実現していることでしょ

>>772
値がムーブされないままスコープが尽きたらデストラクタが自動で呼ばれるだけでしょ
だからRcのように参照カウンタを用いて共有ownershipを提供する仕組みもあるよ
2024/07/12(金) 13:21:18.68ID:KyXC0KGT
唯一の所有者が存在することと所有者の情報を誰でも取得できることを
区別するのは少し難しい
大谷の家が実在することと住所を公表できることを区別できない人もいるかもしれない
776デフォルトの名無しさん
垢版 |
2024/07/12(金) 14:02:34.71ID:HU5SDXKx
「A が Bの継承クラスであること。即ち、C++で
class A : public B {・・・};
と書くのは『A is B』である時が良い事が多いですよ」
という説が有りますけれど、
「多い」というだけだと理解してたんですが、このスレの人には、このルール
を徹底徹尾適用できる言語を夢見ておられるようですね。
2024/07/12(金) 14:20:30.92ID:KyXC0KGT
ここでID何度か被ってきたけどポエムの人とID被ったのは初めて

>>776
クラス継承はメリットが少なくデメリットが多いと長年の共通体験で判明してそれが共通認識となっているから
様々な異なる方針のモダンな言語たちがクラス廃止の点では共通方針となっただけでしょ
2024/07/12(金) 15:35:12.29ID:4qvv2DeJ
何気なく cargo update すると後悔する orz
2024/07/12(金) 15:44:29.48ID:4qvv2DeJ
GAFAM は存在しない
今は GAMAM
2024/07/12(金) 15:46:16.40ID:4qvv2DeJ
>>772
drop(hoge)
2024/07/12(金) 15:49:17.77ID:4qvv2DeJ
>>773
Box
Rc
Arc
Cell
RefCell
OnceCell
Pin
2024/07/12(金) 17:11:30.65ID:LuKbokrL
>>780
サンキュー

>>781
そのあたり全然勉強してない
「相互に参照し合うあうメモリは持てません。それを制限してあまりあるメリットを提供します。どうしてもやりたい人のために別口を用意しました」
という事実が重要
783デフォルトの名無しさん
垢版 |
2024/07/12(金) 20:20:08.14ID:0tYdINiS
Rust製コードエディター「Zed」がLinuxにようやく対応
Windowsサポートにも期待

ttps://forest.watch.impress.co.jp/docs/news/1607906.html
784デフォルトの名無しさん
垢版 |
2024/07/12(金) 20:23:46.34ID:0tYdINiS
個人利用は無償 ~JetBrainsがRust向けIDE「RustRover」を一般公開
メモリ安全性を保障したプログラミング言語「Rust」の開発に特化した統合開発環境

ttps://forest.watch.impress.co.jp/docs/news/1607747.html
2024/07/12(金) 20:46:42.78ID:KyXC0KGT
別口を用意するとは?
RustらしくないRustを用意することかな

もし日本語らしくない日本語が何か成果を出したら
日本語らしさを学習したAIに都合が悪い
2024/07/12(金) 21:35:52.40ID:VV8L6PZC
>>784
慣れの問題なんだろうけど
vscodeがいい…
2024/07/12(金) 22:05:28.85ID:LuKbokrL
>>785
参照カウンタ等がその別口
逆に聞くけど全てを参照カウンタで書かないのはなぜ?
788デフォルトの名無しさん
垢版 |
2024/07/12(金) 22:12:50.70ID:VeLgD+zy
>>781
RcやBoxは分かりやすいけどStringやVecも動的確保だよね、ということに気付いてない人もいるかも?

Rustが良いのはムーブが基本なおかげで意図せぬメモリコピーが起きないこと
所有権を他に渡す (ある構造体から別の構造体にか、あるコンテナから別のコンテナにとか移動する) 際にコストが発生しない
C++は逆で明示的に move しないと意図せぬコピーが起こる
2024/07/12(金) 22:30:09.43ID:KyXC0KGT
>>787
強制されてないから
嫌なら使わなければいい
2024/07/12(金) 22:37:23.69ID:LuKbokrL
電気電子板の人が、Rustの特集やってるインターフェース誌を買って読んだけどわからんかったって言ってたよ
2024/07/12(金) 22:52:07.26ID:LuKbokrL
>>789
俺はそんなことしないよ
全てを参照カウンタなんて使わずに書かない理由を探る
2024/07/12(金) 23:03:04.47ID:IhFaP3QA
>>787
C++で常にshared_ptrを使うと遅い
参照カウンタを利用しがちなSwiftやNimは遅い
2024/07/12(金) 23:08:24.73ID:LuKbokrL
参照カウンタ自体は全然新しくない
Rustがそれを無くせない理由が知りたい
2024/07/12(金) 23:24:14.35ID:LuKbokrL
複数の所有者がいる場合に参照カウンタが有効なのは分かる
難しいのは循環参照
参照カウンタで何が書け、何しか書くべきでないか
795デフォルトの名無しさん
垢版 |
2024/07/12(金) 23:48:00.71ID:VeLgD+zy
>>793
メモリ安全性を提供するため
オブジェクトを共有するのに「所有権は1人だけが持ち、他はそれを参照する」仕組みだと、すでに実体が消えてるオブジェクトを参照する問題が起こり得る
Rustでは、そのようなオブジェクトは参照カウンター付き (RcやArc) にするか、ライフタイムにより「寿命の短いものが寿命の長いものを参照している」ことを示さない限りコンパイルが通らないようにすることで安全性を保証している

逆にC++は参照カウンターなしでも共有できるけど正しく実装しないとメモリ関連のバグを引き起こす
この手のバグはセキュリティの問題になり得る問題を特定しにくい等の厄介さがあるから、Rustはそれをコンパイル時にできる限り防ぐという考え
2024/07/12(金) 23:56:48.21ID:n+FrpY/U
同一スレッド内の別タスクと共有する時にRcを使う
別スレッドや別スレッドになりうる別タスクと共有する時にArcを使う
797デフォルトの名無しさん
垢版 |
2024/07/13(土) 00:02:12.31ID:mV5TIlCk
親子関係のようなオブジェクト間で相互参照するならWeakを使う
これはRcやArcから作るもので、「メインの所有者とそれを弱参照する共有相手」の関係になる
Weak側は相手がまだ存在することを確認できないと参照できないというもの
2024/07/13(土) 00:46:50.81ID:UG7jOJ2R
Rust の所有権システムは機械的に静的検証が可能なように設計されている。
しかし Rust のルールでの機械的静的検証で安全だと確信できないが実際には安全というケースは
ごく普通にあり、その内の典型的なものは実行時のチェックで補えるようにライブラリが整備されている。
2024/07/13(土) 02:23:43.98ID:k/Plwdnm
>>787
全てをRcで扱って渡すときはRcをclone()して渡せばライフタイムを気にしなくて済むが
参照カウンタとその増減のオーバーヘッドだけでなく
書き換えたいなら内部可変性を持ちそのオーバーヘッドも加わるとともに
スタック上で済むときも必ずヒープ利用となるオーバーヘッドもある
2024/07/13(土) 08:49:12.36ID:zzh5ASvo
zennとかqiitaとかのrust記事みてると
活発に描いてた人は2019-2022くらいで
その後更新されてないのが多い
みんな試しただけで使ってないのか
2024/07/13(土) 08:51:48.91ID:zzh5ASvo
>>784
いくつものバージョンのrustやそのバージョン用のcratesを
それぞれ独立に管理して切り替えて使える統合環境なら嬉しいな
venvみたいな
2024/07/13(土) 08:54:10.60ID:zzh5ASvo
>>788
>Rustが良いのはムーブが基本なおかげで意図せぬメモリコピーが起きない

doubt
2024/07/13(土) 08:56:33.88ID:zzh5ASvo
>>790
特集のRustは知らんけど
特集じゃなかったときのインターフェースで紹介されたRustは
(インターフェース誌の読者に多いであろう)C言語利用者に判り易く説明されていた
そういうスタンスだからC知らん人にはきついのかも
2024/07/13(土) 08:58:41.51ID:zzh5ASvo
>>793
無くせない訳じゃなくて
参照カウンタを使わない描き方は今でも充分過ぎるほど可能
特に純粋な関数型言語を使ったことのある人は後者の方が得意だろう
2024/07/13(土) 09:03:05.94ID:UG7jOJ2R
ムーブは管理上の概念で、低レイヤではコピーしてる。
Rust のムーブはカスタマイズの余地なくコピーする (最適化で消えることはある) が C++ のムーブはカスタマイズの余地 (ムーブコンストラクタの定義) があるので効率の面から考えると Rust のほうがよいとは言えない。
2024/07/13(土) 09:29:23.45ID:+smP1Ssu
>>801
venvはないわー
cargoやrustupだけでずっと簡単に管理できる
IDEをそれらをGUIから活用するだけ
2024/07/13(土) 09:38:04.64ID:4hBdJvP4
コマンドプロンプトを無くせない理由を考え続けているそこのあなた
まあいいじゃんそういうの
2024/07/13(土) 09:38:06.14ID:OKewYK0N
>>800
当時記事書いてた一人だけど、日本語書籍も増えたしいまさら書くことないんだよね
アドベントカレンダーがあるならネタ考えるか、くらい
自分はまだRust使ってるし、当時記事書いてた人たちもRust使ってるベンチャーとかに転職してて、だいたいみんな書いてるんじゃないかな
2024/07/13(土) 10:09:47.61ID:aKeOI53x
Rustはカンファレンスとか見てても最近は成熟したからなのか特に目新しいものはない気がする
2024/07/13(土) 10:11:38.51ID:CU8fyG8D
vscodeにできてjetbrains製ideにできないことってある?
正直jetbrainsのヤツのほうがvscodeより使いやすい
2024/07/13(土) 10:27:13.13ID:E2vTTaV1
JetBrains製品は金払ってまで使うほどVSCodeより優れてるわけでないだけで良いIDEではある
VSCodeを何故使うかは商用利用無料だからに尽きるんだわ
2024/07/13(土) 10:59:18.93ID:SqKWY/h6
>>767 >>768
>traitが実装される具体的な型は全てsubtypeに相当する兄弟同士であるため
>supertrait/subtraitの場合に例えばある構造体についてそのインスタンスはどちらも同一になるから
どちらも同じ勘違いをしてるよ
よく読もうね

What is wanted here is something like the following substitution property:
If for each object o1 of type S there is an object o2 of type T such that for all programs P defined in terms of T,
the behavior of P is unchanged when o1 is substituted for o2 then S is a subtype of T
2024/07/13(土) 11:00:31.54ID:l6/BNZgQ
仮にfleetが商用無料になるなら喜んでvscodeを捨てるけど金にがめついjetbrainsが商用無料で配るなんてありえない話
javaやkotlinならともかくrustなら商用無料のvscodeで十分
2024/07/13(土) 11:14:27.08ID:3n/3tOrD
>>812
そこでRustの場合はTがトレイトでSが構造体などの各型で
「impl T for S 」とS型にトレイトTを実装して
「let o1: S = ...」がS型の値(=オブジェクト)になる
『object o1 of type S』 ←存在する
『object o2 of type T』 ←存在しない
したがってRustのトレイトはLSPとなんら関係がない
815デフォルトの名無しさん
垢版 |
2024/07/13(土) 11:36:15.00ID:mV5TIlCk
よく分からんけど
fn do_somethg(x: impl T)
にS型のオブジェクトoを渡すなら、do_somethingにとって o is T が成り立つんじゃない?
この関数は渡された o が S1 なのか S2 なのかは認識しないのだし
2024/07/13(土) 11:44:56.49ID:4Ly9sDTU
>>815
fn foo(x: impl T)は単相化されて
fn foo(x: S1)と
fn foo(x: S2)の二つの関数になるんだよ
いずれにしてもxはS1の値かS2の値であって
Tの値は存在しないね
2024/07/13(土) 11:50:56.55ID:6r0IzkzM
>>813
さすがフリーライダー。
相手に対する敬意が毛ほども無い。
818デフォルトの名無しさん
垢版 |
2024/07/13(土) 11:54:54.91ID:mV5TIlCk
それはコンパイルのされ方の話であって意味の上での問題ではない気がする
Box<dyn T> なら動的ディスパッチされるわけだし
let x: T = ... のような変数を作れないという意味ならその通りだけど、それはオブジェクト指向言語におけるインターフェースでも同じでは
(それともインターフェースに対してLSPは成り立たない?)
2024/07/13(土) 12:02:36.42ID:7b/8td6H
>>812,814,816
なんで毎回飛んでレスするの?
2024/07/13(土) 12:09:19.16ID:Zf2Y/4l2
前も貼ったけどRustはこういうニーズを背負ってる

オブジェクト指向を学ばなかった話
https://qiita.com/adaiimps/items/e04ae03371435aeffe87

C++、ObjectiveC、JavaだったのがRust、LLVM、ELFになって、あーやっぱこっちの方が面白いねと、
好きも嫌いもなく色んな言語を学びまくってる人はLLVMは学ばないのかなと
2024/07/13(土) 12:15:08.95ID:SXOx4oHh
>>818
LSPでは「o1 of type S」と「o2 of type T」の二つのobjectの挙動を比較してるのよ
「o2」が存在しないと挙動の差を論じられないですよ
2024/07/13(土) 12:31:19.55ID:IqeBToeS
rust始めたけどtokioまわりの非同期処理が難しい…
2024/07/13(土) 12:34:40.11ID:UG7jOJ2R
置換原則に沿うかどうかは具体的な実装を検証しないとわからないし、大抵の場合に機械的に検証することは出来ない。
型をサブタイプの関係にするのは原則に沿う「ことにする」という表明になることはあるが、原則に沿うことの保証にはならんのだ。
824デフォルトの名無しさん
垢版 |
2024/07/13(土) 12:40:54.94ID:mV5TIlCk
>>821
>>812 を字義通りに解釈するならそうだけど、その文章はC#やJavaが登場する前の1988年のもので、現在のオブジェクト指向にそのまま適用して良いのか?と思う
インターフェースでない、実体のあるクラスの継承関係についてしか言えなくなるし

現在だとリスコフの置換原則は抽象インターフェースも含んで説明される方が多いように思う
「クラスを継承する際のみに適用できるルール」のように説明されてるのは、少なくとも自分は見たことがない
2024/07/13(土) 12:44:05.69ID:Bid5yHc7
お前らずっと同じ話をループさせてんな😅
2024/07/13(土) 12:51:22.30ID:kEBSnfkM
>>824
親(基底)と子(派生)の挙動の差で満たすべき条件をLSPは挙げてるよね
少なくとも親にも挙動(実装)が存在しないとLSPを満たしているかどうか言及できないと思う
2024/07/13(土) 13:43:19.43ID:4hBdJvP4
>>825
好き嫌いの感覚に素直に従えば面白味のないループはすぐ止まりそうなのに
2024/07/13(土) 13:52:54.97ID:E+PNnzD+
PartialOrd: PartialEqは
PartialEq(等価判定)を持つ型にPartialOrd(半順序判定)を追加するときに
a.partial_cmp(b) == Some(Ordering::Equal)

a.eq(b) (⇔ a == b)
が同じになることを期待してる

この場合の置換の対象は型のインスタンスではなく使われる型の関数だから
LSPをインスタンスの置換に限定するか処理の置換にまで拡張するかで結論が変わる

PartialOrdの追加はPartialEqを使ってる既存のコードに影響しないから
技術的にはLSPと無関係ともいえるし
PartialOrdとPartialEqの等価判定の互換性は概念的にLSPの対象とも考えられる
2024/07/13(土) 14:35:50.27ID:MYuplL5h
つまりRustのトレイトは
LSPの原義に従うと対象外となり
拡張して考えるとLSPを常に満たす
ことになるわけか
830デフォルトの名無しさん
垢版 |
2024/07/13(土) 15:25:32.20ID:mV5TIlCk
>>829
意味の上で考えるとしても「常に」は満たさないかと

struct MyString(String);
impl Clone for MyString {
 fn clone(&self) -> Self {
  Self("元の文字列と関係ない文字列".to_string())
 }
}

のようにすれば、そのトレイトが期待する動作に反した型は作れるわけで
引数や戻り値のシグニチャの同一性だけに注目するならtraitに違反することはできないけど、それなら継承やインタフェースでも同じで、「LSPに違反してはならない」という原則はそもそも意味がない (常に違反できないから) ってことになるし
2024/07/13(土) 15:38:58.70ID:MYuplL5h
>>830
それLSPのどの項目に違反してる?
LSPは振る舞いに関する形式的なものなのでそのような意味論にまでは踏み込んでいないよ
832デフォルトの名無しさん
垢版 |
2024/07/13(土) 15:50:29.46ID:mV5TIlCk
>>831
例えば
fn test_clone(x: impl Clone + PartialEq) {
 assert!(x.clone(), x);
}
はClone および PartialEq トレイトの振る舞いに依存したコードだけど、この振る舞いに反した型は作れるよね
トレイトは事後要件 (x.clone() == x) を定義できないし、そもそも Clone はそれを担保していないと主張することはできるけど、それならLPSって何のためにあるんだ?ってなるし
2024/07/13(土) 15:54:23.34ID:4hBdJvP4
「内在論理」に踏み込めば争いを解決できる説のようなものか
逆効果なのでは?
834デフォルトの名無しさん
垢版 |
2024/07/13(土) 15:55:51.56ID:mV5TIlCk
訂正
>>832 のアサート行は assert!(x.clone(), x) でなく assert!(x.clone() == x)
2024/07/13(土) 15:57:24.24ID:UG7jOJ2R
>>831
不変条件を弱められないルールだろう。
不変条件はシグネチャや定義域で表現できないものも含めた振る舞いの仕様全てのことで、挙動が (仕様に照らして) 望ましくなければ原則を満たさないと言える。
2024/07/13(土) 16:03:55.44ID:E+PNnzD+
829でPartialEq/PartialOrdを例に出したのは
この2つのtraitがsuper/subの関係にあるからで
Cloneとその実装型の関係とは別だよ
PartialEqとPartialOrdの等価判定についてのLSPを考えてる

PartialOrd: PartialEqとする以上
PartialOrdの比較はPartialEqの等価条件を保存すべき←LSP?
みたいな
2024/07/13(土) 16:10:18.20ID:MYuplL5h
>>836
確かにそちらの例は二つのトレイトがsuperとsubの関係だからLSPを満たしてるけど
>>830の例はLSPとは関係ないな
838デフォルトの名無しさん
垢版 |
2024/07/13(土) 17:43:27.19ID:mV5TIlCk
>>831
意味でなく形式に拘るなら「事後要件を弱めてはいけない」などのルールは、要件がプログラム等の形式で表現されない限りLSPの評価の土台にすら上がらないってことにならない?

Cloneトレイトは公式のドキュメントに

// Required method
fn clone(&self) -> Self;
Returns a copy of the value.

とあって、exampleでは実際に assert_eq を使って説明しているので、この説明を元にCloneトレイトを実装する型の妥当性を判断して良いように思う
これでもまだ「それは意味論上のものでしかない」というなら、逆にそれをクリアしてクラス間の振る舞いを示している現実的な例を教えてくれ
2024/07/13(土) 22:57:22.69ID:ZTGyFNne
>>838
それは単純な例だから上手くいってるように思い込めるんじゃないかな
例えばclassの場合はもっと複雑な例になってもsuperclassのコードと挙動が実際にあり
それとsubclassの挙動や(必要なら)コードと照らし合わせて判定できるよ

しかしtraitにはそれがないからドキュメントや付加assertなど一段上のメタ情報を用いなければ何も進めることができない
したがってLSPの枠組みと似てる面はあっても別物
2024/07/14(日) 04:00:15.58ID:xmUtANA3
知らんけど
JavaとかC#の世界でも、interfaceが実装者に要求する条件を実装者が実際には満たさない、って場合にLSP違反って言われるの?
ならRustのtraitでも同じこと言ってよさそうだけど、多分言わんよな
2024/07/14(日) 05:23:41.72ID:QaC7oPd0
継承なしのカプセル化だけなら普通のC言語でもできるし、再コンパイルの問題(変更を加えたファイルだけを再コンパイルすればいいという原則の破れ)も発生しない
それがそのままライブラリやオブジェクトの単位になったんじゃないの
2024/07/14(日) 06:49:30.82ID:ma8dE8UE
文系:xとは未知のもの
厨房:いや未知のものはyやろ
理系:未知のものはfですdf/dx=g(f)を解きます
2024/07/14(日) 07:37:29.94ID:iqWqiKXK
>>841
Rustのtraitにはクラスのような継承はないけど、抽象的なコードを継承できるよ
2024/07/14(日) 07:37:59.13ID:iqWqiKXK
例えばIteratorのtraitにはこのようにfoldメソッドのコードがあって

fn fold<B, F>(mut self, init: B, mut f: F) -> B
where
 Self: Sized,
 F: FnMut(B, Self::Item) -> B,
{
 let mut accum = init;
 while let Some(x) = self.next() {
  accum = f(accum, x);
 }
 accum
}
2024/07/14(日) 07:39:51.02ID:iqWqiKXK
未知のIteratorであっても重複コードを書くことなく自動的にこのfoldメソッドが使える
2024/07/14(日) 07:40:10.97ID:iqWqiKXK
クラスのメソッド継承との決定的な違いは、このコードにメンバー変数は一切登場せず、つまりいかなる構成の型からも独立した抽象的なコードであること
847デフォルトの名無しさん
垢版 |
2024/07/14(日) 09:23:36.10ID:JssLuzWj
fold って next とどうちがうん
848デフォルトの名無しさん
垢版 |
2024/07/14(日) 10:13:20.02ID:aq5pPuoi
>>847
nextはイテレーターを一つ進めるもの、foldやreduceはイテレーターに対して畳み込みを行うもの
例えば「配列内の全ての数値を足し合わせる」とか「全ての数値を掛け算する」「配列内の文字列を全て連結する」いった操作を行うものだよ

この類のものは他の言語でも使われるし、簡潔なコードを書けるようになるから知っておくと良いよ
配列等のコンテナに対して一般に map, filter, reduce と呼ばれる操作があって、そのうちreduceは「要素を畳み込んで1つの値にする」もの
畳み込む方法を関数で渡すもので、概念的には [1, 2, 3].reduce(add) や [1, 2, 3].reduce(multiply) のような形になる
渡す関数は関数のほかクロージャ (言語によってはラムダ式とも) も使える
こんな感じに抽象化するとfor文を使わなくて済むし、何をやってるかが明確になる
2024/07/14(日) 10:32:15.39ID:iqWqiKXK
言語によって呼び名や使い分けが微妙に異なるけど
Rustでは2種類をこう呼び分けています
foldは初期値を別途指定する万能型の畳み込み
reduceは初期値が最初の要素となる畳み込み
2024/07/14(日) 10:33:24.33ID:iqWqiKXK
そして万能型のfoldを呼び出す形で
このような特定の型の構造に依存しない抽象的なコードが
trait Iteratorに用意されているため使えます

fn reduce<F>(mut self, f: F) -> Option<Self::Item>
where
 Self: Sized,
 F: FnMut(Self::Item, Self::Item) -> Self::Item,
{
 let first = self.next()?;
 Some(self.fold(first, f))
}
2024/07/14(日) 11:05:51.89ID:iqWqiKXK
なぜ二種類あるのか?というと
長さ0だと最初の要素すらないため
reduceはOption型が返る特徴があります

例えば和を求める場合でも
長さ0だったらNoneになってほしいならば
reduce(|sum, n: i32| sum + n)

長さ0なら和が0となってほしいならば
fold(0, |sum, n: i32| sum + n)

と使い分けることができます
ちなみに後者はsum()メソッドが用意されています
2024/07/14(日) 11:33:51.37ID:iqWqiKXK
ごめんなさい
>>851で型指定「: i32」の部分は不要です
Iteratorの要素の型に必ず定まります
空配列[]から始めると型指定がどこにもないため横着してそこで指定しちゃったという顛末でした
2024/07/14(日) 12:47:51.97ID:JssLuzWj
>>822
tokio 自体は難しくないけど
cargo test と組み合わせると難しくなる罠
854デフォルトの名無しさん
垢版 |
2024/07/14(日) 12:50:40.22ID:JssLuzWj
>>848
map も reduce も filter も知ってるけど(pythonとかから)
fold は知らんかったd楠
2024/07/14(日) 12:54:55.73ID:JssLuzWj
>>850
python の reduce は初期値を [0] にするのも任意に設定するのも
同じ reduce という名前でいけるのが
Rust だと reduce と fold で使い分ける必要があるということね
Rust が面倒だと言うことは理解した
2024/07/14(日) 13:21:58.79ID:iqWqiKXK
>>855
そういうことではないよ
RustではOption型やResult型でエラーや異常値を含めて正しい状況を値として得られるんだよ
例えば長さ0で初期値なしの時に
Pythonだとエラーだよね
Rustは常に値として返してくれて今回はOption<Self::Item>型
2024/07/14(日) 14:06:11.77ID:CpW1/GRz
>>854
ML 系とか LISP 系の言語ではだいたい reduce や fold は用意されてるね。
ものによっては右側 (シーケンスの終端) から畳み込むとかのバリエーションもある。
2024/07/14(日) 14:15:44.82ID:iqWqiKXK
Rustならrev().fold(...)だね
2024/07/14(日) 15:28:53.80ID:QaC7oPd0
テンプレートが出てきたあたりからC++の勉強をやめたのだけど
これは「型を引数に取ってインスタンス化する」ということでおk?
それがトレイトをまたいだ場合、いつどこで誰が何してるか分からなくなる
ファイルをまたぐインライン関数みたいにソースレベルでなされること?
2024/07/14(日) 16:59:00.63ID:Q38o8Kq2
>>840
JavaとかC#の世界でも、interfaceが実装者に要求する条件を実装者が実際には満たさない、って場合にLSP違反って言われるの?
言われるよ
リスコフ本人が書いたJavaの本にも書いてある
2024/07/14(日) 17:32:49.60ID:Q38o8Kq2
>>839
>ドキュメントや付加assertなど一段上のメタ情報を用いなければ何も進めることができない
一段上のメタ情報であるspecificaitonを使いなさいというのがリスコフの教え
それがBehavioral SubtypingってものでLSPが伝えようとしてる原則だよ
2024/07/14(日) 20:15:07.35ID:QaC7oPd0
ああ、なんだ
クレート=ELFファイルだと思ってたけど違うのね
2024/07/14(日) 23:33:04.31ID:jL63bGYb
もちろんクレートはコンパイルしてELFに出来得る
2024/07/15(月) 00:49:06.25ID:iuOQZB5q
そうかCOFFあかんか。
AIXとかはどうするんだろう?
2024/07/15(月) 01:06:24.34ID:qZQFNGwo
LLVMのバックエンドにCOFFもあるよ
2024/07/15(月) 01:09:28.33ID:RXziJOxB
LLVMの役割
ELFもCOFFもXCOFFもいける
2024/07/15(月) 01:55:53.37ID:S6UfnUI4
>>860-861
なるほどね、本当に特定の言語処理系の型システムの実装が云々というところからは離れたところにある概念なんだ
あえて関連付けるなら、型システムの部分型付け関係がbehavioral subtypingにもなるように定義すべきであると
上位型が具体型であるために暗黙の条件が多数想定される状況では特にLSPを意識すべきだが、それに限定される概念ではないと
2024/07/15(月) 02:35:13.63ID:fmM+TfOR
supertypeの実装がない場合は
LSPの不変条件・事前条件・事後条件などsubtypeの実装と比較しようがなく
LSPの対象になりようがないよね
869デフォルトの名無しさん
垢版 |
2024/07/15(月) 03:42:20.85ID:csp8v2ux
docs.rs の左上のRマーク
今話題のRen4のマークに似てるね
870デフォルトの名無しさん
垢版 |
2024/07/15(月) 09:46:03.12ID:kpV4D65H
コレクションしないんだから狭義には参照カウンタはGCとは言えない。
広義には含めてやってもいいが。
2024/07/15(月) 11:20:28.28ID:qZQFNGwo
ライブラリは.rlibまたは.rmetaで、これもELFやCOFFとは別物
ふむ
872 警備員[Lv.1][新芽]
垢版 |
2024/07/15(月) 11:29:04.89ID:omk2e105
たしかにRマークってRustから周りのやつ外したような感じじゃん
2024/07/15(月) 11:58:24.83ID:K85WsTqt
Ren4のRマークはsans-serifのゴシック体だからRustのロゴとは全然違うだろ
本人のやる気、こだわりのなさをフォントで表現してるんだから
RustのRと一緒にしたら双方に失礼
2024/07/15(月) 13:14:40.10ID:ZO/EZAih
単に好みの問題だけど
ウィルスっぽくて気持ち悪い
好きじゃない
875デフォルトの名無しさん
垢版 |
2024/07/15(月) 14:14:44.43ID:ko+PCaVU
>>874
元々サビ菌がモチーフやからしゃーない
2024/07/15(月) 18:49:44.14ID:GgRIn2WF
独裁者にも見た目がダサい奴がよくいるけど言っても無駄だ
デザインの力とは全然違う別の力でねじ伏せてくる
877デフォルトの名無しさん
垢版 |
2024/07/15(月) 19:16:07.61ID:Vjas5sQD
ダサいという指摘に理由を説明しても、ダサいことは変わらないんだよな
言語がダサければ信者もダサい
うだうだ言いながらダサい服着てそう
2024/07/15(月) 22:03:42.65ID:e+J3OGv0
イテレータ要素をヒープに格納するにはこれでいいんか
.fold(Vec::new(), |mut v, t| { v.push(t); v })
2024/07/15(月) 22:12:32.29ID:S6UfnUI4
またイテレータの話してる
2024/07/15(月) 22:50:12.36ID:9YaXaz6n
>>878
collectしろや
881デフォルトの名無しさん
垢版 |
2024/07/15(月) 23:25:29.58ID:wT4qVw/w
>>878
分かって書いてるかもだけど一応
let v = (0..10).collect::<Vec<i32>>();
コンテナにまとめるならこんな感じに collect を使う
例えば文字を走査するイテレーターをStringにcollectするようなことも可

型パラメーターは推論が効くのでそれに任せても良い
左辺に情報があるならcollectの型パラメーターはいらない
let v: Vec<i32> = (0..10).collect();
要素の型が分かるなら、右辺のコンテナの中身は_で推論させても良い
let v = (0i32..10).collect::<Vec<_>>();
2024/07/15(月) 23:35:20.09ID:nug4GWMJ
クロージャにキャプチャさせれば既存ベクタへ格納も追加もできる
let mut v = Vec::new();
iter.fold((), |_, t| v.push(t));
しかしこれではfold使ってる意味がなくこれと一緒 
iter.for_each(|t| v.push(t));

もちろん正解は既存Vecへ追加なら
v.extend(iter);
新規にVecへ収集なら
let v = iter.collect::<Vec<_>>();
2024/07/16(火) 23:25:36.51ID:ab19AXDr
Foo::from_iter(iter)でもいいね
例えばVec::from_iter(iter)
特にIntoIteratorな時にinto_iter()を省けて見やすいよ
2024/07/17(水) 18:51:22.39ID:Hw1cPZyQ
イテレータをcollectしたい場合と
イテレータではないIntoIteratorを別の構造体に変換したい場合とは文脈が違うでしょ

from_iterを直接呼ぶのは基本的に後者
前者の場合にターボフィッシュ書かなくてもいいという理由で
from_iterを直接呼ぶのはidiomaticではない
2024/07/17(水) 21:48:43.22ID:3eay5eeN
前者のケースでfrom_iterを直接呼んでても分かるから別にいいよ
自分で書くときはcollect使うけど
2024/07/17(水) 23:54:54.61ID:zgRAxdKk
これは短い方がいい
let x = HashMap::<_, _>::from_iter(vec);
let x = vec.into_iter().collect::<HashMap::<_, _>>();
2024/07/17(水) 23:55:29.92ID:zgRAxdKk
これはほぼ長さ変わらないからどちらがわかりやすいか
let x = HashMap::<_, _>::from_iter(iter);
let x = iter.collect::<HashMap::<_, _>>();
2024/07/18(木) 01:10:31.87ID:CNIyJc+8
どちらも一度変数で受ける形になるので型アノテーションが必要なら
let x: HashMap<_, _> のように基本的には左辺に書く

HashMapなら型パラメータ部分も推論に頼らず
明示的に書くことのほうが多いかもしれない

イテレータをcollectしたい場合というのは
イテレータのメソッドチェーンで各種処理をしてから
最終的にcollectする形になることが多いから
from_iterの直呼びじゃなくcollectが好まれる
2024/07/18(木) 02:40:28.19ID:0QBRSK+b
ところでchronoって、しょっちゅうAPIが変わるし
やたら冗長な書き方になるし結構クソじゃない?
2024/07/18(木) 12:05:40.95ID:WL/aeG4d
書き方が気に入らないならtime-rsを試してみたら?
2024/07/18(木) 21:07:48.37ID:2m7Ost/Q
なるほど

trait Iterator {
 type Item;
 
 fn collect<B: FromIterator<Self::Item>>(self) -> B
 where
  Self: Sized,
 {
  FromIterator::from_iter(self)
 }
}
2024/07/18(木) 23:31:33.62ID:GQ1B8wHA
代数的データ型ってなんかすごいけど知名度がモナドより低いな
2024/07/19(金) 02:03:52.09ID:MUvBupZH
>>890
使ってみたけど、time-rsいいね
いつのまにかダウンロード数でchronoを上回る競合があったとは知らんかった
タイムゾーンの扱いがやや簡略化されてるけど、夏時間のない日本人的には問題ない
月を直接intで指定できないのが英語仕様やな……ってちょっと気になる
2024/07/19(金) 03:51:08.70ID:riLGg6QV
>>891
この各収納先への移譲と両側のトレイト境界が汎用化の肝
trait FromIterator<A>: Sized {
 fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self;
}
2024/07/19(金) 06:06:24.35ID:LryDU6eW
Rustはジェネリックとトレイト境界と抽象的なデフォルト実装のおかげで
安全で利便性の高いコードの汎用共通化に成功していますね
896デフォルトの名無しさん
垢版 |
2024/07/19(金) 23:21:36.34ID:rC6z5NUh
cloud strike のはテロルやね
897デフォルトの名無しさん
垢版 |
2024/07/19(金) 23:30:11.35ID:rC6z5NUh
>>886
let x; HashMap::<_, _> = vec.try_into()?;

>>889
+1
2024/07/19(金) 23:52:20.75ID:8WlCJE3Q
>>897
エラーとなりますた
2024/07/20(土) 00:12:48.41ID:bNknJoN/
>>896
ウィルスバスター以来の快挙やね
2024/07/20(土) 14:16:49.05ID:F167yFzL
>>898
; が : の間違いかな

>>899
暴落予想
note.com/asset_n_ichi/n/nceaa6f318b1e
2024/07/20(土) 23:38:20.92ID:6EAP68vq
>>897
HashMapとVecにTryFromが実装されていないから無理
FromIteratorが実装されているのでそれを使う
2024/07/21(日) 01:48:23.56ID:eUhj6//q
★┷┓
┃D┃
┃D┃
┃K┃
┃で┃
┃も┃
┃r┃
┃u┃
┃s┃
┃t┃
┃が┃
┃使┃
┃え┃
┃ま┃
┃す┃
┃よ┃
┃う┃
┃に┃
┗━★
2024/07/21(日) 09:43:03.00ID:QhoywuRk
>>901
こういうのが「Rustは学習コストが高い」って言われる原因なんだろうな
答えを知ってる人は判ってても答えを知らない人は判らない
答えを調べるのにコストがかかりすぎる
2024/07/21(日) 10:14:17.60ID:TGGT0XLq
とあるライブラリに変な癖があるという話は
どの言語でもあるからそういう話ではないだろ
2024/07/21(日) 10:29:10.85ID:U3c7smqS
イテレータ使ったことない
2024/07/21(日) 10:35:28.58ID:W0nR4Dwz
>>903
Rustはその点シンプルでクセもなく覚えやすい

基本的に複数の要素ならFromIterator
VecでもHashMapでも何でもいける
複数のcharやstrなどからString作成もいける
複数のstrやStringやPathなどからPathBuf作成もいける

Fromは基本的に単独要素や配列(=静的固定長)から他へ変換
2024/07/21(日) 11:03:59.33ID:BMrg5vDt
>>903
>>897のはコンパイルエラーの内容が読めればすぐわかる
エラーの内容が読める程度の基礎力は最初に勉強して身につける必要がある
そもそもtry_intoでどういうケースならエラーにして欲しいのか考えればおかしいことに気付く

サードパーティライブラリの学習コストは他の言語に比べると顕著に高いが
基本的な言語機能や標準ライブラリは言うほど高くない
JavaやC#あたりと比べるとむしろ学習コスト低いんじゃないかと思う
908デフォルトの名無しさん
垢版 |
2024/07/21(日) 11:04:04.35ID:xuKRyHnL
>>903
それくらいchatGPTで教えてもらえるだろ
2024/07/21(日) 11:14:46.17ID:BMrg5vDt
>>908
俺もそう思って試してみたけど駄目だね
エラーの簡単な原因とcollect使えみたいな代替案は出してくるけど
根本的な理解につながる答えを返せないだけでなくいろいろと間違った情報を返してくる
2024/07/21(日) 11:48:09.12ID:W0nR4Dwz
from_iter(array)で済むのに
なぜ配列からHashMapへのFromがあるのか理由はおそらく
配列からmoveするinto_iter()が数年前までなかったためだと思う
今は配列を含めて要素が複数なら→イテレータ利用→FromIteratorと覚えればよいかと
911デフォルトの名無しさん
垢版 |
2024/07/21(日) 11:54:05.33ID:9I2odrUJ
そもそもイテレーターとコンテナの概念を勘違いしてる可能性ありそう
別種のコンテナ同士の変換は (特別な対応がない限り) 直接的には無理で、イテレーターを介して中身の要素を走査すれば渡せるということ

みかん箱を冷蔵庫に変換することはできないけど、箱の中のみかんを1つずつ取り出して、それを冷蔵庫型に纏める (collect) ことはできるような感じ
2024/07/21(日) 12:08:53.38ID:QhoywuRk
今回は >>910 さんをベストアンサーとさせて頂きます
みなさんご協力ありがとうございました
2024/07/21(日) 12:17:32.86ID:rbHgMj6q
>>911
それは単に抽象度の違いであって勘違いでも何でもない
2024/07/21(日) 12:17:32.92ID:QhoywuRk
>>911
勘違いはしてない

use std::collections::HashMap;
use std::iter::FromIterator;

fn main() {
let u = vec![("hoge", 1), ("fuga", 2)];
let x: HashMap::<_, _> = u.into_iter().collect();
println!("{:?}", x);
let v = vec![("hoge", 1), ("fuga", 2)];
let y = HashMap::<_, _>::from_iter(v); // use std::iter::FromIterator
println!("{:?}", y);
let w = [("hoge", 1), ("fuga", 2)]; // array
let z = HashMap::<_, _>::from(w);
println!("{:?}", z);
}
2024/07/21(日) 12:21:47.94ID:QhoywuRk
なぜ Vec から HashMap は from が使えないのか?
の問いに GPT は答えてくれない
2024/07/21(日) 12:29:53.31ID:+gih9iRs
>>910
順番が逆
arrayにIntoIteratorが実装された方が先で
From array for HashMapのほうが後
2024/07/21(日) 12:32:17.29ID:BMrg5vDt
>>915
そこはFromのimplがないからと答えてくれる
coherenceの制約を先回りして答えてくれるかどうかは質問次第
2024/07/21(日) 13:57:28.77ID:W0nR4Dwz
>>916
ありがと
調べたらその順だね
そうなるとFrom<配列>だけを特別に用意した理由は配列が基本型だからだろうか
HashMap::from(array)のコードを見ると
HashMap::from_iter(array)とFromIteratorの実装を呼び出すだけなので
2024/07/21(日) 16:06:46.61ID:nMuf3u03
MapやSetのリテラルがないけどリテラルに近い感覚で初期化したい場合の代替策として用意されたのがFromの実装
2024/07/21(日) 16:20:17.13ID:BJsLblxy
_iterの5文字が節約できるメリットだけか
2024/07/21(日) 16:39:36.83ID:u5tRysNp
>>920
タイプアノテーションの要不要があるのでもっと節約できるよ
2024/07/21(日) 16:43:19.24ID:BJsLblxy
>>921
不要になる例を出して
2024/07/21(日) 17:05:45.63ID:QAZ3DYjh
FromがあるとIntoが使えるからHashMap返すときとか引数で渡すときに
HashMap::from([..])
の代わりに
[..].into()
で書ける

型を明記するletだと大差ないかも
let map: HashMap<K, V> = [..].into();
let map = HashMap::<K, V>::from([..]);
2024/07/21(日) 17:22:33.98ID:BJsLblxy
>>923
そこでタイプアノテーションが不要になる例はないよな
関数の引数型か返り型に書いている

into()と書ける件も
collect()と書けるから
FromIteratorに対してFromもあるメリットは3文字節約できるだけか
2024/07/21(日) 21:02:32.72ID:eUhj6//q
dyn traits以外にinto使うなよ。変換するんだから

let s = "Hello, world!";
let string = Into::<String>::into(s);

じゃなくて

let s = "Hello, world!";
let string = String::form(s);

だろ。
2024/07/21(日) 21:07:32.49ID:BUmQiTHC
は?
2024/07/21(日) 22:10:59.79ID:kEjkNYpd
>>922
use std::collections::HashMap;

fn main() {
let xs = [(1, "a"), (2, "b"), (3, "c")];
let map = HashMap::from(xs);
println!("{:?}", map);
}
2024/07/21(日) 22:23:54.17ID:vNf5wQaP
>>927
HashMap::from_iter(xs)で十分じゃね
2024/07/21(日) 22:30:45.10ID:kEjkNYpd
>>928
error[E0283]: type annotations needed for `HashMap<i32, &str, _>`
--> src/main.rs:5:9
|
5 | let map = HashMap::from_iter(xs);
| ^^^ ------- type must be known at this point
|
2024/07/22(月) 12:16:14.88ID:7a9cZObY
配列からのFromは機能が制限されている
struct HashMap<K, V, S = RandomState> { ... }
impl<K: Eq + Hash, V, S: BuildHasher + Default> FromIterator<(K, V)> for HashMap<K, V, S> { ... }
impl<K: Eq + Hash, V, const N: usize> From<[(K, V); N]> for HashMap<K, V, RandomState> { ... }
2024/07/22(月) 12:18:01.98ID:7a9cZObY
つまりFromは重いデフォルトハッシャーに固定されてしまっている
FromIteratorを使えば自由に速いものを利用できる
let xxx = HashMap::<_, _, FxHash>::from_iter(array);
2024/07/23(火) 01:07:15.84ID:XvQFw5Nb
HashMap::from(配列)の場合は
デフォルトハッシャーで困るユースケースは稀だから
APIのエルゴノミクスのために意図的にRandomStateに固定してる
そのおかけでタイプアノテーションなしで書ける

タイプアノテーション無しの場合はデフォルト指定の型を優先的に使うよう
Rustのコンパイラが改良されればこの辺の差はなくなる
2024/07/23(火) 01:10:26.97ID:XvQFw5Nb
>>931
>let xxx = HashMap::<_, _, FxHash>::from_iter(array);
FxHashのところはFxBuildHasherだね
let xxx = FxHashMap::from_iter(array);と書いたほうがいろいろ親切

親切設計のライブラリなら
let xxx = AHashMap::from(array);
のようにFromIteratorだけでなくFromも使える
934デフォルトの名無しさん
垢版 |
2024/07/23(火) 01:31:49.01ID:Rfg4Mjqa
tupleをiteratorしたいんだが無理?
2024/07/23(火) 02:50:50.92ID:l+hNtTPE
こういう意味?
let t = ("abcde", "fghijkl", "mno", "pqrstuvw", "xyz");
assert_eq!("abcdefghijklmnopqrstuvwxyz", Into::<[_; 5]>::into(t).into_iter().collect::<String>());
2024/07/23(火) 09:22:40.63ID:iSDzXJU2
同じ型だけの要素で構成されるtupleならいけそうだけど
色んな型ば混ざってるtupleはエラー出そう
2024/07/23(火) 11:25:10.18ID:ijWLrFq+
dynにすれば色んな型を混ぜられる
関数から返すときはBox<dyn ...>にする
例えば数値と文字列が混じる有名な例をRustでdynを使って書くと

type FizzBuzz = Box<dyn std::fmt::Display>;

fn fizz_buzz_iter() -> impl Iterator<Item=FizzBuzz> {
 (1..).map(|int| match (int % 3, int % 5) {
  (0, 0) => Box::new("FizzBuzz") as FizzBuzz,
  (0, _) => Box::new("Fizz"),
  (_, 0) => Box::new("Buzz"),
  (_, _) => Box::new(int),
 })
}

fn main() {
 for x in fizz_buzz_iter().take(30) {
  println!("{x}");
 }
}
2024/07/23(火) 17:24:06.93ID:hqmWVJB3
またFizzBuzzイテレータ書いてる……
939デフォルトの名無しさん
垢版 |
2024/07/23(火) 21:36:57.26ID:1jhTJKzb
>>936
Haskellだとタプルって構造体代わりだから、色んな型が混ざってる方が普通だけど…。
(ともすれば関数も入れるし。同じ型だけってのはリストのイメージ)

Rustじゃ用途違うん?
2024/07/23(火) 21:58:12.50ID:joaeWjir
タプルは型の制限なくバラバラでいいよ
今回はそれを>>934「iteratorしたい」なので
同じ型に揃えるためにdynかenumを使う
2024/07/23(火) 23:07:54.81ID:tKFzmUCx
ほとんどの言語でオブジェクトを返す時にヒープを使うから
RustでもBox<dyn>を使っても構わないけど
ライフタイムさえ満たしてやればヒープを使わずに&dynにできるよ

use std::fmt::Display;
type FizzBuzz<'a> = &'a dyn Display;

fn fizz_buzz_iter<'a, T: Display>(i: &'a[T], s: &'a[&str; 3]) -> impl Iterator<Item = FizzBuzz<'a>> {
 (1..).map_while(|int| match (int % 3, int % 5) {
  (0, 0) => Some(&s[0] as FizzBuzz),
  (0, _) => Some(&s[1]),
  (_, 0) => Some(&s[2]),
  (_, _) => i.get(int).map(|int| int as FizzBuzz),
 })
}

fn main() {
 let i: [_; 256] = std::array::from_fn(|i| i as u8);
 let s: [_; 3] = ["FizzBuzz", "Fizz", "Buzz"];
 for x in fizz_buzz_iter(&i, &s).take(30) {
  println!("{x}");
 }
}
942デフォルトの名無しさん
垢版 |
2024/07/23(火) 23:38:39.26ID:QoNSkCmh
「tupleでイテレートできないの?」という質問に「こういうイテレータなら異なる型を混ぜられるよ」と回答するあたりがいかにもな感じ
率直に「できる/できない」で回答した上で補足として書けばいいのに
2024/07/23(火) 23:40:03.74ID:38zrS1+w
トレイトオブジェクトをdynと呼ぶのは複オジだけ
2024/07/23(火) 23:40:30.32ID:38zrS1+w
>>942
それな
2024/07/23(火) 23:49:18.56ID:lLea54if
Rust 2018 editionからdyn必須に変わった
2024/07/24(水) 00:02:23.05ID:QMkBbV1F
できる/できないで言えばできるよ

タプルの要素がすべて同じ型で要素数が12個以内ならFrom/Intoで配列に変換してイテレートする
それ以外ならextension traitで自前のイテレータを返すメソッドをタプルに実装する
他にも方法あるけどこの2つが主

タプルの型・要素数、イテレート時の型を汎用化したい場合はマクロが必須でそこそこめんどくさい
特にヘテロなタプルを汎用的にイテレート用の型に揃えるのはめんどくさい

本当にタプルで管理するのが望ましいのか
タプルで管理しつつイテレータで回すのがベストなのか
まずはよく考えたほうがいいと思う
2024/07/24(水) 00:15:33.28ID:sAqPevwn
dynを使えば型が何種類でもいけてトレイト境界も使えて楽だろうけどdynは重い
Fizz Buzzのように2種類の型で済むならEitherを使う
色んなトレイトを透過的に対応してくれている

use either::Either::{self, Left, Right};

type FizzBuzz = Either<usize, &'static str>;

fn fizz_buzz_iter() -> impl Iterator<Item = FizzBuzz> {
 (1..).map(|int| match (int % 3, int % 5) {
  (0, 0) => Right("FizzBuzz"),
  (0, _) => Right("Fizz"),
  (_, 0) => Right("Buzz"),
  (_, _) => Left(int),
 })
}
2024/07/24(水) 00:35:21.34ID:UKniupNy
リフレクションのサポートとかにもっと力入れてれば普通にできるんだろうけど、しゃあなし
Rustはそういうの好かない言語だから
2024/07/24(水) 00:44:54.58ID:djH/Nw1D
rustって流行るかな
950デフォルトの名無しさん
垢版 |
2024/07/24(水) 03:12:39.74ID:s3z853Sv
>>940
タプルをイテレーションしたい…。

リストとか、配列みたいに使いってことですよね?
Haskellでは無理ですが、Rustでは可能なのでしょうか?
(構造体代わりと言った通り、構造体をイテレーションしようと思わないですよね?)

Python,RubyのリストとHaskellのそれみたいに、そもそもの意味が違う可能性もありますし…。
951デフォルトの名無しさん
垢版 |
2024/07/24(水) 03:25:04.27ID:sCVmnNU/
>>935
let t = ("abcde", 123, "mno", "pqrstuvw", 456);
for e Into::<[_; 5]>::into(t).into_iter() {
println!("{:?}", e)
}
無理ポorz
952デフォルトの名無しさん
垢版 |
2024/07/24(水) 03:30:03.16ID:sCVmnNU/
>>946
それっぽいクレートがあるけどよう判らん
これはどんな感じ?
https://crates.io/crates/tuple-iter
2024/07/24(水) 03:57:10.87ID:yTLgnmif
これは典型的なXY問題だから相手にするだけ無駄
質問者は本当に解決したい元の課題Xを素直に話すべき
自分の思い込みで勝手に判断して進めた二次的な課題Yについて質問しているからそれについては相手にしなくていい
2024/07/24(水) 04:42:12.08ID:sCVmnNU/
>>946
imple IntoIterator for (&str, u64, &str, &str, u64) {
...
}
で出来るかと思ったけど
this is not defined in the current crate because tuples are always foreign
2024/07/24(水) 05:38:42.31ID:U0F2g2Py
dynやenumにしろと本質的なアドバイスをもらえているのに対応しようとしない人
2024/07/24(水) 07:25:15.81ID:Py4dd1Kh
たしかにXY問題だな
「異なる型が入り乱れてイテレートしたい」←何のために?
「異なる型が入り乱れてタプルがある」←どうやってそれが出来た?
957デフォルトの名無しさん
垢版 |
2024/07/24(水) 08:43:52.20ID:NUYI7xpt
・タプルは型を混合できる
・タプルはイテレートできない
・異なる型でのイテレートがしたいなら、タプルの代わりに Box<dyn Trait> のような動的型かenum (直和型) の配列を使う
で良いんじゃない?
2024/07/24(水) 08:43:57.79ID:sCVmnNU/
とりあえず出来ました
struct Hoge<'a> { t: (&str, u64, &str, &str, u64) }

impl<'a> IntoIterator for Hoge<'a> {
type Item = Fuga<'a>;
type IntoIter = std::vec::IntoIter<Self::Item>;

fn into_iter(self) -> Self::IntoIter {
vec![
Fuga::from(self.t.0),
Fuga::from(self.t.1),
Fuga::from(self.t.2),
Fuga::from(self.t.3),
Fuga::from(self.t.4),
].into_iter()
}
}
みなさんありがとうございました
959デフォルトの名無しさん
垢版 |
2024/07/24(水) 08:50:34.05ID:NUYI7xpt
XY問題だとか言うけど、上のFizzBuzイテレーターなんかはXとYのどちらとも関係ないでしょ
既にあるデータに対してイテレートする方法でなく、FizzBuzを0から生成するだけだから
それをしつこく何度も書くあたりが本物
2024/07/24(水) 09:24:46.95ID:eaHzhPzb
>>959
それな
2024/07/24(水) 09:30:08.78ID:+W2StRcH
意味のないFizzBuzzを散々書いておいて答えられなくなったら急に質問者を攻撃する複オジくん草
2024/07/24(水) 12:35:19.94ID:qFVR7Ywl
必要な個数のタプルを配列に変換するコードでいいんじゃないかな
これは長さ自由に機械的にマクロで生成できそう

struct Wrapper<A, B, C, D, E>((A, B, C, D, E));

impl<A, B, C, D, E> From<Wrapper<A, B, C, D, E>> for [Tx; 5]
where
 Tx: From<A> + From<B> + From<C> + From<D> + From<E>,
{
 fn from(x: Wrapper<A, B, C, D, E>) -> Self {
  [Tx::from(x.0.0), Tx::from(x.0.1), Tx::from(x.0.2), Tx::from(x.0.3), Tx::from(x.0.4)]
 }
}

impl<A, B, C, D, E> IntoIterator for Wrapper<A, B, C, D, E>
where
 Tx: From<A> + From<B> + From<C> + From<D> + From<E>,
{
 type Item = Tx;
 type IntoIter = std::array::IntoIter<Self::Item, 5>;
 
 fn into_iter(self) -> Self::IntoIter {
  let x: [Self::Item; 5] = self.into();
  x.into_iter()
 }
}
2024/07/24(水) 12:36:33.67ID:qFVR7Ywl
あとはタプルに登場する型を列挙して
例えばこんなコードを機械的に自動生成させてしまえばいいね

type T1 = &'static str;
type T2 = i64;
type T3 = f64;

enum Tx { T1(T1), T2(T2), T3(T3), }

impl From<T1> for Tx { fn from(x: T1) -> Self { Self::T1(x) } }
impl From<T2> for Tx { fn from(x: T2) -> Self { Self::T2(x) } }
impl From<T3> for Tx { fn from(x: T3) -> Self { Self::T3(x) } }

impl std::fmt::Display for Tx {
 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  match self {
   Self::T1(x) => write!(f, "{x}"),
   Self::T2(x) => write!(f, "{x}"),
   Self::T3(x) => write!(f, "{x}"),
  }
 }
}
2024/07/24(水) 12:38:12.03ID:qFVR7Ywl
そうするとタプルの中の型の順番は任意でよくて
タプルをラッパーにかませるだけで利用できるよ

fn main() {
 let tuple = ("abcde", 123, "nop", 0.456, 789);
 for x in Wrapper(tuple) {
  println!("{x}");
 }
 for (i, x) in Wrapper((-1, "pi", 3, 3.14159, "END")).into_iter().enumerate() {
  println!("{i}: {x}");
 }
}
2024/07/24(水) 12:43:52.56ID:mjGiit/q
効いてる効いてるw
2024/07/24(水) 12:49:36.37ID:TJmYfYAi
「XY問題だから相手にするだけ無駄」と言い放っておいてからの〜〜
2024/07/24(水) 17:04:11.48ID:1Kw3Uuff
もっと建設的な話題はないの?
2024/07/24(水) 19:14:00.84ID:UKniupNy
5chより建設的なコミュニティを列挙し移住を検討するのが目下最も建設的な話題である
969デフォルトの名無しさん
垢版 |
2024/07/24(水) 21:00:33.77ID:bzm5y73f
最近出た便利クレートの話とかすれば良いんじゃね?
2024/07/24(水) 22:25:44.31ID:mF9Tvkg9
ベストな日付処理クレートについて議論しよう
2024/07/25(木) 08:45:26.25ID:q/t9CUhu
おすすめクレートの話はしてほしいな~
2024/07/25(木) 10:09:56.78ID:P+cFrEvf
クレートの話をしてくれー、と
973デフォルトの名無しさん
垢版 |
2024/07/25(木) 22:41:22.06ID:zdgCFOr2
クレートではないけれど今日リリースのRust 1.80でLazyCell, LazyLockが安定版に入ったよ
グローバルな変数を外部クレート無しで書きやすくなる
2024/07/25(木) 22:49:30.69ID:9YYk7vP+
>>973
それ、OnceCell使ってたコードは全部置き換えた方がいい奴?
975デフォルトの名無しさん
垢版 |
2024/07/25(木) 23:18:37.32ID:zdgCFOr2
>>974
自分はそれを言えるほど詳しくないけど、必ずしも必要ではないと思う
依存クレートを減らせる点で嬉しいし、今から書くコードでは新しいものにして良いと思うけど、今使ってるものをすぐに置き換える必要があるとまでは思わない
特にライブラリを作ってる場合は、rustcを今日リリースされたばかりの最新バージョンに上げないとライブラリをビルドできなくなるということなので、もう少し待った方が良いかもしれない
2024/07/26(金) 00:25:09.02ID:/65SSmn2
OnceLockからLazyLockへ移行すると
変数宣言と初期化関数が離れていた可読性の問題が解決するとともに
例えばget_or_initを一箇所にするために一つ関数を用意したりするなどしていた手間も省けるようになるね
そして何よりも最大のメリットはDerefによりアクセスできる利便性
2024/07/26(金) 23:32:15.42ID:/65SSmn2
とりあえず定番のこのあたりを置き換えた
static RE: LazyLock<Regex> = LazyLock::new(|| Regex::new("...").unwrap());
static SE: LazyLock<Selector> = LazyLock::new(|| Selector::parse("...").unwrap());
2024/07/27(土) 11:02:49.38ID:WfV9QQMJ
LazyLockよさそうね
2024/07/27(土) 18:38:25.11ID:U5WpGSyZ
俺の今日のハマりポイントを紹介

bindgenにC++のコンストラクタを作らせると、データが壊れる
よく調べたら公式ドキュメントのConstructor semanticsに書いてあった
https://rust-lang.github.io/rust-bindgen/cpp.html

コンストラクタを抜けたとき、C++とちがってRustは値をムーブしちゃうので
struct内部を参照したポインタが変なところを参照してバグる
980デフォルトの名無しさん
垢版 |
2024/07/27(土) 19:30:58.99ID:s18eFGvS
C++も部分的に使えるとはいえ、FFIするならCのAPIにしておく方が無難な気はする
2024/07/27(土) 20:04:50.53ID:U5WpGSyZ
>>980
bindgenはFirefoxがプロダクトでたくさん使ってるって聞いて、いけると思ったんだ
Firefoxは大半がC++だから
982デフォルトの名無しさん
垢版 |
2024/07/28(日) 15:27:45.35ID:v6kdbv5j
>>978
LazyLockさようなら
に観えた
2024/07/28(日) 15:29:40.57ID:v6kdbv5j
>>979
RustとC++は相性最悪
RustとCは相性良いバッチリ
2024/07/30(火) 01:24:35.90ID:xgbf/AIH
>>979
この件って、RustはC++と比べて無駄にムーブするから遅いってこと?
2024/07/30(火) 06:04:09.29ID:RHAjweCG
無駄な移動は消える
cargo asmで生成コードを見ることでそれを確認できる
移動前と移動後のアドレスを表示させて最適化を阻害することで元は別々となる例も確認できる
986デフォルトの名無しさん
垢版 |
2024/07/30(火) 12:06:12.26ID:tiWzrJ23
>>984

>コンストラクタを抜けたとき、C++とちがってRustは値をムーブしちゃうので
>struct内部を参照したポインタが変なところを参照してバグる

って書いてるのに、読解力無い人?
2024/07/30(火) 19:02:27.28ID:dzXOiSL/
>>985
移動じゃなくてムーブね
ここまでのレスで使われてる述語を踏襲すればいいよ
2024/07/30(火) 20:13:33.28ID:VUdF4pDl
>>985
最適化のかかり具合でバグが消えたり現れたりする嫌なパターンだな
2024/07/30(火) 20:41:43.84ID:+5mpqNgW
>>986
Rustを使えばそんなバグは起きない
参照のライフタイムは参照先より長くなることがコンパイル時点で保証される

>>988
Rustならばそこでバグは起きようがない
990デフォルトの名無しさん
垢版 |
2024/07/30(火) 22:41:22.15ID:GjQxUZ/0
>>989
本人じゃないのに出しゃばらせて頂きますが…。

Rust単体じゃなくて、C++との相性問題ですよ。相性最悪って書いてるんだから。
起きようがないじゃなくて、実際に起きてるらしいじゃないですか。

最適化で治るのなら大したことじゃなくても、デバッグ時にハマるの確実な類のバグ。

将来的に全部Rustで書けば起きないような問題も、過渡期の今は良く起きます。

「Rustを使えば」「Rustなら」。
そうでしょうけど、実際問題ライブラリがなければ既存のC/C++ライブラリ使う場面は多々あるでしょう。
(枯れたライブラリならなおさら)

これはRustに限らず、後続の言語全てが抱えている問題です。
991デフォルトの名無しさん
垢版 |
2024/07/30(火) 22:49:06.91ID:MqLM+D1V
最適化じゃなくて単に移動の問題
Box::newで要素を直接ヒープに作れない (いちどスタックに作られてからコピーされる) のと同じで、コンストラクタを抜ける前に構造体が maybeuninit::assume_init で移動する
その上で構造体のアドレスがC++のメソッドにthisポインタとして渡される際に問題を引き起こす、というように思える
だとすると最適化の有無は関係なく起こる気がする

ついでにいえば >>987 もあまり意味のない発言で、移動はムーブの訳語でもある (例えばC++の仕様の訳語に移動コンストラクタという表現がある) し、そもそもこの問題はムーブセマンティクスによるものでもない
これはStringやVecが持つリソースを所有権ごと移動することで効率的に別の変数に割り当てるもので、構造体のアドレスのようなローレベルなものとは違うかと
992デフォルトの名無しさん
垢版 |
2024/07/30(火) 22:59:00.85ID:MqLM+D1V
移動とムーブが仕様として別物だというなら、移動は英語でどう表現されてるんだ?
2024/07/30(火) 23:00:06.83ID:L/ylOhaJ
>>990
それはRust単体では全く発生しない問題だね
C++とRustを併用する時にRustの知識を持たない人がハマるという話
FFI部分は両者の概念と挙動の違いの知識を持った人が作るべきだね
2024/07/30(火) 23:13:56.95ID:EnloT7kO
>>979
>>値をムーブしちゃうのでstruct内部を参照したポインタが変なところを参照してバグる

Rustでそのような自己参照はムーブでライフタイム切れとなるためバグは発生しなくて
自己参照を保ちたいならば値がムーブしなければよくて
値がムーブしないためにはスタック上でそのまま使うかヒープ上に確保して使えばよくて
それを保証するためにRustではPinという枠組みがあって安全に取り扱えるようになってるよ
995デフォルトの名無しさん
垢版 |
2024/07/30(火) 23:19:18.00ID:MqLM+D1V
>>994
bindgenの作者に言ってあげればいいと思うよ
ついでに改善したコードをPRしてコントリビュートしてみてはどうだろう
使用者のミスを擦るよりもずっと有意義なはず
996デフォルトの名無しさん
垢版 |
2024/07/30(火) 23:48:00.88ID:dZ3/RfBM
同意
997デフォルトの名無しさん
垢版 |
2024/07/31(水) 11:32:49.64ID:yHR2oE13
結合が密過ぎないかこの言語
998デフォルトの名無しさん
垢版 |
2024/07/31(水) 11:35:31.65ID:yHR2oE13
>将来的に全部Rustで書けば起きないような問題

さっさと仕事しろおまいらってことですね判ります
999デフォルトの名無しさん
垢版 |
2024/07/31(水) 12:10:03.24ID:yHR2oE13
>>985
Pin
1000デフォルトの名無しさん
垢版 |
2024/07/31(水) 12:10:59.00ID:yHR2oE13
Pin<Arc<T>>
10011001
垢版 |
Over 1000Thread
このスレッドは1000を超えました。
新しいスレッドを立ててください。
life time: 65日 5時間 29分 33秒
10021002
垢版 |
Over 1000Thread
5ちゃんねるの運営はUPLIFT会員の皆さまに支えられています。
運営にご協力お願いいたします。


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

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

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

▼ UPLIFTログインはこちら ▼
https://uplift.5ch.net/login
レス数が1000を超えています。これ以上書き込みはできません。
5ちゃんねるの広告が気に入らない場合は、こちらをクリックしてください。

ニューススポーツなんでも実況