*
 * <p>For example, to test {@link java.util.Collections#unmodifiableList(java.util.List)
 * Collections.unmodifiableList}'s iterator:
 *
 * {@snippet :
 * List<String> expectedElements =
 *     Arrays.asList("a", "b", "c", "d", "e");
 * List<String> actualElements =
 *     Collections.unmodifiableList(
 *         Arrays.asList("a", "b", "c", "d", "e"));

   *
   * {@snippet :
   * b ---- a ---- d
   * |      |
   * |      |
   * e ---- c ---- f
   * }
   */
  private static final SuccessorsFunction<Character> JAVADOC_GRAPH =
      createUndirectedGraph("ba", "ad", "be", "ac", "ec", "cf");

  /**
   * A diamond shaped directed graph (arrows going down):
   *
   * {@snippet :
   *   a
   *  / \
   * b   c
   *  \ /

import java.util.concurrent.TimeoutException;
import org.jspecify.annotations.Nullable;

/**
 * A {@link ListenableFuture} that supports fluent chains of operations. For example:
 *
 * {@snippet :
 * ListenableFuture<Boolean> adminIsLoggedIn =
 *     FluentFuture.from(usersDatabase.getAdminUser())
 *         .transform(User::getId, directExecutor())
 *         .transform(ActivityService::isLoggedIn, threadPool)

   * respective source streams. For example:
   *
   * {@snippet :
   * Streams.forEachPair(
   *   Stream.of("foo1", "foo2", "foo3"),
   *   Stream.of("bar1", "bar2"),
   *   (arg1, arg2) -> System.out.println(arg1 + ":" + arg2)
   * }
   *
   * <p>will print:
   *
   * {@snippet :
   * foo1:bar1
   * foo2:bar2
   * }
   *

/**
 * A sorted set of contiguous values in a given {@link DiscreteDomain}. Example:
 *
 * {@snippet :
 * ContiguousSet.create(Range.closed(5, 42), DiscreteDomain.integers())
 * }
 *
 * <p>Note that because bounded ranges over {@code int} and {@code long} values are so common, this
 * particular example can be written as just:
 *
 * {@snippet :
 * ContiguousSet.closed(5, 42)
 * }
 *

/**
 * A sorted set of contiguous values in a given {@link DiscreteDomain}. Example:
 *
 * {@snippet :
 * ContiguousSet.create(Range.closed(5, 42), DiscreteDomain.integers())
 * }
 *
 * <p>Note that because bounded ranges over {@code int} and {@code long} values are so common, this
 * particular example can be written as just:
 *
 * {@snippet :
 * ContiguousSet.closed(5, 42)
 * }
 *

 *
 * <p>Most implementations will only need to implement {@link #load}. Other methods may be
 * overridden as desired.
 *
 * <p>Usage example:
 *
 * {@snippet :
 * CacheLoader<Key, Graph> loader = new CacheLoader<Key, Graph>() {
 *   public Graph load(Key key) throws AnyException {
 *     return createExpensiveGraph(key);
 *   }
 * };

   * and not contents.
   *
   * <p>This is useful for implementing {@link Object#hashCode()}. For example, in an object that
   * has three properties, {@code x}, {@code y}, and {@code z}, one could write:
   *
   * {@snippet :
   * public int hashCode() {
   *   return Objects.hashCode(getX(), getY(), getZ());
   * }
   * }
   *
   * <p><b>Warning:</b> When a single object is supplied, the returned hash code does not equal the

   * respective source streams. For example:
   *
   * {@snippet :
   * Streams.forEachPair(
   *   Stream.of("foo1", "foo2", "foo3"),
   *   Stream.of("bar1", "bar2"),
   *   (arg1, arg2) -> System.out.println(arg1 + ":" + arg2)
   * }
   *
   * <p>will print:
   *
   * {@snippet :
   * foo1:bar1
   * foo2:bar2
   * }
   *

 * as a {@code List}:
 *
 * {@snippet :
 * ImmutableList<String> results =
 *     FluentIterable.from(database.getClientList())
 *         .filter(Client::isActiveInLastMonth)
 *         .transform(Object::toString)
 *         .limit(10)
 *         .toList();
 * }
 *
 * The approximate stream equivalent is:
 *
 * {@snippet :
 * List<String> results =
 *     database.getClientList()