Gleam Standard Library

https://hexdocs.pm/gleam_stdlib
Admin
Gleam's standard library provides essential modules for common programming tasks, supporting both...
Tokens:65,460
Snippets:364
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Gleam Dict get Example (key found)

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Illustrates using the `get` function to retrieve a value from a Gleam dictionary when the key exists. The result is `Ok` containing the associated value.

```gleam
new() |> insert("a", 0) |> get("a")
// -> Ok(0)
```

--------------------------------

### Gleam Dict get Example (key not found)

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Illustrates using the `get` function to retrieve a value from a Gleam dictionary when the key does not exist. The result is `Error(Nil)`.

```gleam
new() |> insert("a", 0) |> get("b")
// -> Error(Nil)
```

--------------------------------

### Gleam List Syntax Examples

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Demonstrates the dedicated syntax for prefixing elements to a Gleam list and pattern matching to extract elements from a list.

```gleam
let new_list = [1, 2, ..existing_list]

case list {
  [first_element, ..rest] -> first_element
  _ -> "this pattern matches when the list is empty"
}
```

--------------------------------

### Gleam Dict map_values Example

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Illustrates using `map_values` to transform the values in a Gleam dictionary. The example multiplies each value by its corresponding key.

```gleam
from_list([#(3, 3), #(2, 4)])
|> map_values(fn(key, value) { key * value })
// -> from_list([#(3, 9), #(2, 8)])
```

--------------------------------

### Install gleam_stdlib

Source: https://hexdocs.pm/gleam_stdlib/index

Command to add the gleam_stdlib package to your Gleam project dependencies.

```bash
gleam add gleam_stdlib
```

--------------------------------

### Gleam Dict keys Example

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Shows how to use the `keys` function to retrieve a list of all keys from a Gleam dictionary created from a list.

```gleam
from_list([#("a", 0), #("b", 1)]) |> keys
// -> ["a", "b"]
```

--------------------------------

### Gleam `int.to_string` Example

Source: https://hexdocs.pm/gleam_stdlib/gleam/bool

Shows how to use `gleam/int.to_string` to convert a random number to a string and concatenate it for a greeting. This example illustrates dynamic string generation.

```gleam
import gleam/int

let name = ""
let greeting = fn() { "Hello, " <> name }
use <- lazy_guard(when: name == "", otherwise: greeting)
let number = int.random(99)
let name = "User " <> int.to_string(number)
"Welcome, " <> name
// -> "Welcome, User 54"
```

--------------------------------

### Gleam Dict fold Example (sum values)

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Shows how to use the `fold` function to sum all values in a Gleam dictionary. It starts with an initial accumulator (0) and applies a function to each key-value pair.

```gleam
let dict = from_list([#("a", 1), #("b", 3), #("c", 9)])
fold(dict, 0, fn(accumulator, key, value) { accumulator + value })
// -> 13
```

--------------------------------

### Gleam Dict merge Example

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Shows how to merge two Gleam dictionaries. The example demonstrates how entries from the second dictionary overwrite entries with the same keys from the first.

```gleam
let a = from_list([#("a", 0), #("b", 1)])
let b = from_list([#("b", 2), #("c", 3)])
merge(a, b)
// -> from_list([#("a", 0), #("b", 2), #("c", 3)])
```

--------------------------------

### Basic Gleam Function Example

Source: https://hexdocs.pm/gleam_stdlib/index

A simple Gleam function that prints a greeting to the console. It imports the 'io' module for printing and takes a String argument, returning Nil.

```gleam
import gleam/io

pub fn greet(name: String) -> Nil {
  io.println("Hello " <> name <> "!")
}
```

--------------------------------

### Gleam: Create Empty BytesTree

Source: https://hexdocs.pm/gleam_stdlib/gleam/bytes_tree

Creates an empty `BytesTree`. This is useful for starting pipe chains to build up a tree incrementally.

```gleam
pub fn new() -> BytesTree
```

--------------------------------

### Gleam StringTree API Documentation

Source: https://hexdocs.pm/gleam_stdlib/gleam/string_tree

Comprehensive API documentation for the Gleam string_tree module. This includes function signatures, descriptions, and usage examples for various string tree operations.

```APIDOC
Module: gleam/string_tree

Description: Provides functions for working with string trees, an efficient way to represent and manipulate strings.

Functions:

new() -> StringTree
  Description: Creates an empty StringTree. Useful as the start of a pipe chaining many trees together.
  Returns: An empty StringTree.

prepend(to: StringTree, prefix: String) -> StringTree
  Description: Prepends a String onto the start of some StringTree.
  Parameters:
    to: The StringTree to prepend to.
    prefix: The String to prepend.
  Returns: A new StringTree with the prefix added.
  Notes: Runs in constant time.

prepend_tree(to: StringTree, prefix: StringTree) -> StringTree
  Description: Prepends some StringTree onto the start of another.
  Parameters:
    to: The StringTree to prepend to.
    prefix: The StringTree to prepend.
  Returns: A new StringTree with the prefix tree added.
  Notes: Runs in constant time.

join(trees: List(StringTree), with: String) -> StringTree
  Description: Joins the given trees into a new tree separated with the given string.
  Parameters:
    trees: A list of StringTrees to join.
    with: The separator string.
  Returns: A new StringTree representing the joined content.

to_string(tree: StringTree) -> String
  Description: Turns a StringTree into a String. This function is implemented natively by the virtual machine and is highly optimised.
  Parameters:
    tree: The StringTree to convert.
  Returns: The String representation of the tree.

lowercase(tree: StringTree) -> StringTree
  Description: Converts a StringTree to a new one where the contents have been lowercased.
  Parameters:
    tree: The StringTree to convert.
  Returns: A new StringTree with lowercased content.

uppercase(tree: StringTree) -> StringTree
  Description: Converts a StringTree to a new one where the contents have been uppercased.
  Parameters:
    tree: The StringTree to convert.
  Returns: A new StringTree with uppercased content.

reverse(tree: StringTree) -> StringTree
  Description: Converts a StringTree to a new one with the contents reversed.
  Parameters:
    tree: The StringTree to reverse.
  Returns: A new StringTree with reversed content.

split(tree: StringTree, on: String) -> List(StringTree)
  Description: Splits a StringTree on a given pattern into a list of trees.
  Parameters:
    tree: The StringTree to split.
    on: The pattern string to split on.
  Returns: A list of StringTrees resulting from the split.

replace(in: StringTree, each: String, with: String) -> StringTree
  Description: Replaces all instances of a pattern with a given string substitute.
  Parameters:
    in: The StringTree to perform replacements on.
    each: The pattern string to find.
    with: The substitute string.
  Returns: A new StringTree with replacements made.

is_equal(a: StringTree, b: StringTree) -> Bool
  Description: Compares two string trees to determine if they have the same textual content. Comparing two string trees using the `==` operator may return `False` even if they have the same content as they may have been build in different ways, so using this function is often preferred.
  Parameters:
    a: The first StringTree.
    b: The second StringTree.
  Returns: `True` if the trees have the same content, `False` otherwise.

Examples:

// Example for is_equal
// from_strings(["a", "b"]) == from_string("ab")
// -> False
// is_equal(from_strings(["a", "b"]), from_string("ab"))
// -> True

```

--------------------------------

### Gleam Dict insert Example (new entry)

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Shows how to insert a new key-value pair into an empty Gleam dictionary using the `insert` function.

```gleam
new() |> insert("a", 0)
// -> from_list([#("a", 0)])
```

--------------------------------

### Gleam: Prepend BytesTree to BytesTree

Source: https://hexdocs.pm/gleam_stdlib/gleam/bytes_tree

Prepends one bytes tree onto the start of another. This operation runs in constant time.

```gleam
pub fn prepend_tree(
  to second: BytesTree,
  prefix first: BytesTree,
) -> BytesTree
```

--------------------------------

### Gleam BitArray: starts_with

Source: https://hexdocs.pm/gleam_stdlib/gleam/bit_array

Checks whether the first BitArray starts with the second one. This function compares the beginning of a bit array against a given prefix.

```gleam
pub fn starts_with(bits: BitArray, prefix: BitArray) -> Bool

Checks whether the first `BitArray` starts with the second one.

## Examples

```
starts_with(<<1, 2, 3, 4>>, <<1, 2>>)
// -> True

```
```

--------------------------------

### Gleam Dict new API

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Documents the `new` function, which creates an empty Gleam dictionary. This is the starting point for building dictionaries.

```APIDOC
pub fn new() -> Dict(k, v)

Creates a fresh dict that contains no values.
```

--------------------------------

### Gleam Dict fold Example (concatenate keys)

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Demonstrates using `fold` to concatenate all keys from a Gleam dictionary into a single string. It starts with an empty string accumulator and appends each key.

```gleam
import gleam/string

let dict = from_list([#("a", 1), #("b", 3), #("c", 9)])
fold(dict, "", fn(accumulator, key, value) {
  string.append(accumulator, key)
})
// -> "abc"
```

--------------------------------

### Gleam List split() Examples

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Demonstrates how to split a list into two parts at a specified index. The first part contains elements up to (but not including) the index, and the second part contains elements from the index onwards.

```APIDOC
pub fn split(list: List(a), index: Int) -> #(List(a), List(a))
```

```gleam
split([6, 7, 8, 9], 0)
// -> #([], [6, 7, 8, 9])

split([6, 7, 8, 9], 2)
// -> #([6, 7], [8, 9])

split([6, 7, 8, 9], 4)
// -> #([6, 7, 8, 9], [])
```

--------------------------------

### Gleam: Prepend BitArray to BytesTree

Source: https://hexdocs.pm/gleam_stdlib/gleam/bytes_tree

Prepends a bit array to the start of a bytes tree. This operation runs in constant time.

```gleam
pub fn prepend(
  to second: BytesTree,
  prefix first: BitArray,
) -> BytesTree
```

--------------------------------

### Gleam `lazy_guard` Example

Source: https://hexdocs.pm/gleam_stdlib/gleam/bool

Demonstrates the usage of `lazy_guard` with a string comparison and a function call in Gleam. It conditionally executes a function based on a guard condition.

```gleam
let name = "Kamaka"
let inquiry = fn() { "How may we address you?" }
use <- lazy_guard(when: name == "", return: inquiry)
"Hello, " <> name
// -> "Hello, Kamaka"
```

--------------------------------

### Gleam Dict insert Example (update entry)

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Demonstrates updating the value for an existing key in a Gleam dictionary using the `insert` function. The new value replaces the old one.

```gleam
new() |> insert("a", 0) |> insert("a", 5)
// -> from_list([#("a", 5)])
```

--------------------------------

### Gleam Dict is_empty Example (empty)

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Illustrates using `is_empty` on a newly created, empty Gleam dictionary. It correctly returns `True`.

```gleam
new() |> is_empty
// -> True
```

--------------------------------

### Gleam List Range

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Creates a list of integers ranging from a given start value to a given stop value, inclusive. Supports both increasing and decreasing ranges.

```gleam
pub fn range(from start: Int, to stop: Int) -> List(Int)
```

```gleam
range(0, 0)
// -> [0]
```

```gleam
range(0, 5)
// -> [0, 1, 2, 3, 4, 5]
```

```gleam
range(1, -5)
// -> [1, 0, -1, -2, -3, -4, -5]
```

--------------------------------

### Gleam: Prepend String to BytesTree

Source: https://hexdocs.pm/gleam_stdlib/gleam/bytes_tree

Prepends a string onto the start of a bytes tree. Performance is constant time on Erlang, and linear time with the string length otherwise.

```gleam
pub fn prepend_string(
  to second: BytesTree,
  prefix first: String,
) -> BytesTree
```

--------------------------------

### gleam/result Module API Documentation

Source: https://hexdocs.pm/gleam_stdlib/gleam/result

Comprehensive API documentation for the gleam/result module, covering functions for handling Result types. Includes signatures, parameter descriptions, return values, and usage examples for operations like combining results, checking status, mapping values, and unwrapping safely.

```APIDOC
gleam/result Module API Documentation:

all(results: List(Result(a, e))) -> Result(List(a), e)
  Combines a list of results into a single result. If all elements in the list are `Ok` then returns an `Ok` holding the list of values. If any element is `Error` then returns the first error.
  Examples:
    all([Ok(1), Ok(2)])
    // -> Ok([1, 2])

    all([Ok(1), Error("e")])
    // -> Error("e")

flatten(result: Result(Result(a, e), e)) -> Result(a, e)
  Merges a nested `Result` into a single layer.
  Examples:
    flatten(Ok(Ok(1)))
    // -> Ok(1)

    flatten(Ok(Error("")))
    // -> Error("")

    flatten(Error(Nil))
    // -> Error(Nil)

is_error(result: Result(a, e)) -> Bool
  Checks whether the result is an `Error` value.
  Examples:
    is_error(Ok(1))
    // -> False

    is_error(Error(Nil))
    // -> True

is_ok(result: Result(a, e)) -> Bool
  Checks whether the result is an `Ok` value.
  Examples:
    is_ok(Ok(1))
    // -> True

    is_ok(Error(Nil))
    // -> False

lazy_or(first: Result(a, e), second: fn() -> Result(a, e)) -> Result(a, e)
  Returns the first value if it is `Ok`, otherwise evaluates the given function for a fallback value. If you need access to the initial error value, use `result.try_recover`.
  Examples:
    lazy_or(Ok(1), fn() { Ok(2) })
    // -> Ok(1)

    lazy_or(Ok(1), fn() { Error("Error 2") })
    // -> Ok(1)

    lazy_or(Error("Error 1"), fn() { Ok(2) })
    // -> Ok(2)

    lazy_or(Error("Error 1"), fn() { Error("Error 2") })
    // -> Error("Error 2")

lazy_unwrap(result: Result(a, e), or default: fn() -> a) -> a
  Extracts the `Ok` value from a result, evaluating the default function if the result is an `Error`.
  Examples:
    lazy_unwrap(Ok(1), fn() { 0 })
    // -> 1

    lazy_unwrap(Error(""), fn() { 0 })
    // -> 0

map(over result: Result(a, e), with fun: fn(a) -> b) -> Result(b, e)
  Updates a value held within the `Ok` of a result by calling a given function on it. If the result is an `Error` rather than `Ok` the function is not called and the result stays the same.
  Examples:
    map(over: Ok(1), with: fn(x) { x + 1 })
    // -> Ok(2)

    map(over: Error(1), with: fn(x) { x + 1 })
    // -> Error(1)

```

--------------------------------

### Gleam: pad_start String Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/string

Pads the start of a String until it has a given length using a specified padding string. If the string is already longer than or equal to the desired length, it is returned unchanged. The padding string is repeated as necessary.

```gleam
pub fn pad_start(
  string: String,
  to desired_length: Int,
  with pad_string: String,
) -> String
```

--------------------------------

### Gleam String drop_start() Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/string

Drops a specified number of graphemes from the start of a string. This function iterates from the beginning to count graphemes.

```gleam
pub fn drop_start(
  from string: String,
  up_to num_graphemes: Int,
) -> String

// Example:
drop_start(from: "The Lone Gunmen", up_to: 2)
// -> "e Lone Gunmen"
```

--------------------------------

### Gleam Dict has_key Example (key present)

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Demonstrates using `has_key` to check if a key is present in a Gleam dictionary. Returns `True` when the key exists.

```gleam
new() |> insert("a", 0) |> has_key("a")
// -> True
```

--------------------------------

### Gleam: combinations List Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Return unique combinations of elements in the list. Example: `combinations([1, 2, 3], 2)` results in `[[1, 2], [1, 3], [2, 3]]`.

```gleam
pub fn combinations(items: List(a), by n: Int) -> List(List(a))
```

--------------------------------

### Gleam Dict Filter Example (keep all)

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Demonstrates filtering a Gleam dictionary created from a list, keeping all entries by using a filter function that always returns true. Uses `from_list` and `filter`.

```gleam
from_list([#("a", 0), #("b", 1)])
|> filter(fn(key, value) { True })
// -> from_list([#("a", 0), #("b", 1)])
```

--------------------------------

### Gleam Dict is_empty Example (not empty)

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Illustrates using `is_empty` on a Gleam dictionary that contains elements. It correctly returns `False`.

```gleam
new() |> insert("b", 1) |> is_empty
// -> False
```

--------------------------------

### Gleam Dict Filter Example (value != 0)

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Demonstrates filtering a Gleam dictionary created from a list, keeping entries where the value is not zero. Uses the `from_list` and `filter` functions.

```gleam
from_list([#("a", 0), #("b", 1)])
|> filter(fn(key, value) { value != 0 })
// -> from_list([#("b", 1)])
```

--------------------------------

### Gleam `first`: Get the first element of a list

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Safely retrieves the first element from a list. Returns `Ok(element)` if the list is not empty, and `Error(Nil)` if the list is empty.

```Gleam
pub fn first(list: List(a)) -> Result(a, Nil)
```

--------------------------------

### Gleam Dict has_key Example (key absent)

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Demonstrates using `has_key` to check if a key is present in a Gleam dictionary. Returns `False` when the key is absent.

```gleam
new() |> insert("a", 0) |> has_key("b")
// -> False
```

--------------------------------

### Gleam Dynamic Decoding with Field

Source: https://hexdocs.pm/gleam_stdlib/gleam/dynamic/decode

Illustrates decoding data using `dynamic.from` and `decode.field` in Gleam. This example shows how to extract top-level fields from a dynamic structure and build a decoder.

```gleam
let data = dynamic.from(dict.from_list([
  #("email", "lucy@example.com"),
  #("name", "Lucy"),
]))

let decoder = {
  use name <- decode.field("name", string)
  use email <- decode.field("email", string)
  decode.success(SignUp(name: name, email: email))
}

let result = decode.run(data, decoder)
assert result == Ok(SignUp(name: "Lucy", email: "lucy@example.com"))

```

--------------------------------

### Gleam: chunk List Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Returns a list of chunks in which the return value of calling `f` on each element is the same. Example: `[1, 2, 2, 3, 4, 4, 6, 7, 7] |> chunk(by: fn(n) { n % 2 })` results in `[[1], [2, 2], [3], [4, 4, 6], [7, 7]]`.

```gleam
pub fn chunk(in list: List(a), by f: fn(a) -> k) -> List(List(a))
```

--------------------------------

### Decode Array Elements with `at`

Source: https://hexdocs.pm/gleam_stdlib/gleam/dynamic/decode

Uses the `decode.at` decoder with integer keys to index into array-like containers such as Gleam or Erlang tuples, or JavaScript arrays. This example retrieves a string element from an array.

```gleam
// Data:
// ["one", "two", "three"]

let result = decode.run(data, decode.at([1], decode.string))
assert result == Ok("two")

```

--------------------------------

### Gleam: combination_pairs List Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Return unique pair combinations of elements in the list. Example: `combination_pairs([1, 2, 3])` results in `[#(1, 2), #(1, 3), #(2, 3)]`.

```gleam
pub fn combination_pairs(items: List(a)) -> List(#(a, a))
```

--------------------------------

### Decode Gleam Records

Source: https://hexdocs.pm/gleam_stdlib/gleam/dynamic/decode

Decodes records from dynamic data by combining field decoders and a success constructor. This example decodes a `Player` record with string, int, bool, and string fields.

```gleam
// Data:
// {
//   "score" -> 180,
//   "name" -> "Mel Smith",
//   "is-admin" -> false,
//   "enrolled" -> true,
//   "colour" -> "Red",
// }

let decoder = {
  use name <- decode.field("name", decode.string)
  use score <- decode.field("score", decode.int)
  use colour <- decode.field("colour", decode.string)
  use enrolled <- decode.field("enrolled", decode.bool)
  decode.success(Player(name:, score:, colour:, enrolled:))
}

let result = decode.run(data, decoder)
assert result == Ok(Player("Mel Smith", 180, "Red", True))

```

--------------------------------

### Gleam: each List Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Calls a function for each element in a list, discarding the return value. Useful for calling a side effect for every item of a list. Example: `each(["1", "2", "3"], io.println)` prints each element and returns `Nil`.

```gleam
pub fn each(list: List(a), f: fn(a) -> b) -> Nil
```

--------------------------------

### Gleam `find`: Get first matching element in List

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Finds the first element in a list for which a given predicate function returns `True`. Returns `Ok(element)` if found, otherwise `Error(Nil)`. Handles empty lists gracefully.

```Gleam
pub fn find(
  in list: List(a),
  one_that is_desired: fn(a) -> Bool,
) -> Result(a, Nil)
```

--------------------------------

### Gleam: drop_while List Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Drops the first elements in a given list for which the predicate function returns `True`. Example: `drop_while([1, 2, 3, 4], fn (x) { x < 3 })` results in `[3, 4]`.

```gleam
pub fn drop_while(
  in list: List(a),
  satisfying predicate: fn(a) -> Bool,
) -> List(a)
```

--------------------------------

### Gleam: append List Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Joins one list onto the end of another. This function runs in linear time, and it traverses and copies the first list. Example: `append([1, 2], [3])` results in `[1, 2, 3]`.

```gleam
pub fn append(first: List(a), second: List(a)) -> List(a)
```

--------------------------------

### Gleam: Trim Whitespace from Start of String

Source: https://hexdocs.pm/gleam_stdlib/gleam/string

Removes whitespace characters from the start of a Gleam String. Whitespace is defined by Unicode Standard Annex #31's Pattern_White_Space.

```gleam
pub fn trim_start(string: String) -> String
```

--------------------------------

### Gleam Dict get API

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Documents the `get` function for retrieving a value associated with a key from a Gleam dictionary. It returns a `Result` type, wrapping the value in `Ok` if found, or `Error(Nil)` if the key is absent.

```APIDOC
pub fn get(from: Dict(k, v), get: k) -> Result(v, Nil)

Fetches a value from a dict for a given key.
The dict may not have a value for the key, so the value is wrapped in a
`Result`.
```

--------------------------------

### Gleam: Create Sliding Windows from List

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Returns a list of sliding windows of a specified size from a given list. If the window size is larger than the list, an empty list is returned.

```gleam
pub fn window(list: List(a), by n: Int) -> List(List(a))
```

```gleam
window([1,2,3,4,5], 3)
// -> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
```

```gleam
window([1, 2], 4)
// -> []
```

--------------------------------

### Get Bit Size of BitArray

Source: https://hexdocs.pm/gleam_stdlib/gleam/bit_array

Returns an integer representing the total number of bits contained within a BitArray.

```Gleam
pub fn bit_size(x: BitArray) -> Int
```

--------------------------------

### Gleam String contains() Example

Source: https://hexdocs.pm/gleam_stdlib/gleam/string

Demonstrates the usage of the contains function to check if a string contains a substring. It is case-sensitive.

```gleam
contains(does: "theory", contain: "ory")
// -> True

contains(does: "theory", contain: "the")
// -> True

contains(does: "theory", contain: "THE")
// -> False
```

--------------------------------

### Gleam List Prepend

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Prefixes an item to the beginning of a list. This functionality can also be achieved using the `[item, ..list]` syntax.

```gleam
pub fn prepend(to list: List(a), this item: a) -> List(a)
```

```gleam
let existing_list = [2, 3, 4]

[1, ..existing_list]
// -> [1, 2, 3, 4]

prepend(to: existing_list, this: 1)
// -> [1, 2, 3, 4]
```

--------------------------------

### Gleam: starts_with String Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/string

Checks whether a String begins with a specified prefix String. Returns a Boolean value indicating whether the prefix matches the beginning of the string.

```gleam
pub fn starts_with(string: String, prefix: String) -> Bool
```

--------------------------------

### Gleam String length() Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/string

Gets the number of grapheme clusters in a string. This function iterates across the whole string, running in linear time.

```gleam
pub fn length(string: String) -> Int

// Examples:
length("Gleam")
// -> 5

length("ß↑e̊")
// -> 3

length("")
// -> 0
```

--------------------------------

### Gleam List New

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Returns a new, empty list. This is a fundamental operation for list creation.

```gleam
pub fn new() -> List(a)
```

```gleam
new()
// -> []
```

--------------------------------

### Gleam: Get Dictionary Size

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Determines the number of key-value pairs in a dictionary. This function runs in constant time and does not need to iterate the dict.

```gleam
pub fn size(dict: Dict(k, v)) -> Int
```

```gleam
new() |> size
// -> 0

new() |> insert("key", "value") |> size
// -> 1
```

--------------------------------

### Gleam product function

Source: https://hexdocs.pm/gleam_stdlib/gleam/int

Multiplies a list of ints and returns the product. If the list is empty, the product is 1.

```gleam
pub fn product(numbers: List(Int)) -> Int
```

```gleam
product([2, 3, 4])
// -> 24
```

--------------------------------

### Get Byte Size of BitArray

Source: https://hexdocs.pm/gleam_stdlib/gleam/bit_array

Returns an integer representing the total number of bytes contained within a BitArray. This is equivalent to the bit size divided by 8.

```Gleam
pub fn byte_size(x: BitArray) -> Int
```

--------------------------------

### Decode Simple String Type

Source: https://hexdocs.pm/gleam_stdlib/gleam/dynamic/decode

Demonstrates decoding a dynamic string value using `decode.string`. The `decode.run` function takes the data and the decoder, returning an `Ok` result with the decoded string or an error.

```gleam
// Data:
// "Hello, Joe!"

let result = decode.run(data, decode.string)
assert result == Ok("Hello, Joe!")
```

--------------------------------

### reduce: Gleam List Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Reduces a list to a single value by applying a function to an accumulator and each element, starting with the first element. Returns an Error if the list is empty.

```gleam
pub fn reduce(
  over list: List(a),
  with fun: fn(a, a) -> a,
) -> Result(a, Nil)
```

--------------------------------

### Gleam: Trim Whitespace from String

Source: https://hexdocs.pm/gleam_stdlib/gleam/string

Removes whitespace from both the start and end of a Gleam String. Whitespace is defined by Unicode Standard Annex #31's Pattern_White_Space.

```gleam
pub fn trim(string: String) -> String
```

--------------------------------

### Gleam Pair Module Functions

Source: https://hexdocs.pm/gleam_stdlib/gleam/pair

Provides documentation for core functions operating on pairs in the Gleam programming language. This includes accessing elements, transforming elements, creating new pairs, and swapping elements within a pair.

```gleam
gleam/pair:

## first

```
pub fn first(pair: #(a, b)) -> a
```

Returns the first element in a pair.

### Parameters:
*   `pair`: A tuple of two elements `#(a, b)`.

### Returns:
*   The first element of type `a`.

### Example:
```gleam
first(#(1, 2))
// -> 1
```

## second

```
pub fn second(pair: #(a, b)) -> b
```

Returns the second element in a pair.

### Parameters:
*   `pair`: A tuple of two elements `#(a, b)`.

### Returns:
*   The second element of type `b`.

### Example:
```gleam
second(#(1, 2))
// -> 2
```

## swap

```
pub fn swap(pair: #(a, b)) -> #(b, a)
```

Returns a new pair with the elements swapped.

### Parameters:
*   `pair`: A tuple of two elements `#(a, b)`.

### Returns:
*   A new tuple `#(b, a)` with elements swapped.

### Example:
```gleam
swap(#(1, 2))
// -> #(2, 1)
```

## new

```
pub fn new(first: a, second: b) -> #(a, b)
```

Returns a new pair with the given elements. This can also be done using the dedicated syntax instead: `new(1, 2) == #(1, 2)`.

### Parameters:
*   `first`: The first element of type `a`.
*   `second`: The second element of type `b`.

### Returns:
*   A new tuple `#(a, b)`.

### Example:
```gleam
new(1, 2)
// -> #(1, 2)
```

## map_first

```
pub fn map_first(of pair: #(a, b), with fun: fn(a) -> c) -> #(c, b)
```

Returns a new pair with the first element having had `with` applied to it.

### Parameters:
*   `pair`: The input tuple `#(a, b)`.
*   `fun`: A function that takes an element of type `a` and returns an element of type `c`.

### Returns:
*   A new tuple `#(c, b)` where the first element is the result of applying `fun`.

### Example:
```gleam
#(1, 2) |> map_first(fn(n) { n * 2 })
// -> #(2, 2)
```

## map_second

```
pub fn map_second(of pair: #(a, b), with fun: fn(b) -> c) -> #(a, c)
```

Returns a new pair with the second element having had `with` applied to it.

### Parameters:
*   `pair`: The input tuple `#(a, b)`.
*   `fun`: A function that takes an element of type `b` and returns an element of type `c`.

### Returns:
*   A new tuple `#(a, c)` where the second element is the result of applying `fun`.

### Example:
```gleam
#(1, 2) |> map_second(fn(n) { n * 2 })
// -> #(1, 4)
```
```

--------------------------------

### Gleam: Get Maximum of Two Floats

Source: https://hexdocs.pm/gleam_stdlib/gleam/float

Compares two float values and returns the larger of the two. This function provides a straightforward way to find the maximum value.

```gleam
pub fn max(a: Float, b: Float) -> Float
```

--------------------------------

### Gleam: Create BytesTree from String

Source: https://hexdocs.pm/gleam_stdlib/gleam/bytes_tree

Creates a new bytes tree from a string. Performance varies: constant time when running on Erlang, and linear time otherwise.

```gleam
pub fn from_string(string: String) -> BytesTree
```

--------------------------------

### Gleam: Get Minimum of Two Floats

Source: https://hexdocs.pm/gleam_stdlib/gleam/float

Compares two float values and returns the smaller of the two. This function provides a straightforward way to find the minimum value.

```gleam
pub fn min(a: Float, b: Float) -> Float
```

--------------------------------

### Gleam: Create BytesTree from StringTree

Source: https://hexdocs.pm/gleam_stdlib/gleam/bytes_tree

Creates a new bytes tree from a string tree data structure. Performance characteristics are similar to `from_string`: constant time on Erlang, linear time otherwise.

```gleam
pub fn from_string_tree(
  tree: string_tree.StringTree,
) -> BytesTree
```

--------------------------------

### Gleam: Get Dictionary Values

Source: https://hexdocs.pm/gleam_stdlib/gleam/dict

Retrieves a list of all values present in a dictionary. The order of values in the returned list is not guaranteed and should not be relied upon, as dictionaries are unordered.

```gleam
pub fn values(dict: Dict(k, v)) -> List(v)
```

```gleam
from_list([#("a", 0), #("b", 1)]) |> values
// -> [0, 1]
```

--------------------------------

### Gleam: run Decoder

Source: https://hexdocs.pm/gleam_stdlib/gleam/dynamic/decode

Executes a given decoder against a `Dynamic` value, returning the decoded result or a list of decoding errors.

```APIDOC
pub fn run(
  data: dynamic.Dynamic,
  decoder: Decoder(t),
) -> Result(t, List(DecodeError))

Run a decoder on a `Dynamic` value, decoding the value if it is of the
desired type, or returning errors.
```

```gleam
let decoder = {
  use name <- decode.field("email", decode.string)
  use email <- decode.field("password", decode.string)
  decode.success(SignUp(name: name, email: email))
}

decode.run(data, decoder)
```

--------------------------------

### unwrap Gleam Option Default Value

Source: https://hexdocs.pm/gleam_stdlib/gleam/option

Extracts the value from an Option, returning a default value if there is none. This provides a simple way to get a value or a fallback.

```gleam
pub fn unwrap(option: Option(a), or default: a) -> a

-- Examples:
unwrap(Some(1), 0)
// -> 1

unwrap(None, 0)
// -> 0
```

--------------------------------

### Gleam or: Return First Ok Result

Source: https://hexdocs.pm/gleam_stdlib/gleam/result

Returns the first value if it is `Ok`, otherwise returns the second value. This is useful for providing fallback results when an operation fails.

```gleam
pub fn or(
  first: Result(a, e),
  second: Result(a, e),
) -> Result(a, e)
```

```gleam
or(Ok(1), Ok(2))
// -> Ok(1)
```

```gleam
or(Ok(1), Error("Error 2"))
// -> Ok(1)
```

```gleam
or(Error("Error 1"), Ok(2))
// -> Ok(2)
```

```gleam
or(Error("Error 1"), Error("Error 2"))
// -> Error("Error 2")
```

--------------------------------

### Gleam String join() Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/string

Joins a list of strings together using a specified separator. This operation runs in linear time.

```gleam
pub fn join(
  strings: List(String),
  with separator: String,
) -> String

// Example:
join(["home","evan","Desktop"], with: "/")
// -> "home/evan/Desktop"
```

--------------------------------

### Gleam `fold`: Left-to-right list reduction

Source: https://hexdocs.pm/gleam_stdlib/gleam/list

Reduces a list to a single value by applying a function cumulatively from left to right, starting with an initial accumulator value. This is a common pattern for aggregation.

```Gleam
pub fn fold(
  over list: List(a),
  from initial: acc,
  with fun: fn(acc, a) -> acc,
) -> acc
```

--------------------------------

### Create BytesTree from BitArray

Source: https://hexdocs.pm/gleam_stdlib/gleam/bytes_tree

Creates a new BytesTree from a given BitArray. This operation runs in constant time.

```gleam
pub fn from_bit_array(bits: BitArray) -> BytesTree
```

--------------------------------

### Gleam Set new Function

Source: https://hexdocs.pm/gleam_stdlib/gleam/set

Creates and returns a new, empty set.

```gleam
pub fn new() -> Set(member)
```
Tokens:
Raw