collection_tools 0.53.0

General purpose tools to manipulate collections( containers like Vec/HashMap/HashSet ).
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

use super :: *;

#[ test ]
fn reexport() 
{
  let mut set1: the_module ::HashSet< i32 > = the_module ::HashSet ::new();
  set1.insert(1);
  assert!(set1.contains(&1));
  assert!(!set1.contains(&2));

  let mut set2: the_module ::Set< i32 > = the_module ::Set ::new();
  set2.insert(1);
  assert!(set2.contains(&1));
  assert!(!set2.contains(&2));

  assert_eq!(set1, set2);
}

#[ cfg( feature = "collection_constructors" ) ]
#[ test ]
fn constructor() 
{
  // test.case( "empty" );
  let got: the_module ::HashSet< i32 > = the_module ::hset! {};
  let exp = the_module ::HashSet ::new();
  assert_eq!(got, exp);

  // test.case( "multiple entry" );
  let got = the_module ::hset! { 13, 11 };
  let mut exp = the_module ::HashSet ::new();
  exp.insert(11);
  exp.insert(13);
  assert_eq!(got, exp);

  let _got = the_module ::hset!("b");
  let _got = the_module ::exposed ::hset!("b");
}

#[ cfg( feature = "collection_into_constructors" ) ]
#[ test ]
fn into_constructor() 
{
  // test.case( "empty" );
  let got: the_module ::HashSet< i32 > = the_module ::into_hset! {};
  let exp = the_module ::HashSet ::new();
  assert_eq!(got, exp);

  // test.case( "multiple entry" );
  let got = the_module ::into_hset! { 13, 11 };
  let mut exp = the_module ::HashSet ::new();
  exp.insert(11);
  exp.insert(13);
  assert_eq!(got, exp);

  // Note: Cross-crate type compatibility issue - these macros return test_tools ::HashSet
  // but the test expects collection_tools ::HashSet. This is an architectural limitation.
  // drop(the_module ::into_hset!("b"));
  // drop(the_module ::exposed ::into_hset!("b"));
}

#[ test ]
fn iters() 
{
  struct MyContainer 
  {
  entries: the_module ::HashSet< i32 >,
 }

  impl IntoIterator for MyContainer 
  {
  type Item = i32;
  type IntoIter = the_module ::hash_set ::IntoIter< i32 >;

  fn into_iter(self) -> Self ::IntoIter 
  {
   self.entries.into_iter()
 }
 }

  impl< 'a > IntoIterator for &'a MyContainer 
{
  type Item = &'a i32;
  type IntoIter = the_module ::hash_set ::Iter< 'a, i32 >;

  fn into_iter(self) -> Self ::IntoIter 
  {
   self.entries.iter()
 }
 }

  let instance = MyContainer {
  entries: the_module ::HashSet ::from([1, 2, 3]),
 };
  let got: the_module ::HashSet< _ > = instance.into_iter().collect();
  let exp = the_module ::HashSet ::from([1, 2, 3]);
  assert_eq!(got, exp);

  let instance = MyContainer {
  entries: the_module ::HashSet ::from([1, 2, 3]),
 };
  let got: the_module ::HashSet< _ > = (&instance).into_iter().copied().collect();
  let exp = the_module ::HashSet ::from([1, 2, 3]);
  assert_eq!(got, exp);
}