protonpack alternatives and similar libraries
Based on the "Functional Programming" category.
Alternatively, view protonpack alternatives based on common mentions on social networks and blogs.
-
Javaslang
vʌvr (formerly called Javaslang) is a non-commercial, non-profit object-functional library that runs with Java 8+. It aims to reduce the lines of code and increase code quality. -
Functional Java
Backport of Java 8's lambda expressions to Java 7, 6 and 5 -
jOOλ
jOOλ - The Missing Parts in Java 8 jOOλ improves the JDK libraries in areas where the Expert Group's focus was elsewhere. It adds tuple support, function support, and a lot of additional functionality around sequential Streams. The JDK 8's main efforts (default methods, lambdas, and the Stream API) were focused around maintaining backwards compatibility and implementing a functional API for parallelism. -
cyclops-react
An advanced, but easy to use, platform for writing functional applications in Java 8. -
derive4j
Java 8 annotation processor and framework for deriving algebraic data types constructors, pattern-matching, folds, optics and typeclasses. -
Faux Pas
A library that simplifies error handling for Functional Programming in Java -
Vavr
Functional component library that provides persistent data types and functional control structures.
WorkOS - The modern identity platform for B2B SaaS
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of protonpack or a related project?
README
protonpack
A small collection of Stream
utilities for Java 8. Protonpack provides the following:
takeWhile
andtakeUntil
skipWhile
andskipUntil
zip
andzipWithIndex
unfold
MapStream
aggregate
Streamable<T>
unique
collector
For full API documentation, see (http://poetix.github.io/protonpack).
Available from Maven Central:
<dependency>
<groupId>com.codepoetics</groupId>
<artifactId>protonpack</artifactId>
<version>1.16</version>
</dependency>
takeWhile
Takes elements from the stream while the supplied condition is met. takeUntil
does the same, but with the condition negated.
Stream<Integer> infiniteInts = Stream.iterate(0, i -> i + 1);
Stream<Integer> finiteInts = StreamUtils.takeWhile(infiniteInts, i -> i < 10);
assertThat(finiteInts.collect(Collectors.toList()),
hasSize(10));
skipWhile
Skips elements from the stream while the supplied condition is met. skipUntil
does the same, but with the condition negated.
Stream<Integer> ints = Stream.of(1,2,3,4,5,6,7,8,9,10);
Stream<Integer> skipped = StreamUtils.skipWhile(ints, i -> i < 4);
List<Integer> collected = skipped.collect(Collectors.toList());
assertThat(collected,
contains(4, 5, 6, 7, 8, 9, 10));
zip
Combines two streams using the supplied combiner function.
Stream<String> streamA = Stream.of("A", "B", "C");
Stream<String> streamB = Stream.of("Apple", "Banana", "Carrot", "Doughnut");
List<String> zipped = StreamUtils.zip(streamA,
streamB,
(a, b) -> a + " is for " + b)
.collect(Collectors.toList());
assertThat(zipped,
contains("A is for Apple", "B is for Banana", "C is for Carrot"));
unfold
Generates a (potentially infinite) stream using a generator that can indicate the end of the stream at any time by returning Optional.empty().
Stream<Integer> unfolded = StreamUtils.unfold(1, i ->
(i < 10)
? Optional.of(i + 1)
: Optional.empty());
assertThat(unfolded.collect(Collectors.toList()),
contains(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
stream
Transforms a source type into a stream
stream(Optional<T> optional):
Stream<Item> items = idStream.flatMap(id -> StreamUtils.stream(fetchItem(id));
Streamable
Streamable is to Stream as Iterable is to Iterator. Useful when you will want to stream repeatedly over some source.
unique
A collector that returns the one and only item in a stream, if present, or throws an exception if multiple items are found.
assertThat(Stream.of(1, 2, 3).filter(i -> i > 3).collect(CollectorUtils.unique()),
equalTo(Optional.empty()));
assertThat(Stream.of(1, 2, 3).filter(i -> i > 2).collect(CollectorUtils.unique()),
equalTo(Optional.of(3)));
// Throws NonUniqueValueException
Stream.of(1, 2, 3).filter(i -> i > 1).collect(CollectorUtils.unique());
toFutureList
A collector that converts a stream of CompletableFuture<T>
into a CompletableFuture<List<T>>
, which completes
exceptionally if (and as soon as) any of the futures in the list completes exceptionally.
Function<Integer, CompletableFuture<Integer>> processAsynchronously = i -> CompletableFuture.completedFuture(i * 2);
assertThat(
Stream.of(1, 2, 3).map(processAsynchronously)
.collect(CompletableFutures.toFutureList())
.get(),
contains(2, 4, 6));