Можно ли в Rust расширить существующую структуру, сохранив все её поля?

Проблема наследования структур в Rust

Да, вы абсолютно правы: в Rust нет классического наследования структур. Это осознанное решение разработчиков языка, направленное на избежание проблем, связанных с ромбовидным наследованием, виртуальными таблицами и сложной иерархией объектов. Вместо этого Rust предлагает композицию и трейты — более гибкие и безопасные механизмы.

Решение 1: Композиция через вложенную структуру (рекомендуется)

Самый простой и идиоматичный способ — включить одну структуру как поле другой. Это не копипаст, а именно композиция.

struct Base {
    x: i32,
    y: i32,
}

struct Derived {
    base: Base,  // композиция: все поля Base доступны через base
    z: i32,
}

fn main() {
    let d = Derived {
        base: Base { x: 10, y: 20 },
        z: 30,
    };
    
    // Доступ к полям Base:
    println!("x = {}, y = {}, z = {}", d.base.x, d.base.y, d.z);
}

Если вам нужно 5 разных "наследников", вы просто везде используете Base как поле. Никакого дублирования кода.

Решение 2: Реализация методов через Deref (удобный доступ)

Чтобы не писать каждый раз d.base.x, можно реализовать трейт Deref. Это позволит обращаться к полям Base напрямую:

use std::ops::Deref;

struct Base {
    x: i32,
    y: i32,
}

struct Derived {
    base: Base,
    z: i32,
}

impl Deref for Derived {
    type Target = Base;
    
    fn deref(&self) -> &Self::Target {
        &self.base
    }
}

fn main() {
    let d = Derived {
        base: Base { x: 10, y: 20 },
        z: 30,
    };
    
    // Теперь можно обращаться напрямую!
    println!("x = {}, y = {}, z = {}", d.x, d.y, d.z);
}

Важно: Deref работает только для неизменяемых ссылок. Для мутабельного доступа нужно реализовать DerefMut.

Решение 3: Макросы для автоматической генерации

Если у вас много структур, которые должны содержать одни и те же поля, можно написать макрос:

macro_rules! with_base {
    ($name:ident, $($field:ident: $type:ty),*) => {
        struct $name {
            x: i32,
            y: i32,
            $($field: $type),*
        }
    };
}

with_base!(Derived1, z: i32);
with_base!(Derived2, name: String, age: u8);

fn main() {
    let d1 = Derived1 { x: 1, y: 2, z: 3 };
    let d2 = Derived2 { x: 4, y: 5, name: "Alice".into(), age: 30 };
    
    println!("d1: x={}, y={}, z={}", d1.x, d1.y, d1.z);
    println!("d2: name={}, age={}", d2.name, d2.age);
}

Решение 4: Трейты с методами доступа

Если вам нужно именно поведение (методы), а не данные — используйте трейты:

trait HasBase {
    fn x(&self) -> &i32;
    fn y(&self) -> &i32;
    fn x_mut(&mut self) -> &mut i32;
    fn y_mut(&mut self) -> &mut i32;
}

struct Base {
    x: i32,
    y: i32,
}

impl HasBase for Base {
    fn x(&self) -> &i32 { &self.x }
    fn y(&self) -> &i32 { &self.y }
    fn x_mut(&mut self) -> &mut i32 { &mut self.x }
    fn y_mut(&mut self) -> &mut i32 { &mut self.y }
}

struct Derived {
    base: Base,
    z: i32,
}

impl HasBase for Derived {
    fn x(&self) -> &i32 { self.base.x() }
    fn y(&self) -> &i32 { self.base.y() }
    fn x_mut(&mut self) -> &mut i32 { self.base.x_mut() }
    fn y_mut(&mut self) -> &mut i32 { self.base.y_mut() }
}

Что выбрать?

• Для простых случаев — композиция с Deref (решение 2).
• Для сложной иерархии — трейты с методами доступа (решение 4).
• Для кода без оверхеда — макросы (решение 3), но они менее гибкие.
• Для новичков — простая композиция (решение 1).

Главное преимущество композиции перед наследованием: вы явно видите, какие данные где находятся, и компилятор может лучше оптимизировать код. Нет проблем с ромбовидным наследованием или неоднозначностью методов.

// Добавьте в Cargo.toml:
// [dependencies]
// derive_more = "0.99"

use derive_more::{Deref, DerefMut, From};

#[derive(Deref, DerefMut, From)]
struct Base {
    x: i32,
    y: i32,
}

#[derive(Deref, DerefMut)]
struct Derived {
    #[deref]
    base: Base,
    z: i32,
}

fn main() {
    let mut d = Derived {
        base: Base { x: 10, y: 20 },
        z: 30,
    };
    
    // Все поля Base доступны напрямую!
    println!("x = {}, y = {}, z = {}", d.x, d.y, d.z);
    
    // Можно менять через мутабельную ссылку
    d.x = 100;
    println!("new x = {}", d.x);
}