# Maps
{% hint style="info" %}
You can easily import all the functions from the `maps` registry by including the following import statement in your code
```go
import "github.com/go-sprout/sprout/registry/maps"
```
{% endhint %}
### dict
The function creates a dictionary (map) from a list of alternating keys and values, pairing each key with its corresponding value.
| Name | Value |
|---|
| Signature | Dict(values ...any) map[string]any
|
| Must version | ❌ |
{% tabs %}
{% tab title="Template Example" %}
```go
{{ dict "key1", "value1", "key2", "value2" }}
// Output: {"key1": "value1", "key2": "value2"}
```
{% endtab %}
{% endtabs %}
### get
The function retrieves the value associated with a specified key from a dictionary (map). If the key is found, the corresponding value is returned.
| Name | Value |
|---|
| Signature | Get(dict map[string]any, key string) any
|
| Must version | ❌ |
{% tabs %}
{% tab title="Template Example" %}
```go
{{ get {"key": "value"}, "key" }} // Output: "value"
{{ get {"key": "value"}, "invalid" }} // Output: ""
```
{% endtab %}
{% endtabs %}
### set
The function adds a new key-value pair to a dictionary or updates the value associated with an existing key.
| Name | Value |
|---|
| Signature | Set(dict map[string]any, key string, value any) map[string]any
|
| Must version | ❌ |
{% tabs %}
{% tab title="Template Example" %}
```go
{{ set {"key": "oldValue"}, "key", "newValue" }} // Output: {"key": "newValue"}
{{ set {"foo": "bar"}, "far", "boo" }} // Output: {"foo": "bar", "far": "boo"}
```
{% endtab %}
{% endtabs %}
### unset
```go
{{ {"key": "value"}, "key" | unset }} // Output: {}
```
| Name | Value |
|---|
| Signature | Unset(dict map[string]any, key string) map[string]any
|
| Must version | ❌ |
{% tabs %}
{% tab title="Template Example" %}
```go
{{ {"key": "value"}, "key" | unset }} // Output: {}
{{ {"key": "value"}, "invalid" | unset }} // Output: {"key": "value"}
```
{% endtab %}
{% endtabs %}
### keys
The function retrieves all keys from one or more dictionaries, returning them as a list.
| Name | Value |
|---|
| Signature | Keys(dicts ...map[string]any) []string
|
| Must version | ❌ |
{% tabs %}
{% tab title="Template Example" %}
```go
{{ keys {"key1": "value1", "key2": "value2"} }} // Output: ["key1", "key2"]
{{ keys {"key1": "value1"} {"key2": "value2"} }} // Output: ["key1", "key2"]
```
{% endtab %}
{% endtabs %}
### values
The function retrieves all values from a dictionary, returning them as a list.
| Name | Value |
|---|
| Signature | Values(dict map[string]any) []any
|
| Must version | ❌ |
{% tabs %}
{% tab title="Template Example" %}
```go
{{ values {"key1": "value1", "key2": "value2"} }} // Output: ["value1", "value2"]
```
{% endtab %}
{% endtabs %}
### pluck
The function extracts values associated with a specified key from a list of dictionaries, returning a list of those values.
| Name | Value |
|---|
| Signature | Pluck(key string, dicts ...map[string]any) []any
|
| Must version | ❌ |
{% tabs %}
{% tab title="Template Example" %}
{{ $d1 := dict "key" "value1"}}
{{ $d2 := dict "key" "value2" }}
{{ pluck "key" $d1 $d2 }} // Output: ["value1", "value2"]
{% endtab %}
{% endtabs %}
### pick
The function creates a new dictionary that includes only the specified keys from the original dictionary, effectively filtering out all other keys and their associated values.
| Name | Value |
|---|
| Signature | Pick(dict map[string]any, keys ...string) map[string]any
|
| Must version | ❌ |
{% tabs %}
{% tab title="Template Example" %}
```go
{{ $d := dict "key1" "value1" "key2" "value2" "key3" "value3" }}
{{ pick $d "key1" "key3" }} // Output: {"key1": "value1", "key3": "value3"}
```
{% endtab %}
{% endtabs %}
### omit
The function creates a new dictionary by excluding the specified keys from the original dictionary, effectively removing those key-value pairs from the resulting dictionary.
| Name | Value |
|---|
| Signature | Omit(dict map[string]any, keys ...string) map[string]any
|
| Must version | ❌ |
{% tabs %}
{% tab title="Template Example" %}
```go
{{ $d := dict "key1" "value1" "key2" "value2" "key3" "value3" }}
{{ omit $d "key1" "key3" }} // Output: {"key2": "value2"}
```
{% endtab %}
{% endtabs %}
### dig
The function navigates through a nested dictionary structure using a sequence of keys and returns the value found at the specified path, allowing access to deeply nested data. The last argument must be the map.
| Name | Value |
|---|
| Signature | Dig(args ...any) (any, error)
|
| Must version | ❌ |
{% tabs %}
{% tab title="Template Example" %}
```go
{{ $nest := dict "foo" "bar" }}
{{ $d := dict "key1" "value1" "nested" $nest }}
{{ $d | dig "nested" "foo" }} // Output: "bar"
```
{% endtab %}
{% endtabs %}
### hasKey
The function checks whether a specified key exists in the dictionary, returning `true` if the key is found and `false` otherwise.
| Name | Value |
|---|
| Signature | HasKey(dict map[string]any, key string) bool
|
| Must version | ❌ |
{% tabs %}
{% tab title="Template Example" %}
```go
{{ $d := dict "key1" "value1" }}
{{ hasKey $d "key1" }} // Output: true
{{ hasKey $d "key2" }} // Output: false
```
{% endtab %}
{% endtabs %}
### merge / mustMerge
The function combines multiple source maps into a single destination map, adding new key-value pairs without overwriting any existing keys in the destination map.
| Name | Value |
|---|
| Signature | Merge(dest map[string]any, srcs ...map[string]any) any
MustMerge(dest map[string]any, srcs ...map[string]any) (any, error)
|
| Must version | ✅ |
{% tabs %}
{% tab title="Template Example" %}
{{ $d1 := dict "a" 1 "b" 2 }}
{{ $d2 := dict "b" 3 "c" 4 }}
{{ merge $d1, $d2 }} // Output: {"a": 1, "b": 2, "c": 4}, nil
{% endtab %}
{% tab title="Must version" %}
{{ $d1 := dict "a" 1 "b" 2 }}
{{ $d2 := dict "b" 3 "c" 4 }}
{{ mustMerge $d1, $d2 }} // Output: {"a": 1, "b": 2, "c": 4}, nil
{% endtab %}
{% endtabs %}
### mergeOverwrite / mustMergeOverwrite
The function combines multiple source maps into a destination map, overwriting existing keys with values from the source maps.
| Name | Value |
|---|
| Signature | MergeOverwrite(dest map[string]any, srcs ...map[string]any) any
MustMergeOverwrite(dest map[string]any, srcs ...map[string]any) (any, error)
|
| Must version | ✅ |
{% tabs %}
{% tab title="Template Example" %}
```go
{{ $d1 := dict "a" 1 "b" 2 }}
{{ $d2 := dict "b" 3 "c" 4 }}
{{ mergeOverwrite $d1, $d2 }} // Output: {"a": 1, "b": 3, "c": 4}, nil
```
{% endtab %}
{% tab title="Must version" %}
{{ $d1 := dict "a" 1 "b" 2 }}
{{ $d2 := dict "b" 3 "c" 4 }}
{{ mustMergeOverwrite $d1, $d2 }} // Output: {"a": 1, "b": 3, "c": 4}, nil
{% endtab %}
{% endtabs %}
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.atom.codes/sprout/~/changes/gP9HOVz2PoFWbplTHwVo/registries/maps.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.