Crate named_tup

  

This crate provides the tup! macro to produce named tuples, a struct that can contain a set of named arguments. Each named tuple can be added together or even default to a value if it does not already exist.

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.

[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.

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.

[package.metadata.inwelling.named-tup-derive]
arguments = ["count", "ingredients", "eggs", "price"]

Examples

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]. 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.

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
}

Macros

• Tup
  Produces a type annotation for the tup struct. If an expression is needed instead please use the tup! macro.
• tup
  The whole point.

Traits

• TupFrom
  A copy of the From trait from the standard library. The From trait could unfortunately not be used due to it’s type reflexivity which clashed with the Tup implementation.
• TupInto
  A copy of the Into trait from the standard library. The Into trait could unfortunately not be used due to it’s type reflexivity which clashed with the Tup implementation.

Attribute Macros

• tup_default
  An attribute macro that allows you to derive defaults.