let map = std::collections::HashMap::from([
    ("a".to_string(), 1),
    ("b".to_string(), 2),
]);

Here is the super verbose Ada:

with Ada.Containers.Hashed_Maps;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Ada.Strings.Hash;

procedure Example is
    package String_Maps is new Ada.Containers.Hashed_Maps
        (Key_Type        => Unbounded_String,
        Element_Type    => Integer,
        Hash            => Hash,
        Equivalent_Keys => "=");

    use String_Maps;

    Map : Map_Type;
    X   : Integer := 0;
    Key : constant Unbounded_String := To_Unbounded_String("a");
begin
    Map.Insert(To_Unbounded_String("a"), 1);
    Map.Insert(To_Unbounded_String("b"), 2);

    if Map.Contains(Key) then
        X := Map.Element(Key);
    else
        X := 0;
    end if;
end Example;

Which I can mentally compile very easily; even though it is novella sized. And this Ada is more obtuse than usual.

let x = map.get("a").cloned().unwrap_or(0);

Python:

x = {"a": 1, "b": 2}.get("a", 0)

C++:

int x = map.contains("a") ? map["a"] : 0;

I'm not condemning rust, as it is my preferred language, but I find my mental compiler is working overtime to read others, or my own old code. There tend to be lots of clones, unwraps, and weird other bits which pile up. It isn't even the verbosity.