code | poetix

Joink is a library for joining together collections of Java 8 objects in memory.

Here’s what that looks like:

@Test public void
joins_one_to_many() {
    List<Tuple2<Author, Set<Book>>> joined = Joins.join(Arrays.stream(authors))
            .on(Author::getId)
            .to(Book::getAuthorId)
            .oneToMany(Arrays.stream(books))
            .collect(Collectors.toList());

    assertThat(joined, hasItems(
            Tuple2.of(badiou, books(beingAndEvent, logicsOfWorlds, theoryOfTheSubject)),
            Tuple2.of(derrida, books(ofGrammatology, spectresOfMarx)),
            Tuple2.of(deleuzeAndGuattari, books(antiOedipus, aThousandPlateaus)),
            Tuple2.of(levinas, books(totalityAndInfinity)),
            Tuple2.of(kolozova, books(cutOfTheReal)),
            Tuple2.of(notAppearing, books())
        ));
    }

@Test public void

joins_one_to_many() {

List<Tuple2<Author, Set<Book>>> joined = Joins.join(Arrays.stream(authors))

.on(Author::getId)

.to(Book::getAuthorId)

.oneToMany(Arrays.stream(books))

.collect(Collectors.toList());

assertThat(joined, hasItems(

Tuple2.of(badiou, books(beingAndEvent, logicsOfWorlds, theoryOfTheSubject)),

Tuple2.of(derrida, books(ofGrammatology, spectresOfMarx)),

Tuple2.of(deleuzeAndGuattari, books(antiOedipus, aThousandPlateaus)),

Tuple2.of(levinas, books(totalityAndInfinity)),

Tuple2.of(kolozova, books(cutOfTheReal)),

Tuple2.of(notAppearing, books())

));

}

Currently supported: inner, outer, left-outer and right-outer joins, as well as many-to-one, one-to-many and one-to-one joins (“strict”, which enforces uniqueness, and non-strict which doesn’t).

Soon to come: Octarine integration.

Today I’d like to talk about a pattern that as far as I know is unique to Java 8. It makes use of the unusual way Java 8 implements lambdas as single-method interfaces, and the support for default methods in interfaces, to produce what I call “enriched lambdas”.

Here’s a simple example: a “Logged function” that logs every call that is made to it:

public interface LoggedFunction<S, T> extends Function<S, T> {
    static final Logger logger = Logger.getLogger(LoggedFunction.class.getName());
    @Override
    default public T apply(S input) {
        T result = applyLogged(input);
        logger.info(String.format("LoggedFormat %s called with %s as input, returning %s", this, input, result));
        return result;
    }

    T applyLogged(S input);
}

public interface LoggedFunction<S, T> extends Function<S, T> {

static final Logger logger = Logger.getLogger(LoggedFunction.class.getName());

@Override

default public T apply(S input) {

T result = applyLogged(input);

logger.info(String.format("LoggedFormat %s called with %s as input, returning %s", this, input, result));

return result;

}

T applyLogged(S input);

}

Now we can add the logging behaviour to any function by assigning or casting it to LoggedFunction rather than Function:

Function<String, Integer> getLength = s -> s.length(); // does not log calls when "apply" is called.
LoggedFunction<String, Integer> getLengthLogged = s -> s.length(); // logs calls when "apply" is called.
Function<String, Integer> getLengthLogged2 = (LoggedFunction<String, Integer>) String::length; // logs calls when "apply" is called.

Function<String, Integer> getLength = s -> s.length(); // does not log calls when "apply" is called.

LoggedFunction<String, Integer> getLengthLogged = s -> s.length(); // logs calls when "apply" is called.

Function<String, Integer> getLengthLogged2 = (LoggedFunction<String, Integer>) String::length; // logs calls when "apply" is called.

How does this work? LoggedFunction has only one method without a default implementation, so any lambda that matches the signature of this method can be cast to an instance of LoggedFunction. Instead of overriding the “apply” method of LoggedFunction, the lambda will override the “applyLogged” method, which the default “apply” method implementation delegates to.

Octarine uses this pattern in a variety of ways, notably to build up Schemas, Serialisers and Deserialisers from single lambda expressions:

Schema = (record, validationErrors) -> { // expression which validates the record, building up validation errors }

1	Schema = (record, validationErrors) -> { // expression which validates the record, building up validation errors }

In this case, the unimplemented method is used to configure the object, and all other methods (with their default implementations) use this method to obtain their configuration.

This pattern is similar in some respects to the “enrich my library” pattern in Scala, which uses implicits – it provides a safe and convenient way to “upcast” simple lambdas to objects with enriched behaviour.

poetix

Tag Archives: code

Joink

Enriching is Easy

opting out of the ordinary human real