Valores de enum de acceso en Rust

Question

struct Point { x: f64, y: f64 } 

enum Shape { 
    Circle(Point, f64), 
    Rectangle(Point, Point) 
} 

let my_shape = Shape::Circle(Point {x: 0.0, y: 0.0}, 10.0); 

Quiero imprimir la segunda propiedad del círculo, que es 10.0 aquí. Intenté my_shape.last y my_shape.second, pero ninguno funcionó.

¿Qué debo hacer para imprimir 10.0 en este caso?

Gracias

Answer 1

no estoy seguro si hay una mejor manera de hacer eso, pero se puede utilizar la coincidencia de modelos:

use std; 

type point = {x: float, y: float}; 
enum shape { 
    circle(point, float), 
    rectangle(point, point) 
} 

fn main() { 
    let my_shape = circle({x: 0.0, y: 0.0}, 10.0); 
    alt my_shape { 
     circle(_, value) { 
      std::io::println(#fmt("value: %f", value)); 
     } 
    } 
} 

Ejemplo de salida:

value: 10 

Answer 2

Aquí es Otra forma de hacerlo:

use std; 

type point = {x: float, y: float}; 
enum shape { 
    circle(point, float), 
} 

fn main() { 
    let circle(_, radius) = circle({x: 0.0, y: 0.0}, 10.0); 
    std::io::println(#fmt("value: %f", radius)); 
} 

Esto solo funciona si el patrón de let es irrefutable, por ejemplo, si el tipo de enumeración con el que se establece una coincidencia solo tiene una variante. Para que esto funcione, tuve que eliminar la variante rectangle no utilizada.

En los casos en los que tenga más de una variante, probablemente desee la expresión alt completa de todos modos, ya que presumiblemente maneja más de un tipo de forma.

Answer 3

Desde el tutorial Rust (énfasis añadido):

Para los tipos de enumeración con múltiples variantes, desestructuración es la única manera de conseguir por lo su contenido. Todos los constructores variantes se pueden utilizar como patrones, como en esta definición de la zona:

fn area(sh: shape) -> float { 
    alt sh { 
     circle(_, size) { float::consts::pi * size * size } 
     rectangle({x, y}, {x: x2, y: y2}) { (x2 - x) * (y2 - y) } 
    } 
} 

http://doc.rust-lang.org/doc/tutorial.html#enum-patterns

Si desea ser capaz de escribir funciones que son capaces de trabajar en múltiples tipos con diferentes representaciones, echar un vistazo a las interfaces:

http://doc.rust-lang.org/doc/tutorial.html#interfaces

Answer 4

a medida que sólo está interesado en matchin g una de las variantes, se puede utilizar un if let expresión:

struct Point { x: f64, y: f64 } 

enum Shape { 
    Circle(Point, f64), 
    Rectangle(Point, Point) 
} 

fn main() { 
    let my_shape = Shape::Circle(Point { x: 0.0, y: 0.0 }, 10.0); 

    if let Shape::Circle(_, radius) = my_shape { 
     println!("value: {}", radius); 
    } 
} 

Esto significa "si my_shape puede ser desestructurado en una Circle, no hacer nada con el primer índice, pero unir el valor del segundo índice de radius" .