Crate collection_tools

Module :: collection_tools

Collection of general purpose tools to manipulate collections( containers like Vec/HashMap/HashSet… ).

Basic Use Case :: Variadic Constructors for Collections

This module encompasses a suite of meta-tools designed to enhance Rust’s collection handling, most notably through the inclusion of variadic constructors. A prime example is the hmap! macro, which facilitates the ergonomic construction of HashMap instances. These constructors allow for the intuitive and concise initialization of collections, mirroring the simplicity found in other programming languages.

Consider the following example, which demonstrates the use of the hmap! macro to effortlessly create a HashMap:

use collection_tools::*;

let meta_map = hmap! { 3 => 13 };
let mut std_map = std::collections::HashMap::new();
std_map.insert( 3, 13 );
assert_eq!( meta_map, std_map );

Basic Use Case :: no_std HashSet / HashMap

When implementing a no_std environment with the use_alloc feature in your Rust project, you’ll encounter a challenge: collections like Vec are imported differently depending on the availability of the std library. Moreover, to use data structures such as HashSet or HashMap in a no_std context, it’s necessary to depend on third-party crates, as these are not provided by the alloc crate directly. This crate aims to simplify the process of designing Rust libraries or applications that require these collections in a no_std environment, offering a more streamlined approach to working with dynamic data structures without the standard library.

You can do

use collection_tools::Vec;

let mut map : Vec< i32 > = Vec::new();
map.push( 1 );
assert_eq!( map.first().unwrap().clone(), 1 );

Instead of

The code above will be expanded to this

#[ cfg( feature = "use_alloc" ) ]
extern crate alloc;
#[ cfg( feature = "use_alloc" ) ]
use alloc::vec::Vec;
#[ cfg( not( feature = "no_std" ) ) ]
use std::vec::Vec;

let mut collection : Vec< i32 > = Vec::new();
collection.push( 1 );
assert_eq!( collection.first().unwrap().clone(), 1 );

To add to your project

cargo add collection_tools

Try out from the repository

git clone https://github.com/Wandalen/wTools
cd wTools
cd examples/container_tools_trivial
cargo run

Modules

• binary_heap
  A priority queue implemented with a binary heap.
• btree_map
  An ordered map based on a B-Tree.
• btree_set
  An ordered set based on a B-Tree.
• dependency
  Namespace with dependencies.
• exposed
  Exposed namespace of the module.
• hash_map
  A hash map implemented with quadratic probing and SIMD lookup.
• hash_set
  A hash set implemented as a HashMap where the value is ().
• linked_list
  A doubly-linked list with owned nodes.
• orphan
  Parented namespace of the module.
• prelude
  Prelude to use essentials: use my_module::prelude::*.
• protected
  Protected namespace of the module.
• vec
  A contiguous growable array type with heap-allocated contents, written Vec<T>.
• vec_deque
  A double-ended queue (deque) implemented with a growable ring buffer.

Macros

• bmap
  Literally just a BTreeMap literal with keys and values into’d.
• bset
  Literally just a BTreeSet literal with values into’d.
• heap
  Literally just a BinaryHeap literal with values into’d.
• hmap
  Literally just a HashMap literal with keys and values into’d.
• hset
  Literally just a HashSet literal with values into’d.
• list
  Literally just a LinkedList literal with values into’d.
• vec
  Creates a Vec containing the arguments.
• vecd
  Literally just a VecDeque literal with values into’d.

Structs

• BTreeMap
  An ordered map based on a B-Tree.
• BTreeSet
  An ordered set based on a B-Tree.
• BinaryHeap
  A priority queue implemented with a binary heap.
• HashMap
  A hash map implemented with quadratic probing and SIMD lookup.
• HashSet
  A hash set implemented as a HashMap where the value is ().
• LinkedList
  A doubly-linked list with owned nodes.
• TryReserveError
  The error type for try_reserve methods.
• Vec
  A contiguous growable array type, written as Vec<T>, short for ‘vector’.
• VecDeque
  A double-ended queue implemented with a growable ring buffer.

Enums

• Bound
  An endpoint of a range of keys.
• TryReserveErrorKindExperimental
  Details of the allocation that caused a TryReserveError