com.github.tonivade.purefun.instances.OptionInstances Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2018-2019, Antonio Gabriel Muñoz Conejo 
 * Distributed under the terms of the MIT License
 */
package com.github.tonivade.purefun.instances;

import static com.github.tonivade.purefun.Producer.cons;
import static com.github.tonivade.purefun.Nothing.nothing;

import com.github.tonivade.purefun.Eq;
import com.github.tonivade.purefun.Function1;
import com.github.tonivade.purefun.Function2;
import com.github.tonivade.purefun.Higher1;
import com.github.tonivade.purefun.Instance;
import com.github.tonivade.purefun.Kind;
import com.github.tonivade.purefun.Nothing;
import com.github.tonivade.purefun.Pattern2;
import com.github.tonivade.purefun.Tuple;
import com.github.tonivade.purefun.Tuple2;
import com.github.tonivade.purefun.type.Eval;
import com.github.tonivade.purefun.type.Option;
import com.github.tonivade.purefun.typeclasses.Alternative;
import com.github.tonivade.purefun.typeclasses.Applicative;
import com.github.tonivade.purefun.typeclasses.Foldable;
import com.github.tonivade.purefun.typeclasses.Functor;
import com.github.tonivade.purefun.typeclasses.Monad;
import com.github.tonivade.purefun.typeclasses.MonadError;
import com.github.tonivade.purefun.typeclasses.MonoidK;
import com.github.tonivade.purefun.typeclasses.SemigroupK;
import com.github.tonivade.purefun.typeclasses.Semigroupal;
import com.github.tonivade.purefun.typeclasses.Traverse;

public interface OptionInstances {

  static  Eq> eq(Eq eqSome) {
    return (a, b) -> Pattern2., Option, Boolean>build()
      .when((x, y) -> x.isPresent() && y.isPresent())
        .then((x, y) -> eqSome.eqv(x.get(), y.get()))
      .when((x, y) -> x.isEmpty() && y.isEmpty())
        .returns(true)
      .otherwise()
        .returns(false)
      .apply(Option.narrowK(a), Option.narrowK(b));
  }

  static Functor functor() {
    return new OptionFunctor() {};
  }

  static Applicative applicative() {
    return new OptionApplicative() {};
  }

  static Alternative alternative() {
    return new OptionAlternative() {};
  }

  static Monad monad() {
    return new OptionMonad() {};
  }

  static MonadError monadError() {
    return new OptionMonadError() {};
  }

  static Traverse traverse() {
    return new OptionTraverse() {};
  }

  static Semigroupal semigroupal() {
    return new OptionSemigroupal() {};
  }

  static Foldable foldable() {
    return new OptionFoldable() {};
  }
}

@Instance
interface OptionFunctor extends Functor {

  @Override
  default  Option map(Higher1 value, Function1 mapper) {
    return Option.narrowK(value).map(mapper);
  }
}

@Instance
interface OptionPure extends Applicative {

  @Override
  default  Option pure(T value) {
    return Option.some(value);
  }
}

@Instance
interface OptionApplicative extends OptionPure {

  @Override
  default  Option ap(Higher1 value, Higher1> apply) {
    return Option.narrowK(value).flatMap(t -> Option.narrowK(apply).map(f -> f.apply(t)));
  }
}

@Instance
interface OptionMonad extends OptionPure, Monad {

  @Override
  default  Option flatMap(Higher1 value,
      Function1> map) {
    return Option.narrowK(value).flatMap(map.andThen(Option::narrowK));
  }
}

@Instance
interface OptionSemigroupK extends SemigroupK {

  @Override
  default  Option combineK(Higher1 t1, Higher1 t2) {
    return Option.narrowK(t1).fold(cons(Option.narrowK(t2)), Option::some);
  }
}

@Instance
interface OptionMonoidK extends OptionSemigroupK, MonoidK {

  @Override
  default  Option zero() {
    return Option.none();
  }
}

@Instance
interface OptionAlternative extends OptionMonoidK, OptionApplicative, Alternative { }

@Instance
interface OptionMonadError extends OptionMonad, MonadError {

  @Override
  default  Option raiseError(Nothing error) {
    return Option.none();
  }

  @Override
  default  Option handleErrorWith(Higher1 value,
      Function1> handler) {
    return Option.narrowK(value).fold(() -> Option.narrowK(handler.apply(nothing())), Option::some);
  }
}

@Instance
interface OptionFoldable extends Foldable {

  @Override
  default  B foldLeft(Higher1 value, B initial, Function2 mapper) {
    return Option.narrowK(value).fold(cons(initial), a -> mapper.apply(initial, a));
  }

  @Override
  default  Eval foldRight(Higher1 value, Eval initial,
      Function2, Eval> mapper) {
    return Option.narrowK(value).fold(cons(initial), a -> mapper.apply(a, initial));
  }
}

@Instance
interface OptionTraverse extends Traverse, OptionFoldable {

  @Override
  default  Higher1> traverse(
      Applicative applicative, Higher1 value,
      Function1> mapper) {
    return Option.narrowK(value).fold(
        () -> applicative.pure(Option.none()), t -> applicative.map(mapper.apply(t), Option::some));
  }
}

@Instance
interface OptionSemigroupal extends Semigroupal {

  @Override
  default  Option> product(Higher1 fa, Higher1 fb) {
    return Option.narrowK(fa).flatMap(a -> Option.narrowK(fb).map(b -> Tuple.of(a, b)));
  }
}