[Medium] [Code] Builder Pattern in Scala with Phantom Types

chef-class.scala

class Chef[Pizza <: Chef.Pizza](ingredients: Seq[String]) {
  import Chef.Pizza._

  def addCheese(cheeseType: String): Chef[Pizza with Cheese] = new Chef(ingredients :+ cheeseType)

  def addTopping(toppingType: String): Chef[Pizza with Topping] = new Chef(ingredients :+ toppingType)

  def addDough: Chef[Pizza with Dough] = new Chef(ingredients :+ "dough")

  def build(implicit ev: Pizza =:= FullPizza): Food = Food(ingredients)
}

chef-object.scala

object Chef {

  sealed trait Pizza
  object Pizza {
    sealed trait EmptyPizza extends Pizza
    sealed trait Cheese extends Pizza
    sealed trait Topping extends Pizza
    sealed trait Dough extends Pizza

    type FullPizza = EmptyPizza with Cheese with Topping with Dough
  }
}

chef-oop.scala

case class Chef {
    ...
  def build: Food =
    if (hasDoughCheeseAndToppings(ingredients)) Food(ingredients)
    else throw new FoodBuildingException("You tried to build a pizza without enough ingredients")
}

chef-usage-fail.scala

scala> new Chef().addDough.build
<console>:18: error: Cannot prove that Chef.Pizza.EmptyPizza with Chef.Pizza.Dough =:= Chef.Pizza.FullPizza.

chef-usage-success.scala

scala> new Chef()
        .addCheese("mozzarella")
        .addDough
        .addTopping("olives")
        .build
res1: Food = Food(List(mozzarella, dough, olives))

door-builder.scala

case class Door[State <: DoorState](){
  def open(implicit ev: State =:= Closed) = Door[Open]()
  def close(implicit ev: State =:= Open) = Door[Closed]()
}

door-oop.scala

trait DoorState
case class Open() extends DoorState
case class Closed() extends DoorState
case class Door(state: DoorState) {
  def open = state match {
    case _: Open => throw new DoorStateException("You cannot open a door thats already open")
    case _ => Door(Open())
  }
def close = state match {
    case _: Closed => throw new DoorStateException("You cannot close a door thats already closed")
    case _ => Door(Closed())
  }
}

door-open.scala

scala> Door[Open]().open
<console>:17: error: Cannot prove that Open =:= Closed.

door-phantom-types.scala

sealed trait DoorState
sealed trait Open extends DoorState
sealed trait Closed extends DoorState

evidence.scala

def open(implicit ev: State =:= Closed) = Door[Open]()

food.scala

case class Food(ingredients: Seq[String])

implicit.scala

implicit val context: Context = ???
def methodThatRequiresContext(str: String)(implicit context: Context) = ???

methodThatRequiresContext("foo")