Nihirash Interpreter

// by Nihirash
object Interpreter {
  type Result[T] = Either[Throwable, T]

  sealed trait Operations
  final case class Log(message: String) extends Operations
  final case class DoSomething(what: String) extends Operations

  sealed trait Expression[T] {
    def eval(state: Seq[Operations])(implicit env: Map[String, Long]): T
    def print(): String
  }

  sealed trait Operation extends Expression[Seq[Operations]]
  sealed trait NumbericExpression extends Expression[Long]
  sealed trait BooleanExpression extends Expression[Boolean]


  final case class Do(block: Seq[Operation]) extends Operation {
    override def eval(state: Seq[Operations])(implicit env: Map[String, Long]): Seq[Operations] = {
      @scala.annotation.tailrec
      def intEval(intState: Seq[Operations], acc: Seq[Operation]) : Seq[Operations] = acc match {
        case h :: t =>
          intEval(h.eval(intState), t)
        case Nil => intState
      }

      intEval(state, block)
    }

    override def print(): String =
      s"{ \n${block.map(_.print()).mkString("\n")}\n}"
  }

  final case class Condition(cond: BooleanExpression, body: Operation, alter: Operation) extends Operation {
    override def eval(state: Seq[Operations])(implicit env: Map[String, Long]): Seq[Operations] =
      if (cond.eval(state))
        body.eval(state)
    else
        alter.eval(state)

    override def print(): String =
      s"If (${cond.print()})\nТО: ${body.print()}\nelse: ${alter.print()}"
  }

  final case class OperationLog(message: String) extends Operation {
    override def eval(state: Seq[Operations])(implicit env: Map[String, Long]): Seq[Operations] =
      state :+ Log(message)

    override def print(): String =
      s"""Log: "${message}""""
  }

  final case class OperationDoSomething(what: String) extends Operation {
    override def eval(state: Seq[Operations])(implicit env: Map[String, Long]): Seq[Operations] =
      state :+ DoSomething(what)

    override def print(): String =
      s"Do ${what}"
  }

  final case class Constant(value: Long) extends NumbericExpression {
    override def eval(state: Seq[Operations])(implicit env: Map[String, Long]): Long =
      value

    override def print(): String = value.toString
  }

  final case class Sum(lvalue: NumbericExpression, rvalue: NumbericExpression) extends NumbericExpression {
    override def eval(state: Seq[Operations])(implicit env: Map[String, Long]): Long =
      lvalue.eval(state) + rvalue.eval(state)

    override def print(): String =
      s" ${lvalue.print()} + ${rvalue.print()} "
  }

  final case class GetEnvValue(key: String) extends NumbericExpression {
    override def eval(state: Seq[Operations])(implicit env: Map[String, Long]): Long =
      env.getOrElse(key, 0L)

    override def print(): String = key
  }

  final case class NumbericEquals(lexpr: NumbericExpression, rexpr: NumbericExpression) extends BooleanExpression {
    override def eval(state: Seq[Operations])(implicit env: Map[String, Long]): Boolean =
      lexpr.eval(state) == rexpr.eval(state)

    override def print(): String =
      s" ${lexpr.print()} = ${rexpr.print()} "
  }

}

object Hello extends  App {
  import Interpreter._
  val program = Do(Seq(
    OperationLog("Hello, world"),
    Condition(NumbericEquals(Constant(1), Sum(GetEnvValue("first"), Constant(2))),
      Do(Seq(
        OperationLog("Success"),
        OperationDoSomething("Make changes")
      )),
      OperationDoSomething("ConditionFailed")
  )))

  implicit val env = Map[String, Long]("first" -> -1)

  println(s"Operations: ${program.eval(Seq.empty)}")
  println(s"Algorithm: \n${program.print()}")
}