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
//! These are wrappers around `HashSet` and `HashMap` which make them a little more convenient to use. //! They aren't intended for use in main applications, but were created to make prototyping and writing short programs easier. //! //! # Usage //! //! The struct `EasySet` wraps `HashSet` with some useful trait implementations. //! //! ```rust //! use easy_collections::set; //! //! let a = &set!{1, 2, 3}; //! let b = &set!{2, 3, 4}; //! assert_eq!(a & b, set!{2, 3}); // intersection //! assert_eq!(a | b, set!{1, 2, 3, 4}); // union //! assert_eq!(a ^ b, set!{1, 4}); // symmetric difference //! assert_eq!(a - b, set!{1}); // difference //! //! let c = &set!{1, 2, 3, 4}; //! assert!(a < c && b < c); // subset //! assert!(c > a && c > b); // superset //! assert!(*a == set!{1, 2, 3}); // equality //! ``` //! //! The struct `EasyMap` wraps `HashMap` with some useful trait implementations. //! //! ```rust //! use easy_collections::{EasyMap, map}; //! //! // `42` here is the default value which is returned when no item exists in the map //! // The default value is optional. //! let map = map!{42; ("foo", 1), ("bar", 10), ("baz", 100)}; //! assert_eq!(map["foo"], 1); //! assert_eq!(map["bar"], 10); //! assert_eq!(map["baz"], 100); //! assert_eq!(map["nope"], 42); //! assert_eq!(map["nada"], 42); //! assert_eq!(map["nuttin'"], 42); //! //! // If you want to create a map with just a single value, and no default, use a trailing comma: //! let map: EasyMap<&str, (&str, &str)> = map!{("foo", "bar")}; //! let map: EasyMap<&str, &str> = map!{("foo", "bar"),}; //! ``` //! //! Also, both `EasyMap` and `EasySet` deref to their underlying collections, for example: //! //! ```rust //! use std::collections::{HashMap, HashSet}; //! use easy_collections::{EasyMap, EasySet, map, set}; //! //! let easy: EasySet<_> = set!{"foo", "bar"}; //! let hash: &HashSet<_> = &*easy; //! assert_eq!(&*easy, hash); //! //! let easy: EasyMap<_, _> = map!{("foo", "bar"),}; //! let hash: &HashMap<_, _> = &*easy; //! assert_eq!(&*easy, hash); //! ``` mod map; mod set; pub use map as easy_collections; pub use set as easy_set; pub use map::EasyMap; pub use set::EasySet;