*     negated or reversed, undo the negation or reversal and use {@link #compareTrueFirst}.
   * @since 19.0
   */
  @InlineMe(replacement = "this.compareFalseFirst(left, right)")
  @Deprecated
  public final ComparisonChain compare(Boolean left, Boolean right) {
    return compareFalseFirst(left, right);
  }

  /**

final class CompactLinkedHashMap<K extends @Nullable Object, V extends @Nullable Object>
    extends CompactHashMap<K, V> {
  // TODO(lowasser): implement removeEldestEntry so this can be used as a drop-in replacement

  /** Creates an empty {@code CompactLinkedHashMap} instance. */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      CompactLinkedHashMap<K, V> create() {
    return new CompactLinkedHashMap<>();

## Récapitulatif, étape par étape

### Étape 1 : import `FastAPI`

{* ../../docs_src/first_steps/tutorial001.py hl[1] *}

`FastAPI` est une classe Python qui fournit toutes les fonctionnalités nécessaires au lancement de votre API.

/// note | Détails techniques

`FastAPI` est une classe héritant directement de `Starlette`.

   * Returns a hash code for {@code value}; obsolete alternative to {@link
   * Character#hashCode(char)}.
   *
   * @param value a primitive {@code char} value
   * @return a hash code for the value
   */
  @InlineMe(replacement = "Character.hashCode(value)")
  @InlineMeValidationDisabled(
      "The hash code of a char is the int version of the char itself, so it's simplest to return"
          + " that.")
  public static int hashCode(char value) {

   * overflow a {@code long}, so you can just write {@code (long) a + b}.
   *
   * @throws ArithmeticException if {@code a + b} overflows in signed {@code long} arithmetic
   */
  @InlineMe(replacement = "Math.addExact(a, b)")
  public static long checkedAdd(long a, long b) {
    return Math.addExact(a, b);
  }

  /**
   * Returns the difference of {@code a} and {@code b}, provided it does not overflow.

// means that erroneous UTF-8 encodings translate to U+FFFD = "\xef\xbf\xbd".
// Because of the Scan interface, this makes it impossible for the client to
// distinguish correctly encoded replacement runes from encoding errors.
func ScanRunes(data []byte, atEOF bool) (advance int, token []byte, err error) {
	if atEOF && len(data) == 0 {
		return 0, nil, nil
	}

	// Fast path 1: ASCII.

  /**
   * Returns a hash code for {@code value}; obsolete alternative to {@link Integer#hashCode(int)}.
   *
   * @param value a primitive {@code int} value
   * @return a hash code for the value
   */
  @InlineMe(replacement = "Integer.hashCode(value)")
  @InlineMeValidationDisabled(
      "The hash code of a int is the int itself, so it's simplest to return that.")
  public static int hashCode(int value) {
    return value;
  }

  /**

 */
@GwtIncompatible // not worth using in GWT for now
class CompactHashMap<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMap<K, V> implements Serializable {
  /*
   * TODO: Make this a drop-in replacement for j.u. versions, actually drop them in, and test the
   * world. Figure out what sort of space-time tradeoff we're actually going to get here with the

  /**
   * Returns a hash code for {@code value}; obsolete alternative to {@link Long#hashCode(long)}.
   *
   * @param value a primitive {@code long} value
   * @return a hash code for the value
   */
  @InlineMe(replacement = "Long.hashCode(value)")
  public static int hashCode(long value) {
    return Long.hashCode(value);
  }

  /**
   * Compares the two specified {@code long} values. The sign of the value returned is the same as

 * the reference is "absent"); it is never said to "contain {@code null}".
 *
 * <p>A non-null {@code Optional<T>} reference can be used as a replacement for a nullable {@code T}
 * reference. It allows you to represent "a {@code T} that must be present" and a "a {@code T} that
 * might be absent" as two distinct types in your program, which can aid clarity.
 *