今年入ったRustの機能について調べごとをいろいろする

    pub const unsafe fn unwrap_unchecked(self) -> T {
        debug_assert!(self.is_some());
        match self {
            Some(val) => val,
            // SAFETY: the safety contract must be upheld by the caller.
            None => unsafe { hint::unreachable_unchecked() },
        }
    }

    pub const fn unwrap(self) -> T {
        match self {
            Some(val) => val,
            None => panic("called `Option::unwrap()` on a `None` value"),
        }
    }

fn main() {
    let some = Some(42);
    println!("{}", some.unwrap());
}

fn main() {
    let args = std::env::args().collect::<Vec<String>>();
    let num: i32 = args[1].parse().unwrap();
    println!("{}", num);
}

	callq	*core::num::<impl core::str::traits::FromStr for i32>::from_str@GOTPCREL(%rip)
	testb	$1, %al
	jne	.LBB10_42
	shrq	$32, %rax

.LBB10_42:
	movb	%ah, 96(%rsp)
	leaq	.L__unnamed_4(%rip), %rdi
	leaq	.L__unnamed_5(%rip), %rcx
	leaq	.L__unnamed_6(%rip), %r8
	leaq	96(%rsp), %rdx
	movl	$43, %esi
	callq	*core::result::unwrap_failed@GOTPCREL(%rip)

# 下記は読み解くのに必要そうなラベル
.L__unnamed_4:
	.ascii	"called `Result::unwrap()` on an `Err` value"

.L__unnamed_5:
	.quad	core::ptr::drop_in_place<core::num::error::ParseIntError>
	.asciz	"\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000"
	.quad	<core::num::error::ParseIntError as core::fmt::Debug>::fmt

.L__unnamed_8:
	.ascii	"src/main.rs"

fn main() {
    let args = std::env::args().collect::<Vec<String>>();
    let num: i32 = args[1].parse().unwrap_unchecked();
    println!("{}", num);
}

	callq	*core::num::<impl core::str::traits::FromStr for i32>::from_str@GOTPCREL(%rip)
	shrq	$32, %rax

fn main() {
    let a = 42;
    let b = 31;
    let ans = a + b;
    // 従来
    println!("{} + {} = {}", a, b, ans);
    // 以降
    println!("{a} + {b} = {ans}");
    // 下記はできない。
    // (関数や関数の適用、演算を含めることはできない)
    // println!("{a} + {b} = {a + b}");
}

use std::{fs::File, io::Read, process::ExitCode};

// 2 でファイル読み込み時の失敗、3 でファイルが見つからなかったエラーを示すものとする。
fn main() -> ExitCode {
    let args: Vec<String> = std::env::args().collect();
    let file_path = &args[1];
    let file = File::open(file_path);
    match file {
        Ok(mut f) => {
            let mut content = String::new();
            let r = f.read_to_string(&mut content);
            if r.is_err() {
                return 2.into();
            }
            println!("{}", content);
            ExitCode::SUCCESS
        }
        Err(_) => 3.into(),
    }
}

pub fn exit(code: i32) -> ! {
    crate::rt::cleanup();
    crate::sys::os::exit(code)
}

#[derive(Debug, Default)]
enum State {
    #[default]
    Idle,
    Fetch,
    Exec,
}

// できそうだができない
// #[derive(Default)]
// struct Instruction;

// #[derive(Default)]
// enum State2 {
//     Idle,
//     Fetch,
//     #[default]
//     Exec(Instruction),
// }

fn main() {
    println!("{:?}", State::default());
}

pub struct Mutex {
    /// 0: unlocked
    /// 1: locked, no other threads waiting
    /// 2: locked, and other threads waiting (contended)
    futex: AtomicI32,
}

let mut a = vec![1, 2, 3];
let mut x = 0;

std::thread::scope(|s| {
    s.spawn(|| {
        println!("hello from the first scoped thread");
        // We can borrow `a` here.
        dbg!(&a);
    });
    s.spawn(|| {
        println!("hello from the second scoped thread");
        // We can even mutably borrow `x` here,
        // because no other threads are using it.
        x += a[0] + a[2];
    });
    println!("hello from the main thread");
});

// After the scope, we can modify and access our variables again:
a.push(4);
assert_eq!(x, a.len());

use std::thread;

// NG case
fn main() {
    let greeting = String::from("Hello world!");

    // thread::spwan は static なライフタイムを保つため、スレッドは
    // ローカル変数を借用できないという規則がある。
    let handle1 = thread::spawn({
        // そのため、1度クローンしておいてスコープ外の greeting の
        // 所有権が移動しないようにする必要がある。
        // let greeting = greeting.clone();
        move || {
            println!("thread #1 says: {}", greeting);
        }
    });

    let handle2 = thread::spawn(move || {
        println!("thread #2 says: {}", greeting);
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
}

error[E0382]: use of moved value: `greeting`
  --> src/bin/scoped_thread.rs:18:33
   |
5  |     let greeting = String::from("Hello world!");
   |         -------- move occurs because `greeting` has type `String`, which does not implement the `Copy` trait
...
13 |         move || {
   |         ------- value moved into closure here
14 |             println!("thread #1 says: {}", greeting);
   |                                            -------- variable moved due to use in closure
...
18 |     let handle2 = thread::spawn(move || {
   |                                 ^^^^^^^ value used here after move
19 |         println!("thread #2 says: {}", greeting);
   |                                        -------- use occurs due to use in closure

For more information about this error, try `rustc --explain E0382`.
error: could not compile `techfeed-night-9` due to previous error

fn main() {
    let greeting = String::from("Hello world!");

    // scope を使うと greeting を clone せずに済んでいることがわかる。
    thread::scope(|s| {
        let handle1 = s.spawn(|| {
            println!("thread #1 says: {}", greeting);
        });

        let handle2 = s.spawn(|| {
            println!("thread #2 says: {}", greeting);
        });

        handle1.join().unwrap();
        handle2.join().unwrap();
    });
}

async fn a() -> i32 {
    1
}

// どこかの関数内で呼び出し
let y = a().await;

// これが、下記のように脱糖される
let task = a().into_future();
let y = loop {
    match task.poll(&mut cx) {
        Poll::Pending => {},
        Poll::Ready(x) => break x,
    }
};

trait StreamingIterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

struct VecWrapper<T> {
    inner: Vec<T>,
    cur: usize,
}

impl<T> StreamingIterator for VecWrapper<T> {
    type Item = &mut T;
    fn next(&mut self) -> Option<Self::Item> {
        self.inner.get_mut(self.cur).map_or(None, |item| {
            self.cur += 1;
            Some(item)
        })
    }
}

use std::marker::PhantomData;

// NG
trait StreamingIterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

struct VecWrapper<'a, T> {
    inner: Vec<T>,
    cur: usize,
    _marker: PhantomData<&'a T>,
}

// NG
// error: lifetime may not live long enough
//   --> src/bin/gats.rs:36:9
//    |
// 33 |   impl<'a, T> StreamingIterator for VecWrapper<'a, T> {
//    |        -- lifetime `'a` defined here
// 34 |       type Item = &'a mut T;
// 35 |       fn next(&mut self) -> Option<Self::Item> {
//    |               - let's call the lifetime of this reference `'1`
// 36 | /         self.inner.get_mut(self.cur).map_or(None, |item| {
// 37 | |             self.cur += 1;
// 38 | |             Some(item)
// 39 | |         })
//    | |__________^ associated function was supposed to return data with lifetime `'a` but it is returning data with lifetime `'1`
impl<'a, T> StreamingIterator for VecWrapper<'a, T> {
    type Item = &'a mut T;
    fn next(&mut self) -> Option<Self::Item> {
        self.inner.get_mut(self.cur).map_or(None, |item| {
            self.cur += 1;
            Some(item)
        })
    }
}

trait StreamingIterator {
    type Item;
    fn next(&mut self) -> Option<&mut Self::Item>;
}

struct VecWrapper<T> {
    inner: Vec<T>,
    cur: usize,
}

impl<T> StreamingIterator for VecWrapper<T> {
    type Item = T;
    fn next(&mut self) -> Option<&mut Self::Item> {
        self.inner.get_mut(self.cur).map_or(None, |item| {
            self.cur += 1;
            Some(item)
        })
    }
}

trait StreamingIterator {
    type Item<'a>
    where
        Self: 'a;
    fn next(&mut self) -> Option<Self::Item<'_>>;
}

struct VecWrapper<T> {
    inner: Vec<T>,
    cur: usize,
}

impl<T> StreamingIterator for VecWrapper<T> {
    type Item<'a> = &'a mut T where Self: 'a;
    fn next(&mut self) -> Option<Self::Item<'_>> {
        self.inner.get_mut(self.cur).map_or(None, |item| {
            self.cur += 1;
            Some(item)
        })
    }
}

    pub async fn close(&mut self) -> Result<()> {
        let Some(mut file) = self.file.take() else { return Ok(()); };
        debug!("File {} closed", self.filename());
        file.flush().await

        // 元のコード
        // if let Some(mut file) = self.file.take() {
        //     debug!("File {} closed", self.filename());
        //     file.flush().await?;
        // }

        // Ok(())
    }