typed names

naming.scala

object naming {
    object dsl {

        import scala.language.implicitConversions

        implicit def pathNameToNameOps(name: PathName): PathNameDsl = new PathNameDsl(name)
        implicit def verbNameToNameOps(name: VerbName): VerbNameDsl = new VerbNameDsl(name)
        implicit def typeNameToNameOps(name: TypeName): TypeNameDsl = new TypeNameDsl(name)

        class PathNameDsl(val path: PathName) {
            def =|=(name: String): VerbName = VerbName(name, path)
            def =?=(name: String): ParmName = ParmName(name, path)
        }

        class VerbNameDsl(val verb: VerbName) {
            def =?=(name: String) = ParmName(name, verb)
        }

        class TypeNameDsl(val tpe: TypeName) {
            def =#=(name: String) = TypeName(name, Some(tpe))
        }
    }

    abstract class Name(val parent: Option[Name]) {
        val name   : String
        val delimiter: String
        def asString: String = {
           def loop(n: Name, acc: String): String = n.parent match {
               case Some(p) => loop(p, p.name + n.delimiter + acc)
               case None    => acc
           }
           loop(this, this.name)
        }
        override def toString: String = this match {
        	case n: PathName => s"PathName(${ n.asString })"
        	case n: VerbName => s"VerbName(${ n.asString })"
        	case n: ParmName => s"ParmName(${ n.asString })"
        	case n: TypeName => s"TypeName(${ n.asString })"
        }
    }

    case class PathName(name: String) extends Name(None) {
    	override val delimiter: String = "/"
    }

    case class VerbName(name: String, path: PathName) extends Name(Some(path)) {
	   override val delimiter: String = "|"
    }

    case class ParmName(name: String, override val parent: Option[Name]) extends Name(parent) {
	   override val delimiter: String = "?"
    }

    object ParmName {
	   def apply(name: String, parent: PathName): ParmName = ParmName(name, Some(parent))
	   def apply(name: String, parent: VerbName): ParmName = ParmName(name, Some(parent))
    }

    case class TypeName(name: String, override val parent: Option[Name]) extends Name(parent) {
	   override val delimiter: String = "#"
    }

    object TypeName {
	   def apply(name: String): TypeName = TypeName(name, None)
	   def apply(name: String, parent: TypeName): TypeName = TypeName(name, Some(parent))
    }
}