AsyncIterator

A JavaScript async iterator protocol object.

This models the async iterator protocol: an object with a next() method that returns a promise resolving to an iterator result.

See AsyncIterator on MDN.

done

RES

let done: unit => result<'yield, unit>

done() creates a completed iterator result with unit as the final value.

doneWithValue

RES

let doneWithValue: 'return => result<'yield, 'return>

doneWithValue(value) creates a completed iterator result with the provided final value.

forEach

RES

let forEach: (t<'yield, 'return, 'next>, 'yield => unit) => promise<unit>

forEach(asyncIterator, f) consumes all yielded values in asyncIterator and runs f for each yielded value.

The final return value is not passed to f.

ignore

RES

let ignore: t<'yield, 'return, 'next> => unit

ignore(asyncIterator) marks asyncIterator as intentionally unused.

make

RES

let make: (
  unit => promise<result<'yield, 'return>>,
) => t<'yield, 'return, unit>

make(nextFn) creates an async iterator protocol object from a function returning the next result.

The returned value is not automatically async iterable.

Examples

RES
let current = ref(0)

let asyncIterator = AsyncIterator.make(async () => {
  let value = current.contents
  current := value + 1

  if value >= 3 {
    AsyncIterator.done()
  } else {
    AsyncIterator.value(value)
  }
})

let main = async () =>
  await asyncIterator->AsyncIterator.forEach(value => Console.log(value))

main()->ignore

RES

let next: t<
  'yield,
  'return,
  'next,
> => promise<result<'yield, 'return>>

next(asyncIterator) advances asyncIterator without sending a value back in.

Examples

RES
let asyncIterator: AsyncIterator.t<int, unit, unit> = %raw(`({
  current: 0,
  next() {
    if (this.current < 2) {
      return Promise.resolve({done: false, value: this.current++})
    }
    return Promise.resolve({done: true, value: undefined})
  }
})`)

let process = async () => {
  switch await asyncIterator->AsyncIterator.next {
  | Yield({value: 0}) => ()
  | _ => ()
  }
}

process()->ignore

nextRaw

RES

let nextRaw: t<
  'yield,
  'return,
  'next,
> => promise<rawResult<'yield, 'return>>

nextRaw(asyncIterator) advances asyncIterator and returns a promise for the raw JavaScript iterator result object.

This is mainly intended for internal use and protocol-level interop.

nextValue

RES

let nextValue: (
  t<'yield, 'return, 'next>,
  'next,
) => promise<result<'yield, 'return>>

nextValue(asyncIterator, value) advances asyncIterator, sending value back into it.

nextValueRaw

RES

let nextValueRaw: (
  t<'yield, 'return, 'next>,
  'next,
) => promise<rawResult<'yield, 'return>>

nextValueRaw(asyncIterator, value) advances asyncIterator, sends value back into it, and returns a promise for the raw JavaScript iterator result object.

This is mainly intended for internal use and protocol-level interop.

normalizeResult

RES

let normalizeResult: rawResult<'yield, 'return> => result<'yield, 'return>

Low-level raw JavaScript async iterator result shape.

This is mainly intended for internal use and protocol-level interop. Prefer AsyncIterator.result, AsyncIterator.next, and AsyncIterator.nextValue in normal ReScript code.

rawResult

RES

type rawResult<'yield, 'return>

result

RES

type result<'yield, 'return> = Iterator.result<
  'yield,
  'return,
>

Result returned by AsyncIterator.next.

t

RES

type t<'yield, 'return, 'next>

Type representing an async iterator protocol object.

'yield is the type produced while iterating
'return is the final completion value once iteration is done
'next is the type that can be sent back into next(value)

value

RES

let value: 'yield => result<'yield, 'return>

value(value) creates a yielded iterator result.

Examples

RES
let current = ref(0)

let asyncIterableIterator = AsyncIterator.make(async () => {
  let value = current.contents
  current := value + 1

  if value >= 3 {
    AsyncIterator.done()
  } else {
    AsyncIterator.value(value)
  }
})