Rules. Kids know rules. Kids know that certain items belong in certain places. A HashMap is like a set of rules that say, given an item (your shoes, your favorite book, or your clothes) that there is a specific place that they should go (the shoe rack, the bookshelf, or the closet). So if you … Read more
You should use an enum type as value in your HashMap. That enum needs to have a variant for each possible type (boolean, number, string, list, map…) and an associated value of appropriate type for each variant: enum JsonValue<‘a> { String(&’a str), VecOfString(Vec<String>), AnotherHashMap(HashMap<&’a str, u32>), } Fortunately, there already is an implementation of a … Read more
Your usage of additionalProperties is correct and your model is correct. additionalProperties In Swagger/OpenAPI, hashmap keys are assumed to be strings, so the key type is not defined explicitly. additionalProperties define the type of hashmap values. So, this schema type: object additionalProperties: type: string defines a string-to-string map such as: { “en”: “English text”, “de”: … Read more
I don’t think one person’s opinion counts as idiomatic, but I’d probably use // transform keys only (use same values) hashMap.mapKeys { it.key.uppercase() } // transform values only (use same key) – what you’re after! hashMap.mapValues { it.value.uppercase() } // transform keys + values hashMap.entries.associate { it.key.uppercase() to it.value.uppercase() } Note: or toUpperCase() prior to … Read more
Eq is what we call a marker trait: it has no method on its own, it is just a way for the programmer to express that the struct verifies a certain property. You can implement it like this: impl Eq for Application {} Or alternatively, use #[derive(Eq)] on top of the Application declaration Eq is … Read more
This is certainly possible. The signature of get is fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V> where K: Borrow<Q>, Q: Hash + Eq, The problem here is to implement a &Q type such that (A, B): Borrow<Q> Q implements Hash + Eq To satisfy condition (1), we need to think of how to write fn … Read more
There are at least two reasons why this is disallowed: You would need to have two concurrent mutable references to map — one held by the iterator used in the for loop and one in the variable map to call map.remove. You have references to the key and the value within the map when trying … Read more
There isn’t a map literal syntax in Rust. I don’t know the exact reason, but I expect that the fact that there are multiple data structures that act maplike (such as both BTreeMap and HashMap) would make it hard to pick one. Rust 1.56 Many collections now offer conversions from an array argument using From … Read more
Indexing immutably and indexing mutably are provided by two different traits: Index and IndexMut, respectively. Currently, HashMap does not implement IndexMut, while Vec does. The commit that removed HashMap‘s IndexMut implementation states: This commit removes the IndexMut impls on HashMap and BTreeMap, in order to future-proof the API against the eventual inclusion of an IndexSet … Read more
The entry API is designed for this. In manual form, it might look like let values = match map.entry(key) { Entry::Occupied(o) => o.into_mut(), Entry::Vacant(v) => v.insert(default), }; One can use the briefer form via Entry::or_insert_with: let values = map.entry(key).or_insert_with(|| default); If default is already computed, or if it’s OK/cheap to compute even when it isn’t … Read more