// f : A -> Collection<A>

static <A> ItIt<A> mapLike repeatFunctionReturningList_iterator(O f, A input, O... _) {

  final Set<A> seen = optParOr seen(_, () -> (Set) new HashSet);

  final Int max = cast optPar max(_);

  bool plusInput = boolPar plusInput(_); // return original input too?

  // Make pool of iterators

  final new LinkedList<Iterator<A>> pool;

  if (plusInput) pool.add(singletonIterator(input));

  else seen.add(input);

  pool.add(iterator((Iterable<A>) callF(f, input)));

  ret iteratorFromFunction(new F0<A> {

    int n = 0;

    public A get() {

      if (max != null && n >= max) null;

      while ping (!empty(pool)) {

        Iterator<A> it = first(pool);

        if (!it.hasNext()) continue with removeFirst(pool);

        // Get entry and check if seen already

        A entry = it.next();

        if (!seen.add(entry)) continue;

        // found new entry - return and schedule for further analysis

        Collection<A> newStuff = cast callF(f, entry);

        if (nempty(newStuff))

          pool.add(iterator(newStuff));

        ++n;

        ret entry;

      }

      null;

    }

  });

}