GitHub - jooby-project/funzy: Functional Idioms for Java 8

Functional Idioms for Java 8. Funzy is a small/zero-dependencies library with two specific goals:

Provides functional idioms for traditional Java statements
Simplify exception handling and reduces the noise of checked exception while working with lambdas.

design

This library make use of the sneakyThrow technique, which basically let you throw checked exceptions like they were runtime exceptions.

when idiom

Basic example:

import org.jooby.funzy.When.when;

...
Object value = ...;

String result = when(value)
    .is(1, "Got a number")
    .is(2, "Got a string")
    .get();

System.out.println(result);

Auto-cast example:

import org.jooby.funzy.When.when;

...
Object value = ...;

int result = when(value)
    .is(Integer.class, x -> x * 2)
    .orElse(-1);

System.out.println(result);

Throw an exception if no match:

import org.jooby.funzy.When.when;

...
Object value = ...;

String result = when(value)
    .is(Integer.class, "int")
    .is(Long.class, "long")
    .is(Float.class, "float")
    .is(Double.class, "double")
    .orElseThrow(() -> new IllegalArgumentException("NaN"));

System.out.println(result);

Advanced usage via predicates

import org.jooby.funzy.When.when;

...
String value = ...;

String result = when(value)
    .is(s -> s.startsWith("http://"), this::parseUrl)
    .is(s -> s.startsWith("ftp://"), this::parseUrl)
    .orElseThrow(() -> new IllegalArgumentException("Unknown protocol: " + value));

System.out.println(result);

Try idiom

Functional try:

Get a computed value or throw an exception (checked or not):

String value = ...;

int number = Try.apply(() -> {
    return Integer.parseInt(value);
  })
  .get();

Side effect try:

Run some exceptional code and rethrow the exception (checked or not) in case of failure.

String value = ...;

Try.run(() -> {
  runSomeExceptionalCode();
}).throwException();

onSuccess, onFailure and onComplete

Complete callback, executed success or failure (works as finally clause):

String value = ...;

Try.apply(() -> {
  return someExceptionalCode();
}).onSuccess(() -> {
  System.out.println("Success");
}).onFailure(x -> {
  System.out.println("Exception ");
  x.printStacktrace();
}).onComplete(() -> {
  System.out.println("Always executed");
})
.get();

recover, orElse, orElseGet

Recover:

String value = ...;

Try.apply(() -> {
  return someExceptionalCode();
}).recover(x -> {
  System.out.println("Got exception " + x);
  return recoverValue();
})
.get();

Recover from specific exception:

String value = ...;

Try.apply(() -> {
  return someExceptionalCode();
}).recover(SomeException.class, x -> {
  System.out.println("Got SomeException");
  return recoverValue();
})
.get();

Default result value:

String value = Try.apply(() -> {
  return someExceptionalCode();
})
.orElse("default value");

Default lazy result value:

String value = Try.apply(() -> {
  return someExceptionalCode();
})
.orElseGet(() -> computeDefaultValue());

unwrap

Invoke a method using reflection and get the result or unwrap InvocationTargetException.class and rethrow the casue

Object value = Try.apply(() -> {
  Method method = ...;
  return method.invoke(...);
}).unwrap(InvocationTargetException.class)
  .get();

wrap

Wrap any potential exception under a common/custom exception:

Object value = Try.apply(() -> {
  return someExceptionalCode();
}).wrap(x -> new IllegalStateException("Caught exception", x))
  .get();

Try-with-resources idiom

Copy two streams:

Try.of(in, out)
  .run((from, to) -> copy(from, to))
  .throwException();

Run jdbc query:

Try.with(() -> newConnection())
  .map(connection -> connection.preparedStatement("select * from awesome-funzy"))
  .map(statement -> statement.executeQuery())
  .apply(resultSet -> {
    ...
  })
  .get();

Throwable interfaces

We do provide throwable 100% interfaces for:

Consumer
Function
Supplier
Predicate
BiFunction
BiConsumer

File read example:

import static org.jooby.funzy.Throwing.throwingFunction;

Throwing.Function<String, String> fn = ;

Arrays.asList("f1.txt", "f2.txt")
  .stream()
  .map(throwingFunction(file -> {
         return readContent(file);
  }))
  .collect(Collectors.toList());

Additional 8 arguments version for Consumer and Function. All them accessible via Throwing class:

dependency

maven

<dependency>
  <groupId>org.jooby</groupId>
  <artifactId>funzy</artifactId>
  <version>0.1.0</version>
</dependency>

gradle

compile: 'org.jooby:funzy:0.1.0'

license

Apache License 2