How can I create a function with a variable number of arguments?

by

In general, you can’t – Rust does not support variadic functions, except when interoperating with C code that uses varargs.

In this case, since all of your arguments are the same type, you can accept a slice:

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

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

(Playground)

Beyond that, you can explicitly accept optional arguments:

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)

If you need to accept many arguments, optional or not, you can implement a builder:

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)

More Related Contents:

  1. Traits and Rust
  2. Why do try!() and ? not compile when used in a function that doesn’t return Option or Result?
  3. Why does linking lifetimes matter only with mutable references?
  4. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  5. Should trait bounds be duplicated in struct and impl?
  6. How do I collect into an array?
  7. Cannot borrow as mutable more than once at a time in one code – but can in another very similar
  8. Implementing a trait for multiple types at once
  9. How do I get an owned value out of a `Box`?
  10. How do I borrow a RefCell, find a key, and return a reference to the result? [duplicate]
  11. How can I store a Chars iterator in the same struct as the String it is iterating on?
  12. How to disable unused code warnings in Rust?
  13. Is there a way other than traits to add methods to a type I don’t own?
  14. How do you use parent module imports in Rust?
  15. Can’t borrow mutably within two different closures in the same scope
  16. What is the syntax to match on a reference to an enum?
  17. How can I implement Rust’s Copy trait?
  18. How to use a struct’s member as its own key when inserting the struct into a map without duplicating it?
  19. Why can’t I return an &str value generated from a String?
  20. How to implement a custom ‘fmt::Debug’ trait?
  21. How do I pass a closure through raw pointers as an argument to a C function?
  22. What is the prelude?
  23. How to embed resources in Rust executable?
  24. How do I use a crate from another crate without explicitly defining a new dependency in my project?
  25. How do I print an integer in binary with leading zeros?
  26. What does Rust’s unary || (parallel pipe) mean?
  27. How does Rust’s type inference work across multiple statements?
  28. Why does Valgrind not detect a memory leak in a Rust program using nightly 1.29.0?
  29. What is the null pointer optimization in Rust?
  30. How to pass rustc flags to cargo?

Leave a Comment