import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration.Duration

object Test extends App{

  type OrderId = Int
  type ItemId = Int
  case class Order(OrderId:Int, items:Set[ItemId])
  case class Item(id:ItemId)

  def lookupOrder(id:OrderId):Future[OrderId] = {
    println(s"Retrieving order $id")
    Thread.sleep(500)
    println(s"Order retrieved")
    Future(id)
  }
  def fetchOrder(id:OrderId):Future[Order] = {
    println(s"Fetching order $id")
    Thread.sleep(500)
    println(s"Order fetched")
    Future(Order(id, Set(1,2,3,4,5)))
  }

  def fetchItem(id:ItemId) : Future[Item] = {
    println(s"Fetching item $id")
    Thread.sleep(5000)
    println(s"item fetched")
    Future(Item(id))
  }

  def program(id:OrderId) = {
    val future: Future[Set[Item]] = for {
      orderId <- lookupOrder(id)
      order <- fetchOrder(orderId)
      items <- Future.sequence(order.items.par.map(fetchItem).seq)
    } yield items
    val result = Await.result(future, Duration.Inf)
    println(s"Fetched items ${result.mkString(",")}. Done!")
  }

  program(1)
}

import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration.Duration

object Test extends App{

  type OrderId = Int
  type ItemId = Int
  case class Order(OrderId:Int, items:Set[ItemId])
  case class Item(id:ItemId)

  def lookupOrder(id:OrderId):M[OrderId] = {
    M.unit(id)
  }
  def fetchOrder(id:OrderId):M[Order] = {
    M.unit(Order(id, Set(1,2,3,4,5)))
  }

  def fetchItem(id:ItemId) : M[Item] = {
    M.unit(Item(id))
  }

  def program(id:OrderId, m:M:Monad) = {
    val definitionOfProgram: M[Set[Item]] = for {
      orderId <- lookupOrder(id)
      order <- fetchOrder(orderId)
      items <- m.sequence(order.items.par.map(fetchItem).seq)
    } yield items
    val result = m.run(definitionOfProgram)
    println(s"Fetched items ${result.mkString(",")}. Done!")
  }

  program(1, Future) -- для продакшена
  program(1, Id) -- для тестов

}
 
trait Monad{
  unit() - поместить в контекст
  flatMap - вычислить следущий компутейшен в цепочке
  run - выйти из контекста
}

Id extends Monad {
   unit == noop
   flatMap == просто вызов следующего по цепочке
   run == вернуть значение
}