Come si implementa una struttura che utilizza un vettore generico con annotazioni a vita?

Question

I seguenti compila bene:

pub struct Reader<'a> { 
    position: uint, 
    data: &'a [u8] 
} 

Si tratta di un lettore che prende un vettore (in realtà una fetta) di tipo u8 come riferimento, e mi specificare la durata.

Tuttavia, questo non è esattamente quello che voglio. Voglio essere in grado di rendere la struttura generica e, per essere ancora più precisa, voglio dire che il tipo dovrebbe essere una porzione di qualcosa. Ho provato questo per cominciare:

pub struct Reader<'a, T> { 
    position: uint, 
    data: &'a T 
} 

Esso non denota T essere una fetta, ma questo è già venendo a mancare con un messaggio:

il tipo di parametro T potrebbe non vivere abbastanza a lungo; considerare l'aggiunta di un vita esplicito legato T:'a ...

Ok così ho dovuto specificare il corso della vita.

Ma ora il mio problema è che come faccio a renderlo generico di tipo slice e avere la vita? Ho provato cose come Reader<'a, T: 'a Vec> e T: 'a [T] ma non ho idea di come dovrei denotare questo e la guida ufficiale non sembra trattare un caso come questo.

Desidero semplicemente creare un Reader che raccolga qualsiasi tipo di slice prendendolo in prestito e fornisce metodi per operare sui dati (in modalità di sola lettura).

Answer 1

Dopo aver provato un po 'di più, ho finalmente capito fuori:

pub struct Reader<'a, T: 'a> { 
    position: uint, 
    data: &'a [T] 
} 

Definisce del data lettore a essere di tipo Slice<T> ([] denota la fetta) e &'a specifica la durata per i dati presi in prestito.

Ora posso implementare cose come questa:

impl<'a, T> Reader<'a, T> { 
    pub fn from_data(bytes: &'a[T]) -> Reader<'a, T> { 
     Reader { 
      position: 0, 
      data: bytes 
     } 
    } 
} 

Answer 2

non con l'intenzione di rispondere direttamente, è solo che mi sono imbattuto in questo SO rispondo quando ero alla ricerca di una risposta al mio proprio problema: come applicare una vincolo di tipo generico e un vincolo di durata nel campo di una struct.

(Ecco la soluzione di lavoro mi è venuta.)

use std::io::Writer; 

// This specifies lifetime constraint of 'a 
// Type W must implement the Writer trait 
// Type W has the lifetime 'a (the same as the related struct instance) 
pub struct Foo<'a, W: 'a + Writer> { 
    writer: &'a mut W 
}