package main

type Iterator[T any] interface {
	Iterate()
}

type IteratorFunc[T any] func(fn func(T) bool)

func (f IteratorFunc[T]) Iterate() {
}

func FromIterator[T any](it Iterator[T]) {
	it.Iterate()
}

func Foo[T, R any]() {
	FromIterator[R](IteratorFunc[R](nil))
}

func main() {
	Foo[int, int]()

	f(fn)
}

type Stream[T any] struct {
	it Iterator[T]
}

func (s Stream[T]) Iterate(fn func(T) bool) {
	if s.it == nil {
		return
	}
	s.it.Iterate(fn)
}

func FromIterator[T any](it Iterator[T]) Stream[T] {
	return Stream[T]{it: it}
}

func (s Stream[T]) DropWhile(fn func(T) bool) Stream[T] {
	return Pipe[T, T](s, func(t T) (T, bool) {
		return t, true
	})
}

                long index = 0;

                @Override
                public boolean tryAdvance(Consumer<? super R> action) {
                  if (fromIterator.hasNext()) {
                    action.accept(function.apply(fromIterator.next(), index++));
                    return true;
                  }
                  return false;
                }
              },
              isParallel)

        return new Iterator<B>() {
          private final Iterator<? extends A> fromIterator = fromIterable.iterator();

          @Override
          public boolean hasNext() {
            return fromIterator.hasNext();
          }

          @Override
          public B next() {
            return convert(fromIterator.next());
          }

          @Override
          public void remove() {

        return new Iterator<B>() {
          private final Iterator<? extends A> fromIterator = fromIterable.iterator();

          @Override
          public boolean hasNext() {
            return fromIterator.hasNext();
          }

          @Override
          public B next() {
            return convert(fromIterator.next());
          }

          @Override
          public void remove() {

   * fromIterator}.
   *
   * <p>The returned iterator supports {@code remove()} if {@code fromIterator} does. After a
   * successful {@code remove()} call, {@code fromIterator} no longer contains the corresponding
   * element.
   */
  public static <F extends @Nullable Object, T extends @Nullable Object> Iterator<T> transform(
      Iterator<F> fromIterator, Function<? super F, ? extends T> function) {

   * fromIterator}.
   *
   * <p>The returned iterator supports {@code remove()} if {@code fromIterator} does. After a
   * successful {@code remove()} call, {@code fromIterator} no longer contains the corresponding
   * element.
   */
  public static <F extends @Nullable Object, T extends @Nullable Object> Iterator<T> transform(
      Iterator<F> fromIterator, Function<? super F, ? extends T> function) {