Rust part12

**デフォルトの名無しさん** · 2021/08/24(火) 22:55:27.78

公式
https://www.rust-lang.org/
https://blog.rust-lang.org/
https://github.com/rust-lang/rust

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

日本語の情報
https://rust-jp.rs/

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

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

※C++との比較は専用スレへ
C++ vs Rust
https://mevius.5ch.net/test/read.cgi/tech/1619219089/

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

**デフォルトの名無しさん** · 2021/08/27(金) 19:45:18.24

あの会社もあそこもRust採用しているんだから絶対ヨシ！
https://i.imgur.com/aLxQE0R.jpg
https://i.imgur.com/NXcjrJA.jpg

**デフォルトの名無しさん** · 2021/08/27(金) 19:48:14.38

C++で苦しんできた連中は
Rustのやろうとしたことは分かるし
例え失敗に終わっても責める気にはならん
どうころんでもしょせん死屍累々
Rustは人類の明日への尊い礎になるだけ

**デフォルトの名無しさん** · 2021/08/27(金) 19:57:25.52

>>125
そいつが権威主義的思考なのは確かなんだが
新興言語は大手の技術力ある会社がスポンサーにいて
継続的な投資が行われることが確実視されてるかどうかはすごく重要なこと

**デフォルトの名無しさん** · 2021/08/27(金) 21:00:14.71

>>123
二つともわけの分からん企業だな。
自動車と電話会社。

**デフォルトの名無しさん** · 2021/08/27(金) 21:03:28.03

人々の関心の高さは感じるけどな。twitterとか見てると。

**デフォルトの名無しさん** · 2021/08/27(金) 21:07:48.98

でもtwitterでは、Pythonも活況だし、KotlinもRustと似たり寄ったりの数、検索される。
なぜかQtやRailsは検索されにくい。Djangoは沢山検索される。
cplusplusは僅かに検索される。C++やC#は直接的にはそもそもtwitterでは検索できない。
Rustの話題性がPythonやKotlinやDjangoと比べて取り立てて多いということではないようだ。

**デフォルトの名無しさん** · 2021/08/27(金) 21:44:01.80

The Bookは読まないくせにどうでもいいTwitter検索ばっかりしやがって

あーあのTwitterで独り言つぶやき続けてるひとだっけ？
忘れてた

**デフォルトの名無しさん** · 2021/08/27(金) 21:51:00.96

とにかく仕様が必要ならC++使えばよいのでは。主要メンバーがC++標準理解しているようなすごい人ばかりなんだろう

**デフォルトの名無しさん** · 2021/08/27(金) 21:58:56.53

>>138
自分達が「完全な仕様」と思えるものが存在することが重要視なんであって理解している必要はないんでしょ
ある種の宗教上の理由だよ

**デフォルトの名無しさん** · 2021/08/27(金) 22:04:01.75

実際は、Rails : Laravel = 8:2。
Django は、0

どこの学校・サロンもほぼ、Ruby on Rails

**デフォルトの名無しさん** · 2021/08/27(金) 23:00:14.26

確実にinline展開する方法ってある？
手動で書く？
マクロだとどうにかなる？

**デフォルトの名無しさん** · 2021/08/27(金) 23:01:33.75

>>134
自動車の制御はわからんでもない
即応性と安全性の両立を図らなければならないのだから

**デフォルトの名無しさん** · 2021/08/27(金) 23:13:16.52

#[inline(always)]でも100%ではないんだっけ？

**デフォルトの名無しさん** · 2021/08/27(金) 23:22:31.27

>>138
把握してないから必要なときにそれを調べればいいというようなまとまったものが必要なんだよ。

**デフォルトの名無しさん** · 2021/08/27(金) 23:40:58.77

Rust以外で高信頼性指向だとAdaとかMISRA Cとか？

**デフォルトの名無しさん** · 2021/08/27(金) 23:45:38.03

>>143
実装はわからんけど、スペック的にはalwaysも飽くまでヒントらしい

**デフォルトの名無しさん** · 2021/08/27(金) 23:52:40.05

>>145
MISRA Cは言語じゃなくてコーディング規約みたいなもん
組み込み以外では厳しくて準拠してられないと思う

**デフォルトの名無しさん** · 2021/08/28(土) 00:02:42.33

ファッション感覚のバカしかアピールしてない言語だわ。
c++理解してない奴がライフタイムをまともに理解できるとも思わん。
それもわからんバカがcをバインディングなんかしたら事故しか起きんわ。
安全性もクソもない。

**デフォルトの名無しさん** · 2021/08/28(土) 00:03:44.74

組み込み向けRustって1冊本が出たみたいだけど
実際のとこ、見込みありそうなの？
ただのホビー？

**デフォルトの名無しさん** · 2021/08/28(土) 00:05:05.86

>>148
C++ はわかっててもミスるんだってば。

**デフォルトの名無しさん** · 2021/08/28(土) 01:13:09.37

C/C++知らないと～と言う人には型理論知ってる？って聞きたくなる
コンパイルが通れば大体ちゃんと動くようになってるって感覚はhaskellとかOCaml寄りだと思う

**デフォルトの名無しさん** · 2021/08/28(土) 01:30:02.36

Haskell の型システムは好きなんだけど
さすがに副作用 (Haskell 的にはアクションだが……) の扱いがしんどすぎるし
元から C++ には慣れてるので C++ (というか C) 風な文法や意味論と
組み合わせた言語があったらいいなぁと思ってたので
Rust の台頭にはばんじゃーい ∩( ・ω・)∩

**デフォルトの名無しさん** · 2021/08/28(土) 01:31:18.92

おまえらスルー力低すぎやろw

**デフォルトの名無しさん** · 2021/08/28(土) 07:36:29.05

>>151
お前こそ型理論知らんだろ。。
型理論てのは結局どれだけ簡易な計算でエラーチェックするかってだけの話なんだよ。
正しく示すだけならただ単に全実行するのが一番良い。

**デフォルトの名無しさん** · 2021/08/28(土) 08:21:08.61

ガファムがファッションでプログラミングしてるとは知らなかった

**デフォルトの名無しさん** · 2021/08/28(土) 08:46:20.33

twitterでRustは話題性があるように見えるが、ためしにLISPやSchemeや
Clojure(言語)を検索してみてもRustと似たり寄ったりの書き込みがあった。
Haskelが次代を担う言語だ、的な書き込みすらある。

**デフォルトの名無しさん** · 2021/08/28(土) 09:10:33.46

今のgoogleじゃまともなc++プログラマもだいぶ減ってるわな。。
kumagiとかイキってるだけでまともに理解してねーじゃん。

**デフォルトの名無しさん** · 2021/08/28(土) 10:14:03.36

>>156
Haskellの型システムをRustは受け継ぎつつCG無しでメモリ安全性を達成しているので
Rustが実用的なプログラミング言語として現実に機能していますね

**デフォルトの名無しさん** · 2021/08/28(土) 11:32:23.88

CG無し

**デフォルトの名無しさん** · 2021/08/28(土) 11:39:53.86

特撮オンリーでいくわけですねわかります

**デフォルトの名無しさん** · 2021/08/28(土) 11:48:49.70

>>145
MISRAに従ってコーディングするの辛いぞ。

**デフォルトの名無しさん** · 2021/08/28(土) 12:14:36.47

>>160
特撮にはCG有るぞ

**デフォルトの名無しさん** · 2021/08/28(土) 12:24:36.28

次のようなloop文のプログラム(可動)を
while文やfor文に書き換えてわかりやすくしたいのですが
上手く値をbreakできないので助けてください

fn main() {
　let a = [3, 5, 1, 6, 9, 4];
　print_first_even_else_zero(&a);
}
fn print_first_even_else_zero(a: &[i32]) {
　let mut i = a.iter();
　let even = loop {
　　if let Some(&n) = i.next() {
　　　if n % 2 == 0 {
　　　　break n;
　　　}
　　} else {
　　　break 0; // not found
　　}
　};
　println!("{}", even);
}

例えばwhile文なら　let even = while let Some(&n) = i.next() { となりそうで
さらに可能ならfor文で　let even = for &n in a { となるかと思うのですが

**デフォルトの名無しさん** · 2021/08/28(土) 12:44:34.41

let even = a.iter().find(|n| *n % 2 == 0).unwrap_or(&0);

**デフォルトの名無しさん** · 2021/08/28(土) 13:03:12.27

>>164
当然それはわかりますが、for式やwhile式ではどうなるのか、という質問です

**デフォルトの名無しさん** · 2021/08/28(土) 13:07:44.67

前スレより

625 デフォルトの名無しさん 2021/08/16(月) 09:44:36.63 ID:MZWGbmHz
loop式はbreakで指定した値を返せるのに
なぜwhile式やfor式は値を返せないの？
Option型にしてbreakで値を指定した時だけSome(値)としてそれ以外はNoneとすれば便利なのに

630 デフォルトの名無しさん sage 2021/08/16(月) 14:32:54.40 ID:ebJKRLr3
手間かけて機能拡張するほどのメリットがないってことだろうね
https://github.com/rust-lang/rfcs/issues/1767#issuecomment-292678002

**デフォルトの名無しさん** · 2021/08/28(土) 13:08:21.57

そうでしたかすみません
forとwhileは値を返さないのでご想像のようにはなりません

**デフォルトの名無しさん** · 2021/08/28(土) 14:07:01.17

>>166
なるほど
そこでの議論を読むと一番の肝が、
「for式が()を返さないと、最後がfor式で終わる関数の返り値で互換性が無くなる」
というところにあるようですが
「break;」が()を返すことにすれば特に問題ないように見えます
実際にloop式で値なしのbreakだと()を返しています

つまり
・「for/while/loop式が返す型」は「break式の型」とする
・「値指定のない『break;』の型」は()とする
・「break式がない場合の型」も()とする
ここまでは現状と同じになりますね

問題はfor/while式はbreakせずともループを抜けるので、値を返すには、
・「『break 値;』があるfor/while式」は「else節を取ってbreak式と同じ型を返す」
という単純ルールだけで済むように見えます
何か見落としがあるでしょうか？

**デフォルトの名無しさん** · 2021/08/28(土) 14:41:22.43

8日前にちょうどその内容で開かれたRFCあるじゃん
イテレータで思考停止してたわ
https://github.com/rust-lang/rfcs/pull/3163

**デフォルトの名無しさん** · 2021/08/28(土) 15:14:25.46

>>169
なるほどありがとうございます

ところで現状のRustで>>163の例のloop式をfor式で行おうとすると
即時関数を使ってbreakをreturnに置き換えることで
let even = (|| {
　for &n in a {
　　if n % 2 == 0 {
　　　return n;
　　}
　}
　0
})();
と実現できることを思いつきましたが
この方法は表記コストはともかく実行コストもかかってしまいますか？

ちなみにこの「最初の偶数を見つけるコード」はあくまでも例として単純化したものを出しているだけで
実際には様々な例でこのパターン(＝forやwhileで値を返せると便利)が出てくるので簡略な例題として話をしています

**デフォルトの名無しさん** · 2021/08/28(土) 15:30:38.48

>>168
イテレータのコードのほうが遥かにわかりやすい上に簡潔なので
新しく文法を拡張する価値がないと開発陣は考えてる点を見落としてる。る？
特にPythonの失敗例を鑑みれば機能追加される可能性は限りなくゼロ

**デフォルトの名無しさん** · 2021/08/28(土) 15:43:20.61

>>171
現実にはfindより複雑なことでも使うだろうし
async関数呼び出して判断もあるだろうし
イテレータでは無理なことも多いのでは？

**デフォルトの名無しさん** · 2021/08/28(土) 16:01:24.35

Rustに限った話じゃないけど新しめの言語だとイテレータで記述可能な
ループは、出来るだけイテレータで記述するのが主流じゃね
forだのwhileはループ条件の誤りから簡単にバグが生まれるし
使わないで済むならそれに越したことはない
CやCの派生系言語がメインの人には理解しがたいかもしれないが

**デフォルトの名無しさん** · 2021/08/28(土) 16:07:59.88

C++ だとテンプレートの組み合わせで回すのも一般的だけど
Go だと凝ったことするよりなんでも愚直にループを回したほうがいいというのは
基本的なスタンスになってるよね。

**デフォルトの名無しさん** · 2021/08/28(土) 16:18:39.14

>>172
説得力のある実例を出せば今みたいにRFCが即closeされることはないんじゃない？

状況によってはイテレータを拡張したほうがいいという判断も有り得るし
今のforやwhileループみたいにmutで定義した変数を更新するのでも十分かもしれない

**デフォルトの名無しさん** · 2021/08/28(土) 17:39:28.92

>>173
なるほど
出来るだけイテレータで記述する質問です
コマンドライン引数の数字の和をイテレータでpanicさせずに求める場合
これよりもっと短く出来ないでしょうか？
fn main() -> Result<(), std::num::ParseIntError> {
　println!("Sum: {}", std::env::args().skip(1).map(|s| s.parse::<i32>()).collect::<Result<Vec<i32>,_>>()?.iter().sum::<i32>());
　Ok(())
}
以下のように正しく実行できているのですがコードが長いのが気になっています
$ cargo run 10 20 30 40 50
Sum: 150
$ cargo run 10 20 XX 40 50
Error: ParseIntError { kind: InvalidDigit }

**デフォルトの名無しさん** · 2021/08/28(土) 17:58:47.12

そんなに長い？

**デフォルトの名無しさん** · 2021/08/28(土) 18:59:50.15

twitterで「Rust過激派がルール違反と判断された」
「CやC++のこと書いてた人にRustの話吹っかけて迷惑かけてた怖い人たち」
という話を見たが、誰の事？
どういうことなんだ？

**デフォルトの名無しさん** · 2021/08/28(土) 19:21:11.03

>>178
c++テンプレートテクニックの著者のことか？

**デフォルトの名無しさん** · 2021/08/28(土) 19:24:41.12

>>61
int* p1 = malloc(sizeof(int));
int* p2 = malloc(sizeof(int));
int* p3;
if (なんかの条件) p3 = p1; else p3 = p2;
free(p1);
p1 = NULL;
if (なんかの条件) p3 = NULL;
// p2はまだまだ使う
こうすればいいだけの話だろ？ガイジか？
このコードの後 p2またはp3どちらかをfreeしても二重開放にならんよ
このぐらいも考えられないのかガイジは(笑)

**デフォルトの名無しさん** · 2021/08/28(土) 19:28:28.84

いちいち差別的な用語を使わないとレスもできないのか
プログラマとしては一流なのかもしれないが、人間としては最低だな

**デフォルトの名無しさん** · 2021/08/28(土) 20:41:09.02

>>177
このcollectしてから再びiterするところを何とか出来ないものかなと
println!("Sum: {}", std::env::args().skip(1).map(|s| s.parse::<i32>()).collect::<Result<Vec<i32>,_>>()?.iter().sum::<i32>());
イテレータだけを使う限界？

同じことをfor文を使うと短くなってわかりやすくなります
let mut total = 0;
for s in std::env::args().skip(1) {
　total += s.parse::<i32>()?;
}
println!("Sum: {}", total);

**デフォルトの名無しさん** · 2021/08/28(土) 21:00:48.99

std::env::args().skip(1).map(|s| s.parse::<i32>()).sum::<Result<i32, _>>()?

**デフォルトの名無しさん** · 2021/08/28(土) 21:02:35.90

ParseIntError返しても処理しないんだから
unwrap_or(0)みたいなので十分じゃないの？

fn main() {
let args = std::env::args().skip(1);
let sum: i32 = args.map(|s| s.parse().unwrap_or(0)).sum();
println!("Sum: {}", sum);
}

入力、計算、出力で分けてる

**デフォルトの名無しさん** · 2021/08/28(土) 21:14:51.79

>>184
非整数は飛ばす仕様になってる
エラーはエラーだと示すべきかな
あとエラー処理コードがないのは質問の本質じゃないからかと

**デフォルトの名無しさん** · 2021/08/28(土) 21:23:19.42

println!("{}", std::env::args().skip().try_fold(|sum, s| Ok(sum + s.parse::<i32>()?))?);

try_fold使うと?演算子の入る場所が変わらずに済むっぽいな

**デフォルトの名無しさん** · 2021/08/28(土) 21:24:03.32

>>183
なるほど!
sum()もcollect()のように様々な形の集積方法が指定できるのですね
i32整数一覧が入力に来るのにsum::<i32>()とi32型指定をしないと怒られた理由がようやくわかりました
sumとcollect以外にもそういう仕様のメソッドはありますか？

**デフォルトの名無しさん** · 2021/08/28(土) 21:34:12.61

いちいち固有のiterator使うとか可読性悪くなるだけって場合も多い

**デフォルトの名無しさん** · 2021/08/28(土) 21:54:20.22

>>186
素晴らしい!
少し修正して以下で上手く行きました
std::env::args().skip(1).try_fold(0, |sum, s| Ok(sum + s.parse::<i32>()?))?
fold()は知っていたのですがtry_fold()でOptionやResultの形でfold()できるとは便利ですね

ここまでまとめると
sum計算はResult型を返せるsum()があるので>>183でも行けて
このtry_fold()ならばsum計算以外にも汎用的に使えますね

**デフォルトの名無しさん** · 2021/08/28(土) 22:01:27.46

>>185
エラーだと示したいなら結果をハンドリングすればいいんじゃないの？

type Result<T> = std::result::Result<T, std::num::ParseIntError>;

fn main() {
let args = std::env::args().skip(1);
let sum: Result<i32> = args.map(|s| s.parse::<i32>()).sum();
match sum {
Ok(sum) => println!("Sum: {}", sum),
Err(e) => println!("Error: {}", e),
};
}

引数ゼロ個とかエラーは1種類じゃまかなえない
ハンドリングしたいならエラー設計がもう少し必要になるだろうね

**デフォルトの名無しさん** · 2021/08/28(土) 22:12:53.29

>>190
もちろんそんなことは皆わかっていて、最後のResultのErr処理は枝葉末節だから略して議論してるのだと思う
あとmain()でResult返してErrなら勝手にエラー表示してくれるみたいで便利
で、>>185で指摘したことは、>>184のunwrap_or(0)使用はエラーが消えるからマズいよね、ということでした

**デフォルトの名無しさん** · 2021/08/28(土) 22:34:29.66

>>191
何をそんなにカリカリしてるんだ？
main()でResult返したいなら別にそれでもいいんじゃない？

fn main() -> Result<()> {
let args = std::env::args().skip(1);
let sum: Result<i32> = args.map(|s| s.parse::<i32>()).sum();
println!("{}", sum?);
Ok(())
}

**デフォルトの名無しさん** · 2021/08/28(土) 22:53:59.26

>>192
皆がわかりきったことしか書いていなくて何をしたいのかわからないけど
Resultはエラー型も示さないとそのコードでは動かないよ

**デフォルトの名無しさん** · 2021/08/28(土) 23:36:35.98

今回はargs部分も枝葉末節なので外してまとめ直すと
『数値と思われる文字列の配列が与えられた時に非数値があればエラーを返すとして』
let a = ["1", "3", "5", "7", "9"];
和の場合はmap()でResultのままsum()に渡してResultを返せる
let sum = a.iter().map(|s| s.parse::<i32>()).sum::<Result<i32, _>>()?;
和だけでなく積などもtry_fold()を使えばResultを返せる
let sum = a.iter().try_fold(0, |sum, s| Ok(sum + s.parse::<i32>()?))?;
let mul = a.iter().try_fold(1, |mul, s| Ok(mul * s.parse::<i32>()?))?;
今回はparse()で文字列→数値のResultだけど一般的にResultを返す関数なら応用可能
皆さんありがとうございました

**デフォルトの名無しさん** · 2021/08/29(日) 09:06:24.35

>>179
指摘している人も、加害者もエピステーメー氏とは全く関係ない人だと思う。

**デフォルトの名無しさん** · 2021/08/29(日) 12:05:26.47

>>195
えぴすめーてーじゃないほうの共著者のほうでしょ

**デフォルトの名無しさん** · 2021/08/29(日) 13:31:13.01

ローマ字で takaha... の人のことか。
Ukic...の人も何か言ってるんだけどどういう相関関係なのか。。

**デフォルトの名無しさん** · 2021/08/29(日) 17:50:42.33

対立煽りに乗らないように

**デフォルトの名無しさん** · 2021/08/29(日) 20:28:38.19

>>174
Goは確かにその方針だけど、イテレータというか高階関数を受ける型が総称では無いから.collectや.mapなんて
型ごとに定義しないと使えないから。Go2になってくれば違ってくると思う
一方でPythonだとfunctools.reduceなんかより、リスト内包表記が使われるのは局所性で速度が速いからだけど
ループで書かずにかなり長い表現をこれで書かれると保守しずらい。
Rustでもイテレータを何回も取り出してcollectしたり、foldしたりをドットで繋げられるのはあまり読み易いとは
言えないと思う。普通にiter()を何度も呼ぶのなら、let it = a.iter();して欲しい

**デフォルトの名無しさん** · 2021/08/29(日) 21:26:36.38

そのitは一度しか使えないのでわ

**デフォルトの名無しさん** · 2021/08/29(日) 21:37:15.37

collect()したやつに.iter()は確かにやめてほしい
終端操作するなら何か変数に入れた上でやってほしい

**デフォルトの名無しさん** · 2021/08/29(日) 21:56:31.67

AdapterとConsumerは必ず分けろってこと？
もちろん分けたほうがいい場合もあるだろうけど
別に一緒でもいいと思うんだけどな

**デフォルトの名無しさん** · 2021/08/29(日) 22:06:52.56

>>201
中間変数を使うか否かだけの問題だからどうでもいい話
言語自体やその利用方法に本質的な問題があるわけではない

一方で>>199のGoの問題は深刻
Rustがトレイトで解決している分野だ

**デフォルトの名無しさん** · 2021/08/29(日) 22:08:51.10

上にあるコードでcollect()した後にiter()してるやつのことか
それなら分かる

**デフォルトの名無しさん** · 2021/08/29(日) 22:19:15.00

あぁそういうこと
俺は別に繋がってていいかな

**デフォルトの名無しさん** · 2021/08/29(日) 22:49:50.89

>>204
それコードを改善したいという相談やんけ
しかも最終的には>>194のコードへと短くわかりやすくなったのだからRustはよく考えられてるなあとしか

**デフォルトの名無しさん** · 2021/08/29(日) 23:12:51.30

>>206
だからこそcollect()した後にiter()してるコードは改善したほうがいいよって話だろ？

**デフォルトの名無しさん** · 2021/08/29(日) 23:54:47.37

和も積も求めたい時はどうすればいいかな?
文字列から数値への変換を二度するのを避けるとして
一つの方法はこのように一旦collectとして数値のVecを作ってしまう
fn main() -> Result<(), std::num::ParseIntError> {
　let input_numbers: Vec<i32> = std::env::args().skip(1).map(|s| s.parse::<i32>()).collect::<Result<_,_>>()?;
　println!("和: {}", input_numbers.iter().sum::<i32>());
　println!("積: {}", input_numbers.iter().fold(1, |mul, n| mul * n));
　Ok(())
}
それともcollectせずにイテレータのままで止めておいて使う?

**デフォルトの名無しさん** · 2021/08/29(日) 23:59:56.40

質問者とイライラ君が同一人物のパターン?

**デフォルトの名無しさん** · 2021/08/30(月) 00:06:07.90

product()使わないの？

**デフォルトの名無しさん** · 2021/08/30(月) 00:06:33.11

>>208
foldで和と差の2要素のタプルをとりまわせば良いだけ

**デフォルトの名無しさん** · 2021/08/30(月) 00:56:00.83

こうかな
println!("和: {}", std::env::args().skip(1).map(|s| s.parse::<i32>()).sum::<Result<i32,_>>()?);
println!("積: {}", std::env::args().skip(1).map(|s| s.parse::<i32>()).product::<Result<i32,_>>()?);
println!("(和,積): {:?}", std::env::args().skip(1).try_fold((0, 1), |(sum, mul), s| { let n = s.parse::<i32>()?; Ok((sum + n, mul * n))})?);

**デフォルトの名無しさん** · 2021/08/30(月) 01:17:16.84

>>209
っぽい

**デフォルトの名無しさん** · 2021/08/30(月) 01:45:40.23

C++君も

**デフォルトの名無しさん** · 2021/08/30(月) 05:11:39.37

この前はNim連呼してた

**デフォルトの名無しさん** · 2021/08/30(月) 05:23:26.66

二重解放NULL荒らしもな

**デフォルトの名無しさん** · 2021/08/30(月) 08:14:19.28

>>209
確かにこんな特徴的な勘違いをするやつが同時に二人出現するわけないわな

**デフォルトの名無しさん** · 2021/08/30(月) 08:46:37.85

じゃあワイはガリガリ君で

**デフォルトの名無しさん** · 2021/08/30(月) 09:38:42.61

>>214
C++ vs Rustスレでやれと何度言っても聞かずにここでイライラしてるよな

**デフォルトの名無しさん** · 2021/08/30(月) 10:38:26.28

上のイテレータ関連の質問に便乗ですが、
二次元vecの各要素をv[i][j]としたときに、
jごとの総和を計算するやつをイテレータできれいに書く方法ありますか？

例えばこういうやつです

let v = vec![vec![0; n]; m];
// (vの各要素を設定）
let mut result = vec![0; n];
for i in 0..m {
for j in 0..n {
result[j] += v[i][j];
}
}

**デフォルトの名無しさん** · 2021/08/30(月) 10:46:23.34

>中間変数を使うか否かだけの問題だからどうでもいい話

Rustの場合、ライフタイムとオーナーシップの関係で
中間変数を使うか否かは結構重要な問題だったりする

**デフォルトの名無しさん** · 2021/08/30(月) 10:56:01.57

>>220
mapしてsumすればいいだけでは？
きれいかどうかは知らんけど

**デフォルトの名無しさん** · 2021/08/30(月) 12:15:23.57

>>212
これ競プロ用でしょ
一般的なプログラミングとは観点が違うから最初に競プロ用だと書いておいたほうがいいぞ

**デフォルトの名無しさん** · 2021/08/30(月) 12:35:22.36

>>222
mapとsumで書けます？
iごとの総和なら単純に
v.into_iter().map(|v| v.into_iter().sum()).collect()
みたいな感じでいけるとおもうのですが、jごとだとちょっとわからないです

>>223
そうですね（実はもともとの発端は競プロではなかったりするのですが

**デフォルトの名無しさん** · 2021/08/30(月) 13:18:46.38

(0..n).map(|j| (0..m).map(|i| v[i][j]).sum()).collect()

2重forをの親子を逆転してイテレータメソッドチェーンに変換しただけという感じ
こんなことよりもっと意味のあることに頭使ったほうがいい
イテレータでとあったから上を書いたが現実にはndarray入れてsum_axis使うのがいいだろう
https://docs.rs/ndarray/0.15.3/ndarray/struct.ArrayBase.html#method.sum_axis

**デフォルトの名無しさん** · 2021/08/30(月) 13:30:16.69

こんなかんじかな

https://play.rust-lang.org/?version=stable&;mode=debug&edition=2018&gist=e302c841c8dd709418f923ea1ad07868

**デフォルトの名無しさん** · 2021/08/30(月) 13:33:43.06

ほぼかぶってたごめん

**デフォルトの名無しさん** · 2021/08/30(月) 13:38:15.69

>>225-226 インデックス自体のイテレータを作るって発想がありませんでした、ありがとうございます
競プロ用ではないしndarray使うのも考えてみます

**デフォルトの名無しさん** · 2021/08/30(月) 14:45:34.31

汎用的には縦横入れ替えのtransposeを作っておけば色んな操作が楽かもね
イテレータ作成はサボってとりあえず関数版
fn transpose<T>(v: &Vec<Vec<T>>) -> Vec<Vec<T>> where T: Copy {
　(0..v[0].len()).map(|j| v.into_iter().map(|vv| (*vv)[j]).collect::<Vec<T>>()).collect()
}
fn main() {
　let v = vec![vec![1,2,3], vec![4,5,6], vec![7,8,9], vec![10,11,12]];
　let w = transpose(&v);
　println!("{:?}", v); // [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
　println!("{:?}", w); // [[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]
}

**デフォルトの名無しさん** · 2021/08/30(月) 20:06:03.21

transposeみたいな関数用意すべきかは配列の要素数次第かなあ
たかだか1度しか読まないデータのためだけに配列全体をコピーするのはもったいないケースはありそう

**デフォルトの名無しさん** · 2021/08/30(月) 20:10:57.31

性能気にするなら Vec<Vec<_>> の形で数値格納するのではなく
Vec<_> に格納して (i, j) -> j*n+i みたいにインデックスを変換してくれるラッパーを被せた方がよさそう