Loại suy luận về chức năng ẩn danh với phong phú thêm-my-thư viện

Question

Nói rằng tôi có một phương pháp có thể biến một (chức năng trên hai yếu tố) vào một (chức năng trên hai trình tự):

def seqed[T](f: (T,T) => T): (Seq[T], Seq[T]) => Seq[T] = (_,_).zipped map f 

Nói cách, chức năng kết quả mất hai chuỗi xs và ys, và tạo ra một chuỗi mới gồm (xs(0) f ys(0), xs(1) f ys(1), ...) vì vậy, ví dụ, nếu xss là Seq(Seq(1,2),Seq(3,4)) và f là (a: Int, b: Int) => a + b, chúng ta có thể gọi nó như vậy:

xss reduceLeft seqed(f)   // Seq(4, 6) 

hoặc với một chức năng ẩn danh:

xss reduceLeft seqed[Int](_+_) 

này là khá tốt; nó sẽ là tốt đẹp để loại bỏ các đối số loại [Int] nhưng tôi không thấy làm thế nào (bất kỳ ý tưởng?).

Để làm cho nó cảm thấy một chút giống như phương pháp tupled, tôi cũng đã cố gắng mô hình phong phú thêm-my-thư viện:

class SeqFunction[T](f: (T,T) => T) { 
    def seqed: (Seq[T], Seq[T]) => Seq[T] = (_,_).zipped map f 
} 
implicit def seqFunction[T](f: (T,T) => T) = new SeqFunction(f) 

Đối với một chức năng được xác định trước điều này làm việc tuyệt vời, nhưng nó xấu xí với những người ẩn danh

xss reduceLeft f.seqed 
xss reduceLeft ((_:Int) + (_:Int)).seqed 

có một cách khác để tôi có thể tái cấu trúc này để các loại được suy ra, và tôi có thể sử dụng cái gì cú pháp như sau:

// pseudocode 
xss reduceLeft (_+_).seqed   // ... or failing that 
xss reduceLeft (_+_).seqed[Int] 

? Hay tôi hỏi quá nhiều suy luận kiểu?

Answer 1

Lý do tại sao một loại chú thích là cần thiết trong

xss reduceLeft seqed[Int](_+_) 

nhưng không phải trong

xs zip ys map Function.tupled(_+_) 

là do sự khác biệt trong các yêu cầu loại giữa map và reduceLeft.

def reduceLeft [B >: A] (f: (B, A) ⇒ B): B 
def map  [B]  (f: (A) ⇒ B): Seq[B] // simple version! 

reduceLeft hy vọng seqed trở lại loại B nơi B >: Int. Có vẻ như do đó, loại chính xác cho seqed không thể được biết, vì vậy chúng tôi phải cung cấp chú thích. Thông tin thêm trong this question.

Một cách để khắc phục điều này là triển khai lại reduceLeft mà không có giới hạn dưới.

implicit def withReduceL[T](xs: Seq[T]) = new { 
    def reduceL(f: (T, T) => T) = xs reduceLeft f 
} 

Test:

scala> Seq(Seq(1,2,3), Seq(2,2,2)) reduceL seqed(_+_) 
res1: Seq[Int] = List(3, 4, 5) 

Vấn đề bây giờ là điều này bây giờ không hoạt động trên vùng phụ của Seq (ví dụ List), có hoặc không có tham số [Int]:

scala> Seq(List(1,2,3), List(2,2,2)) reduceL seqed(_+_) 
<console>:11: error: missing parameter type for expanded function ((x$1, x$2) => x$1.$plus(x$2)) 
       Seq(List(1,2,3), List(2,2,2)) reduceL seqed(_+_) 
                 ^

reduceL mong đợi một chức năng của loại (List[Int], List[Int]) => List[Int]. Vì Function2 được định nghĩa là Function2 [-T1, -T2, +R], (Seq[Int], Seq[Int]) => Seq[Int] không phải là sự thay thế hợp lệ.

Answer 2

Tôi chắc chắn bạn là hỏi quá nhiều. Nhập suy luận trong Scala goes from left to right, do đó, loại số (_+_) cần phải được tìm ra đầu tiên trước khi xem xét phần .sedeq. Và không có đủ thông tin ở đó.

Answer 3

Bạn không thể thực hiện theo cách mình muốn, nhưng hãy xem Function.tupled, là bộ phận đối kháng với số .tupled giải quyết vấn đề này.

scala> List(1, 2, 3) zip List(1, 2, 3) map (_ + _).tupled 
<console>:8: error: missing parameter type for expanded function ((x$1, x$2) => x$1.$plus(x$2)) 
       List(1, 2, 3) zip List(1, 2, 3) map (_ + _).tupled 
               ^
<console>:8: error: missing parameter type for expanded function ((x$1: <error>, x$2) => x$1.$plus(x$2)) 
       List(1, 2, 3) zip List(1, 2, 3) map (_ + _).tupled 
                ^

scala> List(1, 2, 3) zip List(1, 2, 3) map Function.tupled(_ + _) 
res7: List[Int] = List(2, 4, 6)