Scala: cross (Descartes) sản phẩm với nhiều nguồn và các loại không đồng nhất

Question

Tôi đang cố gắng để xây dựng nhiều sản phẩm chéo của traversables khác nhau (nhưng mỗi đồng nhất) các loại. Kiểu trả về mong muốn là một kiểu đi ngang của một bộ tuple với kiểu phù hợp với các kiểu trong các traversables đầu vào. Ví dụ:

List(1, 2, 3) cross Seq("a", "b") cross Set(0.5, 7.3) 

Điều này phải cung cấp Traversable[(Int, String, Double)] với tất cả các kết hợp có thể có từ ba nguồn. Trường hợp kết hợp chỉ có hai nguồn là độc đáo answered here. Ý tưởng đưa ra là:

implicit class Crossable[X](xs: Traversable[X]) { 
    def cross[A](ys: Traversable[A]) = for { x <- xs; y <- ys } yield (x, y) 
} 

Các bình luận có đề cập ngắn gọn sự cố nguồn hơn, nhưng tôi đang tìm để tìm một giải pháp mà không phụ thuộc vào một trong hai hình thù hoặc scalaz (mặt khác, tôi don' t tâm có một số boilerplate để quy mô lên đến Tuple22).

implicit class Crossable[X](xs: Traversable[X]) { 
    def cross[A](ys: Traversable[A]) = for { x <- xs; y <- ys } yield (x, y) 
    def cross[A,B](ys: Traversable[(A,B)]) = // ... extend all Tuple2's in ys with x in xs to Tuple3's 
    def cross[A,B,C](ys: Traversable[(A,B,C)]) = // ... 
    // ... 
} 

Điều này rõ ràng không hoạt động do chô bôi loại (và, thật không may, có lẽ sẽ đòi hỏi phải sử dụng dấu ngoặc đơn trong ví dụ trên, bởi vì cross sẽ là kết hợp đúng: một cái gì đó như sau những gì tôi muốn làm là).

Câu hỏi của tôi là: Có cách nào đó có thể khai thác các tính năng phản chiếu của Scala 2.10 để giải quyết vấn đề không? Nói chung, kết hợp cả hai loại A và X với các loại bộ khác nhau (và các tham số kiểu của chúng, có vẻ khó khăn) và hợp nhất chúng thành các bộ dữ liệu lớn hơn sẽ cung cấp giải pháp thỏa mãn luật liên kết, đúng không?

Answer 1

Tôi đã có một lúc nó đi và đến với điều này:

trait Crosser[A,B,C] { 
    def cross(as: Traversable[A], bs: Traversable[B]): Traversable[C] 
} 

trait LowPriorityCrosserImplicits { 
    private type T[X] = Traversable[X] 

    implicit def crosser2[A,B] = new Crosser[A,B,(A,B)] { 
    def cross(as: T[A], bs: T[B]): T[(A,B)] = for { a <- as; b <- bs } yield (a, b) 
    } 
} 

object Crosser extends LowPriorityCrosserImplicits { 
    private type T[X] = Traversable[X] 

    implicit def crosser3[A,B,C] = new Crosser[(A,B),C,(A,B,C)] { 
    def cross(abs: T[(A,B)], cs: T[C]): T[(A,B,C)] = for { (a,b) <- abs; c <- cs } yield (a, b, c) 
    } 

    implicit def crosser4[A,B,C,D] = new Crosser[(A,B,C),D,(A,B,C,D)] { 
    def cross(abcs: T[(A,B,C)], ds: T[D]): T[(A,B,C,D)] = for { (a,b,c) <- abcs; d <- ds } yield (a, b, c, d) 
    } 

    // and so on ... 
} 

implicit class Crossable[A](xs: Traversable[A]) { 
    def cross[B,C](ys: Traversable[B])(implicit crosser: Crosser[A,B,C]): Traversable[C] = crosser.cross(xs, ys) 
} 

Ý tưởng chính là để trì hoãn công việc để một lớp kiểu (Crosser) và thực hiện tất cả các arities khác nhau chỉ đơn giản bằng chuyên cho Traversable s của tuples với các arity tương ứng trừ một. Một số thử nghiệm trong REPL:

scala> List(1, 2, 3) cross Seq("a", "b") cross Set(0.5, 7.3) 
res10: Traversable[(Int, String, Double)] = List((1,a,0.5), (1,a,7.3), (1,b,0.5), (1,b,7.3), (2,a,0.5), (2,a,7.3), (2,b,0.5), (2,b,7.3), (3,a,0.5), (3,a,7.3), (3,b,0.5), (3,b,7.3))