Fix formatting in Engine and templates

libraries/stdlib/src/generated/_Arrays.kt

@@ -10,126 +10,126 @@ import java.util.*
 /**
  * Returns true if the array is empty
  */
-public fun <T> Array<out T>.isEmpty() : Boolean {
+public fun <T> Array<out T>.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun BooleanArray.isEmpty() : Boolean {
+public fun BooleanArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun ByteArray.isEmpty() : Boolean {
+public fun ByteArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun CharArray.isEmpty() : Boolean {
+public fun CharArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun DoubleArray.isEmpty() : Boolean {
+public fun DoubleArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun FloatArray.isEmpty() : Boolean {
+public fun FloatArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun IntArray.isEmpty() : Boolean {
+public fun IntArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun LongArray.isEmpty() : Boolean {
+public fun LongArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun ShortArray.isEmpty() : Boolean {
+public fun ShortArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun <T> Array<out T>.isNotEmpty() : Boolean {
+public fun <T> Array<out T>.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun BooleanArray.isNotEmpty() : Boolean {
+public fun BooleanArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun ByteArray.isNotEmpty() : Boolean {
+public fun ByteArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun CharArray.isNotEmpty() : Boolean {
+public fun CharArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun DoubleArray.isNotEmpty() : Boolean {
+public fun DoubleArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun FloatArray.isNotEmpty() : Boolean {
+public fun FloatArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun IntArray.isNotEmpty() : Boolean {
+public fun IntArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun LongArray.isNotEmpty() : Boolean {
+public fun LongArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun ShortArray.isNotEmpty() : Boolean {
+public fun ShortArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 

libraries/stdlib/src/generated/_Guards.kt

@@ -10,52 +10,48 @@ import java.util.*
 /**
  * Returns an original collection containing all the non-*null* elements, throwing an [[IllegalArgumentException]] if there are any null elements
  */
-public fun <T:Any> Array<T?>.requireNoNulls() : Array<T> {
+public fun <T : Any> Array<T?>.requireNoNulls(): Array<T> {
     for (element in this) {
         if (element == null) {
             throw IllegalArgumentException("null element found in $this")
         }
     }
     return this as Array<T>
-    
 }
 
 /**
  * Returns an original collection containing all the non-*null* elements, throwing an [[IllegalArgumentException]] if there are any null elements
  */
-public fun <T:Any> Iterable<T?>.requireNoNulls() : Iterable<T> {
+public fun <T : Any> Iterable<T?>.requireNoNulls(): Iterable<T> {
     for (element in this) {
         if (element == null) {
             throw IllegalArgumentException("null element found in $this")
         }
     }
     return this as Iterable<T>
-    
 }
 
 /**
  * Returns an original collection containing all the non-*null* elements, throwing an [[IllegalArgumentException]] if there are any null elements
  */
-public fun <T:Any> List<T?>.requireNoNulls() : List<T> {
+public fun <T : Any> List<T?>.requireNoNulls(): List<T> {
     for (element in this) {
         if (element == null) {
             throw IllegalArgumentException("null element found in $this")
         }
     }
     return this as List<T>
-    
 }
 
 /**
  * Returns an original collection containing all the non-*null* elements, throwing an [[IllegalArgumentException]] if there are any null elements
  */
-public fun <T:Any> Stream<T?>.requireNoNulls() : Stream<T> {
+public fun <T : Any> Stream<T?>.requireNoNulls(): Stream<T> {
     return FilteringStream(this) {
         if (it == null) {
             throw IllegalArgumentException("null element found in $this")
         }
         true
     } as Stream<T>
-    
 }
 

libraries/stdlib/src/generated/_Numeric.kt

@@ -10,208 +10,192 @@ import java.util.*
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Iterable<Int>.sum() : Int {
+public fun Iterable<Int>.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Iterable<Long>.sum() : Long {
+public fun Iterable<Long>.sum(): Long {
     val iterator = iterator()
-    var sum : Long = 0
+    var sum: Long = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Iterable<Double>.sum() : Double {
+public fun Iterable<Double>.sum(): Double {
     val iterator = iterator()
-    var sum : Double = 0.0
+    var sum: Double = 0.0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Iterable<Float>.sum() : Float {
+public fun Iterable<Float>.sum(): Float {
     val iterator = iterator()
-    var sum : Float = 0.0f
+    var sum: Float = 0.0f
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Array<out Int>.sum() : Int {
+public fun Array<out Int>.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun IntArray.sum() : Int {
+public fun IntArray.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Array<out Long>.sum() : Long {
+public fun Array<out Long>.sum(): Long {
     val iterator = iterator()
-    var sum : Long = 0
+    var sum: Long = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun LongArray.sum() : Long {
+public fun LongArray.sum(): Long {
     val iterator = iterator()
-    var sum : Long = 0
+    var sum: Long = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Array<out Byte>.sum() : Int {
+public fun Array<out Byte>.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun ByteArray.sum() : Int {
+public fun ByteArray.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Array<out Short>.sum() : Int {
+public fun Array<out Short>.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun ShortArray.sum() : Int {
+public fun ShortArray.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Array<out Double>.sum() : Double {
+public fun Array<out Double>.sum(): Double {
     val iterator = iterator()
-    var sum : Double = 0.0
+    var sum: Double = 0.0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun DoubleArray.sum() : Double {
+public fun DoubleArray.sum(): Double {
     val iterator = iterator()
-    var sum : Double = 0.0
+    var sum: Double = 0.0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Array<out Float>.sum() : Float {
+public fun Array<out Float>.sum(): Float {
     val iterator = iterator()
-    var sum : Float = 0.0f
+    var sum: Float = 0.0f
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun FloatArray.sum() : Float {
+public fun FloatArray.sum(): Float {
     val iterator = iterator()
-    var sum : Float = 0.0f
+    var sum: Float = 0.0f
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 

libraries/stdlib/src/generated/_Ordering.kt

@@ -10,193 +10,174 @@ import java.util.*
 /**
  * Returns a list with elements in reversed order
  */
-public fun <T> Array<out T>.reverse() : List<T> {
+public fun <T> Array<out T>.reverse(): List<T> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun BooleanArray.reverse() : List<Boolean> {
+public fun BooleanArray.reverse(): List<Boolean> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun ByteArray.reverse() : List<Byte> {
+public fun ByteArray.reverse(): List<Byte> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun CharArray.reverse() : List<Char> {
+public fun CharArray.reverse(): List<Char> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun DoubleArray.reverse() : List<Double> {
+public fun DoubleArray.reverse(): List<Double> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun FloatArray.reverse() : List<Float> {
+public fun FloatArray.reverse(): List<Float> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun IntArray.reverse() : List<Int> {
+public fun IntArray.reverse(): List<Int> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun LongArray.reverse() : List<Long> {
+public fun LongArray.reverse(): List<Long> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun ShortArray.reverse() : List<Short> {
+public fun ShortArray.reverse(): List<Short> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun <T> Iterable<T>.reverse() : List<T> {
+public fun <T> Iterable<T>.reverse(): List<T> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a string with characters in reversed order
  */
-public fun String.reverse() : String {
+public fun String.reverse(): String {
     return StringBuilder().append(this).reverse().toString()
-    
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun <T: Comparable<T>> Iterable<T>.sort() : List<T> {
+public fun <T : Comparable<T>> Iterable<T>.sort(): List<T> {
     val sortedList = toArrayList()
     java.util.Collections.sort(sortedList)
     return sortedList
-    
 }
 
 /**
  * Returns a list of all elements, sorted by the specified *comparator*
  */
-public fun <T> Array<out T>.sortBy(comparator : Comparator<T>) : List<T> {
+public fun <T> Array<out T>.sortBy(comparator: Comparator<T>): List<T> {
     val sortedList = toArrayList()
     java.util.Collections.sort(sortedList, comparator)
     return sortedList
-    
 }
 
 /**
  * Returns a list of all elements, sorted by the specified *comparator*
  */
-public fun <T> Iterable<T>.sortBy(comparator : Comparator<T>) : List<T> {
+public fun <T> Iterable<T>.sortBy(comparator: Comparator<T>): List<T> {
     val sortedList = toArrayList()
     java.util.Collections.sort(sortedList, comparator)
     return sortedList
-    
 }
 
 /**
  * Returns a list of all elements, sorted by results of specified *order* function.
  */
-public inline fun <T, R: Comparable<R>> Array<out T>.sortBy(order: (T) -> R) : List<T> {
+public inline fun <T, R : Comparable<R>> Array<out T>.sortBy(order: (T) -> R): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y))}
+    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y)) }
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
-    
 }
 
 /**
  * Returns a list of all elements, sorted by results of specified *order* function.
  */
-public inline fun <T, R: Comparable<R>> Iterable<T>.sortBy(order: (T) -> R) : List<T> {
+public inline fun <T, R : Comparable<R>> Iterable<T>.sortBy(order: (T) -> R): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y))}
+    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y)) }
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
-    
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun <T: Comparable<T>> Iterable<T>.sortDescending() : List<T> {
+public fun <T : Comparable<T>> Iterable<T>.sortDescending(): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -x.compareTo(y)}
+    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -x.compareTo(y) }
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
-    
 }
 
 /**
  * Returns a list of all elements, sorted by results of specified *order* function.
  */
-public inline fun <T, R: Comparable<R>> Array<out T>.sortDescendingBy(order: (T) -> R) : List<T> {
+public inline fun <T, R : Comparable<R>> Array<out T>.sortDescendingBy(order: (T) -> R): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -order(x).compareTo(order(y))}
+    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -order(x).compareTo(order(y)) }
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
-    
 }
 
 /**
  * Returns a list of all elements, sorted by results of specified *order* function.
  */
-public inline fun <T, R: Comparable<R>> Iterable<T>.sortDescendingBy(order: (T) -> R) : List<T> {
+public inline fun <T, R : Comparable<R>> Iterable<T>.sortDescendingBy(order: (T) -> R): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -order(x).compareTo(order(y))}
+    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -order(x).compareTo(order(y)) }
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
-    
 }
 

libraries/stdlib/src/generated/_Snapshots.kt

@@ -10,771 +10,742 @@ import java.util.*
 /**
  * Returns an ArrayList of all elements
  */
-public fun <T> Array<out T>.toArrayList() : ArrayList<T> {
+public fun <T> Array<out T>.toArrayList(): ArrayList<T> {
     val list = ArrayList<T>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun BooleanArray.toArrayList() : ArrayList<Boolean> {
+public fun BooleanArray.toArrayList(): ArrayList<Boolean> {
     val list = ArrayList<Boolean>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun ByteArray.toArrayList() : ArrayList<Byte> {
+public fun ByteArray.toArrayList(): ArrayList<Byte> {
     val list = ArrayList<Byte>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun CharArray.toArrayList() : ArrayList<Char> {
+public fun CharArray.toArrayList(): ArrayList<Char> {
     val list = ArrayList<Char>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun DoubleArray.toArrayList() : ArrayList<Double> {
+public fun DoubleArray.toArrayList(): ArrayList<Double> {
     val list = ArrayList<Double>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun FloatArray.toArrayList() : ArrayList<Float> {
+public fun FloatArray.toArrayList(): ArrayList<Float> {
     val list = ArrayList<Float>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun IntArray.toArrayList() : ArrayList<Int> {
+public fun IntArray.toArrayList(): ArrayList<Int> {
     val list = ArrayList<Int>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun LongArray.toArrayList() : ArrayList<Long> {
+public fun LongArray.toArrayList(): ArrayList<Long> {
     val list = ArrayList<Long>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun ShortArray.toArrayList() : ArrayList<Short> {
+public fun ShortArray.toArrayList(): ArrayList<Short> {
     val list = ArrayList<Short>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun <T> Iterable<T>.toArrayList() : ArrayList<T> {
+public fun <T> Iterable<T>.toArrayList(): ArrayList<T> {
     return toCollection(ArrayList<T>())
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun <T> Stream<T>.toArrayList() : ArrayList<T> {
+public fun <T> Stream<T>.toArrayList(): ArrayList<T> {
     return toCollection(ArrayList<T>())
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun String.toArrayList() : ArrayList<Char> {
+public fun String.toArrayList(): ArrayList<Char> {
     return toCollection(ArrayList<Char>())
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <T, C : MutableCollection<in T>> Array<out T>.toCollection(collection : C) : C {
+public fun <T, C : MutableCollection<in T>> Array<out T>.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Boolean>> BooleanArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Boolean>> BooleanArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Byte>> ByteArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Byte>> ByteArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Char>> CharArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Char>> CharArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Double>> DoubleArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Double>> DoubleArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Float>> FloatArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Float>> FloatArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Int>> IntArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Int>> IntArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Long>> LongArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Long>> LongArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Short>> ShortArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Short>> ShortArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <T, C : MutableCollection<in T>> Iterable<T>.toCollection(collection : C) : C {
+public fun <T, C : MutableCollection<in T>> Iterable<T>.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <T, C : MutableCollection<in T>> Stream<T>.toCollection(collection : C) : C {
+public fun <T, C : MutableCollection<in T>> Stream<T>.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Char>> String.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Char>> String.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun <T> Array<out T>.toHashSet() : HashSet<T> {
+public fun <T> Array<out T>.toHashSet(): HashSet<T> {
     return toCollection(HashSet<T>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun BooleanArray.toHashSet() : HashSet<Boolean> {
+public fun BooleanArray.toHashSet(): HashSet<Boolean> {
     return toCollection(HashSet<Boolean>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun ByteArray.toHashSet() : HashSet<Byte> {
+public fun ByteArray.toHashSet(): HashSet<Byte> {
     return toCollection(HashSet<Byte>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun CharArray.toHashSet() : HashSet<Char> {
+public fun CharArray.toHashSet(): HashSet<Char> {
     return toCollection(HashSet<Char>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun DoubleArray.toHashSet() : HashSet<Double> {
+public fun DoubleArray.toHashSet(): HashSet<Double> {
     return toCollection(HashSet<Double>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun FloatArray.toHashSet() : HashSet<Float> {
+public fun FloatArray.toHashSet(): HashSet<Float> {
     return toCollection(HashSet<Float>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun IntArray.toHashSet() : HashSet<Int> {
+public fun IntArray.toHashSet(): HashSet<Int> {
     return toCollection(HashSet<Int>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun LongArray.toHashSet() : HashSet<Long> {
+public fun LongArray.toHashSet(): HashSet<Long> {
     return toCollection(HashSet<Long>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun ShortArray.toHashSet() : HashSet<Short> {
+public fun ShortArray.toHashSet(): HashSet<Short> {
     return toCollection(HashSet<Short>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun <T> Iterable<T>.toHashSet() : HashSet<T> {
+public fun <T> Iterable<T>.toHashSet(): HashSet<T> {
     return toCollection(HashSet<T>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun <T> Stream<T>.toHashSet() : HashSet<T> {
+public fun <T> Stream<T>.toHashSet(): HashSet<T> {
     return toCollection(HashSet<T>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun String.toHashSet() : HashSet<Char> {
+public fun String.toHashSet(): HashSet<Char> {
     return toCollection(HashSet<Char>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun <T> Array<out T>.toLinkedList() : LinkedList<T> {
+public fun <T> Array<out T>.toLinkedList(): LinkedList<T> {
     return toCollection(LinkedList<T>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun BooleanArray.toLinkedList() : LinkedList<Boolean> {
+public fun BooleanArray.toLinkedList(): LinkedList<Boolean> {
     return toCollection(LinkedList<Boolean>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun ByteArray.toLinkedList() : LinkedList<Byte> {
+public fun ByteArray.toLinkedList(): LinkedList<Byte> {
     return toCollection(LinkedList<Byte>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun CharArray.toLinkedList() : LinkedList<Char> {
+public fun CharArray.toLinkedList(): LinkedList<Char> {
     return toCollection(LinkedList<Char>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun DoubleArray.toLinkedList() : LinkedList<Double> {
+public fun DoubleArray.toLinkedList(): LinkedList<Double> {
     return toCollection(LinkedList<Double>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun FloatArray.toLinkedList() : LinkedList<Float> {
+public fun FloatArray.toLinkedList(): LinkedList<Float> {
     return toCollection(LinkedList<Float>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun IntArray.toLinkedList() : LinkedList<Int> {
+public fun IntArray.toLinkedList(): LinkedList<Int> {
     return toCollection(LinkedList<Int>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun LongArray.toLinkedList() : LinkedList<Long> {
+public fun LongArray.toLinkedList(): LinkedList<Long> {
     return toCollection(LinkedList<Long>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun ShortArray.toLinkedList() : LinkedList<Short> {
+public fun ShortArray.toLinkedList(): LinkedList<Short> {
     return toCollection(LinkedList<Short>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun <T> Iterable<T>.toLinkedList() : LinkedList<T> {
+public fun <T> Iterable<T>.toLinkedList(): LinkedList<T> {
     return toCollection(LinkedList<T>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun <T> Stream<T>.toLinkedList() : LinkedList<T> {
+public fun <T> Stream<T>.toLinkedList(): LinkedList<T> {
     return toCollection(LinkedList<T>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun String.toLinkedList() : LinkedList<Char> {
+public fun String.toLinkedList(): LinkedList<Char> {
     return toCollection(LinkedList<Char>())
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun <T> Array<out T>.toList() : List<T> {
+public fun <T> Array<out T>.toList(): List<T> {
     return toCollection(ArrayList<T>())
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun BooleanArray.toList() : List<Boolean> {
+public fun BooleanArray.toList(): List<Boolean> {
     val list = ArrayList<Boolean>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun ByteArray.toList() : List<Byte> {
+public fun ByteArray.toList(): List<Byte> {
     val list = ArrayList<Byte>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun CharArray.toList() : List<Char> {
+public fun CharArray.toList(): List<Char> {
     val list = ArrayList<Char>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun DoubleArray.toList() : List<Double> {
+public fun DoubleArray.toList(): List<Double> {
     val list = ArrayList<Double>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun FloatArray.toList() : List<Float> {
+public fun FloatArray.toList(): List<Float> {
     val list = ArrayList<Float>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun IntArray.toList() : List<Int> {
+public fun IntArray.toList(): List<Int> {
     val list = ArrayList<Int>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun LongArray.toList() : List<Long> {
+public fun LongArray.toList(): List<Long> {
     val list = ArrayList<Long>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun ShortArray.toList() : List<Short> {
+public fun ShortArray.toList(): List<Short> {
     val list = ArrayList<Short>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun <T> Iterable<T>.toList() : List<T> {
+public fun <T> Iterable<T>.toList(): List<T> {
     return toCollection(ArrayList<T>())
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun <T> Stream<T>.toList() : List<T> {
+public fun <T> Stream<T>.toList(): List<T> {
     return toCollection(ArrayList<T>())
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun String.toList() : List<Char> {
+public fun String.toList(): List<Char> {
     return toCollection(ArrayList<Char>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun <T> Array<out T>.toSet() : Set<T> {
+public fun <T> Array<out T>.toSet(): Set<T> {
     return toCollection(LinkedHashSet<T>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun BooleanArray.toSet() : Set<Boolean> {
+public fun BooleanArray.toSet(): Set<Boolean> {
     return toCollection(LinkedHashSet<Boolean>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun ByteArray.toSet() : Set<Byte> {
+public fun ByteArray.toSet(): Set<Byte> {
     return toCollection(LinkedHashSet<Byte>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun CharArray.toSet() : Set<Char> {
+public fun CharArray.toSet(): Set<Char> {
     return toCollection(LinkedHashSet<Char>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun DoubleArray.toSet() : Set<Double> {
+public fun DoubleArray.toSet(): Set<Double> {
     return toCollection(LinkedHashSet<Double>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun FloatArray.toSet() : Set<Float> {
+public fun FloatArray.toSet(): Set<Float> {
     return toCollection(LinkedHashSet<Float>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun IntArray.toSet() : Set<Int> {
+public fun IntArray.toSet(): Set<Int> {
     return toCollection(LinkedHashSet<Int>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun LongArray.toSet() : Set<Long> {
+public fun LongArray.toSet(): Set<Long> {
     return toCollection(LinkedHashSet<Long>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun ShortArray.toSet() : Set<Short> {
+public fun ShortArray.toSet(): Set<Short> {
     return toCollection(LinkedHashSet<Short>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun <T> Iterable<T>.toSet() : Set<T> {
+public fun <T> Iterable<T>.toSet(): Set<T> {
     return toCollection(LinkedHashSet<T>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun <T> Stream<T>.toSet() : Set<T> {
+public fun <T> Stream<T>.toSet(): Set<T> {
     return toCollection(LinkedHashSet<T>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun String.toSet() : Set<Char> {
+public fun String.toSet(): Set<Char> {
     return toCollection(LinkedHashSet<Char>())
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun <T: Comparable<T>> Array<out T>.toSortedList() : List<T> {
+public fun <T : Comparable<T>> Array<out T>.toSortedList(): List<T> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun BooleanArray.toSortedList() : List<Boolean> {
+public fun BooleanArray.toSortedList(): List<Boolean> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun ByteArray.toSortedList() : List<Byte> {
+public fun ByteArray.toSortedList(): List<Byte> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun CharArray.toSortedList() : List<Char> {
+public fun CharArray.toSortedList(): List<Char> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun DoubleArray.toSortedList() : List<Double> {
+public fun DoubleArray.toSortedList(): List<Double> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun FloatArray.toSortedList() : List<Float> {
+public fun FloatArray.toSortedList(): List<Float> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun IntArray.toSortedList() : List<Int> {
+public fun IntArray.toSortedList(): List<Int> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun LongArray.toSortedList() : List<Long> {
+public fun LongArray.toSortedList(): List<Long> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun ShortArray.toSortedList() : List<Short> {
+public fun ShortArray.toSortedList(): List<Short> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun <T: Comparable<T>> Iterable<T>.toSortedList() : List<T> {
+public fun <T : Comparable<T>> Iterable<T>.toSortedList(): List<T> {
     return sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun <T: Comparable<T>> Stream<T>.toSortedList() : List<T> {
+public fun <T : Comparable<T>> Stream<T>.toSortedList(): List<T> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun String.toSortedList() : List<Char> {
+public fun String.toSortedList(): List<Char> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun <T> Array<out T>.toSortedSet() : SortedSet<T> {
+public fun <T> Array<out T>.toSortedSet(): SortedSet<T> {
     return toCollection(TreeSet<T>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun BooleanArray.toSortedSet() : SortedSet<Boolean> {
+public fun BooleanArray.toSortedSet(): SortedSet<Boolean> {
     return toCollection(TreeSet<Boolean>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun ByteArray.toSortedSet() : SortedSet<Byte> {
+public fun ByteArray.toSortedSet(): SortedSet<Byte> {
     return toCollection(TreeSet<Byte>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun CharArray.toSortedSet() : SortedSet<Char> {
+public fun CharArray.toSortedSet(): SortedSet<Char> {
     return toCollection(TreeSet<Char>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun DoubleArray.toSortedSet() : SortedSet<Double> {
+public fun DoubleArray.toSortedSet(): SortedSet<Double> {
     return toCollection(TreeSet<Double>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun FloatArray.toSortedSet() : SortedSet<Float> {
+public fun FloatArray.toSortedSet(): SortedSet<Float> {
     return toCollection(TreeSet<Float>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun IntArray.toSortedSet() : SortedSet<Int> {
+public fun IntArray.toSortedSet(): SortedSet<Int> {
     return toCollection(TreeSet<Int>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun LongArray.toSortedSet() : SortedSet<Long> {
+public fun LongArray.toSortedSet(): SortedSet<Long> {
     return toCollection(TreeSet<Long>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun ShortArray.toSortedSet() : SortedSet<Short> {
+public fun ShortArray.toSortedSet(): SortedSet<Short> {
     return toCollection(TreeSet<Short>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun <T> Iterable<T>.toSortedSet() : SortedSet<T> {
+public fun <T> Iterable<T>.toSortedSet(): SortedSet<T> {
     return toCollection(TreeSet<T>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun <T> Stream<T>.toSortedSet() : SortedSet<T> {
+public fun <T> Stream<T>.toSortedSet(): SortedSet<T> {
     return toCollection(TreeSet<T>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun String.toSortedSet() : SortedSet<Char> {
+public fun String.toSortedSet(): SortedSet<Char> {
     return toCollection(TreeSet<Char>())
 }
 

libraries/stdlib/src/generated/_SpecialJVM.kt

@@ -10,450 +10,433 @@ import java.util.*
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun <T> Array<out T>.binarySearch(element: T, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun <T> Array<out T>.binarySearch(element: T, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun ByteArray.binarySearch(element: Byte, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun ByteArray.binarySearch(element: Byte, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun CharArray.binarySearch(element: Char, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun CharArray.binarySearch(element: Char, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun DoubleArray.binarySearch(element: Double, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun DoubleArray.binarySearch(element: Double, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun FloatArray.binarySearch(element: Float, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun FloatArray.binarySearch(element: Float, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun IntArray.binarySearch(element: Int, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun IntArray.binarySearch(element: Int, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun LongArray.binarySearch(element: Long, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun LongArray.binarySearch(element: Long, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun ShortArray.binarySearch(element: Short, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun ShortArray.binarySearch(element: Short, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun <T> Array<out T>.copyOf() : Array<T> {
+public fun <T> Array<out T>.copyOf(): Array<T> {
     return Arrays.copyOf(this, size) as Array<T>
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun BooleanArray.copyOf() : BooleanArray {
+public fun BooleanArray.copyOf(): BooleanArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun ByteArray.copyOf() : ByteArray {
+public fun ByteArray.copyOf(): ByteArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun CharArray.copyOf() : CharArray {
+public fun CharArray.copyOf(): CharArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun DoubleArray.copyOf() : DoubleArray {
+public fun DoubleArray.copyOf(): DoubleArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun FloatArray.copyOf() : FloatArray {
+public fun FloatArray.copyOf(): FloatArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun IntArray.copyOf() : IntArray {
+public fun IntArray.copyOf(): IntArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun LongArray.copyOf() : LongArray {
+public fun LongArray.copyOf(): LongArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun ShortArray.copyOf() : ShortArray {
+public fun ShortArray.copyOf(): ShortArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun <T> Array<out T>.copyOf(newSize: Int) : Array<T?> {
+public fun <T> Array<out T>.copyOf(newSize: Int): Array<T?> {
     return Arrays.copyOf(this, newSize) as Array<T?>
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun BooleanArray.copyOf(newSize: Int) : BooleanArray {
+public fun BooleanArray.copyOf(newSize: Int): BooleanArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun ByteArray.copyOf(newSize: Int) : ByteArray {
+public fun ByteArray.copyOf(newSize: Int): ByteArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun CharArray.copyOf(newSize: Int) : CharArray {
+public fun CharArray.copyOf(newSize: Int): CharArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun DoubleArray.copyOf(newSize: Int) : DoubleArray {
+public fun DoubleArray.copyOf(newSize: Int): DoubleArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun FloatArray.copyOf(newSize: Int) : FloatArray {
+public fun FloatArray.copyOf(newSize: Int): FloatArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun IntArray.copyOf(newSize: Int) : IntArray {
+public fun IntArray.copyOf(newSize: Int): IntArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun LongArray.copyOf(newSize: Int) : LongArray {
+public fun LongArray.copyOf(newSize: Int): LongArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun ShortArray.copyOf(newSize: Int) : ShortArray {
+public fun ShortArray.copyOf(newSize: Int): ShortArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun <T> Array<out T>.copyOfRange(from: Int, to: Int) : Array<T> {
+public fun <T> Array<out T>.copyOfRange(from: Int, to: Int): Array<T> {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun BooleanArray.copyOfRange(from: Int, to: Int) : BooleanArray {
+public fun BooleanArray.copyOfRange(from: Int, to: Int): BooleanArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun ByteArray.copyOfRange(from: Int, to: Int) : ByteArray {
+public fun ByteArray.copyOfRange(from: Int, to: Int): ByteArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun CharArray.copyOfRange(from: Int, to: Int) : CharArray {
+public fun CharArray.copyOfRange(from: Int, to: Int): CharArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun DoubleArray.copyOfRange(from: Int, to: Int) : DoubleArray {
+public fun DoubleArray.copyOfRange(from: Int, to: Int): DoubleArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun FloatArray.copyOfRange(from: Int, to: Int) : FloatArray {
+public fun FloatArray.copyOfRange(from: Int, to: Int): FloatArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun IntArray.copyOfRange(from: Int, to: Int) : IntArray {
+public fun IntArray.copyOfRange(from: Int, to: Int): IntArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun LongArray.copyOfRange(from: Int, to: Int) : LongArray {
+public fun LongArray.copyOfRange(from: Int, to: Int): LongArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun ShortArray.copyOfRange(from: Int, to: Int) : ShortArray {
+public fun ShortArray.copyOfRange(from: Int, to: Int): ShortArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun <T> Array<out T>.fill(element: T) : Array<out T> {
+public fun <T> Array<out T>.fill(element: T): Array<out T> {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun BooleanArray.fill(element: Boolean) : BooleanArray {
+public fun BooleanArray.fill(element: Boolean): BooleanArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun ByteArray.fill(element: Byte) : ByteArray {
+public fun ByteArray.fill(element: Byte): ByteArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun CharArray.fill(element: Char) : CharArray {
+public fun CharArray.fill(element: Char): CharArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun DoubleArray.fill(element: Double) : DoubleArray {
+public fun DoubleArray.fill(element: Double): DoubleArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun FloatArray.fill(element: Float) : FloatArray {
+public fun FloatArray.fill(element: Float): FloatArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun IntArray.fill(element: Int) : IntArray {
+public fun IntArray.fill(element: Int): IntArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun LongArray.fill(element: Long) : LongArray {
+public fun LongArray.fill(element: Long): LongArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun ShortArray.fill(element: Short) : ShortArray {
+public fun ShortArray.fill(element: Short): ShortArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Returns a list containing all elements that are instances of specified class
  */
-public fun <T, R: T> Array<out T>.filterIsInstance(klass: Class<R>) : List<R> {
+public fun <T, R : T> Array<out T>.filterIsInstance(klass: Class<R>): List<R> {
     return filterIsInstanceTo(ArrayList<R>(), klass)
-    
 }
 
 /**
  * Returns a list containing all elements that are instances of specified class
  */
-public fun <T, R: T> Iterable<T>.filterIsInstance(klass: Class<R>) : List<R> {
+public fun <T, R : T> Iterable<T>.filterIsInstance(klass: Class<R>): List<R> {
     return filterIsInstanceTo(ArrayList<R>(), klass)
-    
 }
 
 /**
  * Returns a stream containing all elements that are instances of specified class
  */
-public fun <T, R: T> Stream<T>.filterIsInstance(klass: Class<R>) : Stream<T> {
+public fun <T, R : T> Stream<T>.filterIsInstance(klass: Class<R>): Stream<T> {
     return FilteringStream(this, true, { klass.isInstance(it) })
-    
 }
 
 /**
  * Returns a list containing all elements that are instances of specified class
  */
-public fun <R: Char> String.filterIsInstance(klass: Class<R>) : List<R> {
+public fun <R : Char> String.filterIsInstance(klass: Class<R>): List<R> {
     return filterIsInstanceTo(ArrayList<R>(), klass)
-    
 }
 
 /**
  * Appends all elements that are instances of specified class into the given *collection*
  */
-public fun <T, C: MutableCollection<in R>, R: T> Array<out T>.filterIsInstanceTo(collection: C, klass: Class<R>) : C {
+public fun <T, C : MutableCollection<in R>, R : T> Array<out T>.filterIsInstanceTo(collection: C, klass: Class<R>): C {
     for (element in this) if (klass.isInstance(element)) collection.add(element as R)
     return collection
-    
 }
 
 /**
  * Appends all elements that are instances of specified class into the given *collection*
  */
-public fun <T, C: MutableCollection<in R>, R: T> Iterable<T>.filterIsInstanceTo(collection: C, klass: Class<R>) : C {
+public fun <T, C : MutableCollection<in R>, R : T> Iterable<T>.filterIsInstanceTo(collection: C, klass: Class<R>): C {
     for (element in this) if (klass.isInstance(element)) collection.add(element as R)
     return collection
-    
 }
 
 /**
  * Appends all elements that are instances of specified class into the given *collection*
  */
-public fun <T, C: MutableCollection<in R>, R: T> Stream<T>.filterIsInstanceTo(collection: C, klass: Class<R>) : C {
+public fun <T, C : MutableCollection<in R>, R : T> Stream<T>.filterIsInstanceTo(collection: C, klass: Class<R>): C {
     for (element in this) if (klass.isInstance(element)) collection.add(element as R)
     return collection
-    
 }
 
 /**
  * Appends all elements that are instances of specified class into the given *collection*
  */
-public fun <C: MutableCollection<in R>, R: Char> String.filterIsInstanceTo(collection: C, klass: Class<R>) : C {
+public fun <C : MutableCollection<in R>, R : Char> String.filterIsInstanceTo(collection: C, klass: Class<R>): C {
     for (element in this) if (klass.isInstance(element)) collection.add(element as R)
     return collection
-    
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun <T> Array<out T>.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun <T> Array<out T>.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun ByteArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun ByteArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun CharArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun CharArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun DoubleArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun DoubleArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun FloatArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun FloatArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun IntArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun IntArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun LongArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun LongArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun ShortArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun ShortArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 

libraries/stdlib/src/generated/_Streams.kt

@@ -10,96 +10,128 @@ import java.util.*
 /**
  * Returns a stream from the given collection
  */
-public fun <T> Array<out T>.stream() : Stream<T> {
+public fun <T> Array<out T>.stream(): Stream<T> {
-    return object : Stream<T> { override fun iterator() : Iterator<T> { return this@stream.iterator() } }
+    return object : Stream<T> {
-    
+        override fun iterator(): Iterator<T> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun BooleanArray.stream() : Stream<Boolean> {
+public fun BooleanArray.stream(): Stream<Boolean> {
-    return object : Stream<Boolean> { override fun iterator() : Iterator<Boolean> { return this@stream.iterator() } }
+    return object : Stream<Boolean> {
-    
+        override fun iterator(): Iterator<Boolean> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun ByteArray.stream() : Stream<Byte> {
+public fun ByteArray.stream(): Stream<Byte> {
-    return object : Stream<Byte> { override fun iterator() : Iterator<Byte> { return this@stream.iterator() } }
+    return object : Stream<Byte> {
-    
+        override fun iterator(): Iterator<Byte> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun CharArray.stream() : Stream<Char> {
+public fun CharArray.stream(): Stream<Char> {
-    return object : Stream<Char> { override fun iterator() : Iterator<Char> { return this@stream.iterator() } }
+    return object : Stream<Char> {
-    
+        override fun iterator(): Iterator<Char> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun DoubleArray.stream() : Stream<Double> {
+public fun DoubleArray.stream(): Stream<Double> {
-    return object : Stream<Double> { override fun iterator() : Iterator<Double> { return this@stream.iterator() } }
+    return object : Stream<Double> {
-    
+        override fun iterator(): Iterator<Double> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun FloatArray.stream() : Stream<Float> {
+public fun FloatArray.stream(): Stream<Float> {
-    return object : Stream<Float> { override fun iterator() : Iterator<Float> { return this@stream.iterator() } }
+    return object : Stream<Float> {
-    
+        override fun iterator(): Iterator<Float> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun IntArray.stream() : Stream<Int> {
+public fun IntArray.stream(): Stream<Int> {
-    return object : Stream<Int> { override fun iterator() : Iterator<Int> { return this@stream.iterator() } }
+    return object : Stream<Int> {
-    
+        override fun iterator(): Iterator<Int> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun LongArray.stream() : Stream<Long> {
+public fun LongArray.stream(): Stream<Long> {
-    return object : Stream<Long> { override fun iterator() : Iterator<Long> { return this@stream.iterator() } }
+    return object : Stream<Long> {
-    
+        override fun iterator(): Iterator<Long> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun ShortArray.stream() : Stream<Short> {
+public fun ShortArray.stream(): Stream<Short> {
-    return object : Stream<Short> { override fun iterator() : Iterator<Short> { return this@stream.iterator() } }
+    return object : Stream<Short> {
-    
+        override fun iterator(): Iterator<Short> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun <T> Iterable<T>.stream() : Stream<T> {
+public fun <T> Iterable<T>.stream(): Stream<T> {
-    return object : Stream<T> { override fun iterator() : Iterator<T> { return this@stream.iterator() } }
+    return object : Stream<T> {
-    
+        override fun iterator(): Iterator<T> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun <T> Stream<T>.stream() : Stream<T> {
+public fun <T> Stream<T>.stream(): Stream<T> {
     return this
-    
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun String.stream() : Stream<Char> {
+public fun String.stream(): Stream<Char> {
-    return object : Stream<Char> { override fun iterator() : Iterator<Char> { return this@stream.iterator() } }
+    return object : Stream<Char> {
-    
+        override fun iterator(): Iterator<Char> {
+            return this@stream.iterator()
+        }
+    }
 }
 

libraries/stdlib/src/generated/_Strings.kt

@@ -12,7 +12,7 @@ import java.util.*
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun <T> Array<out T>.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun <T> Array<out T>.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -24,7 +24,6 @@ public fun <T> Array<out T>.appendString(buffer: Appendable, separator: String =
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -32,7 +31,7 @@ public fun <T> Array<out T>.appendString(buffer: Appendable, separator: String =
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun BooleanArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun BooleanArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -44,7 +43,6 @@ public fun BooleanArray.appendString(buffer: Appendable, separator: String = ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -52,7 +50,7 @@ public fun BooleanArray.appendString(buffer: Appendable, separator: String = ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun ByteArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun ByteArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -64,7 +62,6 @@ public fun ByteArray.appendString(buffer: Appendable, separator: String = ", ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -72,7 +69,7 @@ public fun ByteArray.appendString(buffer: Appendable, separator: String = ", ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun CharArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun CharArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -84,7 +81,6 @@ public fun CharArray.appendString(buffer: Appendable, separator: String = ", ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -92,7 +88,7 @@ public fun CharArray.appendString(buffer: Appendable, separator: String = ", ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun DoubleArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun DoubleArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -104,7 +100,6 @@ public fun DoubleArray.appendString(buffer: Appendable, separator: String = ", "
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -112,7 +107,7 @@ public fun DoubleArray.appendString(buffer: Appendable, separator: String = ", "
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun FloatArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun FloatArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -124,7 +119,6 @@ public fun FloatArray.appendString(buffer: Appendable, separator: String = ", ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -132,7 +126,7 @@ public fun FloatArray.appendString(buffer: Appendable, separator: String = ", ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun IntArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun IntArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -144,7 +138,6 @@ public fun IntArray.appendString(buffer: Appendable, separator: String = ", ", p
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -152,7 +145,7 @@ public fun IntArray.appendString(buffer: Appendable, separator: String = ", ", p
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun LongArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun LongArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -164,7 +157,6 @@ public fun LongArray.appendString(buffer: Appendable, separator: String = ", ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -172,7 +164,7 @@ public fun LongArray.appendString(buffer: Appendable, separator: String = ", ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun ShortArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun ShortArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -184,7 +176,6 @@ public fun ShortArray.appendString(buffer: Appendable, separator: String = ", ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -192,7 +183,7 @@ public fun ShortArray.appendString(buffer: Appendable, separator: String = ", ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun <T> Iterable<T>.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun <T> Iterable<T>.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -204,7 +195,6 @@ public fun <T> Iterable<T>.appendString(buffer: Appendable, separator: String =
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -212,7 +202,7 @@ public fun <T> Iterable<T>.appendString(buffer: Appendable, separator: String =
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun <T> Stream<T>.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun <T> Stream<T>.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -224,7 +214,6 @@ public fun <T> Stream<T>.appendString(buffer: Appendable, separator: String = ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -232,7 +221,7 @@ public fun <T> Stream<T>.appendString(buffer: Appendable, separator: String = ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun String.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun String.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -244,7 +233,6 @@ public fun String.appendString(buffer: Appendable, separator: String = ", ", pre
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -252,11 +240,10 @@ public fun String.appendString(buffer: Appendable, separator: String = ", ", pre
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun <T> Array<out T>.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun <T> Array<out T>.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -264,11 +251,10 @@ public fun <T> Array<out T>.makeString(separator: String = ", ", prefix: String
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun BooleanArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun BooleanArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -276,11 +262,10 @@ public fun BooleanArray.makeString(separator: String = ", ", prefix: String = ""
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun ByteArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun ByteArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -288,11 +273,10 @@ public fun ByteArray.makeString(separator: String = ", ", prefix: String = "", p
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun CharArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun CharArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -300,11 +284,10 @@ public fun CharArray.makeString(separator: String = ", ", prefix: String = "", p
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun DoubleArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun DoubleArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -312,11 +295,10 @@ public fun DoubleArray.makeString(separator: String = ", ", prefix: String = "",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun FloatArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun FloatArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -324,11 +306,10 @@ public fun FloatArray.makeString(separator: String = ", ", prefix: String = "",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun IntArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun IntArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -336,11 +317,10 @@ public fun IntArray.makeString(separator: String = ", ", prefix: String = "", po
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun LongArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun LongArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -348,11 +328,10 @@ public fun LongArray.makeString(separator: String = ", ", prefix: String = "", p
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun ShortArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun ShortArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -360,11 +339,10 @@ public fun ShortArray.makeString(separator: String = ", ", prefix: String = "",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun <T> Iterable<T>.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun <T> Iterable<T>.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -372,11 +350,10 @@ public fun <T> Iterable<T>.makeString(separator: String = ", ", prefix: String =
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun <T> Stream<T>.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun <T> Stream<T>.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -384,10 +361,9 @@ public fun <T> Stream<T>.makeString(separator: String = ", ", prefix: String = "
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun String.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun String.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 

libraries/tools/kotlin-stdlib-gen/src/generators/GenerateCollections.kt

@@ -5,12 +5,12 @@ import templates.Family.*
 import templates.*
 import templates.PrimitiveType.*
 
-fun generateCollectionsAPI(outDir : File) {
+fun generateCollectionsAPI(outDir: File) {
     elements().writeTo(File(outDir, "_Elements.kt")) { build() }
     filtering().writeTo(File(outDir, "_Filtering.kt")) { build() }
     ordering().writeTo(File(outDir, "_Ordering.kt")) { build() }
     arrays().writeTo(File(outDir, "_Arrays.kt")) { build() }
-    snapshots().writeTo(File(outDir, "_Snapshots.kt"))  { build() }
+    snapshots().writeTo(File(outDir, "_Snapshots.kt")) { build() }
     mapping().writeTo(File(outDir, "_Mapping.kt")) { build() }
     aggregates().writeTo(File(outDir, "_Aggregates.kt")) { build() }
     guards().writeTo(File(outDir, "_Guards.kt")) { build() }
@@ -22,11 +22,11 @@ fun generateCollectionsAPI(outDir : File) {
     numeric().writeTo(File(outDir, "_Numeric.kt")) {
         val builder = StringBuilder()
         // TODO: decide if sum for byte and short is needed and how to make it work
-        for(numeric in listOf(Int, Long, /*Byte, Short, */ Double, Float)) {
+        for (numeric in listOf(Int, Long, /*Byte, Short, */ Double, Float)) {
             build(builder, Iterables, numeric)
         }
 
-        for(numeric in listOf(Int, Long, Byte, Short,  Double, Float)) {
+        for (numeric in listOf(Int, Long, Byte, Short, Double, Float)) {
             build(builder, ArraysOfObjects, numeric)
             build(builder, ArraysOfPrimitives, numeric)
         }

libraries/tools/kotlin-stdlib-gen/src/templates/Aggregates.kt

@@ -104,7 +104,7 @@ fun aggregates(): List<GenericFunction> {
         doc { "Returns the smallest element or null if there are no elements" }
         returns("T?")
         exclude(PrimitiveType.Boolean)
-        typeParam("T: Comparable<T>")
+        typeParam("T : Comparable<T>")
         body {
             """
             val iterator = iterator()
@@ -135,8 +135,8 @@ fun aggregates(): List<GenericFunction> {
         inline(true)
 
         doc { "Returns the first element yielding the smallest value of the given function or null if there are no elements" }
-        typeParam("R: Comparable<R>")
+        typeParam("R : Comparable<R>")
-        typeParam("T: Any")
+        typeParam("T : Any")
         returns("T?")
         body {
             """
@@ -149,8 +149,8 @@ fun aggregates(): List<GenericFunction> {
                 val e = iterator.next()
                 val v = f(e)
                 if (minValue > v) {
-                   minElem = e
+                    minElem = e
-                   minValue = v
+                    minValue = v
                 }
             }
             return minElem
@@ -166,8 +166,8 @@ fun aggregates(): List<GenericFunction> {
                 val e = this[i]
                 val v = f(e)
                 if (minValue > v) {
-                   minElem = e
+                    minElem = e
-                   minValue = v
+                    minValue = v
                 }
             }
             return minElem
@@ -180,7 +180,7 @@ fun aggregates(): List<GenericFunction> {
 
         only(Maps)
         doc { "Returns the first element yielding the smallest value of the given function or null if there are no elements" }
-        typeParam("R: Comparable<R>")
+        typeParam("R : Comparable<R>")
         returns("T?")
         body {
             """
@@ -193,8 +193,8 @@ fun aggregates(): List<GenericFunction> {
                 val e = iterator.next()
                 val v = f(e)
                 if (minValue > v) {
-                   minElem = e
+                    minElem = e
-                   minValue = v
+                    minValue = v
                 }
             }
             return minElem
@@ -206,7 +206,7 @@ fun aggregates(): List<GenericFunction> {
         doc { "Returns the largest element or null if there are no elements" }
         returns("T?")
         exclude(PrimitiveType.Boolean)
-        typeParam("T: Comparable<T>")
+        typeParam("T : Comparable<T>")
         body {
             """
             val iterator = iterator()
@@ -239,8 +239,8 @@ fun aggregates(): List<GenericFunction> {
         inline(true)
 
         doc { "Returns the first element yielding the largest value of the given function or null if there are no elements" }
-        typeParam("R: Comparable<R>")
+        typeParam("R : Comparable<R>")
-        typeParam("T: Any")
+        typeParam("T : Any")
         returns("T?")
         body {
             """
@@ -253,8 +253,8 @@ fun aggregates(): List<GenericFunction> {
                 val e = iterator.next()
                 val v = f(e)
                 if (maxValue < v) {
-                   maxElem = e
+                    maxElem = e
-                   maxValue = v
+                    maxValue = v
                 }
             }
             return maxElem
@@ -270,8 +270,8 @@ fun aggregates(): List<GenericFunction> {
                 val e = this[i]
                 val v = f(e)
                 if (maxValue < v) {
-                   maxElem = e
+                    maxElem = e
-                   maxValue = v
+                    maxValue = v
                 }
             }
             return maxElem
@@ -284,7 +284,7 @@ fun aggregates(): List<GenericFunction> {
 
         only(Maps)
         doc { "Returns the first element yielding the largest value of the given function or null if there are no elements" }
-        typeParam("R: Comparable<R>")
+        typeParam("R : Comparable<R>")
         returns("T?")
         body {
             """
@@ -297,8 +297,8 @@ fun aggregates(): List<GenericFunction> {
                 val e = iterator.next()
                 val v = f(e)
                 if (maxValue < v) {
-                   maxElem = e
+                    maxElem = e
-                   maxValue = v
+                    maxValue = v
                 }
             }
             return maxElem

libraries/tools/kotlin-stdlib-gen/src/templates/Elements.kt

@@ -116,7 +116,7 @@ fun elements(): List<GenericFunction> {
         }
     }
 
-    templates add f("elementAt(index : Int)") {
+    templates add f("elementAt(index: Int)") {
         doc { "Returns element at given *index*" }
         returns("T")
         body {
@@ -241,10 +241,12 @@ fun elements(): List<GenericFunction> {
         body {
             """
             when (this) {
-                is List<*> -> if (size == 0)
+                is List<*> -> {
+                    if (size == 0)
                         throw IllegalArgumentException("Collection is empty")
                     else
                         return this[size - 1] as T
+                }
                 else -> {
                     val iterator = iterator()
                     if (!iterator.hasNext())

libraries/tools/kotlin-stdlib-gen/src/templates/Engine.kt

@@ -91,7 +91,7 @@ class GenericFunction(val signature: String) : Comparable<GenericFunction> {
         typeParams.add(t)
     }
 
-    fun inline(value : Boolean, vararg families: Family) {
+    fun inline(value: Boolean, vararg families: Family) {
         if (families.isEmpty())
             defaultInline = value
         else
@@ -148,7 +148,7 @@ class GenericFunction(val signature: String) : Comparable<GenericFunction> {
             Iterables -> "Iterable<T>"
             Collections -> "Collection<T>"
             Lists -> "List<T>"
-            Maps -> "Map<K,V>"
+            Maps -> "Map<K, V>"
             Streams -> "Stream<T>"
             ArraysOfObjects -> "Array<T>"
             Strings -> "String"
@@ -186,7 +186,7 @@ class GenericFunction(val signature: String) : Comparable<GenericFunction> {
                                   "T" -> {
                                       when (f) {
                                           Strings -> "Char"
-                                          Maps -> "Map.Entry<K,V>"
+                                          Maps -> "Map.Entry<K, V>"
                                           else -> primitive?.name() ?: token
                                       }
                                   }
@@ -200,7 +200,7 @@ class GenericFunction(val signature: String) : Comparable<GenericFunction> {
         fun effectiveTypeParams(): List<String> {
             val types = ArrayList(typeParams)
             if (primitive == null && f != Strings) {
-                val implicitTypeParameters = receiver.dropWhile { it != '<' }.drop(1).takeWhile { it != '>' }.split(",")
+                val implicitTypeParameters = receiver.dropWhile { it != '<' }.drop(1).filterNot { it == ' ' }.takeWhile { it != '>' }.split(",")
                 for (implicit in implicitTypeParameters.reverse()) {
                     if (!types.any { it.startsWith(implicit) }) {
                         types.add(0, implicit)
@@ -249,18 +249,21 @@ class GenericFunction(val signature: String) : Comparable<GenericFunction> {
 
 
         builder.append(receiverType)
-        builder.append(".${signature.renderType()} : ${returnType.renderType()} {")
+        builder.append(".${signature.renderType()}: ${returnType.renderType()} {")
 
         val body = (bodies[f] ?: defaultBody).trim("\n")
-        val prefix: Int = body.takeWhile { it == ' ' }.length
+        val indent: Int = body.takeWhile { it == ' ' }.length
 
+        builder.append('\n')
         StringReader(body).forEachLine {
-            builder.append('\n')
+            var count = indent
-            var count = prefix
+            val line = it.dropWhile { count-- > 0 && it == ' ' } .renderType()
-            builder.append("    ").append(it.dropWhile { count-- > 0 && it == ' ' } .renderType())
+            if (line.isNotEmpty()) {
+                builder.append("    ").append(line)
+                builder.append("\n")
+            }
         }
-
+        builder.append("}\n\n")
-        builder.append("\n}\n\n")
     }
 
     public override fun compareTo(other: GenericFunction): Int = this.signature.compareTo(other.signature)

libraries/tools/kotlin-stdlib-gen/src/templates/Filtering.kt

@@ -29,7 +29,7 @@ fun filtering(): List<GenericFunction> {
         }
 
         body(Strings) { "return substring(Math.min(n, size))" }
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
 
         body(Collections, ArraysOfObjects, ArraysOfPrimitives) {
             """
@@ -63,7 +63,7 @@ fun filtering(): List<GenericFunction> {
         }
 
         body(Strings) { "return substring(0, Math.min(n, size))" }
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
 
         doc(Streams) { "Returns a stream containing first *n* elements" }
         returns(Streams) { "Stream<T>" }
@@ -90,7 +90,7 @@ fun filtering(): List<GenericFunction> {
         }
     }
 
-    templates add f("dropWhile(predicate: (T)->Boolean)") {
+    templates add f("dropWhile(predicate: (T) -> Boolean)") {
         inline(true)
 
         doc { "Returns a list containing all elements except first elements that satisfy the given *predicate*" }
@@ -102,7 +102,7 @@ fun filtering(): List<GenericFunction> {
             for (item in this)
                 if (yielding)
                     list.add(item)
-                else if(!predicate(item)) {
+                else if (!predicate(item)) {
                     list.add(item)
                     yielding = true
                 }
@@ -110,7 +110,7 @@ fun filtering(): List<GenericFunction> {
             """
         }
 
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
         body(Strings) {
             """
             for (index in 0..length)
@@ -128,20 +128,20 @@ fun filtering(): List<GenericFunction> {
             """
             var yielding = false
             return FilteringStream(this) {
-                        if (yielding)
+                if (yielding)
-                            true
+                    true
-                        else if (!predicate(it)) {
+                else if (!predicate(it)) {
-                            yielding = true
+                    yielding = true
-                            true
+                    true
-                        } else
+                } else
-                            false
+                    false
-                    }
+            }
             """
         }
 
     }
 
-    templates add f("takeWhile(predicate: (T)->Boolean)") {
+    templates add f("takeWhile(predicate: (T) -> Boolean)") {
         inline(true)
 
         doc { "Returns a list containing first elements satisfying the given *predicate*" }
@@ -150,15 +150,15 @@ fun filtering(): List<GenericFunction> {
             """
             val list = ArrayList<T>()
             for (item in this) {
-                 if(!predicate(item))
+                if (!predicate(item))
                     break;
-                 list.add(item)
+                list.add(item)
             }
             return list
             """
         }
 
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
         body(Strings) {
             """
             for (index in 0..length)
@@ -179,7 +179,7 @@ fun filtering(): List<GenericFunction> {
         }
     }
 
-    templates add f("filter(predicate: (T)->Boolean)") {
+    templates add f("filter(predicate: (T) -> Boolean)") {
         inline(true)
 
         doc { "Returns a list containing all elements matching the given *predicate*" }
@@ -190,7 +190,7 @@ fun filtering(): List<GenericFunction> {
             """
         }
 
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
         body(Strings) {
             """
             return filterTo(StringBuilder(), predicate).toString()
@@ -212,7 +212,7 @@ fun filtering(): List<GenericFunction> {
         inline(true)
 
         doc { "Appends all elements matching the given *predicate* into the given *collection*" }
-        typeParam("C: TCollection")
+        typeParam("C : TCollection")
         returns("C")
 
         body {
@@ -236,7 +236,7 @@ fun filtering(): List<GenericFunction> {
         include(Maps)
     }
 
-    templates add f("filterNot(predicate: (T)->Boolean)") {
+    templates add f("filterNot(predicate: (T) -> Boolean)") {
         inline(true)
 
         doc { "Returns a list containing all elements not matching the given *predicate*" }
@@ -247,7 +247,7 @@ fun filtering(): List<GenericFunction> {
             """
         }
 
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
         body(Strings) {
             """
             return filterNotTo(StringBuilder(), predicate).toString()
@@ -269,7 +269,7 @@ fun filtering(): List<GenericFunction> {
         inline(true)
 
         doc { "Appends all elements not matching the given *predicate* to the given *collection*" }
-        typeParam("C: TCollection")
+        typeParam("C : TCollection")
         returns("C")
 
         body {
@@ -292,7 +292,7 @@ fun filtering(): List<GenericFunction> {
     templates add f("filterNotNull()") {
         exclude(ArraysOfPrimitives, Strings)
         doc { "Returns a list containing all elements that are not null" }
-        typeParam("T: Any")
+        typeParam("T : Any")
         returns("List<T>")
         toNullableT = true
         body {
@@ -314,8 +314,8 @@ fun filtering(): List<GenericFunction> {
         exclude(ArraysOfPrimitives, Strings)
         doc { "Appends all elements that are not null to the given *collection*" }
         returns("C")
-        typeParam("C: TCollection")
+        typeParam("C : TCollection")
-        typeParam("T: Any")
+        typeParam("T : Any")
         toNullableT = true
         body {
             """

libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt

@@ -11,9 +11,9 @@ fun generators(): List<GenericFunction> {
         returns("List<T>")
         body {
             """
-                val answer = toArrayList()
+            val answer = toArrayList()
-                answer.add(element)
+            answer.add(element)
-                return answer
+            return answer
             """
         }
 
@@ -32,9 +32,9 @@ fun generators(): List<GenericFunction> {
         returns("List<T>")
         body {
             """
-                val answer = toArrayList()
+            val answer = toArrayList()
-                answer.addAll(collection)
+            answer.addAll(collection)
-                return answer
+            return answer
             """
         }
     }
@@ -45,9 +45,9 @@ fun generators(): List<GenericFunction> {
         returns("List<T>")
         body {
             """
-                val answer = toArrayList()
+            val answer = toArrayList()
-                answer.addAll(array)
+            answer.addAll(array)
-                return answer
+            return answer
             """
         }
     }
@@ -88,32 +88,32 @@ fun generators(): List<GenericFunction> {
         returns("Pair<List<T>, List<T>>")
         body {
             """
-                val first = ArrayList<T>()
+            val first = ArrayList<T>()
-                val second = ArrayList<T>()
+            val second = ArrayList<T>()
-                for (element in this) {
+            for (element in this) {
-                    if (predicate(element)) {
+                if (predicate(element)) {
-                        first.add(element)
+                    first.add(element)
-                    } else {
+                } else {
-                        second.add(element)
+                    second.add(element)
-                    }
                 }
-                return Pair(first, second)
+            }
+            return Pair(first, second)
             """
         }
 
         returns(Strings) { "Pair<String, String>" }
         body(Strings) {
             """
-                val first = StringBuilder()
+            val first = StringBuilder()
-                val second = StringBuilder()
+            val second = StringBuilder()
-                for (element in this) {
+            for (element in this) {
-                    if (predicate(element)) {
+                if (predicate(element)) {
-                        first.append(element)
+                    first.append(element)
-                    } else {
+                } else {
-                        second.append(element)
+                    second.append(element)
-                    }
                 }
-                return Pair(first.toString(), second.toString())
+            }
+            return Pair(first.toString(), second.toString())
             """
         }
     }
@@ -126,37 +126,37 @@ fun generators(): List<GenericFunction> {
             """
         }
         typeParam("R")
-        returns("List<Pair<T,R>>")
+        returns("List<Pair<T, R>>")
         body {
             """
-                val first = iterator()
+            val first = iterator()
-                val second = other.iterator()
+            val second = other.iterator()
-                val list = ArrayList<Pair<T,R>>()
+            val list = ArrayList<Pair<T, R>>()
-                while (first.hasNext() && second.hasNext()) {
+            while (first.hasNext() && second.hasNext()) {
-                    list.add(first.next() to second.next())
+                list.add(first.next() to second.next())
-                }
+            }
-                return list
+            return list
             """
         }
     }
 
-    templates add f("zip(other : String)") {
+    templates add f("zip(other: String)") {
         only(Strings)
         doc {
             """
             Returns a list of pairs built from characters of both strings with same indexes. List has length of shortest collection.
             """
         }
-        returns("List<Pair<Char,Char>>")
+        returns("List<Pair<Char, Char>>")
         body {
             """
-                val first = iterator()
+            val first = iterator()
-                val second = other.iterator()
+            val second = other.iterator()
-                val list = ArrayList<Pair<Char,Char>>()
+            val list = ArrayList<Pair<Char, Char>>()
-                while (first.hasNext() && second.hasNext()) {
+            while (first.hasNext() && second.hasNext()) {
-                    list.add(first.next() to second.next())
+                list.add(first.next() to second.next())
-                }
+            }
-                return list
+            return list
             """
         }
     }
@@ -169,16 +169,16 @@ fun generators(): List<GenericFunction> {
             """
         }
         typeParam("R")
-        returns("List<Pair<T,R>>")
+        returns("List<Pair<T, R>>")
         body {
             """
-                val first = iterator()
+            val first = iterator()
-                val second = array.iterator()
+            val second = array.iterator()
-                val list = ArrayList<Pair<T,R>>()
+            val list = ArrayList<Pair<T, R>>()
-                while (first.hasNext() && second.hasNext()) {
+            while (first.hasNext() && second.hasNext()) {
-                    list.add(first.next() to second.next())
+                list.add(first.next() to second.next())
-                }
+            }
-                return list
+            return list
             """
         }
     }
@@ -191,10 +191,10 @@ fun generators(): List<GenericFunction> {
             """
         }
         typeParam("R")
-        returns("Stream<Pair<T,R>>")
+        returns("Stream<Pair<T, R>>")
         body {
             """
-                return ZippingStream(this, stream)
+            return ZippingStream(this, stream)
             """
         }
     }

libraries/tools/kotlin-stdlib-gen/src/templates/Guards.kt

@@ -12,7 +12,7 @@ fun guards(): List<GenericFunction> {
         include(Lists)
         exclude(Strings, ArraysOfPrimitives)
         doc { "Returns an original collection containing all the non-*null* elements, throwing an [[IllegalArgumentException]] if there are any null elements" }
-        typeParam("T:Any")
+        typeParam("T : Any")
         toNullableT = true
         returns("SELF")
         body {

libraries/tools/kotlin-stdlib-gen/src/templates/Mapping.kt

@@ -25,7 +25,7 @@ fun mapping(): List<GenericFunction> {
         }
     }
 
-    templates add f("map(transform : (T) -> R)") {
+    templates add f("map(transform: (T) -> R)") {
         inline(true)
 
         doc { "Returns a list containing the results of applying the given *transform* function to each element of the original collection" }
@@ -39,16 +39,16 @@ fun mapping(): List<GenericFunction> {
         returns(Streams) { "Stream<R>" }
         doc(Streams) { "Returns a stream containing the results of applying the given *transform* function to each element of the original stream" }
         body(Streams) {
-            "return TransformingStream(this, transform) "
+            "return TransformingStream(this, transform)"
         }
         include(Maps)
     }
 
-    templates add f("mapNotNull(transform : (T) -> R)") {
+    templates add f("mapNotNull(transform: (T) -> R)") {
         inline(true)
         exclude(Strings, ArraysOfPrimitives)
         doc { "Returns a list containing the results of applying the given *transform* function to each non-null element of the original collection" }
-        typeParam("T: Any")
+        typeParam("T : Any")
         typeParam("R")
         returns("List<R>")
         toNullableT = true
@@ -68,7 +68,7 @@ fun mapping(): List<GenericFunction> {
         }
     }
 
-    templates add f("mapTo(collection: C, transform : (T) -> R)") {
+    templates add f("mapTo(collection: C, transform: (T) -> R)") {
         inline(true)
 
         doc {
@@ -78,7 +78,7 @@ fun mapping(): List<GenericFunction> {
             """
         }
         typeParam("R")
-        typeParam("C: MutableCollection<in R>")
+        typeParam("C : MutableCollection<in R>")
         returns("C")
 
         body {
@@ -91,7 +91,7 @@ fun mapping(): List<GenericFunction> {
         include(Maps)
     }
 
-    templates add f("mapNotNullTo(collection: C, transform : (T) -> R)") {
+    templates add f("mapNotNullTo(collection: C, transform: (T) -> R)") {
         inline(true)
         exclude(Strings, ArraysOfPrimitives)
         doc {
@@ -100,9 +100,9 @@ fun mapping(): List<GenericFunction> {
             to the given *collection*
             """
         }
-        typeParam("T: Any")
+        typeParam("T : Any")
         typeParam("R")
-        typeParam("C: MutableCollection<in R>")
+        typeParam("C : MutableCollection<in R>")
         returns("C")
         toNullableT = true
         body {
@@ -110,14 +110,14 @@ fun mapping(): List<GenericFunction> {
             for (element in this) {
                 if (element != null) {
                     collection.add(transform(element))
-                 }
+                }
             }
             return collection
             """
         }
     }
 
-    templates add f("flatMap(transform: (T)-> Iterable<R>)") {
+    templates add f("flatMap(transform: (T) -> Iterable<R>)") {
         inline(true)
 
         exclude(Streams)
@@ -130,7 +130,7 @@ fun mapping(): List<GenericFunction> {
         include(Maps)
     }
 
-    templates add f("flatMap(transform: (T)-> Stream<R>)") {
+    templates add f("flatMap(transform: (T) -> Stream<R>)") {
         only(Streams)
         doc { "Returns a single stream of all elements streamed from results of *transform* function being invoked on each element of original stream" }
         typeParam("R")
@@ -145,7 +145,7 @@ fun mapping(): List<GenericFunction> {
         exclude(Streams)
         doc { "Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*" }
         typeParam("R")
-        typeParam("C: MutableCollection<in R>")
+        typeParam("C : MutableCollection<in R>")
         returns("C")
         body {
             """
@@ -165,7 +165,7 @@ fun mapping(): List<GenericFunction> {
         only(Streams)
         doc { "Appends all elements yielded from results of *transform* function being invoked on each element of original stream, to the given *collection*" }
         typeParam("R")
-        typeParam("C: MutableCollection<in R>")
+        typeParam("C : MutableCollection<in R>")
         returns("C")
         body {
             """

libraries/tools/kotlin-stdlib-gen/src/templates/Numeric.kt

@@ -10,12 +10,12 @@ fun numeric(): List<GenericFunction> {
         returns("SUM")
         body {
             """
-                val iterator = iterator()
+            val iterator = iterator()
-                var sum : SUM = ZERO
+            var sum: SUM = ZERO
-                while (iterator.hasNext()) {
+            while (iterator.hasNext()) {
-                    sum += iterator.next()
+                sum += iterator.next()
-                }
+            }
-                return sum
+            return sum
             """
         }
     }

libraries/tools/kotlin-stdlib-gen/src/templates/Ordering.kt

@@ -17,7 +17,7 @@ fun ordering(): List<GenericFunction> {
         }
 
         doc(Strings) { "Returns a string with characters in reversed order" }
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
         body(Strings) {
             // TODO: Replace with StringBuilder(this) when JS can handle it
             """
@@ -35,7 +35,7 @@ fun ordering(): List<GenericFunction> {
             """
         }
         returns("List<T>")
-        typeParam("T: Comparable<T>")
+        typeParam("T : Comparable<T>")
         body {
             """
             val sortedList = toArrayList()
@@ -57,11 +57,11 @@ fun ordering(): List<GenericFunction> {
             """
         }
         returns("List<T>")
-        typeParam("T: Comparable<T>")
+        typeParam("T : Comparable<T>")
         body {
             """
             val sortedList = toArrayList()
-            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -x.compareTo(y)}
+            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -x.compareTo(y) }
             java.util.Collections.sort(sortedList, sortBy)
             return sortedList
             """
@@ -82,11 +82,11 @@ fun ordering(): List<GenericFunction> {
             """
         }
         returns("List<T>")
-        typeParam("R: Comparable<R>")
+        typeParam("R : Comparable<R>")
         body {
             """
             val sortedList = toArrayList()
-            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y))}
+            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y)) }
             java.util.Collections.sort(sortedList, sortBy)
             return sortedList
             """
@@ -106,11 +106,11 @@ fun ordering(): List<GenericFunction> {
             """
         }
         returns("List<T>")
-        typeParam("R: Comparable<R>")
+        typeParam("R : Comparable<R>")
         body {
             """
             val sortedList = toArrayList()
-            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -order(x).compareTo(order(y))}
+            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -order(x).compareTo(order(y)) }
             java.util.Collections.sort(sortedList, sortBy)
             return sortedList
             """
@@ -121,7 +121,7 @@ fun ordering(): List<GenericFunction> {
         exclude(Strings)
     }
 
-    templates add f("sortBy(comparator : Comparator<T>)") {
+    templates add f("sortBy(comparator: Comparator<T>)") {
         doc {
             """
             Returns a list of all elements, sorted by the specified *comparator*

libraries/tools/kotlin-stdlib-gen/src/templates/Snapshots.kt

@@ -5,7 +5,7 @@ import templates.Family.*
 fun snapshots(): List<GenericFunction> {
     val templates = arrayListOf<GenericFunction>()
 
-    templates add f("toCollection(collection : C)") {
+    templates add f("toCollection(collection: C)") {
         doc { "Appends all elements to the given *collection*" }
         returns("C")
         typeParam("C : MutableCollection<in T>")
@@ -94,7 +94,7 @@ fun snapshots(): List<GenericFunction> {
 
     templates add f("toSortedList()") {
         doc { "Returns a sorted list of all elements" }
-        typeParam("T: Comparable<T>")
+        typeParam("T : Comparable<T>")
         returns("List<T>")
         body { "return toArrayList().sort()" }
         body(Iterables) { "return sort()" }

libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt

@@ -63,7 +63,7 @@ fun specialJVM(): List<GenericFunction> {
         }
     }
 
-    templates add f("sort(fromIndex : Int = 0, toIndex : Int = size - 1)") {
+    templates add f("sort(fromIndex: Int = 0, toIndex: Int = size - 1)") {
         only(ArraysOfObjects, ArraysOfPrimitives)
         exclude(PrimitiveType.Boolean)
         doc { "Sorts array or range in array inplace" }
@@ -75,8 +75,8 @@ fun specialJVM(): List<GenericFunction> {
 
     templates add f("filterIsInstanceTo(collection: C, klass: Class<R>)") {
         doc { "Appends all elements that are instances of specified class into the given *collection*" }
-        typeParam("C: MutableCollection<in R>")
+        typeParam("C : MutableCollection<in R>")
-        typeParam("R: T")
+        typeParam("R : T")
         returns("C")
         exclude(ArraysOfPrimitives)
         body {
@@ -89,7 +89,7 @@ fun specialJVM(): List<GenericFunction> {
 
     templates add f("filterIsInstance(klass: Class<R>)") {
         doc { "Returns a list containing all elements that are instances of specified class" }
-        typeParam("R: T")
+        typeParam("R : T")
         returns("List<R>")
         body {
             """

libraries/tools/kotlin-stdlib-gen/src/templates/Stream.kt

@@ -10,7 +10,11 @@ fun streams(): List<GenericFunction> {
         returns("Stream<T>")
         body {
             """
-            return object : Stream<T> { override fun iterator() : Iterator<T> { return this@stream.iterator() } }
+            return object : Stream<T> {
+                override fun iterator(): Iterator<T> {
+                    return this@stream.iterator()
+                }
+            }
             """
         }
 

libraries/tools/kotlin-stdlib-gen/src/templates/Strings.kt

@@ -5,7 +5,7 @@ import templates.Family.*
 fun strings(): List<GenericFunction> {
     val templates = arrayListOf<GenericFunction>()
 
-    templates add f("appendString(buffer: Appendable, separator: String = \", \", prefix: String =\"\", postfix: String = \"\", limit: Int = -1, truncated: String = \"...\")") {
+    templates add f("appendString(buffer: Appendable, separator: String = \", \", prefix: String = \"\", postfix: String = \"\", limit: Int = -1, truncated: String = \"...\")") {
         doc {
             """
             Appends the string from all the elements separated using the *separator* and using the given *prefix* and *postfix* if supplied