История изменений

struct A(pub i32);

struct B(A);

impl Clone for B {
    fn clone(&self) -> Self {
        Self( A(self.0.0) )
    }
}
trait Inface { fn inface(&mut self); }
impl Inface for B {
    fn inface(&mut self){
        self.0.0 += 1;
        println!("{}", self.0.0);
    }
}
impl Default for B {
    fn default() -> Self {
        Self(A(42))
    }
}
impl B {
    pub fn print_a(&self){
        println!("{}", self.0.0);
    }
}

fn f<T: Clone+Inface>(v:&T){
    let mut copy = v.clone();
    copy.inface();
}
fn main() {
    let b = B::default();
    f(&b);
    b.print_a();
}

Прямо вот употел приседая (нет). В чём проблема-то, собственно? UB, пардон, я повторять не буду. И почему растовик вдруг забудет Copy, (а так же Clone c Debug), необходимость рассмотрения которых вылезет сразу же после первой попытки тестировать? Плюсовик же вот не забыл поставить struct вместо class и A() = default? И это у плюсовика вероятность забыть что-то подобное намного выше - язык дико раздутая и измученная стандартизацией помойка. А раст это как раз язычок специально спроектированный чтобы компилятор не давал забывать и не прощал. А вот попробуй повторить в плюсах что-то такое:

    // метод  в любом типе
    pub fn move_out(self)->Self {
        self

хоть заприседайся, но в полной мере, на уровне компилтайма, в плюсах это невозможно.

И это корёжит весь код.

Это только если мозг покорёжен дурными сишными привычками. Можно так рассматривать: мув - это такая минимальная фундаментальная операция, сохраняющая его идентичность и максимальный контроль над всевозможными контрактами/инвариантами объекта данного типа. Копирование - это дополнительная фича, уже в какой-то мере ослабляющая/размывающая этот контроль, соответсвенно должна добавляться с осознанием программистом. Что консистентно с идеей языка, который позиционируется как системный, т.е. надёжный. А значит по дефолту всё должно быть максимально ограниченное - инициализированое, иммутабельное, приватное, не копируемое и т.д.

struct A(pub i32);

struct B(A);

impl Clone for B {
    fn clone(&self) -> Self {
        Self( A(self.0.0) )
    }
}
trait Inface { fn inface(&mut self); }
impl Inface for B {
    fn inface(&mut self){
        self.0.0 += 1;
        println!("{}", self.0.0);
    }
}
impl Default for B {
    fn default() -> Self {
        Self(A(42))
    }
}
impl B {
    pub fn print_a(&self){
        println!("{}", self.0.0);
    }
}

fn f<T: Clone+Inface>(v:&T){
    let mut copy = v.clone();
    copy.inface();
}
fn main() {
    let b = B::default();
    f(&b);
    b.print_a();
}

Прямо вот употел приседая (нет). В чём проблема-то, собственно? UB, пардон, я повторять не буду. И почему растовик вдруг забудет Copy, (а так же Clone c Debug), необходимость рассмотрения которых вылезет сразу же после первой попытки тестировать? Плюсовик же вот не забыл поставить struct вместо class и A() = default? И это у плюсовика вероятность забыть что-то подобное намного выше - язык дико раздутая и измученная стандартизацией помойка. А раст это как раз язычок специально спроектированный чтобы компилятор не давал забывать и не прощал. А вот попробуй повторить в плюсах что-то такое:

    // метод  в любом типе
    pub fn move_out(self)->Self {
        self

хоть заприседайся, но в полной мере, на уровне компилтайма, в плюсах это невозможно.

И это корёжит весь код.

Это только если мозг покорёжен дурными сишными привычками. Можно так рассматривать: мув - это такая минимальная фундаментальная операция, сохраняющая максимальный контроль над всевозможными контрактами/инвариантами объекта данного типа. Копирование - это дополнительная фича, уже в какой-то мере ослабляющая/размывающая этот контроль, соответсвенно должна добавляться с осознанием программистом. Что консистентно с идеей языка, который позиционируется как системный, т.е. надёжный. А значит по дефолту всё должно быть максимально ограниченное - инициализированое, иммутабельное, приватное, не копируемое и т.д.

struct A(pub i32);

struct B(A);

impl Clone for B {
    fn clone(&self) -> Self {
        Self( A(self.0.0) )
    }
}
trait Inface { fn inface(&mut self); }
impl Inface for B {
    fn inface(&mut self){
        self.0.0 += 1;
        println!("{}", self.0.0);
    }
}
impl Default for B {
    fn default() -> Self {
        Self(A(42))
    }
}
impl B {
    pub fn print_a(&self){
        println!("{}", self.0.0);
    }
}

fn f<T: Clone+Inface>(v:&T){
    let mut copy = v.clone();
    copy.inface();
}
fn main() {
    let b = B::default();
    f(&b);
    b.print_a();
}

Прямо вот употел приседая (нет). В чём проблема-то, собственно? UB, пардон, я повторять не буду. И почему растовик вдруг забудет Copy, (а так же Clone c Debug), необходимость рассмотрения которых вылезет сразу же после первой попытки тестировать? Плюсовик же вот не забыл поставить struct вместо class и A() = default? И это у плюсовика вероятность забыть что-то подобное намного выше - язык дико раздутая и измученная стандартизацией помойка. А раст это как раз язычок специально спроектированный чтобы компилятор не давал забывать и не прощал. А вот попробуй повторить в плюсах что-то такое:

    // метод  в любом типе
    pub fn move_out(self)->Self {
        self

хоть заприседайся, но в полной мере, на уровне компилтайма, в плюсах это невозможно.

И это корёжит весь код.

Это только если мозг покорёжен дурными сишными привычками. Можно так рассматривать: мув - это такая минимальная фундаментальная операция сохраняющая максимальный контроль над всевозможными контрактами/инвариантами объекта данного типа. Копирование - это дополнительная фича, уже в какой-то мере ослабляющая/размывающая этот контроль, соответсвенно должна добавляться с осознанием программистом. Что консистентно с идеей языка, который позиционируется как системный, т.е. надёжный. А значит по дефолту всё должно быть максимально ограниченное - инициализированое, иммутабельное, приватное, не копируемое и т.д.