Joins multiple decoders into one. When run they will each be tried in turn until one succeeds, or they all fail.

Examples

import gleam/result

let bool_or_string = any(of: [
  string,
  fn(x) { result.map(bool(x), fn(_) { "a bool" }) }
])

bool_or_string(from("ok"))
// -> Ok("ok")

bool_or_string(from(True))
// -> Ok("a bool")

bool_or_string(from(1))
// -> Error(DecodeError(expected: "another type", found: "Int", path: []))

Checks to see whether a Dynamic value is a bit array, and returns that bit array if it is.

Examples

import gleam/bit_array
bit_array(from("Hello")) == bit_array.from_string("Hello")
// -> True

bit_array(from(123))
// -> Error([DecodeError(expected: "BitArray", found: "Int", path: [])])

Checks to see whether a Dynamic value is a bool, and returns that bool if it is.

Examples

bool(from(True))
// -> Ok(True)

bool(from(123))
// -> Error([DecodeError(expected: "Bool", found: "Int", path: [])])

Return a string indicating the type of the dynamic value.

classify(from("Hello"))
// -> "String"

Decode 1 values from a Dynamic value.

Examples

from(#(1, 2.0, "3")) |> decode1(MyRecord, element(0, int))
// -> Ok(MyRecord(1))

from(#("", "", "")) |> decode1(MyRecord, element(0, int))
// -> Error([
//   DecodeError(expected: "Int", found: "String", path: ["0"]),
// ])

Decode 2 values from a Dynamic value.

Examples

from(#(1, 2.0, "3"))
|> decode2(MyRecord, element(0, int), element(1, float))
// -> Ok(MyRecord(1, 2.0))

from(#("", "", ""))
|> decode2(MyRecord, element(0, int), element(1, float))
// -> Error([
//   DecodeError(expected: "Int", found: "String", path: ["0"]),
//   DecodeError(expected: "Float", found: "String", path: ["1"]),
// ])

Decode 3 values from a Dynamic value.

Examples

from(#(1, 2.0, "3"))
|> decode3(MyRecord, element(0, int), element(1, float), element(2, string))
// -> Ok(MyRecord(1, 2.0, "3"))

from(#("", "", ""))
|> decode3(MyRecord, element(0, int), element(1, float), element(2, string))
// -> Error([
//   DecodeError(expected: "Int", found: "String", path: ["0"]),
//   DecodeError(expected: "Float", found: "String", path: ["1"]),
// ])

Decode 4 values from a Dynamic value.

Examples

from(#(1, 2.1, "3", "4"))
|> decode4(
  MyRecord,
  element(0, int),
  element(1, float),
  element(2, string),
  element(3, string),
)
// -> Ok(MyRecord(1, 2.1, "3", "4"))

from(#("", "", "", ""))
|> decode4(
  MyRecord,
  element(0, int),
  element(1, float),
  element(2, string),
  element(3, string),
)
// -> Error([
//   DecodeError(expected: "Int", found: "String", path: ["0"]),
//   DecodeError(expected: "Float", found: "String", path: ["1"]),
// ])

Decode 5 values from a Dynamic value.

Examples

from(#(1, 2.1, "3", "4", "5"))
|> decode5(
  MyRecord,
  element(0, int),
  element(1, float),
  element(2, string),
  element(3, string),
  element(4, string),
)
// -> Ok(MyRecord(1, 2.1, "3", "4", "5"))

from(#("", "", "", "", ""))
|> decode5(
  MyRecord,
  element(0, int),
  element(1, float),
  element(2, string),
  element(3, string),
  element(4, string),
)
// -> Error([
//   DecodeError(expected: "Int", found: "String", path: ["0"]),
//   DecodeError(expected: "Float", found: "String", path: ["1"]),
// ])

Decode 6 values from a Dynamic value.

Examples

from(#(1, 2.1, "3", "4", "5", "6"))
|> decode6(
  MyRecord,
  element(0, int),
  element(1, float),
  element(2, string),
  element(3, string),
  element(4, string),
  element(5, string),
)
// -> Ok(MyRecord(1, 2.1, "3", "4", "5", "6"))

from(#("", "", "", "", "", ""))
|> decode6(
  MyRecord,
  element(0, int),
  element(1, float),
  element(2, string),
  element(3, string),
  element(4, string),
  element(5, string),
)
// -> Error([
//   DecodeError(expected: "Int", found: "String", path: ["0"]),
//   DecodeError(expected: "Float", found: "String", path: ["1"]),
// ])

Decode 7 values from a Dynamic value.

Examples

from(#(1, 2.1, "3", "4", "5", "6"))
|> decode7(
  MyRecord,
  element(0, int),
  element(1, float),
  element(2, string),
  element(3, string),
  element(4, string),
  element(5, string),
  element(6, string),
)
// -> Ok(MyRecord(1, 2.1, "3", "4", "5", "6", "7"))

from(#("", "", "", "", "", "", ""))
|> decode7(
  MyRecord,
  element(0, int),
  element(1, float),
  element(2, string),
  element(3, string),
  element(4, string),
  element(5, string),
  element(6, string),
)
// -> Error([
//   DecodeError(expected: "Int", found: "String", path: ["0"]),
//   DecodeError(expected: "Float", found: "String", path: ["1"]),
// ])

Decode 8 values from a Dynamic value.

Examples

from(#(1, 2.1, "3", "4", "5", "6", "7", "8"))
|> decode8(
  MyRecord,
  element(0, int),
  element(1, float),
  element(2, string),
  element(3, string),
  element(4, string),
  element(5, string),
  element(6, string),
  element(7, string),
)
// -> Ok(MyRecord(1, 2.1, "3", "4", "5", "6", "7", "8"))

from(#("", "", "", "", "", "", "", ""))
|> decode8(
  MyRecord,
  element(0, int),
  element(1, float),
  element(2, string),
  element(3, string),
  element(4, string),
  element(5, string),
  element(6, string),
  element(7, string),
)
// -> Error([
//   DecodeError(expected: "Int", found: "String", path: ["0"]),
//   DecodeError(expected: "Float", found: "String", path: ["1"]),
// ])

Decode 9 values from a Dynamic value.

Examples

from(#(1, 2.1, "3", "4", "5", "6", "7", "8", "9"))
|> decode9(
  MyRecord,
  element(0, int),
  element(1, float),
  element(2, string),
  element(3, string),
  element(4, string),
  element(5, string),
  element(6, string),
  element(7, string),
  element(8, string),
)
// -> Ok(MyRecord(1, 2.1, "3", "4", "5", "6", "7", "8", "9"))

from(#("", "", "", "", "", "", "", "", ""))
|> decode9(
  MyRecord,
  element(0, int),
  element(1, float),
  element(2, string),
  element(3, string),
  element(4, string),
  element(5, string),
  element(6, string),
  element(7, string),
  element(8, string),
)
// -> Error([
//   DecodeError(expected: "Int", found: "String", path: ["0"]),
//   DecodeError(expected: "Float", found: "String", path: ["1"]),
// ])

Checks to see if a Dynamic value is a dict.

Examples

import gleam/dict
dict.new() |> from |> map(string, int)
// -> Ok(dict.new())

from(1) |> map(string, int)
// -> Error(DecodeError(expected: "Map", found: "Int", path: []))

from("") |> map(string, int)
// -> Error(DecodeError(expected: "Map", found: "String", path: []))

Decodes a Dynamic value from a Dynamic value.

This function doesn’t seem very useful at first, but it can be convenient when you need to give a decoder function but you don’t actually care what the to-decode value is.

Checks to see if a Dynamic value is a tuple large enough to have a certain index, and returns the value of that index if it is.

Examples

from(#(1, 2))
|> element(0, int)
// -> Ok(from(1))

from(#(1, 2))
|> element(2, int)
// -> Error([
//   DecodeError(
//     expected: "Tuple of at least 3 elements",
//     found: "Tuple of 2 elements",
//     path: [],
//   ),
// ])

Checks to see if a Dynamic value is a map with a specific field, and returns the value of that field if it is.

This will not succeed on a record.

Examples

import gleam/dict
dict.new()
|> dict.insert("Hello", "World")
|> from
|> field(named: "Hello", of: string)
// -> Ok("World")

from(123) |> field("Hello", string)
// -> Error([DecodeError(expected: "Map", found: "Int", path: [])])

Checks to see whether a Dynamic value is a float, and returns that float if it is.

Examples

float(from(2.0))
// -> Ok(2.0)

float(from(123))
// -> Error([DecodeError(expected: "Float", found: "Int", path: [])])

Converts any Gleam data into Dynamic data.

Checks to see whether a Dynamic value is an int, and returns that int if it is.

Examples

int(from(123))
// -> Ok(123)

int(from("Hello"))
// -> Error([DecodeError(expected: "Int", found: "String", path: [])])

Checks to see whether a Dynamic value is a list of a particular type, and returns that list if it is.

The second argument is a decoder function used to decode the elements of the list. The list is only decoded if all elements in the list can be successfully decoded using this function.

If you do not wish to decode all the elements in the list use the shallow_list function instead.

Examples

from(["a", "b", "c"]) |> list(of: string)
// -> Ok(["a", "b", "c"])

from([1, 2, 3]) |> list(of: string)
// -> Error([DecodeError(expected: "String", found: "Int", path: ["*"])])

from("ok") |> list(of: string)
// -> Error([DecodeError(expected: "List", found: "String", path: [])])

Checks to see if a Dynamic value is a nullable version of a particular type, and returns a corresponding Option if it is.

Examples

from("Hello") |> optional(string)
// -> Ok(Some("Hello"))

from("Hello") |> optional(string)
// -> Ok(Some("Hello"))

import gleam/erlang/atom
from(atom.from_string("null")) |> optional(string)
// -> Ok(None)

import gleam/erlang/atom
from(atom.from_string("nil")) |> optional(string)
// -> Ok(None)

import gleam/erlang/atom
from(atom.from_string("undefined")) |> optional(string)
// -> Ok(None)

from(123) |> optional(string)
// -> Error([DecodeError(expected: "String", found: "Int", path: [])])

Checks to see if a Dynamic value is a map with a specific field. If the map does not have the specified field, returns an Ok(None) instead of failing; otherwise, returns the decoded field wrapped in Some(_).

Examples

import gleam/dict
dict.new()
|> dict.insert("Hello", "World")
|> from
|> optional_field(named: "Hello", of: string)
// -> Ok(Some("World"))

import gleam/dict
dict.new()
|> from
|> optional_field(named: "Hello", of: string)
// -> Ok(None)

from(123)
|> optional_field("Hello", string)
// -> Error([DecodeError(expected: "Map", found: "Int", path: [])])

Checks to see whether a Dynamic value is a result of a particular type, and returns that result if it is.

The ok and error arguments are decoders for decoding the Ok and Error values of the result.

Examples

from(Ok(1)) |> result(ok: int, error: string)
// -> Ok(Ok(1))

from(Error("boom")) |> result(ok: int, error: string)
// -> Ok(Error("boom"))

from(123) |> result(ok: int, error: string)
// -> Error([DecodeError(expected: "Result", found: "Int", path: [])])

Checks to see whether a Dynamic value is a list, and returns that list if it is. The types of the elements are not checked.

If you wish to decode all the elements in the list use the list function instead.

Examples

shallow_list(from(["a", "b", "c"]))
// -> Ok([from("a"), from("b"), from("c")])

shallow_list(1)
// -> Error([DecodeError(expected: "List", found: "Int", path: [])])

Checks to see whether a Dynamic value is a string, and returns that string if it is.

Examples

string(from("Hello"))
// -> Ok("Hello")

string(from(123))
// -> Error([DecodeError(expected: "String", found: "Int", path: [])])

Checks to see if a Dynamic value is a 2-element tuple, list or array containing specifically typed elements.

Examples

from(#(1, 2))
|> tuple2(int, int)
// -> Ok(#(1, 2))

from(#(1, 2.0))
|> tuple2(int, float)
// -> Ok(#(1, 2.0))

from([1, 2])
|> tuple2(int, int)
// -> Ok(#(1, 2))

from([from(1), from(2.0)])
|> tuple2(int, float)
// -> Ok(#(1, 2.0))

from(#(1, 2, 3))
|> tuple2(int, float)
// -> Error([
//   DecodeError(
//     expected: "Tuple of 2 elements",
//     found: "Tuple of 3 elements",
//     path: [],
//   ),
// ])

from("")
|> tuple2(int, float)
// -> Error([
//   DecodeError(
//     expected: "Tuple of 2 elements",
//     found: "String",
//     path: [],
//   ),
// ])

Checks to see if a Dynamic value is a 3-element tuple, list or array containing specifically typed elements.

Examples

from(#(1, 2, 3))
|> tuple3(int, int, int)
// -> Ok(#(1, 2, 3))

from(#(1, 2.0, "3"))
|> tuple3(int, float, string)
// -> Ok(#(1, 2.0, "3"))

from([1, 2, 3])
|> tuple3(int, int, int)
// -> Ok(#(1, 2, 3))

from([from(1), from(2.0), from("3")])
|> tuple3(int, float, string)
// -> Ok(#(1, 2.0, "3"))

from(#(1, 2))
|> tuple3(int, float, string)
// -> Error([
//   DecodeError(
//     expected: "Tuple of 3 elements",
//     found: "Tuple of 2 elements",
//     path: [],
//   ),
// ])

from("")
|> tuple3(int, float, string)
// -> Error([
//   DecodeError(
//     expected: "Tuple of 3 elements",
//     found: "String",
//     path: [],
//   ),
// ])

Checks to see if a Dynamic value is a 4-element tuple, list or array containing specifically typed elements.

Examples

from(#(1, 2, 3, 4))
|> tuple4(int, int, int, int)
// -> Ok(#(1, 2, 3, 4))

from(#(1, 2.0, "3", 4))
|> tuple4(int, float, string, int)
// -> Ok(#(1, 2.0, "3", 4))

from([1, 2, 3, 4])
|> tuple4(int, int, int, int)
// -> Ok(#(1, 2, 3, 4))

from([from(1), from(2.0), from("3"), from(4)])
|> tuple4(int, float, string, int)
// -> Ok(#(1, 2.0, "3", 4))

from(#(1, 2))
|> tuple4(int, float, string, int)
// -> Error([
//   DecodeError(
//     expected: "Tuple of 4 elements",
//     found: "Tuple of 2 elements",
//     path: [],
//   ),
// ])

from("")
|> tuple4(int, float, string, int)
// -> Error([
//   DecodeError(
//     expected: "Tuple of 4 elements",
//     found: "String",
//     path: [],
//   ),
// ])

Checks to see if a Dynamic value is a 5-element tuple, list or array containing specifically typed elements.

Examples

from(#(1, 2, 3, 4, 5))
|> tuple5(int, int, int, int, int)
// -> Ok(#(1, 2, 3, 4, 5))

from(#(1, 2.0, "3", 4, 5))
|> tuple5(int, float, string, int, int)
// -> Ok(#(1, 2.0, "3", 4, 5))

from([1, 2, 3, 4, 5])
|> tuple5(int, int, int, int, int)
// -> Ok(#(1, 2, 3, 4, 5))

from([from(1), from(2.0), from("3"), from(4), from(True)])
|> tuple5(int, float, string, int, bool)
// -> Ok(#(1, 2.0, "3", 4, True))

from(#(1, 2))
|> tuple5(int, float, string, int, int)
// -> Error([
//   DecodeError(
//     expected: "Tuple of 5 elements",
//     found: "Tuple of 2 elements",
//     path: [],
//   ),
// ])

from("")
|> tuple5(int, float, string, int, int)
// -> Error([
//   DecodeError(
//     expected: "Tuple of 5 elements",
//     found: "String",
//     path: [],
//   ),
// ])

Checks to see if a Dynamic value is a 6-element tuple, list or array containing specifically typed elements.

Examples

from(#(1, 2, 3, 4, 5, 6))
|> tuple6(int, int, int, int, int, int)
// -> Ok(#(1, 2, 3, 4, 5, 6))

from(#(1, 2.0, "3", 4, 5, 6))
|> tuple6(int, float, string, int, int, int)
// -> Ok(#(1, 2.0, "3", 4, 5, 6))

from([1, 2, 3, 4, 5, 6])
|> tuple6(int, int, int, int, int, int)
// -> Ok(#(1, 2, 3, 4, 5, 6))

from([from(1), from(2.0), from("3"), from(4), from(True), from(False)])
|> tuple6(int, float, string, int, bool, bool)
// -> Ok(#(1, 2.0, "3", 4, True, False))

from(#(1, 2))
|> tuple6(int, float, string, int, int, int)
// -> Error([
//   DecodeError(
//     expected: "Tuple of 6 elements",
//     found: "Tuple of 2 elements",
//     path: [],
//   ),
// ])

from("")
|> tuple6(int, float, string, int, int, int)
// -> Error([
//   DecodeError(
//     expected: "Tuple of 6 elements",
//     found: "String",
//     path: [],
//  ),
// ])

Unsafely casts a Dynamic value into any other type.

This is an escape hatch for the type system that may be useful when wrapping native Erlang APIs. It is to be used as a last measure only!

If you can avoid using this function, do!