rust - todas - ¿Cómo puedo crear una función con una cantidad variable de argumentos?

tipos de funciones en c

Question

¿Cómo puedo crear una función con una cantidad variable de argumentos en Rust?

Al igual que este código de Java:

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

Answer 1

En general, no se puede: Rust no admite funciones variadic, excepto cuando se interopera con el código C que usa varargs.

En este caso, dado que todos sus argumentos son del mismo tipo, puede aceptar un segmento:

fn foo(args: &[&str]) {
for arg in args {
println!("{}", arg);
}
}
fn main() {
foo(&["hello", "world", "I", "am", "arguments"]);
}

( Patio de recreo )

Más allá de eso, puedes aceptar explícitamente argumentos opcionales:

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);
}

( Patio de recreo )

Si necesita aceptar muchos argumentos, opcionales o no, puede implementar un constructor:

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"));
}

( Patio de recreo )

Answer 2

fn variable_func<T>(_vargs: &[T]) {}
fn main() {
variable_func(&[1]);
variable_func(&[1, 2]);
variable_func(&["A", "B", "C"]);
}