patrón Rust búsqueda de más de un vector

Question

El tutorial muestra algunos ejemplos muy básicos de coincidencia de patrones, tales como búsqueda de más de un número entero de emular una sentencia switch c-estilo. El tutorial también muestra cómo hacer una desestructuración básica sobre un tipo de tupla y desestructurar estructuras.

parece que debería ser posible patrón de coincidencia sobre un vector, pero no puedo averiguar la sintaxis correcta para él y no he encontrado ningún ejemplo de ello.

Por ejemplo, en Haskell se puede desestructurar fácilmente una lista:

foldr :: (a -> b -> b) -> b -> [a] -> b 
foldr func initValue []  = initValue 
foldr func initValue (x:xs) = func initValue $ foldr initValue func xs 

Así, mirando a una traducción aproximada, sería bueno poder hacer:

fn foldr<A, B>(func: fn(A, B) -> B, 
       initValue: B, 
       vals: [A]) -> B { 
    alt vals { 
    [] { ret initValue; } 
    _ { 
     let h = vec::head(vals), 
      t = vec::tail(vals); 
     ret foldr(func, func(initValue, h), t); 
    } 
    } 
} 

Nota : Sé que podría usar una instrucción if aquí, solo estoy usando esto como un ejemplo de coincidencia de patrones sobre un vector.

este momento, vuelve:

patterns.rs:10:4: 10:5 error: constant contains unimplemented expression type 
patterns.rs:10  [] { ret initValue; } 
       ^
error: aborting due to previous errors 

Hay un ejemplo en el tutorial para desestructurar estructuras (definida con { .. }) y tuplas (definidos con (..)), por lo que parece que debe haber soporte integrado para vectores también considerando que también contienen una sintaxis especial (definida con [ .. ]).

dude en corregirme si estoy usando vectores de la forma equivocada también.

Answer 1

Me gustaría poder dar consejos más general sobre la mejor coincidencia de patrones usados ​​en vectores, pero aquí es cómo puede utilizarlos para la prueba de vectores vacíos (al menos yo que eso es lo que el código Haskell está haciendo .. .):

use std; 
import std::io::println; 

fn main() { 
    let empty: [int] = []; 
    println(vec_alt(empty)); 
    println(vec_alt([1,2,3])); 
} 

fn vec_alt<A>(vals: [A]) -> str { 
    alt vals { 
     x if x == [] { "empty" } 
     _ { "otherwise" } 
    } 
} 

Tenga en cuenta que tratar de pasar simplemente [] como argumento falla porque el compilador no puede inferir un tipo para el vector. Parece que es posible pasar [()] (un vector con un nil interior) sin antes declarar, pero la declaración alt parece incapaz de pruebas para ver si la expresión coincide con la cabeza [()] (simplemente cae hasta el valor por defecto).

En general, los vectores parece un poco áspero en el momento. Si hay algún uso específico que tenga en cuenta que Rust no parece ser compatible, los desarrolladores están abiertos a sugerencias y críticas: https://mail.mozilla.org/listinfo/rust-dev

Consulte también el manual de referencia para obtener una definición más formal, y algunos ejemplos más para ayudar a aclarar las cosas: http://doc.rust-lang.org/doc/rust.html#alternative-expressions