ikovalyov

fun main() {
  println(processRequest(1))
  println(processRequest(10))
  println(processRequest(-1))
}

// 2
// 20
// -1

ikovalyov

fun processRequest(input: Int): Int {
  val initial = State.RequestReceived(input)
  val result = transitions.fold(initial)
  return if (result.validationResult) {
    result.previousState.response
    } else {
    -1
  }
}

ikovalyov

val transitions = listOf(
  ValidateRequest(),
  ProcessRequest(),
  ValidateResponse()
)

ikovalyov

fun List<Transition<State, State>>.fold(initial: State.RequestReceived): State.ResponseValidated {
  var currentState: State = initial
  forEach {
    currentState = it.invoke(currentState)
  }
  if (currentState is State.ResponseValidated) {
    return currentState as State.ResponseValidated
  } else {
    throw IllegalStateException("currentState is not of State.ResponseValidated type")
  }

ikovalyov

abstract class Transition<InputState: State, OutputState: State> {
  abstract fun invoke(state: InputState) : OutputState
}

class ValidateRequest: Transition<State.RequestReceived, State.RequestValidated>() {
  override fun invoke(state: State.RequestReceived): State.RequestValidated {
    // let's just check something here
    return State.RequestValidated(state.request > 0, state)
  }
}

ikovalyov

sealed class State(val previousState: State?) {
  class RequestReceived(val request: Int): State(null)
  class RequestValidated(val validationResult: Boolean, previousState: RequestReceived): State(previousState)
  class RequestProcessed(val response: Int, previousState: RequestValidated): State(previousState)
  class ResponseValidated(val validationResult: Boolean, previousState: RequestProcessed): State(previousState)
}

ikovalyov

val teaPotTurnedOn = if (turnOnTheTeaPot) {
        // region Turning teapot on
        teaPotService.turnOn()
        true
        // endregion
    } else {
        // region Turning teapot off
        teaPotService.turnOff()
        false
        // endregion

ikovalyov

fun turnOnTheTeaPot(teapotService: TeaPotService) : Boolean {
      teaPotService.turnOn()
      return true
}

fun turnOffTheTeaPot(teapotService: TeaPotService) : Boolean {
      teaPotService.turnOff()
      return false
}

ikovalyov

if (turnOnTheTeaPot) {
    // Turning teapot on
    teaPotService.turnOn()
    teaPotTurnedOn = true
} else {
    // Turning teapot off
    teaPotService.turnOff()
    teaPotTurnedOn = false
}

ikovalyov

class TeaPotService {
    fun turnOn() {
        //do something
    }
    fun turnOff() {
        //do something
    }
}

fun main() {