Newlines

source

Controls how line breaks in the input source are handled If classic (default), the old mixed behaviour will be used If keep, try to keep source newlines If fold, ignore source and try to remove line breaks If unfold, ignore source and try to break lines

neverBeforeJsNative

If true, a newline will never be placed in front of js.native.

sometimesBeforeColonInMethodReturnType

If true, scalafmt may choose to put a newline before colon : at defs.

penalizeSingleSelectMultiArgList

If true, adds a penalty to newlines before a dot starting a select chain of length one and argument list. The penalty matches the number of arguments to the select chain application.

// If true, favor
logger.elem(a,
            b,
            c)
// instead of
logger
  .elem(a, b, c)
// penalty is proportional to argument count, example:
logger.elem(a, b, c)    // penalty 2
logger.elem(a, b, c, d) // penalty 3, etc.

If false, matches pre-v0.5 behavior. Note. this option may be removed in a future release.

alwaysBeforeCurlyBraceLambdaParams

If true, puts a newline after the open brace and the parameters list of an anonymous function. For example something.map { n => consume(n) }

topLevelStatementsMinBreaks

Minimum span (number of line breaks between first and last line) to start forcing blank lines.

topLevelStatements

Forces a blank line before and/or after a top-level statement.

afterCurlyLambda

If never (default), it will remove any extra lines below curly lambdas

something.map { x =>
  f(x)
}

will become

something.map { x =>
  f(x)
}

If always, it will always add one empty line (opposite of never). If preserve, and there isn't an empty line, it will keep it as it is. If there is one or more empty lines, it will place a single empty line. If squash, it will try to squash lambda body in one line:

xs.map { x =>
  x + 1
}

will become

xs.map { x => x + 1 }

alwaysBeforeElseAfterCurlyIf

if true, add a new line between the end of a curly if and the following else. For example if(someCond) { // ... } else //...

alwaysBeforeMultilineDef

If true, add a newline before the body of a multiline def without curly braces. See #1126 for discussion. For example,

// newlines.alwaysBeforeMultilineDef = false
def foo(bar: Bar): Foo = bar
  .flatMap(f)
  .map(g)
// newlines.alwaysBeforeMultilineDef = true
def foo(bar: Bar): Foo =
  bar
    .flatMap(f)
    .map(g)

afterInfix

Controls how line breaks around operations are handled If keep (default for source=classic,keep), preserve existing If some (default for source=fold), break after some infix ops If many (default for source=unfold), break after many infix ops

afterInfixBreakOnNested

Force breaks around nested (enclosed in parentheses) expressions

afterInfixMaxCountPerExprForSome

Switch to many for a given expression (possibly nested) if the number of operations in that expression exceeds this value AND afterInfix had been set to some.

afterInfixMaxCountPerFile

Switch to keep for a given file if the total number of infix operations in that file exceeds this value

avoidAfterYield

If false (legacy behavior), inserts unconditional line break after yield if the yield body doesn't fit on a single line. For example,

// newlines.avoidAfterYield = true (default)
for (a <- as)
yield Future {
  ...
}
// newlines.avoidAfterYield = false (default before v2).
for (a <- as)
yield
  Future {
    ...
  }

Linear Supertypes

Serializable, Serializable, Product, Equals, AnyRef, Any

Instance Constructors

new Newlines(source: SourceHints = Newlines.classic, neverInResultType: Boolean = false, neverBeforeJsNative: Boolean = false, sometimesBeforeColonInMethodReturnType: Boolean = true, penalizeSingleSelectMultiArgList: Boolean = true, alwaysBeforeCurlyBraceLambdaParams: Boolean = false, topLevelStatementsMinBreaks: Int = 1, topLevelStatements: Seq[BeforeAfter] = Seq.empty, alwaysBeforeTopLevelStatements: Boolean = false, afterCurlyLambda: NewlineCurlyLambda = NewlineCurlyLambda.never, implicitParamListModifierForce: Seq[BeforeAfter] = Seq.empty, implicitParamListModifierPrefer: Option[BeforeAfter] = None, alwaysBeforeElseAfterCurlyIf: Boolean = false, alwaysBeforeMultilineDef: Boolean = true, afterInfix: Option[AfterInfix] = None, afterInfixBreakOnNested: Boolean = false, afterInfixMaxCountPerExprForSome: Int = 10, afterInfixMaxCountPerFile: Int = 500, avoidAfterYield: Boolean = true)
source
Controls how line breaks in the input source are handled If classic (default), the old mixed behaviour will be used If keep, try to keep source newlines If fold, ignore source and try to remove line breaks If unfold, ignore source and try to break lines
neverBeforeJsNative
If true, a newline will never be placed in front of js.native.
sometimesBeforeColonInMethodReturnType
If true, scalafmt may choose to put a newline before colon : at defs.
penalizeSingleSelectMultiArgList
If true, adds a penalty to newlines before a dot starting a select chain of length one and argument list. The penalty matches the number of arguments to the select chain application.
```
// If true, favor
logger.elem(a,
            b,
            c)
// instead of
logger
  .elem(a, b, c)
// penalty is proportional to argument count, example:
logger.elem(a, b, c)    // penalty 2
logger.elem(a, b, c, d) // penalty 3, etc.
```
If false, matches pre-v0.5 behavior. Note. this option may be removed in a future release.
alwaysBeforeCurlyBraceLambdaParams
If true, puts a newline after the open brace and the parameters list of an anonymous function. For example something.map { n => consume(n) }
topLevelStatementsMinBreaks
Minimum span (number of line breaks between first and last line) to start forcing blank lines.
topLevelStatements
Forces a blank line before and/or after a top-level statement.
afterCurlyLambda
If never (default), it will remove any extra lines below curly lambdas
```
something.map { x =>
  f(x)
}
```
will become
```
something.map { x =>
  f(x)
}
```
If always, it will always add one empty line (opposite of never). If preserve, and there isn't an empty line, it will keep it as it is. If there is one or more empty lines, it will place a single empty line. If squash, it will try to squash lambda body in one line:
```
xs.map { x =>
  x + 1
}
```
will become
```
xs.map { x => x + 1 }
```
alwaysBeforeElseAfterCurlyIf
if true, add a new line between the end of a curly if and the following else. For example if(someCond) { // ... } else //...
alwaysBeforeMultilineDef
If true, add a newline before the body of a multiline def without curly braces. See #1126 for discussion. For example,
```
// newlines.alwaysBeforeMultilineDef = false
def foo(bar: Bar): Foo = bar
  .flatMap(f)
  .map(g)
// newlines.alwaysBeforeMultilineDef = true
def foo(bar: Bar): Foo =
  bar
    .flatMap(f)
    .map(g)
```
afterInfix
Controls how line breaks around operations are handled If keep (default for source=classic,keep), preserve existing If some (default for source=fold), break after some infix ops If many (default for source=unfold), break after many infix ops
afterInfixBreakOnNested
Force breaks around nested (enclosed in parentheses) expressions
afterInfixMaxCountPerExprForSome
Switch to many for a given expression (possibly nested) if the number of operations in that expression exceeds this value AND afterInfix had been set to some.
afterInfixMaxCountPerFile
Switch to keep for a given file if the total number of infix operations in that file exceeds this value
avoidAfterYield
If false (legacy behavior), inserts unconditional line break after yield if the yield body doesn't fit on a single line. For example,
```
// newlines.avoidAfterYield = true (default)
for (a <- as)
yield Future {
  ...
}
// newlines.avoidAfterYield = false (default before v2).
for (a <- as)
yield
  Future {
    ...
  }
```

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val afterCurlyLambda: NewlineCurlyLambda

If never (default), it will remove any extra lines below curly lambdas
If never (default), it will remove any extra lines below curly lambdas
```
something.map { x =>
  f(x)
}
```
will become
```
something.map { x =>
  f(x)
}
```
If always, it will always add one empty line (opposite of never). If preserve, and there isn't an empty line, it will keep it as it is. If there is one or more empty lines, it will place a single empty line. If squash, it will try to squash lambda body in one line:
```
xs.map { x =>
  x + 1
}
```
will become
```
xs.map { x => x + 1 }
```
val afterInfix: Option[AfterInfix]

Controls how line breaks around operations are handled If keep (default for source=classic,keep), preserve existing If some (default for source=fold), break after some infix ops If many (default for source=unfold), break after many infix ops
val afterInfixBreakOnNested: Boolean

Force breaks around nested (enclosed in parentheses) expressions
val afterInfixMaxCountPerExprForSome: Int

Switch to many for a given expression (possibly nested) if the number of operations in that expression exceeds this value AND afterInfix had been set to some.
val afterInfixMaxCountPerFile: Int

Switch to keep for a given file if the total number of infix operations in that file exceeds this value
val alwaysBeforeCurlyBraceLambdaParams: Boolean

If true, puts a newline after the open brace and the parameters list of an anonymous function.
If true, puts a newline after the open brace and the parameters list of an anonymous function. For example something.map { n => consume(n) }
val alwaysBeforeElseAfterCurlyIf: Boolean

if true, add a new line between the end of a curly if and the following else.
if true, add a new line between the end of a curly if and the following else. For example if(someCond) { // ... } else //...
val alwaysBeforeMultilineDef: Boolean

If true, add a newline before the body of a multiline def without curly braces.
If true, add a newline before the body of a multiline def without curly braces. See #1126 for discussion. For example,
```
// newlines.alwaysBeforeMultilineDef = false
def foo(bar: Bar): Foo = bar
  .flatMap(f)
  .map(g)
// newlines.alwaysBeforeMultilineDef = true
def foo(bar: Bar): Foo =
  bar
    .flatMap(f)
    .map(g)
```
val alwaysBeforeTopLevelStatements: Boolean
final def asInstanceOf[T0]: T0

Definition Classes
Any
val avoidAfterYield: Boolean

If false (legacy behavior), inserts unconditional line break after yield if the yield body doesn't fit on a single line.
If false (legacy behavior), inserts unconditional line break after yield if the yield body doesn't fit on a single line. For example,
```
// newlines.avoidAfterYield = true (default)
for (a <- as)
yield Future {
  ...
}
// newlines.avoidAfterYield = false (default before v2).
for (a <- as)
yield
  Future {
    ...
  }
```
val breakAfterInfix: AfterInfix
def checkInfixConfig(infixCount: Int): Newlines
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
lazy val forceAfterImplicitParamListModifier: Boolean
lazy val forceBeforeImplicitParamListModifier: Boolean
lazy val forceBlankAfterMultilineTopLevelStmt: Boolean
lazy val forceBlankBeforeMultilineTopLevelStmt: Boolean
val formatInfix: Boolean
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
val implicitParamListModifierForce: Seq[BeforeAfter]
val implicitParamListModifierPrefer: Option[BeforeAfter]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val neverBeforeJsNative: Boolean

If true, a newline will never be placed in front of js.native.
val neverInResultType: Boolean
lazy val notBeforeImplicitParamListModifier: Boolean
lazy val notPreferAfterImplicitParamListModifier: Boolean
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val penalizeSingleSelectMultiArgList: Boolean

If true, adds a penalty to newlines before a dot starting a select chain of length one and argument list.
If true, adds a penalty to newlines before a dot starting a select chain of length one and argument list. The penalty matches the number of arguments to the select chain application.
```
// If true, favor
logger.elem(a,
            b,
            c)
// instead of
logger
  .elem(a, b, c)
// penalty is proportional to argument count, example:
logger.elem(a, b, c)    // penalty 2
logger.elem(a, b, c, d) // penalty 3, etc.
```
If false, matches pre-v0.5 behavior. Note. this option may be removed in a future release.
val reader: ConfDecoder[Newlines]
val sometimesBeforeColonInMethodReturnType: Boolean

If true, scalafmt may choose to put a newline before colon : at defs.
val source: SourceHints

Controls how line breaks in the input source are handled If classic (default), the old mixed behaviour will be used If keep, try to keep source newlines If fold, ignore source and try to remove line breaks If unfold, ignore source and try to break lines
val sourceIgnored: Boolean
def sourceIn(hints: SourceHints*): Boolean

Annotations
@inline()
def sourceIs(hint: SourceHints): Boolean

Annotations
@inline()
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val topLevelStatements: Seq[BeforeAfter]

Forces a blank line before and/or after a top-level statement.
val topLevelStatementsMinBreaks: Int

Minimum span (number of line breaks between first and last line) to start forcing blank lines.
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object Newlines | package config

Instance Constructors

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val afterCurlyLambda: NewlineCurlyLambda

val afterInfix: Option[AfterInfix]

val afterInfixBreakOnNested: Boolean

val afterInfixMaxCountPerExprForSome: Int

val afterInfixMaxCountPerFile: Int

val alwaysBeforeCurlyBraceLambdaParams: Boolean

val alwaysBeforeElseAfterCurlyIf: Boolean

val alwaysBeforeMultilineDef: Boolean

val alwaysBeforeTopLevelStatements: Boolean

final def asInstanceOf[T0]: T0

val avoidAfterYield: Boolean

val breakAfterInfix: AfterInfix

def checkInfixConfig(infixCount: Int): Newlines

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

lazy val forceAfterImplicitParamListModifier: Boolean

lazy val forceBeforeImplicitParamListModifier: Boolean

lazy val forceBlankAfterMultilineTopLevelStmt: Boolean

lazy val forceBlankBeforeMultilineTopLevelStmt: Boolean

val formatInfix: Boolean

final def getClass(): Class[_]

val implicitParamListModifierForce: Seq[BeforeAfter]

val implicitParamListModifierPrefer: Option[BeforeAfter]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

val neverBeforeJsNative: Boolean

val neverInResultType: Boolean

lazy val notBeforeImplicitParamListModifier: Boolean

lazy val notPreferAfterImplicitParamListModifier: Boolean

final def notify(): Unit

final def notifyAll(): Unit

val penalizeSingleSelectMultiArgList: Boolean

val reader: ConfDecoder[Newlines]

val sometimesBeforeColonInMethodReturnType: Boolean

val source: SourceHints

val sourceIgnored: Boolean

def sourceIn(hints: SourceHints*): Boolean

def sourceIs(hint: SourceHints): Boolean

final def synchronized[T0](arg0: ⇒ T0): T0

val topLevelStatements: Seq[BeforeAfter]

val topLevelStatementsMinBreaks: Int

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped