• Java

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

• Java

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

• Java

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

• Java

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

• Java

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

• Ada

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;

• C

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

• Caml

module StringMap = Map.Make(String)

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

• Clojure

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

• C++

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

• C++

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

• C#

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

• C#

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

• D

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

• Dart

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

• Elixir

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

• Elixir

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

• Erlang

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

• Go

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

• Groovy

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

• Groovy

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

• Haskell

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

• JS

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

• JS

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

• JS

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

• Kotlin

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

• Kotlin

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

• Kotlin

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

• Lisp

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

• Lua

x = {one = 1, two = 2}

• Obj-C

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

• PHP

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

• Pascal

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

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

• Perl

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

• Python

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

• Python

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

• Ruby

x = {one: 1, two: 2}

• Rust

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

• Rust

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

• Scala

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

• Scheme

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

• Smalltalk

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

• VB

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