code: public final Optional<E> last() {
      // Iterables#getLast was inlined here so we don't have to throw/catch a NSEE
  
      // TODO(kevinb): Support a concurrently modified collection?
      Iterable<E> iterable = getDelegate();
      if (iterable instanceof List) {
        List<E> list = (List<E>) iterable;
        if (list.isEmpty()) {
          return Optional.absent();
        }
        return Optional.of(list.get(list.size() - 1));
      }
      Iterator<E> iterator = iterable.iterator();
      if (!iterator.hasNext()) {
        return Optional.absent();
      }
  
      /*
       * TODO(kevinb): consider whether this "optimization" is worthwhile. Users with SortedSets tend
       * to know they are SortedSets and probably would not call this method.
       */
      if (iterable instanceof SortedSet) {
        SortedSet<E> sortedSet = (SortedSet<E>) iterable;
        return Optional.of(sortedSet.last());
      }
  
      while (true) {
        E current = iterator.next();
        if (!iterator.hasNext()) {
          return Optional.of(current);
        }
      }
    }
docs: Returns an {@link Optional} containing the last element in this fluent iterable. If the
  iterable is empty, {@code Optional.absent()} is returned. If the underlying {@code iterable} is
  a {@link List} with {@link java.util.RandomAccess} support, then this operation is guaranteed
  to be {@code O(1)}.
  
  <p><b>{@code Stream} equivalent:</b> {@code stream.reduce((a, b) -> b)}.
  
  @throws NullPointerException if the last element is null; if this is a possibility, use {@link
  Iterables#getLast} instead.