gleam/erlang

Types

Crash

pub type Crash {
  Exited(Dynamic)
  Thrown(Dynamic)
  Errored(Dynamic)
}

Constructors

```
Exited(Dynamic)
```
```
Thrown(Dynamic)
```
```
Errored(Dynamic)
```

EnsureAllStartedError

</>

pub type EnsureAllStartedError {
  UnknownApplication(name: Atom)
  ApplicationFailedToStart(name: Atom, reason: Dynamic)
}

Constructors

```
UnknownApplication(name: Atom)
```

ApplicationFailedToStart(name: Atom, reason: Dynamic)

Reference

</>

A unique reference value.

It holds no particular meaning or value, but unique values are often useful in programs are used heavily within both Gleam and Erlang’s OTP frameworks.

More can be read about references in the Erlang documentation.

pub type Reference

TimeUnit

</>

pub type TimeUnit {
  Second
  Millisecond
  Microsecond
  Nanosecond
}

Constructors

```
Second
```
```
Millisecond
```
```
Microsecond
```
```
Nanosecond
```

Functions

binary_to_term

</>

pub fn binary_to_term(binary: BitArray) -> Result(Dynamic, Nil)

Decodes a value from a BitArray representing an Erlang external term.

https://www.erlang.org/doc/apps/erts/erlang.html#binary_to_term/1

bounded_phash2

</>

pub fn bounded_phash2(term: a, limit limit: Int) -> Int

Portable hash function that gives the same hash for the same Gleam/Erlang term regardless of machine architecture and ERTS version.

The function returns a hash value for Term within the range 0..limit-1. The maximum value for limit is 2^32.

https://www.erlang.org/doc/apps/erts/erlang.html#phash2/2

ensure_all_started

</>

pub fn ensure_all_started(
  application application: Atom,
) -> Result(List(Atom), EnsureAllStartedError)

Starts an OTP application’s process tree in the background, as well as the trees of any applications that the given application depends upon. An OTP application typically maps onto a Gleam or Hex package.

Returns a list of the applications that were started. Calling this function for application that have already been started is a no-op so you do not need to check the application state beforehand.

In Gleam we prefer to not use these implicit background process trees, but you will likely still need to start the trees of OTP applications written in other BEAM languages such as Erlang or Elixir, including those included by default with Erlang/OTP.

For more information see the OTP documentation.

erlang_timestamp

</>

pub fn erlang_timestamp() -> #(Int, Int, Int)

Returns the current OS system time as a tuple of Ints

http://erlang.org/doc/man/os.html#timestamp-0

format

</>

pub fn format(term: a) -> String

Return a string representation of any term

Example

erlang.format(input)
// -> {ok,<<"Gleam\n">>}%

get_line

</>

pub fn get_line(
  prompt prompt: String,
) -> Result(String, GetLineError)

Reads a line from standard input with the given prompt.

Example

get_line("Language: ")
// > Language: <- Gleam
// -> Ok("Gleam\n")

make_reference

</>

pub fn make_reference() -> Reference

Create a new unique reference.

phash2

</>

pub fn phash2(term: a) -> Int

Equivalent to bounded_phash2, with a upper limit of 2^27-1

priv_directory

</>

pub fn priv_directory(name: String) -> Result(String, Nil)

Returns the path of a package’s priv directory, where extra non-Gleam or Erlang files are typically kept.

Returns an error if no package was found with the given name.

Example

erlang.priv_directory("my_app")
// -> Ok("/some/location/my_app/priv")

reference_from_dynamic

</>

pub fn reference_from_dynamic(
  from from: Dynamic,
) -> Result(Reference, List(DecodeError))

Checks to see whether a Dynamic value is a Reference, and return the Reference if it is.

Examples

import gleam/dynamic

reference_from_dynamic(dynamic.from(make_reference()))
// -> Ok(Reference)

import gleam/dynamic

reference_from_dynamic(dynamic.from(123))
// -> Error([DecodeError(expected: "Reference", found: "Int", path: [])])

rescue

</>

pub fn rescue(a: fn() -> a) -> Result(a, Crash)

Gleam doesn’t offer any way to raise exceptions, but they may still occur due to bugs when working with unsafe code, such as when calling Erlang function.

This function will catch any error thrown and convert it into a result rather than crashing the process.

start_arguments

</>

pub fn start_arguments() -> List(String)

Deprecated: Please use the argv package instead

Get the arguments given to the program when it was started.

This is sometimes called argv in other languages.

system_time

</>

pub fn system_time(a: TimeUnit) -> Int

Returns the current OS system time.

https://erlang.org/doc/apps/erts/time_correction.html#OS_System_Time

term_to_binary

</>

pub fn term_to_binary(a: a) -> BitArray

Returns a BitArray representing given value as an Erlang external term.

https://www.erlang.org/doc/apps/erts/erlang.html#term_to_binary/1

unsafe_binary_to_term

</>

pub fn unsafe_binary_to_term(
  binary: BitArray,
) -> Result(Dynamic, Nil)

Decodes a value from a trusted BitArray representing an Erlang external term.

Warning: Do not use this function with untrusted input, this can lead to Denial-of-Service. More information in the Erlang documentation.