code: public static <F, T> Iterable<T> transform(
        final Iterable<F> fromIterable, final Function<? super F, ? extends T> function) {
      checkNotNull(fromIterable);
      checkNotNull(function);
      return new FluentIterable<T>() {
        @Override
        public Iterator<T> iterator() {
          return Iterators.transform(fromIterable.iterator(), function);
        }
  
        @Override
        public void forEach(Consumer<? super T> action) {
          checkNotNull(action);
          fromIterable.forEach((F f) -> action.accept(function.apply(f)));
        }
  
        @Override
        public Spliterator<T> spliterator() {
          return CollectSpliterators.map(fromIterable.spliterator(), function);
        }
      };
    }
docs: Returns a view containing the result of applying {@code function} to each element of {@code
  fromIterable}.
  
  <p>The returned iterable's iterator supports {@code remove()} if {@code fromIterable}'s
  iterator does. After a successful {@code remove()} call, {@code fromIterable} no longer
  contains the corresponding element.
  
  <p>If the input {@code Iterable} is known to be a {@code List} or other {@code Collection},
  consider {@link Lists#transform} and {@link Collections2#transform}.
  
  <p><b>{@code Stream} equivalent:</b> {@link Stream#map}