Default Implementations — Rust

Default Implementations in Rust Traits

When you define a trait, you can provide a default method body directly in the trait definition. Types that implement the trait can then choose to use the default as-is, or override it with their own implementation. This keeps trait definitions expressive without forcing every implementor to repeat boilerplate.

Basic Default Implementation

Any trait method can have a default body. Implementors that do not override the method automatically inherit the default behaviour.

RUST

trait Greet {
    // Required method — every implementor must provide this
    fn name(&self) -> &str;

    // Default method — implementors may override, but do not have to
    fn greeting(&self) -> String {
        format!("Hello, {}!", self.name())
    }
}

struct English { person: String }
struct French  { person: String }

impl Greet for English {
    fn name(&self) -> &str { &self.person }
    // Uses the default greeting: "Hello, Alice!"
}

impl Greet for French {
    fn name(&self) -> &str { &self.person }

    // Override the default with a French greeting
    fn greeting(&self) -> String {
        format!("Bonjour, {} !", self.name())
    }
}

fn main() {
    let e = English { person: String::from("Alice") };
    let f = French  { person: String::from("Pierre") };

    println!("{}", e.greeting()); // Hello, Alice!
    println!("{}", f.greeting()); // Bonjour, Pierre !
}

Calling Other Trait Methods from a Default

A default implementation can call other methods on the same trait — both required and other defaults. This lets you build richer behaviour from small, composable pieces.

RUST

trait Summary {
    // Required: implementors must provide these
    fn title(&self) -> &str;
    fn author(&self) -> &str;

    // Optional: a snippet of the content
    fn snippet(&self) -> String {
        String::from("(Read more...)")
    }

    // Default that calls the other methods — no override needed
    fn summarize(&self) -> String {
        format!("{} by {} — {}", self.title(), self.author(), self.snippet())
    }
}

struct Article {
    title:   String,
    author:  String,
    content: String,
}

impl Summary for Article {
    fn title(&self)  -> &str { &self.title }
    fn author(&self) -> &str { &self.author }

    // Override snippet to show the first 50 characters
    fn snippet(&self) -> String {
        let s: String = self.content.chars().take(50).collect();
        format!("{}...", s)
    }
    // summarize() is inherited and uses our overridden snippet()
}

struct Tweet { username: String, message: String }

impl Summary for Tweet {
    fn title(&self)  -> &str { &self.message }
    fn author(&self) -> &str { &self.username }
    // Uses both the default snippet() and default summarize()
}

fn main() {
    let article = Article {
        title:   String::from("Rust 2024 Edition"),
        author:  String::from("The Rust Team"),
        content: String::from("Exciting changes are coming to the Rust language this year."),
    };
    let tweet = Tweet {
        username: String::from("rustlang"),
        message:  String::from("Rust 2.0 is here!"),
    };

    println!("{}", article.summarize());
    println!("{}", tweet.summarize());
}

Rust 2024 Edition by The Rust Team — Exciting changes are coming to the Rust ...
Rust 2.0 is here! by rustlang — (Read more...)

Note

When a default method calls another method, the call is dispatched on `self`'s actual type. If the implementor overrides the called method, the override is used — not the default. This is how `summarize()` above picks up the overridden `snippet()`.

The Default Trait

Rust's standard library provides a built-in trait specifically for zero-argument construction: std::default::Default. It has one required method, fn default() -> Self, which returns a sensible "zero" or "empty" value for a type.

Standard types that implement Default:

Numbers (i32, f64, etc.): 0
bool: false
String, &str: empty string
Option<T>: None
Tuples, arrays: default of each element
Vec<T>, HashMap<K,V>: empty collection

RUST

fn main() {
    // Calling Default::default() on common types
    let n:   i32             = Default::default(); // 0
    let b:   bool            = Default::default(); // false
    let s:   String          = Default::default(); // ""
    let opt: Option<i32>     = Default::default(); // None
    let v:   Vec<u8>         = Default::default(); // []

    println!("i32={} bool={} String={:?} Option={:?} Vec={:?}",
             n, b, s, opt, v);
}

i32=0 bool=false String="" Option=None Vec=[]

Implementing Default for Custom Types

You can implement Default manually for your own types. This is useful when "empty" or "zero" state has a clear meaning for your type.

RUST

struct Config {
    host:        String,
    port:        u16,
    max_retries: u8,
    verbose:     bool,
}

impl Default for Config {
    fn default() -> Self {
        Config {
            host:        String::from("localhost"),
            port:        8080,
            max_retries: 3,
            verbose:     false,
        }
    }
}

fn main() {
    let cfg = Config::default();
    println!("{}:{} retries={} verbose={}",
             cfg.host, cfg.port, cfg.max_retries, cfg.verbose);
    // localhost:8080 retries=3 verbose=false
}

#[derive(Default)]

When every field in your struct implements Default, Rust can derive the implementation automatically. The derived default() calls Default::default() on each field in turn.

RUST

#[derive(Debug, Default)]
struct ServerConfig {
    host:     String,   // ""
    port:     u16,      // 0
    workers:  usize,    // 0
    tls:      bool,     // false
    timeout:  Option<u64>, // None
}

fn main() {
    let cfg = ServerConfig::default();
    println!("{:#?}", cfg);
}

ServerConfig {
    host: "",
    port: 0,
    workers: 0,
    tls: false,
    timeout: None,
}

Tip

Derived `Default` works on enums too, but you must mark which variant is the default with `#[default]`: `#[derive(Default)] enum Status { #[default] Idle, Running }`. This requires Rust 1.62 or later.

Struct Update Syntax with Default

Rust's struct update syntax (..value) lets you copy all remaining fields from another instance. Combined with Default::default(), this creates a concise pattern for customising only the fields you care about while everything else gets a sensible default.

RUST

#[derive(Debug, Default)]
struct HttpRequest {
    method:   String,
    path:     String,
    body:     String,
    timeout:  u64,    // default: 0 (interpreted as "no timeout")
    retries:  u8,     // default: 0
    verbose:  bool,   // default: false
}

fn main() {
    // Only specify the fields that differ from the defaults
    let req = HttpRequest {
        method: String::from("GET"),
        path:   String::from("/api/users"),
        ..Default::default() // body="", timeout=0, retries=0, verbose=false
    };

    println!("{} {} (timeout={}, retries={})",
             req.method, req.path, req.timeout, req.retries);
    // GET /api/users (timeout=0, retries=0)
}

Builder Pattern Using Default

A common Rust pattern combines Default with a builder to construct complex structs step by step. Start from Default::default(), then set only the fields you need.

RUST

#[derive(Debug, Default)]
struct QueryBuilder {
    table:   String,
    filter:  Option<String>,
    limit:   Option<usize>,
    offset:  usize,
    order:   String,
}

impl QueryBuilder {
    fn new() -> Self { Self::default() }

    fn table(mut self, t: &str) -> Self {
        self.table = t.to_string(); self
    }
    fn filter(mut self, f: &str) -> Self {
        self.filter = Some(f.to_string()); self
    }
    fn limit(mut self, n: usize) -> Self {
        self.limit = Some(n); self
    }
    fn offset(mut self, n: usize) -> Self {
        self.offset = n; self
    }
    fn order(mut self, col: &str) -> Self {
        self.order = col.to_string(); self
    }

    fn build(&self) -> String {
        let mut q = format!("SELECT * FROM {}", self.table);
        if let Some(ref f) = self.filter { q.push_str(&format!(" WHERE {}", f)); }
        if !self.order.is_empty()        { q.push_str(&format!(" ORDER BY {}", self.order)); }
        if let Some(lim) = self.limit    { q.push_str(&format!(" LIMIT {}", lim)); }
        if self.offset > 0               { q.push_str(&format!(" OFFSET {}", self.offset)); }
        q
    }
}

fn main() {
    let query = QueryBuilder::new()
        .table("users")
        .filter("active = true")
        .order("created_at DESC")
        .limit(25)
        .offset(50)
        .build();

    println!("{}", query);
    // SELECT * FROM users WHERE active = true ORDER BY created_at DESC LIMIT 25 OFFSET 50
}

Strategy Pattern via Default Methods

You can define a few required methods that capture the "core" of a type, and then provide rich default implementations built on top of them. Types only implement the core, and get the full behaviour for free — this is the Strategy pattern in Rust.

RUST

trait Validator {
    // Core — implementors define these
    fn name(&self) -> &str;
    fn is_valid(&self, input: &str) -> bool;

    // Derived behaviour — built from the core methods
    fn validate(&self, input: &str) -> Result<(), String> {
        if self.is_valid(input) {
            Ok(())
        } else {
            Err(format!("[{}] rejected {:?}", self.name(), input))
        }
    }

    fn validate_all<'a>(&self, inputs: &[&'a str]) -> Vec<&'a str> {
        inputs.iter().copied().filter(|s| self.is_valid(s)).collect()
    }
}

struct NotEmpty;
struct EmailLike;
struct ShortEnough { max: usize }

impl Validator for NotEmpty {
    fn name(&self) -> &str { "not-empty" }
    fn is_valid(&self, input: &str) -> bool { !input.is_empty() }
}
impl Validator for EmailLike {
    fn name(&self) -> &str { "email-like" }
    fn is_valid(&self, input: &str) -> bool { input.contains('@') }
}
impl Validator for ShortEnough {
    fn name(&self) -> &str { "short-enough" }
    fn is_valid(&self, input: &str) -> bool { input.len() <= self.max }
}

fn main() {
    let v = EmailLike;

    println!("{:?}", v.validate("user@example.com")); // Ok(())
    println!("{:?}", v.validate("not-an-email"));     // Err("...")

    let candidates = ["a@b.com", "bad", "x@y.org", "no-at"];
    let valid = v.validate_all(&candidates);
    println!("{:?}", valid); // ["a@b.com", "x@y.org"]
}

Ok(())
Err("[email-like] rejected "not-an-email"")
["a@b.com", "x@y.org"]

Best Practices

Require the essential, default the optional — required methods capture what makes a type unique; defaults provide shared convenience
Default methods should call only required or other default methods — do not assume anything about fields, only the trait contract
Use #[derive(Default)] whenever possible — it is zero-boilerplate and documents intent clearly
Combine Default with struct update syntax — great for configuration types with many optional fields
Override sparingly — if most implementors need to override a default, the default is probably wrong; consider making it required

Success

Default implementations let traits provide "batteries included" behaviour while staying extensible. Types implement only what makes them unique; everything else is inherited. The `Default` trait plugs into Rust's ecosystem — struct update syntax, derive macros, builder patterns, and standard-library APIs all expect types to implement `Default` when they have a sensible zero value.