Crate tuplez

Tuples represented in recursive form rather than parallel form.

Motivation

The primitive tuple types are represented in parallel form, like:

(a, b, c, d ...)

Since Rust doesn’t support variadic generics, we cannot add methods to primitive tuples with any number of elements.

Currently, most tuple crates use declarative macros to implement methods for tuples whose number of elements is less than a certain limit (usually 32).

To solve this, tuplez introduces a Tuple type represented in recursive form, like:

Tuple(a, Tuple(b, Tuple(c, Tuple(d, ...))))

The advantage of this representation is that you can implement methods recursively for all tuples, and there is no longer a limit on the number of tuple’s elements. And, in almost all cases, the Tuple takes no more memory than the primitive tuples.

Functionality

• Create tuples with any number of elements.
• Access elements in a tuple at any index, or by their types.
• Push element to a tuple or pop element from a tuple.
• Join two tuples or split a tuple into two parts.
• Reverse, left rotate, or right rotate a tuple.
• If all element types implement a Trait (e.g. Eq, Add), then the Tuple also implement that Trait. See which traits are supported and learn how to implement your custom traits for Tuple.
• Traverse all elements of a tuple.
• When the number of elements of a tuple doesn’t exceed 32, then it can be converted from/to a primitive tuple or a primitive array.

Optional features

• any_array: Use Rust’s unstable feature to implement conversion from/to primitive arrays on tuples with any number of elements. This feature requires compiling with rustc released to nightly channel.
• unwrap (by default): Allows converting a tuple whose elements are all wrappers into a tuple of the values those wrappers contain. See Unwrap and UnwrapOrDefault.

Examples

// Enable Rust's `generic_const_exprs` feature if you enable tuplez's `any_array` feature.
#![cfg_attr(feature = "any_array", feature(generic_const_exprs))]

use tuplez::*;

let tup = tuple!(1, "hello".to_string(), 3.14);
let tup2 = Tuple::from((2, " world", -3.14));
let tup3 = tup + tup2;
assert_eq!(tup3, tuple!(3, "hello world".to_string(), 0.0));

let tup4 = tup3.push(Some([1, 2, 3]));
let (tup5, popped) = tup4.pop_front();
assert_eq!(
    tup5,
    tuple!("hello world".to_string(), 0.0, Some([1, 2, 3]))
);
assert_eq!(popped, 3);

let tup6 = tup5.rev();
assert_eq!(
    tup6,
    tuple!(Some([1, 2, 3]), 0.0, "hello world".to_string())
);
let tup7 = tup6.rot_l();
assert_eq!(
    tup7,
    tuple!(0.0, "hello world".to_string(), Some([1, 2, 3]))
);

let tup8 = tup7.foreach_once(mapper_once! {
    x : f64 => String : x.to_string();
    x : Option<[i32; 3]> => String: format!("{:?}", x.unwrap());
    x : String : x
});
let arr = tup8.to_array();
assert_eq!(
    arr,
    [
        "0".to_string(),
        "hello world".to_string(),
        "[1, 2, 3]".to_string()
    ]
);

Please check Tuple’s documentation page for detailed usage.

Macros

• get
  Get the element at a specific index of the tuple.
• mapper
  Provides a simple way to create a functor that implements Mapper.
• mapper_mut
  Provides a simple way to create a functor that implements MapperMut.
• mapper_once
  Provides a simple way to create a functor that implements MapperOnce.
• split_at
  Split the tuple into two tuples at a specific index.
• tuple
  Generate a tuple from a list of expressions.
• tuple_pat
  Generate patterns for tuples.
• tuple_t
  Generate the complete type signature for tuples.

Structs

• Searched
  Helper class for Search, indicates that the current element is the one searched for.
• Searching
  Helper class for Search, indicates that the current element is not the one searched for.
• Tuple
  The type used to represent tuples containing at least one element.
• Unit
  The unit type that represents tuples of zero elements.

Traits

• Foreach
  Traverse the tuple by immutable references to its elements.
• ForeachMut
  Traverse the tuple by mutable references to its elements.
• ForeachOnce
  Traverse the tuple by taking its elements.
• Mapper
  Define functors for traversing the tuple by immutable references to tuple’s elements.
• MapperMut
  Define functors for traversing the tuple by mutable references to tuple’s elements.
• MapperOnce
  Define functors for traversing the tuple by taking its elements.
• Popable
  The Popable trait allows popping elements from the front and back of the tuple.
• Rotatable
  The Rotatable trait allows you to rotate the elements of the tuple.
• Search
  Search for an element of a specific type in a tuple.
• ToArray
  The ToArray trait allows you to convert tuples to primitive arrays, if and only if all elements of the tuple are of the same type.
• ToPrimitive
  The ToPrimitive trait allows you to convert tuplez’s tuples to primitive tuples.
• TupleLike
  The TupleLike trait defines the basic methods of tuples.
• Unwrap
  Indicate that a type is a wrapper of a value and can be unwrapped into it.
• UnwrapOrDefault
  Indicate that a type is a wrapper of a value and can be unwrapped into it or the default value.