'Default arguments' -> 'Default parameters'

docs/topics/coding-conventions.md

@@ -1112,7 +1112,7 @@ class Point(val x: Double, val y: Double) {
 ```
 
 If you have an object with multiple overloaded constructors that don't call different superclass constructors and
-can't be reduced to a single constructor with default argument values, prefer to replace the overloaded constructors with
+can't be reduced to a single constructor with optional parameters, prefer to replace the overloaded constructors with
 factory functions.
 
 ### Platform types

docs/topics/collection-transformations.md

@@ -244,8 +244,8 @@ strings: [`joinToString()`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.
 `joinToString()` builds a single `String` from the collection elements based on the provided arguments.
 `joinTo()` does the same but appends the result to the given [`Appendable`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/-appendable/index.html) object.
 
-When called with the default arguments, the functions return the result similar to calling `toString()` on the collection:
-a `String` of elements' string representations separated by commas with spaces. 
+When called with the parameters' default values, the functions return the result similar to calling `toString()` on the collection:
+a `String` of elements' string representations separated by commas with spaces.
 
 ```kotlin
 

docs/topics/functions.md

@@ -40,10 +40,10 @@ fun powerOf(
 ) { /*...*/ }
 ```
 
-### Default arguments
+### Parameters with default values
 
-Function parameters can have default values, which are used when you skip the corresponding argument. This reduces the number
-of overloads:
+Function parameters can have default values, which are used when you skip the corresponding argument.
+This reduces the number of overloads:
 
 ```kotlin
 fun read(
@@ -53,6 +53,8 @@ fun read(
 ) { /*...*/ }
 ```
 
+Such parameters are sometimes referred as _optional parameters_.
+
 A default value is set by appending `=` to the type.
 
 Overriding methods always use the base method's default parameter values.
@@ -68,7 +70,7 @@ class B : A() {
 }
 ```
 
-If a default parameter precedes a parameter with no default value, the default value can only be used by calling
+If a parameter with default value precedes a parameter with no default value, the default value can only be used by calling
 the function with [named arguments](#named-arguments):
 
 ```kotlin
@@ -80,8 +82,8 @@ fun foo(
 foo(baz = 1) // The default value bar = 0 is used
 ```
 
-If the last argument after default parameters is a [lambda](lambdas.md#lambda-expression-syntax),
-you can pass it either as a named argument or [outside the parentheses](lambdas.md#passing-trailing-lambdas):
+If the last parameter after all optional parameters has a functional type,
+then you can pass the corresponding [lambda](lambdas.md#lambda-expression-syntax) argument either as a named argument or [outside the parentheses](lambdas.md#passing-trailing-lambdas):
 
 ```kotlin
 fun foo(

docs/topics/js/js-interop.md

@@ -133,7 +133,7 @@ class Bar : Foo() {
 There are some limitations:
 
 - When a function of an external base class is overloaded by signature, you can't override it in a derived class.
-- You can't override a function with default arguments.
+- You can't override a function with optional parameters.
 - Non-external classes can't be extended by external classes.
 
 ### external interfaces

docs/topics/jvm/comparison-to-java.md

@@ -45,7 +45,7 @@ Kotlin fixes a series of issues that Java suffers from:
 * [Data classes](data-classes.md)
 * [Coroutines](coroutines-overview.md)
 * [Top-level functions](functions.md)
-* [Default arguments](functions.md#default-arguments)
+* [Parameters with default values](/docs/topics/functions.md#parameters-with-default-values)
 * [Named parameters](functions.md#named-arguments)
 * [Infix functions](functions.md#infix-notation)
 * [Expect and actual declarations](multiplatform-expect-actual.md)