// run does not take anything nor does it return any result.
doSomething(shh(() -> doItWithAnnoyance.run());
// accept returns nothing
doSomething(shh(x -> doItWithAnnoyance. accept(x)));
// get takes no argument and returns a result.
doSomething(shh(() -> doItWithAnnoyance.get());

// doItWithAnnoyance takes more than two arguments and returns a result
doSomething(shh((id, name, isMember, code) -> doItWithAnnoyance(id, name, isMember, code)));

// There should be shh for functions using primitive types. e.g.) BooleanSupplier, IntConsumer, IntFunction, etc.

public class Something {

  public String checkIt2(Integer i1, Integer i2) {
    return "The params are " + i1 + " and " + i2 + ".";
  }

  public String checkIt3(Integer i1, Integer i2, Integer i3) {
    return "The params are " + i1 + ", " + i2 + " and " + i3 + ".";
  }
}

// Then checkIt2 and checkIt3 can be curried using currying methods.
import static cc.kevinlee.functional.spicy.Curry.*;

final Something something = new Something();
final Function<Integer, String> function = currying(something::checkIt2, 1);
System.out.println(function.apply(2));      // result: "The params are 1 and 2."

final Function2<Integer, Integer, String> function2 = currying(something::checkIt3, 1);
System.out.println(function2.apply(2, 3));  // result: "The params are 1, 2 and 3."

Maybe.just(1).toOptional();
Maybe.<Integer>nothing().toOptional();

Maybe.maybe(Maybe.maybe(999));
// Maybe<Just> = Just(Maybe<Integer> = Just(999))

Maybe.maybe(Maybe.maybe(999));
// Maybe<Maybe<Integer>> = Just(Just(999))

Maybe.maybe(Maybe.maybe(Maybe.maybe(999)));
// Maybe<Maybe<Integer>> = Just(Just(Just(999)))

Maybe.maybe(Maybe.maybe(Maybe.nothing()));
// Maybe<Maybe<Maybe>> = Just(Just(Nothing))

Maybe.just(1) // Maybe<Integer> = Just(1)
Maybe.just<String>(null) // Maybe<String> = Nothing
Maybe.nothing<String>() // Maybe<String> = Nothing

Maybe.just(1).map(n -> n + 99) // Maybe<Integer> = Just(100)
Maybe.nothing<Integer>().map(n -> n * 2) // Maybe<Integer> = Nothing

final Integer maybeX = Maybe.just(123); // Maybe<Integer> = Just(123)
final Integer maybeY = Maybe.just(111); // Maybe<Integer> = Just(111)

maybeX.flatMap(x -> maybeY.map(y -> x + y)) // Maybe<Integer> = Just(234)

Maybe.just(11).filter(x -> x < 10) // Maybe<Integer> = Nothing
Maybe.just(11).filter(x -> x > 10) // Maybe<Integer> = Just(11)

Maybe.nothing<Integer>().filter(x -> x >= 0) // Maybe<Integer> = Nothing
Maybe.nothing<Integer>().filter(x -> x < 0) // Maybe<Integer> = Nothing
Maybe.nothing<Integer>().filter(x -> true) // Maybe<Integer> = Nothing

Maybe.just(5).ap(() -> Maybe.just(i -> i * 2)) // Maybe<Integer> = Just(10)
Maybe.nothing<Integer>().ap(() -> Maybe.nothing()) // Maybe<Integer> = Nothing

Maybe.just(3).fold(x -> x * x, () -> 0) // Integer = 9
Maybe.just(3).fold(x -> x.toString, () -> "no value") // String = "3"

Maybe.nothing<Integer>().fold(x -> x * x, () -> 0) // Integer = 0
Maybe.nothing<Integer>().fold(x -> x.toString(), () -> "no value") // String = "no value"

Maybe.just(999).getOrElse(() -> 0) // Integer = 999
Maybe.nothing<Integer>().getOrElse(() -> 0) // Integer = 0

Maybe.just(999).orElse(() -> Maybe.just(111)) // Maybe<Integer> = 999
Maybe.nothing<Integer>().orElse(() -> Maybe.just(111)) // Maybe<Integer> = 111

Maybe.just(999).isJust() // boolean = true
Maybe.just(999).isNothing() // boolean = false
Maybe.nothing<Integer>().isJust() // boolean = false
Maybe.nothing<Integer>().isNothing() // boolean = true

Maybe.just(5).forEach(System.out::println) // "5" is printed out
Maybe.nothing<Integer>().forEach(System.out::println) // nothing happens.

final Either<String, Integer> a = Either.right(123);
Maybe.fromEither(a) // Maybe<Integer> = Just(123)

final Either<String, Integer> b = Either.left("error");
Maybe.fromEither(b) // Maybe<Integer> = Nothing

final Optional<String> a = Optional.ofNullable(null); // Optional.empty
Maybe.fromOptional(a) // Maybe<String> = Nothing

final Optional<String> a = Optional.ofNullable("abc"); // Optional<String> // Optional(abc)
Maybe.fromOptional(a) // Maybe<String> = Just("abc")

  private <E, T> T doItWithAnnoyance(E whatEver) throws Exception {
    throw new Exception("Annoying exception!");
  }

  private static <E, T> T testSomething(E someInput, Function<E, T> function) {
    return function.apply(someInput);
  }

  // ...
  testSomething(whatever, this::doItWithAnnoyance);  // <- compile time error: Unhandled exception: java.lang.Exception
  testSomething(null, x -> doItWithAnnoyance(x));    // <- compile time error: Unhandled exception: java.lang.Exception
  // ...

  testSomething(whatever, shh(this::doItWithAnnoyance));  // <- NO compile time error anymore
  testSomething(null, shh(x -> doItWithAnnoyance(x)));    // <- NO compile time error anymore

final Function4<Integer, Integer, Integer, Integer, Integer> f4 = (i1, i2, i3, i4) -> i1 + i2 + i3 + i4;
final Function3<Integer, Integer, Integer, Integer> plus1000 = f4.curried(1000);

System.out.println(plus1000.apply(200, 30, 4));  // result: 1234
System.out.println(plus1000.apply(1, 2, 3));     // result: 1006

final Function2<Integer, Integer, Integer> f2 = (i1, i2) -> i1 + i2;
final Function<Integer, Integer> plus1 = f2.curried(1);

System.out.println(plus1.apply(1));    // result: 2
System.out.println(plus1.apply(9));    // result: 10

Maybe.just(null) // Nothing
Maybe.just(1) // Just(1)

Maybe.maybe(null) // Nothing
Maybe.maybe(1) // Just(1)

Maybe.just(1).fold(() -> "no number", i -> "number: " + i)
// String = number: 1

Maybe.<Integer>nothing().fold(() -> "no number", i -> "number: " + i)
// String = no number

Functions.applying(...) // too long!

Maybe.just(1).toEither(() -> "error");
Maybe.<Integer>nothing().toEither(() -> "error");

final Consumer2<Integer, Integer> addAndPrint = (i1, i2) -> System.out.println("i1 + i2 = " + (i1 + i2));
final Consumer<Integer> addTenAndPrint = addAndPrint.curried(10);

System.out.println(addAndPrint.accept(1 , 2));     // result: i1 + i2 = 3
System.out.println(addTenAndPrint.accept(101));    // result: i1 + i2 = 111

public void foo() throws RuntimeException {
  try {
   // some code
    doSomething();
  } catch (final SomeException ex) {
    throw new RuntimeException(ex);
  }
}

runOrRethrowCause(SomeException.class, () -> foo()) // will throw SomeException

Either.<String, Integer>right(1).getLeftOrElse(() -> "Default"); // String = Default
Either.<String, Integer>left("ERROR").getLeftOrElse(() -> "Default"); // String = ERROR

public Either<SomeError, User> doSomething(final String id) {
  try {
    final Something something = doActualWork(id);
    return Either.right(something);
  }
  catch (final SomeRuntimeExeption e) {
    return Either.left(new SomeError(e));
  }
}

public class UserError {
  public abstract String getMessage();

  static class UserNotFound extends UserError {
    private final String id;
    public UserNotFound(String id) {
      this.id = id;
    }

    @Override
    public String getMessage() {
      return "User with the given id, " + id +", not found";
    }
  }

  public static UserError userNotFound(final String id) {
    return new UserNotFound(id);
  }
}

public Either<UserError, User> updateEmail(final String id, final Email email) {
  return Either.fromOptional(
      findUser(id)
    , () -> UserError.userNotFound(id)
    )
    .map(user -> user.setEmail(email));      
}

final Either<UserNotFoundError, User> userFound = UserService.findUser(id);
return userFound.map(
  User::getFullName // getFullName returns String
);

// result might be either Left(UserNotFoundError) 
// or Right("User's full name")

final Either<UserNotFoundError, User> userFound = UserService.findUser(id);
return userFound.leftMap(
  UserNotFoundError::getMessage // getMessage returns String
);

// result might be either Left(String) 
// or Right(User)

final Integer num1 = 5;

final Integer result1 = useIfSatisfy(num1, i -> i > 0, () -> 1);  // result: 5 as 5 is greater than 0.
final Integer result2 = useIfSatisfy(num1, i -> i < 0, () -> -1); // result: -1 as 5 is NOT less than 0 so it uses
                                                                  //         the alternative returned from the given function (lazily evaluated).

public <T> T doItThrowingMyException() throws Exception {
  throw new MyException("This is MyException!");
}

AnnoyingFuns.getOrRethrowCause(
  throwable -> throwable instanceof MyException,
  AnnoyingFuns.shh(() -> doItThrowingMyException())
) // It will throw MyException instead of RuntimeException with MyException as its cause

final Predicate2<Integer, Integer> twoPositives = (i1, i2) -> i1 > 0 && i2;
final Predicate<Integer> onePositive = twoPositives.curried(1);

System.out.println(twoPositives.test(1 , 2));    // result: true
System.out.println(onePositive.test(2));         // result: true
System.out.println(onePositive.test(-1));        // result: false

Either.<String, Integer>right(1).toMaybe();
Either.<String, Integer>left("error").toMaybe();

public void doItThrowingMyException() throws Exception {
  throw new MyException("This is MyException!");
}

AnnoyingFuns.runOrRethrowCause(
  throwable -> throwable instanceof MyException,
  AnnoyingFuns.shh(() -> doItThrowingMyException())
) // It will throw MyException instead of RuntimeException with MyException as its cause

final Pair<Integer, String> idAndName = tuple(1, "Kevin");
final Tuple2<Integer, String> idAndName = tuple(1, "Kevin");
final Tuple3<Integer, String, Boolean> idNameAndActive = tuple(1, "Kevin", true);
// and so on

Either.<String, Integer>right(1).toOptional();
Either.<String, Integer>left("error").toOptional();

Maybe.just(1).toString() // Just(1)
Maybe.nothing() // Nothing

Maybe.just(1).toString() // Maybe<Integer> = Just(1)
Maybe.nothing() // Maybe = Nothing

final Comparator<Integer> intCmp = Integer::compareTo;
final Comparator<Integer> reversedIntCmp = reversed(integerComparator);  // compile-time error!

Either.<String, Integer>right(1).getOrElse(() -> 999); // Integer = 1
Either.<String, Integer>left("ERROR").getOrElse(() -> 999); // Integer = 999

final String uniqueWords =
  listOfString.stream()
              .map(this::doSomethingReturnsEmptyList)  // List<String[]>
              .flatMap(Arrays::stream)
              .distinct()
              .sorted()
              .collect(joining(", "));

final String uniqueWords =
  listOfString.stream()
              .map(this::doSomethingReturnsEmptyList)  // List<String[]>
              .filter(each -> each.length != 0)
              .flatMap(Arrays::stream)
              .distinct()
              .sorted()
              .collect(joining(", "));

final String uniqueWords =
  listOfString.stream()
              .map(this::doSomethingReturnsEmptyList)  // List<String[]>
              .filter(each -> ArrayFuns.isNotEmpty(each))
              .flatMap(Arrays::stream)
              .distinct()
              .sorted()
              .collect(joining(", "));

final String uniqueWords =
  listOfString.stream()
              .map(this::doSomethingReturnsEmptyList)  // List<String[]>
              .filter(ArrayFuns::isNotEmpty)
              .flatMap(Arrays::stream)
              .distinct()
              .sorted()
              .collect(joining(", "));

public Result foo() throws RuntimeException {
  try {
   // some code
    return a;
  } catch (final SomeException ex) {
    throw new RuntimeException(ex);
  }
}

getOrRethrowCause(SomeException.class, () -> foo()) // will throw SomeException

final Maybe<Integer> maybeNumber = Maybe.just(1);
Either.fromMaybe(maybeNumber, () -> "No number found")
// Either<String, Integer> = Right(1)

final Maybe<Integer> maybeNumber = Maybe.<Integer>nothing();
Either.fromMaybe(maybeNumber, () -> "No number found")
// Either<String, Integer> = Left("No number found")