object MonadicTransformerExample {
  import scala.concurrent.ExecutionContext.Implicits.global

  case class User(id: Int, name: String)
  case class Address(user: User)
  case class FutureOpt[A](value: Future[Option[A]]) {
    def map[B](f: A => B) = {
      FutureOpt(value.map(_.map(f)))
    }
    def flatMap[B](f: A => FutureOpt[B]) = {
      FutureOpt(value.flatMap {
        case Some(x) => f(x).value
        case None => Future.successful(None)
      })
    }
  }

  val users = Seq(
    User(1, "Alex"),
    User(2, "Xela"),
    User(3, "Katya"),
    User(4, "Aytak")
  )

  val addresses = Seq(
    Address(users(0)),
    Address(users(2))
  )

  def main(args: Array[String]) {

    def findUserById(id: Long): Future[Option[User]] = {
      Future.successful(users.find(_.id == id)) //just mock
    }

    def findAddressByUser(user: User): Future[Option[Address]] = {
      Future.successful(addresses.find(_.user == user))
    }

    def findAddressByUserId(id: Int): Future[Option[Address]] = {
      val f = for {
        user <- FutureOpt(findUserById(id))
        address <- FutureOpt(findAddressByUser(user))
      } yield address

      f.value
    }

    import scala.concurrent.duration._
    println(Await.result(findAddressByUserId(1), 1 seconds))
    println(Await.result(findAddressByUserId(2), 1 seconds))
    println(Await.result(findAddressByUserId(3), 1 seconds))
    println(Await.result(findAddressByUserId(4), 1 seconds))
  }
}