Lib.rs

Overview

This is just a little fun project and should probably not be used in production. Currently variadics are only implemented up to a dimension of 4. Variadic's are only pssible because of default types and I consider this implementaion a hack.

Variadic<T> is the trait that makes variadic arguments possible in stable Rust. VarArgs1, VarArgs2 etc implement Variadic<T> which allows the user the call pop().

pop will return the first argument inside an Option and another VarArgs(n-1). For example

    let (Some(value), rest: VarArgs2<i32, i32>) = VarArgs3(1, 2, 3).pop();

Examples:

A simple sum example implemented with recursion.

fn sum<Args: Variadic<i32>>(args: Args) -> i32 {
   if let (Some(front), rest) = args.pop() {
       front + sum(rest)
   } else {
       0
   }
}
println!("sum: {}", sum(VarArgs4(1, 2, 3, 4)));

Here we call pop on VarArgsN<i32...> and it will return (Option<i32>, VarArgs(N-1)<i32...>). The recursion stops at VarArgs0 which will returns a (Option<i32>, VarArgs0<i32>) where Option<i32> will always be None.

fn fact<Args: Variadic<i32>>(args: Args) -> i32 {
   if let (Some(front), rest) = args.pop() {
       front * fact(rest)
   } else {
       1
   }
}
println!("fact: {}", fact(VarArgs4(1, 2, 3, 4)));

It is also possible to use traits with Variadic. Here we constrain T with std::fmt::Debug, then we print out every value that we pop off until we reach VarArgs0.

fn debug_print<T, Args: Variadic<T>>(args: Args)
   where T: std::fmt::Debug
{
   if let (Some(front), rest) = args.pop() {
       println!("{:?}", front);
       debug_print(rest);
   }
}

debug_print(VarArgs3(1, 2, 3));