Programming-Idioms

declare
   package Maps is new Indefinite_Hashed_Maps (Key_Type => String,
                                               Element_Type => Integer,
                                               Hash => Ada.Strings.Hash,
                                               Equivalent_Keys => "=");
      
   use Maps;
      
   X : Map := Empty_Map;
begin
   X.Insert ("One", 1);
   X.Insert ("Two", 2);
   X.Insert ("Three", 3);
end;

ENTRY a = {"foo", "twenty"};
ENTRY b = {"bar", "three"};
if (hcreate (23)) {
    hsearch(a, ENTER);
    hsearch(b, ENTER);
}

module StringMap = Map.Make(String)

let x =
    StringMap.empty
    |> StringMap.add "one" 1
    |> StringMap.add "two" 2
    |> StringMap.add "three" 3

(def x {"One" 1
	"Two" 2
	"Three" 3})

std::unordered_map<std::string, double> mymap = {
    {"mom", 5.4},
    {"dad", 6.1},
    {"bro", 5.9}
};

std::map<const char*, int> x;
x["one"] = 1;
x["two"] = 2;

var x = new Dictionary<string, int> {
   {"year", 2019}, {"month", 12}
};

var x = new Dictionary<string, int> {
   ["year"] = 2019,
   ["month"] = 12
};

int[string] x = ["one": 1, "two": 2];

var x = {
	"one": 1,
	"two": 2
};

x = %{one: 1, two: 2}

x = %{"one" => 1, "two" => 2}

X = #{one => 1, "two" => 2.0, <<"three">> => [i, i, i]}.

x := map[string]int {"one": 1, "two": 2}

def x = ['un':1, 'dos':2, 'tres':3]

def x = [un:1, dos:2, tres:3]

x = Data.Map.Strict.fromList [ ("red", "FF0000"), ("blue", "0000FF") ]

const x = new Map([["one",1],["two",2]]);

const x = {one: 1, two:2}

const x = new Map();
x.set("one", 1);
x.set("two", 2);

Map<String, Integer> x = of("x", 1, "y", 2);

Entry<String, Integer> a = entry("x", 1),
                       b = entry("y", 2);
Map<String, Integer> x = ofEntries(a, b);

Map<String,Integer> x = new HashMap<>();
x.put("one", 1);
x.put("two", 2);

Map<String, Integer> x = new HashMap<>(of("x", 1, "y", 2));

final Map<String, Integer> x = new HashMap<String, Integer>() {{
    put("one", 1);
    put("two", 2);
    put("three", 3);
}};

val x = mutableMapOf<String, Int>().apply { 
    this["one"] = 1
    this["two"] = 2
}

val x = mapOf("one" to 1, "two" to 2)

val x = mutableMapOf<String, Int>()
x["one"] = 1
x["two"] = 2

(let ((table (make-hash-table)))
  (setf (gethash 'one table) 1)
  (setf	(gethash 'two table) 2))

x = {one = 1, two = 2}

NSDictionary *x=@{@"one":@1, @"two":@2};

$x = ['one' => 1, 'two' => 2];

type TMap = specialize TFPGMap<String, Integer>;
var x: TMap;

begin
  x := TMap.Create;
  x['one'] := 1;
  x['two'] := 2;  
end.

my %x = ( 
    name => 'Roboticus',
    'foo bar' => 'joe'
);

x = {"one" : 1, "two" : 2}

x = dict(a=1, b=2, c=3)

x = {one: 1, two: 2}

let mut x = BTreeMap::new();
x.insert("one", 1);
x.insert("two", 2);

let x: HashMap<&str, i32> = [
    ("one", 1),
    ("two", 2),
].into_iter().collect();

val x = Map("a" -> 1, "b" -> 2, "c" -> 3)

(define x '(
    ("one" 1) 
    ("two" 2) 
    ("three" 3)))

x := Dictionary newFrom: {
	#a -> 1.
	#b -> Object new}.

Dim x As New Dictionary(Of String, Integer)() From {
    {"one", 1},
    {"two", 2}
}