Iterator

A JavaScript iterator protocol object.

This is the minimal protocol shape: an object with a next() method that produces yielded values until it eventually completes with a final return value.

See Iterator 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.

ignore

RES

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

ignore(iterator) marks iterator as intentionally unused.

make

RES

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

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

The returned value is not automatically iterable.

Examples

RES
let current = ref(0)

let iterator = Iterator.make(() => {
  let value = current.contents
  current := value + 1

  if value >= 2 {
    Iterator.doneWithValue("done")
  } else {
    Iterator.value(value)
  }
})

iterator->Iterator.next == Yield({value: 0})

RES

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

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

Examples

RES
let iterator: Iterator.t<int, string, unit> = %raw(`({
  current: 0,
  next() {
    if (this.current < 2) {
      return {done: false, value: this.current++}
    }
    return {done: true, value: "done"}
  }
})`)

iterator->Iterator.next == Yield({value: 0})

nextRaw

RES

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

nextRaw(iterator) advances iterator and returns 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,
) => result<'yield, 'return>

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

nextValueRaw

RES

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

nextValueRaw(iterator, value) advances iterator, sending value back into it, and returns 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 iterator result shape.

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

rawResult

RES

type rawResult<'yield, 'return>

result

RES

type result<'yield, 'return> =
  | Yield({value: 'yield})
  | Return({value: 'return})

Result returned by Iterator.next.

t

RES

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

Type representing an 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.