Điểm của nhiều mệnh đề tham số trong định nghĩa hàm trong Scala là gì?

Question

Tôi đang cố gắng hiểu điểm của tính năng ngôn ngữ này của nhiều mệnh đề tham số và lý do bạn sẽ sử dụng nó. Ví dụ, sự khác biệt giữa hai hàm này thực sự là gì?

class WTF { 
    def TwoParamClauses(x : Int)(y: Int) = x + y 
    def OneParamClause(x: Int, y : Int) = x + y 
} 

>> val underTest = new WTF 
>> underTest.TwoParamClauses(1)(1) // result is '2' 
>> underTest.OneParamClause(1,1) // result is '2' 

Có gì đó trong số này Scala specification at point 4.6. Xem nếu điều đó có ý nghĩa với bạn không.

NB: spec gọi các mệnh đề 'tham số' này, nhưng tôi nghĩ một số người cũng có thể gọi chúng là 'danh sách tham số'.

Answer 1

Dưới đây là ba công dụng thực tế của nhiều danh sách tham số,

1. Để hỗ trợ kiểu suy luận. Điều này đặc biệt hữu ích khi sử dụng các phương thức đặt hàng cao hơn. Dưới đây, các tham số kiểu A của g2 được suy ra từ các tham số đầu tiên x, vì vậy các đối số chức năng trong tham số thứ hai có thể được f elided,

   def g1[A](x: A, f: A => A) = f(x) 
   g1(2, x => x) // error: missing parameter type for argument x 
   
   def g2[A](x: A)(f: A => A) = f(x) 
   g2(2) {x => x} // type is inferred; also, a nice syntax 
   

2. Đối với các thông số ngầm. Chỉ danh sách tham số cuối cùng mới có thể được đánh dấu là ẩn, và một danh sách tham số duy nhất không thể kết hợp các tham số ngầm định và không ngầm. Định nghĩa của g3 dưới đây đòi hỏi phải có hai danh sách tham số,

   // analogous to a context bound: g3[A : Ordering](x: A) 
   def g3[A](x: A)(implicit ev: Ordering[A]) {} 
   

3. Để thiết lập các giá trị mặc định dựa trên các thông số trước,

   def g4(x: Int, y: Int = 2*x) {} // error: not found value x 
   def g5(x: Int)(y: Int = 2*x) {} // OK 
   

Answer 2

Có một số trường hợp phân biệt này quan trọng:

1. Nhiều danh sách tham số cho phép bạn có những thứ như TwoParamClauses (2); đó là chức năng được tạo tự động của kiểu Int => Int, nó thêm 2 vào đối số của nó. Tất nhiên bạn có thể tự định nghĩa chính mình bằng cách sử dụng OneParamClause, nhưng nó sẽ mất nhiều lần nhấn phím hơn

2. Nếu bạn có hàm với tham số ngầm định cũng có tham số rõ ràng, tham số ngầm phải là tất cả trong mệnh đề tham số riêng của chúng. điều này có vẻ như là một hạn chế tùy ý nhưng thực sự khá hợp lý)

Ngoài ra, tôi nghĩ, sự khác biệt là phong cách.

Answer 3

TwoParamClause liên quan đến hai lần gọi phương thức trong khi OneParamClause chỉ gọi phương thức chỉ một lần. Tôi nghĩ cụm từ bạn đang tìm kiếm là currying. Trong số nhiều trường hợp sử dụng, nó giúp bạn phân tích tính toán thành các bước nhỏ. Điều này answer có thể thuyết phục bạn về tính hữu ích của currying.

Answer 4

Nhiều danh sách tham số có thể giúp loại scala suy luận để biết thêm chi tiết xem: Making the most of Scala's (extremely limited) type inference

Loại thông tin không chảy từ trái sang phải trong một danh sách đối số, chỉ từ trái sang phải trên danh sách đối số. Vì vậy, mặc dù Scala biết các loại của hai đối số đầu tiên ... thông tin đó không chảy vào chức năng ẩn danh của chúng ta.

...

Bây giờ chức năng nhị phân của chúng tôi là trong một danh sách đối số riêng biệt, bất kỳ loại thông tin từ danh sách đối số trước đó được sử dụng để điền vào các loại cho chức năng của chúng tôi ... do đó chúng tôi không cần chú thích thông số lambda của chúng tôi.

Answer 5

Có sự khác biệt giữa cả hai phiên bản liên quan đến suy luận kiểu.Cân nhắc

def f[A](a:A, aa:A) = null 
f("x",1) 
//Null = null 

Ở đây, loại A là ràng buộc để Any, mà là một loại siêu String và Int. Nhưng:

def g[A](a:A)(aa:A) = null 
g("x")(1) 

error: type mismatch; 
found : Int(1) 
required: java.lang.String 
     g("x")(1) 
      ^

Như bạn thấy, kiểm tra loại chỉ xem xét danh sách đối số đầu tiên, vì vậy A bị ràng buộc để String, vì vậy giá trị Int cho aa trong danh sách đối số thứ hai là một lỗi type.