Crate overfn

Overload functions

This crate allows you to overload functions with the same name but with different number of arguments through the overload macro. After overloading all the functions, you need to use the macros!() to genarate the macros to invoke the overloaded functions.

Example

use overfn::*;

#[overload]
fn test(item: usize) -> usize {
    item
}

#[overload]
fn test(left: usize, right: usize) -> usize {
    left + right
}

struct Test(usize);

impl Test {
    #[overload(Test)]
    fn new() -> Self {
        Self(0)
    }

    #[overload(Test)]
    fn new(item: usize) -> Self {
        Self(item)
    }

    #[overload(Test)]
    fn test(&self) -> usize {
        self.0
    }

    #[overload(Test)]
    fn test(&self, other: usize) -> usize {
        self.0 + other
    }
}

macros!();

assert_eq!(test!(2), 2);
assert_eq!(test!(2, 2), 4);

let test = Test_new!();
assert_eq!(test.0, 0);

let test = Test_new!(2);
assert_eq!(test.0, 2);

assert_eq!(Test_test!(test), 2);
assert_eq!(Test_test!(test, 2), 4);

Limitations

• Curretly, you can’t overload a function with the same number of arguments with different types.
• You need to use the macros!() macro to generate the macros to call the overloaded functions.
• If you overload a class method or instance method, you need to pass the class name in the attribute.

Macros

• macros
  Generate the macros to call the overloaded functions. You need to call this macro after all the functions are overloaded.

Attribute Macros

• overload
  Overload a function with a new function with the same name but with different number of arguments.