Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/buttercrab/default-args.rs
zero runtime cost default arguments in rust
https://github.com/buttercrab/default-args.rs
default-arguments macro rust rust-lang rust-macro
Last synced: about 2 months ago
JSON representation
zero runtime cost default arguments in rust
- Host: GitHub
- URL: https://github.com/buttercrab/default-args.rs
- Owner: buttercrab
- License: mit
- Created: 2021-08-22T07:51:39.000Z (about 3 years ago)
- Default Branch: master
- Last Pushed: 2023-06-26T01:27:16.000Z (about 1 year ago)
- Last Synced: 2024-07-12T22:53:44.724Z (2 months ago)
- Topics: default-arguments, macro, rust, rust-lang, rust-macro
- Language: Rust
- Homepage:
- Size: 45.9 KB
- Stars: 84
- Watchers: 2
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Default Arguments in Rust
[](https://github.com/buttercrab/default-args.rs/actions/workflows/build.yml)
[](https://github.com/buttercrab/default-args.rs/releases)
[](https://crates.io/crates/default-args)
[](https://github.com/buttercrab/default-args.rs/blob/master/LICENSE)
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 default_args::default_args;
// this would make a macro named `foo`
// and original function named `foo_`
default_args! {
fn foo(important_arg: u32, optional: u32 = 100) -> String {
format!("{}, {}", important_arg, optional)
}
}
// in other codes ...
assert_eq!(foo!(1), "1, 100"); // foo(1, 100)
assert_eq!(foo!(1, 3), "1, 3"); // foo(1, 3)
assert_eq!(foo!(1, optional = 10), "1, 10"); // foo(1, 10)
// let's make another one
default_args! {
#[inline]
pub async unsafe extern "C" fn bar(a: S1, b: S2 = "b", c: S3 = "c") -> String
where
S1: AsRef,
S2: AsRef,
S3: AsRef,
{
format!("{}, {}, {}", a.as_ref(), b.as_ref(), c.as_ref())
}
// that was long signature!
}
// in other codes ...
assert_eq!(unsafe { bar!("a") }.await, "a, b, c");
assert_eq!(unsafe { bar!("a", "d") }.await, "a, d, c");
// you can even mix named & unnamed argument in optional arguments
assert_eq!(unsafe { bar!("a", "d", c = "e") }.await, "a, d, e");
assert_eq!(unsafe { bar!("a", c = "e") }.await, "a, b, e");
```
See [examples](https://github.com/buttercrab/default-args.rs/tree/master/examples) for more information.
## More Features
### Export
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_export]
macro_rules! foo { () => {}; }
```
### Path of function
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
#[macro_use]
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_()
};
}
}
```
#### *Why do we have to write module?*
> `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.
## License
[MIT License](https://github.com/buttercrab/default-args.rs/blob/master/LICENSE)