import cats.effect.Sync

import scala.language.higherKinds
import cats.instances.list._
import cats.syntax.applicative._
import cats.syntax.flatMap._
import cats.syntax.functor._
import cats.syntax.traverse._

import scala.util.{Success, Try}


final case class Operation(name: String)

sealed trait ExecutionResult {
  def stringify: String
  def operation: Operation
}

final case class UnitExecution(state: Int, operation: Operation) extends ExecutionResult {
  override def stringify: String = s"unit execution result: $state, of operation $operation"
}

final case class InterruptedExecution(operation: Operation) extends ExecutionResult {
  override def stringify: String = "interrupted execution result"
}

trait Logger2[F[_]] {
  def info(message: String): F[Unit]
}

object Logger2 {
  def getLogger[F[_]: Sync]: Logger2[F] =
    (message: String) => Sync[F].delay(println(message))
}

object Main2 extends App {

  def execOperations[F[_]: Sync](operations: List[Operation]): F[Unit] = {
    def execOperation(operation: Operation): F[Try[ExecutionResult]] =
      (Success(UnitExecution(123, operation)): Try[ExecutionResult]).pure[F]

    val logger = Logger2.getLogger[F]

    operations.traverse { op =>
      execOperation(op).flatMap { res =>
        res.map(x => logger.info(x.stringify)).getOrElse {
          logger.info(s"operation $op failed")
        }
      }
    }.map(_ => ())
  }

  execOperations[cats.effect.IO](List(Operation("o1"), Operation("o2"), Operation("o3"))).unsafeRunSync()
}