https://github.com/sigurd4/tuple_split
An extension for the tupleops crate which adds a trait for splitting tuples by an index.
https://github.com/sigurd4/tuple_split
const rust split trait tuple
Last synced: about 1 year ago
JSON representation
An extension for the tupleops crate which adds a trait for splitting tuples by an index.
- Host: GitHub
- URL: https://github.com/sigurd4/tuple_split
- Owner: sigurd4
- License: mit
- Created: 2023-03-20T15:48:47.000Z (about 3 years ago)
- Default Branch: master
- Last Pushed: 2023-03-20T16:11:48.000Z (about 3 years ago)
- Last Synced: 2024-04-25T14:22:28.315Z (almost 2 years ago)
- Topics: const, rust, split, trait, tuple
- Language: Rust
- Homepage:
- Size: 3.91 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
[](https://github.com/sigurd4/tuple_split/actions/workflows/build-nightly.yml)
[](https://github.com/sigurd4/tuple_split/actions/workflows/build-nightly-all-features.yml)
[](https://github.com/sigurd4/tuple_split/actions/workflows/build-stable.yml)
[](https://github.com/sigurd4/tuple_split/actions/workflows/build-stable-all-features.yml)
[](https://github.com/sigurd4/tuple_split/actions/workflows/test.yml)
[](https://github.com/sigurd4/tuple_split/actions/workflows/lint.yml)
[](https://crates.io/crates/tuple_split)
[](https://opensource.org/licenses/MIT)
[](https://docs.rs/tuple_split)
[](https://app.codecov.io/github/sigurd4/tuple_split)
# tuple_split
This crate an extension for the [tupleops](https://crates.io/crates/tupleops) crate.
[tupleops](https://crates.io/crates/tupleops) contains many useful features for manipulating tuples and using tuples in generic code. However, it does not support any kind of splitting of tuples. This crate adds that feature.
## Examples
```rust
let t = (32, 0.707, "test");
// Splitting tuples by index
let (l, r) = tuple_split::split_tuple_at::<0, _>(t);
assert_eq!(t, tupleops::concat_tuples(l, r));
let (l, r) = tuple_split::split_tuple_at::<1, _>(t);
assert_eq!(t, tupleops::concat_tuples(l, r));
let (l, r) = tuple_split::split_tuple_at::<2, _>(t);
assert_eq!(t, tupleops::concat_tuples(l, r));
let (l, r) = tuple_split::split_tuple_at::<3, _>(t);
assert_eq!(t, tupleops::concat_tuples(l, r));
// Splitting tuples given a left side
let (l, r) = tuple_split::split_tuple_into_left::<(u8, f32), _>(t);
assert_eq!(t, tupleops::concat_tuples(l, r));
// Splitting tuples given a right side
let (l, r) = tuple_split::split_tuple_into_right::<(&str,), _>(t);
assert_eq!(t, tupleops::concat_tuples(l, r));
// Splitting tuples given both sides
let (l, r) = tuple_split::split_tuple_into::<(u8, f32), (&str)>(t);
assert_eq!(t, tupleops::concat_tuples(l, r));
```
## Split by index
Tuples can be split by a const-generic index. To use this feature, put `#![feature(generic_const_exprs)]` on the top of your `lib.rs` or `main.rs`.
### Example
```rust
#![feature(generic_const_exprs)]
let t = (1, 1.0, "test");
let (l, r) = tuple_split::split_tuple_at::<2, _>(t);
assert_eq!(t, tupleops::concat_tuples(l, r));
```
## Split by type
The type of tuple you want from the split operation can be used instead of an index. This does not require `#![feature(generic_const_exprs)]`. Either the left, right or both can be provided as a generic type.
### Examples
#### Left
```rust
let t = (1, 1.0, "test");
let (l, r) = tuple_split::split_tuple_into_left::<(u8, f32), _>(t);
assert_eq!(t, tupleops::concat_tuples(l, r));
```
#### Right
```rust
let t = (1, 1.0, "test");
let (l, r) = tuple_split::split_tuple_into_right::<(&str,), _>(t);
assert_eq!(t, tupleops::concat_tuples(l, r));
```
#### Both
```rust
let t = (1, 1.0, "test");
let (l, r) = tuple_split::split_tuple_into::<(u8, f32), (&str,)>(t);
assert_eq!(t, tupleops::concat_tuples(l, r));
```
## Tuple sizes
By default, this crate operates with tuples of up to 16 elements, just like the [tupleops](https://crates.io/crates/tupleops) crate. If you want to use differently sized tuples, use the features `8`, `16`, `32`, `64`, `96`, `128`, `160`, `192`, `224` or `256` to set the maximum supported tuple size.
The `dont_hurt_yourself_by_using_all_features` is there to prevent usage of tuples bigger than 8 if `cargo` is ran with the flag `--all-features`. Using a tuple size above 16 is highly discouraged as it will make compilation time unbearably long. Compilation time will increase exponentially. You have been warned.