Где вы разделяете длинные сигнатуры функций Scala?

Question

Определение типа

def foo(x: Int) = x + 1

красиво и коротко и выглядит красиво, но когда сама подпись становится неудобно длинной,

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

Я не знаю, где ее разбить,Я считаю, что все следующее выглядит неловко:

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

Но, учитывая, что мне придется привыкнуть к одному из них, это будет меньше всего раздражать моих товарищей по команде?

Answer 1

Руководству по стилю Scala нечего сказать по этому поводу. Фактически он рекомендует использовать методы с меньшим количеством параметров: -).

Для вызовов функций рекомендуется разделение, чтобы каждая последующая строка выравнивалась с первой круглой скобкой:

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

Лично в вашем случае я бы разделил в соответствии с правилом "держись как вещи вместе":

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

Таким образом, параметры находятся в одной строке, тип возвращаемого значения - в одной строке, а ограничение типа - в одной строке.

Answer 2

В Хаскеле подписи длинных типов часто пишутся таким образом:

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

Чтобы перевести этот хаскелизм в Scala,

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

Вот как я это сделаю.Не уверен, насколько кошерно это с сообществом Scala.