Dict

A mutable dictionary with string keys.

Compiles to a regular JavaScript object.

Type representing a dictionary of value 'a.

getUnsafe(dict, key) Returns the value at the provided key.

This is unsafe, meaning it will return undefined value if key does not exist in dict.

Use Dict.getUnsafe only when you are sure the key exists (i.e. when iterating Dict.keys result).

Examples

RESCRIPT
let dict = dict{"key1": "value1", "key2": "value2"}
let value = dict->Dict.getUnsafe("key1")
Console.log(value) // value1

Returns the value at the provided key, if it exists. Returns an option.

Examples

RESCRIPT
let dict = dict{"someKey": "someValue"}

switch dict->Dict.get("someKey") {
| None => Console.log("Nope, didn't have the key.")
| Some(value) => Console.log(value)
}

Alternative: Pattern Matching with dict{}

For nested dictionary access, consider using the more concise dict{} pattern matching syntax:

RESCRIPT
// More concise approach using pattern matching
let decodeImageUrl = (json: JSON.t) => {
  switch json {
  | JSON.Object(dict{"data": JSON.Object(dict{"image_url": JSON.String(url)})}) => Some(url)
  | _ => None
  }
}

// Alternative using Dict.get
let decodeImageUrl = (json: JSON.t) => {
  switch json {
  | JSON.Object(obj) =>
    switch Dict.get(obj, "data") {
    | Some(JSON.Object(data)) =>
      switch Dict.get(data, "image_url") {
      | Some(JSON.String(url)) => Some(url)
      | _ => None
      }
    | _ => None
    }
  | _ => None
  }
}

set(dictionary, key, value) sets the value at the provided key to the provided value.

Examples

RESCRIPT
let dict = Dict.make()

dict->Dict.set("someKey", "someValue")

delete(dictionary, key) deletes the value at key, if it exists.

Examples

RESCRIPT
let dict = dict{"someKey": "someValue"}

dict->Dict.delete("someKey")

make() creates a new, empty dictionary.

Examples

RESCRIPT
let dict1: dict<int> = Dict.make() // You can annotate the type of the values of your dict yourself if you want

let dict2 = Dict.make() // Or you can let ReScript infer it via usage.
dict2->Dict.set("someKey", 12)

fromArray(entries) creates a new dictionary from the provided array of key/value pairs.

Examples

RESCRIPT
let dict = Dict.fromArray([("key1", "value1"), ("key2", "value2")])

fromIterator(entries) creates a new dictionary from the provided iterator of key/value pairs.

Examples

RESCRIPT
let iterator: Iterator.t<(string, int)> = %raw(`
  (() => {
    var map1 = new Map();
    map1.set('first', 1);
    map1.set('second', 2);
    var iterator1 = map1[Symbol.iterator]();
    return iterator1;
  })()
`)
iterator
->Dict.fromIterator
->Dict.valuesToArray == [1, 2]

toArray(dictionary) returns an array of all the key/value pairs of the dictionary.

Examples

RESCRIPT
let dict = Dict.make()
dict->Dict.set("someKey", 1)
dict->Dict.set("someKey2", 2)
let asArray = dict->Dict.toArray
Console.log(asArray) // Logs `[["someKey", 1], ["someKey2", 2]]` to the console

keysToArray(dictionary) returns an array of all the keys of the dictionary.

Examples

RESCRIPT
let dict = Dict.make()
dict->Dict.set("someKey", 1)
dict->Dict.set("someKey2", 2)
let keys = dict->Dict.keysToArray
Console.log(keys) // Logs `["someKey", "someKey2"]` to the console

size(dictionary) returns the number of key/value pairs in the dictionary.

Examples

RESCRIPT
let dict = Dict.make()
dict->Dict.size->assertEqual(0)

dict->Dict.set("someKey", 1)
dict->Dict.set("someKey2", 2)
dict->Dict.size->assertEqual(2)

// After deleting a key
dict->Dict.delete("someKey")
dict->Dict.size->assertEqual(1)

isEmpty(dictionary) returns true if the dictionary is empty (has no key/value pairs), false otherwise.

Examples

RESCRIPT
let emptyDict = Dict.make()
emptyDict->Dict.isEmpty->assertEqual(true)

let dict = Dict.make()
dict->Dict.set("someKey", 1)
dict->Dict.isEmpty->assertEqual(false)

// After clearing all keys
dict->Dict.delete("someKey")
dict->Dict.isEmpty->assertEqual(true)

valuesToArray(dictionary) returns an array of all the values of the dictionary.

Examples

RESCRIPT
let dict = Dict.make()
dict->Dict.set("someKey", 1)
dict->Dict.set("someKey2", 2)
let values = dict->Dict.valuesToArray
Console.log(values) // Logs `[1, 2]` to the console

assign(dictionary1, dictionary2) shallowly merges dictionary2 into dictionary1, and returns dictionary1.

Beware this will mutate dictionary1. If you're looking for a way to copy a dictionary, check out Dict.copy.

Examples

RESCRIPT
let dict1 = Dict.make()
dict1->Dict.set("firstKey", 1)
Console.log(dict1->Dict.keysToArray) // Logs `["firstKey"]`

let dict2 = Dict.make()
dict2->Dict.set("someKey", 2)
dict2->Dict.set("someKey2", 3)

let dict1 = dict1->Dict.assign(dict2)

Console.log(dict1->Dict.keysToArray) // Logs `["firstKey", "someKey", "someKey2"]`

copy(dictionary) shallowly copies the provided dictionary to a new dictionary.

Examples

RESCRIPT
let dict = dict{"key1": "value1", "key2": "value2"}
let dict2 = dict->Dict.copy

// Both log `["key1", "key2"]` here.
Console.log2(dict->Dict.keysToArray, dict2->Dict.keysToArray)

forEach(dictionary, f) iterates through all values of the dict.

Please note that this is without the keys, just the values. If you need the key as well, use Dict.forEachWithKey.

Examples

RESCRIPT
let dict = dict{"key1": "value1", "key2": "value2"}

dict->Dict.forEach(value => {
  Console.log(value)
})

forEachWithKey(dictionary, f) iterates through all values of the dict, including the key for each value.

Examples

RESCRIPT
let dict = dict{"key1": "value1", "key2": "value2"}

dict->Dict.forEachWithKey((value, key) => {
  Console.log2(value, key)
})

mapValues(dictionary, f) returns a new dictionary with the same keys, and f applied to each value in the original dictionary.

Examples

RESCRIPT
let dict = dict{"key1": 1, "key2": 2}

dict->Dict.mapValues(v => v + 10)->Dict.toArray // [("key1", 11), ("key2", 12)]
dict->Dict.mapValues(v => Int.toString(v))->Dict.toArray // [("key1", "1"), ("key2", "2")]

has(dictionary, "key") returns true if the "key" is present in the dictionary.

Be aware that it uses the JavaScript in operator under the hood.

Examples

RESCRIPT
let dict = dict{"key1": Some(1), "key2": None}

dict->Dict.has("key1") == true
dict->Dict.has("key2") == true
dict->Dict.has("key3") == false
dict->Dict.has("toString") == true

ignore(dict) ignores the provided dict and returns unit.

This helper is useful when you want to discard a value (for example, the result of an operation with side effects) without having to store or process it further.