"full" code for example from Martin's talk on implicits

01-shadowing-implicit-functions.scala

class Table(var rows: List[Row] = Nil) {
  def add(r: Row) = { rows = r :: rows }
}
class Row(var cells: List[Cell] = Nil) {
  def add(c: Cell) = { cells = c :: cells }
}
case class Cell(content: String)

object test {
  def table(init: implicit Table => Unit) = {
    implicit val t = new Table()
    init
    t
  }

  def row(init: implicit Row => Unit)(implicit t: Table) = {
    implicit val r = new Row()
    init
    t.add(r)
  }

  def cell(str: String)(implicit r: Row) =
    r.add(Cell(str))

  val doc = table {
    row {
      cell("test")
    }

    table {
      row {
        cell("test2")
      }
    }
  }
}

02-posttyper.scala

// result of 
//     dotc -Xprint:posttyper examples/scoping.scala

// ...
val doc: Table =
  test.table(
    {
      def $anonfun(implicit evidence$1: Table): Unit =
        {
          test.row(
            {
              def $anonfun(implicit evidence$2: Row): Unit =
                {
                  test.cell("test")(evidence$2)
                }
              closure($anonfun)
            }
          )(evidence$1)
          {
            test.table(
              {
                def $anonfun(implicit evidence$3: Table): Unit =
                  {
                    test.row(
                      {
                        def $anonfun(implicit evidence$4: Row): Unit =
                          {
                            test.cell("test2")(evidence$4)
                          }
                        closure($anonfun)
                      }
                    )(evidence$3)
                  }
                closure($anonfun)
              }
            )
            ()
          }
        }
      closure($anonfun)
    }
  )