}

    @Override
    public Optional<Project> getProject() {
        return Optional.ofNullable(session.getProject(delegate.getProject()));
    }

    @Override
    public Optional<MojoExecution> getMojoExecution() {
        return Optional.ofNullable(delegate.getMojoExecution()).map(me -> new DefaultMojoExecution(session, me));
    }

    @Override
    public Optional<Exception> getException() {

  public void testEmptiesFirst() {
    Optional<String> empty = Optional.empty();
    Optional<String> abc = Optional.of("abc");
    Optional<String> z = Optional.of("z");

    Comparator<Optional<String>> comparator = emptiesFirst(comparing(String::length));
    testComparator(comparator, empty, z, abc);

    // Just demonstrate that no explicit type parameter is required
    Comparator<Optional<String>> unused = emptiesFirst(naturalOrder());

     *
     * @return an {@link Optional} containing the boolean value {@code true} if specified, or empty
     */
    Optional<Boolean> force();

    /**
     * Should imply "yes" to all questions.
     *
     * @return an {@link Optional} containing the boolean value {@code true} if specified, or empty
     */
    Optional<Boolean> yes();

    /**

        // v1 == 0.
        .optional(defaultValue = 0),
      Adapters.INTEGER_AS_BIG_INTEGER,
      algorithmIdentifier,
      name,
      validity,
      name,
      subjectPublicKeyInfo,
      Adapters.BIT_STRING.withTag(tag = 1L).optional(),
      Adapters.BIT_STRING.withTag(tag = 2L).optional(),
      extension.asSequenceOf().withExplicitBox(tag = 3).optional(defaultValue = listOf()),
      decompose = {

            throw new LookupException(e);
        }
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type) {
        try {
            return Optional.of(container.lookup(type));
        } catch (ComponentLookupException e) {
            if (e.getCause() instanceof NoSuchElementException) {
                return Optional.empty();
            }
            throw new LookupException(e);
        }
    }

    /**
     * Performs a lookup for optional typed component.
     *
     * @param type The component type.
     * @return Optional carrying component or empty optional if no such component.
     * @param <T> The component type.
     * @throws LookupException if there is some provisioning related issue.
     */
    @Nonnull
    <T> Optional<T> lookupOptional(Class<T> type);

    /**

    }

    @Override
    public Optional<Path> rootDirectory() {
        return Optional.ofNullable(rootDirectory);
    }

    @Override
    public Optional<List<CoreExtensions>> coreExtensions() {
        return Optional.ofNullable(coreExtensions);
    }

    @Override
    public Optional<CIInfo> ciInfo() {
        return Optional.ofNullable(ciInfo);
    }

`typing`에는 `None`이 될 수 있음을 선언하는 축약형으로 `Optional`도 있습니다.

아주 개인적인 관점에서의 팁입니다:

- 🚨 `Optional[SomeType]` 사용은 피하세요
- 대신 ✨ **`Union[SomeType, None]`를 사용하세요** ✨.

둘은 동등하며 내부적으로도 같습니다. 하지만 단어 "optional"은 값이 선택 사항이라는 인상을 주는 반면, 실제 의미는 "값이 `None`이 될 수 있다"는 뜻입니다. 값이 선택 사항이 아니라 여전히 필수인 경우에도 그렇습니다.

`Union[SomeType, None]`가 의미를 더 명확하게 드러낸다고 생각합니다.

이는 단지 단어와 명칭의 문제입니다. 하지만 이런 단어가 여러분과 팀원이 코드를 어떻게 생각하는지에 영향을 줄 수 있습니다.

예를 들어, 다음 함수를 보세요:

```python

        when(options.all()).thenReturn(Optional.ofNullable(all));
        when(options.infer()).thenReturn(Optional.ofNullable(infer));
        when(options.model()).thenReturn(Optional.ofNullable(model));
        when(options.plugins()).thenReturn(Optional.ofNullable(plugins));
        when(options.modelVersion()).thenReturn(Optional.ofNullable(modelVersion));
        return options;
    }

    /**

@REM
@REM   JAVA_HOME           (Optional) Points to a Java installation.
@REM   MAVEN_BATCH_ECHO    (Optional) Set to 'on' to enable the echoing of the batch commands.
@REM   MAVEN_BATCH_PAUSE   (Optional) set to 'on' to wait for a key stroke before ending.
@REM   MAVEN_OPTS          (Optional) Java runtime options used when Maven is executed.
@REM   MAVEN_SKIP_RC       (Optional) Flag to disable loading of mavenrc files.