Iterator

class RecentSearches(capacity: Int) : Iterable<String> {
    private val buffer = arrayOfNulls<String>(capacity)
    private var newest = -1
    var size = 0
        private set

    fun add(query: String) {
        newest = (newest + 1) % buffer.size
        buffer[newest] = query
        size = minOf(size + 1, buffer.size)
    }

    // Each call creates a fresh iterator with its own position
    override fun iterator(): Iterator<String> = object : Iterator<String> {
        private var step = 0
        override fun hasNext() = step < size
        override fun next(): String {
            if (!hasNext()) throw NoSuchElementException()
            val index = (newest - step + buffer.size) % buffer.size
            step++
            return buffer[index]!!
        }
    }
}

for (query in recent) println(query)                 // newest first
val suggestions = recent.filter { it.startsWith(text) }.take(5)

public final class RecentSearches implements Iterable<String> {
    private final String[] buffer;
    private int newest = -1;
    private int size = 0;

    public RecentSearches(int capacity) { buffer = new String[capacity]; }

    public void add(String query) {
        newest = (newest + 1) % buffer.length;
        buffer[newest] = query;
        size = Math.min(size + 1, buffer.length);
    }

    // Each call creates a fresh iterator with its own position
    @Override
    public Iterator<String> iterator() {
        return new Iterator<>() {
            private int step = 0;
            public boolean hasNext() { return step < size; }
            public String next() {
                if (!hasNext()) throw new NoSuchElementException();
                int index = (newest - step + buffer.length) % buffer.length;
                step++;
                return buffer[index];
            }
        };
    }
}

for (String query : recent) System.out.println(query);   // newest first

class RecentSearches implements Iterable<string> {
  private readonly buffer: (string | undefined)[];
  private newest = -1;
  private count = 0;

  constructor(capacity: number) { this.buffer = new Array(capacity); }

  add(query: string) {
    this.newest = (this.newest + 1) % this.buffer.length;
    this.buffer[this.newest] = query;
    this.count = Math.min(this.count + 1, this.buffer.length);
  }

  // A generator method: each call returns a fresh iterator
  *[Symbol.iterator](): Iterator<string> {
    for (let step = 0; step < this.count; step++) {
      const index = (this.newest - step + this.buffer.length) % this.buffer.length;
      yield this.buffer[index]!;
    }
  }
}

for (const query of recent) console.log(query);       // newest first
const all = [...recent];                               // spread works too

data class OrdersPage(val orders: List<Order>, val nextCursor: String?)

fun allOrders(api: OrdersApi): Flow<Order> = flow {
    var cursor: String? = null
    do {
        val page = api.orders(after = cursor)                  // suspend function
        page.orders.forEach { emit(it) }
        cursor = page.nextCursor
    } while (cursor != null)
}

val match = allOrders(api).firstOrNull { it.id == wanted }    // cancels the flow when found

public record OrdersPage(List<Order> orders, String nextCursor) {}

// A lazy Iterator that fetches the next page only when the current one is used up
public final class AllOrders implements Iterable<Order> {
    private final OrdersApi api;
    public AllOrders(OrdersApi api) { this.api = api; }

    @Override
    public Iterator<Order> iterator() {
        return new Iterator<>() {
            private Iterator<Order> current = Collections.emptyIterator();
            private String cursor = null;
            private boolean lastPage = false;

            public boolean hasNext() {
                while (!current.hasNext() && !lastPage) {
                    OrdersPage page = api.orders(cursor);
                    current = page.orders().iterator();
                    cursor = page.nextCursor();
                    lastPage = cursor == null;
                }
                return current.hasNext();
            }

            public Order next() {
                if (!hasNext()) throw new NoSuchElementException();
                return current.next();
            }
        };
    }
}

Optional<Order> match = StreamSupport.stream(new AllOrders(api).spliterator(), false)
        .filter(o -> o.id().equals(wanted))
        .findFirst();                                         // stops fetching when found

interface OrdersPage { orders: Order[]; nextCursor: string | null }

async function* allOrders(api: OrdersApi): AsyncGenerator<Order> {
  let cursor: string | null = null;
  do {
    const page: OrdersPage = await api.orders(cursor);
    yield* page.orders;
    cursor = page.nextCursor;
  } while (cursor !== null);
}

for await (const order of allOrders(api)) {
  if (order.id === wanted) break;                             // later pages are never fetched
}