【Rust】Rust 1.98 完全ガイド — format_into と algebraic_add

rustup update stable
rustc --version

# 実行結果
# rustc 1.98.1 (48a229cea 2026-09-01)

use core::fmt::NumBuffer;

let mut buf = NumBuffer::new();
let n = 1972u32;
println!("{}", n.format_into(&mut buf));

// 実行結果
// 1972

println!("{:?}", "[hello]".strip_circumfix('[', ']'));

let v = [1, 2, 3, 4, 5];
println!("{:?}", v.strip_circumfix(&[1], &[5]));

let data = "a, b, b, a";

for part in data.split(", ") {
    match data.substr_range(part) {
        Some(r) => println!("{:?} = {}..{}", part, r.start, r.end),
        None => println!("{:?} = None", part),
    }
}

let bytes: Vec<u8> = "abc".encode_utf16().flat_map(|u| u.to_le_bytes()).collect();
println!("{:?}", String::from_utf16le(&bytes).unwrap());

// 実行結果
// Some("hello")
// Some([2, 3, 4])
// "a" = 0..1
// "b" = 3..4
// "b" = 6..7
// "a" = 9..10
// "abc"

const N: u64 = 3_000_000;
let mut sink = 0usize;

// 1. format_into
let start = Instant::now();

for i in 0..N {
    let mut buf = NumBuffer::new();
    sink += i.format_into(&mut buf).len();
}

let fmt_into = start.elapsed();

// 2. to_string（毎回 String を確保する）
let start = Instant::now();

for i in 0..N {
    sink += i.to_string().len();
}

let to_string = start.elapsed();

// 3. write!（String を1本使い回す）
let start = Instant::now();
let mut s = String::with_capacity(20);

for i in 0..N {
    s.clear();
    write!(s, "{}", i).unwrap();
    sink += s.len();
}

let write_fmt = start.elapsed();

// それぞれの elapsed を表示する（sink は最適化で消えないように足し込む）

// 実行結果
// sink=59666670
// format_into:   13.61ms
// to_string  :   79.83ms
// write!     :   41.49ms

fn plain_sum(xs: &[f64]) -> f64 {
    let mut total: f64 = 0.0;

    for x in xs {
        total = total + *x;
    }

    total
}

fn algebraic_sum(xs: &[f64]) -> f64 {
    let mut total: f64 = 0.0;

    for x in xs {
        total = total.algebraic_add(*x);
    }

    total
}

let big: Vec<f64> = (1..=1_000_000).map(|i| i as f64 * 1e-6).collect();
println!("exact         : {:.10}", 500000.5);
println!("plain sum     : {:.10}", plain_sum(&big));
println!("algebraic sum : {:.10}", algebraic_sum(&big));

// 実行結果
// exact         : 500000.5000000000
// plain sum     : 500000.5000000001
// algebraic sum : 500000.4999999999

// plain_sum と algebraic_sum を同じ配列で200回ずつ合計する
let start = Instant::now();

for _ in 0..200 {
    sink += plain_sum(&big);
}

let plain = start.elapsed();

// 実行結果
// plain     :  118.17ms
// algebraic :   22.46ms

#[derive(Debug, PartialEq, Eq)]
struct Weird(u32);

// PartialOrd は逆順、Ord は正順（わざと食い違わせる）
impl PartialOrd for Weird {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(other.0.cmp(&self.0))
    }
}

impl Ord for Weird {
    fn cmp(&self, other: &Self) -> Ordering {
        self.0.cmp(&other.0)
    }
}

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct Outer {
    w: Weird,
}

let a = Outer { w: Weird(1) };
let b = Outer { w: Weird(2) };

println!("a < b (PartialOrd): {}", a < b);
println!("a.cmp(&b) (Ord)   : {:?}", a.cmp(&b));
println!("a.partial_cmp(&b) : {:?}", a.partial_cmp(&b));