Operazione binaria! = Non può essere applicata quando si usano i generici per un vettore bit

Question

Sono in procinto di implementare una classe Bit Vector come esercizio, tuttavia solo conoscendo Rust per meno di una settimana mi trovo nei guai con il seguente codice :

use std::cmp::Eq; 
use std::ops::BitAnd; 
use std::ops::Index; 
use std::ops::Not; 

struct BitVector<S = usize> 
    where S: Sized + BitAnd<usize> + Not + Eq { 
    data: Vec<S>, 
    capacity: usize 
} 

impl<S> BitVector<S> 
    where S: Sized + BitAnd<usize> + Not + Eq { 
    fn with_capacity(capacity: usize) -> BitVector { 
     let len = (capacity/(std::mem::size_of::<S>() * 8)) + 1; 
     BitVector { data: vec![0; len], capacity: capacity } 
    } 
} 

impl<S> Index<usize> for BitVector<S> 
    where S: Sized + BitAnd<usize> + Not + Eq { 
    type Output = bool; 

    fn index(&self, index: usize) -> &bool { 
     let data_index = index/(std::mem::size_of::<S>() * 8); 
     let remainder = index % (std::mem::size_of::<S>() * 8); 
     (self.data[data_index] & (1 << remainder)) != 0 
    } 
} 

L'idea è che S può essere uno per esempio u8, u16, u32, u64 e usize garantire che impostandola 0 in with_capacity crea un valore di bit per S che consiste di tutti zeri.

L'errore che ottengo è il seguente:

lib.rs:27:10: 27:50 error: binary operation != cannot be applied to type <S as std::ops::BitAnd<usize>>::Output [E0369]
lib.rs:27 (self.data[data_index] & (1 << remainder)) != 0
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lib.rs:27:10: 27:50 help: run rustc --explain E0369 to see a detailed explanation
lib.rs:27:10: 27:50 note: an implementation of std::cmp::PartialEq might be missing for <S as std::ops::BitAnd<usize>>::Output
lib.rs:27 (self.data[data_index] & (1 << remainder)) != 0 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
error: Could not compile bit-vector .

Answer 1

Questo particolare errore qui, in termini semplici, significa che il Output di BitAnd ing S e usize non implementa PartialEq. Una soluzione potrebbe essere quella di aggiungere un vincolo che S s' BitAnd<usize> s Output è S:

BitAnd<usize, Output = S> 

Dopo questo, si incorrerà in un altro errore, perché si sta confrontando il valore della BitAnd per 0 e non a un valore di tipo S. Per risolvere il problema è possibile definire il proprio tratto Zero e utilizzarlo oppure utilizzare l'instabile di Rust std::num::Zero e confrontarlo con S::zero().

Dovrete anche a fare in modo che S: Copy facendo la BitAnd non consuma il valore (o aggiungere S: Clone ed esplicitamente clonare prima di chiamare BitAnd::bitand).

Infine si verificherà un errore che il tuo index deve restituire un &bool mentre si restituisce un bool. È possibile utilizzare il trucco bit-vec utilizza per definire 2 statica:

static TRUE: bool = true; 
static FALSE: bool = false; 

e ritorno &TRUE o &FALSE da index.

di lavoro finale (su Nightly) Codice:

#![feature(zero_one)] 

use std::cmp::Eq; 
use std::num::Zero; 
use std::ops::BitAnd; 
use std::ops::Index; 
use std::ops::Not; 

struct BitVector<S = usize> 
    where S: Sized + BitAnd<usize, Output = S> + Not + Eq + Copy + Zero 
{ 
    data: Vec<S>, 
    capacity: usize, 
} 

impl<S> BitVector<S> 
    where S: Sized + BitAnd<usize, Output = S> + Not + Eq + Copy + Zero 
{ 
    fn with_capacity(capacity: usize) -> BitVector { 
     let len = (capacity/(std::mem::size_of::<S>() * 8)) + 1; 
     BitVector { 
      data: vec![0; len], 
      capacity: capacity, 
     } 
    } 
} 

static TRUE: bool = true; 
static FALSE: bool = false; 

impl<S> Index<usize> for BitVector<S> 
    where S: Sized + BitAnd<usize, Output = S> + Not + Eq + Copy + Zero 
{ 
    type Output = bool; 

    fn index(&self, index: usize) -> &bool { 
     let data_index = index/(std::mem::size_of::<S>() * 8); 
     let remainder = index % (std::mem::size_of::<S>() * 8); 
     if (self.data[data_index] & (1 << remainder)) != S::zero() { 
      &TRUE 
     } else { 
      &FALSE 
     } 
    } 
} 

fn main() { 
}