Default

#209 Jun 2026

209. ..Default::default() — set the fields you care about, default the rest

Building a struct with a dozen fields when you only want to change one is tedious. Struct update syntax lets you fill in the rest from a default — or from any other value.

Say you have a config struct. Spelling out every field just to flip one flag is noise:

1
2
3
4
5
6
7
let cfg = ServerConfig {
    host: String::new(),
    port: 8080,
    max_connections: 0,
    use_tls: true,
    timeout_secs: 0,
};

Derive Default, then use ..Default::default() to fill the fields you didn’t mention:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
#[derive(Debug, Default, PartialEq)]
struct ServerConfig {
    host: String,
    port: u16,
    max_connections: u32,
    use_tls: bool,
    timeout_secs: u64,
}

let cfg = ServerConfig {
    port: 8080,
    use_tls: true,
    ..Default::default()
};

assert_eq!(cfg.port, 8080);
assert_eq!(cfg.use_tls, true);
assert_eq!(cfg.host, "");        // String::default()
assert_eq!(cfg.max_connections, 0);

The ..base part isn’t limited to Default — you can spread from any existing instance, so it doubles as a cheap “clone but tweak”:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
let base = ServerConfig {
    max_connections: 1024,
    ..Default::default()
};

let derived = ServerConfig {
    port: 9090,
    ..base
};

assert_eq!(derived.port, 9090);
assert_eq!(derived.max_connections, 1024);

Two things to remember: the ..rest has to come last, and the fields it pulls in are moved out of the source value (or copied, if they’re Copy) — so a non-Copy field like host means you can’t keep using base afterward.

#011 Mar 2022

enum default

11. Fuse

Fuse is an iterator that yields None forever after the underlying iterator yields None once. USage:

1
2
let values = [1,2,3,4];
let iter = values.iter().fuse();

Why is it useful? see example in this bite.

Sometimes an underlying iterator may or may yield Some(T) again after None was returned.

fuse ensures that after a None is returned for the first time, it always returns None.

Example from the rust documentation:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
struct Alternate {
    state: i32,
}

impl Iterator for Alternate {
    type Item = i32;

    fn next(&mut self) -> Option<i32> {
        let val = self.state;
        self.state = self.state + 1;

        if val % 2 == 0 {
            Some(val)
        } else {
            None
        }
    }
}

let mut iter = Alternate { state: 0 };

assert_eq!(iter.next(), Some(0));
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), None);

let mut iter = iter.fuse();

assert_eq!(iter.next(), Some(4));
assert_eq!(iter.next(), None);

assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);