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

Go to download
/*
 * Copyright (c) 2018-2022, 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.Precondition.checkNonNull;
import com.github.tonivade.purefun.Function1;
import com.github.tonivade.purefun.Kind;
import com.github.tonivade.purefun.Tuple;
import com.github.tonivade.purefun.Unit;
import com.github.tonivade.purefun.Witness;
import com.github.tonivade.purefun.transformer.StateT;
import com.github.tonivade.purefun.transformer.StateTOf;
import com.github.tonivade.purefun.transformer.StateT_;
import com.github.tonivade.purefun.typeclasses.Monad;
import com.github.tonivade.purefun.typeclasses.MonadError;
import com.github.tonivade.purefun.typeclasses.MonadReader;
import com.github.tonivade.purefun.typeclasses.MonadState;

public interface StateTInstances {

  static  Monad, S>> monad(Monad monadF) {
    return StateTMonad.instance(checkNonNull(monadF));
  }

  static  MonadState, S>, S> monadState(Monad monadF) {
    return StateTMonadState.instance(checkNonNull(monadF));
  }

  static  MonadError, S>, E> monadError(MonadError monadErrorF) {
    return StateTMonadError.instance(checkNonNull(monadErrorF));
  }

  static  MonadReader, S>, R> monadReader(MonadReader monadReaderF) {
    return StateTMonadReader.instance(checkNonNull(monadReaderF));
  }
}

interface StateTMonad extends Monad, S>> {

  static  StateTMonad instance(Monad monadF) {
    return () -> monadF;
  }

  Monad monadF();

  @Override
  default  StateT pure(T value) {
    return StateT.pure(monadF(), value);
  }

  @Override
  default  StateT flatMap(Kind, S>, ? extends T> value,
      Function1, S>, ? extends R>> map) {
    return StateTOf.narrowK(value).flatMap(map.andThen(StateTOf::narrowK));
  }
}

interface StateTMonadError extends MonadError, S>, E>, StateTMonad {

  static  StateTMonadError instance(MonadError monadErrorF) {
    return () -> monadErrorF;
  }

  @Override
  MonadError monadF();

  @Override
  default  StateT raiseError(E error) {
    Kind raiseError = monadF().raiseError(error);
    return StateT.state(monadF(), state -> monadF().map(raiseError, value -> Tuple.of(state, value)));
  }

  @Override
  default  StateT handleErrorWith(
      Kind, S>, A> value,
      Function1, S>, ? extends A>> handler) {
    StateT stateT = value.fix(StateTOf::narrowK);
    return StateT.state(monadF(),
        state -> monadF().handleErrorWith(stateT.run(state),
            error -> handler.apply(error).fix(StateTOf::narrowK).run(state)));
  }
}

interface StateTMonadState extends MonadState, S>, S>, StateTMonad {

  static  StateTMonadState instance(Monad monadF) {
    return () -> monadF;
  }

  @Override
  default StateT get() {
    return StateT.get(monadF());
  }

  @Override
  default StateT set(S state) {
    return StateT.set(monadF(), state);
  }
}

interface StateTMonadReader extends MonadReader, S>, R>, StateTMonad {

  static  StateTMonadReader instance(MonadReader monadReaderF) {
    return () -> monadReaderF;
  }

  @Override
  MonadReader monadF();

  @Override
  default StateT ask() {
    return StateT.state(monadF(), state -> monadF().map(monadF().ask(), reader -> Tuple.of(state, reader)));
  }
}