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

tags graffiti nombres

Question

Una definición como

def foo(x: Int) = x + 1

es agradable y corto y se ve bonito, pero cuando la firma en sí se vuelve incómodamente larga,

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

No sé dónde dividirlo. Encuentro todo lo siguiente para parecer incómodo:

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 voy a tener que acostumbrarme a uno de estos, ¿cuál será la menor molestia para mis compañeros de equipo?

Answer 1

En Haskell, las firmas de 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 haskelismo a Scala,

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

Así es como lo haría. No estoy seguro de qué tan kosher es con la comunidad Scala.

Answer 2

La guía de estilo Scala no tiene nada que decir sobre esto. De hecho, recomienda utilizar métodos con menos parámetros :-).

Para las invocaciones de funciones, se recomienda dividir para que cada línea subsiguiente se alinee con el primer paréntesis:

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

Personalmente, en su caso, me dividiría de acuerdo con la regla de "mantener las cosas juntas":

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

Por lo tanto, 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.