code: public static <F, T> List<T> transform(
        List<F> fromList, Function<? super F, ? extends T> function) {
      return (fromList instanceof RandomAccess)
          ? new TransformingRandomAccessList<F, T>(fromList, function)
          : new TransformingSequentialList<F, T>(fromList, function);
    }
docs: Returns a list that applies {@code function} to each element of {@code
  fromList}. The returned list is a transformed view of {@code fromList};
  changes to {@code fromList} will be reflected in the returned list and vice
  versa.
  
  <p>Since functions are not reversible, the transform is one-way and new
  items cannot be stored in the returned list. The {@code add},
  {@code addAll} and {@code set} methods are unsupported in the returned
  list.
  
  <p>The function is applied lazily, invoked when needed. This is necessary
  for the returned list to be a view, but it means that the function will be
  applied many times for bulk operations like {@link List#contains} and
  {@link List#hashCode}. For this to perform well, {@code function} should be
  fast. To avoid lazy evaluation when the returned list doesn't need to be a
  view, copy the returned list into a new list of your choosing.
  
  <p>If {@code fromList} implements {@link RandomAccess}, so will the
  returned list. The returned list is threadsafe if the supplied list and
  function are.
  
  <p>If only a {@code Collection} or {@code Iterable} input is available, use
  {@link Collections2#transform} or {@link Iterables#transform}.
  
  <p><b>Note:</b> serializing the returned list is implemented by serializing
  {@code fromList}, its contents, and {@code function} -- <i>not</i> by
  serializing the transformed values. This can lead to surprising behavior,
  so serializing the returned list is <b>not recommended</b>. Instead,
  copy the list using {@link ImmutableList#copyOf(Collection)} (for example),
  then serialize the copy. Other methods similar to this do not implement
  serialization at all for this reason.