com.github.tonivade.purefun.instances.ValidationInstances 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 com.github.tonivade.purefun.Eq;
import com.github.tonivade.purefun.Function1;
import com.github.tonivade.purefun.Higher1;
import com.github.tonivade.purefun.Higher2;
import com.github.tonivade.purefun.Instance;
import com.github.tonivade.purefun.Pattern2;
import com.github.tonivade.purefun.type.Validation;
import com.github.tonivade.purefun.typeclasses.Applicative;
import com.github.tonivade.purefun.typeclasses.Bifunctor;
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.MonadThrow;

public interface ValidationInstances {

  static  Eq> eq(Eq errorEq, Eq validEq) {
    return (a, b) -> Pattern2., Validation, Boolean>build()
      .when((x, y) -> x.isInvalid() && y.isInvalid())
        .then((x, y) -> errorEq.eqv(x.getError(), y.getError()))
      .when((x, y) -> x.isValid() && y.isValid())
        .then((x, y) -> validEq.eqv(x.get(), y.get()))
      .otherwise()
        .returns(false)
      .apply(Validation.narrowK(a), Validation.narrowK(b));
  }

  static  Functor> functor() {
    return new ValidationFunctor() {};
  }

  static Bifunctor bifunctor() {
    return new ValidationBifunctor() {};
  }

  static  Applicative> applicative() {
    return new ValidationApplicative() {};
  }

  static  Monad> monad() {
    return new ValidationMonad() {};
  }

  static  MonadError, E> monadError() {
    return new ValidationMonadError() {};
  }

  static MonadThrow> monadThrow() {
    return new ValidationMonadThrow() {};
  }
}

@Instance
interface ValidationFunctor extends Functor> {

  @Override
  default  Validation map(Higher1, T> value, Function1 map) {
    return Validation.narrowK(value).map(map);
  }
}

@Instance
interface ValidationBifunctor extends Bifunctor {

  @Override
  default  Validation bimap(Higher2 value,
      Function1 leftMap, Function1 rightMap) {
    return Validation.narrowK(value).mapError(leftMap).map(rightMap);
  }
}

@Instance
interface ValidationPure extends Applicative> {

  @Override
  default  Validation pure(T value) {
    return Validation.valid(value);
  }
}

@Instance
interface ValidationApplicative extends ValidationPure {

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

@Instance
interface ValidationMonad extends ValidationPure, Monad> {

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

@Instance
interface ValidationMonadError extends ValidationMonad, MonadError, E> {

  @Override
  default  Validation raiseError(E error) {
    return Validation.invalid(error);
  }

  @Override
  default  Validation handleErrorWith(Higher1, A> value,
      Function1, A>> handler) {
    return Validation.narrowK(value).fold(handler.andThen(Validation::narrowK), Validation::valid);
  }
}

@Instance
interface ValidationMonadThrow
    extends ValidationMonadError,
            MonadThrow> { }