#tuple #iterator #meta

no-std tuples

Provides many useful tools related to tuples

11 stable releases

new 1.9.0 Mar 20, 2023
1.8.0 Mar 19, 2023
1.7.0 Feb 7, 2023
1.6.0 Jun 20, 2022
1.4.0 Nov 11, 2020

#126 in Rust patterns

Download history 50/week @ 2022-11-28 55/week @ 2022-12-05 33/week @ 2022-12-12 44/week @ 2022-12-19 13/week @ 2022-12-26 16/week @ 2023-01-02 231/week @ 2023-01-09 860/week @ 2023-01-16 173/week @ 2023-01-23 56/week @ 2023-01-30 38/week @ 2023-02-06 95/week @ 2023-02-13 73/week @ 2023-02-20 44/week @ 2023-02-27 29/week @ 2023-03-06 31/week @ 2023-03-13

191 downloads per month
Used in 3 crates

MIT license

3MB
35K SLoC

tuples

Rust version documentation LICENSE

Provides many useful tools related to tuples

  • AsRef
  • AsMut
  • AsOption
  • AsResult
  • AsDeref
  • AsDerefMut
  • Transpose Option
  • Transpose Result
  • Cloned
  • Copied
  • Flatten
  • Combin
  • Split
  • Mapping
  • Iter
  • IntoIter
  • FromIter
  • Collect
  • Meta Trait
  • Shorthand Macro

Examples

  • map
    let a = (1, 2, 3);
    let b = a.map(|v| v * 3);
    assert_eq!(b, (3, 6, 9));
    
  • mapN
    let a = (1, 2, 3, 4, 5);
    let b = a.map3(|v| v * 5);
    assert_eq!(b, (1, 2, 3, 20, 5));
    
  • map_all
    let a = (1, 2, 3);
    let b = a.map_all(|v| v * 10, |v| v * 100, |v| v * 1000);
    assert_eq!(b, (10, 200, 3000));
    
  • as_ref
    let t = (5, 6, 7);
    let (a, b, c) = t.as_ref();
    assert_eq!(*a, 5);
    assert_eq!(*b, 6);
    assert_eq!(*c, 7);
    
  • cloned
    let a = (&1, &2, &3);
    let b = a.cloned();
    assert_eq!(b, (1, 2, 3))
    
  • flatten
    let a = ((1, 2, 3), (4, 5, 6), (7, 8, 9));
    let b = a.flatten();
    assert_eq!(b, (1, 2, 3, 4, 5, 6, 7, 8, 9));
    
  • meta
    let a = (1, 2, 3, 4, 5);
    assert_eq!(a.arity(), 5);
    
    let b = ();
    assert_eq!(b.arity(), 0);
    
  • iter
    let a = (1, 2, 3)
        .into_iter()
        .map(|v| v * 3)
        .collect_tuple::<tuple![3;]>();
    let b: (i32, i32, i32) = (3, 6, 9);
    assert_eq!(a, b);
    
    let a = (1, 2, 3)
        .into_iter()
        .map(|v| v * 3)
        .try_collect_tuple::<tuple![3;]>();
    let b: Option<(i32, i32, i32)> = Some((3, 6, 9));
    assert_eq!(a, b);
    
    let a = (1, 2, 3)
        .into_iter()
        .map(|v| v * 3)
        .collect_tuple_try::<tuple![3;]>();
    let b: (Option<i32>, Option<i32>, Option<i32>) = (Some(3), Some(6), Some(9));
    assert_eq!(a, b);
    
  • transpose
    let a = Some((1, 2, 3)).transpose();
    assert_eq!(a, (Some(1), Some(2), Some(3)));
    
    let b = (Some(1), Some(2), Some(3)).transpose();
    assert_eq!(b, Some((1, 2, 3)));
    
    let a: (Result<u8, ()>, Result<u8, ()>, Result<u8, ()>) = (Ok(1), Ok(2), Ok(3));
    let b: Result<(u8, u8, u8), ()> = a.transpose();
    assert_eq!(b, Ok((1, 2, 3)));
    
    let a: (Result<u8, i16>, Result<u8, i32>, Result<u8, i64>) = (Ok(1), Err(-1), Ok(3));
    let b: Result<(u8, u8, u8), i64> = a.transpose();
    assert_eq!(b, Err(-1));
    
    let a: (Result<u8, i16>, Result<u8, i32>, Result<u8, i64>) = (Ok(1), Err(-1), Ok(3));
    let b = a.transpose1::<i64>();
    assert_eq!(b, Err(-1));
    
  • combin
    let a = (1, 2).push_right(3);
    assert_eq!(a, (1, 2, 3));
    
    let b = (2, 1).push_left(3);
    assert_eq!(b, (3, 2, 1));
    
    let c = (1, 2, 3).concat((4, 5, 6));
    assert_eq!(c, (1, 2, 3, 4, 5, 6))
    
  • split
    • split_parts
      let t = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
      
      let a = t.split_2_parts();
      assert_eq!(a, ((0, 1, 2, 3, 4), (5, 6, 7, 8, 9)));
      
      let b = t.split_3_parts();
      assert_eq!(b, ((0, 1, 2, 3), (4, 5, 6), (7, 8, 9)));
      
      let c = t.split_4_parts();
      assert_eq!(c, ((0, 1, 2), (3, 4, 5), (6, 7), (8, 9)));
      
      let d = t.split_5_parts();
      assert_eq!(d, ((0, 1), (2, 3), (4, 5), (6, 7), (8, 9)));
      
    • split_at
      let t = (1, 2, 3, 4, 5, 6);
      
      let a = t.split_at_1();
      assert_eq!(a, (1, (2, 3, 4, 5, 6)));
      
      let b = t.split_at_3();
      assert_eq!(b, ((1, 2, 3), (4, 5, 6)));
      
      let c = t.split_at_5();
      assert_eq!(c, ((1, 2, 3, 4, 5), 6));
      
    • split_by
      let t = (1, 2, 3, 4, 5, 6);
      let t2 = (1, 2, 3, 4, 5);
      
      let a = t.split_by_2();
      assert_eq!(a, ((1, 2), (3, 4), (5, 6)));
      
      let b = t2.split_by_2();
      assert_eq!(b, ((1, 2), (3, 4), 5));
      
      let c = t.split_by_3();
      assert_eq!(c, ((1, 2, 3), (4, 5, 6)));
      
      let d = t2.split_by_3();
      assert_eq!(d, ((1, 2, 3), (4, 5)));
      
      let e = t.split_by_6();
      assert_eq!(e, ((1, 2, 3, 4, 5, 6)));
      
    • split_to_tuple_at
      let t = (1, 2, 3, 4, 5, 6);
      
      let a = t.split_to_tuple_at_1();
      assert_eq!(a, ((1,), (2, 3, 4, 5, 6)));
      
      let b = t.split_to_tuple_at_3();
      assert_eq!(b, ((1, 2, 3), (4, 5, 6)));
      
      let c = t.split_to_tuple_at_5();
      assert_eq!(c, ((1, 2, 3, 4, 5), (6,)));
      
    • split_to_tuple_by
      let t = (1, 2, 3, 4, 5, 6);
      let t2 = (1, 2, 3, 4, 5);
      
      let a = t.split_to_tuple_by_2();
      assert_eq!(a, ((1, 2), (3, 4), (5, 6)));
      
      let b = t2.split_to_tuple_by_2();
      assert_eq!(b, ((1, 2), (3, 4), (5,)));
      
      let c = t.split_to_tuple_by_3();
      assert_eq!(c, ((1, 2, 3), (4, 5, 6)));
      
      let d = t2.split_to_tuple_by_3();
      assert_eq!(d, ((1, 2, 3), (4, 5)));
      
      let e = t.split_to_tuple_by_6();
      assert_eq!(e, (((1, 2, 3, 4, 5, 6),)));
      

No runtime deps

Features

  • cloned
  • combin
  • flatten
  • re-exports
  • shorthand
  • split
  • split_at
  • split_by
  • split_parts
  • split_to_tuple_at
  • split_to_tuple_by
  • transpose
  • tuple_as
  • tuple_call
  • tuple_iter
  • tuple_map
  • tuple_meta