alexengrig/lambdax

Useful Java 8 Lambdas

LambdaX 0.5.0

⚠️ This library is under experimental development - expect the major version ⚠️

This library contains utility classes with useful lambdas.

Features

LambdaX uses concepts of functional programming:

• Pure functions.
• Higher-order functions.
• Currying functions.

LambdaX provides the following:

• Writing code in declarative style.
• Writing code in chaining style.

Examples

Chain

• Data flow:

    int integer = ChainX.of("some string")
            .map(String::length)
            .filter(length -> length > 0)
            .mutate(length -> holder[0] = length)
            .orElse(-1);

Collection

• Get the value from Map and print it on the console:

    Map<Integer, String> map = new HashMap<>();
    map.put(1, "one");
    Holder<Map<Integer, String>> holder = new Holder<>(map);
// Plain Java
    Map<Integer, String> map = holder.get();
    String actual = map.get(key);
    System.out.println(actual);
// Chaining Style
    Optional.of(holder)
            .map(Holder::get)
            .map(m -> m.get(key))
            .ifPresent(System.out::println);
// LambdaX
    String actual = Optional.of(holder)
             .map(Holder::get)
             .map(MapX.get(key))
             .ifPresent(System.out::println);

• Insert the value into Collection if it does not contain it:

    Collection<Integer> numbers = new ArrayList<>();
    Holder<Collection<Integer>> holder = new Holder<>(numbers);
    int value = 1;
// Plain Java
    Collection<Integer> target = holder.get();
    if (!target.contains(value)) {
        target.add(value);
    }
// Chaining Style  
    Optional.of(holder)
            .map(Holder::get)
            .filter(collection -> !collection.contains(value))
            .ifPresent(collection -> collection.add(value));
// LambdaX
    Optional.of(holder)
            .map(Holder::get)
            .filter(CollectionX.notContains(value))
            .ifPresent(CollectionX.onlyAdd(value));

Predicate

• Filter holders by name (not null safe):

List<Holder<Item>> filterByName(List<Holder<Item>> list) {
    return list.stream()
            .filter(PredicateX.of(Holder<Item>::get)
                    .map(Item::getName) // NPE if item is null
                    .equal("Item name"))
            .collect(Collectors.toList());
}

and null safe variant:

List<Holder<Item>> filterByExistingName(List<Holder<Item>> list) {
    return list.stream()
            .filter(PredicateX.ofNullable(Holder<Item>::get)
                    .map(Item::getName)
                    .equal("Item name")
                    .orLie()) // return false if item or item name is null
            .collect(Collectors.toList());
}

Installation

Releases are available in Maven Central.

List of version changes.

Maven

Add this snippet to the pom.xml dependencies section:

<dependency>
  <groupId>io.github.alexengrig</groupId>
  <artifactId>lambdax</artifactId>
  <version>0.5.0</version>
</dependency>

Gradle

Add this snippet to the build.gradle dependencies section:

implementation 'io.github.alexengrig:lambdax:0.5.0'

Others

Other snippets are available in The Central Repository.

License

This project is licensed under Apache License, version 2.0.

lambdax's Issues

Create PredicateX#isNull and PredicateX#notNull

Use:

boxes
    .stream()
//      .filter(box -> box.getItem().getName() == null
    .filter(PredicateX.of(Box::getItem).map(Item::getName).isNull())
//      .filter(box -> box.getItem().getName() != null
    .filter(PredicateX.of(Box::getItem).map(Item::getName).notNull())

Create PredicateX#truth for the permanent true result

Create PredicateX#truth for the permanent true result: obj -> true.

Create MapX

Create utility class with useful lambdas for java.lang.Map.

Fix MapX#get

Fix MapX#get return type:

Function<Map<? extends K, ? extends V>, ? extends V>

Create try/catch methods to ChainX

Think of methods with exceptions.

Create PredicateX#not for negate predicates

Create PredicateX#not like Java 11 Predicate#not.

Create QueueX JavaDoc

Create JavaDoc for io.github.alexengrig.lambdax.collection.QueueX.

Release 0.1.3

v0.1.3

Create CollectionX

Create utility class with useful lambdas for java.lang.Collection.

Create OptionalX JavaDoc

Create JavaDoc for io.github.alexengrig.lambdax.OptionalX.

Create DequeX tests with use Optional

Create DequeX tests with use java.util.Optional.

Create ListX JavaDoc

Create JavaDoc for io.github.alexengrig.lambdax.collection.ListX.

Add OptionalX#of for nullable value

Optional<T> of(T value) {
  return Optional.ofNullable(value);
}

Release 0.2.0

v0.2.0

Add null safe implementation of PredicateI and ComparablePredicatI

Add check of the arguments on null - require not null.

PredicateX.of(Box::getItem).map(null); // throws the NPE

Add check of the mapper result on null - skip mapping.

Box box = new Box(null); // without a item
PredicateX.of(Box::getItem)
    .map(Item::getName) // NPE
    .equal("some name");

Solution

Add PredicateX.ofNullable(...) with null handling.

Create examples of using this library

Create examples of using LambdaX library. Add some examples in README.md.

Create the primitive implementations of PredicateI and ComparablePredicateI

The implementation for primitives.
After doing #82.

Create MapX JavaDoc

Create JavaDoc for io.github.alexengrig.lambdax.collection.MapX.

Add the chaining style link

Writing code in chaining style.

Create CollectionX JavaDoc

Create JavaDoc for io.github.alexengrig.lambdax.collection.CollectionX.

Fix PredicateX#map

Describe the bug
Cannot resolve method 'map(java.util.function.Function<java.util.Map<? extends K,? extends V>,V>)'

Target
Method: PredicateX#map and MapX#get

Code

class Entry {
    private Map<Integer, String> numbers;
}

<...>

List<String> numbers = entries.stream()
    .filter(PredicateX.of(Entry::getNumbers)
                    // .map(MapX.get(1)) // doesn't work
                    // .map(m -> m.get(1)) // doesn't work
                    .map((Map<Integer, String> m) -> m.get(1)) // works
                    .nonNull())
    .collect(Collectors.toList());

Release 0.1.1

v0.1.1

Remove wildcards from collection

Remove wildcards from io.github.alexengrig.lambdax.collection.*.

Fix coverage

Fix coverage.

Fix coverage in PredicateB

PredicateB.java#L158 and PredicateB.java#L178.

Create DequeX

Create utility class with useful lambdas for java.lang.Deque.

Create QueueX

Create utility class with useful lambdas for java.lang.Queue.

Create OptionalX

Create utility class with useful lambdas for java.lang.Optional.

Fix JavaDoc version

0.1.0:

lambdax/src/main/java/io/github/alexengrig/lambdax/package-info.java

Line 22 in 6615625

* @since 0.1.2

0.1.0:

lambdax/src/main/java/io/github/alexengrig/lambdax/package-info.java

Line 22 in 6615625

* @since 0.1.2

Create PredicateX#lie for the permanent false result

Create PredicateX#lie for the permanent false result: obj -> false.

Release 0.1.2

v0.1.2

Create ChainX

Use:

ChainX.of(HashMap<Integer, String>::new)
    .mutate(MapX.onlyPut(1, "one"))
    .mutate(MapX.onlyPut(2, "two"))
    .get();

Add PredicateX#and, Add PredicateX#or and Add PredicateX#xor

Predicate<String> checker = PredicateX.and(Objects::nonNull, "Text":eqauls);

<T> Predicate<T> and(Predicate<T> first, Predicate<T> second, Predicate<T>...others) {...}

Refactor PredicateX

Migrate PredicateX to interface.
Create PredicateChainX.

PredicateX.chain(Box::get);
PredicateChainX.of(Box:get);

• Implemention
• Test
• Documentation
• CHANGES
• README
• MIGRATION

Create ListX

Create utility class with useful lambdas for java.lang.List.

Create SetX

Create utility class with useful lambdas for java.lang.Set.

Create SetX tests with use Optional

Create SetX tests with use java.util.Optional.

Create PredicateX#truth(Consumer) and PredicateX#lie(Consumer)

Create CollectionX tests with use Optional

Create CollectionX tests with use java.util.Optional.

Create PredicateX#from(Predicate)

Use:

Predicate<Box> predicate = Box::isEmpty; // ok
Predicate<Box> predicate = Box::isEmpty.and(nextPredicate); // not work
Predicate<Box> predicate = PredicateX.from(Box::isEmpty).and(nextPredicate); // work

Implementation:

<T> Predicate<T> from(Predicate<? super T> checker) {
    return (Predicate<T>) checker;
}

Create ListX tests with use Optional

Create ListX tests with use java.util.Optional.

Create SetX JavaDoc

Create JavaDoc for io.github.alexengrig.lambdax.collection.SetX.

Create DequeX JavaDoc

Create JavaDoc for io.github.alexengrig.lambdax.collection.DequeX.

Create StringX

Currying String.

• Implemention
• Test
• Documentation
• CHANGES
• README

Create package-info for JavaDoc

Create package-info.java for JavaDoc.

Negate methods - "not"

Add methods with negate predicate; name prefix "not".
Example: Collection#notContains.

Create PredicateX#greater, #less, #greaterOrEqual and #lessOrEqual

Create mappable predicate

Create static constructor of, methods map, check, equal, less, greater, lessOrEqual, greaterOrEqual.

Use:

boxes
    .stream()
//  NPE    .filter(box -> box.getItem().getName().equals("Coca-Cola")
    .filter(PredicateX.of(Box::getItem).map(Item::getName).check("Coca-Cola"::equals))
    .collect(Collectors.toList());

Fix JavaDoc

public static Predicate xnor(Predicate first, Predicate second, Predicate... others)

Create QueueX tests with use Optional

Create QueueX tests with use java.util.Optional.