持久且不可变的 Java LinkedList

public record empty<t>() implements seqlist<t> {
}

public record cons<t>(t head, seqlist<t> tail) implements seqlist<t> {
}

public sealed interface seqlist<t> permits empty, cons {
  /**
   * creates an empty list.
   *
   * @param <t> the type of the elements
   * @return an empty list
   */
  static <t> seqlist<t> empty() {
    return new empty<>();
  }

  /**
   * creates a new list with the given elements. the complexity of this method is o(n) where n is
   * the number of elements.
   *
   * @param elements the elements to add
   * @param <t>      the type of the elements
   * @return a new list with the elements added
   */
  @safevarargs
  static <t> seqlist<t> of(t... elements) {
    seqlist<t> list = empty();
    for (int i = elements.length - 1; i >= 0; i--) {
      list = list.add(elements[i]);
    }
    return list;
  }

  /**
   * prepends the element to the list. the complexity of this method is o(1).
   *
   * @param element the element to add
   * @return a new list with the element prepended
   */
  default seqlist<t> add(t element) {
    return new cons<>(element, this);
  }
}

/**
   * removes the first occurrence of the element from the list. if the element is not found, the
   * list is returned as is. the complexity of this method is o(n) where n is the number of
   * elements. it uses structural sharing up to the element to remove. if the element is not found
   * the structural sharing is not utilized.
   *
   * @param element the element to remove
   * @return a new list with the element removed
   * @throws stackoverflowerror for infinite lists
   */
  default seqlist<t> remove(t element) {
    if (isempty()) {
      return this;
    }
    if (head().equals(element)) {
      return tail();
    }
    return new cons<>(head(), tail().remove(element));
  }

public record cons<t>(t head, seqlist<t> tail) implements seqlist<t> {

  @override
  public boolean isempty() {
    return false;
  }

  @override
  public optional<t> headoption() {
    return optional.ofnullable(head);
  }

  @override
  public optional<t> last() {
    if (tail.isempty()) {
      return optional.ofnullable(head);
    }
    return tail.last();
  }
}

public record empty<t>() implements seqlist<t> {

  @override
  public boolean isempty() {
    return true;
  }

  @override
  public t head() {
    throw new unsupportedoperationexception("head() called on empty list");
  }

  @override
  public optional<t> headoption() {
    return optional.empty();
  }

  @override
  public seqlist<t> tail() {
    throw new unsupportedoperationexception("tail() called on empty list");
  }

  @override
  public optional<t> last() {
    return optional.empty();
  }
}

/**
   * applies a map function to the elements of the list. the complexity of this method is o(n) where
   * n is the number of elements.
   * <b>it does not use structural sharing</b> as it requires advanced data structures to achieve
   * it.
   *
   * @param fn  the map function
   * @param <u> the type of the elements of the new list
   * @return a new list with the elements mapped
   * @throws stackoverflowerror for infinite lists
   */
  default <u> seqlist<u> map(function<? super t, ? extends u> fn) {
    if (isempty()) {
      return empty();
    }
    return new cons<>(fn.apply(head()), tail().map(fn));
  }

  /**
   * applies a flat map function to the elements of the list. the complexity of this method is o(n)
   * where n is the number of elements.
   * <b>it does not use structural sharing</b> as it requires advanced data structures to achieve
   * it.
   *
   * @param fn  the flat map function
   * @param <u> the type of the elements of the new list
   * @return a new list with the elements flat mapped
   * @throws stackoverflowerror for infinite lists
   */
  default <u> seqlist<u> flatmap(function<? super t, ? extends seqlist<u>> fn) {
    if (isempty()) {
      return empty();
    }
    seqlist<u> mappedhead = fn.apply(head());
    seqlist<u> newtail = tail().flatmap(fn);
    return concat(mappedhead, newtail);
  }

  /**
   * concatenates two lists. the complexity of this method is o(n) where n is the number of
   * elements.
   *
   * @param list1 the first list
   * @param list2 the second list
   * @param <t>   the type of the elements
   * @return a new list with the elements of the two lists concatenated
   * @throws stackoverflowerror for infinite lists
   */
  static <t> seqlist<t> concat(seqlist<t> list1, seqlist<t> list2) {
    if (list1.isempty()) {
      return list2;
    }
    return new cons<>(list1.head(), concat(list1.tail(), list2));
  }

seqlist<integer> list = seqlist.of(1, 2, 3, 4, 5, 6);
seqlist<double> updatedlist = list
   .filterout(number -> number % 2 == 0)
   .map(number -> math.pow(number, 2));

seqlist<string> list = seqlist.of("a", "b", "c", "d", "e");
seqlist<string> updatedlist = list
   .map(letter -> "prefix" + letter + "suffix");

seqlist<seqlist<integer>> list = seqlist.of(seqlist.of(1, 2), seqlist.of(3, 4), seqlist.of(5, 6));
seqlist<integer> updatedlist = list
   .flatmap(seqlist -> seqlist);

SeqList<Integer> list = SeqList.of(1, 2, 3, 4, 5, 6);
switch (list) {
  case Empty() -> {
    // do something
  }
  case Cons<Integer> cons -> {
    //do something else
  }
}