Rustの構造体初期化テクニック：効率的なインスタンス生成と柔軟な構文の使い分け

// ユーザー情報を表す単純な構造体
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    // 構造体リテラルによるインスタンス化
    let user1 = User {
        username: String::from("rust_user"),
        email: String::from("example@example.com"),
        active: true,
        sign_in_count: 1,
    };
    
    println!("User: {}", user1.username);
}

User: rust_user

fn build_user(email: String, username: String) -> User {
    // email: email, username: username と書く代わりに略記できる
    User {
        email,
        username,
        active: true,
        sign_in_count: 1,
    }
}

impl User {
    // 慣習的なnew関数
    pub fn new(username: &str, email: &str) -> Self {
        Self {
            username: username.to_string(),
            email: email.to_string(),
            active: true,
            sign_in_count: 1,
        }
    }
}

fn main() {
    let user = User::new("tech_writer", "info@example.com");
    println!("Created user: {}", user.username);
}

#[derive(Debug)]
struct Config {
    timeout: u32,
    retries: u8,
    verbose: bool,
}

// Defaultトレイトの手動実装
impl Default for Config {
    fn default() -> Self {
        Self {
            timeout: 30,
            retries: 3,
            verbose: false,
        }
    }
}

fn main() {
    // デフォルト値で生成
    let config = Config::default();
    println!("{:?}", config);
}

Config { timeout: 30, retries: 3, verbose: false }

fn main() {
    let base_user = User::new("original", "base@example.com");

    // base_userの一部だけを変えて、新しいuser2を作成
    let user2 = User {
        email: String::from("new_email@example.com"),
        ..base_user // 残りのフィールド(username, active, sign_in_count)をbase_userから引き継ぐ
    };
    
    // 注意：StringなどのCopyトレイトを実装していない型が含まれる場合、
    // base_userから一部のデータがムーブされるため、これ以降base_user全体は使用できなくなる場合があります。
}

let custom_config = Config {
    timeout: 60,
    ..Config::default()
};

struct Server {
    host: String,
    port: u16,
    max_connections: u32,
}

struct ServerBuilder {
    host: Option<string>,
    port: Option<u16>,
    max_connections: Option<u32>,
}

impl ServerBuilder {
    fn new() -> Self {
        Self { host: None, port: None, max_connections: None }
    }

    fn host(mut self, host: &str) -> Self {
        self.host = Some(host.to_string());
        self
    }

    fn port(mut self, port: u16) -> Self {
        self.port = Some(port);
        self
    }

    fn build(self) -> Result<Server, String> {
        let host = self.host.ok_or("Host is required")?;
        let port = self.port.unwrap_or(8080);
        let max_connections = self.max_connections.unwrap_or(100);

        Ok(Server { host, port, max_connections })
    }
}

fn main() {
    let server = ServerBuilder::new()
        .host("localhost")
        .port(3000)
        .build()
        .expect("Failed to build server");
}
</u32></u16></string>