Bạn phân chia chữ ký chức năng Scala dài ở đâu?

Question

Một định nghĩa như

def foo(x: Int) = x + 1 

là tốt đẹp và ngắn và trông xinh đẹp, nhưng khi chữ ký riêng của mình được thoải mái dài,

def foo[T <: Token[T]](x: ArrayBuffer[T], y: T => ArrayBuffer[() => T]): (T, T, BigDecimal) = { 
    // ... 
} 

tôi không biết được nơi để chia nó. Tôi tìm thấy tất cả những điều sau đây để trông khó xử:

def foo(
    x: Int, 
    y: Int 
): Int = { 
    // ... 
} 

def foo(
     x: Int, 
     y: Int 
    ): Int = 
{ 
    // ... 
} 

def foo(
     x: Int, 
     y: Int 
    ): Int 
= { 
    // ... 
} 

def foo(
     x: Int, 
     y: Int 
    ): 
Int = { 
    // ... 
} 

Nhưng, tôi sẽ phải quen với một trong số này, điều này sẽ gây ít phiền toái nhất cho đồng đội của tôi?

Answer 1

Scala style guide không có gì để nói về điều này. Trong thực tế, nó khuyến cáo sử dụng các phương thức có ít tham số hơn :-).

Đối với lời gọi hàm nó khuyên tách để mỗi dòng tiếp theo thẳng hàng với dấu ngoặc đơn đầu tiên:

foo(someVeryLongFieldName, 
    andAnotherVeryLongFieldName, 
    "this is a string", 
    3.1415) 

Cá nhân trong trường hợp của bạn tôi sẽ chia theo một 'giữ như mọi thứ lại với nhau' quy tắc:

def foo[T <: Token[T]] 
     (x: ArrayBuffer[T], y: T => ArrayBuffer[() => T]) 
     : (T, T, BigDecimal) = { 
    // ... 
} 

Vì vậy, các thông số nằm trên một dòng, loại trả về nằm trên một dòng và giới hạn loại là trên một dòng.

Answer 2

Trong Haskell, chữ ký kiểu long thường được viết theo cách này:

someFunc :: (Some Constraints Go Here) 
     => Really Long Arg1 Type 
     -> Really Long Arg2 Type 
     -> Really Long Result Type 
somefunc x y = ... 

Để dịch Haskellism này vào Scala,

def foo [ T <: Token[T] ] 
     (x : ArrayBuffer[T] 
     , y : T => ArrayBuffer[() => T] 
     ) : (T, T, BigDecimal) = { 
    // ... 
} 

Đó là cách tôi sẽ làm điều đó. Bạn không chắc chắn về sự cộng hưởng của cộng đồng Scala.