Newlines

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) }

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.

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)

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(neverInResultType: Boolean = false, neverBeforeJsNative: Boolean = false, sometimesBeforeColonInMethodReturnType: Boolean = true, penalizeSingleSelectMultiArgList: Boolean = true, alwaysBeforeCurlyBraceLambdaParams: Boolean = false, alwaysBeforeTopLevelStatements: Boolean = false, afterCurlyLambda: NewlineCurlyLambda = NewlineCurlyLambda.never, afterImplicitKWInVerticalMultiline: Boolean = false, beforeImplicitKWInVerticalMultiline: Boolean = false, alwaysBeforeElseAfterCurlyIf: Boolean = false, alwaysBeforeMultilineDef: Boolean = true, avoidAfterYield: Boolean = true)
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) }
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.
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)
```
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.
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 {
    ...
  }
```
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] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
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
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.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
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( ... )

Deprecated Value Members

val afterImplicitKWInVerticalMultiline: Boolean

Annotations
@deprecated
Deprecated
Use VerticalMultiline.newlineAfterImplicitKW instead
val beforeImplicitKWInVerticalMultiline: Boolean

Annotations
@deprecated
Deprecated
Use VerticalMultiline.newlineBeforeImplicitKW instead

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 alwaysBeforeCurlyBraceLambdaParams: Boolean

val alwaysBeforeElseAfterCurlyIf: Boolean

val alwaysBeforeMultilineDef: Boolean

val alwaysBeforeTopLevelStatements: Boolean

final def asInstanceOf[T0]: T0

val avoidAfterYield: Boolean

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

val neverBeforeJsNative: Boolean

val neverInResultType: Boolean

final def notify(): Unit

final def notifyAll(): Unit

val penalizeSingleSelectMultiArgList: Boolean

val reader: ConfDecoder[Newlines]

val sometimesBeforeColonInMethodReturnType: Boolean

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Deprecated Value Members

val afterImplicitKWInVerticalMultiline: Boolean

val beforeImplicitKWInVerticalMultiline: Boolean

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped