Logo

Programming-Idioms

  • Lua
  • Pascal
  • Rust
  • C
  • C++

Idiom #8 Create a map (associative array)

Create a new map object x, and provide some (key, value) pairs as initial content.

#include <unordered_map>
std::unordered_map<std::string, double> mymap = {
    {"mom", 5.4},
    {"dad", 6.1},
    {"bro", 5.9}
};
#include <map>
std::map<const char*, int> x;
x["one"] = 1;
x["two"] = 2;
x = {one = 1, two = 2}
uses fgl;
type TMap = specialize TFPGMap<String, Integer>;
var x: TMap;

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

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

Something different than a BTreeMap might be used, depending on the usage.

The function new of the type BTreeMap returns a usable map.
The map is stored mutable in the variable x.

Maps in Rust are generic and type safe at compile time.
use std::collections::HashMap;
let x: HashMap<&str, i32> = [
    ("one", 1),
    ("two", 2),
].into_iter().collect();
#include <search.h>
ENTRY a = {"foo", "twenty"};
ENTRY b = {"bar", "three"};
if (hcreate (23)) {
    hsearch(a, ENTER);
    hsearch(b, ENTER);
}

This POSIX functions maintain a single global hashmap. The GNU C library provides hcreate_r
with Ada.Containers.Indefinite_Hashed_Maps;
with Ada.Strings.Hash;

use Ada.Containers;
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;
New implementation...
< > ⌨
programming-idioms.org 
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;
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.

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();
ENTRY a = {"foo", "twenty"};
ENTRY b = {"bar", "three"};
if (hcreate (23)) {
    hsearch(a, ENTER);
    hsearch(b, ENTER);
}
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;
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})
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 = new HashMap<>();
x.put("one", 1);
x.put("two", 2);
Entry<String, Integer> a = entry("x", 1),
                       b = entry("y", 2);
Map<String, Integer> x = ofEntries(a, b);
Map<String, Integer> x = of("x", 1, "y", 2);
final Map<String, Integer> x = new HashMap<String, Integer>() {{
    put("one", 1);
    put("two", 2);
    put("three", 3);
}};
Map<String, Integer> x = new HashMap<>(of("x", 1, "y", 2));
val x = mapOf("one" to 1, "two" to 2)

val x = mutableMapOf<String, Int>().apply { 
    this["one"] = 1
    this["two"] = 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))
NSDictionary *x=@{@"one":@1, @"two":@2};
$x = ['one' => 1, 'two' => 2];
my %x = ( 
    name => 'Roboticus',
    'foo bar' => 'joe'
);
x = dict(a=1, b=2, c=3)
x = {"one" : 1, "two" : 2}
x = {one: 1, two: 2}
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}
}