Rust の練習帳 メモ

    let bytes = matches.value_of("bytes")
        .map(parse_positive_int)
        .transpose()
        .map_err(|e| format!("illegal byte count -- : {}", e))?;

    Ok(Config {
      files: matches.values_of_lossy("files").unwrap(),
      lines: lines.unwrap(),
      bytes,
    })

    let lines = matches.value_of("lines")
        .map(|line| parse_positive_int(line))
        .transpose()
        .map_err(|e| format!("illegal line count -- : {}", e))?;

    let lines = matches.value_of("lines")
        .map(parse_positive_int)
        .transpose()
        .map_err(|e| format!("illegal line count -- : {}", e))?;

        if let Some(num_bytes) = config.bytes {
          let mut handle = file.take(num_bytes as u64);
          let mut buffer = vec![0; num_bytes];
          let bytes_read = handle.read(&mut buffer)?;
          print!(
            "{}",
            String::from_utf8_lossy(&buffer[..bytes_read])
          )
        }

fn gen_config(
  files: Vec<String>,
  mut lines: bool,
  mut words: bool,
  mut bytes: bool,
  mut chars: bool,
) -> MyResult<Config> {
 
  if lines {
    lines = true;
    words = false;
    bytes = false;
    chars = false;
  }

  if words {
    lines = false;
    words = true;
    bytes = false;
    chars = false;
  }

  if bytes {
    lines = false;
    words = false;
    bytes = true;
    chars = false;
  }

  if chars {
    lines = false;
    words = false;
    bytes = false;
    chars = true;
  }

  if !lines && !words && !bytes && !chars {
    lines = false;
    words = false;
    bytes = false;
    chars = true;
  }

  Ok(Config {
      files,
      lines,
      words,
      bytes,
      chars,
  })
}

fn gen_config(
  files: Vec<String>,
  lines: bool,
  words: bool,
  bytes: bool,
  chars: bool,
) -> MyResult<Config> {

  let (lines, words, bytes, chars) = match (lines, words, bytes, chars) {
      (true, _, _, _) => (true, false, false, false),
      (_, true, _, _) => (false, true, false, false),
      (_, _, true, _) => (false, false, true, false),
      (_, _, _, true) => (false, false, false, true),
      _ => (false, false, false, true),
  };

  Ok(Config {
      files,
      lines,
      words,
      bytes,
      chars,
  })
}

let arr = [1, 2, 3, 4]; // [i32: 4]
arr.iter() // Iter
arr.iter().all(|&n| ....)

format!("{:04}", 42);             // => "0042" with leading zeros

    {
        let r;

        {
            let x = 5;
            r = &x;
        }

        println!("r: {}", r);
    }

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0597]: `x` does not live long enough
（エラー[E0597]: `x`の生存期間が短すぎます）
  --> src/main.rs:7:17
   |
7  |             r = &x;
   |                 ^^ borrowed value does not live long enough
   |                   (借用された値の生存期間が短すぎます)
8  |         }
   |         - `x` dropped here while still borrowed
   |          (`x`は借用されている間にここでドロップされました)
9  | 
10 |         println!("r: {}", r);
   |                           - borrow later used here
   |                            (その後、借用はここで使われています)

error: aborting due to previous error

For more information about this error, try `rustc --explain E0597`.
error: could not compile `chapter10`.

To learn more, run the command again with --verbose.

#![allow(unused)]
fn main() {
    let s = String::from("hello");  // sがスコープに入る

    takes_ownership(s);             // sの値が関数にムーブされ s の所有権を失う
    
    println!("let s: {}", s)
}
 
fn takes_ownership(some_string: String) { // some_stringがスコープに入る。
    println!("some_string: {}", some_string); // スコープを抜けると some_string が drop
}

#![allow(unused)]
fn main() {
    let s = String::from("hello");  // sがスコープに入る

    takes_ownership(&s);             // & により変数を貸し出す
    
    println!("let s: {}", s)                // s は借用させただけなので所有権を保持していることから参照できる
}
 
fn takes_ownership(some_string: &String) { // some_stringがスコープに入る。
    println!("some_string: {}", some_string); // some_string の所有権は持っていないのでスコープ外となっても drop されない
} 

fn main() {
    let a = 1;

    let b = &a;

    println!("{}", *b);
}

fn main() {
    let a = 1;

    let b = &a;

    println!("{}", b);
}

fn two() {
    let a = String::new();

    // reference to a is created. a can still be used, though exactly how it can be used depends on context
    let b = &a;

    // dereferencing can't move out of a, we can read the value but not move it
    *b; // error[E0507]: cannot move out of `*b` which is behind a shared reference
}

fn three() {
    let a = 0usize;

    // reference to a is created. a can still be used, though exactly how it can be used depends on context
    let b = &a;

    // dereferencing is allowed because the type of a implements Copy, which means its impossible to move out of a. Attempts to move out of a will always result in a new copy of the value
    *b; // Creates a new usize value copied from a.
}