Package io.vavr.collection

Class Array<T>

java.lang.Object
io.vavr.collection.Array<T>
Type Parameters:
T - Component type
All Implemented Interfaces:
Foldable<T>, IndexedSeq<T>, Seq<T>, Traversable<T>, Function1<Integer,T>, PartialFunction<Integer,T>, Value<T>, Serializable, Iterable<T>, Function<Integer,T>
public final class Array<T> extends Object implements IndexedSeq<T>, Serializable
Array is an immutable Traversable wrapper for Object[] containing elements of type T.
Author:
Ruslan Sennov, Daniel Dietrich
See Also:

  • Method Details

    • collector

      public static <T> Collector<T,ArrayList<T>,Array<T>> collector()
      Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a Array.
      Type Parameters:
      T - Component type of the Array.
      Returns:
      A Array Collector.

    • empty

      public static <T> Array<T> empty()
      Returns the empty Array.
      Type Parameters:
      T - Component type
      Returns:
      The empty Array.

    • narrow

      public static <T> Array<T> narrow(Array<? extends T> array)
      Narrows a Array<? extends T> to Array<T> via a type-safe cast. Safe here because the array is immutable and no elements can be added that would violate the type (covariance)
      Type Parameters:
      T - the target element type
      Parameters:
      array - the array to narrow
      Returns:
      the same array viewed as Array<T>

    • of

      public static <T> Array<T> of(T element)
      Returns a singleton Array, i.e. a Array of one element.
      Type Parameters:
      T - The component type
      Parameters:
      element - An element.
      Returns:
      A new Array instance containing the given element

    • of

      @SafeVarargs public static <T> Array<T> of(T @NonNull ... elements)
      Creates an Array of the given elements.
      Type Parameters:
      T - Component type of the Array.
      Parameters:
      elements - Zero or more elements.
      Returns:
      An Array containing the given elements in the same order.
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static <T> Array<T> ofAll(@NonNull Iterable<? extends T> elements)
      Creates an Array of the given elements.

      If the iteration order of the given elements is stable, the resulting Array will maintain that same order.

      Type Parameters:
      T - Component type of the Array.
      Parameters:
      elements - An Iterable of elements.
      Returns:
      An Array containing the given elements in the same order.
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static <T> Array<T> ofAll(Stream<? extends T> javaStream)
      Creates an Array that contains the elements of the given Stream.
      Type Parameters:
      T - Component type of the Stream.
      Parameters:
      javaStream - A Stream
      Returns:
      An Array containing the given elements in the same order.

    • ofAll

      public static Array<Boolean> ofAll(boolean @NonNull ... elements)
      Creates an Array from boolean values.
      Parameters:
      elements - boolean values
      Returns:
      A new Array of Boolean values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static Array<Byte> ofAll(byte @NonNull ... elements)
      Creates an Array from byte values.
      Parameters:
      elements - byte values
      Returns:
      A new Array of Byte values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static Array<Character> ofAll(char @NonNull ... elements)
      Creates an Array from char values.
      Parameters:
      elements - char values
      Returns:
      A new Array of Character values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static Array<Double> ofAll(double @NonNull ... elements)
      Creates an Array from double values.
      Parameters:
      elements - double values
      Returns:
      A new Array of Double values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static Array<Float> ofAll(float @NonNull ... elements)
      Creates an Array from float values.
      Parameters:
      elements - float values
      Returns:
      A new Array of Float values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static Array<Integer> ofAll(int @NonNull ... elements)
      Creates an Array from int values.
      Parameters:
      elements - int values
      Returns:
      A new Array of Integer values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static Array<Long> ofAll(long @NonNull ... elements)
      Creates an Array from long values.
      Parameters:
      elements - long values
      Returns:
      A new Array of Long values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static Array<Short> ofAll(short @NonNull ... elements)
      Creates an Array from short values.
      Parameters:
      elements - short values
      Returns:
      A new Array of Short values
      Throws:
      NullPointerException - if elements is null

    • tabulate

      public static <T> Array<T> tabulate(int n, @NonNull Function<? super Integer,? extends T> f)
      Returns an Array containing n values of a given Function f over a range of integer values from 0 to n - 1.
      Type Parameters:
      T - Component type of the Array
      Parameters:
      n - The number of elements in the Array
      f - The Function computing element values
      Returns:
      An Array consisting of elements f(0),f(1), ..., f(n - 1)
      Throws:
      NullPointerException - if f is null

    • fill

      public static <T> Array<T> fill(int n, @NonNull Supplier<? extends T> s)
      Returns an Array containing n values supplied by a given Supplier s.
      Type Parameters:
      T - Component type of the Array
      Parameters:
      n - The number of elements in the Array
      s - The Supplier computing element values
      Returns:
      An Array of size n, where each element contains the result supplied by s.
      Throws:
      NullPointerException - if s is null

    • fill

      public static <T> Array<T> fill(int n, T element)
      Returns an Array containing n times the given element
      Type Parameters:
      T - Component type of the Array
      Parameters:
      n - The number of elements in the Array
      element - The element
      Returns:
      An Array of size n, where each element is the given element.

    • range

      public static Array<Character> range(char from, char toExclusive)
      Creates an Array of char numbers starting from from, extending to toExclusive - 1.

      Examples: 

       
 Array.range('a', 'a')  // = Array()
 Array.range('c', 'a')  // = Array()
 Array.range('a', 'd')  // = Array('a', 'b', 'c')
      Parameters:
      from - the first char
      toExclusive - the last char + 1
      Returns:
      a range of char values as specified or the empty range if from >= toExclusive

    • rangeBy

      public static Array<Character> rangeBy(char from, char toExclusive, int step)
      Creates an Array of char numbers starting from from, extending to toExclusive - 1, with step.

      Examples: 

       
 Array.rangeBy('a', 'c', 1)  // = Array('a', 'b')
 Array.rangeBy('a', 'd', 2)  // = Array('a', 'c')
 Array.rangeBy('d', 'a', -2) // = Array('d', 'b')
 Array.rangeBy('d', 'a', 2)  // = Array()
      Parameters:
      from - the first char
      toExclusive - the last char + 1
      step - the step
      Returns:
      a range of char values as specified or the empty range if
      from >= toInclusive and step > 0 or
      from <= toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • rangeBy

      @GwtIncompatible public static Array<Double> rangeBy(double from, double toExclusive, double step)
      Creates an Array of double numbers starting from from, extending to toExclusive - 1, with step.

      Examples: 

       
 Array.rangeBy(1.0, 3.0, 1.0)  // = Array(1.0, 2.0)
 Array.rangeBy(1.0, 4.0, 2.0)  // = Array(1.0, 3.0)
 Array.rangeBy(4.0, 1.0, -2.0) // = Array(4.0, 2.0)
 Array.rangeBy(4.0, 1.0, 2.0)  // = Array()
      Parameters:
      from - the first double
      toExclusive - the last double + 1
      step - the step
      Returns:
      a range of double values as specified or the empty range if
      from >= toInclusive and step > 0 or
      from <= toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • range

      public static Array<Integer> range(int from, int toExclusive)
      Creates an Array of int numbers starting from from, extending to toExclusive - 1.

      Examples: 

       
 Array.range(0, 0)  // = Array()
 Array.range(2, 0)  // = Array()
 Array.range(-2, 2) // = Array(-2, -1, 0, 1)
      Parameters:
      from - the first number
      toExclusive - the last number + 1
      Returns:
      a range of int values as specified or the empty range if from >= toExclusive

    • rangeBy

      public static Array<Integer> rangeBy(int from, int toExclusive, int step)
      Creates an Array of int numbers starting from from, extending to toExclusive - 1, with step.

      Examples: 

       
 Array.rangeBy(1, 3, 1)  // = Array(1, 2)
 Array.rangeBy(1, 4, 2)  // = Array(1, 3)
 Array.rangeBy(4, 1, -2) // = Array(4, 2)
 Array.rangeBy(4, 1, 2)  // = Array()
      Parameters:
      from - the first number
      toExclusive - the last number + 1
      step - the step
      Returns:
      a range of long values as specified or the empty range if
      from >= toInclusive and step > 0 or
      from <= toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • range

      public static Array<Long> range(long from, long toExclusive)
      Creates an Array of long numbers starting from from, extending to toExclusive - 1.

      Examples: 

       
 Array.range(0L, 0L)  // = Array()
 Array.range(2L, 0L)  // = Array()
 Array.range(-2L, 2L) // = Array(-2L, -1L, 0L, 1L)
      Parameters:
      from - the first number
      toExclusive - the last number + 1
      Returns:
      a range of long values as specified or the empty range if from >= toExclusive

    • rangeBy

      public static Array<Long> rangeBy(long from, long toExclusive, long step)
      Creates an Array of long numbers starting from from, extending to toExclusive - 1, with step.

      Examples: 

       
 Array.rangeBy(1L, 3L, 1L)  // = Array(1L, 2L)
 Array.rangeBy(1L, 4L, 2L)  // = Array(1L, 3L)
 Array.rangeBy(4L, 1L, -2L) // = Array(4L, 2L)
 Array.rangeBy(4L, 1L, 2L)  // = Array()
      Parameters:
      from - the first number
      toExclusive - the last number + 1
      step - the step
      Returns:
      a range of long values as specified or the empty range if
      from >= toInclusive and step > 0 or
      from <= toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • rangeClosed

      public static Array<Character> rangeClosed(char from, char toInclusive)
      Creates an Array of char numbers starting from from, extending to toInclusive.

      Examples: 

       
 Array.rangeClosed('a', 'a')  // = Array('a')
 Array.rangeClosed('c', 'a')  // = Array()
 Array.rangeClosed('a', 'c')  // = Array('a', 'b', 'c')
      Parameters:
      from - the first char
      toInclusive - the last char
      Returns:
      a range of char values as specified or the empty range if from > toInclusive

    • rangeClosedBy

      public static Array<Character> rangeClosedBy(char from, char toInclusive, int step)
      Creates an Array of char numbers starting from from, extending to toInclusive, with step.

      Examples: 

       
 Array.rangeClosedBy('a', 'c', 1)  // = Array('a', 'b', 'c')
 Array.rangeClosedBy('a', 'd', 2)  // = Array('a', 'c')
 Array.rangeClosedBy('d', 'a', -2) // = Array('d', 'b')
 Array.rangeClosedBy('d', 'a', 2)  // = Array()
      Parameters:
      from - the first char
      toInclusive - the last char
      step - the step
      Returns:
      a range of char values as specified or the empty range if
      from > toInclusive and step > 0 or
      from < toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • rangeClosedBy

      @GwtIncompatible public static Array<Double> rangeClosedBy(double from, double toInclusive, double step)
      Creates an Array of double numbers starting from from, extending to toInclusive, with step.

      Examples: 

       
 Array.rangeClosedBy(1.0, 3.0, 1.0)  // = Array(1.0, 2.0, 3.0)
 Array.rangeClosedBy(1.0, 4.0, 2.0)  // = Array(1.0, 3.0)
 Array.rangeClosedBy(4.0, 1.0, -2.0) // = Array(4.0, 2.0)
 Array.rangeClosedBy(4.0, 1.0, 2.0)  // = Array()
      Parameters:
      from - the first double
      toInclusive - the last double
      step - the step
      Returns:
      a range of double values as specified or the empty range if
      from > toInclusive and step > 0 or
      from < toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • rangeClosed

      public static Array<Integer> rangeClosed(int from, int toInclusive)
      Creates an Array of int numbers starting from from, extending to toInclusive.

      Examples: 

       
 Array.rangeClosed(0, 0)  // = Array(0)
 Array.rangeClosed(2, 0)  // = Array()
 Array.rangeClosed(-2, 2) // = Array(-2, -1, 0, 1, 2)
      Parameters:
      from - the first number
      toInclusive - the last number
      Returns:
      a range of int values as specified or the empty range if from > toInclusive

    • rangeClosedBy

      public static Array<Integer> rangeClosedBy(int from, int toInclusive, int step)
      Creates an Array of int numbers starting from from, extending to toInclusive, with step.

      Examples: 

       
 Array.rangeClosedBy(1, 3, 1)  // = Array(1, 2, 3)
 Array.rangeClosedBy(1, 4, 2)  // = Array(1, 3)
 Array.rangeClosedBy(4, 1, -2) // = Array(4, 2)
 Array.rangeClosedBy(4, 1, 2)  // = Array()
      Parameters:
      from - the first number
      toInclusive - the last number
      step - the step
      Returns:
      a range of int values as specified or the empty range if
      from > toInclusive and step > 0 or
      from < toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • rangeClosed

      public static Array<Long> rangeClosed(long from, long toInclusive)
      Creates an Array of long numbers starting from from, extending to toInclusive.

      Examples: 

       
 Array.rangeClosed(0L, 0L)  // = Array(0L)
 Array.rangeClosed(2L, 0L)  // = Array()
 Array.rangeClosed(-2L, 2L) // = Array(-2L, -1L, 0L, 1L, 2L)
      Parameters:
      from - the first number
      toInclusive - the last number
      Returns:
      a range of long values as specified or the empty range if from > toInclusive

    • rangeClosedBy

      public static Array<Long> rangeClosedBy(long from, long toInclusive, long step)
      Creates an Array of long numbers starting from from, extending to toInclusive, with step.

      Examples: 

       
 Array.rangeClosedBy(1L, 3L, 1L)  // = Array(1L, 2L, 3L)
 Array.rangeClosedBy(1L, 4L, 2L)  // = Array(1L, 3L)
 Array.rangeClosedBy(4L, 1L, -2L) // = Array(4L, 2L)
 Array.rangeClosedBy(4L, 1L, 2L)  // = Array()
      Parameters:
      from - the first number
      toInclusive - the last number
      step - the step
      Returns:
      a range of int values as specified or the empty range if
      from > toInclusive and step > 0 or
      from < toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • unfoldRight

      public static <T, U> Array<U> unfoldRight(T seed, Function<? super T,Option<Tuple2<? extends U,? extends T>>> f)
      Creates an Array from a seed value and a function. The function takes the seed at first. The function should return None when it's done generating the Array, otherwise Some Tuple of the element for the next call and the value to add to the resulting Array.

      Example: 

       
 Array.unfoldRight(10, x -> x == 0
             ? Option.none()
             : Option.of(new Tuple2<gt;(x, x-1)));
 // Array(10, 9, 8, 7, 6, 5, 4, 3, 2, 1))
      Type Parameters:
      T - type of seeds
      U - type of unfolded values
      Parameters:
      seed - the start value for the iteration
      f - the function to get the next step of the iteration
      Returns:
      an Array with the values built up by the iteration
      Throws:
      NullPointerException - if f is null

    • unfoldLeft

      public static <T, U> Array<U> unfoldLeft(T seed, Function<? super T,Option<Tuple2<? extends T,? extends U>>> f)
      Creates an Array from a seed value and a function. The function takes the seed at first. The function should return None when it's done generating the list, otherwise Some Tuple of the value to add to the resulting list and the element for the next call.

      Example: 

       
 Array.unfoldLeft(10, x -> x == 0
             ? Option.none()
             : Option.of(new Tuple2<gt;(x-1, x)));
 // Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
      Type Parameters:
      T - type of seeds
      U - type of unfolded values
      Parameters:
      seed - the start value for the iteration
      f - the function to get the next step of the iteration
      Returns:
      an Array with the values built up by the iteration
      Throws:
      NullPointerException - if f is null

    • unfold

      public static <T> Array<T> unfold(T seed, Function<? super T,Option<Tuple2<? extends T,? extends T>>> f)
      Creates an Array from a seed value and a function. The function takes the seed at first. The function should return None when it's done generating the list, otherwise Some Tuple of the value to add to the resulting list and the element for the next call.

      Example: 

       
 Array.unfold(10, x -> x == 0
             ? Option.none()
             : Option.of(new Tuple2<gt;(x-1, x)));
 // Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
      Type Parameters:
      T - type of seeds and unfolded values
      Parameters:
      seed - the start value for the iteration
      f - the function to get the next step of the iteration
      Returns:
      an Array with the values built up by the iteration
      Throws:
      NullPointerException - if f is null

    • append

      public Array<T> append(T element)
      Description copied from interface: Seq
      Returns a new sequence with the given element appended at the end.
      Specified by:
      append in interface IndexedSeq<T>
      Specified by:
      append in interface Seq<T>
      Parameters:
      element - the element to append
      Returns:
      a new Seq containing all elements of this sequence followed by the given element

    • appendAll

      public Array<T> appendAll(@NonNull Iterable<? extends T> elements)
      Description copied from interface: Seq
      Returns a new sequence with all elements from the given Iterable appended at the end of this sequence.
      Specified by:
      appendAll in interface IndexedSeq<T>
      Specified by:
      appendAll in interface Seq<T>
      Parameters:
      elements - the elements to append; must not be null
      Returns:
      a new Seq containing all elements of this sequence followed by the given elements

    • asJava

      @GwtIncompatible public List<T> asJava()
      Description copied from interface: Seq
      Returns an immutable List view of this Seq. Any attempt to modify the view (e.g., via mutator methods) will throw UnsupportedOperationException at runtime.

      This is a view, not a copy. Compared to conversion methods like toJava*():

      • Creating the view is O(1) (constant time), whereas conversions take O(n), with n = collection size.
      • Operations on the view have the same performance characteristics as the underlying persistent Vavr collection, while converted collections behave like standard Java collections.

      Note: the immutable Java list view throws UnsupportedOperationException before checking method arguments, which may differ from standard Java behavior.

      Specified by:
      asJava in interface Seq<T>
      Returns:
      an immutable List view of this sequence

    • asJava

      @GwtIncompatible public Array<T> asJava(@NonNull Consumer<? super List<T>> action)
      Description copied from interface: Seq
      Creates an immutable List view of this Seq and passes it to the given action.

      The view is immutable: any attempt to modify it will throw UnsupportedOperationException at runtime.

      Specified by:
      asJava in interface IndexedSeq<T>
      Specified by:
      asJava in interface Seq<T>
      Parameters:
      action - a side-effecting operation that receives an immutable java.util.List view
      Returns:
      this sequence
      See Also:

    • asJavaMutable

      @GwtIncompatible public List<T> asJavaMutable()
      Description copied from interface: Seq
      Returns a mutable List view of this Seq. All standard mutator methods of the List interface are supported and modify the underlying view.

      Unlike Seq.asJava(), this view allows modifications, but the performance characteristics correspond to the underlying persistent Vavr collection.

      Specified by:
      asJavaMutable in interface Seq<T>
      Returns:
      a mutable List view of this sequence
      See Also:

    • asJavaMutable

      @GwtIncompatible public Array<T> asJavaMutable(@NonNull Consumer<? super List<T>> action)
      Description copied from interface: Seq
      Creates a mutable List view of this Seq and passes it to the given action.

      The view supports all standard mutator methods. The result of the action determines what is returned:

      • If only read operations are performed, this instance is returned.
      • If any write operations are performed, a new Seq reflecting those changes is returned.
      Specified by:
      asJavaMutable in interface IndexedSeq<T>
      Specified by:
      asJavaMutable in interface Seq<T>
      Parameters:
      action - a side-effecting operation that receives a mutable java.util.List view
      Returns:
      this sequence or a new sequence reflecting modifications made through the view
      See Also:

    • collect

      public <R> Array<R> collect(@NonNull PartialFunction<? super T,? extends R> partialFunction)
      Description copied from interface: Traversable
      Applies a PartialFunction to all elements that are defined for it and collects the results.

      For each element in iteration order, the function is first tested: 

      
 partialFunction.isDefinedAt(element)
      If true, the element is mapped to type R: 
      
 R newElement = partialFunction.apply(element)

      Note: If this Traversable is ordered (i.e., extends Ordered), the caller must ensure that the resulting elements are comparable (i.e., implement Comparable).

      Specified by:
      collect in interface IndexedSeq<T>
      Specified by:
      collect in interface Seq<T>
      Specified by:
      collect in interface Traversable<T>
      Type Parameters:
      R - the type of elements in the resulting Traversable
      Parameters:
      partialFunction - a function that may not be defined for all elements of this traversable
      Returns:
      a new Traversable containing the results of applying the partial function

    • hasDefiniteSize

      public boolean hasDefiniteSize()
      Description copied from interface: Traversable
      Indicates whether this Traversable has a known finite size.

      This should typically be implemented by concrete classes, not interfaces.

      Specified by:
      hasDefiniteSize in interface Traversable<T>
      Returns:
      true if the number of elements is finite and known, false otherwise.

    • isAsync

      public boolean isAsync()
      An Array is computed synchronously.
      Specified by:
      isAsync in interface Value<T>
      Returns:
      false

    • isLazy

      public boolean isLazy()
      An Array is computed eagerly.
      Specified by:
      isLazy in interface Value<T>
      Returns:
      false

    • isTraversableAgain

      public boolean isTraversableAgain()
      Description copied from interface: Traversable
      Checks if this Traversable can be traversed multiple times without side effects.

      Implementations should provide the correct behavior; this is not meant for interfaces alone.

      Specified by:
      isTraversableAgain in interface Traversable<T>
      Returns:
      true if this Traversable is guaranteed to be repeatably traversable, false otherwise

    • iterator

      public @NonNull Iterator<T> iterator()
      Description copied from interface: Traversable
      Returns an iterator over the elements of this Traversable, implemented via Traversable.head() and Traversable.tail(). Subclasses may override for a more efficient implementation.
      Specified by:
      iterator in interface Iterable<T>
      Specified by:
      iterator in interface Traversable<T>
      Specified by:
      iterator in interface Value<T>
      Returns:
      a new Iterator over the elements of this Traversable

    • combinations

      public Array<Array<T>> combinations()
      Description copied from interface: Seq
      Returns a sequence containing all combinations of elements from this sequence, for all sizes from 0 to length().

      Examples: 

       
 [].combinations() = [[]]

 [1,2,3].combinations() = [
   [],                  // k = 0
   [1], [2], [3],       // k = 1
   [1,2], [1,3], [2,3], // k = 2
   [1,2,3]              // k = 3
 ]
      Specified by:
      combinations in interface IndexedSeq<T>
      Specified by:
      combinations in interface Seq<T>
      Returns:
      a sequence of sequences representing all combinations of this sequence's elements

    • combinations

      public Array<Array<T>> combinations(int k)
      Description copied from interface: Seq
      Returns all subsets of this sequence containing exactly k distinct elements, i.e., the k-combinations of this sequence.
      Specified by:
      combinations in interface IndexedSeq<T>
      Specified by:
      combinations in interface Seq<T>
      Parameters:
      k - the size of each subset
      Returns:
      a sequence of sequences representing all k-element combinations
      See Also:

    • crossProduct

      public Iterator<Array<T>> crossProduct(int power)
      Description copied from interface: Seq
      Returns the n-ary Cartesian power (cross product) of this sequence. Each element of the resulting iterator is a sequence of length power, containing all possible combinations of elements from this sequence.

      Example for power = 2:

      
 // Result: [(A,A), (A,B), (A,C), ..., (B,A), (B,B), ..., (Z,Y), (Z,Z)]
 CharSeq.rangeClosed('A', 'Z').crossProduct(2);

      If power is negative, the result is an empty iterator:

      
 // Result: ()
 CharSeq.rangeClosed('A', 'Z').crossProduct(-1);
      Specified by:
      crossProduct in interface IndexedSeq<T>
      Specified by:
      crossProduct in interface Seq<T>
      Parameters:
      power - the number of Cartesian multiplications
      Returns:
      an Iterator over sequences representing the Cartesian power of this sequence

    • get

      public T get(int index)
      Description copied from interface: Seq
      Returns the element at the specified index.
      Specified by:
      get in interface Seq<T>
      Parameters:
      index - the position of the element to retrieve
      Returns:
      the element at the given index

    • distinct

      public Array<T> distinct()
      Description copied from interface: Traversable
      Returns a new Traversable containing the elements of this instance with all duplicates removed. Element equality is determined using equals.
      Specified by:
      distinct in interface IndexedSeq<T>
      Specified by:
      distinct in interface Seq<T>
      Specified by:
      distinct in interface Traversable<T>
      Returns:
      a new Traversable without duplicate elements

    • distinctBy

      public Array<T> distinctBy(@NonNull Comparator<? super T> comparator)
      Description copied from interface: Traversable
      Returns a new Traversable containing the elements of this instance without duplicates, as determined by the given comparator.
      Specified by:
      distinctBy in interface IndexedSeq<T>
      Specified by:
      distinctBy in interface Seq<T>
      Specified by:
      distinctBy in interface Traversable<T>
      Parameters:
      comparator - a comparator used to determine equality of elements
      Returns:
      a new Traversable with duplicates removed

    • distinctBy

      public <U> Array<T> distinctBy(@NonNull Function<? super T,? extends U> keyExtractor)
      Description copied from interface: Traversable
      Returns a new Traversable containing the elements of this instance without duplicates, based on keys extracted from elements using keyExtractor.

      The first occurrence of each key is retained in the resulting sequence.

      Specified by:
      distinctBy in interface IndexedSeq<T>
      Specified by:
      distinctBy in interface Seq<T>
      Specified by:
      distinctBy in interface Traversable<T>
      Type Parameters:
      U - the type of key
      Parameters:
      keyExtractor - a function to extract keys for determining uniqueness
      Returns:
      a new Traversable with duplicates removed based on keys

    • distinctByKeepLast

      public Array<T> distinctByKeepLast(@NonNull Comparator<? super T> comparator)
      Description copied from interface: Seq
      Returns a sequence with duplicate elements removed, as determined by the provided comparator. When duplicates are found, the **last occurrence** of each element is retained.
      Specified by:
      distinctByKeepLast in interface IndexedSeq<T>
      Specified by:
      distinctByKeepLast in interface Seq<T>
      Parameters:
      comparator - a comparator defining equality between elements
      Returns:
      a new sequence with duplicates removed, keeping the last occurrence of each element

    • distinctByKeepLast

      public <U> Array<T> distinctByKeepLast(@NonNull Function<? super T,? extends U> keyExtractor)
      Description copied from interface: Seq
      Returns a sequence with duplicates removed based on a key extracted from each element. The key is obtained via the provided keyExtractor function. When duplicates are found, the **last occurrence** of each element for a given key is retained.
      Specified by:
      distinctByKeepLast in interface IndexedSeq<T>
      Specified by:
      distinctByKeepLast in interface Seq<T>
      Type Parameters:
      U - the type of the key used for determining uniqueness
      Parameters:
      keyExtractor - a function extracting a key from each element for uniqueness comparison
      Returns:
      a new sequence of elements distinct by the extracted key, keeping the last occurrence

    • drop

      public Array<T> drop(int n)
      Description copied from interface: Traversable
      Returns a new Traversable without the first n elements, or an empty instance if this contains fewer than n elements.
      Specified by:
      drop in interface IndexedSeq<T>
      Specified by:
      drop in interface Seq<T>
      Specified by:
      drop in interface Traversable<T>
      Parameters:
      n - the number of elements to drop
      Returns:
      a new instance excluding the first n elements

    • dropUntil

      public Array<T> dropUntil(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Returns a new Traversable starting from the first element that satisfies the given predicate, dropping all preceding elements.
      Specified by:
      dropUntil in interface IndexedSeq<T>
      Specified by:
      dropUntil in interface Seq<T>
      Specified by:
      dropUntil in interface Traversable<T>
      Parameters:
      predicate - a condition tested on each element
      Returns:
      a new instance starting from the first element matching the predicate

    • dropWhile

      public Array<T> dropWhile(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Returns a new Traversable starting from the first element that does not satisfy the given predicate, dropping all preceding elements.

      This is equivalent to dropUntil(predicate.negate()), which is useful for method references that cannot be negated directly.

      Specified by:
      dropWhile in interface IndexedSeq<T>
      Specified by:
      dropWhile in interface Seq<T>
      Specified by:
      dropWhile in interface Traversable<T>
      Parameters:
      predicate - a condition tested on each element
      Returns:
      a new instance starting from the first element not matching the predicate

    • dropRight

      public Array<T> dropRight(int n)
      Description copied from interface: Traversable
      Returns a new Traversable without the last n elements, or an empty instance if this contains fewer than n elements.
      Specified by:
      dropRight in interface IndexedSeq<T>
      Specified by:
      dropRight in interface Seq<T>
      Specified by:
      dropRight in interface Traversable<T>
      Parameters:
      n - the number of elements to drop from the end
      Returns:
      a new instance excluding the last n elements

    • dropRightUntil

      public Array<T> dropRightUntil(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Seq
      Drops elements from the end of the sequence until an element satisfies the given predicate. The returned sequence includes the last element that satisfies the predicate.
      Specified by:
      dropRightUntil in interface IndexedSeq<T>
      Specified by:
      dropRightUntil in interface Seq<T>
      Parameters:
      predicate - a condition to test elements, starting from the end
      Returns:
      a new sequence containing all elements up to and including the last element that satisfies the predicate

    • dropRightWhile

      public Array<T> dropRightWhile(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Seq
      Drops elements from the end of the sequence while the given predicate holds.

      This is equivalent to dropRightUntil(predicate.negate()). Useful when using method references that cannot be negated directly.

      Specified by:
      dropRightWhile in interface IndexedSeq<T>
      Specified by:
      dropRightWhile in interface Seq<T>
      Parameters:
      predicate - a condition to test elements, starting from the end
      Returns:
      a new sequence containing all elements up to and including the last element that does not satisfy the predicate

    • filter

      public Array<T> filter(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Returns a new traversable containing only the elements that satisfy the given predicate.
      Specified by:
      filter in interface IndexedSeq<T>
      Specified by:
      filter in interface Seq<T>
      Specified by:
      filter in interface Traversable<T>
      Parameters:
      predicate - the condition to test elements
      Returns:
      a traversable with elements matching the predicate

    • reject

      public Array<T> reject(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Returns a new traversable containing only the elements that do not satisfy the given predicate.

      This is equivalent to filter(predicate.negate()).

      Specified by:
      reject in interface IndexedSeq<T>
      Specified by:
      reject in interface Seq<T>
      Specified by:
      reject in interface Traversable<T>
      Parameters:
      predicate - the condition to test elements
      Returns:
      a traversable with elements not matching the predicate

    • flatMap

      public <U> Array<U> flatMap(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper)
      Description copied from interface: Traversable
      Transforms each element of this Traversable into an Iterable of elements and flattens the resulting iterables into a single Traversable.
      Specified by:
      flatMap in interface IndexedSeq<T>
      Specified by:
      flatMap in interface Seq<T>
      Specified by:
      flatMap in interface Traversable<T>
      Type Parameters:
      U - the type of elements in the resulting Traversable
      Parameters:
      mapper - a function mapping elements to iterables
      Returns:
      a new Traversable containing all elements produced by applying mapper and flattening

    • groupBy

      public <C> Map<C,Array<T>> groupBy(@NonNull Function<? super T,? extends C> classifier)
      Description copied from interface: Traversable
      Groups elements of this Traversable based on a classifier function.
      Specified by:
      groupBy in interface IndexedSeq<T>
      Specified by:
      groupBy in interface Seq<T>
      Specified by:
      groupBy in interface Traversable<T>
      Type Parameters:
      C - The type of the group keys
      Parameters:
      classifier - A function that assigns each element to a group
      Returns:
      A map where each key corresponds to a group of elements
      See Also:

    • grouped

      public Iterator<Array<T>> grouped(int size)
      Description copied from interface: Traversable
      Splits this Traversable into consecutive blocks of the given size.

      Let length be the number of elements in this Traversable:

      • If empty, the resulting Iterator is empty.
      • If size <= length, the resulting Iterator contains length / size blocks of size size and possibly a final smaller block of size length % size.
      • If size > length, the resulting Iterator contains a single block of size length.

      Examples:

       
 [].grouped(1) = []
 [].grouped(0) throws
 [].grouped(-1) throws
 [1,2,3,4].grouped(2) = [[1,2],[3,4]]
 [1,2,3,4,5].grouped(2) = [[1,2],[3,4],[5]]
 [1,2,3,4].grouped(5) = [[1,2,3,4]]

      Note: grouped(size) is equivalent to sliding(size, size).

      Specified by:
      grouped in interface IndexedSeq<T>
      Specified by:
      grouped in interface Seq<T>
      Specified by:
      grouped in interface Traversable<T>
      Parameters:
      size - the block size; must be positive
      Returns:
      an Iterator over blocks of elements

    • head

      public T head()
      Description copied from interface: Traversable
      Returns the first element of this non-empty Traversable.
      Specified by:
      head in interface Traversable<T>
      Returns:
      the first element

    • indexOf

      public int indexOf(T element, int from)
      Description copied from interface: Seq
      Returns the index of the first occurrence of the given element, starting at the specified index, or -1 if this sequence does not contain the element.
      Specified by:
      indexOf in interface Seq<T>
      Parameters:
      element - the element to search for
      from - the starting index for the search
      Returns:
      the index of the first occurrence at or after from, or -1 if not found

    • init

      public Array<T> init()
      Description copied from interface: Traversable
      Returns all elements of this Traversable except the last one.

      This is the dual of Traversable.tail().

      Specified by:
      init in interface IndexedSeq<T>
      Specified by:
      init in interface Seq<T>
      Specified by:
      init in interface Traversable<T>
      Returns:
      a new instance containing all elements except the last

    • initOption

      public Option<Array<T>> initOption()
      Description copied from interface: Traversable
      Returns all elements of this Traversable except the last one, wrapped in an Option.

      This is the dual of Traversable.tailOption().

      Specified by:
      initOption in interface IndexedSeq<T>
      Specified by:
      initOption in interface Seq<T>
      Specified by:
      initOption in interface Traversable<T>
      Returns:
      Some(traversable) if non-empty, or None if this Traversable is empty

    • isEmpty

      public boolean isEmpty()
      Description copied from interface: Traversable
      Checks if this Traversable contains no elements.
      Specified by:
      isEmpty in interface Traversable<T>
      Specified by:
      isEmpty in interface Value<T>
      Returns:
      true if empty, false otherwise

    • insert

      public Array<T> insert(int index, T element)
      Description copied from interface: Seq
      Returns a new sequence with the given element inserted at the specified index.
      Specified by:
      insert in interface IndexedSeq<T>
      Specified by:
      insert in interface Seq<T>
      Parameters:
      index - the position at which to insert the element
      element - the element to insert
      Returns:
      a new Seq with the element inserted

    • insertAll

      public Array<T> insertAll(int index, @NonNull Iterable<? extends T> elements)
      Description copied from interface: Seq
      Returns a new sequence with the given elements inserted at the specified index.
      Specified by:
      insertAll in interface IndexedSeq<T>
      Specified by:
      insertAll in interface Seq<T>
      Parameters:
      index - the position at which to insert the elements
      elements - the elements to insert; must not be null
      Returns:
      a new Seq with the elements inserted

    • intersperse

      public Array<T> intersperse(T element)
      Description copied from interface: Seq
      Returns a new sequence where the given element is inserted between all elements of this sequence.
      Specified by:
      intersperse in interface IndexedSeq<T>
      Specified by:
      intersperse in interface Seq<T>
      Parameters:
      element - the element to intersperse
      Returns:
      a new Seq with the element interspersed

    • lastIndexOf

      public int lastIndexOf(T element, int end)
      Description copied from interface: Seq
      Returns the index of the last occurrence of the given element at or before the specified end index, or -1 if this sequence does not contain the element.
      Specified by:
      lastIndexOf in interface Seq<T>
      Parameters:
      element - the element to search for
      end - the maximum index to consider
      Returns:
      the index of the last occurrence at or before end, or -1 if not found

    • length

      public int length()
      Description copied from interface: Traversable
      Returns the number of elements in this Traversable.

      Equivalent to Traversable.size().

      Specified by:
      length in interface Traversable<T>
      Returns:
      the number of elements

    • map

      public <U> Array<U> map(@NonNull Function<? super T,? extends U> mapper)
      Description copied from interface: Traversable
      Transforms the elements of this Traversable to a new type, preserving order if defined.
      Specified by:
      map in interface IndexedSeq<T>
      Specified by:
      map in interface Seq<T>
      Specified by:
      map in interface Traversable<T>
      Specified by:
      map in interface Value<T>
      Type Parameters:
      U - the target element type
      Parameters:
      mapper - a mapping function
      Returns:
      a new Traversable containing the mapped elements

    • mapTo

      public <U> Array<U> mapTo(U value)
      Description copied from interface: Value
      Maps the underlying value to another fixed value.
      Specified by:
      mapTo in interface IndexedSeq<T>
      Specified by:
      mapTo in interface Seq<T>
      Specified by:
      mapTo in interface Traversable<T>
      Specified by:
      mapTo in interface Value<T>
      Type Parameters:
      U - The new component type
      Parameters:
      value - value to replace the contents with
      Returns:
      A new value

    • mapToVoid

      public Array<Void> mapToVoid()
      Description copied from interface: Value
      Maps the underlying value to Void
      Specified by:
      mapToVoid in interface IndexedSeq<T>
      Specified by:
      mapToVoid in interface Seq<T>
      Specified by:
      mapToVoid in interface Traversable<T>
      Specified by:
      mapToVoid in interface Value<T>
      Returns:
      A new value of type Void

    • orElse

      public Array<T> orElse(Iterable<? extends T> other)
      Description copied from interface: Traversable
      Returns this Traversable if it is non-empty; otherwise, returns the given alternative.
      Specified by:
      orElse in interface IndexedSeq<T>
      Specified by:
      orElse in interface Seq<T>
      Specified by:
      orElse in interface Traversable<T>
      Parameters:
      other - an alternative Traversable to return if this is empty
      Returns:
      this Traversable if non-empty, otherwise other

    • orElse

      public Array<T> orElse(@NonNull Supplier<? extends Iterable<? extends T>> supplier)
      Description copied from interface: Traversable
      Returns this Traversable if it is non-empty; otherwise, returns the result of evaluating the given supplier.
      Specified by:
      orElse in interface IndexedSeq<T>
      Specified by:
      orElse in interface Seq<T>
      Specified by:
      orElse in interface Traversable<T>
      Parameters:
      supplier - a supplier of an alternative Traversable if this is empty
      Returns:
      this Traversable if non-empty, otherwise the result of supplier.get()

    • padTo

      public Array<T> padTo(int length, T element)
      Description copied from interface: Seq
      Returns a new sequence with this sequence padded on the right with the given element until the specified target length is reached.

      Note: Lazily-evaluated sequences may need to process all elements to determine the overall length.

      Specified by:
      padTo in interface IndexedSeq<T>
      Specified by:
      padTo in interface Seq<T>
      Parameters:
      length - the target length of the resulting sequence
      element - the element to append as padding
      Returns:
      a new Seq consisting of this sequence followed by the minimal number of occurrences of element to reach at least length

    • leftPadTo

      public Array<T> leftPadTo(int length, T element)
      Description copied from interface: Seq
      Returns a new sequence with this sequence padded on the left with the given element until the specified target length is reached.

      Note: Lazily-evaluated sequences may need to process all elements to determine the overall length.

      Specified by:
      leftPadTo in interface Seq<T>
      Parameters:
      length - the target length of the resulting sequence
      element - the element to prepend as padding
      Returns:
      a new Seq consisting of this sequence prepended by the minimal number of occurrences of element to reach at least length

    • patch

      public Array<T> patch(int from, @NonNull Iterable<? extends T> that, int replaced)
      Description copied from interface: Seq
      Returns a new sequence in which a slice of elements in this sequence is replaced by the elements of another sequence.
      Specified by:
      patch in interface IndexedSeq<T>
      Specified by:
      patch in interface Seq<T>
      Parameters:
      from - the starting index of the slice to be replaced
      that - the sequence of elements to insert; must not be null
      replaced - the number of elements to remove from this sequence starting at from
      Returns:
      a new Seq with the specified slice replaced

    • partition

      public Tuple2<Array<T>,Array<T>> partition(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Splits this Traversable into two partitions according to a predicate.

      The first partition contains all elements that satisfy the predicate, and the second contains all elements that do not. The original iteration order is preserved.

      Specified by:
      partition in interface IndexedSeq<T>
      Specified by:
      partition in interface Seq<T>
      Specified by:
      partition in interface Traversable<T>
      Parameters:
      predicate - a predicate used to classify elements
      Returns:
      a Tuple2 containing the two resulting Traversable instances

    • peek

      public Array<T> peek(@NonNull Consumer<? super T> action)
      Description copied from interface: Value
      Performs the given action on the first element if this is an eager implementation. Performs the given action on all elements (the first immediately, successive deferred), if this is a lazy implementation.
      Specified by:
      peek in interface IndexedSeq<T>
      Specified by:
      peek in interface Seq<T>
      Specified by:
      peek in interface Traversable<T>
      Specified by:
      peek in interface Value<T>
      Parameters:
      action - The action that will be performed on the element(s).
      Returns:
      this instance

    • permutations

      public Array<Array<T>> permutations()
      Description copied from interface: Seq
      Returns all unique permutations of this sequence.

      Example:

      
 [].permutations() = []

 [1, 2, 3].permutations() = [
   [1, 2, 3],
   [1, 3, 2],
   [2, 1, 3],
   [2, 3, 1],
   [3, 1, 2],
   [3, 2, 1]
 ]
      Specified by:
      permutations in interface IndexedSeq<T>
      Specified by:
      permutations in interface Seq<T>
      Returns:
      a sequence of all unique permutations of this sequence

    • prepend

      public Array<T> prepend(T element)
      Description copied from interface: Seq
      Returns a new sequence with the given element prepended to this sequence.
      Specified by:
      prepend in interface IndexedSeq<T>
      Specified by:
      prepend in interface Seq<T>
      Parameters:
      element - the element to prepend
      Returns:
      a new Seq with the element added at the front

    • prependAll

      public Array<T> prependAll(@NonNull Iterable<? extends T> elements)
      Description copied from interface: Seq
      Returns a new sequence with all given elements prepended to this sequence.
      Specified by:
      prependAll in interface IndexedSeq<T>
      Specified by:
      prependAll in interface Seq<T>
      Parameters:
      elements - the elements to prepend; must not be null
      Returns:
      a new Seq with the elements added at the front

    • remove

      public Array<T> remove(T element)
      Description copied from interface: Seq
      Returns a new sequence with the first occurrence of the given element removed.
      Specified by:
      remove in interface IndexedSeq<T>
      Specified by:
      remove in interface Seq<T>
      Parameters:
      element - the element to remove
      Returns:
      a new Seq without the first occurrence of the element

    • removeFirst

      public Array<T> removeFirst(@NonNull Predicate<T> predicate)
      Description copied from interface: Seq
      Returns a new sequence with the first element that satisfies the given predicate removed.
      Specified by:
      removeFirst in interface IndexedSeq<T>
      Specified by:
      removeFirst in interface Seq<T>
      Parameters:
      predicate - the predicate used to identify the element to remove; must not be null
      Returns:
      a new Seq without the first matching element

    • removeLast

      public Array<T> removeLast(@NonNull Predicate<T> predicate)
      Description copied from interface: Seq
      Returns a new sequence with the last element that satisfies the given predicate removed.
      Specified by:
      removeLast in interface IndexedSeq<T>
      Specified by:
      removeLast in interface Seq<T>
      Parameters:
      predicate - the predicate used to identify the element to remove; must not be null
      Returns:
      a new Seq without the last matching element

    • removeAt

      public Array<T> removeAt(int index)
      Description copied from interface: Seq
      Returns a new sequence with the element at the specified position removed. Subsequent elements are shifted to the left (indices decreased by one).
      Specified by:
      removeAt in interface IndexedSeq<T>
      Specified by:
      removeAt in interface Seq<T>
      Parameters:
      index - the position of the element to remove
      Returns:
      a new Seq without the element at the specified index

    • removeAll

      public Array<T> removeAll(T element)
      Description copied from interface: Seq
      Returns a new sequence with all occurrences of the given element removed.
      Specified by:
      removeAll in interface IndexedSeq<T>
      Specified by:
      removeAll in interface Seq<T>
      Parameters:
      element - the element to remove
      Returns:
      a new Seq without any occurrences of the element

    • removeAll

      public Array<T> removeAll(@NonNull Iterable<? extends T> elements)
      Description copied from interface: Seq
      Returns a new sequence with all occurrences of the given elements removed.
      Specified by:
      removeAll in interface IndexedSeq<T>
      Specified by:
      removeAll in interface Seq<T>
      Parameters:
      elements - the elements to remove; must not be null
      Returns:
      a new Seq without any of the given elements

    • removeAll

      @Deprecated public Array<T> removeAll(@NonNull Predicate<? super T> predicate)
      Deprecated.
      Description copied from interface: Seq
      Returns a new Seq consisting of all elements which do not satisfy the given predicate.
      Specified by:
      removeAll in interface IndexedSeq<T>
      Specified by:
      removeAll in interface Seq<T>
      Parameters:
      predicate - the predicate used to test elements
      Returns:
      a new Seq

    • replace

      public Array<T> replace(T currentElement, T newElement)
      Description copied from interface: Traversable
      Replaces the first occurrence of currentElement with newElement, if it exists.
      Specified by:
      replace in interface IndexedSeq<T>
      Specified by:
      replace in interface Seq<T>
      Specified by:
      replace in interface Traversable<T>
      Parameters:
      currentElement - the element to be replaced
      newElement - the replacement element
      Returns:
      a new Traversable with the first occurrence of currentElement replaced by newElement

    • replaceAll

      public Array<T> replaceAll(T currentElement, T newElement)
      Description copied from interface: Traversable
      Replaces all occurrences of currentElement with newElement.
      Specified by:
      replaceAll in interface IndexedSeq<T>
      Specified by:
      replaceAll in interface Seq<T>
      Specified by:
      replaceAll in interface Traversable<T>
      Parameters:
      currentElement - the element to be replaced
      newElement - the replacement element
      Returns:
      a new Traversable with all occurrences of currentElement replaced by newElement

    • retainAll

      public Array<T> retainAll(@NonNull Iterable<? extends T> elements)
      Description copied from interface: Traversable
      Retains only the elements from this Traversable that are contained in the given elements.
      Specified by:
      retainAll in interface IndexedSeq<T>
      Specified by:
      retainAll in interface Seq<T>
      Specified by:
      retainAll in interface Traversable<T>
      Parameters:
      elements - the elements to keep
      Returns:
      a new Traversable containing only the elements present in elements, in their original order

    • reverse

      public Array<T> reverse()
      Description copied from interface: Seq
      Returns a new sequence with the order of elements reversed.
      Specified by:
      reverse in interface IndexedSeq<T>
      Specified by:
      reverse in interface Seq<T>
      Returns:
      a new Seq with elements in reversed order

    • rotateLeft

      public Array<T> rotateLeft(int n)
      Description copied from interface: Seq
      Returns a new sequence with the elements circularly rotated to the left by the specified distance.

      Example:

      
 // Result: List(3, 4, 5, 1, 2)
 List.of(1, 2, 3, 4, 5).rotateLeft(2);
      Specified by:
      rotateLeft in interface IndexedSeq<T>
      Specified by:
      rotateLeft in interface Seq<T>
      Parameters:
      n - the number of positions to rotate left
      Returns:
      a new Seq with elements rotated left

    • rotateRight

      public Array<T> rotateRight(int n)
      Description copied from interface: Seq
      Returns a new sequence with the elements circularly rotated to the right by the specified distance.

      Example:

      
 // Result: List(4, 5, 1, 2, 3)
 List.of(1, 2, 3, 4, 5).rotateRight(2);
      Specified by:
      rotateRight in interface IndexedSeq<T>
      Specified by:
      rotateRight in interface Seq<T>
      Parameters:
      n - the number of positions to rotate right
      Returns:
      a new Seq with elements rotated right

    • scan

      public Array<T> scan(T zero, @NonNull BiFunction<? super T,? super T,? extends T> operation)
      Description copied from interface: Traversable
      Computes a prefix scan of the elements of this Traversable.

      The neutral element zero may be applied more than once.

      Specified by:
      scan in interface IndexedSeq<T>
      Specified by:
      scan in interface Seq<T>
      Specified by:
      scan in interface Traversable<T>
      Parameters:
      zero - the neutral element for the operator
      operation - an associative binary operator
      Returns:
      a new Traversable containing the prefix scan of the elements

    • scanLeft

      public <U> Array<U> scanLeft(U zero, @NonNull BiFunction<? super U,? super T,? extends U> operation)
      Description copied from interface: Traversable
      Produces a collection containing cumulative results of applying the operator from left to right.

      Will not terminate for infinite collections. The results may vary across runs unless the collection is ordered.

      Specified by:
      scanLeft in interface IndexedSeq<T>
      Specified by:
      scanLeft in interface Seq<T>
      Specified by:
      scanLeft in interface Traversable<T>
      Type Parameters:
      U - the type of the resulting elements
      Parameters:
      zero - the initial value
      operation - a binary operator applied to the intermediate result and each element
      Returns:
      a new Traversable containing the cumulative results

    • scanRight

      public <U> Array<U> scanRight(U zero, @NonNull BiFunction<? super T,? super U,? extends U> operation)
      Description copied from interface: Traversable
      Produces a collection containing cumulative results of applying the operator from right to left.

      The head of the resulting collection is the last cumulative result. Will not terminate for infinite collections. Results may vary across runs unless the collection is ordered.

      Specified by:
      scanRight in interface IndexedSeq<T>
      Specified by:
      scanRight in interface Seq<T>
      Specified by:
      scanRight in interface Traversable<T>
      Type Parameters:
      U - the type of the resulting elements
      Parameters:
      zero - the initial value
      operation - a binary operator applied to each element and the intermediate result
      Returns:
      a new Traversable containing the cumulative results

    • shuffle

      public Array<T> shuffle()
      Description copied from interface: Seq
      Returns a new sequence with the elements randomly shuffled.
      Specified by:
      shuffle in interface IndexedSeq<T>
      Specified by:
      shuffle in interface Seq<T>
      Returns:
      a new Seq containing the same elements in a random order

    • slice

      public Array<T> slice(int beginIndex, int endIndex)
      Description copied from interface: Seq
      Returns a subsequence (slice) of this sequence, starting at beginIndex (inclusive) and ending at endIndex (exclusive).

      Examples:

      
 List.of(1, 2, 3, 4).slice(1, 3); // = (2, 3)
 List.of(1, 2, 3, 4).slice(0, 4); // = (1, 2, 3, 4)
 List.of(1, 2, 3, 4).slice(2, 2); // = ()
 List.of(1, 2).slice(1, 0);       // = ()
 List.of(1, 2).slice(-10, 10);    // = (1, 2)

      See also Seq.subSequence(int, int), which may throw an exception instead of returning a sequence in some cases.

      Specified by:
      slice in interface IndexedSeq<T>
      Specified by:
      slice in interface Seq<T>
      Parameters:
      beginIndex - the starting index (inclusive)
      endIndex - the ending index (exclusive)
      Returns:
      a new Seq representing the specified slice

    • slideBy

      public Iterator<Array<T>> slideBy(@NonNull Function<? super T,?> classifier)
      Description copied from interface: Traversable
      Partitions this Traversable into consecutive non-overlapping windows according to a classification function.

      Each window contains elements with the same class, as determined by classifier. Two consecutive elements belong to the same window only if classifier returns equal values for both. Otherwise, the current window ends and a new window begins with the next element.

      Examples: 

      
 [].slideBy(Function.identity()) = []
 [1,2,3,4,4,5].slideBy(Function.identity()) = [[1],[2],[3],[4,4],[5]]
 [1,2,3,10,12,5,7,20,29].slideBy(x -> x / 10) = [[1,2,3],[10,12],[5,7],[20,29]]
      Specified by:
      slideBy in interface IndexedSeq<T>
      Specified by:
      slideBy in interface Seq<T>
      Specified by:
      slideBy in interface Traversable<T>
      Parameters:
      classifier - A function classifying elements into groups
      Returns:
      An Iterator of windows (grouped elements)

    • sliding

      public Iterator<Array<T>> sliding(int size)
      Description copied from interface: Traversable
      Slides a window of a given size over this Traversable with a step size of 1.

      This is equivalent to calling Traversable.sliding(int, int) with a step size of 1.

      Specified by:
      sliding in interface IndexedSeq<T>
      Specified by:
      sliding in interface Seq<T>
      Specified by:
      sliding in interface Traversable<T>
      Parameters:
      size - a positive window size
      Returns:
      An Iterator of windows, each containing up to size elements

    • sliding

      public Iterator<Array<T>> sliding(int size, int step)
      Description copied from interface: Traversable
      Slides a window of a specific size with a given step over this Traversable.

      Examples: 

      
 [].sliding(1, 1) = []
 [1,2,3,4,5].sliding(2, 3) = [[1,2],[4,5]]
 [1,2,3,4,5].sliding(2, 4) = [[1,2],[5]]
 [1,2,3,4,5].sliding(2, 5) = [[1,2]]
 [1,2,3,4].sliding(5, 3) = [[1,2,3,4],[4]]
      Specified by:
      sliding in interface IndexedSeq<T>
      Specified by:
      sliding in interface Seq<T>
      Specified by:
      sliding in interface Traversable<T>
      Parameters:
      size - a positive window size
      step - a positive step size
      Returns:
      an Iterator of windows with the given size and step

    • sorted

      public Array<T> sorted()
      Description copied from interface: Seq
      Returns a new sequence with elements sorted according to their natural order.
      Specified by:
      sorted in interface IndexedSeq<T>
      Specified by:
      sorted in interface Seq<T>
      Returns:
      a new Seq with elements in natural order

    • sorted

      public Array<T> sorted(@NonNull Comparator<? super T> comparator)
      Description copied from interface: Seq
      Returns a new sequence with elements sorted according to the given Comparator.
      Specified by:
      sorted in interface IndexedSeq<T>
      Specified by:
      sorted in interface Seq<T>
      Parameters:
      comparator - the comparator used to order elements; must not be null
      Returns:
      a new Seq with elements sorted according to the comparator

    • sortBy

      public <U extends Comparable<? super U>> Array<T> sortBy(@NonNull Function<? super T,? extends U> mapper)
      Description copied from interface: Seq
      Returns a new sequence sorted by comparing elements in a different domain defined by the given mapper.
      Specified by:
      sortBy in interface IndexedSeq<T>
      Specified by:
      sortBy in interface Seq<T>
      Type Parameters:
      U - the type used for comparison
      Parameters:
      mapper - a function mapping elements to a Comparable domain; must not be null
      Returns:
      a new Seq sorted according to the mapped values

    • sortBy

      public <U> Array<T> sortBy(@NonNull Comparator<? super U> comparator, Function<? super T,? extends U> mapper)
      Description copied from interface: Seq
      Returns a new sequence sorted by comparing elements in a different domain defined by the given mapper, using the provided comparator.
      Specified by:
      sortBy in interface IndexedSeq<T>
      Specified by:
      sortBy in interface Seq<T>
      Type Parameters:
      U - the type used for comparison
      Parameters:
      comparator - the comparator used to compare mapped values; must not be null
      mapper - a function mapping elements to the domain for comparison; must not be null
      Returns:
      a new Seq sorted according to the mapped values and comparator

    • splitAt

      public Tuple2<Array<T>,Array<T>> splitAt(int n)
      Description copied from interface: Seq
      Splits this sequence at the specified index.

      The result of splitAt(n) is equivalent to Tuple.of(take(n), drop(n)).

      Specified by:
      splitAt in interface Seq<T>
      Parameters:
      n - the index at which to split
      Returns:
      a Tuple2 containing the first n elements and the remaining elements

    • splitAt

      public Tuple2<Array<T>,Array<T>> splitAt(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Seq
      Splits this sequence at the first element satisfying the given predicate.
      Specified by:
      splitAt in interface Seq<T>
      Parameters:
      predicate - the predicate used to determine the split point; must not be null
      Returns:
      a Tuple2 containing the sequence before the first matching element and the remaining sequence

    • splitAtInclusive

      public Tuple2<Array<T>,Array<T>> splitAtInclusive(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Seq
      Splits this sequence at the first element satisfying the given predicate, including the element in the first part.
      Specified by:
      splitAtInclusive in interface Seq<T>
      Parameters:
      predicate - the predicate used to determine the split point; must not be null
      Returns:
      a Tuple2 containing the sequence up to and including the first matching element and the remaining sequence

    • span

      public Tuple2<Array<T>,Array<T>> span(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Splits this Traversable into a prefix and remainder according to the given predicate.

      The first element of the returned Tuple is the longest prefix of elements satisfying predicate, and the second element is the remaining elements.

      Specified by:
      span in interface IndexedSeq<T>
      Specified by:
      span in interface Seq<T>
      Specified by:
      span in interface Traversable<T>
      Parameters:
      predicate - a predicate used to determine the prefix
      Returns:
      a Tuple containing the prefix and remainder

    • subSequence

      public Array<T> subSequence(int beginIndex)
      Description copied from interface: Seq
      Returns a Seq that is a subsequence of this sequence, starting from the specified beginIndex and extending to the end of this sequence.

      Examples:

      
 List.of(1, 2).subSequence(0);   // = (1, 2)
 List.of(1, 2).subSequence(1);   // = (2)
 List.of(1, 2).subSequence(2);   // = ()
 List.of(1, 2).subSequence(10);  // throws IndexOutOfBoundsException
 List.of(1, 2).subSequence(-10); // throws IndexOutOfBoundsException

      See also Seq.drop(int), which provides similar functionality but does not throw an exception for out-of-bounds indices.

      Specified by:
      subSequence in interface IndexedSeq<T>
      Specified by:
      subSequence in interface Seq<T>
      Parameters:
      beginIndex - the starting index (inclusive) of the subsequence
      Returns:
      a new Seq representing the subsequence from beginIndex to the end

    • subSequence

      public Array<T> subSequence(int beginIndex, int endIndex)
      Description copied from interface: Seq
      Returns a Seq that is a subsequence of this sequence, starting from the specified beginIndex (inclusive) and ending at endIndex (exclusive).

      Examples:

      
 List.of(1, 2, 3, 4).subSequence(1, 3); // = (2, 3)
 List.of(1, 2, 3, 4).subSequence(0, 4); // = (1, 2, 3, 4)
 List.of(1, 2, 3, 4).subSequence(2, 2); // = ()
 List.of(1, 2).subSequence(1, 0);       // throws IndexOutOfBoundsException
 List.of(1, 2).subSequence(-10, 1);     // throws IndexOutOfBoundsException
 List.of(1, 2).subSequence(0, 10);      // throws IndexOutOfBoundsException

      See also Seq.slice(int, int), which returns an empty sequence instead of throwing exceptions when indices are out of range.

      Specified by:
      subSequence in interface IndexedSeq<T>
      Specified by:
      subSequence in interface Seq<T>
      Parameters:
      beginIndex - the starting index (inclusive) of the subsequence
      endIndex - the ending index (exclusive) of the subsequence
      Returns:
      a new Seq representing the subsequence from beginIndex to endIndex - 1

    • tail

      public Array<T> tail()
      Description copied from interface: Traversable
      Returns a new Traversable without its first element.
      Specified by:
      tail in interface IndexedSeq<T>
      Specified by:
      tail in interface Seq<T>
      Specified by:
      tail in interface Traversable<T>
      Returns:
      a new Traversable containing all elements except the first

    • tailOption

      public Option<Array<T>> tailOption()
      Description copied from interface: Traversable
      Returns a new Traversable without its first element as an Option.
      Specified by:
      tailOption in interface IndexedSeq<T>
      Specified by:
      tailOption in interface Seq<T>
      Specified by:
      tailOption in interface Traversable<T>
      Returns:
      Some(traversable) if non-empty, otherwise None

    • take

      public Array<T> take(int n)
      Description copied from interface: Traversable
      Returns the first n elements of this Traversable, or all elements if n exceeds the length.

      Equivalent to sublist(0, max(0, min(length(), n))), but safe for n < 0 or n > length().

      If n < 0, an empty instance is returned. If n > length(), the full instance is returned.

      Specified by:
      take in interface IndexedSeq<T>
      Specified by:
      take in interface Seq<T>
      Specified by:
      take in interface Traversable<T>
      Parameters:
      n - the number of elements to take
      Returns:
      a new Traversable containing the first n elements

    • takeUntil

      public Array<T> takeUntil(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Takes elements from this Traversable until the given predicate holds for an element.

      Equivalent to takeWhile(predicate.negate()), but useful when using method references that cannot be negated directly.

      Specified by:
      takeUntil in interface IndexedSeq<T>
      Specified by:
      takeUntil in interface Seq<T>
      Specified by:
      takeUntil in interface Traversable<T>
      Parameters:
      predicate - a condition tested sequentially on the elements
      Returns:
      a new Traversable containing all elements before the first one that satisfies the predicate

    • takeWhile

      public Array<T> takeWhile(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Takes elements from this Traversable while the given predicate holds.
      Specified by:
      takeWhile in interface IndexedSeq<T>
      Specified by:
      takeWhile in interface Seq<T>
      Specified by:
      takeWhile in interface Traversable<T>
      Parameters:
      predicate - a condition tested sequentially on the elements
      Returns:
      a new Traversable containing all elements up to (but not including) the first one that does not satisfy the predicate

    • takeRight

      public Array<T> takeRight(int n)
      Description copied from interface: Traversable
      Returns the last n elements of this Traversable, or all elements if n exceeds the length.

      Equivalent to sublist(max(0, length() - n), length()), but safe for n < 0 or n > length().

      If n < 0, an empty instance is returned. If n > length(), the full instance is returned.

      Specified by:
      takeRight in interface IndexedSeq<T>
      Specified by:
      takeRight in interface Seq<T>
      Specified by:
      takeRight in interface Traversable<T>
      Parameters:
      n - the number of elements to take from the end
      Returns:
      a new Traversable containing the last n elements

    • takeRightUntil

      public Array<T> takeRightUntil(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Seq
      Takes elements from the end of the sequence until an element satisfies the given predicate. The returned sequence starts after the last element that satisfies the predicate.
      Specified by:
      takeRightUntil in interface IndexedSeq<T>
      Specified by:
      takeRightUntil in interface Seq<T>
      Parameters:
      predicate - a condition to test elements, starting from the end
      Returns:
      a new sequence containing all elements after the last element that satisfies the predicate

    • takeRightWhile

      public Array<T> takeRightWhile(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Seq
      Takes elements from the end of the sequence while the given predicate holds.

      This is an equivalent to takeRightUntil(predicate.negate()). Useful when using method references that cannot be negated directly.

      Specified by:
      takeRightWhile in interface IndexedSeq<T>
      Specified by:
      takeRightWhile in interface Seq<T>
      Parameters:
      predicate - a condition to test elements, starting from the end
      Returns:
      a new sequence containing all elements after the last element that does not satisfy the predicate

    • transform

      public <U> U transform(Function<? super Array<T>,? extends U> f)
      Transforms this Array.
      Type Parameters:
      U - Type of transformation result
      Parameters:
      f - A transformation
      Returns:
      An instance of type U
      Throws:
      NullPointerException - if f is null

    • unzip

      public <T1, T2> Tuple2<Array<T1>,Array<T2>> unzip(@NonNull Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
      Description copied from interface: Traversable
      Unzips the elements of this Traversable by mapping each element to a pair and splitting them into two separate Traversable collections.
      Specified by:
      unzip in interface IndexedSeq<T>
      Specified by:
      unzip in interface Seq<T>
      Specified by:
      unzip in interface Traversable<T>
      Type Parameters:
      T1 - type of the first element in the resulting pairs
      T2 - type of the second element in the resulting pairs
      Parameters:
      unzipper - a function that maps elements of this Traversable to pairs
      Returns:
      a Tuple2 containing two Traversable collections with the split elements

    • unzip3

      public <T1, T2, T3> Tuple3<Array<T1>,Array<T2>,Array<T3>> unzip3(@NonNull Function<? super T,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
      Description copied from interface: Traversable
      Unzips the elements of this Traversable by mapping each element to a triple and splitting them into three separate Traversable collections.
      Specified by:
      unzip3 in interface IndexedSeq<T>
      Specified by:
      unzip3 in interface Seq<T>
      Specified by:
      unzip3 in interface Traversable<T>
      Type Parameters:
      T1 - type of the first element in the resulting triples
      T2 - type of the second element in the resulting triples
      T3 - type of the third element in the resulting triples
      Parameters:
      unzipper - a function that maps elements of this Traversable to triples
      Returns:
      a Tuple3 containing three Traversable collections with the split elements

    • update

      public Array<T> update(int index, T element)
      Description copied from interface: Seq
      Returns a new Seq with the element at the specified index replaced by the given value.
      Specified by:
      update in interface IndexedSeq<T>
      Specified by:
      update in interface Seq<T>
      Parameters:
      index - the index of the element to update
      element - the new element to set at the specified index
      Returns:
      a new Seq with the updated element

    • update

      public Array<T> update(int index, @NonNull Function<? super T,? extends T> updater)
      Description copied from interface: Seq
      Returns a new Seq with the element at the specified index updated using the given function.
      Specified by:
      update in interface IndexedSeq<T>
      Specified by:
      update in interface Seq<T>
      Parameters:
      index - the index of the element to update
      updater - a function that computes the new element from the existing element
      Returns:
      a new Seq with the element at index transformed by updater

    • zip

      public <U> Array<Tuple2<T,U>> zip(@NonNull Iterable<? extends U> that)
      Description copied from interface: Traversable
      Returns a Traversable formed by pairing elements of this Traversable with elements of another Iterable. Pairing stops when either collection runs out of elements; any remaining elements in the longer collection are ignored.

      The length of the resulting Traversable is the minimum of the lengths of this Traversable and that.

      Specified by:
      zip in interface IndexedSeq<T>
      Specified by:
      zip in interface Seq<T>
      Specified by:
      zip in interface Traversable<T>
      Type Parameters:
      U - the type of elements in the second half of each pair
      Parameters:
      that - an Iterable providing the second element of each pair
      Returns:
      a new Traversable containing pairs of corresponding elements

    • zipWith

      public <U, R> Array<R> zipWith(@NonNull Iterable<? extends U> that, BiFunction<? super T,? super U,? extends R> mapper)
      Description copied from interface: Traversable
      Returns a Traversable by combining elements of this Traversable with elements of another Iterable using a mapping function. Pairing stops when either collection runs out of elements.

      The length of the resulting Traversable is the minimum of the lengths of this Traversable and that.

      Specified by:
      zipWith in interface IndexedSeq<T>
      Specified by:
      zipWith in interface Seq<T>
      Specified by:
      zipWith in interface Traversable<T>
      Type Parameters:
      U - the type of elements in the second parameter of the mapper
      R - the type of elements in the resulting Traversable
      Parameters:
      that - an Iterable providing the second parameter of the mapper
      mapper - a function that combines elements from this and that into a new element
      Returns:
      a new Traversable containing mapped elements

    • zipAll

      public <U> Array<Tuple2<T,U>> zipAll(@NonNull Iterable<? extends U> that, T thisElem, U thatElem)
      Description copied from interface: Traversable
      Returns a Traversable formed by pairing elements of this Traversable with elements of another Iterable, filling in placeholder elements when one collection is shorter than the other.

      The length of the resulting Traversable is the maximum of the lengths of this Traversable and that.

      If this Traversable is shorter than that, thisElem is used as a filler. Conversely, if that is shorter, thatElem is used.

      Specified by:
      zipAll in interface IndexedSeq<T>
      Specified by:
      zipAll in interface Seq<T>
      Specified by:
      zipAll in interface Traversable<T>
      Type Parameters:
      U - the type of elements in the second half of each pair
      Parameters:
      that - an Iterable providing the second element of each pair
      thisElem - the element used to fill missing values if this Traversable is shorter than that
      thatElem - the element used to fill missing values if that is shorter than this Traversable
      Returns:
      a new Traversable containing pairs of elements, including fillers as needed

    • zipWithIndex

      public Array<Tuple2<T,Integer>> zipWithIndex()
      Description copied from interface: Traversable
      Zips this Traversable with its indices, starting at 0.
      Specified by:
      zipWithIndex in interface IndexedSeq<T>
      Specified by:
      zipWithIndex in interface Seq<T>
      Specified by:
      zipWithIndex in interface Traversable<T>
      Returns:
      a new Traversable containing each element paired with its index

    • zipWithIndex

      public <U> Array<U> zipWithIndex(@NonNull BiFunction<? super T,? super Integer,? extends U> mapper)
      Description copied from interface: Traversable
      Zips this Traversable with its indices and maps the resulting pairs using the provided mapper.
      Specified by:
      zipWithIndex in interface IndexedSeq<T>
      Specified by:
      zipWithIndex in interface Seq<T>
      Specified by:
      zipWithIndex in interface Traversable<T>
      Type Parameters:
      U - the type of elements in the resulting Traversable
      Parameters:
      mapper - a function mapping an element and its index to a new element
      Returns:
      a new Traversable containing the mapped elements

    • equals

      public boolean equals(Object o)
      Description copied from interface: Traversable
      Determines whether this collection is equal to the given object.

      In Vavr, there are four basic collection types:

      • Seq – sequential elements
      • Set – distinct elements
      • Map – key-value pairs
      • Multimap – keys mapped to multiple values
      Two collections are considered equal if and only if:
      • They are of the same collection type (Seq, Set, Map, Multimap)
      • They contain the same elements
      • For Seq, the element order is the same

      For Map and Multimap, two entries (key1, value1) and (key2, value2) are equal if both their keys and values are equal.

      Additional notes:

      • No collection equals null (e.g., Queue(1) != null)
      • Null elements are allowed and treated as expected (e.g., List(null, 1) == Stream(null, 1), HashMap((null,1)) == LinkedHashMap((null,1)))
      • Element order matters only for Seq
      • Other collection classes are equal if their types and elements (in iteration order) are equal
      • Iterators are compared by reference only
      Specified by:
      equals in interface Traversable<T>
      Specified by:
      equals in interface Value<T>
      Overrides:
      equals in class Object
      Parameters:
      o - the object to compare with, may be null
      Returns:
      true if the collections are equal according to the rules above, false otherwise

    • hashCode

      public int hashCode()
      Description copied from interface: Traversable
      Returns the hash code of this collection.

      Vavr distinguishes between collections with predictable iteration order (like Seq) and collections with arbitrary iteration order (like Set, Map, and Multimap). In all cases, the hash of an empty collection is defined as 1.

      For collections with predictable iteration order, the hash is computed as:

      
 int hash = 1;
 for (T t : this) {
     hash = hash * 31 + Objects.hashCode(t);
 }

      For collections with arbitrary iteration order, the hash is computed to be independent of element order:

      
 int hash = 1;
 for (T t : this) {
     hash += Objects.hashCode(t);
 }

      Note that these algorithms may change in future Vavr versions. Hash codes are generally not cached, unlike size/length, because caching would increase memory usage due to persistent tree-based structures. Computing the hash code is linear in time, O(n). For frequently re-used collections (e.g., as HashMap keys), caching can be done externally using a wrapper, for example:

      
 public final class Hashed<K> {
     private final K key;
     private final Lazy<Integer> hashCode;

     public Hashed(K key) {
         this.key = key;
         this.hashCode = Lazy.of(() -> Objects.hashCode(key));
     }

     public K key() { return key; }

     @Override
     public boolean equals(Object o) {
         if (o == key) return true;
         if (key != null && o instanceof Hashed) return key.equals(((Hashed<?>) o).key);
         return false;
     }

     @Override
     public int hashCode() { return hashCode.get(); }

     @Override
     public String toString() { return "Hashed(" + key + ")"; }
 }
      Specified by:
      hashCode in interface Traversable<T>
      Specified by:
      hashCode in interface Value<T>
      Overrides:
      hashCode in class Object
      Returns:
      the hash code of this collection

    • stringPrefix

      public String stringPrefix()
      Description copied from interface: Value
      Returns the name of this Value type, which is used by toString().
      Specified by:
      stringPrefix in interface Value<T>
      Returns:
      This type name.

    • toString

      public String toString()
      Description copied from interface: Value
      Clarifies that values have a proper toString() method implemented.

      See Object.toString().

      Specified by:
      toString in interface Value<T>
      Overrides:
      toString in class Object
      Returns:
      A String representation of this object