### Basic Struct with Derive Builder

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Example of a basic struct annotated with `#[derive(Builder)]` to generate a builder.

```rust
#[derive(Builder)]
struct MyStruct {
    field1: String,
    field2: u32,
}
```

--------------------------------

### Rust Builder: Custom Constructor and Initialization

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Control builder initialization with `#[builder(custom_constructor)]` and `create_empty = "..."`. This example defines a custom `new` function and an empty builder initializer.

```rust
use derive_builder::Builder;

#[derive(Debug, Clone)]
pub enum ContentType {
    Json,
    Xml,
}

impl Default for ContentType {
    fn default() -> Self {
        Self::Json
    }
}

#[derive(Debug, Builder)]
#[builder(
    custom_constructor,
    create_empty = "empty",
    build_fn(private, name = "fallible_build")
)]
pub struct ApiClient {
    #[builder(setter(custom))]
    host: String,
    #[builder(setter(custom))]
    key: String,
    #[builder(default)]
    content_type: ContentType,
}

impl ApiClient {
    pub fn new(host: impl Into<String>, key: impl Into<String>) -> ApiClientBuilder {
        ApiClientBuilder {
            host: Some(host.into()),
            key: Some(key.into()),
            ..ApiClientBuilder::empty()
        }
    }
}

impl ApiClientBuilder {
    pub fn build(&self) -> ApiClient {
        self.fallible_build()
            .expect("All required fields were initialized")
    }
}

fn main() {
    let client = ApiClient::new("api.example.com", "secret-key")
        .content_type(ContentType::Xml)
        .build();

    println!("{:?}", client);
}
```

--------------------------------

### Generic Struct Example

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Demonstrates a generic struct with `derive_builder`, highlighting the restriction on using `VALUE` as a type parameter when type conversions are enabled.

```rust
#[derive(Builder)]
struct MyStruct<T> {
    field1: T,
}
```

--------------------------------

### Skipping Setters

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Example of how to skip generating a setter for a specific field using `#[builder(setter(skip))]`.

```rust
#[derive(Builder)]
struct MyStruct {
    #[builder(setter(skip))]
    field1: String,
    field2: u32,
}
```

--------------------------------

### Generated Boilerplate Code

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

This is an example of the code automatically generated by the derive_builder macro. It includes the builder struct definition and implementation, handling optional fields and build errors.

```rust
#[derive(Clone, Default)]
struct ChannelBuilder {
    token: Option<i32>,
    special_info: Option<i32>,
}

#[allow(dead_code)]
impl ChannelBuilder {
    pub fn token<VALUE: Into<i32>>(&mut self, value: VALUE) -> &mut Self {
        let mut new = self;
        new.token = Some(value.into());
        new
    }
    pub fn special_info<VALUE: Into<i32>>(&mut self, value: VALUE) -> &mut Self {
        let mut new = self;
        new.special_info = Some(value.into());
        new
    }
    fn build(
        &self,
    ) -> Result<Channel, ChannelBuilderError> {
        Ok(Channel {
            id: match self.id {
                Some(ref value) => Clone::clone(value),
                None => {
                    return Err(
                        Into::into(
                            ::derive_builder::UninitializedFieldError::from("id"),
                        ),
                    )
                }
            },
            token: match self.token {
                Some(ref value) => Clone::clone(value),
                None => {
                    return Err(
                        Into::into(
                            ::derive_builder::UninitializedFieldError::from("token"),
                        ),
                    )
                }
            },
            special_info: match self.special_info {
                Some(ref value) => Clone::clone(value),
                None => {
                    return Err(
                        Into::into(
                            ::derive_builder::UninitializedFieldError::from("special_info"),
                        ),
                    )
                }
            },
        })
    }
}
```

--------------------------------

### Derive Builder Usage Example

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Annotate your struct with #[derive(Builder)] and use the generated builder to create instances. The `#[builder(setter(into))]` attribute allows setters to accept types that can be converted into the field's type.

```rust
use derive_builder::Builder;

#[derive(Default, Builder, Debug)]
#[builder(setter(into))]
struct Channel {
    token: i32,
    special_info: i32,
    // .. a whole bunch of other fields ..
}

fn main() {
    // builder pattern, go, go, go!...
    let ch = ChannelBuilder::default()
        .special_info(42u8)
        .token(19124)
        .build()
        .unwrap();
    println!("{:?}", ch);
}
```

--------------------------------

### Basic Builder Usage

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/derive_builder/README.md

Demonstrates the default builder pattern where setter methods consume and return `&mut self` for chaining.

```rust
struct MyStruct {
    field1: String,
    field2: u32,
}

#[derive(Builder)]
struct MyStructBuilder {
    field1: String,
    field2: u32,
}

fn main() {
    let builder = MyStructBuilder::create()
        .field1("hello".to_string())
        .field2(123)
        .build();
}
```

--------------------------------

### Immutable Builder Pattern

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Demonstrates how to opt into the immutable builder pattern using `#[builder(pattern = "immutable")]`.

```rust
#[derive(Builder)]
#[builder(pattern = "immutable")]
struct MyStruct {
    field1: String,
    field2: u32,
}
```

--------------------------------

### Fallible Setters with TryInto

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Shows how to use `#[builder(try_setter)]` and `setter(into)` to create setters that accept types implementing `TryInto`. This allows for fallible conversions during the build process.

```rust
use derive_builder::Builder;

#[derive(Builder, Debug, PartialEq)]
#[builder(try_setter, setter(into))]
struct Lorem {
    pub name: String,
    pub ipsum: u8,
}

fn main() {
    // Regular setter
    let x = LoremBuilder::default()
        .name("hello")
        .ipsum(42u8)
        .build()
        .unwrap();

    // Try setter - conversion from u16 to u8
    let y = LoremBuilder::default()
        .try_ipsum(100u16).unwrap()  // 100 fits in u8
        .name("world")
        .build()
        .unwrap();

    assert_eq!(y.ipsum, 100);

    // Try setter failure - 300 doesn't fit in u8
    let err = LoremBuilder::default()
        .try_ipsum(300u16);
    assert!(err.is_err());
}
```

--------------------------------

### Generic Structs with Derive Builder

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Demonstrates how to use derive-builder with generic structs that have trait bounds. Supports concrete types and type annotations for generic parameters.

```rust
use derive_builder::Builder;
use std::fmt::Display;

#[derive(Debug, PartialEq, Default, Builder, Clone)]
struct Generic<T: Display + Clone> {
    ipsum: &'static str,
    pub dolor: T,
}

#[derive(Debug, PartialEq, Default, Builder, Clone)]
pub struct GenericReference<'a, T: 'a + Default + Display> {
    pub bar: Option<&'a T>,
}

fn main() {
    // Generic with concrete type
    let x = GenericBuilder::default()
        .ipsum("Generic")
        .dolor(true)
        .build()
        .unwrap();

    assert_eq!(x, Generic { ipsum: "Generic", dolor: true });

    // With type annotation
    let y = GenericBuilder::<i32>::default()
        .ipsum("Numbers")
        .dolor(42)
        .build()
        .unwrap();

    assert_eq!(y.dolor, 42);

    // Generic reference
    static BAR: u32 = 42;
    let z = GenericReferenceBuilder::<'static, u32>::default()
        .bar(Some(&BAR))
        .build()
        .unwrap();

    assert_eq!(z.bar, Some(&42));
}
```

--------------------------------

### No Alloc no_std Support

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Configures no_std support without requiring the `alloc` feature, using `#[builder(no_std, build_fn(error(validation_error = false)))]` or a custom error type.

```rust
#[builder(no_std, build_fn(error(validation_error = false)))]
struct MyStruct {
    field1: String,
}
```

--------------------------------

### Rust Builder Patterns: Mutable, Owned, Immutable

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Demonstrates the three builder patterns: mutable (&mut self), owned (self), and immutable (&self). Choose based on field mutability and cloning requirements.

```rust
use derive_builder::Builder;

// Mutable pattern (default): setters take &mut self, return &mut Self
#[derive(Debug, PartialEq, Default, Builder, Clone)]
#[builder(pattern = "mutable")]
struct Mutable {
    value: u32,
}

// Owned pattern: setters take self, return Self (useful for non-Clone fields)
#[derive(Debug, PartialEq, Default, Builder)]
#[builder(pattern = "owned")]
struct Owned {
    value: u32,
}

// Immutable pattern: setters take &self, return new Self
#[derive(Debug, PartialEq, Default, Builder, Clone)]
#[builder(pattern = "immutable")]
struct Immutable {
    value: u32,
}

fn main() {
    // Mutable: can conditionally call setters
    let mut builder = MutableBuilder::default();
    let condition = true;
    if condition {
        builder.value(42);
    }
    let m = builder.build().unwrap();
    assert_eq!(m.value, 42);

    // Owned: full chaining, consumes builder
    let o = OwnedBuilder::default()
        .value(42)
        .build()
        .unwrap();
    assert_eq!(o.value, 42);

    // Immutable: returns new builder each time
    let b1 = ImmutableBuilder::default();
    let b2 = b1.value(42);
    let i = b2.build().unwrap();
    assert_eq!(i.value, 42);
}
```

--------------------------------

### no_std Support

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Enables no_std compatibility by adding `#[builder(no_std)]` and ensuring the `alloc` feature is used.

```rust
#[builder(no_std)]
struct MyStruct {
    field1: String,
}
```

--------------------------------

### Owned Builder Pattern

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Shows how to use the owned builder pattern with `#[builder(pattern = "owned")]`.

```rust
#[derive(Builder)]
#[builder(pattern = "owned")]
struct MyStruct {
    field1: String,
    field2: u32,
}
```

--------------------------------

### Basic Builder Pattern Implementation in Rust

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Applies `#[derive(Builder)]` to a struct to generate a builder with setters and a `build()` method. Missing required fields will result in errors.

```rust
use derive_builder::Builder;

#[derive(Builder, Debug, PartialEq)]
struct Lorem {
    ipsum: u32,
    dolor: String,
}

fn main() {
    // Create instance using the generated builder
    let lorem = LoremBuilder::default()
        .ipsum(42)
        .dolor("sit".to_string())
        .build()
        .unwrap();

    assert_eq!(lorem.ipsum, 42);
    assert_eq!(lorem.dolor, "sit");

    // Missing required fields produce errors
    let error = LoremBuilder::default().build().unwrap_err();
    assert_eq!(&error.to_string(), "`ipsum` must be initialized");
}
```

--------------------------------

### Additional Trait Derivations on Builder

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Illustrates how to use `#[builder(derive(...))]` to automatically derive traits like `Debug`, `PartialEq`, and `Eq` on the generated builder struct itself.

```rust
use derive_builder::Builder;

#[derive(Builder, Clone)]
#[builder(derive(Debug, PartialEq, Eq))]
pub struct Lorem {
    foo: u8,
    bar: String,
}

fn main() {
    let b1 = LoremBuilder::default();
    let b2 = LoremBuilder::default();

    // PartialEq derived on builder
    assert_eq!(b1, b2);

    // Debug derived on builder
    println!("{:?}", b1);
}
```

--------------------------------

### Implement Pre-Build Validation in Rust

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Use `#[builder(build_fn(validate = "path::to::fn"))]` to execute custom validation logic before a struct is built. Ensure the validation function returns a `Result<(), String>`.

```rust
use derive_builder::Builder;

#[derive(Builder, Debug, PartialEq)]
#[builder(build_fn(validate = "Self::validate"))]
struct Lorem {
    pub ipsum: u8,
}

impl LoremBuilder {
    fn validate(&self) -> Result<(), String> {
        if let Some(ref ipsum) = self.ipsum {
            match *ipsum {
                i if i < 20 => Err("Try harder".to_string()),
                i if i > 100 => Err("You'll tire yourself out".to_string()),
                _ => Ok(()),
            }
        } else {
            Ok(())
        }
    }
}

fn main() {
    // Valid value
    let x = LoremBuilder::default().ipsum(50).build().unwrap();
    assert_eq!(x.ipsum, 50);

    // Validation failure - value too high
    let err = LoremBuilder::default().ipsum(120).build().unwrap_err();
    assert_eq!(&err.to_string(), "You'll tire yourself out");

    // Validation failure - value too low
    let err = LoremBuilder::default().ipsum(10).build().unwrap_err();
    assert_eq!(&err.to_string(), "Try harder");
}
```

--------------------------------

### Pre-build Validation

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Adds custom validation logic before the struct is built by referencing a validation function with `#[builder(build_fn(validate = "path::to::fn"))]`.

```rust
#[derive(Builder)]
#[builder(build_fn(validate = "my_validation_fn"))]
struct MyStruct {
    field1: String,
    field2: u32,
}
```

--------------------------------

### Collection Setters (each with Into)

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/derive_builder/README.md

Combines `each` with `into` for collection setters, allowing items to be converted into the collection's element type.

```rust
#[derive(Builder, Debug)]
struct MyStruct {
    #[builder(setter(each(name = "add_item", into)))]
    items: Vec<String>,
}

fn main() {
    let builder = MyStructBuilder::create()
        .add_item("one") // Accepts &str due to `into`
        .add_item("two")
        .build();
}
```

--------------------------------

### Collection Setter with Into

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Combines collection setters with type conversion, allowing generic input types for items using `#[builder(setter(each(name = "foo", into)))]`.

```rust
#[derive(Builder)]
struct MyStruct {
    #[builder(setter(each(name = "add_foo", into)))]
    foo: Vec<String>,
}
```

--------------------------------

### Default Values

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/derive_builder/README.md

Assign default values to fields using `#[builder(default)]` or `#[builder(default = "...")]`.

```rust
#[derive(Builder, Debug)]
struct MyStruct {
    #[builder(default)]
    field1: String,
    #[builder(default = "100")]
    field2: u32,
}

fn main() {
    let builder = MyStructBuilder::create().build(); // Uses default values
    println!("{:?}", builder);
}
```

--------------------------------

### Collection Setter (Each)

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Generates a setter for fields that implement `Default` and `Extend`, allowing items to be added to a collection using `#[builder(setter(each(name = "method_name")))]`.

```rust
#[derive(Builder)]
struct MyStruct {
    #[builder(setter(each(name = "add_foo")))]
    foo: Vec<String>,
}
```

--------------------------------

### Private Setter

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Illustrates how to make all setters private by annotating the struct with `#[builder(private)]`.

```rust
#[derive(Builder)]
#[builder(private)]
struct MyStruct {
    field1: String,
    field2: u32,
}
```

--------------------------------

### Rust Builder: Custom Setter Implementation

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Replace auto-generated setters with custom logic using `#[builder(setter(custom))]`. This allows for validation or transformation before setting the field.

```rust
use derive_builder::Builder;

#[derive(Builder, Debug, PartialEq)]
struct SetterOptOut {
    #[builder(setter(custom))]
    custom_setter: u32,
    normal: String,
}

impl SetterOptOutBuilder {
    // Implement custom setter logic
    pub fn custom_setter(&mut self, value: u32) -> &mut Self {
        // Custom validation or transformation
        self.custom_setter = Some(value.saturating_mul(2));
        self
    }
}

fn main() {
    let x = SetterOptOutBuilder::default()
        .custom_setter(21)  // Uses our custom implementation
        .normal("test".to_string())
        .build()
        .unwrap();

    assert_eq!(x.custom_setter, 42);  // 21 * 2
    assert_eq!(x.normal, "test");
}
```

--------------------------------

### Strip Option for Optional Fields in Rust Builder

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Use `#[builder(setter(strip_option))]` on optional fields to accept `T` directly instead of `Option<T>`, simplifying the builder API. Fields marked with `default` will initialize to `None` if not set.

```rust
use derive_builder::Builder;

#[derive(Builder, Debug, PartialEq)]
struct Lorem {
    #[builder(setter(into, strip_option))] 
    pub ipsum: Option<String>,
    #[builder(setter(into, strip_option), default)]
    pub foo: Option<String>,
}

fn main() {
    // Pass value directly without wrapping in Some()
    let x = LoremBuilder::default()
        .ipsum("foo")  // Automatically wrapped in Some()
        .build()
        .unwrap();

    assert_eq!(x.ipsum, Some("foo".to_string()));
    assert_eq!(x.foo, None);  // Default is None

    // Set both optional fields
    let y = LoremBuilder::default()
        .ipsum("bar")
        .foo("baz")
        .build()
        .unwrap();

    assert_eq!(y.ipsum, Some("bar".to_string()));
    assert_eq!(y.foo, Some("baz".to_string()));
}
```

--------------------------------

### Collection Setters with Each in Rust Builder

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Employ `#[builder(setter(each(name = "method_name")))]` to create methods for adding items individually to collection fields like `Vec` or `HashMap`. The `into` conversion can be used for types like `&str`.

```rust
use derive_builder::Builder;
use std::collections::HashMap;

#[derive(Debug, PartialEq, Default, Builder, Clone)]
struct Lorem {
    #[builder(setter(each(name = "bar")))]
    bars: Vec<String>,
    #[builder(setter(each(name = "baz")))]
    bazes: HashMap<String, i32>,
    #[builder(setter(each(name = "item", into)))]  // with into conversion
    items: Vec<String>,
}

fn main() {
    let x = LoremBuilder::default()
        // Add items one at a time
        .bar("first".into())
        .bar("second".into())
        .bar("third".into())
        // HashMap entries as tuples
        .baz(("key1".into(), 1))
        .baz(("key2".into(), 2))
        // With into conversion, can pass &str directly
        .item("a")
        .item("b")
        .build()
        .unwrap();

    assert_eq!(x.bars, vec!["first", "second", "third"]);
    assert_eq!(x.bazes.get("key1"), Some(&1));
    assert_eq!(x.bazes.get("key2"), Some(&2));
    assert_eq!(x.items, vec!["a", "b"]);
}
```

--------------------------------

### Custom Build Method Error Type

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Specifies a custom error type for the build method using `#[builder(build_fn(error = "path::to::Error"))]`.

```rust
#[derive(Builder)]
#[builder(build_fn(error = "MyError"))]
struct MyStruct {
    field1: String,
    field2: u32,
}
```

--------------------------------

### Setter Strip Option

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Allows setter methods for `Option<T>` fields to accept `T` directly using `#[builder(setter(strip_option))]`.

```rust
#[derive(Builder)]
struct MyStruct {
    #[builder(setter(strip_option))]
    field1: Option<String>,
    field2: u32,
}
```

--------------------------------

### Crate Renaming and Re-export

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Specifies the root crate for `derive_builder` using `#[builder(crate = "...")]`, useful for renaming or re-exporting.

```rust
#[builder(crate = "my_builder_crate")]
#[derive(Builder)]
struct MyStruct {
    field1: String,
}
```

--------------------------------

### Setter Type Conversion (Into)

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Enables generic setter input types that implement `Into` for the field type using `#[builder(setter(into))]`.

```rust
#[derive(Builder)]
struct MyStruct {
    #[builder(setter(into))]
    field1: String,
    field2: u32,
}
```

--------------------------------

### Skip Build Method

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Disables the auto-generated build method, allowing for a custom implementation, using `#[builder(build_fn(skip))]`.

```rust
#[derive(Builder)]
#[builder(build_fn(skip))]
struct MyStruct {
    field1: String,
    field2: u32,
}
```

--------------------------------

### Rust Builder: Hiding Fields with `setter(skip)`

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Use `#[builder(setter(skip))]` to exclude a field from the generated builder setters. Such fields must implement `Default`.

```rust
use derive_builder::Builder;

#[derive(Builder, Debug, PartialEq)]
struct HiddenField {
    setter_present: u32,
    #[builder(setter(skip))]
    setter_skipped: u32,  // Must implement Default
}

fn main() {
    // Can only set setter_present, setter_skipped uses default
    let x = HiddenFieldBuilder::default()
        .setter_present(42)
        .build()
        .unwrap();

    assert_eq!(x.setter_present, 42);
    assert_eq!(x.setter_skipped, 0);  // Default for u32
}
```

--------------------------------

### Default Value from Trait

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Assigns a default value to a field by delegating to its `Default` implementation using `#[builder(default)]`.

```rust
#[derive(Builder)]
struct MyStruct {
    #[builder(default)]
    field1: String,
    field2: u32,
}
```

--------------------------------

### Pass-through Attributes

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Adds attributes to the generated builder parts using `#[builder_struct_attr(...)]`, `#[builder_impl_attr(...)]`, etc.

```rust
#[builder_struct_attr(derive(Debug))]
#[derive(Builder)]
struct MyStruct {
    field1: String,
}
```

--------------------------------

### Computed Defaults with Builder Access in Rust

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Allows default expressions to reference other builder fields using `self`, enabling computed defaults based on previously set values and custom validation logic.

```rust
use derive_builder::Builder;

#[derive(Builder, PartialEq, Debug)]
struct Lorem {
    ipsum: String,
    #[builder(default = "self.default_dolor()? ")]
    dolor: String,
}

impl LoremBuilder {
    fn default_dolor(&self) -> Result<String, String> {
        match self.ipsum {
            Some(ref x) if x.chars().count() > 3 => Ok(format!("dolor {}", x)),
            _ => Err("ipsum must be at least 3 chars".to_string()),
        }
    }
}

fn main() {
    let x = LoremBuilder::default()
        .ipsum("ipsum".to_string())
        .build()
        .unwrap();

    assert_eq!(x.ipsum, "ipsum");
    assert_eq!(x.dolor, "dolor ipsum");  // Computed from ipsum

    // Validation error when ipsum is too short
    let err = LoremBuilder::default()
        .ipsum("ab".to_string())
        .build()
        .unwrap_err();
    assert!(err.to_string().contains("at least 3 chars"));
}
```

--------------------------------

### Define Custom Error Types for Rust Builder

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Specify a custom error type using `#[builder(build_fn(error = "path::to::Error"))]` for enhanced error handling. Implement `fmt::Display` and `From<UninitializedFieldError>` for the custom error enum.

```rust
use std::fmt;
use derive_builder::{Builder, UninitializedFieldError};

fn validate_age(builder: &ExampleBuilder) -> Result<(), Error> {
    match builder.age {
        Some(age) if age > 150 => Err(Error::UnrealisticAge(age)),
        _ => Ok(()),
    }
}

#[derive(Debug, Builder)]
#[builder(setter(into), build_fn(validate = "validate_age", error = "Error"))]
struct Example {
    name: String,
    age: usize,
}

enum Error {
    UninitializedField(&'static str),
    UnrealisticAge(usize),
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::UnrealisticAge(age) => write!(f, "Nobody is {} years old", age),
            Self::UninitializedField(field) => write!(f, "Required field '{}' not set", field),
        }
    }
}

impl From<UninitializedFieldError> for Error {
    fn from(e: UninitializedFieldError) -> Self {
        Self::UninitializedField(e.field_name())
    }
}

fn main() {
    let person_err = ExampleBuilder::default()
        .name("Jane Doe")
        .age(200usize)
        .build()
        .unwrap_err();

    assert_eq!(format!("{}", person_err), "Nobody is 200 years old");

    // Missing field error
    let missing_err = ExampleBuilder::default().build().unwrap_err();
    assert_eq!(format!("{}", missing_err), "Required field 'name' not set");
}
```

--------------------------------

### Default Value from Explicit Value

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Sets a specific default value for a field using `#[builder(default = "..")]`.

```rust
#[derive(Builder)]
struct MyStruct {
    #[builder(default = "default_value")]
    field1: String,
    field2: u32,
}
```

--------------------------------

### Private Setters

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/derive_builder/README.md

Generate private setter methods by annotating the struct with `#[builder(private)]`. These setters are not accessible outside the module.

```rust
#[derive(Builder, Debug)]
#[builder(private)]
struct MyStruct {
    field1: String,
    field2: u32,
}

fn main() {
    // .field1() and .field2() are private
    let builder = MyStructBuilder::create().field2(123);
    // let instance = builder.field1("hello".to_string()).field2(123).build(); // This would fail
}
```

--------------------------------

### Build Method Suppression

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/derive_builder/README.md

Disable the auto-generated build method with `#[builder(build_fn(skip))]` to provide your own implementation.

```rust
#[derive(Builder, Debug)]
#[builder(build_fn(skip))]
struct MyStruct {
    field1: String,
}

// Manual implementation required
impl MyStructBuilder {
    fn build(&self) -> MyStruct {
        MyStruct { field1: self.field1.clone() }
    }
}
```

--------------------------------

### Default Values for Struct Fields in Rust

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Configures default values for struct fields using `#[builder(default)]` for `Default` trait delegation or `#[builder(default = "expression")]` for custom expressions.

```rust
use derive_builder::Builder;

#[derive(Builder, Debug, PartialEq)]
struct Lorem {
    #[builder(default = "42")]
    ipsum: u32,
    #[builder(default)]
    dolor: String,  // Uses String::default() -> ""
    #[builder(default = "format!(\"Hello {}!\", \"World\")")]
    greeting: String,
}

fn main() {
    // Build without setting any fields - defaults are used
    let x = LoremBuilder::default().build().unwrap();

    assert_eq!(x.ipsum, 42);
    assert_eq!(x.dolor, "");
    assert_eq!(x.greeting, "Hello World!");

    // Override specific defaults
    let y = LoremBuilder::default()
        .ipsum(100)
        .build()
        .unwrap();

    assert_eq!(y.ipsum, 100);
}
```

--------------------------------

### Derive Additional Traits

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Applies additional trait derivations to the builder struct using `#[builder(derive(Trait1, Trait2, ...))]`.

```rust
#[derive(Builder)]
#[builder(derive(Debug, Serialize))]
struct MyStruct {
    field1: String,
    field2: u32,
}
```

--------------------------------

### Builder Field Visibility

Source: https://github.com/colin-kiegel/rust-derive-builder/blob/master/README.md

Controls the visibility of fields within the generated builder struct using `#[builder(field(private))]` or `..(public)`.

```rust
#[derive(Builder)]
struct MyStruct {
    #[builder(field(private))]
    field1: String,
    field2: u32,
}
```

--------------------------------

### Generic Setters with Into Trait in Rust

Source: https://context7.com/colin-kiegel/rust-derive-builder/llms.txt

Uses `#[builder(setter(into))]` to make setters generic over the `Into` trait, enabling automatic type conversions for field assignments.

```rust
use derive_builder::Builder;

#[derive(Builder, Debug, PartialEq)]
#[builder(setter(into))]
struct Channel {
    token: i32,
    special_info: i32,
}

fn main() {
    // Values are automatically converted via Into trait
    // u8 is converted to i32 automatically
    let ch = ChannelBuilder::default()
        .special_info(42u8)  // u8 -> i32
        .token(19_124)
        .build()
        .unwrap();

    assert_eq!(ch.token, 19_124);
    assert_eq!(ch.special_info, 42);
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.