Vavr

https://docs.vavr.io/
Admin
Vavr is a functional library for Java 8+ that provides persistent data types, functional control...
Tokens:8,070
Snippets:119
Trust Score:9.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Scala Pattern Matching Example

Source: https://docs.vavr.io/

Illustrates Scala's native pattern matching syntax as an expression.

```scala
val s = i match {
  case 1 => "one"
  case 2 => "two"
  case _ => "?"
}
```

--------------------------------

### Matching Try Results

Source: https://docs.vavr.io/

Example of matching Success and Failure states of a Try instance.

```java
Match(_try).of(
    Case($Success($()), value -> ...),
    Case($Failure($()), x -> ...)
);
```

--------------------------------

### Basic Pattern Matching

Source: https://docs.vavr.io/

Example of matching an integer against specific values with a wildcard fallback.

```java
String s = Match(i).of(
    Case($(1), "one"),
    Case($(2), "two"),
    Case($(), "?")
);
```

--------------------------------

### Advanced Collection Operations

Source: https://docs.vavr.io/

Examples of grouping and zipping operations using Vavr collections.

```java
// = HashMap((0, List(2, 4)), (1, List(1, 3)))
List.of(1, 2, 3, 4).groupBy(i -> i % 2);

// = List((a, 0), (b, 1), (c, 2))
List.of('a', 'b', 'c').zipWithIndex();
```

--------------------------------

### Define a Person model

Source: https://docs.vavr.io/

A simple data class used in conjunction with the Validation example.

```java
class Person {

    public final String name;
    public final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person(" + name + ", " + age + ")";
    }

}
```

--------------------------------

### Initialize and use Lazy evaluation

Source: https://docs.vavr.io/

Lazy provides memoized evaluation of a value. The computation runs only once upon the first call to get().

```java
Lazy<Double> lazy = Lazy.of(Math::random);
lazy.isEvaluated(); // = false
lazy.get();         // = 0.123 (random generated)
lazy.isEvaluated(); // = true
lazy.get();         // = 0.123 (memoized)
```

--------------------------------

### Configure SortedSet ordering

Source: https://docs.vavr.io/

Demonstrates creating a SortedSet with natural ordering versus a custom Comparator for reverse ordering.

```java
// = TreeSet(1, 2, 3);
SortedSet<Integer> set = TreeSet.of(2, 3, 1, 2);

// = TreeSet(3, 2, 1);
Comparator<Integer> c = (a, b) -> b - a;
SortedSet<Integer> reversed = TreeSet.of(c, 2, 3, 1, 2);
```

--------------------------------

### Working with Vavr Tuples

Source: https://docs.vavr.io/

Demonstrates creating and accessing elements in a Tuple2.

```java
// = (1, "A")
Tuple2<Integer, String> entry = Tuple.of(1, "A");

Integer key = entry._1;
String value = entry._2;
```

--------------------------------

### Enqueue elements into a Queue

Source: https://docs.vavr.io/

Demonstrates creating a Queue and adding elements using the immutable enqueue operation.

```java
Queue<Integer> queue = Queue.of(1, 2, 3)
                            .enqueue(4)
                            .enqueue(5);
```

--------------------------------

### Compare Java Optional and Vavr Option behavior

Source: https://docs.vavr.io/

Demonstrates how Java's Optional handles nulls in map operations compared to Vavr's strict monadic behavior.

```java
Optional<String> maybeFoo = Optional.of("foo"); __**(1)**
then(maybeFoo.get()).isEqualTo("foo");
Optional<String> maybeFooBar = maybeFoo.map(s -> (String)null)  __**(2)**
                                       .map(s -> s.toUpperCase() + "bar");
then(maybeFooBar.isPresent()).isFalse();
```

```java
Option<String> maybeFoo = Option.of("foo"); __**(1)**
then(maybeFoo.get()).isEqualTo("foo");
try {
    maybeFoo.map(s -> (String)null) __**(2)**
            .map(s -> s.toUpperCase() + "bar"); __**(3)**
    Assert.fail();
} catch (NullPointerException e) {
    // this is clearly not the correct approach
}
```

--------------------------------

### Demonstrate Referential Transparency

Source: https://docs.vavr.io/

Compare expressions that are referentially transparent versus those that are not.

```java
// not referentially transparent
Math.random();

// referentially transparent
Math.max(1, 2);
```

--------------------------------

### Perform Persistent List Operations

Source: https://docs.vavr.io/

Demonstrates creating a new version of a list by prepending an element, while the original list remains unchanged.

```java
// = List(0, 2, 3)
List<Integer> list2 = list1.tail().prepend(0);
```

--------------------------------

### Iterating Vavr Collections

Source: https://docs.vavr.io/

Demonstrates using enhanced for-loops and internal iteration with lambdas on Vavr lists.

```java
for (String s : List.of("Java", "Advent")) {
    // side effects and mutation
}
```

```java
List.of("Java", "Advent").forEach(s -> {
    // side effects and mutation
});
```

--------------------------------

### Initialize Vavr Option

Source: https://docs.vavr.io/

Create an Option instance to represent an optional value.

```java
// optional *value*, no more nulls
Option<T> option = Option.of(...);
```

--------------------------------

### Dequeue elements from a Queue

Source: https://docs.vavr.io/

Shows how to retrieve the first element and the remaining queue, noting that the original queue remains unchanged.

```java
Queue<Integer> queue = Queue.of(1, 2, 3);

// = (1, Queue(2, 3))
Tuple2<Integer, Queue<Integer>> dequeued =
        queue.dequeue();
```

--------------------------------

### Demonstrate Unmodifiable Collection Failure

Source: https://docs.vavr.io/

Shows how Java's unmodifiable collection wrappers throw exceptions at runtime when mutation is attempted.

```java
List<String> list = Collections.unmodifiableList(otherList);

// Boom!
list.add("why not?");
```

--------------------------------

### Add snapshot repository to Maven

Source: https://docs.vavr.io/

Configure the snapshot repository in your ~/.m2/settings.xml file to enable access to developer builds.

```xml
<profiles>
    <profile>
        <id>allow-snapshots</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <repositories>
            <repository>
                <id>snapshots-repo</id>
                <url>https://oss.sonatype.org/content/repositories/snapshots</url>
                <releases>
                    <enabled>false</enabled>
                </releases>
                <snapshots>
                    <enabled>true</enabled>
                </snapshots>
            </repository>
        </repositories>
    </profile>
</profiles>
```

--------------------------------

### Decomposing Root Patterns

Source: https://docs.vavr.io/

Demonstrates matching with root patterns Success and Failure, decomposing them into specific types.

```java
Match(_try).of(
    Case($Success($Tuple2($("a"), $())), tuple2 -> ...),
    Case($Failure($(instanceOf(Error.class))), error -> ...)
);
```

--------------------------------

### Perform Property Testing

Source: https://docs.vavr.io/

Uses the io.vavr:vavr-test module to verify a mathematical property against generated integers.

```java
Arbitrary<Integer> ints = Arbitrary.integer();

// square(int) >= 0: OK, passed 1000 tests.
Property.def("square(int) >= 0")
        .forAll(ints)
        .suchThat(i -> i * i >= 0)
        .check()
        .assertIsSatisfied();
```

--------------------------------

### Import Vavr API

Source: https://docs.vavr.io/

Required static import to enable the Match, Case, and atomic pattern methods.

```java
import static io.vavr.API.*;
```

--------------------------------

### Concise String Joining

Source: https://docs.vavr.io/

Uses the mkString method to perform string joining in a single line.

```java
List.of(words).mkString(", ");
```

--------------------------------

### Instantiate a Vavr List

Source: https://docs.vavr.io/

Creates a new immutable List using the static factory method.

```java
// = List(1, 2, 3)
List<Integer> list1 = List.of(1, 2, 3);
```

--------------------------------

### Import Vavr Predicates

Source: https://docs.vavr.io/

Required static import to access default Vavr predicates.

```java
import static io.vavr.Predicates.*;
```

--------------------------------

### String Joining Comparison

Source: https://docs.vavr.io/

Compares a traditional imperative approach to joining strings with a functional Vavr approach.

```java
String join(String... words) {
    StringBuilder builder = new StringBuilder();
    for(String s : words) {
        if (builder.length() > 0) {
            builder.append(", ");
        }
        builder.append(s);
    }
    return builder.toString();
}
```

```java
String join(String... words) {
    return List.of(words)
               .intersperse(", ")
               .foldLeft(new StringBuilder(), StringBuilder::append)
               .toString();
}
```

--------------------------------

### Add snapshot repository to Gradle

Source: https://docs.vavr.io/

Include the Sonatype snapshot repository in your build.gradle file to access developer versions.

```groovy
repositories {
    (...)
    maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
}
```

--------------------------------

### Handle exceptions with Vavr Try

Source: https://docs.vavr.io/

Use Try to encapsulate computations that might throw exceptions, providing recovery mechanisms.

```java
// no need to handle exceptions
Try.of(() -> bunchOfWork()).getOrElse(other);
```

```java
import static io.vavr.API.*;        // $, Case, Match
import static io.vavr.Predicates.*; // instanceOf

A result = Try.of(this::bunchOfWork)
    .recover(x -> Match(x).of(
        Case($(instanceOf(Exception_1.class)), t -> somethingWithException(t)),
        Case($(instanceOf(Exception_2.class)), t -> somethingWithException(t)),
        Case($(instanceOf(Exception_n.class)), t -> somethingWithException(t))
    ))
    .getOrElse(other);
```

--------------------------------

### Java 8 Stream Computation Pattern

Source: https://docs.vavr.io/

Demonstrates the conceptual model of Java 8 Stream operations as a computational layer.

```java
// i + 1
i.prepareForAddition()
 .add(1)
 .mapBackToInteger(Mappers.toInteger())
```

--------------------------------

### Importing Predefined Patterns

Source: https://docs.vavr.io/

Required import to access Vavr's predefined match patterns.

```java
import static io.vavr.Patterns.*;
```

--------------------------------

### Defining User Patterns

Source: https://docs.vavr.io/

Using @Patterns and @Unapply annotations to define custom unapply logic for classes.

```java
import io.vavr.match.annotation.*;

@Patterns
class My {

    @Unapply
    static <T> Tuple1<T> Optional(java.util.Optional<T> optional) {
        return Tuple.of(optional.orElse(null));
    }
}
```

--------------------------------

### Reduce and Sum Collections

Source: https://docs.vavr.io/

Compares standard Java 8 stream operations with Vavr's List API for summing elements.

```java
Arrays.asList(1, 2, 3).stream().reduce((i, j) -> i + j);
```

```java
IntStream.of(1, 2, 3).sum();
```

```java
// io.vavr.collection.List
List.of(1, 2, 3).sum();
```

--------------------------------

### Lifting a method reference

Source: https://docs.vavr.io/

Lifting can be applied to existing methods that throw exceptions, mapping those exceptions to None.

```java
int sum(int first, int second) {
    if (first < 0 || second < 0) {
        throw new IllegalArgumentException("Only positive integers are allowed"); __**(1)**
    }
    return first + second;
}
```

```java
Function2<Integer, Integer, Option<Integer>> sum = Function2.lift(this::sum);

// = None
Option<Integer> optionalResult = sum.apply(-1, 2); __**(1)**
```

--------------------------------

### Safe dequeue using Option

Source: https://docs.vavr.io/

Uses dequeueOption to handle empty queues safely without throwing a NoSuchElementException.

```java
// = Some((1, Queue()))
Queue.of(1).dequeueOption();

// = None
Queue.empty().dequeueOption();
```

--------------------------------

### Create a SortedSet

Source: https://docs.vavr.io/

Initializes a TreeSet, which automatically sorts elements based on their natural ordering.

```java
// = TreeSet(1, 2, 3, 4, 6, 7, 8)
SortedSet<Integer> xs = TreeSet.of(6, 1, 3, 2, 4, 7, 8);
```

--------------------------------

### Handle nulls in Vavr Option using flatMap

Source: https://docs.vavr.io/

Use flatMap to safely handle potential null values within an Option chain.

```java
Option<String> maybeFoo = Option.of("foo"); __**(1)**
then(maybeFoo.get()).isEqualTo("foo");
Option<String> maybeFooBar = maybeFoo.map(s -> (String)null) __**(2)**
                                     .flatMap(s -> Option.of(s) __**(3)**
                                                         .map(t -> t.toUpperCase() + "bar"));
then(maybeFooBar.isEmpty()).isTrue();
```

```java
Option<String> maybeFoo = Option.of("foo"); __**(1)**
then(maybeFoo.get()).isEqualTo("foo");
Option<String> maybeFooBar = maybeFoo.flatMap(s -> Option.of((String)null)) __**(2)**
                                     .map(s -> s.toUpperCase() + "bar");
then(maybeFooBar.isEmpty()).isTrue();
```

--------------------------------

### Vavr Stream Transformation

Source: https://docs.vavr.io/

A concise Vavr equivalent to the Java 8 Stream transformation.

```java
// = Stream("1", "2", "3") in Vavr
Stream.of(1, 2, 3).map(Object::toString)
```

--------------------------------

### Process optional dequeue results

Source: https://docs.vavr.io/

Demonstrates mapping over the Option returned by dequeueOption to extract elements or the remaining queue.

```java
// = Queue(1)
Queue<Integer> queue = Queue.of(1);

// = Some((1, Queue()))
Option<Tuple2<Integer, Queue<Integer>>> dequeued =
        queue.dequeueOption();

// = Some(1)
Option<Integer> element = dequeued.map(Tuple2::_1);

// = Some(Queue())
Option<Queue<Integer>> remaining =
        dequeued.map(Tuple2::_2);
```

--------------------------------

### Partial application of functions

Source: https://docs.vavr.io/

Derive new functions by fixing a subset of parameters from an existing function.

```java
Function2<Integer, Integer, Integer> sum = (a, b) -> a + b;
Function1<Integer, Integer> add2 = sum.apply(2); __**(1)**

then(add2.apply(4)).isEqualTo(6);
```

```java
Function5<Integer, Integer, Integer, Integer, Integer, Integer> sum = (a, b, c, d, e) -> a + b + c + d + e;
Function2<Integer, Integer, Integer> add6 = sum.apply(2, 3, 1); __**(1)**

then(add6.apply(4, 3)).isEqualTo(13);
```

--------------------------------

### Iterate over a Vavr Stream

Source: https://docs.vavr.io/

Demonstrates using Stream.continually to generate and iterate over a sequence of random numbers.

```java
// 1000 random numbers
for (double random : Stream.continually(Math::random).take(1000)) {
    ...
}
```

--------------------------------

### Matching with Predicates

Source: https://docs.vavr.io/

Using the is predicate to match specific values.

```java
String s = Match(i).of(
    Case($(is(1)), "one"),
    Case($(is(2)), "two"),
    Case($(), "?")
);
```

--------------------------------

### Matching with Guards

Source: https://docs.vavr.io/

Using predicates within patterns to match Optional values based on nullability.

```java
Match(optional).of(
    Case($Optional($(v -> v != null)), "defined"),
    Case($Optional($(v -> v == null)), "empty")
);
```

--------------------------------

### Create a Lazy Stream

Source: https://docs.vavr.io/

Shows the creation of an infinite lazy stream filtered by an even number condition.

```java
// 2, 4, 6, ...
Stream.from(1).filter(i -> i % 2 == 0);
```

--------------------------------

### Project Either values

Source: https://docs.vavr.io/

Either represents a value of two possible types, typically used for success (Right) and failure (Left) scenarios.

```java
Either<String,Integer> value = compute().right().map(i -> i * 2).toEither();
```

--------------------------------

### Optional Match Result

Source: https://docs.vavr.io/

Use the option method to return an Option instead of throwing a MatchError when no case matches.

```java
Option<String> s = Match(i).option(
    Case($(0), "zero")
);
```

--------------------------------

### Create a lazy interface proxy

Source: https://docs.vavr.io/

Lazy.val creates a lazy proxy for an interface.

```java
CharSequence chars = Lazy.val(() -> "Yay!", CharSequence.class);
```

--------------------------------

### Performing Side-Effects

Source: https://docs.vavr.io/

Using the run helper to execute side-effects within a Match expression.

```java
Match(arg).of(
    Case($(isIn("-h", "--help")), o -> run(this::displayHelp)),
    Case($(isIn("-v", "--version")), o -> run(this::displayVersion)),
    Case($(), o -> run(() -> {
        throw new IllegalArgumentException(arg);
    }))
);
```

--------------------------------

### Matching Vavr Option

Source: https://docs.vavr.io/

Matching against Some and None patterns using Vavr's Option type.

```java
Match(option).of(
    Case($Some($()), "defined"),
    Case($None(), "empty")
);
```

--------------------------------

### Lifting a partial function

Source: https://docs.vavr.io/

Use Function2.lift to convert a partial function into a total function that returns an Option, preventing exceptions for invalid inputs.

```java
Function2<Integer, Integer, Integer> divide = (a, b) -> a / b;
```

```java
Function2<Integer, Integer, Option<Integer>> safeDivide = Function2.lift(divide);

// = None
Option<Integer> i1 = safeDivide.apply(1, 0); __**(1)**

// = Some(2)
Option<Integer> i2 = safeDivide.apply(4, 2); __**(2)**
```

--------------------------------

### Compose Vavr Functions

Source: https://docs.vavr.io/

Combine functions using andThen or compose to create new functions from existing ones.

```java
Function1<Integer, Integer> plusOne = a -> a + 1;
Function1<Integer, Integer> multiplyByTwo = a -> a * 2;

Function1<Integer, Integer> add1AndMultiplyBy2 = plusOne.andThen(multiplyByTwo);

then(add1AndMultiplyBy2.apply(2)).isEqualTo(6);
```

```java
Function1<Integer, Integer> add1AndMultiplyBy2 = multiplyByTwo.compose(plusOne);

then(add1AndMultiplyBy2.apply(2)).isEqualTo(6);
```

--------------------------------

### Configure Vavr dependency in Gradle

Source: https://docs.vavr.io/

Add the Vavr library to your project dependencies. Use the compile configuration for older Gradle versions or implementation for Gradle 7+.

```groovy
dependencies {
    compile "io.vavr:vavr:0.11.0"
}
```

```groovy
dependencies {
    implementation "io.vavr:vavr:0.11.0"
}
```

--------------------------------

### Conditional Predicate Syntax

Source: https://docs.vavr.io/

General syntax for using conditional patterns within a Case.

```java
Case($(predicate), ...)
```

--------------------------------

### Create Vavr Functions

Source: https://docs.vavr.io/

Vavr provides functional interfaces up to 8 parameters, supporting lambda expressions, anonymous classes, and method references.

```java
// sum.apply(1, 2) = 3
Function2<Integer, Integer, Integer> sum = (a, b) -> a + b;
```

```java
Function2<Integer, Integer, Integer> sum = new Function2<Integer, Integer, Integer>() {
    @Override
    public Integer apply(Integer a, Integer b) {
        return a + b;
    }
};
```

```java
Function3<String, String, String, String> function3 =
        Function3.of(this::methodWhichAccepts3Parameters);
```

--------------------------------

### Matching Multiple Conditions

Source: https://docs.vavr.io/

Using the isIn predicate to match against a set of values.

```java
Case($(isIn("-h", "--help")), ...)
```

--------------------------------

### Named Parameters in Matching

Source: https://docs.vavr.io/

Using lambdas to capture and transform matched values based on their type.

```java
Number plusOne = Match(obj).of(
    Case($(instanceOf(Integer.class)), i -> i + 1),
    Case($(instanceOf(Double.class)), d -> d + 1),
    Case($(), o -> { throw new NumberFormatException(); })
);
```

--------------------------------

### Java 8 Stream Collection Transformation

Source: https://docs.vavr.io/

A standard Java 8 Stream pipeline to transform and collect elements into a list.

```java
// = ["1", "2", "3"] in Java 8
Arrays.asList(1, 2, 3)
      .stream()
      .map(Object::toString)
      .collect(Collectors.toList())
```

--------------------------------

### Map a Tuple using one Mapper

Source: https://docs.vavr.io/

Map a tuple using a single function that accepts all tuple components.

```java
// (vavr, 1)
Tuple2<String, Integer> that = java8.map(
        (s, i) -> Tuple.of(s.substring(2) + "vr", i / 8)
);
```

--------------------------------

### Handle Exceptions with Try

Source: https://docs.vavr.io/

Encapsulate side-effect-prone division operations using the Try type to represent success or failure explicitly.

```java
int divide(int dividend, int divisor) {
    // throws if divisor is zero
    return dividend / divisor;
}
```

```java
// = Success(result) or Failure(exception)
Try<Integer> divide(Integer dividend, Integer divisor) {
    return Try.of(() -> dividend / divisor);
}
```

--------------------------------

### Create a Tuple in Vavr

Source: https://docs.vavr.io/

Use the static factory method Tuple.of() to create an immutable tuple containing multiple types.

```java
// (Java, 8)
Tuple2<String, Integer> java8 = Tuple.of("Java", 8); __**(1)**

// "Java"
String s = java8._1; __**(2)**

// 8
Integer i = java8._2; __**(3)**
```

--------------------------------

### Currying functions

Source: https://docs.vavr.io/

Currying transforms a function into a chain of single-parameter functions.

```java
Function2<Integer, Integer, Integer> sum = (a, b) -> a + b;
Function1<Integer, Integer> add2 = sum.curried().apply(2); __**(1)**

then(add2.apply(4)).isEqualTo(6);
```

```java
Function3<Integer, Integer, Integer, Integer> sum = (a, b, c) -> a + b + c;
final Function1<Integer, Function1<Integer, Integer>> add2 = sum.curried().apply(2);__**(1)**

then(add2.apply(4).apply(3)).isEqualTo(9);__**(2)**
```

--------------------------------

### Configure Vavr dependency in Maven

Source: https://docs.vavr.io/

Include the Vavr dependency in your project's pom.xml file.

```xml
<dependencies>
    <dependency>
        <groupId>io.vavr</groupId>
        <artifactId>vavr</artifactId>
        <version>0.11.0</version>
    </dependency>
</dependencies>
```

--------------------------------

### Correct Side-Effect Usage

Source: https://docs.vavr.io/

Wrap run in a lambda body to ensure lazy evaluation during pattern matching.

```java
// Ok
Case($(isIn("-h", "--help")), o -> run(this::displayHelp))
```

--------------------------------

### Map a Tuple Component-wise

Source: https://docs.vavr.io/

Evaluate a function per element in the tuple to return a new tuple.

```java
// (vavr, 1)
Tuple2<String, Integer> that = java8.map(
        s -> s.substring(2) + "vr",
        i -> i / 8
);
```

--------------------------------

### Validate input with Validation

Source: https://docs.vavr.io/

Validation accumulates errors instead of short-circuiting, making it ideal for form validation.

```java
PersonValidator personValidator = new PersonValidator();

// Valid(Person(John Doe, 30))
Validation<Seq<String>, Person> valid = personValidator.validatePerson("John Doe", 30);

// Invalid(List(Name contains invalid characters: '!4?', Age must be greater than 0))
Validation<Seq<String>, Person> invalid = personValidator.validatePerson("John? Doe!4", -1);
```

--------------------------------

### Implement a PersonValidator

Source: https://docs.vavr.io/

This class demonstrates combining multiple validation results into a single Validation instance.

```java
class PersonValidator {

    private static final String VALID_NAME_CHARS = "[a-zA-Z ]";
    private static final int MIN_AGE = 0;

    public Validation<Seq<String>, Person> validatePerson(String name, int age) {
        return Validation.combine(validateName(name), validateAge(age)).ap(Person::new);
    }

    private Validation<String, String> validateName(String name) {
        return CharSeq.of(name).replaceAll(VALID_NAME_CHARS, "").transform(seq -> seq.isEmpty()
                ? Validation.valid(name)
                : Validation.invalid("Name contains invalid characters: '"
                + seq.distinct().sorted() + "'"));
    }

    private Validation<String, Integer> validateAge(int age) {
        return age < MIN_AGE
                ? Validation.invalid("Age must be at least " + MIN_AGE)
                : Validation.valid(age);
    }

}
```

--------------------------------

### Add elements to a SortedSet

Source: https://docs.vavr.io/

Adds an element to an existing SortedSet, resulting in a new set with the element inserted in the correct position.

```java
// = TreeSet(1, 2, 3, 4, 5, 6, 7, 8)
SortedSet<Integer> ys = xs.add(5);
```

--------------------------------

### Define a Mutable Collection Interface

Source: https://docs.vavr.io/

Illustrates the standard Java Collection interface pattern where mutator methods return void.

```java
interface Collection<E> {
    // removes all elements from this collection
    void clear();
}
```

--------------------------------

### Transform a Tuple

Source: https://docs.vavr.io/

Use apply to transform the contents of a tuple into a new type.

```java
// "vavr 1"
String that = java8.apply(
        (s, i) -> s.substring(2) + "vr " + i / 8
);
```

--------------------------------

### Memoizing functions

Source: https://docs.vavr.io/

Memoization caches the result of a function execution to avoid redundant computations.

```java
Function0<Double> hashCache =
        Function0.of(Math::random).memoized();

double randomValue1 = hashCache.apply();
double randomValue2 = hashCache.apply();

then(randomValue1).isEqualTo(randomValue2);
```

--------------------------------

### Define a Future

Source: https://docs.vavr.io/

Future represents an asynchronous computation result that is non-blocking.

```java
// future *value*, result of an async calculation
Future<T> future = Future.of(...);
```

--------------------------------

### Incorrect Side-Effect Usage

Source: https://docs.vavr.io/

Eager evaluation occurs if run is used directly as a return value outside a lambda.

```java
// Wrong!
Case($(isIn("-h", "--help")), run(this::displayHelp))
```
Tokens:
Raw