¿Dónde se dividen las firmas largas de la función Scala?

Question

Una definición como

def foo(x: Int) = x + 1 

es agradable y corto y se ve bastante, pero cuando la firma en sí que está demasiado largo,

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

no sé dónde dividirlo. Me parece todo lo siguiente para buscar incómoda:

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

Pero, dado que yo voy a tener que acostumbrarse a uno de ellos, lo que hará que la menor molestia a mis compañeros de equipo?

Answer 1

El Scala style guide no tiene nada que decir al respecto. De hecho, recomienda utilizar métodos con menos parámetros :-).

Para las invocaciones de función sí recomienda la división para que cada línea posterior se alinea con el primer paréntesis:

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

personalmente en su caso sin dividir de acuerdo con un 'mantener que las cosas juntos' regla:

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

Entonces los parámetros están en una línea, el tipo de retorno está en una sola línea y la restricción de tipo está en una sola línea.

Answer 2

En Haskell, firmas tipo largo se escriben a menudo de esta manera:

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

Para traducir este Haskellism en Scala,

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

Así es como yo lo haría. No estoy seguro de cuán kosher es con la comunidad de Scala.