correspondant sur une boîte

Question

Ce code est montré dans The Rust Programming Language:

#![feature(box_syntax, box_patterns)] 

fn main() { 
    let b = Some(box 5); 
    match b { 
     Some(box n) if n < 0 => { 
      println!("Box contains negative number {}", n); 
     } 
     Some(box n) if n >= 0 => { 
      println!("Box contains non-negative number {}", n); 
     } 
     None => { 
      println!("No box"); 
     } 
     _ => unreachable!(), 
    } 
} 

Mais quand je le lance, l'erreur suivante se produit:

error[E0554]: #[feature] may not be used on the stable release channel 

J'ai aussi essayé

fn main() { 
    let b = Some(box 5); 
} 

error: box expression syntax is experimental; 

Est-ce parce que ma version de Rust n'est pas la dernière? Comment puis-je obtenir le contenu dans Box::new()? J'ai essayé

fn main() { 
    let b = Some(Box::new(5)); 
    match b { 
     Some(Box::new(y)) => print!("{:?}", y), 

     _ => print!("{:?}", 1), 
    } 
} 

error[E0164]: `Box::new` does not name a tuple variant or a tuple struct 
--> main.rs:6:14 
    | 
6 |   Some(Box::new(y)) => print!("{:?}", y), 
    |    ^^^^^^^^^^^ not a tuple variant or struct 

Answer 1

Vous utilisez un #[feature] et ceux qui ne peuvent être utilisés avec un nightly Rust compiler. Je ne pense pas qu'il est actuellement possible de faire correspondre contre un Box à Rust stable, mais permet la nuit de la façon suivante de le faire (comme vous avez essayé au début):

#![feature(box_patterns)] 

fn main() { 
    let b = Some(Box::new(5)); 
    match b { 
     Some(box y) => print!("{:?}", y), 
     _ => print!("{:?}", 1), 
    } 
} 

Answer 2

Rust a three release channels: stable, beta, and nightly. Stable est la version principale, et les développeurs de Rust veillent à ce que les fonctionnalités et mises à jour apportées au canal stable soient bien stables. Cela signifie qu'ils sont entièrement implémentés et sûrs à utiliser, mais surtout, lorsque les développeurs de Rust ajoutent une fonctionnalité à stable, cela signifie qu'ils s'engagent à une rétrocompatibilité. L'engagement de compatibilité descendante est important car cela signifie que les développeurs peuvent commencer à utiliser des fonctionnalités stables dans les bibliothèques sans avoir à se soucier de devoir réécrire entièrement de grandes parties de leur bibliothèque lorsque la langue est mise à jour.

Il existe d'autres fonctionnalités disponibles dans Rust, par exemple la syntaxe box, qui ne sont pas encore complètement finalisées. Beaucoup d'entre eux ont des implémentations partielles ou presque complètes, mais leur syntaxe exacte et leur implémentation sont encore sujettes à changement. Étant donné que ces fonctionnalités ne sont pas considérées comme stables, elles risquent d'être soumises à des modifications incompatibles avec les versions antérieures, ce qui pourrait casser votre code existant si vous en dépendiez.

Par exemple, il y a, ou ont été, deux propositions de syntaxe pour ce qu'on appelle « placement nouvelle » (en évitant la nécessité d'abord allouer sur la pile puis copiez sur le tas):

in PLACE { BLOCK } 
PLACE <- EXPR 

Lorsque le placement nouvelle portée stable, une seule syntaxe sera disponible. Cependant, pendant le développement, l'équipe de Rust peut expérimenter plusieurs façons de faire les choses et les changer comme bon leur semble. Toute personne utilisant des fonctionnalités instables devra mettre à jour son code chaque fois que le compilateur ou les API de langage changeront.

Mais parfois les gens veulent prendre ce risque et utiliser des fonctionnalités qui ne sont pas encore disponibles dans la version stable, sachant que leur code pourrait être cassé par les futures versions.

Pour cela il y a la libération nocturne. C'est une version du compilateur qui est construite avec des fonctions instables et des API activées. Si vous utilisez la version nocturne, vous pouvez utiliser la syntaxe box et une variété d'autres fonctionnalités qui ne sont pas considérées comme prêtes pour une version stable.

Probablement le moyen le plus simple d'obtenir une version nocturne et de basculer entre les versions de nuit et stables est d'installer de la rouille en utilisant rustup. Rustup facilite l'installation de compilateurs Rust ciblant différentes plates-formes et permet de basculer entre les versions stables, nocturnes et bêta.