The Path is Relative



From above code val in = new inner.InInner, we've already known, the path of a package can be relative. This can save us some keystrokes, since we don't have to put the whole path outer.inner.InInner.

In most of the cases this can be advantageous. However, there are a few cases may get confused with relative path. There is a mark for absolute path, _root_, and you may want to use it to get your intention clearly expressed.

In following example, there is a top-level 'stater' package, and, package 'level1' and 'level2' each contains a 'starter' package. Let's say, we are in package 'level1', and we want to access the three 'starter' package, how do we do it?

First of all, since we are in package 'level', we may directly use the 'starter' in it. And we just need to specify the 'level2' package as a relative path to 'level2.starter'.

But, how about the top-level 'starter' package? Here comes the issue, if you put starter.Runner directly, the compiler will give you the one in the 'level1' package. This is the case _root_ helps. Now the compiler knows where to get the right type.

package starter {
  class Runner {
    override def toString = "I'm in the root starter package"
  }
}

package level1 {
  package starter {
    class Runner {
      override def toString = "I'm in the level1 starter package"
    }
  }
  package level2 {
    package starter {
  
    class Runner {
      override def toString = "I'm in the level2 starter package"
    }
  
    }
  }

  object TestRunner extends App {
    val runner1 = new starter.Runner  //level1
    println(runner1)
    val runner2 = new level2.starter.Runner
    println(runner2)
    val runner3 = new _root_.starter.Runner
    println(runner3)
  }
}

Please visit RelativePackage for the complete code.