递归打印方法中的阵列

Question

我试图做一个println替代品，以更易读的格式输出嵌套集合。这最好用一个例子来说明：我想List(Set(Vector(1.0,1.1), Vector(0d)), Set(Vector("a", "b", "c"), Vector("x", "y")))可以打印，

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

这将是没有类型擦除方便很多，但我已经拿出

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) 
} 

我m正在努力使其与数组很好地协作，而没有大量的代码重复。我希望他们能够像其他收藏一样工作。具体做法是：

• 数组不是Traversable

• 可以转换使用genericArrayOps到ArrayOps这是TraversableOnce阵列，但TraversableOnce没有一个head方法，所以我不能看到如何获取元素以检查它的类型

• toString不起作用很喜欢其他收藏品（使用.deep）

将数组并入该方法的最佳方法是什么？或者有什么不同的方法可以更好地工作？

Answer 1

为了使它更灵活我限定的性状，其包括工具方法和一个抽象方法，使得它可以用来像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) 
} 

然后暗示使它看起来像str和print是方法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 
    }) 
} 

这种处理任意深度嵌套，但不会使用多行不包含集合的集合 - 例如，将打印：

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) 

Answer 2

而不是转换为ArrayOps，请尝试一个WrappedArray，它具有头部方法并且可以穿过。

Answer 3

尝试tu在匹配短语中使用更一般的类型，如GenTraversable以女巫存在隐式转换。

import scala.collection.GenTraversable 

def rprint[T](a: T, indent: Int = 0): Unit = a match { 
    case x: String => println(" "*indent + '"' + x + '"') 
    case x: GenTraversable[_] => 
    println(" "*indent + (x.stringPrefix)) 
    x foreach (rprint(_, indent+2)) 
    case x: Array[_] => 
    println(" "*indent + (a.getClass.getSimpleName)) 
    x foreach (rprint(_, indent+2)) 
    case x => println(" "*indent + x) 
} 

rprint(Map(1->"one",2->"two")) 
rprint(List("one", "two"))   //I don't know why this type is printed weird: $colon$colon 
rprint(Array(1,2))     //This prints less weird: int[] 

可以为特定类型的缺失增加更多的情况下（如元组）

我想不出有什么用打印某种类型的名称（如List和Array问题 - 看功能后的例子定义）。无论a.getClass.getSimpleName和a.ToString回报有线串

我还尝试连接类型Array和GenTraversable - 因为有隐式转换从Array到WrapperArray <: GenTraversable。
该解决方案如下不满足它打印“WrappedArray”，而不是“阵列”， 当我们调用函数Array实例

case x: Array[_] => rprint(x:GenTraversable[_]) 

编辑：
我已经改变名称提取器GenTraversable到a.stringPrefix

Answer 4

这不是我的意图来回答我自己的问题，但我有一些工作。我认为它可以提高很多，所以建议表示赞赏。那里仍然有重复和相当丑陋的表演。

def rprint(a: Any, indent: Int = 0): Unit = { 
    val (typeStr, fullStr) = a match { 
     case x: collection.mutable.WrappedArray[_] => ("Array", x.deep.toString) 
     case x: Traversable[_] => (x.stringPrefix, x.toString) 
     case _ => ("", "") 
    } 
    a match { 
     case x: Traversable[_] => 
     if (x.isEmpty) 
      rprint(typeStr + " <empty>", indent) 
     else 
      x.head match { 
      case _: Array[_] => { 
       rprint(typeStr, indent) 
       x foreach {i => rprint(genericWrapArray(
             i.asInstanceOf[Array[_]]), indent + 2)} 
      } 
      case _: Traversable[_] => { 
       rprint(typeStr, indent) 
       x foreach {i => rprint(i, indent + 2)} 
      } 
      case _ => rprint(fullStr, indent) 
      } 
     case x: Array[_] => rprint(genericWrapArray(x)) 
     case x => println(" " * indent + x) 
    } 
    } 

测试：

scala> rprint(List(Array(Vector(1.0,1.1), Vector(0d)), Array(Array("a", "b", "c"), Array("x", "y")))) 
List 
    Array 
    Vector(1.0, 1.1) 
    Vector(0.0) 
    Array 
    Array(a, b, c) 
    Array(x, y)