rx/eager

Types

Eager

opaque </>

A finite reactive sequence evaluated eagerly.

Operators on Eager run immediately and remain composable with Gleam’s pipeline operator. Convert to the actor-backed Observable API with to_observable when asynchronous/runtime-managed composition is needed.

pub opaque type Eager(value, error)

Values

append

</>

pub fn append(
  first: Eager(value, error),
  second: Eager(value, error),
) -> Eager(value, error)

empty

</>

pub fn empty() -> Eager(value, error)

fail

</>

pub fn fail(error: error) -> Eager(value, error)

filter

</>

pub fn filter(
  sequence: Eager(value, error),
  predicate: fn(value) -> Bool,
) -> Eager(value, error)

flat_map

</>

pub fn flat_map(
  sequence: Eager(a, error),
  mapper: fn(a) -> Eager(b, error),
) -> Eager(b, error)

fold

</>

pub fn fold(
  sequence: Eager(value, error),
  initial: accumulator,
  reducer: fn(accumulator, value) -> accumulator,
) -> Result(accumulator, error)

from_list

</>

pub fn from_list(values: List(value)) -> Eager(value, error)

from_result

</>

pub fn from_result(
  result: Result(value, error),
) -> Eager(value, error)

map

</>

pub fn map(
  sequence: Eager(a, error),
  mapper: fn(a) -> b,
) -> Eager(b, error)

map_error

</>

pub fn map_error(
  sequence: Eager(value, a),
  mapper: fn(a) -> b,
) -> Eager(value, b)

of

</>

pub fn of(value: value) -> Eager(value, error)

scan

</>

pub fn scan(
  sequence: Eager(value, error),
  initial: accumulator,
  reducer: fn(accumulator, value) -> accumulator,
) -> Eager(accumulator, error)

skip

</>

pub fn skip(
  sequence: Eager(value, error),
  count: Int,
) -> Eager(value, error)

take

</>

pub fn take(
  sequence: Eager(value, error),
  count: Int,
) -> Eager(value, error)

tap

</>

pub fn tap(
  sequence: Eager(value, error),
  effect: fn(value) -> Nil,
) -> Eager(value, error)

to_observable

</>

pub fn to_observable(
  sequence: Eager(value, error),
) -> rx.Observable(value, error)

Convert an eager sequence into the current actor-backed Observable API.

to_result

</>

pub fn to_result(
  sequence: Eager(value, error),
) -> Result(List(value), error)