rustのエラーメッセージの意味がわかりません

Question

前提・実現したいこと

rustのエラーメッセージの意味がわかりません。

シェルから以下のように引数を評価して、＋１して表示させる
プログラムです。

cargo run 123
124

なにが問題なのでしょうか？

発生している問題・エラーメッセージ

error[E0507]: cannot move out of indexed content
  --> src/main.rs:12:24
   |
12 |     println!("{}",add1(arg[1]));
   |                        ^^^^^^ cannot move out of indexed content

該当のソースコード

use std::env;

fn main() {
    let arg: Vec<String>  = env::args().collect();
    println!("{}",add1(arg[1]));
        
}

fn add1(s: String) -> i32{
    let a:i32 = s.parse().unwrap();
    return a + 1
}


#[test]
fn test_add1(){
    let x  = "5".to_string();
    assert_eq!(add1(x), 6);
}

試したこと

ソースコードのテストはパスする

補足情報（FW/ツールのバージョンなど）

rustc 1.24.1 (d3ae9a9e0 2018-02-27)
cargo 0.25.0 (96d8071da 2018-02-26)

Answer 1

すでにベストアンサーが選ばれていますが、補足させてください。（他の回答に気づかずに回答を途中まで書いてしまった）

エラーとなる理由は他の方が説明されているとおり所有権によるものです。Vecから1要素だけmove out（所有権を移動）させることはできません。

clone()は解決方法のひとつですが、元の値（ここではString）を複製しますので、ある程度の実行時のコストがかかります。可能な限りはベストアンサーの2つ目の方法である借用を使うのがおすすめです。

fn main() {
    // Vec<String>型
    let v = vec!["zero".to_string(), "one".to_string()];
    // Vecから1要素だけmove out（所有権を移動）させることはできない。
    // 質問と同じコンパイルエラー（cannot move out of indexed context）になる
    // let v1 = v[1];    // String型

    // `&`を使って値を借用すれば、値を複製しないで済む（おすすめの方法）
    let v1_ref = &v[1];  // &String型
}

借用を使う場合はプログラムを以下のように修正します。

use std::env;

fn main() {
    // Vec<String>型
    let arg = env::args().collect::<Vec<_>>();
    // &arg[1]は&String型
    println!("{}", add1(&arg[1]));
}

// 引数を&str型にする。こうするとコンパイラの型強制というしくみを
// 使って、引数として&str型の値と、&String型の値の両方を取れるように
// なるので便利
fn add1(s: &str) -> i32 {
    let a = s.parse::<i32>().unwrap();
    a + 1   // 最後の式の値が返されるのでreturnキーワードは不要
}

#[test]
fn test_add1() {
    let x = "5".to_string();  // String型
    assert_eq!(add1(&x), 6);
    let x = "7";              // &str型
    assert_eq!(add1(x), 8);
}

その他の方法としてはstd::mem::replace()を使って、今の値はmove outし、元の場所に代わりの値を入れることもできます。

fn main() {
    // ベクタの内容を変更するので`mut`が必要
    let mut v = vec!["zero".to_string(), "one".to_string()];

    // 今の値をmove outし、元の場所に代わりの値（例："dummy"）を入れる
    // v1はString型
    let v1 = std::mem::replace(&mut v[1], "dummy".to_string());
}

ところでコマンドライン引数を取り出すときは、また別の回答にある nth() を使うのが一般的です。これにコマンドライン引数のエラー処理なども加えると元のプログラムは以下のようになります。

use std::env;
use std::error::Error;

// 注意：main関数からResult型を返すにはRust 1.26.0かそれ以降が必要
fn main() -> Result<(), Box<Error>> {
    // String型
    let arg1 = env::args().nth(1).ok_or("Please specify arg1.")?;
    // &String → &strへ型強制する
    println!("{}", add1(&arg1)?);
    Ok(())
}

fn add1(s: &str) -> Result<i32, Box<Error>> {
    let a = s.parse::<i32>()?;
    Ok(a + 1)
}

#[test]
fn test_add1() {
    let x = "5".to_string();  // String型
    assert_eq!(add1(&x).unwrap(), 6);
    let x = "7";              // &str型
    assert_eq!(add1(x).unwrap(), 8);

    // i32に変換できない文字列を与えるとエラー
    assert!(add1("abc").is_err());
}

実行結果

# 正しいコマンドライン引数を与えた
$ cargo run -- 123
124

# 引数を与えなかった
$ cargo run --    
Error: StringError("Please specify arg1.")

# 数値に変換できない値を与えた
$ cargo run -- abc
Error: ParseIntError { kind: InvalidDigit }

Answer 2

Rustの[1]はコピーではなく、移動のようです。
つまりargs[1]の要素を削除して、変数argに代入するということになります。
イミュータブルな配列の要素を削除しようとしているから怒られているのではないでしょうか。

let arg1 = env::args().nth(1)
println!("{}",add1(arg1));

とか

let arg: Vec<String>  = env::args().collect();
let ref arg1 = &arg[1];
println!("{}",add1(arg1));

とか
mutをつけるとミュータブルにできるようですので

let mut arg: Vec<String> = env::args().collect();
println!("{}",add1(arg[0]));

とかではどうでしょうか？
ただし、デフォルトがイミュータブルのプログラミング言語で、
ミュータブルを使用するのは、それなりの理由がなければ忌み嫌われると思います。

Comments

[Eki]

2つ目の例では、 arg1 の型は &&String となってしまい、型が合わずにコンパイルが通りません。また、これはミュータビリティの問題ではないので3つ目の例のように mut をつけてもコンパイルは通りません。

この仕様は少し不便ですが Vec の一部の要素がムーブされているか否か、コンパイラが静的に知ることはできないので仕方ないですね...。この例ではインデックスが定数ですが、もちろん実行時に決まる値にすることもできますしね。

[root_jp]

ご丁寧に補足いただきありがとうございます。勉強になります。
あまり良くしらない言語に関して回答するものではありませんね。
失礼いたしました。

Answer 3

所有権の問題ですね。
関数呼び出しはデフォルトで所有権を移動してしまい、配列の中身の所有権を移動することはできないのでエラーが起きています。
配列の中身を直接渡さず、cloneを渡すといいと思います。

fn main() {
    let arg: Vec<String> = env::args().collect();
    println!("{}",add1(arg[1].clone()));
}

借用することで移動しないようにする方法もあります。

use std::env;

fn main() {
    let arg: Vec<String> = env::args().collect();
    println!("{}",add1(&arg[1]));
}

fn add1(s: &String) -> i32{
    let a:i32 = s.parse().unwrap();
    return a + 1
}


#[test]
fn test_add1(){
    let x  = "5".to_string();
    assert_eq!(add1(&x), 6);
}