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.