Category Archives: Java 8

Typeclasses in Java 8

2014/11/14 domfox

Java 8 doesn’t have implicits (for which much thanks will be given in some quarters), which makes it difficult to create typeclasses in a Scala(z)ish fashion. This is one possible compromise.

public class MonoidTest {

    public interface Monoid<T> {
        public static <T> Function<Monoid<T>, Optional<T>> sum(Collection<T> items) {
            return monoid -> {
                Iterator<T> iter = items.iterator();
                if (!iter.hasNext()) {
                    return Optional.empty();
                }
                T accumulator = iter.next();
                while (iter.hasNext()) {
                    accumulator = monoid.append(accumulator, iter.next());
                }
                return Optional.of(accumulator);
            };
        }

        T append(T first, T second);
    }

    public interface IntegerMonoid {
        static <R> R run(Function<Monoid<Integer>, R> f) {
            return f.apply((a, b) -> a + b);
        }
    }

    public interface StringMonoid {
        static <R> R run(Function<Monoid<String>, R> f) {
            return f.apply((a, b) -> a + b);
        }
    }

    @Test public void sums() {
        Optional<Integer> sumOfInts = IntegerMonoid.run(Monoid.sum(Arrays.asList(1, 2, 3)));
        Optional<String> sumOfStrings = StringMonoid.run(Monoid.sum(Arrays.asList("a", "b", "c")));

        assertThat(sumOfInts.get(), equalTo(6));
        assertThat(sumOfStrings.get(), equalTo("abc"));
    }
}

public class MonoidTest {

public interface Monoid<T> {

public static <T> Function<Monoid<T>, Optional<T>> sum(Collection<T> items) {

return monoid -> {

Iterator<T> iter = items.iterator();

if (!iter.hasNext()) {

return Optional.empty();

}

T accumulator = iter.next();

while (iter.hasNext()) {

accumulator = monoid.append(accumulator, iter.next());

}

return Optional.of(accumulator);

};

}

T append(T first, T second);

}

public interface IntegerMonoid {

static <R> R run(Function<Monoid<Integer>, R> f) {

return f.apply((a, b) -> a + b);

}

public interface StringMonoid {

static <R> R run(Function<Monoid<String>, R> f) {

return f.apply((a, b) -> a + b);

}

@Test public void sums() {

Optional<Integer> sumOfInts = IntegerMonoid.run(Monoid.sum(Arrays.asList(1, 2, 3)));

Optional<String> sumOfStrings = StringMonoid.run(Monoid.sum(Arrays.asList("a", "b", "c")));

assertThat(sumOfInts.get(), equalTo(6));

assertThat(sumOfStrings.get(), equalTo("abc"));

}

Java 8

What’s New In Octarine

2014/07/14 domfox

Octarine is now at version 0.5, and has been enhanced with New Stuff:

Transformers

Transform records (and anything else you have extractors/lenses for) with a fluent mapping DSL.

Key<String> sourceForename = $("forename");
Key<String> sourceSurname = $("surname");
Key<Integer> sourceAge = $("age");
Key<String> sourceFavouriteColour = $("favouriteColour");

Key<String> targetName = $("name");
Key<Integer> targetAge = $("age");
Key<String> targetFavouriteColour = $("favouriteColour");

RecordTransformer<Record> recordTransformer = c -> c
            .map(r -> sourceForename.get(r).orElse("") + " " + sourceSurname.get(r).orElse(""), targetName)
            .map(sourceAge, targetAge)
            .map(sourceFavouriteColour.mappedWith(String::toLowerCase), targetFavouriteColour);

Record source = $$(
    sourceForename.of("Arthur"),
    sourceSurname.of("Putey"),
    sourceAge.of(23),
    sourceFavouriteColour.of("Puce");

Record target = recordTransformer.apply(source);

assertThat(target, ARecord.instance().with(targetName, "Arthur Putey").with(targetFavouriteColour, "puce"));

Key<String> sourceForename = $("forename");

Key<String> sourceSurname = $("surname");

Key<Integer> sourceAge = $("age");

Key<String> sourceFavouriteColour = $("favouriteColour");

Key<String> targetName = $("name");

Key<Integer> targetAge = $("age");

Key<String> targetFavouriteColour = $("favouriteColour");

RecordTransformer<Record> recordTransformer = c -> c

.map(r -> sourceForename.get(r).orElse("") + " " + sourceSurname.get(r).orElse(""), targetName)

.map(sourceAge, targetAge)

.map(sourceFavouriteColour.mappedWith(String::toLowerCase), targetFavouriteColour);

Record source = $$(

sourceForename.of("Arthur"),

sourceSurname.of("Putey"),

sourceAge.of(23),

sourceFavouriteColour.of("Puce");

Record target = recordTransformer.apply(source);

assertThat(target, ARecord.instance().with(targetName, "Arthur Putey").with(targetFavouriteColour, "puce"));

BeanRecords

When you have a bean, but want a record, and your key names map (or can be mapped) reflectively onto bean property names:

Key<String> name = $("name");
Key<Integer> age = $("age");
Key<LocalDate> dob = $("dob", BeanRecord.methodName.of("dateOfBirth"));

Bean bean = new Bean("Arthur Putey", 23, LocalDate.of(2014, 7, 11));
Record record = BeanRecord.of(bean, name, age, dob).with(age.of(34));
Bean newBean = Extractors.join(name, age, dob, Bean::new).extract(record);

assertThat(newBean.getAge(), equalTo(34));

Key<String> name = $("name");

Key<Integer> age = $("age");

Key<LocalDate> dob = $("dob", BeanRecord.methodName.of("dateOfBirth"));

Bean bean = new Bean("Arthur Putey", 23, LocalDate.of(2014, 7, 11));

Record record = BeanRecord.of(bean, name, age, dob).with(age.of(34));

Bean newBean = Extractors.join(name, age, dob, Bean::new).extract(record);

assertThat(newBean.getAge(), equalTo(34));

Reflective JSON serialisation

You lazy so-and-so, you.

Record me = $$(
    Person.name.of("Dominic"),
    Person.age.of(39),
    Person.favouriteColour.of(Color.RED),
    Person.address.of(Address.addressLines.of("13 Rue Morgue", "PO3 1TP")));

ObjectMapper mapper = ReflectiveJsonRecordSerialiser.mapperWith(new ColorJsonSerializer());

String json = mapper.writeValueAsString(me);

Record meToo = Person.deserialiser.fromString(json);

assertThat(meToo, equalTo(me));

Record me = $$(

Person.name.of("Dominic"),

Person.age.of(39),

Person.favouriteColour.of(Color.RED),

Person.address.of(Address.addressLines.of("13 Rue Morgue", "PO3 1TP")));

ObjectMapper mapper = ReflectiveJsonRecordSerialiser.mapperWith(new ColorJsonSerializer());

String json = mapper.writeValueAsString(me);

Record meToo = Person.deserialiser.fromString(json);

assertThat(meToo, equalTo(me));

Serialisation/deserialisation of maps

Sometimes the “keys” in a JSON array are dynamic values, such as ids, rather than static property names. In that case, you need to be able to serialise/deserialise a map of values rather than a record. The serialisation/deserialisation libraries have been revamped to support this, and a variety of other cases (lists of maps of lists of records, etc.)

String json = "{\"home\": {\"prefix\": \"0208\", \"number\": \"123456\"}, \"work\": {\"prefix\": \"07775\", \"number\": \"654321\"}}";

Map<String, Record> numbers = fromMap(readNumber).fromString(json);

assertThat(numbers, AnInstance.<Map<String, Record>>ofGeneric(Map.class)
    .with(Path.<String, Record>toKey("home").join(prefix), Present.and(equalTo("0208"))));

String json = "{\"home\": {\"prefix\": \"0208\", \"number\": \"123456\"}, \"work\": {\"prefix\": \"07775\", \"number\": \"654321\"}}";

Map<String, Record> numbers = fromMap(readNumber).fromString(json);

assertThat(numbers, AnInstance.<Map<String, Record>>ofGeneric(Map.class)

.with(Path.<String, Record>toKey("home").join(prefix), Present.and(equalTo("0208"))));

Java 8

Extractors

2014/06/14 domfox

An Extractor<S, T> may be seen as a partial function from S to T: it can only “extract” a value of type T from a value of type S if such a value (or the material from which one can be created) is present. In Octarine, an Extractor<T, V> is a cross between a Function<T, Optional<V>> and a Predicate<T> . It has three methods:

V extract(T source) – extracts a value of type V directly from the source (or fails with an exception).
Optional<V> apply(T source) – returns either a value of type V extracted from the source and wrapped in an Optional, or Optional.empty if no such value is available.
boolean test(T source) – returns true if the source contains the kind of value that we want, and false otherwise.

The obvious example is a Record , which might or might not contain a value for a given Key<T> . We have:

Key<Integer> age = Key.named("age");

Record recordWithAge = Record.of(age.of(23));
age.extract(recordWithAge); // returns 23.
age.apply(recordWithAge); // returns Optional.of(23).
age.test(recordWithAge); // returns true.

Record emptyRecord = Record.empty();
age.extract(emptyRecord); // throws an exception
age.apply(emptyRecord); // returns Optional.empty().
age.test(emptyRecord); // return false.

Key<Integer> age = Key.named("age");

Record recordWithAge = Record.of(age.of(23));

age.extract(recordWithAge); // returns 23.

age.apply(recordWithAge); // returns Optional.of(23).

age.test(recordWithAge); // returns true.

Record emptyRecord = Record.empty();

age.extract(emptyRecord); // throws an exception

age.apply(emptyRecord); // returns Optional.empty().

age.test(emptyRecord); // return false.

We can enhance extractors with predicates to look for values matching additional criteria besides existence – for example:

Key<Integer> age = Key.named("age");
Extractor<Record, Integer> ageOverForty = age.is(i -> i >= 40);
Extractor<Record, Integer> ageUnderForty = age.is(i -> i < 40);

Record record = Record.of(age.of(23));
ageOverForty.extract(record); // throws an exception
ageUnderForty.extract(record); // returns 23
ageOverForty.apply(record); // returns Optional.empty()
ageUnderForty.apply(record); // returns Optional.of(23)
ageOverForty.test(record); // returns false.
ageUnderForty.test(record); // returns true.

Key<Integer> age = Key.named("age");

Extractor<Record, Integer> ageOverForty = age.is(i -> i >= 40);

Extractor<Record, Integer> ageUnderForty = age.is(i -> i < 40);

Record record = Record.of(age.of(23));

ageOverForty.extract(record); // throws an exception

ageUnderForty.extract(record); // returns 23

ageOverForty.apply(record); // returns Optional.empty()

ageUnderForty.apply(record); // returns Optional.of(23)

ageOverForty.test(record); // returns false.

ageUnderForty.test(record); // returns true.

This makes them useful when composing tests on a record:

boolean isOldArthur = name.is("Arthur").and(age.is(i -> i >= 40)).test(record));

1	boolean isOldArthur = name.is("Arthur").and(age.is(i -> i >= 40)).test(record));

Which in turn makes them useful when filtering a collection of records:

Stream<Record> oldArthurs = records.stream().filter(name.is("Arthur").and(age.is(i -> i >= 40)));

1	Stream<Record> oldArthurs = records.stream().filter(name.is("Arthur").and(age.is(i -> i >= 40)));

Any OptionalLens<T, V> in Octarine is also an Extractor<T, V> , and any plain old Lens<T, V> can be turned into an Extractor<T, V> by calling Lens::asOptional on it.

Java 8

Joink

2014/06/08 domfox

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.

Java 8

Monoidal FizzBuzz

2014/05/23 domfox

package com.codepoetics.fizzbuzz.monoidal;

import java.util.function.Function;

public class MonoidalFizzBuzz<T, I extends Interpreter<T>, M extends Monoid<T>, R extends Representation<T>> implements Function<Integer, String> {

    private final I interpreter;
    private final M monoid;
    private final R representable;

    public MonoidalFizzBuzz(I interpreter, M monoid, R representable) {
        this.interpreter = interpreter;
        this.monoid = monoid;
        this.representable = representable;
    }

    @Override
    public String apply(Integer integer) {
        T product = interpreter.interpret(integer)
                               .stream()
                               .reduce(monoid.zero(), monoid::product);
        return product.equals(monoid.zero()) ? integer.toString() : representable.represent(product);
    }

    public static void main(String[] argv) {
        Function<Integer, String> mfb = new MonoidalFizzBuzz<>(
                FizzBuzz.interpreter,
                FizzBuzz.monoid,
                FizzBuzz.representation);

        for (int i=1; i<=100; i++) {
            System.out.println(mfb.apply(i));
        }
    }
}

package com.codepoetics.fizzbuzz.monoidal;

import java.util.function.Function;

public class MonoidalFizzBuzz<T, I extends Interpreter<T>, M extends Monoid<T>, R extends Representation<T>> implements Function<Integer, String> {

private final I interpreter;

private final M monoid;

private final R representable;

public MonoidalFizzBuzz(I interpreter, M monoid, R representable) {

this.interpreter = interpreter;

this.monoid = monoid;

this.representable = representable;

}

@Override

public String apply(Integer integer) {

T product = interpreter.interpret(integer)

.stream()

.reduce(monoid.zero(), monoid::product);

return product.equals(monoid.zero()) ? integer.toString() : representable.represent(product);

}

public static void main(String[] argv) {

Function<Integer, String> mfb = new MonoidalFizzBuzz<>(

FizzBuzz.interpreter,

FizzBuzz.monoid,

FizzBuzz.representation);

for (int i=1; i<=100; i++) {

System.out.println(mfb.apply(i));

}

See the whole thing on github.

Java 8

Octarine vs Rekord: Design Comparison

2014/05/18 domfox

Rekord is an excellent Java 7 library by my friend and sometime colleague Samir, which overlaps in several respects with my Java 8 library Octarine. The similarities are due both to a common ancestry (we both used to work on a codebase that made extensive use in testing of Nat Pryce’s make-it-easy) and an ongoing process of looking in on each other’s code from time to time to see if there’s anything worth pinching. More generally, I think myself and Samir have been scratching similar itches: we’ve both suffered under the tyrannical reign of Java Beans, and have both wanted to find better ways of dealing with record types in Java.

One major design difference between the two libraries has to do with their approach to type tagging. A Rekord is always a Rekord<T> of some particular type T, and is always constrained to use keys which are connected to that type:

public interface Sandvich {
    Key<Sandvich, Bread> bread = Key.named("bread").that(defaultsTo(Brown));
    Key<Sandvich, Filling> filling = Key.named("filling");
    Key<Sandvich, Style> style = Key.named("style");

    Rekord rekord = Rekord.of(Sandvich.class).accepting(filling, bread, style);
}

public interface Sandvich {

Key<Sandvich, Bread> bread = Key.named("bread").that(defaultsTo(Brown));

Key<Sandvich, Filling> filling = Key.named("filling");

Key<Sandvich, Style> style = Key.named("style");

Rekord rekord = Rekord.of(Sandvich.class).accepting(filling, bread, style);

}

The first type parameter in each of the Key<Sandvich, T> declarations identifies that key as one that can be used when creating Rekords of type Rekord<Sandvich>. This means that common key names that might occur in multiple contexts are kept separate by the type system. This helps you to avoid constructing a Rekord<Sandvich> containing a Key<Hair, Style> field. The Sandvich type acts as a kind of namespace for keys.

In Octarine, a Record is just a Record: it can contain key-value pairs using any keys you like. There is a reason for this. I wanted Octarine to move away altogether from the ORM pattern of mirroring types in a domain (database tables, for example) in the record types that represented values taken from that domain. The reason is that we are often interested in records that span domains; for example, if I join the Person table to the Address table, to get a record that represents a person together with their current address, that record will contain values drawn from the columns of both tables.

With Octarine, it’s quite legitimate to define collections of keys that refer to the columns in different tables, but to compose records that use keys from several such collections. Disambiguation of keys is done by prefixing the key name with the name of the interface it’s defined in, for example:

interface Person {
    Key name = Key.named("name");
    Key age = Key.named("age");
}

interface Address {
    Key name = Key.named("name");
    ListKey addressLines = ListKey.named("addressLines");
    Key postcode = Key.named("postcode");
}

Record record = Record.of(Person.name.of("Arthur Putey"), Person.age.of(37), Address.name.of("The Groves"), Address.addressLines.of("23 Acacia Avenue", "Sunderland"), Address.postcode.of("VB6 5UX"));

interface Person {

Key name = Key.named("name");

Key age = Key.named("age");

}

interface Address {

Key name = Key.named("name");

ListKey addressLines = ListKey.named("addressLines");

Key postcode = Key.named("postcode");

}

Record record = Record.of(Person.name.of("Arthur Putey"), Person.age.of(37), Address.name.of("The Groves"), Address.addressLines.of("23 Acacia Avenue", "Sunderland"), Address.postcode.of("VB6 5UX"));

Where Octarine uses type tags is in validation – given a Schema<T>, you can use it to extract a Valid<T> from a Record. It’s up to the schema to determine which keys are permitted/required, and with what values. Schemas can also be permissive, doing just enough validation to ensure that a record can be used in the expected way, but not objecting to the presence of unfamiliar key-value pairs. This seems to me to be the right way to deal with data at the edges of a system, where code that works with an older version of a protocol should not necessarily fail just because a newer version adds a few extra pieces of information. From the point of view of some code that works with Persons, the presence of some Address fields is neither here nor there.

Among the merits of Rekord’s approach is that it enlists the help of the compiler in making sure that data held in Rekords is coherent: there is a real sense in which a Rekord has a type, even though it is not an instance of that type in the traditional sense. Octarine trades off a bit of safety in the interests of flexibility, but also provides a mechanism for tagging records with types that can be used to verify that they are suitable for particular purposes. There’s no reason why each library could not be extended to support the other’s more/less permissive approach (as Karg does, for example, with its support for both typed and untyped keys).

clojure, Java 8

Higher-Order FizzBuzz

2014/05/16 domfox 1 Comment

Clojure (paste into an instarepl to see outputs):

(defn condition [pred? term]
  (fn [n] (if (pred? n) term "")))

(def fizz (condition #(zero? (mod % 3)) "fizz"))
(def buzz (condition #(zero? (mod % 5)) "buzz"))

(defn try-conditions [&amp; conditions]
  (fn [n] 
    (let [s (apply str (map #(% n) conditions))]
      (if (empty? s) (str n) s))))

(def fizzbuzz (try-conditions fizz buzz))
(def buzzfizz (try-conditions buzz fizz))

(map fizzbuzz (range 1 100))

(map buzzfizz (range 1 100))

(def bang (condition #(zero? (mod % 7)) "bang"))
(def fizzbuzzbang (try-conditions fizz buzz bang))

(map fizzbuzzbang (range 1 106))

(defn condition [pred? term]

(fn [n] (if (pred? n) term "")))

(def fizz (condition #(zero? (mod % 3)) "fizz"))

(def buzz (condition #(zero? (mod % 5)) "buzz"))

(defn try-conditions [& conditions]

(fn [n]

(let [s (apply str (map #(% n) conditions))]

(if (empty? s) (str n) s))))

(def fizzbuzz (try-conditions fizz buzz))

(def buzzfizz (try-conditions buzz fizz))

(map fizzbuzz (range 1 100))

(map buzzfizz (range 1 100))

(def bang (condition #(zero? (mod % 7)) "bang"))

(def fizzbuzzbang (try-conditions fizz buzz bang))

(map fizzbuzzbang (range 1 106))

Java 8:

public class FizzBuzzEtc {
    private static Function<Integer, String> condition(Predicate<Integer> p, String t) {
        return n -> p.test(n) ? t : "";
    }

    private static Function<Integer, String> tryConditions(Function<Integer, String>...conditions) {
        return n -> {
            String s = String.join("", Stream.of(conditions).map(c -> c.apply(n)).collect(Collectors.toList()));
            return s.isEmpty() ? Integer.toString(n) : s;
        };
    }

    private static void run(String description, Function<Integer, String>...conditions) {
        System.out.println("\n" + description + ":");
        IntStream.range(1, 106).boxed().map(tryConditions(conditions)).forEach(System.out::println);
    }

    public static void main(String[] argv) {
        Function<Integer, String> fizz = condition(n -> (n % 3) == 0, "fizz");
        Function<Integer, String> buzz = condition(n -> (n % 5) == 0, "buzz");
        Function<Integer, String> bang = condition(n -> (n % 7) == 0, "bang");

        run("FIZZBUZZ", fizz, buzz);
        run("BUZZFIZZ", buzz, fizz);
        run("FIZZBUZZBANG", fizz, buzz, bang);
    }
}

public class FizzBuzzEtc {

private static Function<Integer, String> condition(Predicate<Integer> p, String t) {

return n -> p.test(n) ? t : "";

}

private static Function<Integer, String> tryConditions(Function<Integer, String>...conditions) {

return n -> {

String s = String.join("", Stream.of(conditions).map(c -> c.apply(n)).collect(Collectors.toList()));

return s.isEmpty() ? Integer.toString(n) : s;

};

}

private static void run(String description, Function<Integer, String>...conditions) {

System.out.println("\n" + description + ":");

IntStream.range(1, 106).boxed().map(tryConditions(conditions)).forEach(System.out::println);

}

public static void main(String[] argv) {

Function<Integer, String> fizz = condition(n -> (n % 3) == 0, "fizz");

Function<Integer, String> buzz = condition(n -> (n % 5) == 0, "buzz");

Function<Integer, String> bang = condition(n -> (n % 7) == 0, "bang");

run("FIZZBUZZ", fizz, buzz);

run("BUZZFIZZ", buzz, fizz);

run("FIZZBUZZBANG", fizz, buzz, bang);

}

Conclusion: Java 8 is an acceptable functional programming language.

Java 8

Validation in Octarine

2014/05/08 domfox 1 Comment

A Record in Octarine is a heterogeneous map, whose keys carry type information about their values. The only type guarantee you get is that if a Record contains a Key<T> , then the value pointed to by that key will be of type T:

Key<String> name = Key.named("name");
Key<Integer> age = Key.named("age");

Record person = Record.of(name.of("Alceste"), age.of(53));

String personName = name.extract(person);
Integer personAge = age.extract(person);

Key<String> name = Key.named("name");

Key<Integer> age = Key.named("age");

Record person = Record.of(name.of("Alceste"), age.of(53));

String personName = name.extract(person);

Integer personAge = age.extract(person);

Some additional safety can be given by validating a Record against a Schema<T> . If the validation is successful, a Valid<T> can be obtained, which is a Record ornamented with a type tag linking it to the schema that validated it. You can then enlist the help of the compiler in ensuring that code that will only work with a Valid<T> is only ever passed a Valid<T> .

Here’s how it works:

interface Person {
  static final Key<String> name = Key.named("name");
  static final Key<Integer> age = Key.named("age");
  static final Schema<Person> schema = (record, validationErrors) -> {
    if (!name.test(record)) validationErrors.accept("Person must have a name");
    if (!age.test(record)) validationErrors.accept("Person must have an age");
    if (age.extract(record) < 0) validationErrors.accept("Age must be greater than or equal to 0");
  };
}

Validation<Person> result = Person.schema.validate(Person.name.of("Alceste"), Person.age.of(53));

// Throws an exception if the record did not pass validation.
Valid<Person> person = result.get(); 

// Formatter will only accept a Valid<Person>
Function<Valid<Person>, String> formatter = p -> 
  String.format("%s, age %d",
    Person.name.extract(p),
    Person.age.extract(p));

System.out.println(formatter.apply(person));

interface Person {

static final Key<String> name = Key.named("name");

static final Key<Integer> age = Key.named("age");

static final Schema<Person> schema = (record, validationErrors) -> {

if (!name.test(record)) validationErrors.accept("Person must have a name");

if (!age.test(record)) validationErrors.accept("Person must have an age");

if (age.extract(record) < 0) validationErrors.accept("Age must be greater than or equal to 0");

};

}

Validation<Person> result = Person.schema.validate(Person.name.of("Alceste"), Person.age.of(53));

// Throws an exception if the record did not pass validation.

Valid<Person> person = result.get();

// Formatter will only accept a Valid<Person>

Function<Valid<Person>, String> formatter = p ->

String.format("%s, age %d",

Person.name.extract(p),

Person.age.extract(p));

System.out.println(formatter.apply(person));

The Person interface here is never instantiated. It has two purposes:

To act as a holder for the Key s and Schema associated with Person s
To be used as a type tag identifying Record s that have passed validation as instances of Valid<Person>

The Schema<Person> is created from a lambda expression that consumes a record and a consumer of validation errors, to which it can send strings describing any errors that it detects. In the example above, we test for the presence of two keys, and apply an additional test to the value of the “age” key.

You can call Validation::isValid to find out whether validation has succeeded, and Validation::validationErrors to get a list of all the validation errors that have been detected. Only if the list of validation errors is empty will Validation::get return a Valid<T> ; otherwise a RecordValidationException will be thrown.

The tests for the presence of mandatory keys are a bit cumbersome, so you can use a KeySet to check that all the keys belonging to Person are present:

public interface Person {

    static final KeySet mandatoryKeys = new KeySet();
    static final Key<String> name = mandatoryKeys.add("name");
    static final Key<Integer> age = mandatoryKeys.add("age");
    
    static final Schema<Person> schema = (record, validationErrors) -> {
        mandatoryKeys.accept(record, validationErrors);
        if (age.extract(record) < 0) validationErrors.accept("Age must be 0 or greater");
    };

}

public interface Person {

static final KeySet mandatoryKeys = new KeySet();

static final Key<String> name = mandatoryKeys.add("name");

static final Key<Integer> age = mandatoryKeys.add("age");

static final Schema<Person> schema = (record, validationErrors) -> {

mandatoryKeys.accept(record, validationErrors);

if (age.extract(record) < 0) validationErrors.accept("Age must be 0 or greater");

};

}

Obviously, the compiler can’t guarantee that validation will succeed, since the tests carried out by the schema are only executed at runtime. However, you can subsequently guarantee that other code will only be passed a record that has been validated, by requiring a type of Valid<T> rather than just a plain Record . This is how Octarine’s validation provides a bridge between the type-unsafe world of external data, and the type-safe world of your program’s domain model.

Java 8

Enriching is Easy

2014/05/07 domfox

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

Category Archives: Java 8

Typeclasses in Java 8

What’s New In Octarine

Transformers

BeanRecords

Reflective JSON serialisation

Serialisation/deserialisation of maps

Extractors

Joink

Monoidal FizzBuzz

Octarine vs Rekord: Design Comparison

Higher-Order FizzBuzz

Validation in Octarine

Enriching is Easy

opting out of the ordinary human real