Contributors

Daniel Dietrich
Erlend Hamnaberg
Michael Ummels
Pap Lőrinc
Robert Erdin
Valeriy Vyrva

Changelog

Works fine on JDK 9

Vavr 0.9.2 now works fine on JDK 9. The previous release 0.9.1 had an internal dependency that broke the JDK 9 build - we fixed that.

Note: JDK 9 introduced a type inference bug that may affect Vavr's pattern matching in some cases. Please see JDK-8039214.

Collections

• We fixed the implementation of Multimap.last(). We did not override the default Traversable implementation.
• We fixed a problem with the intersection of ordered collections that are based on RedBlackTree (such as TreeSet).

Concurrent

• We fixed Future.traverse(ExecutorService, Iterable, Function). The ExecutorService was not taken into account.

More fixes...

• Beside the above, we fixed some javadoc typos.

Please find the complete list of changes here.

Contributors

Christian Bongiorno
Daniel Dietrich
Emmanuel Touzery
Julien Debon
Nazarii Bardiuk
Pascal Schumacher
Ruslan Sennov

Changelog

Concurrent operations

• We fixed a bug that prevented onFailure actions to be performed when a Future has been cancelled.
• There are known problems with Promise that occur under certain circumstances (see details below). Please note that we did not fix this problem in 0.9.1. We currently work on it in #2093.

// we choose a work-stealing thread pool
ExecutorService executor = java.util.concurrent.ForkJoinPool.commonPool();
Future<Object> someFuture = Future.of(executor, () -> longRunningTask());

// the internal Future of a Promise might deadlock the system if we block on that Future
Promise<Object> promise = Promise.make(executor);
someFuture.onComplete(promise::complete);

// the bug only shows up when calling a blocking operation, like get() or isEmpty()
Object result = promise.future().get();

Numeric operations

• Removed the Traversable.min(), max() overloads TreeSet.min() and TreeSet.max()
• Made Traversable.average(), sum() and product() more accurate.

// = TreeSet(3, 2, 1)
Set<Integer> ints = TreeSet.of(Comparator.reverseOrder(), 1, 2, 3);

// = 3 (before), = 1 (after)
ints.min();

// = 1 (before), = 3 (after)
ints.max();

// = List(1.0, NaN, 3.0)
List<Integer> doubles = List.of(1.0, Double.NaN, 3.0);

// = 1.0 (before), = NaN (after)
doubles.min();

// = NaN (both ok, before and after this change)
doubles.max();

// = OptionalDouble(0.0) (wrong)
j.u.s.DoubleStream.of(1.0, 10e100, 2.0, -10e100).average()

// = Some(0.75) (correct)
List.of(1.0, 10e100, 2.0, -10e100).average()

Missing methods

We added

• Either.sequence(Iterable<? extends Either<? extends L, ? extends R>>)
• Either.sequenceRight(Iterable<? extends Either<? extends L, ? extends R>>)

// = Right(List(all, right)) of type Either<Seq<Integer>, Seq<String>> 
Either.sequence(List.of(Either.right("all"), Either.right("right")));

// = Left(List(1, 2)) of type Either<Seq<Integer>, Seq<String>> 
Either.sequence(List.of(Either.left(1), Either.left(2), Either.right("ok")));

// = Right(List(all, right)) of type Either<Integer, Seq<String>> 
Either.sequenceRight(List.of(Either.right("all"), Either.right("right")));

// = Left(1) of type Either<Integer, Seq<String>> 
Either.sequenceRight(List.of(Either.left(1), Either.left(2), Either.right("ok")));

Type narrowing

We changed the generic bounds of these method arguments:

• Function0<R>.narrow(Function0<? extends R>) (before: narrow(Supplier<? extends R>))
• Function1<T1, R> Function1.narrow(Function1<? super T1, ? extends R>) (before: narrow(Function<? super T1, ? extends R>))
• Function2<T1, T2, R> Function2.narrow(Function2<? super T1, ? super T2, ? extends R>) (before: narrow(BiFunction<? super T1, ? super T2, ? extends R>))

M<? extends T> m = ...;
M<T> narrowed = m; // does not work but it is correct for immutable objects.

M<? extends T> m = ...;
M<T> narrowed = M.narrow(m); // works as expected

GWT compatibility fixes

The following methods were annotated with @GwtIncompatible:

• Predicates#instanceOf(Class)
• asJava(), asJava(Consumer), asJavaMutable(), asJavaMutable(Consumer) of io.vavr.collection.Seq and all its subtypes,
  namely IndexedSeq, LinearSeq, Array, CharSeq, List, Queue, Stream and Vector

Documentation

We added more examples and improved the readability of the Javadoc:

Thanks to Stuart Marks, he was so kind to initiate an issue in order to improve the default Javadoc style.

You find the Vavr 0.9.1 API specification here.

More fixes...

• We removed internal memoization of sortBy() in order to fix an issue with lazy collections that have infinite size
• We optimized collection conversion
• We fixed the generics of Multimap builders
• We improved Traversable.reduceLeft
• We improved Iterator.dropWhile and slideBy

Please find the complete list of changes here.

Changes to the Base Package io.vavr

We removed the interfaces Kind1 and Kind2. They served as bridge for the removed module javaslang-pure, which contained experimental algebraic extensions.

Values

• We removed getOption() in favor of toOption() (which has the same semantics)
• We changed the functional interface argument of getOrElseTry(CheckedFunction0) (was: getOrElseTry(Try.CheckedSupplier))
• We removed the conversion method toStack()
• We replaced the conversion methods
  • toJavaList(Supplier) by toJavaList(Function)
  • toJavaSet(Supplier) by toJavaSet(Function)

Functions

We removed the interface λ (the mother of all functions). It was neat but it had no practical purpose. The unicode character caused several problems with 3rd party tools, which did not handle unicode characters properly.

• We renamed the interface io.vavr.λ to io.vavr.Lambda and removed it from the public API.
• We removed the interface λ.Memoized from the public API.

Functional interfaces

With Vavr 0.9 we bundled our functions in io.vavr.

• We moved the functional interfaces Try.CheckedConsumer, Try.CheckedPredicate, Try.CheckedRunnable to io.vavr.
• We replaced the functional interface Try.CheckedSupplier by the existing CheckedFunction0.

Exception Handling

Other Factory Methods

Function0<? extends CharSequence> f_ = () -> "hi";
Function0<CharSequence> f = Function0.narrow(f_);

Tuples

• We renamed transform() to apply(), e.g.
  y = f(x1, x2, x3) can be understood as y = Tuple(x1, x2, x3).apply(f).

The API Gateway

We added io.vavr.API that gives direct access to most of the Vavr API without additional imports.

We are now able to start using Vavr by adding one gateway import. More imports can be added on demand by the IDE.

'Companion' Factory Methods

import static io.vavr.API.*;

Try<Integer>     _try    = Try(1);
Success<Integer> success = Success(1);
Failure<Integer> failure = Failure(new Error());

Option<Integer> option   = Option(1);
Some<Integer>   some     = Some(1);
None<Integer>   none     = None();

Array<Integer>  array    = Array(1, 2, 3);
List<Integer>   list     = List(1, 2, 3);
Stream<Integer> stream   = Stream(1, 2, 3);
Vector<Integer> vector   = Vector(1, 2, 3);

Tuple1<T>       tuple1   = Tuple(t);
Tuple3<T, U, V> tuple3   = Tuple(t, u, v);

// types work as expected
Option<CharSeqeuence> option = Some("");

// `str` might be null
Option<CharSeqeuence> option = Option(str);

// also possible, it is a Some(null)!
Option<CharSeqeuence> option = Some(null);

Uncheck Functions

Function1<String, User> getUserById = CheckedFunction1.of(id -> throw new IOException()).unchecked();
                                 // = CheckedFunction1.of(User::getById).unchecked();

Function1<String, User> getUserById = unchecked(id -> throw new IOException());
                                 // = unchecked(User::getById);

More Syntacic Sugar

println("easy");

void fancyNewAlgorithm(Arg arg) {
    return TODO("some fancy stuff will appear soon");
}

fancyNewAlgorithm(TODO("need to construct the `arg`"));

Pattern Matching

Internally pattern matching now uses the new PartialFunction interface, which gives a performance boost.

Pattern Names

We removed the possibility to create pattern matching cases outside of the pattern scope. Now we always use the existing $() methods to lift objects and functions into a pattern context.

// before
Case(obj, ...)          // e.g. Case(1, ...)
Case(predicate, ...)    // e.g. Case(t -> true, ...)

// after
Case($(obj), ...)       // e.g. Case($(1), ...)
Case($(predicate), ...) // e.g. Case($(t -> true), ...)

Our pattern generator vavr-match follows the new naming scheme and adds a $ to all generated pattern names.

Please prefix all patterns with $, e.g. $Some(...) instead of Some(...).

import static io.vavr.API.*;
import static io.vavr.Patterns.*;

// same as `intOption.map(i -> i * 2).getOrElse(-1)`
String result = Match(intOption).of(
    Case($Some($()), i -> i * 2),
    Case($None(), -1)
);

More details here.

Pre-defined Patterns

Accordingly all pattern names in io.vavr.Patterns are now prefixed with a $, and

• we replaced the List() patterns by $Cons(...) and $Nil().
• we removed the Stream() patterns because we need to enhance our pattern generator to express inner patterns $Stream.Cons(...) and $Stream.Empty() (API not finished).

More details here.

Pre-defined Predicates

Changes to the Base Package io.vavr.control

Try keeps original Exception

• We removed Try.FatalException and Try.NonFatalException
• Instead we sneaky throw the original exception when calling get() (even if it is checked!)

For additions see the Try API.

Changes to the Collections io.vavr.collection

• We removed AbstractIterator from the public API
• We changed the index type from long to int. That strikes many methods, like take(int), drop(int), zipWithIndex(), ...
• We removed the unsafe Map.of(Object...) factory methods which interpreted the given objects as pairs.
• We added the safe Map.of(K, V, ...) factory methods (up to 10 key/value pairs).

Java Collection Views

java.util.List<Integer> list = Vector(1, 2, 3).asJava();

More Collections

We completely re-implemented Vector.

Committers

Daniel Dietrich
Gregor Trefs
Jan Ferko
Pap Lőrinc
Przemek Wesołek
Ruslan Sennov

Changelog

Base

#1891 Changed generic bounds of Predicates allOf(), anyOf() and noneOf()

-   public static <T> Predicate<T> allOf(Predicate<? super T>... predicates) { ... }
+   public static <T> Predicate<T> allOf(Predicate<T>... predicates) { ... }

Match(value).of(
        Case(instanceOf(Either.LeftProjection.class), false),
        Case(instanceOf(Either.RightProjection.class), false),
        Case(instanceOf(Future.class), false),
        Case(instanceOf(Iterator.class), false),
        Case(instanceOf(Validation.class), false),
        Case(instanceOf(Either.class), true),
        Case(instanceOf(Option.class), true),
        Case(instanceOf(Try.class), true),
        Case(instanceOf(Traversable.class), true)
);

Match(value).of(
        Case(anyOf(
                instanceOf(Either.LeftProjection.class),
                instanceOf(Either.RightProjection.class),
                instanceOf(Future.class),
                instanceOf(Iterator.class),
                instanceOf(Validation.class)
        ), false),
        Case(anyOf(
                instanceOf(Either.class),
                instanceOf(Option.class),
                instanceOf(Try.class),
                instanceOf(Traversable.class)
        ), true)
);

#1892 Make interfaces Serializable

Collections

#1796 Fixed stackoverflow problem of List.hashCode().

List.range(0, 1_000_000)).hashCode();

#1792 Fixes deadlock on concurrent class initialization

import javaslang.collection.AbstractIterator;
import javaslang.collection.Iterator;

/**
 * Created by aeremeev on 25.12.16.
 */
public class DeadlockTest {

    public static void main(String[] args) {
        new Thread(Iterator::empty).start();
        new A();
        System.out.println("Success");
    }

    private static class A extends AbstractIterator<Void> {
        @Override
        protected Void getNext() {
            return null;
        }

        @Override
        public boolean hasNext() {
            return false;
        }
    }
}

#1816, #1823 HashArrayMappedTrie.equals() and LeafList.hashCode() fixed

final Map<String, Integer> map1 = HashMap.of("Aa", 1, "BB", 2);
final Map<String, Integer> map2 = HashMap.of("BB", 2, "Aa", 1);
assertThat(map1).isEqualTo(map2);

jshell> "Aa".hashCode()
$1 ==> 2112

jshell> "BB".hashCode()
$2 ==> 2112

#1854 LinkedHashMap.keySet() order

final Set<Integer> keySet = LinkedHashMap.of(4, "d", 1, "a", 2, "b").keySet();
assertThat(keySet.mkString()).isEqualTo("412");

#1858 Set.add(existing) does nothing, Map.put(existing, any) overwrites

#1878 Fixes Traversable.containsAll(Iterable)

default boolean containsAll(Iterable<? extends T> elements) {
-   final HashSet<T> uniqueElements = HashSet.ofAll(elements);
-   return toSet().intersect(uniqueElements).size() == uniqueElements.size();
+   for (T element : elements) {
+       if (!contains(element)) {
+           return false;
+       }
+   }
+   return true;
}

#1907 Fixes memory leak of grouped iterator

Iterator.continually(1)
        .grouped(100)
        .zipWithIndex()
        .forEach(t -> System.out.println("Group " + t._2));

Functions

#1837 Changed memoization's computeIfAbsent to synchronized get and put

private static final Function2<Integer, Integer, Integer> recurrent1 = (i1, i2) -> i1 <= 0 ? i1 : Function2Test.recurrent2.apply(i1 - 1, i2) + 1;
private static final Function2<Integer, Integer, Integer> recurrent2 = Function2Test.recurrent1.memoized();

@Test
public void shouldCalculatedRecursively() {
    assertThat(recurrent1.apply(11, 11)).isEqualTo(11);
    assertThat(recurrent1.apply(22, 22)).isEqualTo(22);
}

Property Testing

#1700 Optimized random value generators

static <T> Gen<T> of(T seed, Function<? super T, ? extends T> next) {
    Objects.requireNonNull(next, "next is null");
-   final Iterator<T> iterator = Stream.iterate(seed, next).iterator();
+   final Iterator<T> iterator = Iterator.iterate(seed, next);
    return ignored -> iterator.next();
}

interface Gen<T> {
-   static Gen<Character> choose(char[] characters) {
+   static Gen<Character> choose(char... characters) {
}

#1702 ArrayStoreException in Gen.choose(Iterable)

static <T> Gen<T> choose(Iterable<T> values) {
    ...
-   final T[] array = stream.toJavaArray((Class<T>) stream.head().getClass());
+   final T[] array = (T[]) iterator.toJavaArray();
    ...
}

#1759 Gen.frequency filters non-positive frequencies

Javadoc

#1735 Correct prefix-delimiter-suffix in mkString() javadoc

    /**
     ...
-    * This has the same effect as calling {@code mkString(delimiter, "", "")}.
+    * This has the same effect as calling {@code mkString("", delimiter, "")}.
     ...
     */

Committers

@ashrko619
@danieldietrich
@mduesterhoeft
@paplorinc
@ruslansennov

New and Noteworthy

API Additions

Javaslang follows the semantic versioning scheme. In the strict sense API additions require a minor version update. However, the additions that are contained in this bugfix release are considered to be fixes, not additional features.

Beside backward-compatible modifier- and override-fixes, the release includes these API additions:

• TreeMap/TreeSet.collector() do explicitly enforce that the key/element-type is Comparable. We did this by narrowing a generic parameter. However, the previous version would have lead to a ClassCastException at runtime if the given type were not Comparable.

interface javaslang.collection.Iterator<T> {
    + static Iterator<BigDecimal> rangeBy(BigDecimal from, BigDecimal toExclusive, BigDecimal step)
}

class javaslang.collection.TreeMap<K, V> {
    ~ static <K extends Comparable<? super K>, V> Collector<Tuple2<K, V>, ArrayList<Tuple2<K, V>>, TreeMap<K, V>> collector()
    + static <K, V> Collector<Tuple2<K, V>, ArrayList<Tuple2<K, V>>, TreeMap<K, V>> collector(Comparator<? super K> keyComparator)
}

class javaslang.collection.TreeSet<T> {
    ~ static <T extends Comparable<? super T>> Collector<T, ArrayList<T>, TreeSet<T>> collector()
    + static <T> Collector<T, ArrayList<T>, TreeSet<T>> collector(Comparator<? super T> comparator)
}

Behavioral Changes

• Iterator.rangeBy/rangeClosedBy internally now use BigDecimal instead of double to calculate the range (see #1309).
• Traversable.dropWhile/takeWhile/span behaved incorrect. This is fixed now (see #1641).
• LinkedHashMap.values() does now preserve insertion order (see #1656).
• Value.toCharSeq() now returns a string representation of the contained element(s) instead of the container type (see #1685).
• Traversable.min()/max() throw now NullPointerException in each case if a null element exists (see #1482).

List of Changes

Bugfixes

«base»

• PR #1691 (fixes #1685) Fixed toCharSeq()
  → 15667be

«collections»

• PR #1695 (fixes #1549) Re-worked TreeMap comparators, considering null-keys
  → 2767cf
• PR #1692 (fixes #1482) min() max() now throw NPE on null values
  → 5326c88, 7c2c906
• PR #1671 (fixes #1633) use a Vector as accumulator of map.traverse
  → 662cdd7
• PR #1657 (fixes #1656) Fixes LinkedHashMap::values()
  → 6466e98
• PR #1646 (fixes #1641) Fixes truncation bug of dropWhile and null handling of takeWhile and dropWhile
  → 6b6d40e
• PR #1308 (fixes #1309) Iterator range maintenance
  → cc48033
• PR #1251 (fixes #1249) Map/Set factories with comparator
  → f3f8f99

Improvements

«collections»

• PR #1696 (fixes #1227) Made naturalComparator() a singleton and made use of it
  → 7a9cc48

Documentation

«control»

• PR #1673 (fixes #1670) Updated javadoc of Either.map and .mapLeft
  → f463f29
• PR #1672 (fixes #1670) javadoc of Either.map + .mapLeft
  → da54383

Committers

@danieldietrich
@jorander
@mvh77
@paplorinc
@ruslansennov

New and Noteworthy

API Additions

Javaslang follows the semantic versioning scheme. In the strict sense API additions require a minor version update. However, the additions that are contained in this bugfix release are considered to be fixes, not additional features.

Beside backward-compatible modifier- and override-fixes, the release includes these API additions:

class javaslang.Lazy<T> {
  + static <T> Lazy<T> narrow(Lazy<? extends T> lazy)
}

class javaslang.collection.CharSeq {
  + interface CharUnaryOperator {
    char apply(char c)
  }
  + interface CharFunction<R> {
    R apply(char c)
  }
}

class javaslang.control.Option<T> {
  + static <T> Option<T> when(boolean condition, T value)
}

Behavioral Changes

• Option.when(boolean, Supplier) returns Some(null) instead of None if the Supplier returns null.
• Validation.valid(null) does return Valid(null) instead of throwing a NullPointerException.
• LinkedHashMap.replace(Tuple2, Tuple2) replaces a pair (if exists) and preserves its position instead of appending it.
• LinkedHashSet.replace(T, T) replaces an element (if exists) and preserves its position instead of appending it.

List of Changes

Bugfixes

• PR #1269 (fixes #1272) Fixed Option.when in case of a nullable supplier
  → 7e1e7f9, b7be4fc
• PR #1297 SortedSet.unzip3 overridden
  → 796dfe0, c766726
• PR #1390 (fixes #1388) Pattern-match generator should use full class names in generated code
  → 84c6f15
• PR #1400 (fixes #1377) Added a few methods to the public API of collections
  → 3bff648
• PR #1419 Iterator#iterate should not call supplier function until value is really needed
  → 3d76301, f369a5c
• PR #1420 Fix TreeMap creation from Java Map
  → 9358416, 8337cc8
• PR #1512 (fixes #1326) Replaces AbstractMap with Maps.
  → c1f4d98, baf1659
• PR #1586 (fixes #1585) Taking primitive types into account when converting to Java array.
  → bfb7063
• PR #1587 NullPointer Exception could occur on equals call.
  → 100cce9
• PR #1597 Fixes problem with null-keys in LinkedHashMap put() and remove()
  → 7ea1ae4
• PR #1598 Fixed exception messages in Array
  → 9d5ac62
• PR #1601 (fixes #1599) Fixes LinkedHashMap/LinkedHashSet replace() methods
  → 7d7712e

Improvements

• PR #1242 (fixes #1235) better equals/hashcode impls
  → fbfe9f9, b4c8c56
• PR #1247 (fixes #1243) LeafSingleton: compare hashCodes before checking equality
  → 9c2fbd2
• PR #1350 (fixes #1345) Optimized groupBy operations
  → 21c901b, 6d70844, 0a7e912, 0f1bf89
• PR #1357 makes HAMT iteration 10x faster
  → 49a9aa6, e1235db, 6104935
• PR #1567 Optimized usage of double-check idiom
  → 9868a9e
• PR #1571 further improvement of Lazy.get()
  → 3b8171e
• PR #1577 Lazy access minor speedup
  → 743cb07
• PR #1588 Allow Validation.valid(null)
  → 5747633
• PR #1595 Try$NonFatal.of is not intended to be public
  → 6863cff
• PR #1596 Re-added Traversable.hash in order to stay backward compatible
  → b67699a

Documentation

• PR #1538 (fixes #1304) Clarifies Traversable.min()/max() javadoc.
  → 465ca93
• PR #1541 Unify author tags
  → 9b7797b, ce427b7

• 1dd090a Fixes escaping RejectedExecutionException in Future

• Fixed #1366

• e823c71 Fixes For2..For8-comprehension
• 762ca59 Inner For-loop should not memoize.
• b689ec1 Match/Case API in 2.0.1 #1246