code: public final Iterable<ObjectType> getImplicitPrototypeChain() {
      final ObjectType self = this;
  
      return () ->
          new AbstractIterator<ObjectType>() {
  
            private ObjectType next = self; // We increment past this type before first access.
  
            @Override
            public ObjectType computeNext() {
              next = next.getImplicitPrototype();
              return (next != null) ? next : endOfData();
            }
          };
    }
docs: Returns a lazy, dynamic {@link Iterable} for the types forming the implicit prototype chain of
  this type.
  
  <p>The chain is iterated bottom to top; from the nearest ancestor to the most distant.
  Iteration stops when the next ancestor would be a {@code null} reference.
  
  <p>The created {@link Iterator}s will not reflect changes to the prototype chain of elements it
  has already iterated past, but will reflect those of upcoming elements. Neither the {@link
  Iterable} nor its {@link Iterator} support mutation.