implicit argument lists

[kiritsuku]

From @fommil on October 25, 2014 11:24

It is fairly standard practice in implicit-heavy libraries to write implicit parameter lists like this

  def canBuildFromFormat[F, E, T]()(implicit
    cbf: CanBuildFrom[F, E, T],
    ef: SexpFormat[E]
  )

but unfortunately I can't set up scalariform to use this trailing-implicit format. Is this something you could support with a new option?

Note that it is possible to do this sort of thing

  def canBuildFromFormat[F, E, T]()(
    implicit
    cbf: CanBuildFrom[F, E, T],
    ef: SexpFormat[E]
  )

Copied from original issue: daniel-trinh#36

[kiritsuku]

From @nairbv on January 1, 2016 1:36

I'm looking for any way to use scalariform without condensing curried function signatures, but the issue isn't just with implicit parameters, it's any kind of currying.
e.g., when I see code like:

def aReallyLongMethodName(thatHasSomeParameters:WithLongTypes)(andThenAnother:ParameterList) = foo

I'd like to be able to write it as:

def aReallyLongMethodName(thatHasSomeParameters:WithLongTypes)
                         (andThenAnother:ParameterList) = foo

But it automatically gets reformatted back to the first one by scalariform. This prevents me from keeping a tight limit on org.scalastyle.file.FileLineLengthChecker in scalaStyle, and I've often seen single lines of code that get excessively long.

From the preview here it looks like characters aren't monospaced, but what I was getting at in my example is I would typically align the open-paren of my curried parameters, implicit or not.

Ideally I think I'd rather just have scalariform not touch any whitespace between a close and then open paren. I hadn't considered your style for writing implicit parameters.

[kiritsuku]

From @nairbv on January 1, 2016 17:39

I think I'll create a separate issue for what I'm describing since the option I'm requesting for curried parameters is a bit different.

[jkinkead]

I have a patch that formats implicits all with the keyword attached to the first parameter:

def foo()(
  implicit a: TypeA,
  b: TypeB
): Unit = {}

This could be leveraged into the filer's format if desired.

[fommil]

I've seen that style, it might be a useful addition.

[godenji]

This works out of the box (0.2.4)

def canBuildFromFormat[F, E, T]()(implicit
  cbf: CanBuildFrom[F, E, T],
  ef: SexpFormat[E]
)

While this is not currently possible

def aReallyLongMethodName(thatHasSomeParameters:WithLongTypes)
                         (andThenAnother:ParameterList) = foo

An alternative solution is

def aReallyLongMethodName
  (thatHasSomeParameters:WithLongTypes)
  (andThenAnother:ParameterList) = foo

Basically, stack param groups and let the library handle indentation.