kemitix/mon
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #36 from kemitix/next

Browse source 
Next
This commit is contained in:
Paul Campbell 2018-07-12 22:21:36 +01:00 committed by GitHub
commit a9d28c9950
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 143 additions and 18 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
CHANGELOG
View file

@ -1,6 +1,13 @@
CHANGELOG
=========
0.11.0
* Rename `Result.maybeThen()` as `Result.flatMapMaybe()`
* Add `Maybe.match(Consumer,Runnable)`
* Add `Maybe.isJust()`
* Add `Maybe.isNothing()`
0.10.0
------

15
src/main/java/net/kemitix/mon/maybe/Just.java
View file

@ -44,6 +44,16 @@ final class Just<T> implements Maybe<T> {
private final T value;
@Override
public boolean isJust() {
return true;
}
@Override
public boolean isNothing() {
return false;
}
@Override
public <R> Maybe<R> flatMap(final Function<T, Maybe<R>> f) {
return f.apply(value);
@ -98,6 +108,11 @@ final class Just<T> implements Maybe<T> {
// ignore - not nothing
}
@Override
public void match(final Consumer<T> justMatcher, final Runnable nothingMatcher) {
justMatcher.accept(value);
}
@Override
public void orElseThrow(final Supplier<Exception> e) {
// do not throw

22
src/main/java/net/kemitix/mon/maybe/Maybe.java
View file

@ -76,6 +76,20 @@ public interface Maybe<T> extends Functor<T, Maybe<?>> {
return just(value);
}
/**
* Checks if the Maybe is a Just.
*
* @return true if the Maybe is a Just
*/
boolean isJust();
/**
* Checks if the Maybe is Nothing.
*
* @return true if the Maybe is Nothing
*/
boolean isNothing();
/**
* Monad binder maps the Maybe into another Maybe using the binder method f.
*
@ -149,4 +163,12 @@ public interface Maybe<T> extends Functor<T, Maybe<?>> {
* @param runnable the runnable to call if this is a Nothing
*/
void ifNothing(Runnable runnable);
/**
* Matches the Maybe, either just or nothing, and performs either the Consumer, for Just, or Runnable for nothing.
*
* @param justMatcher the Consumer to pass the value of a Just to
* @param nothingMatcher the Runnable to call if the Maybe is a Nothing
*/
void match(Consumer<T> justMatcher, Runnable nothingMatcher);
}

16
src/main/java/net/kemitix/mon/maybe/Nothing.java
View file

@ -34,10 +34,21 @@ import java.util.stream.Stream;
* @param <T> the type of the missing content
* @author Paul Campbell (pcampbell@kemitix.net)
*/
@SuppressWarnings("methodcount")
final class Nothing<T> implements Maybe<T> {
static final Maybe<?> INSTANCE = new Nothing<>();
@Override
public boolean isJust() {
return false;
}
@Override
public boolean isNothing() {
return true;
}
@Override
public <R> Maybe<R> flatMap(final Function<T, Maybe<R>> f) {
return Maybe.nothing();
@ -79,6 +90,11 @@ final class Nothing<T> implements Maybe<T> {
runnable.run();
}
@Override
public void match(final Consumer<T> justMatcher, final Runnable nothingMatcher) {
nothingMatcher.run();
}
@Override
public void orElseThrow(final Supplier<Exception> e) throws Exception {
throw e.get();

6
src/main/java/net/kemitix/mon/result/Result.java
View file

@ -129,19 +129,19 @@ public interface Result<T> extends Functor<T, Result<?>> {
* @param <R> the type of the updated Result
* @return a new Maybe within a Result
*/
static <T, R> Result<Maybe<R>> maybeThen(Result<Maybe<T>> maybeResult, Function<Maybe<T>, Result<Maybe<R>>> f) {
static <T, R> Result<Maybe<R>> flatMapMaybe(Result<Maybe<T>> maybeResult, Function<Maybe<T>, Result<Maybe<R>>> f) {
return maybeResult.flatMap(f);
}
/**
* Checks of the Result is an error.
* Checks if the Result is an error.
*
* @return true if the Result is an error.
*/
boolean isError();
/**
* Checks of the Result is a success.
* Checks if the Result is a success.
*
* @return true if the Result is a success.
*/

69
src/test/java/net/kemitix/mon/MaybeTest.java
View file

@ -22,7 +22,7 @@ public class MaybeTest implements WithAssertions {
@Test
public void justMustBeNonNull() {
assertThatNullPointerException().isThrownBy(() -> just(null))
.withMessageContaining("value");
.withMessageContaining("value");
}
@Test
@ -84,7 +84,7 @@ public class MaybeTest implements WithAssertions {
public void toOptional() {
assertThat(just(1).toOptional()).isEqualTo(Optional.of(1));
assertThat(nothing()
.toOptional()).isEqualTo(Optional.empty());
.toOptional()).isEqualTo(Optional.empty());
}
@Test
@ -194,4 +194,69 @@ public class MaybeTest implements WithAssertions {
assertThat(capture).isTrue();
}
@Test
public void just_whenMatch_thenJustTriggers() {
//given
final Maybe<Integer> maybe = Maybe.just(1);
//then
maybe.match(
just -> assertThat(just).isEqualTo(1),
() -> fail("Not nothing")
);
}
@Test
public void nothing_whenMatch_thenNothingTriggers() {
//given
final Maybe<Integer> maybe = Maybe.nothing();
final AtomicBoolean flag = new AtomicBoolean(false);
//when
maybe.match(
just -> fail("Not a just"),
() -> flag.set(true)
);
//then
assertThat(flag).isTrue();
}
@Test
public void just_isJust_isTrue() {
//given
final Maybe<Integer> maybe = just(1);
//when
final boolean isJust = maybe.isJust();
//then
assertThat(isJust).isTrue();
}
@Test
public void just_isNothing_isFalse() {
//given
final Maybe<Integer> maybe = just(1);
//when
final boolean isNothing = maybe.isNothing();
//then
assertThat(isNothing).isFalse();
}
@Test
public void nothing_isJust_isFalse() {
//given
final Maybe<Object> maybe = nothing();
//when
final boolean isJust = maybe.isJust();
//then
assertThat(isJust).isFalse();
}
@Test
public void nothing_isNothing_isTrue() {
//given
final Maybe<Object> maybe = nothing();
//when
final boolean isNothing = maybe.isNothing();
//then
assertThat(isNothing).isTrue();
}
}

26
src/test/java/net/kemitix/mon/ResultTest.java
View file

@ -605,24 +605,24 @@ public class ResultTest implements WithAssertions {
}
@Test
public void okayJust_whenMaybeThen_whereOkayJust_thenIsOkayJust() {
public void okayJust_whenFlatMapMaybe_whereOkayJust_thenIsOkayJust() {
//given
final Result<Maybe<Integer>> okJust = Result.ok(Maybe.just(1));
//when
final Result<Maybe<Integer>> result = Result.maybeThen(okJust, mv -> Result.ok(Maybe.just(2)));
final Result<Maybe<String>> result = Result.flatMapMaybe(okJust, maybe -> Result.ok(maybe.flatMap(v -> Maybe.just("2"))));
//then
result.match(
success -> assertThat(success.toOptional()).contains(2),
success -> assertThat(success.toOptional()).contains("2"),
error -> fail("Not an error")
);
}
@Test
public void okayJust_whenMaybeThen_whereOkayNothing_thenIsOkayNothing() {
public void okayJust_whenFlatMapMaybe_whereOkayNothing_thenIsOkayNothing() {
//given
final Result<Maybe<Integer>> okJust = Result.ok(Maybe.just(1));
//when
final Result<Maybe<Integer>> result = Result.maybeThen(okJust, v -> Result.ok(Maybe.nothing()));
final Result<Maybe<String>> result = Result.flatMapMaybe(okJust, maybe -> Result.ok(maybe.flatMap(v -> Maybe.nothing())));
//then
result.match(
success -> assertThat(success.toOptional()).isEmpty(),
@ -631,12 +631,12 @@ public class ResultTest implements WithAssertions {
}
@Test
public void okayJust_whenMaybeThen_whereError_thenIsError() {
public void okayJust_whenFlatMapMaybe_whereError_thenIsError() {
//given
final Result<Maybe<Integer>> okJust = Result.ok(Maybe.just(1));
final RuntimeException exception = new RuntimeException();
//when
final Result<Maybe<Integer>> result = Result.maybeThen(okJust, v -> Result.error(exception));
final Result<Maybe<Integer>> result = Result.flatMapMaybe(okJust, v -> Result.error(exception));
//then
result.match(
success -> fail("Not a success"),
@ -645,27 +645,27 @@ public class ResultTest implements WithAssertions {
}
@Test
public void okayNothing_whenMaybeThen_thenDoNotApply() {
public void okayNothing_whenFlatMapMaybe_thenDoNotApply() {
//given
final Result<Maybe<Integer>> okNothing = Result.ok(Maybe.nothing());
//when
final Result<Maybe<Integer>> result = Result.maybeThen(okNothing, v -> Result.ok(Maybe.just(2)));
final Result<Maybe<String>> result = Result.flatMapMaybe(okNothing, maybe -> Result.ok(maybe.flatMap(v -> Maybe.just("2"))));
//then
okNothing.match(
result.match(
success -> assertThat(success.toOptional()).isEmpty(),
error -> fail("Not an error")
);
}
@Test
public void error_whenMaybeThen_thenDoNotApply() {
public void error_whenFlatMapMaybe_thenDoNotApply() {
//given
final RuntimeException exception = new RuntimeException();
final Result<Maybe<Integer>> maybeResult = Result.error(exception);
//when
final Result<Maybe<Integer>> result = Result.maybeThen(maybeResult, v -> Result.ok(Maybe.just(2)));
final Result<Maybe<String>> result = Result.flatMapMaybe(maybeResult, maybe -> Result.ok(maybe.flatMap(v -> Maybe.just("2"))));
//then
maybeResult.match(
result.match(
success -> fail("Not a success"),
error -> assertThat(error).isSameAs(exception)
);