Derive Macro Getter 

#[derive(Getter)]
{
    // Attributes available to this derive:
    #[get]
}

A procedural macro that automatically generates getter methods for struct and enum fields.

This macro derives getter methods with configurable visibility and return type behavior. The generated getters can return either references to field values or cloned copies, with support for Option and Result types.

Supported Attributes

• #[get(pub)] - Generates a public getter with reference return type
• #[get(pub, reference)] - Generates a public getter that returns a reference (&T)
• #[get(pub, clone)] - Generates a public getter that returns a cloned value (T)
• #[get(pub, copy)] - Generates a public getter that returns a copy of the field value (self.field) for Copy types
• #[get(pub, deref)] - Generates a public getter that returns a dereferenced value (*field) with enhanced match control for Option/Result types
• #[get(pub(crate))] - Generates a crate-visible getter
• #[get(private)] - Generates a private getter

Return Type Behavior

• reference - Returns &T - a reference to the field value
• clone - Returns T - a cloned copy of the field value
• copy - Returns T - a copy of the field value (self.field) for types implementing Copy trait
• deref - Returns dereferenced values with enhanced match control:
  • Option<T> → T with detailed None panic messages
  • Result<T, E> → T with detailed Err panic messages
  • Box<T> → T by dereferencing the box
  • Rc<T> → T by cloning the inner value
  • Arc<T> → T by cloning the inner value
  • Other types → T by dereferencing
• Default behavior: Returns &T for non-Option/Result types, T for Option/Result types

Default Behavior Details

• Non-Option/Result types: Returns &T (reference to field)
• Option/Result types: Returns T (cloned value) to avoid exposing internal references
• This ensures safe access patterns while maintaining performance for common use cases

Examples

Basic Usage

use lombok_macros::*;

#[derive(Getter, Clone)]
struct BasicStruct {
    #[get(pub)]
    name: String,
    #[get(pub, type(reference))]
    description: String,
    #[get(pub, type(clone))]
    data: Vec<i32>,
    #[get(pub, type(copy))]
    count: i32,
}

let basic = BasicStruct {
    name: "test".to_string(),
    description: "description".to_string(),
    data: vec![1, 2, 3],
    count: 42,
};
let name_ref: &String = basic.get_name();
let description_ref: &String = basic.get_description();
let data_clone: Vec<i32> = basic.get_data();
let count_copy: i32 = basic.get_count();
assert_eq!(*name_ref, "test");
assert_eq!(*description_ref, "description");
assert_eq!(data_clone, vec![1, 2, 3]);
assert_eq!(count_copy, 42);

Option and Result Types

use lombok_macros::*;

#[derive(Getter, Clone)]
struct OptionalStruct {
    #[get(pub)]
    optional: Option<String>,
    #[get(pub, type(reference))]
    optional_ref: Option<String>,
    #[get(pub)]
    result: Result<String, String>,
}

let opt_struct = OptionalStruct {
    optional: Some("value".to_string()),
    optional_ref: Some("ref_value".to_string()),
    result: Ok("success".to_string()),
};
let optional_value: String = opt_struct.get_optional();
let optional_reference: &Option<String> = opt_struct.get_optional_ref();
let result_value: String = opt_struct.get_result();
assert_eq!(optional_value, "value");
assert_eq!(*optional_reference, Some("ref_value".to_string()));
assert_eq!(result_value, "success");

Tuple Structs

use lombok_macros::*;

#[derive(Getter, Clone)]
struct TupleStruct(
    #[get(pub)] String,
    #[get(pub, type(clone))] Vec<i32>,
);

let tuple = TupleStruct("hello".to_string(), vec![1, 2, 3]);
let field0: &String = tuple.get_0();
let field1: Vec<i32> = tuple.get_1();
assert_eq!(*field0, "hello");
assert_eq!(field1, vec![1, 2, 3]);

Copy Return Type

use lombok_macros::*;

#[derive(Getter, Clone)]
struct CopyStruct {
    #[get(pub, type(copy))]
    value: i32,
    #[get(pub, type(copy))]
    flag: bool,
    #[get(pub, type(copy))]
    count: u64,
}

let copy_struct = CopyStruct {
    value: 42,
    flag: true,
    count: 1000,
};
let copied_value: i32 = copy_struct.get_value();
let copied_flag: bool = copy_struct.get_flag();
let copied_count: u64 = copy_struct.get_count();
assert_eq!(copied_value, 42);
assert_eq!(copied_flag, true);
assert_eq!(copied_count, 1000);

Deref Return Type with Enhanced Match Control

use lombok_macros::*;

#[derive(Getter, Clone)]
struct DerefStruct {
    #[get(pub, type(deref))]
    optional: Option<bool>,
    #[get(pub, type(deref))]
    result: Result<String, &'static str>,
    #[get(pub, type(deref))]
    boxed_value: Box<i32>,
    #[get(pub, type(deref))]
    rc_value: std::rc::Rc<String>,
    #[get(pub, type(deref))]
    arc_value: std::sync::Arc<Vec<u8>>,
}

let deref_struct = DerefStruct {
    optional: Some(true),
    result: Ok("success".to_string()),
    boxed_value: Box::new(100),
    rc_value: std::rc::Rc::new("test".to_string()),
    arc_value: std::sync::Arc::new(vec![1, 2, 3]),
};
let optional_value: bool = deref_struct.get_optional();
let result_value: String = deref_struct.get_result();
let boxed_value: i32 = deref_struct.get_boxed_value();
let rc_value: String = deref_struct.get_rc_value();
let arc_value: Vec<u8> = deref_struct.get_arc_value();
assert_eq!(optional_value, true);
assert_eq!(result_value, "success");
assert_eq!(boxed_value, 100);
assert_eq!(rc_value, "test");
assert_eq!(arc_value, vec![1, 2, 3]);

Generics and Lifetimes

use lombok_macros::*;

#[derive(Getter, Clone)]
struct GenericStruct<'a, T: Clone> {
    #[get(pub)]
    value: &'a T,
    #[get(pub, type(clone))]
    owned: T,
}

let data = 42;
let generic = GenericStruct {
    value: &data,
    owned: 42,
};
let value_ref: &i32 = generic.get_value();
let owned_clone: i32 = generic.get_owned();
assert_eq!(*value_ref, 42);
assert_eq!(owned_clone, 42);