std-macro-extensions

Official Documentation

A collection of macro extensions for Rust's standard library data structures, simplifying the creation and manipulation of common collections such as HashMap, Vec, and more.

Features

• Simplified Initialization: Use macros to easily create instances of common data structures.
• Supports Various Data Structures: Includes macros for Vec, HashMap, Arc, and more.
• Easy to Use: Intuitive syntax for quick data structure creation.

Installation

To install std-macro-extensions run cmd:

cargo add std-macro-extensions

Usage

Here are some examples of how to use the macros provided by this crate:

Example: Using arc!

use std_macro_extensions::*;

fn main() {
    let value = arc!(5);
}

Example: Using b_tree_map!

use std_macro_extensions::*;

fn main() {
    let empty_map: BTreeMap<i32, i32> = b_tree_map!();
    let b_tree_map_a: BTreeMap<&str, &str> = b_tree_map!(
        "a" => "a",
        "b" => "b"
    );
}

Example: Using b_tree_set!

use std_macro_extensions::*;

fn main() {
    let empty_set: BTreeSet<i32> = b_tree_set!();
    let number_set: BTreeSet<i32> = b_tree_set!(1, 2, 3);
}

Example: Using binary_heap!

use std_macro_extensions::*;

fn main() {
    let empty_set: BTreeSet<i32> = b_tree_set!();
    let number_set: BTreeSet<i32> = b_tree_set!(1, 2, 3);
}

Example: Using boxed!

use std_macro_extensions::*;

fn main() {
    let boxed_value = boxed!(10);
}

Example: Using cell!

use std_macro_extensions::*;

fn main() {
    let cell_value: Cell<i32> = cell!(5);
}

Example: Using hash_map!

use std_macro_extensions::*;

fn main() {
    let my_map: HashMap<&str, i32> = hash_map!();
    let my_map: HashMap<&str, i32> = hash_map!("a" => 1, "b" => 2);
}

Example: Using hash_set!

use std_macro_extensions::*;

fn main() {
    let my_set: HashSet<i32> = hash_set!();
    let my_set: HashSet<i32> = hash_set!(1, 2, 3);
}

Example: Using linked_list!

use std_macro_extensions::*;

fn main() {
    let my_list: LinkedList<i32> = linked_list!();
    let my_list: LinkedList<i32> = linked_list!(1, 2, 3);
}

Example: Using mutex!

use std_macro_extensions::*;

fn main() {
    let my_mutex: Mutex<i32> = mutex!(5);
    let lock: MutexGuard<'_, i32> = my_mutex.lock().unwrap();
}

Example: Using rc!

use std_macro_extensions::*;

fn main() {
    let my_rc = rc!(5);
}

Example: Using refcell!

use std_macro_extensions::*;

fn main() {
    use std_macro_extensions::*;
    let my_refcell = refcell!(5);
}

Example: Using rw_lock!

use std_macro_extensions::*;

fn main() {
    let my_rwlock = rw_lock!(5);
}

Example: Using string!

use std_macro_extensions::*;

fn main() {
    let empty_string = string!();
    let hello_string = string!("Hello");
}

Example: Using vector!

use std_macro_extensions::*;

fn main() {
    let empty_vector: Vec<i32> = vector!();
    let numbers = vector!(1, 2, 3);
}

Example: Using vector_deque!

use std_macro_extensions::*;

fn main() {
    let empty_deque: VecDeque<i32> = vector_deque!();
    let numbers = vector_deque!(1, 2, 3);
}

Example: Using join_paths!

let combined_path: String = join_paths!("/home/", "/user/", "/documents", "file.txt");
let another_path: String = join_paths!("C:/", "/Program Files", "App");

Example: Using cin!

let input: String = cin!();
println!("You typed: {}", input);

Example: Using cin_parse!

let input: &str = "1 2 3";
let numbers: Vec<i32> = cin_parse!(input, Vec<i32>);
assert_eq!(numbers, vec![1, 2, 3]);
let single_input: &str = "12";
let number: i32 = cin_parse!(single_input, i32);
assert_eq!(number, 12);

Example: Using cout!

let name: &str = "Alice";
let age: i32 = 30;
cout!("Name: {}, Age: {}\n", name, age);

Example: Using endl!

endl!();

Example: Using cout_endl!

let name: &str = "Alice";
let age: i32 = 30;
cout_endl!("Name: {}, Age: {}\n", name, age);

Example: Using execute!

fn sum(data: &[i32]) -> i32 {
    data.iter().sum()
}
fn add_offset(data: &[i32], offset: i32) -> i32 {
    data.iter().map(|x| x + offset).sum()
}
let nums: Vec<i32> = vec![1, 2, 3];
let total: i32 = execute!(sum, &nums);
assert_eq!(total, 6);
let total_with_offset: i32 = execute!(add_offset, &nums, 10);
assert_eq!(total_with_offset, 36);

Available Macros

• arc!: Creates an Arc<T>.
• vector!: Creates a Vec<T>.
• map!: Creates a HashMap<K, V>.
• set!: Creates a HashSet<T>.
• b_tree_map!: Creates a BTreeMap<K, V>.
• b_tree_set!: Creates a BTreeSet<T>.
• list!: Creates a LinkedList<T>.
• heap!: Creates a BinaryHeap<T>.
• string!: Creates a String.
• boxed!: Creates a Box<T>.
• rc!: Creates an Rc<T>.
• arc!: Creates an Arc<T>.
• mutex!: Creates a Mutex<T>.
• rw_lock!: Creates a RwLock<T>.
• cell!: Creates a Cell<T>.
• ref_cell!: Creates a RefCell<T>.
• vector_deque!: Creates a VecDeque<T>.
• join_paths!: Combines multiple paths into a single valid path, handling overlapping slashes.
• cin!: Reads a line of input from the standard input.
• cin_parse!: Parses input into a specified type.
• cout!: Prints formatted output to the standard output.
• endl!: Prints a newline character to the standard output.
• cout_endl!: Prints formatted output followed by a newline character to the standard output.
• execute!: Executes a function with the provided arguments.

License

This project is licensed under the MIT License. See the LICENSE file for details.

Contributing

Contributions are welcome! Please open an issue or submit a pull request.

Contact

For any inquiries, please reach out to the author at root@ltpp.vip.