gossamer

// src/gossamer/iterator.ffi.ts
import * as $iteratorHandlerOutcome from "./iterator_handler_outcome.mjs";
import {
  List$isNonEmpty,
  List$NonEmpty$first,
  List$NonEmpty$rest,
  Result$Ok
} from "../../prelude.mjs";
import {
  toGleamIteratorResult,
  toIteratorResult
} from "./iterator_result.ffi.mjs";
import { fromArray } from "../utils/list.ffi.mjs";
import { toOption } from "../utils/option.ffi.mjs";
import { toResult } from "../utils/result.ffi.mjs";
function withHelpers(iterator) {
  return Iterator.from(iterator);
}
var new_ = (...[next2]) => {
  const iterator = {
    next: (...[value]) => toIteratorResult(next2(toOption(value))),
    [Symbol.iterator]() {
      return this;
    }
  };
  return iterator;
};
var from_list = (list) => {
  let current = list;
  const iterator = {
    next() {
      if (List$isNonEmpty(current)) {
        const value = List$NonEmpty$first(current);
        current = List$NonEmpty$rest(current);
        return { done: false, value };
      }
      return { done: true, value: void 0 };
    },
    [Symbol.iterator]() {
      return this;
    }
  };
  return iterator;
};
var to_list = (iterator) => {
  const values = [];
  while (true) {
    const result = iterator.next();
    if (result.done) {
      break;
    }
    values.push(result.value);
  }
  return fromArray(values);
};
var with_return = (iterator, return_2) => {
  const newIterator = {
    ...iterator,
    next: (...args) => iterator.next(...args),
    return: (value) => toIteratorResult(return_2(toOption(value))),
    [Symbol.iterator]() {
      return this;
    }
  };
  return newIterator;
};
var with_throw = (iterator, throw_2) => {
  const newIterator = {
    ...iterator,
    next: (...args) => iterator.next(...args),
    throw: (value) => toIteratorResult(throw_2(value)),
    [Symbol.iterator]() {
      return this;
    }
  };
  return newIterator;
};
var next = (iterator) => {
  const result = iterator.next();
  return toGleamIteratorResult(result);
};
var next_with = (iterator, value) => {
  const result = iterator.next(value);
  return toGleamIteratorResult(result);
};
var return_ = (iterator) => {
  const returnFn = iterator.return;
  if (!returnFn) {
    return Result$Ok(
      $iteratorHandlerOutcome.IteratorHandlerOutcome$NoHandler()
    );
  }
  return toResult.fromThrows(
    () => $iteratorHandlerOutcome.IteratorHandlerOutcome$Handled(
      toGleamIteratorResult(returnFn.call(iterator))
    )
  );
};
var return_with = (iterator, value) => {
  const returnFn = iterator.return;
  if (!returnFn) {
    return Result$Ok(
      $iteratorHandlerOutcome.IteratorHandlerOutcome$NoHandler()
    );
  }
  return toResult.fromThrows(
    () => $iteratorHandlerOutcome.IteratorHandlerOutcome$Handled(
      toGleamIteratorResult(returnFn.call(iterator, value))
    )
  );
};
var throw_ = (iterator, reason) => {
  const throwFn = iterator.throw;
  if (!throwFn) {
    return Result$Ok(
      $iteratorHandlerOutcome.IteratorHandlerOutcome$NoHandler()
    );
  }
  return toResult.fromThrows(
    () => $iteratorHandlerOutcome.IteratorHandlerOutcome$Handled(
      toGleamIteratorResult(throwFn.call(iterator, reason))
    )
  );
};
var for_ = (iterator, fun) => {
  while (true) {
    const result = iterator.next();
    if (result.done) {
      break;
    }
    fun(result.value);
  }
};
var map = (iterator, callback) => {
  return withHelpers(iterator).map(callback);
};
var filter = (iterator, predicate) => {
  return withHelpers(iterator).filter(predicate);
};
var take = (iterator, limit) => {
  return withHelpers(iterator).take(limit);
};
var drop = (iterator, count) => {
  return withHelpers(iterator).drop(count);
};
var flat_map = (iterator, callback) => {
  return withHelpers(iterator).flatMap(callback);
};
var reduce = (iterator, initial, callback) => {
  return withHelpers(iterator).reduce(callback, initial);
};
var some = (iterator, predicate) => {
  return withHelpers(iterator).some(predicate);
};
var every = (iterator, predicate) => {
  return withHelpers(iterator).every(predicate);
};
var find = (iterator, predicate) => {
  return toResult(withHelpers(iterator).find(predicate));
};
export {
  drop,
  every,
  filter,
  find,
  flat_map,
  for_,
  from_list,
  map,
  new_,
  next,
  next_with,
  reduce,
  return_,
  return_with,
  some,
  take,
  throw_,
  to_list,
  with_return,
  with_throw
};