Enables default arguments in rust by macro in zero cost. Just wrap function with default_args! and macro with name of
function would be automatically generated to be used with default argument. See below for usage
```rust use defaultargs::defaultargs;
// this would make a macro named foo
// and original function named foo_
defaultargs! {
fn foo(importantarg: u32, optional: u32 = 100) -> String {
format!("{}, {}", important_arg, optional)
}
}
// in other codes ... asserteq!(foo!(1), "1, 100"); // foo(1, 100) asserteq!(foo!(1, 3), "1, 3"); // foo(1, 3) assert_eq!(foo!(1, optional = 10), "1, 10"); // foo(1, 10)
// let's make another one
defaultargs! {
#[inline]
pub async unsafe extern "C" fn bar
// in other codes ... asserteq!(unsafe { bar!("a") }.await, "a, b, c"); asserteq!(unsafe { bar!("a", "d") }.await, "a, d, c"); // you can even mix named & unnamed argument in optional arguments asserteq!(unsafe { bar!("a", "d", c = "e") }.await, "a, d, e"); asserteq!(unsafe { bar!("a", c = "e") }.await, "a, b, e"); ```
See examples for more information.
Add export in the front of the function and the macro would be exported. (add pub to export function with macro)
rust
default_args! {
export pub fn foo() {}
}
Above macro will expand as below
```rust pub fn foo_() {}
macro_rules! foo { () => {}; } ```
Macro just call the function in name, so you should import both macro and the function to use it. By writing the path of
this function, you can just only import the macro.
(path should start with crate)
```rust
pub mod foo { default_args! { pub fn crate::foo::bar() {} } }
// then it would create bar!()
bar!();
```
Above macro would expand as below
```rust pub mod foo { pub fn bar_() {}
macro_rules! bar_ {
() => {
$crate::foo::bar_()
};
}
} ```
std::module_path!can resolve the module path of the function where it is declared. However, it can be resolved in runtime, not compile-time. I couldn't find a way to get module path in compile-time.