}

// Unique returns whether the index is unique or not.
func (idx Index) Unique() (unique bool, ok bool) {
	return idx.UniqueValue.Bool, idx.UniqueValue.Valid
}

// Option return the optional attribute of the index
func (idx Index) Option() string {
	return idx.OptionValue

Sprich:

```Python
q: Union[str, None] = Query(default=None)
```

... macht den Parameter optional, mit dem Defaultwert `None`, genauso wie:

```Python
q: Union[str, None] = None
```

Und in Python 3.10 und darüber macht:

```Python
q: str | None = Query(default=None)
```

... den Parameter optional, mit dem Defaultwert `None`, genauso wie:

```Python
q: str | None = None
```

        private ActivationFrame nextFrame(String property) {
            return new ActivationFrame(property, Optional.empty());
        }

        private <P> ActivationFrame nextFrame(String property, Function<P, InputLocationTracker> child) {
            @SuppressWarnings("unchecked")
            final Optional<P> parent = (Optional<P>) stk.peek().parent;
            return new ActivationFrame(property, parent.map(child));
        }

    * `dict`의 키(key)는 `str`타입이다. (각 아이템의 이름(name))
    * `dict`의 값(value)는 `float`타입이다. (각 아이템의 가격(price))

#### `Optional`

`str`과 같이 타입을 선언할 때 `Optional`을 쓸 수도 있는데, "선택적(Optional)"이기때문에 `None`도 될 수 있습니다:

```Python hl_lines="1  4"
{!../../docs_src/python_types/tutorial009.py!}
```

`Optional[str]`을 `str` 대신 쓰게 되면, 특정 값이 실제로는 `None`이 될 수도 있는데 항상 `str`이라고 가정하는 상황에서 에디터가 에러를 찾게 도와줄 수 있습니다.

#### Generic(제네릭) 타입

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.graph.Graphs.checkNonNegative;

import com.google.common.annotations.Beta;
import com.google.common.base.Optional;
import com.google.errorprone.annotations.CanIgnoreReturnValue;

/**
 * A builder for constructing instances of {@link MutableValueGraph} or {@link ImmutableValueGraph}
 * with user-defined properties.
 *

    for (TestEnum constant : TestEnum.values()) {
      Optional<TestEnum> result = Enums.getIfPresent(shadowTestEnum, constant.name());
      assertThat(result).isPresent();
      shadowConstants.add(result.get());
    }
    assertEquals(ImmutableSet.<Object>copyOf(shadowTestEnum.getEnumConstants()), shadowConstants);
    Optional<TestEnum> result = Enums.getIfPresent(shadowTestEnum, "blibby");

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertThrows;

import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.hash.HashCode;
import com.google.common.hash.Hashing;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

							jcifs*;version="${osgi.pkg.version}",
						</Export-Package>
						<Private-Package />
						<Import-Package>
							javax.servlet*;resolution:=optional,
							com.sun.security.jgss;resolution:=optional,
							org.bouncycastle*;version="1.63",
							!jcifs.internal*,
							*
						</Import-Package>
					</instructions>
				</configuration>
			</plugin>
			<plugin>

from typing import Any, Dict, Optional, Sequence, Type, Union

from pydantic import BaseModel, create_model
from starlette.exceptions import HTTPException as StarletteHTTPException
from starlette.exceptions import WebSocketException as StarletteWebSocketException
from typing_extensions import Annotated, Doc


class HTTPException(StarletteHTTPException):
    """
    An HTTP exception you can raise in your own code to show errors to the client.

   *     network
   * @since 23.0
   */
  Optional<E> edgeConnecting(N nodeU, N nodeV);

  /**
   * Returns the single edge that directly connects {@code endpoints} (in the order, if any,
   * specified by {@code endpoints}), if one is present, or {@code Optional.empty()} if no such edge
   * exists.
   *
   * <p>If this network is directed, the endpoints must be ordered.