DRYing to Monad in Java8

DRYing to Monads
in
Java8
dhaval.dalal@software-artisan.com
@softwareartisan

class User {
private final String id;
private final String name;
User(final String id, final String name) {
this.id = id;
this.name = name;
}
public String getName() {
return name;
}
public String getId() {
return id;
}
}
Setting the context…

class Authenticator {
public User login(String id, String pwd) throws Exception {
// throw new Exception("password mismatch");
return new User(id, "Dhaval");
}
public User gmailLogin(String id, String pwd) throws Exception {
// throw new IOException("some problem");
return new User(id, "Dhaval");
}
public void twoFactor(User user, long pwd) {
// throw new RuntimeException("twoFactor Incorrect key");
}
}
class Dispatcher {
static void redirect(URL target) {
System.out.println("Going to => " + target);
}
}

class Test {
public static void main(String[] args) throws Exception {
final URL dashboard = new URL("http://dashboard");
final URL loginPage = new URL("http://login");
final String userid = "softwareartisan";
final String pwd = "1234";
User user;
Authenticator authenticator = new Authenticator();
try {
user = authenticator.login(userid, pwd);
} catch (Exception es) {
try {
user = authenticator.gmailLogin(userid, pwd);
} catch(Exception eg) {
Dispatcher.redirect(loginPage);
return;
}
}
URL target;
try {
long twoFactorPwd = 167840;
authenticator.twoFactor(user, twoFactorPwd);
target = dashboard;
} catch (Exception tfe) {
target = loginPage;
}
Dispatcher.redirect(target);
}
}
TheHappyPath

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
Do this ﬁrst
TheHappyPath

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
Do this ﬁrst
Do this Second
TheHappyPath

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
Do this ﬁrst
Do this Second
Do this Third
TheHappyPath

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
Modiﬁes user that got
declared outside the
block scope of try.
Modiﬁes target that
got declared outside the
block scope
of the try-catch

Pattern of Repeated
Behaviour
• Consume some data, return a result and pass it
to the next function for its consumption.
• This is a very common pattern, where we mutate
a temp variable, only to be passed to the next
function in chain.

Can we chain the two
try blocks and pass
data around implicitly?

But before chaining, we need to start with what is near
to us.
We have these functions wrapped in try blocks.
So thats our starting-point (near to us).
Ability to chain the functions wrapped in try blocks is
our goal and is far.
“From Near to Far”

• From Near to Far.
• That which is obvious and close to us now is the starting
point, a.k.a the inﬂection point.
• That which is far, and can be abstract is our goal.
• Take baby steps.
General Principles in
Refactoring

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
1
Essential code
wrapped in try
boiler-plate
TheHappyPath

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
1
Essential code
wrapped in try
boiler-plate
2
Essential Code
wrapped in try
boiler-plate
TheHappyPath

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
1
Essential code
wrapped in try
boiler-plate
2
Essential Code
wrapped in try
boiler-plate
3
Eventually
TheHappyPath

DRYing Boiler-plate
• Create a method that takes in different code blocks for try.
• Use lambda to wrap each code block and defer evaluation.
• As checked exception is thrown in the ﬁrst try block, a regular
Java8 Supplier<T> will not work
• Instead pass the code block using exceptional Supplier<T>
- lets call it SupplierThrowsException<T>
• Exceptional SAM wraps the code that throws exception in a
lambda, catches it and returns T.
• We can do the same for the next try computation executed on
success.

Tiding up…
@FunctionalInterface
interface SupplierThrowsException<T, E extends Exception> {
T get() throws E;
}
class Test {
static <T, E extends Exception>
T tryWith(SupplierThrowsException<T, E> s) {
try {
return s.get();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static void main(String[] args) throws Exception { … }
}

Tidingup…
class Test {
User user;
try {
user = Test.tryWith(() -> authenticator.login(userid, pwd));
try {
user = Test.tryWith(() -> authenticator.gmailLogin(userid, pwd));
return;
}
}
URL target;
try {
target = Test.tryWith(() -> {
return dashboard;
});
target = dashboard;
target = loginPage;
}

Tidingup…
class Test {
User user;
try {
user = Test.tryWith(() -> authenticator.login(userid, pwd));
try {
user = Test.tryWith(() -> authenticator.gmailLogin(userid, pwd));
return;
}
}
URL target;
try {
target = Test.tryWith(() -> {
return dashboard;
});
target = loginPage;
}
}
}
Compilation Error!!
“local variables referenced
from a lambda expression
must be ﬁnal or effectively
ﬁnal”

Lets Pause and Reﬂect…
• Can we contain the user in a CUSTOM
CONTAINER, so that we can pass it to the next
computation in sequence, without needing to
reach outside the block scope of try-catch?
• Yes, that will solve the problem of declaring a user
outside.
• The container will hold the user within it (implicit data) and
pass it to the next computation in sequence.

Create a
Try<T> Container
Checked or
Unchecked
Exception.
Success
Failure
Value
Input(s)
Computation
It holds either the success value or the exception
resulting from the executing computation.

class Test {
try {
return s.get();
}
}
}
IntroducingTry<T>

class Test {
try {
return s.get();
}
}
}
IntroducingTry<T> class Try<T> {
T with(SupplierThrowsException<T, E> s) {
try {
return s.get();
}
}
}

Introduce Polymorphic
variants of Try<T>
• Success<T> - holds successful result of
computation.
• Failure<T> - holds exception from
computation.

VariantsofTry<T> class Try<T> {
Try<T> with(SupplierThrowsException<T, E> s) {
try {
return new Success<>(s.get());
return s.get();
return new Failure<>(e);
}
}
}
class Success<T> extends Try<T> {
private final T value;
Success(T value) { this.value = value; }
}
class Failure<T> extends Try<T> {
private final Exception e;
Failure(Exception e) { this.e = e; }
}

ApplyingTry<T>
class Test {
Try<User> user;
try {
user = Try.with(() -> authenticator.login(userid, pwd));
try {
user = Try.with(() -> authenticator.gmailLogin(userid, pwd));
return;
}
}
Try<URL> target;
try {
target = Try.with(() -> {
return dashboard;
});
target = loginPage;
}
}
}

class Test {
Try<User> user;
try {
user = Try.with(() -> authenticator.login(userid, pwd));
try {
user = Try.with(() -> authenticator.gmailLogin(userid, pwd));
return;
}
}
Try<URL> target;
try {
target = Try.with(() -> {
return dashboard;
});
target = loginPage;
}
}
}
Compilation Error
“Incompatible types: Try<User>
cannot be converted to
User”
ApplyingTry<T>

Time to address the
question:
How can we chain
the next try block?

Introducing chain
• Allows us to chain the two try blocks.
• Facilitate passing result/exception of earlier
computation on left (which is this) to the one
on right.
// (LEFT) returns Try<User>
Try.with(() -> authenticator.login(userid, pwd));
// (RIGHT) returns Try<URL>
Try.with(() -> {
return dashboard;
});

Signature of chain
• Consumes a function that goes from: User -> Try<URL>
• Generically, a function from T -> Try
• Produces Try<URL>
• Generically Try
• Try chain(Function<T, Try> f)
Try.with(() -> authenticator.login(userid, pwd))
.chain(user -> Try.with(() -> {
return dashboard;
}); // returns Try<URL>

Addingchain abstract class Try<T> {
Try<T> with(SupplierThrowsException<T, E> s) { … }
public abstract Try chain(Function<T, Try> f);
}
public Try chain(Function<T, Try> f) {
try { return f.apply(value); }
catch (Exception e) { return new Failure(e); }
}
}
public Try chain(Function<T, Try> f) {
return (Try) this;
}
}

class Test {
Try<URL> target = Try.with(() -> authenticator.login(userid, pwd))
return new URL("http://dashboard");
}));
}
}
Applying chain

class Test {
URL loginPage = new URL("http://login");
String userid = "softwareartisan";
String pwd = "1234";
}));
}
}
Applying chain
Compilation Error
“Incompatible types: Try<URL>
cannot be converted to
URL”

Addingget()
abstract class Try<T> {
Try<T> with(SupplierThrowsException<T, E> s) {
try { return new Success<>(s.get()); }
catch (Exception e) { return new Failure<>(e); }
}
public abstract T get();
}
public Try chain(Function<T, Try> f) { … }
public T get() { return value; }
}
public T get() {
throw new RuntimeException("Failure cannot return", e);
}
}

class Test {
}));
Dispatcher.redirect(target.get());
}
}
Applying get

Visualizing the pipes
so far…
Try.with (system login)
chain (two factor authentication)
URL
Unhandled
Errors
Dashboard

class Test {
}));
}
}
// We have yet to tackle:
// 1. Recovery using gmailLogin
// 2. What about failure?
// 3. What about redirection to login URL upon failure (because
// of either login, or gmailLogin or twoFactor).
PendingItems

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
FailureRecovery

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
Try this ﬁrst
FailureRecovery

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
Try this ﬁrst
FailureRecovery
In case of failure,
recover with

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
Try this ﬁrst
Do this Second
FailureRecovery
In case of failure,
recover with

Introducing recoverWith
• Inside a Try<T> if the computation throws an
exception, we need to give it a chance to recover
from failure.
• Create a method recoverWith on Try<T> that
allows us to chain the code block inside catch.
• What will recoverWith’s signature look like?
• Consumes a function that goes from Throwable ->
Try<User>, generically, a function from Throwable ->
Try
• Produces Try<User>, generically Try

AddingrecoverWith
public abstract Try recoverWith(Function<Exception, Try> f);
}
public Try recoverWith(Function<Exception, Try> f) {
return (Try) this;
}
}
public T get() { … }
public Try recoverWith(Function<Exception, Try> f) {
try { return f.apply(e); }
catch (Exception e) { return new Failure(e); }
}
}

Applying recoverWith
class Test {
.recoverWith(e -> Try.with(() ->
authenticator.gmailLogin(userid, pwd)))
}))
}
}

again…
Try.with (System login)
recoverWith (gmail login)
URL
Unhandled
Errors
Dashboard

PendingItemsclass Test {
}))
}
}
// 3. What about the login URL redirection upon failure due to
// either login, or gmailLogin or twoFactor.

class Test {
URL dashboard = new URL("http://dashboard");
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
IfRecoveryfails…

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
IfRecoveryfails…
If recovery fails,
then do this and
go back

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
IfRecoveryfails…
If recovery fails,
then do this and
go back
Don’t execute
this at all

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
IftwoFactorfails…

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
IftwoFactorfails…
If twoFactor
fails, set target
to loginPage

Introducing orElse
• If recovery fails or if the next computation in the chain fails.
What do we do?
• Can we attach handlers as in the Chain of Responsibility
pattern?
• Create a method orElse on Try<T> that allows us to set-
up a handler chain.
• What will orElse’ signature look like?
• Consumes a Try<URL>,
• Generically, a Try
• Produces Try<URL>, generically Try

AddingorElse abstract class Try<T> {
public abstract Try<T> orElse(Try<T> other);
}
public Try recoverWith(Function<Exception, Try> f) { … }
public Try<T> orElse(Try<T> other) { return this; }
}
public Try<T> orElse(Try<T> other) { return other; }
}

Applying orElse
class Test {
public static void main(String[] args) {
}))
.orElse(Try.with(() -> new URL("http://login"))
}
}

again…Try.with (System login)
recoverWith (gmail login)
URL
Unhandled
Errors
Dashboard
orElse (login URL)

PendingItems class Test {
}))
}
}
// 3. What about the login URL redirection upon failure due to
// either login, or gmailLogin or twoFactor.

Getting from get is
Dangerous
• For Success, we get the actual value.
• For Failure, it throws.
• To do something useful with Success, we
consume its value.
• Whereas upon Failure, we have nothing to
consume.

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
Aftergettingvalue…
were-direct

class Test {
User user;
try {
try {
return;
}
}
URL target;
try {
target = dashboard;
target = loginPage;
}
}
}
Perform
Side-effect
Aftergettingvalue…
were-direct

Introducing forEach
• What will forEach’s signature look like?
• Consumes a function that goes from URL -> (),
• Generically, a function from T -> (), this is our friendly
Java8 Consumer<T>
• Produces nothing - void

AddingforEach
public abstract Try<T> orElse(Try<T> defaultValue);
public abstract void forEach(Consumer<T> c);
}
public Try<T> orElse(Try<T> defaultValue) { return this; }
public void forEach(Consumer<T> c) { c.accept(value); }
}
public Try<T> orElse(Try<T> defaultValue) { return defaultValue; }
public void forEach(Consumer<T> c) { }
}

Applying forEach
class Test {
}))
.forEach(target -> Dispatcher.redirect(target));
}
}

Finally we are here!
class Test {
}))
.forEach(Dispatcher::redirect);
}
}

Implementation available
on
http://dhavaldalal.github.io/Java8-Try

Monad
• One can view a Monad as representing a context and
we want to do computations within that context.
• chain - chains output of one function into the input of
the other, i.e., transform a function into composable
form
• inject - to inject a regular value in to the chain
• For Try<T> the value is a code block and, inject == with.
• chain + inject - these core functions deﬁne a
Monad.
Notions of Chaining and
Injection (Getting inside the Chain)

Observations
• Monad functions run the code in the context of
the monad itself by unwrapping the result.
• These functions let us use the value from its
monadic wrapper.
• Monad controls what happens inside it and what
gets out.

Essence of Try<T>
• Bring catching exceptions (a side-effect) under
control using compositionality.
• Pass the result of computation to a subsequent
computation in the chain.
• By-pass the chain of evaluation in case a
computation fails.
• Recover with other computation or a value and if
everything fails, resort to default handler in the
chain of responsibility.

Monad Laws
• Left Unit
• inject(x).chain(f) == f(x)
• Right Unit
• M.chain(inject) == M
• Associative
• (M.chain(f)).chain(g) == M.chain((x -> f(x)).chain(g))
with
Try

Practical Interpretation of
Monad Laws
• Left Unit: inject(x).chain(f) == f(x)
• Don’t complicate un-necessarily, if you know you can use f(x)
• The long form is identical in its effect to the short form.
• Right Unit: M.chain(inject) == M
• Again, the long form is identical in its effect to the short form.
• Associative: (M.chain(f)).chain(g) == M.chain((x ->
f(x)).chain(g))
• Refactor or Break up big computations in to smaller ones, and re-group
(compose) to create new computations while preserving their ordering.

Monad Laws
• Left Unit fails for Try<T>. Why?
• Try.with(expr).chain(f) != f(expr)

Monad Laws
x
LHS will
never raise
an exception
RHS will raise
an exception
thrown by f
or by expr

Monad Laws
x
LHS will
never raise
an exception
RHS will raise
an exception
thrown by f
or by expr
• Right Unit and Associative laws hold for Try.
• For practical purposes, you can still treat it as a Monad

Essence of Monads
• Bring the world of side-effects under control using
compositionality. (Brian Beckman)
• Compositionality is the way to control Complexity.
(Brian Beckman)
• Monads are commonly used to order sequences of
computation, but are not about ordering or sequencing.
(Haskell Wiki)
• Monads capture a -- very speciﬁc -- relationship
between values of a speciﬁc domain into a common
abstraction. (Haskell Wiki)
• Monadic structures are very common in our day-to-day
programming.

Language chain is a.k.a…
Scala flatMap or map and flatten
Java8 flatMap
C# SelectMany
Clojure mapcat
Haskell bind or >>=
Ruby flat_map
Groovy collect and flatten
Different names but are the same

References
• Real world Haskell
• Bryan O’ Sullivan, John Goerzen & Don Stewart.
• Don’t fear the Monad! - Channel 9
• Brian Beckman
• Principles of Reactive Programming - Coursera Course.
• Martin Odersky, Eric Meijer and Roland Kuhn
• Integral Education
• Sri Aurobindo’s Work and Sraddhalu Ranade’s talk.

DRYing to Monad in Java8

More Related Content

What's hot

Similar to DRYing to Monad in Java8

More from Dhaval Dalal

Recently uploaded

DRYing to Monad in Java8