Gdzie dzielisz długie podpisy funkcji Scala?

Question

Definicja jak

def foo(x: Int) = x + 1 

jest miła i krótka i wygląda całkiem, ale gdy sam podpis staje się nieprzyjemnie długo,

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

nie wiem gdzie go podzielić. Uważam wszystkie następujące wyglądać niezręcznie:

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 = { 
    // ... 
} 

Ale, biorąc pod uwagę, że będę musiał przyzwyczaić się do jednego z nich, który spowoduje najmniejszą uciążliwość dla moich kolegów?

Answer 1

The Scala style guide nie ma nic do powiedzenia na ten temat. W rzeczywistości zaleca stosowanie metod o mniejszej liczbie parametrów :-).

Dla wywołania funkcji to nie zaleca podział tak, że każda kolejna linia wyrównany pierwszym nawiasie:

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

Osobiście w twoim przypadku będzie podzielona według tak zwanego „zachować jak rzeczy razem” zasada:

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

Parametry są w jednym wierszu, typ zwracany znajduje się w pojedynczej linii, a ograniczenie typu w jednym wierszu.

Answer 2

W Haskell, podpisy długo typu są często pisane w ten sposób:

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

Aby przetłumaczyć ten Haskellism w Scala,

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

To w jaki sposób to zrobić. Nie wiem, jak koszerne jest to ze społecznością Scala.