Update to Java 21

[Luro02]

Description

Has some nice language features

[Luro02]

As an example for what will be possible: A common problem in the codebase is the null return value. When null is returned, it is easy to forget, which would result in a crash. Therefore, in most cases Optional is returned.

Optional is a pain to work with and it might take forever to be usable (https://mail.openjdk.org/pipermail/amber-spec-experts/2024-January/003976.html). In many parts of the code, you will therefore find a .orElse(null).

With Java 21 we can write a better Optional that is similar to what rust provides (Option<T>).

Here is the proof of concept implementation:

`Option.java`

import java.util.Iterator;
import java.util.function.Function;
import java.util.stream.Stream;

public sealed interface Option<T> extends Iterable<T> permits Some, None {
  static <T> Option<T> ofNullable(T value) {
      return value == null ? new None<>() : new Some<>(value);
  }

  default T unwrap() {
      return switch (this) {
          case Some<T> (var value) -> value;
          case None<T> ignored -> throw new IllegalStateException("Expected Some value, but got None.");
      };
  }

  default boolean isSome() {
      return this instanceof Some;
  }

  default <U> Option<U> map(Function<T, U> function) {
      return switch (this) {
          case Some<T>(var value) -> new Some<>(function.apply(value));
          case None<T> ignored -> new None<>();
      };
  }

  /**
   * Returns the value if it is present or null if it is not.
   *
   * @return the value or null
   */
  default T nullable() {
      return switch (this) {
          case Some<T>(var value) -> value;
          case None<T> ignored -> null;
      };
  }

  default Stream<T> stream() {
      return switch (this) {
          case Some<T>(var value) -> Stream.of(value);
          case None<T> ignored -> Stream.empty();
      };
  }

  @Override
  default Iterator<T> iterator() {
      return stream().iterator();
  }
}

`Some.java`

public record Some<T>(T value) implements Option<T> {
}

`None.java`

public record None<T>() implements Option<T> {
}