funzy
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
sneakyThrowtechnique, which basically let youthrowchecked exceptions like they wereruntimeexceptions.
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'