Better integration between derives and operator overloads · dtolnay/cxx

(5 commenti) (0 reazioni) (0 assegnatari)Rust (253 fork)batch import

help wanted

Metriche repository

Star: (4472 stelle)
Metriche merge PR: (Merge medio 8m) (3 PR mergiate in 30 g)

Descrizione

Many integration opportunities here.

If a shared struct has a #[derive(PartialEq or Ord)] then emit a compatible operator ==, operator !=, operator <, operator <=, operator >, operator >= on the type for C++.
```
mod ffi {
    #[derive(PartialEq)]
    struct Key {
        n: usize,
    }
}
```
If an opaque Rust type is written with trait bounds then wire up the corresponding operator for C++ in a way that delegates to Rust's implementation of the operator.
```
mod ffi {
    extern "Rust" {
        type R: PartialEq;
    }
}

struct R {...}
impl PartialEq for R {...}
```
If an opaque C++ type is written with trait bounds then produce a trait impl in Rust that delegates to the corresponding overloaded operator(s) in C++.
```
mod ffi {
    extern "C++" {
        type C: PartialEq;  // produce a PartialEq that calls `operator ==`
    }
}
```

Guida contributor

Direzione di ricerca: Implementa macro di derivazione che generano overload degli operatori C++ per struct che derivano PartialEq/Ord e generano implementazioni di trait per tipi opachi che si legano agli operatori C++.
Tech stack: rust
Dominio: api
Tipo issue: Funzionalità
Difficoltà: 3
Tempo stimato: 1-2 giorni
Stato attività: Attiva
Chiarezza: Chiara
Prerequisiti: RustC++
Adatta ai principianti: 30