Question

I’m trying to make a println replacement that outputs nested collections in a more readable format. This is best illustrated with an example: I’d like List(Set(Vector(1.0,1.1), Vector(0d)), Set(Vector("a", "b", "c"), Vector("x", "y"))) to be printed as

List
  Set
    Vector(1.0, 1.1)
    Vector(0.0)
  Set
    Vector(a, b, c)
    Vector(x, y)

This would be a lot easier without type erasure, but I’ve come up with

def rprint(a: Any, indent: Int = 0): Unit = a match {
  case x: Traversable[_] =>
    if (x.isEmpty)
      rprint(x.toString, indent)
    else x.head match {
      case y: Traversable[_] => {
        rprint(x.toString.takeWhile(_ != '('), indent)
        x foreach {i => rprint(i, indent + 2)}
      }
      case y => rprint(x.toString, indent)
    }
  case x => println(" " * indent + x)
}

I’m struggling with getting this to work nicely with Arrays, without substantial code duplication. I’d like them to work the same as for other collections. Specifically:

• Arrays are not Traversable

• could convert Arrays using genericArrayOps to ArrayOps which is TraversableOnce, but TraversableOnce doesn’t have a head method, so I can’t see how to get an element to check its type

• toString doesn’t work quite like other collections (use .deep)

What’s the best way to incorporate Arrays into this method, or is there a different approach that would work better?

Answer 1

To make it more flexible I’m defining a trait that includes utility methods and one abstract method, so that it can be used like that Array(1,2).print:

trait Printable[T] {
  def str(indent: Int = 0): String
  def str: String = str(0)
  def print(indent: Int = 0): Unit = println(str(indent))
  def print: Unit = print(0)
}

Then an implicit to make it look like str and print are methods of Any:

implicit def any2Printable(a: Any): Printable[Any] = new Printable[Any] {
  import collection._
  def name = a match {
    case a: Array[_] => "Array"
    case g: GenTraversableLike[_, _] => g.stringPrefix 
    case i: Iterator[_] => "Iterator"
    case _ => ""
  }
  object Iter {
    def unapply(a: Any): Option[GenIterable[_]] = a match {
      case a: Array[_] => Some(a.toIterable)
      case t: GenTraversableOnce[_] => Some(t.toIterable)
      case _ => None
    }
  }
  object Nested {
    def unapply(i: GenIterable[_]): Option[GenIterable[_]] = i match {
      case nested if i.exists{case Iter(j) =>true case _ =>false} => Some(nested)
      case _ => None
    }
  }
  def str(indent: Int = 0) = " " * indent + (a match {
    case Iter(i) if i.isEmpty => name + " <empty>"
    case Iter(Nested(i)) => name + "\n" + i.map(_.str(indent+2)).mkString("\n")
    case Iter(i) => name + i.map(_.toString).mkString("(", ", ", ")")
    case _ => a.toString
  })
}

This handles arbitrary deep nesting, but won’t use multiple lines for collections that don’t contain collections – for instance that would print:

Array
  Set
    Array(1.0, 1.1)
    Vector <empty>
    Array <empty>
    Set
      Vector(a, b, c)
      Vector(x, y)
      List
        Set
          Array(1.0, 1.1)
          Vector(0.0)
        Set
          Vector(a, b, c)
          Vector(x, y)