src/Pure/PIDE/yxml.scala

   /* chunk markers */
 
   val X = '\u0005'
   val Y = '\u0006'
 
-  val is_X = (c: Char) => c == X
-  val is_Y = (c: Char) => c == Y
+  val is_X: Char => Boolean = _ == X
+  val is_Y: Char => Boolean = _ == Y
 
   val X_string: String = X.toString
   val Y_string: String = Y.toString
   val XY_string: String = X_string + Y_string
   val XYX_string: String = XY_string + X_string
 
   def detect(s: String): Boolean = s.exists(c => c == X || c == Y)
   def detect_elem(s: String): Boolean = s.startsWith(XY_string)
 
 
-  /* string representation */  // FIXME byte array version with pseudo-utf-8 (!?)
+  /* string representation */
 
-  def traversal(string: String => Unit, body: XML.Body): Unit =
+  def traversal(string: String => Unit, body: XML.Body)
   {
     def tree(t: XML.Tree): Unit =
       t match {
         case XML.Elem(Markup(name, atts), ts) =>
           string(XY_string)

   private def err_element() = err("bad element")
   private def err_unbalanced(name: String) =
     if (name == "") err("unbalanced element")
     else err("unbalanced element " + quote(name))
 
-  private def parse_attrib(source: CharSequence) = {
+  private def parse_attrib(source: CharSequence): (String, String) =
+  {
     val s = source.toString
     val i = s.indexOf('=')
     if (i <= 0) err_attribute()
     (s.substring(0, i), s.substring(i + 1))
   }

     def buffer(): mutable.ListBuffer[XML.Tree] = new mutable.ListBuffer[XML.Tree]
     var stack: List[(Markup, mutable.ListBuffer[XML.Tree])] = List((Markup.Empty, buffer()))
 
     def add(x: XML.Tree)
     {
-      (stack: @unchecked) match { case ((_, body) :: _) => body += x }
+      (stack: @unchecked) match { case (_, body) :: _ => body += x }
     }
 
     def push(name: String, atts: XML.Attributes)
     {
       if (name == "") err_element()

     }
 
     def pop()
     {
       (stack: @unchecked) match {
-        case ((Markup.Empty, _) :: _) => err_unbalanced("")
-        case ((markup, body) :: pending) =>
+        case (Markup.Empty, _) :: _ => err_unbalanced("")
+        case (markup, body) :: pending =>
           stack = pending
           add(XML.Elem(markup, body.toList))
       }
     }