API / Core / Dict

Dict

A mutable dictionary with string keys.

Compiles to a regular JavaScript object.

t

RESCRIPT
type t<'a> = Js.Dict.t<'a>

Type representing a dictionary of value 'a.

getUnsafe

RESCRIPT
let getUnsafe: (t<'a>, string) => '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.fromArray([("key1", "value1"), ("key2", "value2")]) let value = dict->Dict.getUnsafe("key1") Console.log(value) // value1

get

RESCRIPT
let get: (t<'a>, string) => option<'a>

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

Examples

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

set

RESCRIPT
let set: (t<'a>, string, 'a) => unit

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

RESCRIPT
let delete: (t<'a>, string) => unit

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

Examples

RESCRIPT
let dict = Dict.fromArray([("someKey", "someValue")]) dict->Dict.delete("someKey")

make

RESCRIPT
let make: unit => t<'a>

make() creates a new, empty dictionary.

Examples

RESCRIPT
let dict1: Dict.t<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

RESCRIPT
let fromArray: array<(string, 'a)> => t<'a>

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

RESCRIPT
let fromIterator: Core__Iterator.t<(string, 'a)> => t<'a>

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

Examples

RESCRIPT
// Pretend we have an iterator of the correct shape @val external someIterator: Iterator.t<(string, int)> = "someIterator" let dict = Dict.fromIterator(someIterator) // Dict.t<int>

toArray

RESCRIPT
let toArray: t<'a> => array<(string, 'a)>

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

RESCRIPT
let keysToArray: t<'a> => array<string>

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

valuesToArray

RESCRIPT
let valuesToArray: t<'a> => array<'a>

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

RESCRIPT
let assign: (t<'a>, t<'a>) => t<'a>

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

RESCRIPT
let copy: t<'a> => t<'a>

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

Examples

RESCRIPT
let dict = Dict.fromArray([("key1", "value1"), ("key2", "value2")]) let dict2 = dict->Dict.copy // Both log `["key1", "key2"]` here. Console.log2(dict->Dict.keysToArray, dict2->Dict.keysToArray)

forEach

RESCRIPT
let forEach: (t<'a>, 'a => unit) => unit

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.fromArray([("key1", "value1"), ("key2", "value2")]) dict->Dict.forEach(value => { Console.log(value) })

forEachWithKey

RESCRIPT
let forEachWithKey: (t<'a>, ('a, string) => unit) => unit

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

Examples

RESCRIPT
let dict = Dict.fromArray([("key1", "value1"), ("key2", "value2")]) dict->Dict.forEachWithKey((value, key) => { Console.log2(value, key) })

mapValues

RESCRIPT
let mapValues: (t<'a>, 'a => 'b) => t<'b>

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.fromArray([("key1", 1), ("key2", 2)]) dict->Dict.mapValues(v => v + 10)->Dict.toArray // [("key1", 11), ("key2", 12)] dict->Dict.mapValues(Int.toString)->Dict.toArray // [("key1", "1"), ("key2", "2")]