Come posso creare una funzione con un numero variabile di argomenti?

Question

Come posso creare una funzione con un numero variabile di argomenti in Rust?

Ti piace questa codice Java:

void foo(String... args) { 
    for (String arg : args) { 
     System.out.println(arg); 
    } 
} 

Answer 1

In generale, non è possibile - Rust non supporta le funzioni variadic, eccetto quando l'interoperabilità con codice C che utilizza varargs.

In questo caso, dal momento che tutti i tuoi argomenti sono dello stesso tipo, è possibile accettare una fetta:

fn foo(args: &[&str]) { 
    for arg in args { 
     println!("{}", arg); 
    } 
} 

fn main() { 
    foo(&["hello", "world", "I", "am", "arguments"]); 
} 

(Playground)

Oltre a ciò, è possibile accettare esplicitamente argomenti opzionali:

fn foo(name: &str, age: Option<u8>) { 
    match age { 
     Some(age) => println!("{} is {}.", name, age), 
     None  => println!("Who knows how old {} is?", name), 
    } 
} 

fn main() { 
    foo("Sally", Some(27)); 
    foo("Bill", None); 
} 

(Playground)

Se è necessario accettare molti argomenti, opzionali o no, è possibile implementare un costruttore:

struct Arguments<'a> { 
    name: &'a str, 
    age: Option<u8>, 
} 

impl<'a> Arguments<'a> { 
    fn new(name: &'a str) -> Arguments<'a> { 
     Arguments { 
      name: name, 
      age: None 
     } 
    } 

    fn age(self, age: u8) -> Self { 
     Arguments { 
      age: Some(age), 
      ..self 
     } 
    } 
} 

fn foo(arg: Arguments) { 
    match arg.age { 
     Some(age) => println!("{} is {}.", arg.name, age), 
     None  => println!("Who knows how old {} is?", arg.name), 
    } 
} 

fn main() { 
    foo(Arguments::new("Sally").age(27)); 
    foo(Arguments::new("Bill")); 
} 

(Playground)

Answer 2

fn variable_func<T>(_vargs: &[T]) {} 

fn main() { 
    variable_func(&[1]); 
    variable_func(&[1, 2]); 
    variable_func(&["A", "B", "C"]); 
}