Package net.tangly.commons.lang.functional

Interface LList<T>

Type Parameters:

T - type of the list items

All Known Implementing Classes:

LList.ImmutableList, LList.Nil

public sealed interface LList<T>
permits LList.Nil<T>, LList.ImmutableList<T>

Defines an immutable list structure as used in Lisp, Scheme, or Clojure. The fundamental data structure in many functional languages is the immutable list. It is constructed from two building blocks:

Nil

The empty list

Cons

A cell containing an element also known as first; and a pointer to the rest of the list also known as tail.

The term cons comes from functional programming language Lisp or Scheme. These kind of data structures are called persistent data structures. Since the data structure is immutable, one might think that a lot of memory would be consumed since a new list would be created when we try to perform various operations on list. On the contrary, these kind of data structures allow structural sharing by sharing nodes. A persistent data structure does preserve the previous version of itself when being modified and is therefore effectively immutable. Fully persistent data structures allow both updates and queries on any version.

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static final record	LList.ImmutableList<T>
static class	LList.LListSplitIterator<T>	Define a split iterator for the immutable persistent list structure.
static final class	LList.Nil<T>

Method Summary

Modifier and Type	Method	Description
default LList<T>	append(@NotNull LList<T> list)
static <T> LList<T>	cons(T first, @NotNull LList<T> tail)	Return a new immutable list with a new item inserted in the front.
default LList<T>	copy()
T	first()	Return the first of the list.
boolean	isEmpty()	Return true if the list is empty otherwise false.
default int	length()
static <T> LList<T>	list(T... items)
default <R> LList<R>	map(@NotNull Function<T,? extends R> function)
static <T> LList<T>	nil()	Return an empty list
LList<T>	rest()	Return the tail of the list.
default Stream<T>	stream()

Method Details

nil

static <T> LList<T> nil()

Return an empty list

Type Parameters:

T - Type of the items in the list

Returns:

empty list

cons

static <T> LList<T> cons(@NotNull
 T first,
 @NotNull
 @NotNull LList<T> tail)

Return a new immutable list with a new item inserted in the front.

Type Parameters:

T - Type of the items in the list

Parameters:

first - new item to add at the beginning of the list

tail - list to which the item is added

Returns:

immutable list with the new item at the beginning

list

@SafeVarargs
static <T> LList<T> list(@NotNull
 T... items)

isEmpty

boolean isEmpty()

Return true if the list is empty otherwise false.

Returns:

true if the list is empty

first

T first()

Return the first of the list. Is equivalent to the car Scheme operation.

Returns:

first item of the list

rest

LList<T> rest()

Return the tail of the list. Is equivalent to the cdr Scheme operation.

Returns:

tail of the list

length

default int length()

copy

default LList<T> copy()

append

default LList<T> append(@NotNull
 @NotNull LList<T> list)

map

default <R> LList<R> map(@NotNull
 @NotNull Function<T,? extends R> function)

stream

default Stream<T> stream()