}

  public void testPresentInstances_allPresent() {
    List<Optional<String>> optionals =
        ImmutableList.of(Optional.of("a"), Optional.of("b"), Optional.of("c"));
    assertThat(Optional.presentInstances(optionals)).containsExactly("a", "b", "c").inOrder();
  }

  public void testPresentInstances_allAbsent() {
    List<Optional<Object>> optionals = ImmutableList.of(Optional.absent(), Optional.absent());

class ReleasedVersionsDetails(currentBaseVersion: GradleVersion, releasedVersionsFile: RegularFile) {
    val allPreviousVersions: List<GradleVersion>
    val mostRecentRelease: GradleVersion
    val mostRecentSnapshot: GradleVersion

    val allTestedVersions: List<GradleVersion>

    val mainTestedVersions: List<GradleVersion>
    val lowestInterestingVersion: GradleVersion = GradleVersion.version("0.8")

class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None
    tags: list[str] = []


@app.post("/items/", response_model=Item)
async def create_item(item: Item) -> Any:
    return item


@app.get("/items/", response_model=list[Item])
async def read_items() -> Any:
    return [
        {"name": "Portal Gun", "price": 42.0},

有些型別可以在方括號中接收「型別參數」，以定義其內部元素的型別，例如「字串的 list」可以宣告為 `list[str]`。

這些能接收型別參數的型別稱為「泛型（Generic types）」或「Generics」。

你可以將相同的內建型別用作泛型（使用方括號並在裡面放型別）：

* `list`
* `tuple`
* `set`
* `dict`

#### List { #list }

例如，讓我們定義一個變數是 `str` 的 `list`。

宣告變數，使用相同的冒號（`:`）語法。

型別填 `list`。

由於 list 是一種包含內部型別的型別，你要把內部型別放在方括號中：

   * high 32 bits of each long is the "prev" pointer, whereas the low 32 bits is the "succ" pointer
   * (pointing to the next entry in the linked list). The pointers in [size(), entries.length) are
   * all "null" (UNSET).
   *
   * <p>A node with "prev" pointer equal to {@code ENDPOINT} is the first node in the linked list,
   * and a node with "next" pointer equal to {@code ENDPOINT} is the last node.
   */

@app.get("/response_model_list_of_model-no_annotation", response_model=list[User])
def response_model_list_of_model_no_annotation():
    return [
        DBUser(name="John", surname="Doe", password_hash="secret"),
        DBUser(name="Jane", surname="Does", password_hash="secret2"),
    ]


@app.get("/no_response_model-annotation_list_of_model")
def no_response_model_annotation_list_of_model() -> list[User]:
    return [

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.lang.reflect.Method;
import org.junit.Ignore;

/**
 * Tests {@link java.util.List#hashCode}.
 *
 * @author George van den Driessche
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")

      return snapshot().toArray(array);
    }

    private List<Multiset.Entry<E>> snapshot() {
      List<Multiset.Entry<E>> list = newArrayListWithExpectedSize(size());
      // Not Iterables.addAll(list, this), because that'll forward right back here.
      Iterators.addAll(list, iterator());
      return list;
    }
  }

  /**
   * @serialData the ConcurrentMap of elements and their counts.

import com.google.common.collect.testing.Helpers;
import com.google.common.collect.testing.features.CollectionSize;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.SortedMap;
import org.junit.Ignore;

/**

package org.apache.maven.artifact.resolver.filter;

import java.util.List;

import org.apache.maven.artifact.Artifact;

/**
 * Filter to exclude from a list of artifact patterns.
 *
 * TODO I think this is equiv. to exclusion set filter in maven-core
 */
public class ExcludesArtifactFilter extends IncludesArtifactFilter {
    public ExcludesArtifactFilter(List<String> patterns) {
        super(patterns);
    }

    @Override