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

case class LocalResponse(statusCode: Int)
case class RemoteResponse(message: String)

sealed trait Computation {
  type Response
  val work: Future[Response]
}

case class LocalComputation(work: Future[LocalResponse]) extends Computation {
  type Response = LocalResponse
}
case class RemoteComputation(work: Future[RemoteResponse]) extends Computation {
  type Response = RemoteResponse
}

object Service {
  def handle(computation: Computation): computation.Response = {
    val duration = Duration(2, SECONDS)
    Await.result(computation.work, duration)
  }

  def main(args:Array[String]) = {
    val a:LocalResponse = Service.handle(LocalComputation(Future(RemoteResponse(0))))
      a.statusCode
      //.statusCode
    // Result: LocalResponse = LocalResponse(0)
    val a2:RemoteResponse = Service.handle(RemoteComputation(Future(RemoteResponse("remote call"))))
    a2.message
      //.message
    // Result: RemoteResponse = RemoteResponse(remote call)
  }
}

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

case class LocalResponse(statusCode: Int)
case class RemoteResponse(message: String)

sealed trait Computation {
  type Response
  val work: Future[Response]
}

case class LocalComputation(work: Future[LocalResponse]) extends Computation {
  type Response = LocalResponse
}
case class RemoteComputation(work: Future[RemoteResponse]) extends Computation {
  type Response = RemoteResponse
}

object Service {
  def handle(computation: Computation): computation.Response = {
    val duration = Duration(2, SECONDS)
    Await.result(computation.work, duration)
  }

  def main(args:Array[String]) = {
    val a:LocalResponse = Service.handle(LocalComputation(Future(LocalResponse(0))))
    println(a.statusCode) //Compiling fine

    val a2:RemoteResponse = Service.handle(RemoteComputation(Future(RemoteResponse("remote call"))))
    println(a2.message)//Compiling fine

    val a3:RemoteResponse = Service.handle(RemoteComputation(Future(LocalResponse("remote call")))) // BOOM
  }
}

import scala.language.implicitConversions

object Pipeline {
  implicit class toPiped[V](value:V) {
    def |>[R] (f : V => R) = f(value)
  }
}

sealed trait PreTaxDeductions
sealed trait PostTaxDeductions
sealed trait Final

// For simplicity, use Float for money. Not recommended...
case class Employee(
                     name: String,
                     annualSalary: Float,
                     taxRate: Float,  // For simplicity, just 1 rate covering all taxes.
                     insurancePremiumsPerPayPeriod: Float,
                     _401kDeductionRate: Float,  // A pretax, retirement savings plan in the USA.
                     postTaxDeductions: Float)

case class Pay[Step](employee: Employee, netPay: Float)

object Payroll {
  // Biweekly paychecks. Assume exactly 52 weeks/year for simplicity.
  def start(employee: Employee): Pay[PreTaxDeductions] =
    Pay[PreTaxDeductions](employee, employee.annualSalary / 26.0F)

  def minusInsurance(pay: Pay[PreTaxDeductions]): Pay[PreTaxDeductions] = {
    val newNet = pay.netPay - pay.employee.insurancePremiumsPerPayPeriod
    pay copy (netPay = newNet)
  }

  def minus401k(pay: Pay[PreTaxDeductions]): Pay[PreTaxDeductions] = {
    val newNet = pay.netPay - (pay.employee._401kDeductionRate * pay.netPay)
    pay copy (netPay = newNet)
  }

  def minusTax(pay: Pay[PreTaxDeductions]): Pay[PostTaxDeductions] = {
    val newNet = pay.netPay - (pay.employee.taxRate * pay.netPay)
    pay copy (netPay = newNet)
  }

  def minusFinalDeductions(pay: Pay[PostTaxDeductions]): Pay[Final] = {
    val newNet = pay.netPay - pay.employee.postTaxDeductions
    pay copy (netPay = newNet)
  }
}

object CalculatePayroll {
  def main(args: Array[String]) = {
    import Pipeline._
    import Payroll._

    val e = Employee("Buck Trends", 100000.0F, 0.25F, 200F, 0.10F, 0.05F)
    val pay = start(e) |>
      minus401k        |>
      minusInsurance   |>
      minusTax         |>
      minusFinalDeductions
    val twoWeekGross = e.annualSalary / 26.0F
    val twoWeekNet   = pay.netPay
    val percent      = (twoWeekNet / twoWeekGross) * 100
    println(s"For ${e.name}, the gross vs. net pay every 2 weeks is:")
    println(f"  $$${twoWeekGross}%.2f vs. $$${twoWeekNet}%.2f or ${percent}%.1f%%")
  }
}

class Service {
        <T> Future<T> handle(Computation<T> computation) {
            return Executors.newFixedThreadPool(1).submit( () -> computation.work());
        }
    }

object DepTypes3 {

  class Franchise(name: String) {
    case class Character(name: String)
    def createFanFictionWith(lovestruck: Character, objectOfDesire: Character): (Character, Character) = (lovestruck, objectOfDesire)
  }

  val starTrek = new Franchise("Star Trek")
  val starWars = new Franchise("Star Wars")

  val quark = starTrek.Character("Quark")
  val jadzia = starTrek.Character("Jadzia Dax")

  val luke = starWars.Character("Luke Skywalker")
  val yoda = starWars.Character("Yoda")

  starTrek.createFanFictionWith(lovestruck = quark, objectOfDesire = jadzia)
  starWars.createFanFictionWith(lovestruck = luke, objectOfDesire = yoda)

  //starTrek.createFanFictionWith(lovestruck = jadzia, objectOfDesire = luke) Компилейшен еррор, как и ожидается
}