Named Tups
==================
[
](https://github.com/miam-miam/named-tup)
[
](https://crates.io/crates/named-tup)
[
](https://docs.rs/named-tup)
Provides a new type called Named Tups that can be called using the [`tup!`] macro. Named Tups are structs that can
contain a set of named arguments, effectively they work like normal tuples that can be accessed and created using an
actual name.
[`tup!`]: https://docs.rs/named-tup/latest/named-tup/macro.tup.html
The idea of named tuples is to provide a way to quickly iterate on ideas without having to create a builder struct or
losing the ability to type check at compile time. Named tuples also allow the creation of default values that can
replace nonexistent arguments.
```toml
[dependencies]
named-tup = "0.3.1"
[build-dependencies]
inwelling = "0.4.0"
[package.metadata.inwelling.named-tup-derive]
```
And put the following in your `build.rs` file.
```rust
fn main() {
inwelling::register();
}
```
If you would prefer for this crate to not scan your project files to determine what named arguments are being used add a
list
of the named tup arguments you used in your Cargo.toml like so.
```toml
[package.metadata.inwelling.named-tup-derive]
arguments = ["count", "ingredients", "eggs", "price"]
```
## Examples
```rust
use named_tup::tup;
let count = 5;
// This will have the type of Tup!(count: i32, ingredients: [&str; 3], eggs: bool)
let cakes = tup!(count, ingredients: ["milk", "flower", "sugar"], eggs: true);
// We can just add a price afterwards
let mut cakes = cakes + tup!(price: 3);
// And now it has the type of Tup!(eggs: bool, ingredients: [&str; 3], count: i32, price: i32)
// Once the price is in the tup we can just update it!
cakes.price = 4;
// Will print tup { count: 5, eggs: true, ingredients: ["milk", "flower", "sugar"], price: 4 }
println!("{cakes:?}");
```
To use defaults just annotate the item where you set a field
with [`#[tup_default]`](https://docs.rs/named-tup/latest/named-tup/attr.tup_default.html). Additionally since the
defaulted [`tup!`] is a type you need to convert into it by calling [`.into_tup()`] which can be accessed through
the [`TupInto`] trait.
[`.into_tup()`]: https://docs.rs/named-tup/latest/named-tup/trait.TupInto.html
[`TupInto`]: https://docs.rs/named-tup/latest/named-tup/trait.TupInto.html
```rust
use named_tup::{tup, Tup, tup_default, TupInto};
let options = tup!(read: false, write: true);
// Converts to Tup!(read: false, write: true, create: false, timeout: 5)
open_file("main.rs", options.into_tup());
#[tup_default]
fn open_file(
path: &str,
options: Tup!(
read: bool = true,
write: bool = false,
create: bool = false,
timeout: i32 = 5
))
{
// Open the file
}
```
To test the crate enable the feature `dev-test`.
## Roadmap
- Write some more tests
- Serialise and Deserialise using Serde
- Provide nice looking types for cargo doc
#### License
Licensed under either of Apache License, Version
2.0 or MIT license at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
be dual licensed as above, without any additional terms or conditions.