可変参照を要素とする配列の要素の更新

Question

Rustにおいて、配列に可変参照を要素として持たせて、それらを一斉に変更させるようなコードを書きたいと思っています。
以下のコードはコンパイルが通りました。(rustc 1.38.0)

fn main() {
    let mut a = 1;
    let mut b = 2;
    let c = [&mut a, &mut b];
    add1s(c);
    println!("{}, {}", a, b);   // => 2, 3
}

fn add1s(c: [&mut i32; 2]) {
    *c[0] += 1;
    *c[1] += 1;
}

このadd1sの中身をfor文またはイテレータに対するfor_each(){...}に置き換えたいのですが、試しに

fn add1s(c: [&mut i32; 2]) {
    // *c[0] += 1;
    // *c[1] += 1;
    for x in c.iter() {
        **x += 1;
    }
}

としてみると、

   |
14 |     for x in c.iter() {
   |         - help: consider changing this to be a mutable reference: `&mut &mut i32`
15 |         **x += 1;
   |         ^^^^^^^^ `x` is a `&` reference, so the data it refers to cannot be written

と言われてしまいます。*xはa, bへの可変参照になるので参照はずしの**xで中身を書き換えられると思ったのですが、エラーの原因はx自体は可変参照でなく、ただの参照なので、中身を書き換えられないということのようです。
要するにfor文でIterator要素を可変で取り出すことはできないということなのでしょうか。
回避方法(*c[0] = ...; *c[1] = ...;のように要素ごとに書く必要がない方法)がありましたら、ご教示いただけたら幸いです。
よろしくお願いいたします。

Answer 1

iter ではなく iter_mut を使うと動きます。

fn add1s(mut c: [&mut i32; 2]) {
    // *c[0] += 1;
    // *c[1] += 1;
    for x in c.iter_mut() {
        **x += 1;
    }
}

iter を使った際は &&mut i32 という要素をイテレートしようとしますが、Rustは &&mut T のデリファレンスを許さないため、 **x という書き方ができなくなります(出来ると容易に &mut T のコピーが作れてしまい、「&mut T は1つしか存在しない」という制約を破ってしまいます）。 iter_mut ならば &mut &mut i32 になり、デリファレンス可能になります。

因みにRustでは for のイテレーション対象には seq.iter() や seq.iter_mut() よりも &seq や &mut seq を好むようなので本当は以下の方が好ましいです。

fn add1s(mut c: [&mut i32; 2]) {
    // *c[0] += 1;
    // *c[1] += 1;
    for x in &mut c {
        **x += 1;
    }
}

少しお節介かもしれませんが、Rustで [&mut T] という書き方はあまりみません。もちろん、どうしても必要なケースもあるかと思いますが、多くの場合は &mut [T] をよく使うと思います。
もし配列の要素を自由に編集したいだけなら以下の書き方をお勧めします。

fn main() {
    let a = 1;
    let b = 2;
    let c = &mut [a, b];
    add1s(c);
    println!("{}, {}", a, b);   // => 2, 3
}

fn add1s(c: &mut [i32; 2]) {
    // *c[0] += 1;
    // *c[1] += 1;
    for x in c {
        *x += 1;
    }
}

Comments

[moch]

なるほど、ありがとうございます!
iter_mut()は要素を可変参照として返してくれるんですね。
for x in &mut c...　の書き方も、仕組みがよくわかっていませんが、勉強してみます。

[&mut T]より&mut [T]の方がよくみられるということについてですが、実は今回のコード使って、
struct Container {
a: i32,
b: i32,
}
impl Container {
fn params(&mut self) -> [&mut i32; 2] {
[&mut self.a, &mut self.b]
}
}
というような構造体のフィールドを変更できるようにしたいと思っていて、その場合、params関数で参照(&mut[T]型)を返すことはできないようなので、返り値は[&mut i32; 2]やVec<&mut i32>のように可変参照を要素とするコレクションになるのかなと考えています。
&mut [T]の方がよく使われているのには何か理由はあるのでしょうか?

[blackenedgold]

> 返り値は[&mut i32; 2]やVec<&mut i32>のように可変参照を要素とするコレクションになるのかなと考えています。

そのように明確に可変な参照の配列が必要な場合は問題ないです（というよりその場合は要素の配列は作れないでしょう）。もしかして「配列の要素を変更できるようにしたい」と思って各要素を可変な参照にしたのかなと思ってコメントしましたが要らぬ世話でしたね。