zipWith (lập bản đồ trên nhiều Seq) trong Scala

Question

Giả sử tôi có

val foo : Seq[Double] = ... 
val bar : Seq[Double] = ... 

và tôi muốn tạo ra một seq nơi baz (i) = foo (i) + bar (i). Một cách tôi có thể nghĩ ra để làm điều này là

val baz : Seq[Double] = (foo.toList zip bar.toList) map ((f: Double, b : Double) => f+b) 

Tuy nhiên, điều này cảm thấy cả hai xấu xí và không hiệu quả - Tôi phải chuyển đổi cả seqs vào danh sách (trong đó phát nổ với danh sách lười biếng), tạo danh sách tạm thời này của các bộ, chỉ để lập bản đồ trên nó và để cho nó được GCed. Có lẽ suối giải quyết vấn đề lười biếng, nhưng trong mọi trường hợp, điều này cảm thấy như không cần thiết xấu xí. Trong lisp, chức năng bản đồ sẽ lập bản đồ trên nhiều trình tự. Tôi sẽ viết

(mapcar (lambda (f b) (+ f b)) foo bar) 

Và không có danh sách tạm thời nào được tạo ở bất cứ đâu. Có một bản đồ-over-nhiều-danh sách chức năng trong Scala, hoặc là zip kết hợp với destructuring thực sự là 'đúng' cách để làm điều này?

Answer 1

Hàm bạn muốn được gọi là zipWith, nhưng nó không phải là một phần của thư viện chuẩn. Nó sẽ được trong 2.8 (UPDATE: Rõ ràng là không, xem ý kiến).

foo zipWith((f: Double, b : Double) => f+b) bar 

Xem this Trac ticket.

Answer 2

Danh sách lười biếng không phải là bản sao của danh sách - nó giống như một đối tượng duy nhất. Trong trường hợp cài đặt zip lười, mỗi lần nó được yêu cầu cho mục tiếp theo, nó lấy một mục từ mỗi danh sách đầu vào và tạo ra một bộ từ chúng, và sau đó bạn chia tách bộ tách ra với mẫu phù hợp trong lambda của bạn.

Vì vậy, không bao giờ cần tạo bản sao hoàn chỉnh của toàn bộ (các) danh sách đầu vào trước khi bắt đầu hoạt động trên chúng. Nó tóm tắt một mô hình phân bổ rất giống với bất kỳ ứng dụng nào đang chạy trên JVM - rất nhiều phân bổ rất ngắn nhưng nhỏ, mà JVM được tối ưu hóa để giải quyết.

Cập nhật: để rõ ràng, bạn cần sử dụng Luồng (danh sách lười) không phải Danh sách. Luồng của Scala có mã zip hoạt động theo cách lười biếng và vì vậy bạn không nên chuyển đổi mọi thứ thành danh sách. Lý tưởng nhất là thuật toán của bạn phải có khả năng làm việc trên hai luồng vô hạn mà không bị nổ tung (giả sử nó không làm bất kỳ folding, tất nhiên, nhưng chỉ đọc và tạo luồng).

Answer 3

Vâng, đó là thiếu zip, là sự thiếu hụt trong 2.7 của Seala. Scala 2.8 có một thiết kế bộ sưu tập tốt, để thay thế cách thức đặc biệt mà các bộ sưu tập hiện diện trong 2.7 trở thành (lưu ý rằng chúng không được tạo ra cùng một lúc, với một thiết kế thống nhất).

Bây giờ, khi bạn muốn tránh tạo bộ sưu tập tạm thời, bạn nên sử dụng "chiếu" trên Scala 2.7 hoặc "xem" trên Scala 2.8. Điều này sẽ cung cấp cho bạn một loại bộ sưu tập mà một số hướng dẫn nhất định, đặc biệt là bản đồ, flatMap và bộ lọc, không nghiêm ngặt. Trên Scala 2.7, phép chiếu của một List là một Stream. Trên Scala 2.8, có một SequenceView của một Sequence, nhưng có một zipWith ngay trong Sequence, bạn thậm chí sẽ không cần nó. Đã nói rằng, như đã đề cập, JVM được tối ưu hóa để xử lý phân bổ đối tượng tạm thời, và, khi chạy ở chế độ máy chủ, tối ưu hóa thời gian chạy có thể làm điều kỳ diệu. Vì vậy, không tối ưu hóa sớm.Kiểm tra mã trong các điều kiện nó sẽ được chạy - và nếu bạn chưa định chạy nó ở chế độ máy chủ, thì hãy suy nghĩ lại nếu mã được mong đợi là dài hạn, và chọn khi nào/ở đâu nếu cần.

EDIT

gì đang thực sự sẽ có sẵn trên Scala 2.8 là thế này:

(foo,bar).zipped.map(_+_) 

Answer 4

UPDATE: Nó đã được chỉ ra (trong ý kiến) rằng đây "câu trả lời" doesn 't thực sự giải quyết các câu hỏi được hỏi. Câu trả lời này sẽ lập bản đồ trên mỗi kết hợp của foo và bar, sản xuất N x M yếu tố này, thay vì phút (M, N) theo yêu cầu. Vì vậy, đây là sai, nhưng để lại cho hậu thế vì đó là thông tin tốt.

---

Cách tốt nhất để làm điều này là với flatMap kết hợp với map. Mã nói to hơn từ:

foo flatMap { f => bar map { b => f + b } } 

Điều này sẽ tạo ra một Seq[Double] duy nhất, chính xác như bạn mong đợi. Mô hình này là rất phổ biến mà Scala thực sự bao gồm một số ma thuật cú pháp mà thực hiện nó:

for { 
    f <- foo 
    b <- bar 
} yield f + b 

Hoặc cách khác:

for (f <- foo; b <- bar) yield f + b 

Các for { ... } cú pháp thực sự là con đường thành ngữ nhất để làm điều này. Bạn có thể tiếp tục thêm mệnh đề trình tạo (ví dụ: b <- bar) nếu cần. Do đó, nếu đột nhiên trở thành baSeq mà bạn phải lập bản đồ, bạn có thể dễ dàng mở rộng cú pháp của mình cùng với các yêu cầu của bạn (để viết một cụm từ).

Answer 5

Trong Scala 2.8:

val baz = (foo, bar).zipped map (_ + _) 

Và nó hoạt động trong hơn hai toán hạng trong cùng một cách. I E. sau đó bạn có thể làm theo này với:

(foo, bar, baz).zipped map (_ * _ * _) 

Answer 6

Khi phải đối mặt với một nhiệm vụ tương tự, tôi đã thêm các ma cô sau để Iterable s:

implicit class IterableOfIterablePimps[T](collOfColls: Iterable[Iterable[T]]) { 
    def mapZipped[V](f: Iterable[T] => V): Iterable[V] = new Iterable[V] { 
    override def iterator: Iterator[V] = new Iterator[V] { 
     override def next(): V = { 
     val v = f(itemsLeft.map(_.head)) 
     itemsLeft = itemsLeft.map(_.tail) 
     v 
     } 

     override def hasNext: Boolean = itemsLeft.exists(_.nonEmpty) 

     private var itemsLeft = collOfColls 
    } 
    } 
} 

Có điều này, người ta có thể làm điều gì đó như:

val collOfColls = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9)) 
collOfColls.mapZipped { group => 
    group // List(1, 4, 7), then List(2, 5, 8), then List(3, 6, 9) 
} 

Lưu ý rằng bạn nên xem xét cẩn thận loại bộ sưu tập được chuyển thành lồng nhau Iterable, vì tail và head sẽ được gọi lại thường xuyên trên i t. Vì vậy, lý tưởng bạn nên vượt qua bộ sưu tập Iterable[List] hoặc other với nhanh tail và head.

Ngoài ra, mã này dự kiến ​​các bộ sưu tập lồng nhau có cùng kích thước. Đó là trường hợp sử dụng của tôi, nhưng tôi nghi ngờ điều này có thể được cải thiện, nếu cần thiết.