iter_tools 0.50.0

Collection of general purpose tools to iterate. Currently it simply reexports itertools.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//!
//! Tests for `zip` re-export functionality.
//!
//! ## Root Cause
//!
//! Issue found during manual testing: `zip()` was unavailable when `no_std` feature was enabled
//! because the cfg guard was `#[ cfg(not(feature = "no_std")) ]`, which disabled `zip` when
//! `no_std` was active. However, `core::iter::zip` is available in both std and `no_std`
//! environments, so this guard was incorrect.
//!
//! ## Why Not Caught
//!
//! - Default features don't include `no_std`, so normal testing passed
//! - Running with `--all-features` enabled `no_std`, exposing the bug
//! - No existing tests verified `zip` availability with all feature combinations
//!
//! ## Fix Applied
//!
//! Removed the `#[ cfg(not(feature = "no_std")) ]` guard from `zip` re-export in `src/iter.rs:267`,
//! making `zip` unconditionally available since `core::iter::zip` exists in all configurations.
//!
//! ## Prevention
//!
//! Added comprehensive tests that verify `zip` works with:
//! - Default features (`no_std` disabled)
//! - All features (`no_std` enabled)
//! - Various iterator configurations (empty, equal length, different lengths)
//!
//! ## Pitfall
//!
//! When re-exporting from `core::` namespace, don't add cfg guards based on `no_std` unless the
//! functionality genuinely requires std. `core::iter::zip` is available everywhere, so it should
//! be unconditionally re-exported.
//!

#[ allow( unused_imports ) ]
use super::*;
#[ allow( unused_imports ) ]
use the_module::*;

//

/// Test zip with equal length iterators (normal case from spec.md Pattern 1)
#[ test ]
#[ cfg( feature = "enabled" ) ]
fn zip_equal_length()
{
  let vec = vec![ 5, 1, -2 ];
  let added = vec![ "a", "b", "c" ];
  let mut result = vec![];
  let zipped = zip( &vec, &added );
  for ( left, right ) in zipped
  {
    result.push( ( *left, *right ) );
  }
  assert_eq!( result, vec![ ( 5, "a" ), ( 1, "b" ), ( -2, "c" ) ] );
}

/// Test zip with empty iterators (corner case)
#[ test ]
#[ cfg( feature = "enabled" ) ]
fn zip_empty()
{
  let a: Vec< i32 > = vec![];
  let b: Vec< &str > = vec![];
  let zipped: Vec< _ > = zip( &a, &b ).collect();
  assert_eq!( zipped.len(), 0 );
}

/// Test zip with different length iterators - first longer (corner case)
#[ test ]
#[ cfg( feature = "enabled" ) ]
fn zip_first_longer()
{
  let a = vec![ 1, 2, 3, 4 ];
  let b = vec![ "a", "b" ];
  let zipped: Vec< _ > = zip( &a, &b ).collect();
  // zip stops at shortest iterator
  assert_eq!( zipped.len(), 2 );
  assert_eq!( zipped, vec![ ( &1, &"a" ), ( &2, &"b" ) ] );
}

/// Test zip with different length iterators - second longer (corner case)
#[ test ]
#[ cfg( feature = "enabled" ) ]
fn zip_second_longer()
{
  let a = vec![ 1, 2 ];
  let b = vec![ "a", "b", "c", "d" ];
  let zipped: Vec< _ > = zip( &a, &b ).collect();
  // zip stops at shortest iterator
  assert_eq!( zipped.len(), 2 );
  assert_eq!( zipped, vec![ ( &1, &"a" ), ( &2, &"b" ) ] );
}

/// Test that zip is available even when `no_std` feature is enabled.
/// This test exists specifically to prevent regression of the bug where zip
/// was unavailable with `no_std` feature.
#[ test ]
#[ cfg( feature = "enabled" ) ]
#[ cfg( feature = "no_std" ) ]
fn zip_available_with_no_std()
{
  let a = vec![ 1, 2, 3 ];
  let b = vec![ "x", "y", "z" ];
  let result: Vec< _ > = zip( &a, &b ).collect();
  assert_eq!( result, vec![ ( &1, &"x" ), ( &2, &"y" ), ( &3, &"z" ) ] );
}