diff --git a/js/js.libraries/src/core/javautil.kt b/js/js.libraries/src/core/javautil.kt
index ec7a32b9314..bc01dda3cca 100644
--- a/js/js.libraries/src/core/javautil.kt
+++ b/js/js.libraries/src/core/javautil.kt
@@ -8,7 +8,7 @@ private val DEFAULT_LOAD_FACTOR = 0.75f
 
 library
 public trait Comparator<T> {
-    fun compare(obj1: T, obj2: T): Int;
+    public fun compare(obj1: T, obj2: T): Int;
 }
 
 library
diff --git a/js/js.libraries/src/core/kotlin.kt b/js/js.libraries/src/core/kotlin.kt
index e4178931e46..9f74e504776 100644
--- a/js/js.libraries/src/core/kotlin.kt
+++ b/js/js.libraries/src/core/kotlin.kt
@@ -2,9 +2,6 @@ package kotlin
 
 import java.util.*
 
-library("comparator")
-public fun comparator<T>(f : (T, T) -> Int): Comparator<T> = noImpl
-
 library
 public fun <T> array(vararg value : T): Array<T> = noImpl
 
diff --git a/js/js.translator/testData/kotlin_lib.js b/js/js.translator/testData/kotlin_lib.js
index 9c63dbfdc22..4fb5bcc2d51 100644
--- a/js/js.translator/testData/kotlin_lib.js
+++ b/js/js.translator/testData/kotlin_lib.js
@@ -831,29 +831,6 @@
         compare: throwAbstractFunctionInvocationError("Comparator#compare")
     });
 
-    /**
-     * @class
-     * @implements {Kotlin.Comparator.<T>}
-     *
-     * @constructor
-     * @param {function(T,T): Boolean} comparator
-     * @template T
-     */
-    var ComparatorImpl = Kotlin.createClassNow(Kotlin.Comparator,
-        function (comparator) {
-            this.compare = comparator;
-        }
-    );
-
-    /**
-     * @param {function(T,T): Boolean} f
-     * @returns {Kotlin.Comparator.<T>}
-     * @template T
-     */
-    Kotlin.comparator = function (f) {
-        return new ComparatorImpl(f);
-    };
-
     Kotlin.collectionsMax = function (c, comp) {
         if (c.isEmpty()) {
             //TODO: which exception?
diff --git a/libraries/stdlib/src/generated/_Ordering.kt b/libraries/stdlib/src/generated/_Ordering.kt
index 5137f2d602a..a519de2ce81 100644
--- a/libraries/stdlib/src/generated/_Ordering.kt
+++ b/libraries/stdlib/src/generated/_Ordering.kt
@@ -136,7 +136,7 @@ public fun <T> Iterable<T>.sortBy(comparator: Comparator<in T>): List<T> {
  */
 public inline fun <T, R : Comparable<R>> Array<out T>.sortBy(inlineOptions(InlineOption.ONLY_LOCAL_RETURN) 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> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -146,7 +146,7 @@ public inline fun <T, R : Comparable<R>> Array<out T>.sortBy(inlineOptions(Inlin
  */
 public inline fun <T, R : Comparable<R>> Iterable<T>.sortBy(inlineOptions(InlineOption.ONLY_LOCAL_RETURN) 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> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -156,8 +156,7 @@ public inline fun <T, R : Comparable<R>> Iterable<T>.sortBy(inlineOptions(Inline
  */
 public fun <T : Comparable<T>> Iterable<T>.sortDescending(): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> y.compareTo(x) }
-    java.util.Collections.sort(sortedList, sortBy)
+    java.util.Collections.sort(sortedList, comparator { x, y -> y.compareTo(x) })
     return sortedList
 }
 
@@ -166,7 +165,7 @@ public fun <T : Comparable<T>> Iterable<T>.sortDescending(): List<T> {
  */
 public inline fun <T, R : Comparable<R>> Array<out T>.sortDescendingBy(inlineOptions(InlineOption.ONLY_LOCAL_RETURN) order: (T) -> R): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(y).compareTo(order(x)) }
+    val sortBy: Comparator<T> = compareByDescending(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -176,7 +175,7 @@ public inline fun <T, R : Comparable<R>> Array<out T>.sortDescendingBy(inlineOpt
  */
 public inline fun <T, R : Comparable<R>> Iterable<T>.sortDescendingBy(inlineOptions(InlineOption.ONLY_LOCAL_RETURN) order: (T) -> R): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(y).compareTo(order(x)) }
+    val sortBy: Comparator<T> = compareByDescending(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -285,7 +284,7 @@ public fun <T : Comparable<T>> Stream<T>.toSortedList(): List<T> {
  */
 public fun <T, V : Comparable<V>> Array<out T>.toSortedListBy(order: (T) -> V): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y)) }
+    val sortBy: Comparator<T> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -295,7 +294,7 @@ public fun <T, V : Comparable<V>> Array<out T>.toSortedListBy(order: (T) -> V):
  */
 public fun <V : Comparable<V>> BooleanArray.toSortedListBy(order: (Boolean) -> V): List<Boolean> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<Boolean> = comparator<Boolean> {(x: Boolean, y: Boolean) -> order(x).compareTo(order(y)) }
+    val sortBy: Comparator<Boolean> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -305,7 +304,7 @@ public fun <V : Comparable<V>> BooleanArray.toSortedListBy(order: (Boolean) -> V
  */
 public fun <V : Comparable<V>> ByteArray.toSortedListBy(order: (Byte) -> V): List<Byte> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<Byte> = comparator<Byte> {(x: Byte, y: Byte) -> order(x).compareTo(order(y)) }
+    val sortBy: Comparator<Byte> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -315,7 +314,7 @@ public fun <V : Comparable<V>> ByteArray.toSortedListBy(order: (Byte) -> V): Lis
  */
 public fun <V : Comparable<V>> CharArray.toSortedListBy(order: (Char) -> V): List<Char> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<Char> = comparator<Char> {(x: Char, y: Char) -> order(x).compareTo(order(y)) }
+    val sortBy: Comparator<Char> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -325,7 +324,7 @@ public fun <V : Comparable<V>> CharArray.toSortedListBy(order: (Char) -> V): Lis
  */
 public fun <V : Comparable<V>> DoubleArray.toSortedListBy(order: (Double) -> V): List<Double> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<Double> = comparator<Double> {(x: Double, y: Double) -> order(x).compareTo(order(y)) }
+    val sortBy: Comparator<Double> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -335,7 +334,7 @@ public fun <V : Comparable<V>> DoubleArray.toSortedListBy(order: (Double) -> V):
  */
 public fun <V : Comparable<V>> FloatArray.toSortedListBy(order: (Float) -> V): List<Float> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<Float> = comparator<Float> {(x: Float, y: Float) -> order(x).compareTo(order(y)) }
+    val sortBy: Comparator<Float> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -345,7 +344,7 @@ public fun <V : Comparable<V>> FloatArray.toSortedListBy(order: (Float) -> V): L
  */
 public fun <V : Comparable<V>> IntArray.toSortedListBy(order: (Int) -> V): List<Int> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<Int> = comparator<Int> {(x: Int, y: Int) -> order(x).compareTo(order(y)) }
+    val sortBy: Comparator<Int> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -355,7 +354,7 @@ public fun <V : Comparable<V>> IntArray.toSortedListBy(order: (Int) -> V): List<
  */
 public fun <V : Comparable<V>> LongArray.toSortedListBy(order: (Long) -> V): List<Long> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<Long> = comparator<Long> {(x: Long, y: Long) -> order(x).compareTo(order(y)) }
+    val sortBy: Comparator<Long> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -365,7 +364,7 @@ public fun <V : Comparable<V>> LongArray.toSortedListBy(order: (Long) -> V): Lis
  */
 public fun <V : Comparable<V>> ShortArray.toSortedListBy(order: (Short) -> V): List<Short> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<Short> = comparator<Short> {(x: Short, y: Short) -> order(x).compareTo(order(y)) }
+    val sortBy: Comparator<Short> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -375,7 +374,7 @@ public fun <V : Comparable<V>> ShortArray.toSortedListBy(order: (Short) -> V): L
  */
 public fun <T, V : Comparable<V>> Iterable<T>.toSortedListBy(order: (T) -> V): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y)) }
+    val sortBy: Comparator<T> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
@@ -385,7 +384,7 @@ public fun <T, V : Comparable<V>> Iterable<T>.toSortedListBy(order: (T) -> V): L
  */
 public fun <T, V : Comparable<V>> Stream<T>.toSortedListBy(order: (T) -> V): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y)) }
+    val sortBy: Comparator<T> = compareBy(order)
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
 }
diff --git a/libraries/stdlib/src/kotlin/Deprecated.kt b/libraries/stdlib/src/kotlin/Deprecated.kt
index e3018d3766a..447b4dd0483 100644
--- a/libraries/stdlib/src/kotlin/Deprecated.kt
+++ b/libraries/stdlib/src/kotlin/Deprecated.kt
@@ -50,7 +50,6 @@ public fun <T> Iterable<T>.containsItem(item : T) : Boolean = contains(item)
 deprecated("Use sortBy() instead")
 public fun <T> Iterable<T>.sort(comparator: java.util.Comparator<T>) : List<T> = sortBy(comparator)
 
-
 deprecated("Use size() instead")
 public val Array<*>.size: Int get() = size()
 
@@ -77,3 +76,6 @@ public val DoubleArray.size: Int get() = size()
 
 deprecated("Use size() instead")
 public val BooleanArray.size: Int get() = size()
+
+deprecated("Use compareValuesBy() instead")
+public fun <T : Any> compareBy(a: T?, b: T?, vararg functions: (T) -> Comparable<*>?): Int = compareValuesBy(a, b, *functions)
diff --git a/libraries/stdlib/src/kotlin/Ordering.kt b/libraries/stdlib/src/kotlin/Ordering.kt
index c380f18f1c0..d6265a5657f 100644
--- a/libraries/stdlib/src/kotlin/Ordering.kt
+++ b/libraries/stdlib/src/kotlin/Ordering.kt
@@ -16,18 +16,19 @@
 
 package kotlin
 
+import java.util.Comparator
+
 /**
- * Helper method for implementing [[Comparable]] methods using a list of functions
- * to calculate the values to compare
+ * Compares two values using the sequence of functions to calculate a result of comparison.
  */
-public fun <T : Any> compareBy(a: T?, b: T?, vararg functions: T.() -> Comparable<*>?): Int {
+public fun <T : Any> compareValuesBy(a: T?, b: T?, vararg functions: (T) -> Comparable<*>?): Int {
     require(functions.size > 0)
     if (a identityEquals b) return 0
-    if (a == null) return - 1
+    if (a == null) return -1
     if (b == null) return 1
     for (fn in functions) {
-        val v1 = a.fn()
-        val v2 = b.fn()
+        val v1 = fn(a)
+        val v2 = fn(b)
         val diff = compareValues(v1, v2)
         if (diff != 0) return diff
     }
@@ -35,14 +36,92 @@ public fun <T : Any> compareBy(a: T?, b: T?, vararg functions: T.() -> Comparabl
 }
 
 /**
- * Compares the two values which may be [[Comparable]] otherwise
- * they are compared via [[#equals()]] and if they are not the same then
- * the [[#hashCode()]] method is used as the difference
+ * Compares two [Comparable] nullable values, null is considered less than any value.
  */
 public fun <T : Comparable<*>> compareValues(a: T?, b: T?): Int {
     if (a identityEquals b) return 0
-    if (a == null) return - 1
+    if (a == null) return -1
     if (b == null) return 1
 
     return (a as Comparable<Any?>).compareTo(b)
 }
+
+/**
+ * Creates a comparator using the sequence of functions to calculate a result of comparison.
+ */
+public fun <T> compareBy(vararg functions: (T) -> Comparable<*>?): Comparator<T> {
+    return object : Comparator<T> {
+        public override fun compare(a: T, b: T): Int = compareValuesBy(a, b, *functions)
+    }
+}
+
+/**
+ * Creates a comparator using the sequence of functions to calculate a result of comparison.
+ */
+deprecated("Use compareBy() instead")
+public fun <T> comparator(vararg functions: (T) -> Comparable<*>?): Comparator<T> = compareBy(*functions)
+
+/**
+ * Creates a comparator using the function to transform value to a [Comparable] instance for comparison
+ */
+inline public fun <T> compareBy(inlineOptions(InlineOption.ONLY_LOCAL_RETURN) comparable: (T) -> Comparable<*>): Comparator<T> {
+    return object : Comparator<T> {
+        public override fun compare(a: T, b: T): Int = compareValues(comparable(a), comparable(b))
+    }
+}
+
+/**
+ * Creates a descending comparator using the function to transform value to a [Comparable] instance for comparison
+ */
+inline public fun <T> compareByDescending(inlineOptions(InlineOption.ONLY_LOCAL_RETURN) comparable: (T) -> Comparable<*>): Comparator<T> {
+    return object : Comparator<T> {
+        public override fun compare(a: T, b: T): Int = compareValues(comparable(b), comparable(a))
+    }
+}
+
+/**
+ * Creates a comparator using the primary comparator and
+ * the function to transform value to a [Comparable] instance for comparison
+ */
+inline public fun <T> Comparator<T>.thenBy(inlineOptions(InlineOption.ONLY_LOCAL_RETURN) comparable: (T) -> Comparable<*>): Comparator<T> {
+    return object : Comparator<T> {
+        public override fun compare(a: T, b: T): Int {
+            val previousCompare = this@thenBy.compare(a, b)
+            return if (previousCompare != 0) previousCompare else compareValues(comparable(a), comparable(b))
+        }
+    }
+}
+
+/**
+ * Creates a descending comparator using the primary comparator and
+ * the function to transform value to a [Comparable] instance for comparison
+ */
+inline public fun <T> Comparator<T>.thenByDescending(inlineOptions(InlineOption.ONLY_LOCAL_RETURN) comparable: (T) -> Comparable<*>): Comparator<T> {
+    return object : Comparator<T> {
+        public override fun compare(a: T, b: T): Int {
+            val previousCompare = this@thenByDescending.compare(a, b)
+            return if (previousCompare != 0) previousCompare else compareValues(comparable(b), comparable(a))
+        }
+    }
+}
+
+/**
+ * Creates a comparator using the function to calculate a result of comparison.
+ */
+inline public fun <T> comparator(inlineOptions(InlineOption.ONLY_LOCAL_RETURN) comparison: (T, T) -> Int): Comparator<T> {
+    return object : Comparator<T> {
+        public override fun compare(a: T, b: T): Int = comparison(a, b)
+    }
+}
+
+/**
+ * Creates a comparator using the primary comparator and function to calculate a result of comparison.
+ */
+inline public fun <T> Comparator<T>.thenComparator(inlineOptions(InlineOption.ONLY_LOCAL_RETURN) comparison: (T, T) -> Int): Comparator<T> {
+    return object : Comparator<T> {
+        public override fun compare(a: T, b: T): Int {
+            val previousCompare = this@thenComparator.compare(a, b)
+            return if (previousCompare != 0) previousCompare else comparison(a, b)
+        }
+    }
+}
\ No newline at end of file
diff --git a/libraries/stdlib/src/kotlin/OrderingJVM.kt b/libraries/stdlib/src/kotlin/OrderingJVM.kt
deleted file mode 100644
index 880e9b3673a..00000000000
--- a/libraries/stdlib/src/kotlin/OrderingJVM.kt
+++ /dev/null
@@ -1,51 +0,0 @@
-package kotlin
-
-import java.util.Comparator
-
-/**
- * Creates a comparator using the sequence of functions used to calculate a value to compare on
- */
-public fun <T> comparator(vararg functions: T.() -> Comparable<*>?): Comparator<T> {
-    return FunctionComparator<T>(*functions)
-}
-
-
-private class FunctionComparator<T>(private vararg val functions: T.() -> Comparable<*>?) : Comparator<T> {
-
-    public override fun toString(): String {
-        return "FunctionComparator${functions.toList()}"
-    }
-
-    public override fun compare(o1: T, o2: T): Int {
-        return compareBy<T>(o1, o2, *functions)
-    }
-
-    public override fun equals(obj: Any?): Boolean {
-        return this == obj
-    }
-}
-
-/**
- * Creates a comparator using the sequence of functions used to calculate a value to compare on
- */
-public fun <T> comparator(fn: (T,T) -> Int): Comparator<T> {
-    return Function2Comparator<T>(fn)
-}
-
-private class Function2Comparator<T>(private val compareFn: (T, T) -> Int) : Comparator<T> {
-
-    public override fun toString(): String {
-        return "Function2Comparator${compareFn}"
-    }
-
-    public override fun compare(a: T, b: T): Int {
-        if (a === b) return 0
-        if (a == null) return -1
-        if (b == null) return 1
-        return (compareFn)(a, b)
-    }
-
-    public override fun equals(obj: Any?): Boolean {
-        return this == obj
-    }
-}
diff --git a/libraries/stdlib/test/CompareJVMTest.kt b/libraries/stdlib/test/CompareJVMTest.kt
deleted file mode 100644
index 057f990c6b4..00000000000
--- a/libraries/stdlib/test/CompareJVMTest.kt
+++ /dev/null
@@ -1,40 +0,0 @@
-package test.compare
-
-import java.util.Comparator
-import kotlin.test.*
-import org.junit.Test
-
-class CompareJVMTest {
-    val v1 = Item("wine", 9)
-    val v2 = Item("beer", 10)
-
-    Test fun sortUsingComparatorHelperMethod() {
-        val c = comparator<Item>({ rating }, { name })
-        println("Created comparator $c")
-
-        val diff = c.compare(v1, v2)
-        assertTrue(diff < 0)
-        val items = arrayListOf(v1, v2)
-        items.sortBy(c)
-        println("Sorted list in rating order $items")
-    }
-
-    Test fun sortUsingCustomComparator() {
-        val c = object : Comparator<Item>{
-            override fun compare(o1: Item, o2: Item): Int {
-                return compareBy(o1, o2, { name }, { rating })
-            }
-            override fun equals(obj: Any?): Boolean {
-                return this == obj
-            }
-        }
-        println("Created comparator $c")
-
-        val diff = c.compare(v1, v2)
-        assertTrue(diff > 0)
-        val items = arrayListOf(v1, v2)
-        items.sortBy(c)
-        println("Sorted list in rating order $items")
-    }
-
-}
diff --git a/libraries/stdlib/test/CompareTest.kt b/libraries/stdlib/test/CompareTest.kt
deleted file mode 100644
index e517f869d61..00000000000
--- a/libraries/stdlib/test/CompareTest.kt
+++ /dev/null
@@ -1,37 +0,0 @@
-package test.compare
-
-import kotlin.test.*
-import org.junit.Test
-
-class Item(val name: String, val rating: Int): Comparable<Item> {
-    override fun toString() = "Item($name, $rating)"
-
-    public override fun compareTo(other: Item): Int {
-        return compareBy(this, other, { rating }, { name })
-    }
-}
-
-class CompareTest {
-    val v1 = Item("wine", 9)
-    val v2 = Item("beer", 10)
-
-    Test fun compareByCompareTo() {
-        val diff = v1.compareTo(v2)
-        assertTrue(diff < 0)
-    }
-
-    Test fun compareByNameFirst() {
-        val diff = compareBy(v1, v2, { name }, { rating })
-        assertTrue(diff > 0)
-    }
-
-    Test fun compareByRatingFirst() {
-        val diff = compareBy(v1, v2, { rating }, { name })
-        assertTrue(diff < 0)
-    }
-
-    Test fun compareSameObjectsByRatingFirst() {
-        val diff = compareBy(v1, v1, { rating }, { name })
-        assertTrue(diff == 0)
-    }
-}
diff --git a/libraries/stdlib/test/OrderingTest.kt b/libraries/stdlib/test/OrderingTest.kt
new file mode 100644
index 00000000000..4cf465f28ad
--- /dev/null
+++ b/libraries/stdlib/test/OrderingTest.kt
@@ -0,0 +1,93 @@
+package test.compare
+
+import java.util.*
+import kotlin.test.*
+import org.junit.Test
+
+data class Item(val name: String, val rating: Int) : Comparable<Item> {
+    public override fun compareTo(other: Item): Int {
+        return compareValuesBy(this, other, { it.rating }, { it.name })
+    }
+}
+
+class OrderingTest {
+    val v1 = Item("wine", 9)
+    val v2 = Item("beer", 10)
+
+    Test fun compareByCompareTo() {
+        val diff = v1.compareTo(v2)
+        assertTrue(diff < 0)
+    }
+
+    Test fun compareByNameFirst() {
+        val diff = compareValuesBy(v1, v2, { it.name }, { it.rating })
+        assertTrue(diff > 0)
+    }
+
+    Test fun compareByRatingFirst() {
+        val diff = compareValuesBy(v1, v2, { it.rating }, { it.name })
+        assertTrue(diff < 0)
+    }
+
+    Test fun compareSameObjectsByRatingFirst() {
+        val diff = compareValuesBy(v1, v1, { it.rating }, { it.name })
+        assertTrue(diff == 0)
+    }
+
+    Test fun sortComparatorThenComparator() {
+        val comparator = comparator<Item> {(a, b) -> a.name.compareTo(b.name) } thenComparator {(a, b) -> a.rating.compareTo(b.rating) }
+
+        val diff = comparator.compare(v1, v2)
+        assertTrue(diff > 0)
+        val items = arrayListOf(v1, v2).sortBy(comparator)
+        assertEquals(v2, items[0])
+        assertEquals(v1, items[1])
+    }
+
+    Test fun sortByThenBy() {
+        val comparator = compareBy<Item> { it.rating } thenBy { it.name }
+
+        val diff = comparator.compare(v1, v2)
+        assertTrue(diff < 0)
+        val items = arrayListOf(v1, v2).sortBy(comparator)
+        assertEquals(v1, items[0])
+        assertEquals(v2, items[1])
+    }
+
+    Test fun sortByThenByDescending() {
+        val comparator = compareBy<Item> { it.rating } thenByDescending { it.name }
+
+        val diff = comparator.compare(v1, v2)
+        assertTrue(diff < 0)
+        val items = arrayListOf(v1, v2).sortBy(comparator)
+        assertEquals(v1, items[0])
+        assertEquals(v2, items[1])
+    }
+
+    Test fun sortUsingFunctionalComparator() {
+        val comparator = compareBy<Item>({ it.name }, { it.rating })
+        val diff = comparator.compare(v1, v2)
+        assertTrue(diff > 0)
+        val items = arrayListOf(v1, v2).sortBy(comparator)
+        assertEquals(v2, items[0])
+        assertEquals(v1, items[1])
+    }
+
+    Test fun sortUsingCustomComparator() {
+        val comparator = object : Comparator<Item> {
+            override fun compare(o1: Item, o2: Item): Int {
+                return compareValuesBy(o1, o2, { it.name }, { it.rating })
+            }
+
+            override fun equals(other: Any?): Boolean {
+                return this == other
+            }
+        }
+        val diff = comparator.compare(v1, v2)
+        assertTrue(diff > 0)
+        val items = arrayListOf(v1, v2).sortBy(comparator)
+        assertEquals(v2, items[0])
+        assertEquals(v1, items[1])
+    }
+
+}
diff --git a/libraries/stdlib/test/collections/MapJVMTest.kt b/libraries/stdlib/test/collections/MapJVMTest.kt
index 6680456a3f1..25cf51f1d3f 100644
--- a/libraries/stdlib/test/collections/MapJVMTest.kt
+++ b/libraries/stdlib/test/collections/MapJVMTest.kt
@@ -23,11 +23,7 @@ class MapJVMTest {
 
     test fun toSortedMapWithComparator() {
         val map = mapOf(Pair("c", 3), Pair("bc", 2), Pair("bd", 4), Pair("abc", 1))
-        val c = comparator<String>{ a, b ->
-            val answer = a.length() - b.length()
-            if (answer == 0) a.compareTo(b) else answer
-        }
-        val sorted = map.toSortedMap(c)
+        val sorted = map.toSortedMap(compareBy<String> { it.length() } thenBy { it })
         assertEquals(arrayListOf("c", "bc", "bd", "abc"), sorted.keySet().toList())
         assertEquals(1, sorted["abc"])
         assertEquals(2, sorted["bc"])
diff --git a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/KDocConfig.kt b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/KDocConfig.kt
index 7383122fa87..1829a080fca 100644
--- a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/KDocConfig.kt
+++ b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/KDocConfig.kt
@@ -114,7 +114,7 @@ class KDocConfig() {
 
 private object LongestFirstStringComparator : Comparator<String> {
     override fun compare(o1: String, o2: String): Int {
-        return compareBy<String>(o1, o2, { length() }, { this })
+        return compareValuesBy<String>(o1, o2, { it.length() }, { it })
     }
 
     override fun equals(other: Any?): Boolean {
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Ordering.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Ordering.kt
index 89e8e9aac7e..5180a24e8f9 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Ordering.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Ordering.kt
@@ -80,8 +80,7 @@ fun ordering(): List<GenericFunction> {
         body {
             """
             val sortedList = toArrayList()
-            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> y.compareTo(x) }
-            java.util.Collections.sort(sortedList, sortBy)
+            java.util.Collections.sort(sortedList, comparator { x, y -> y.compareTo(x) })
             return sortedList
             """
         }
@@ -105,7 +104,7 @@ fun ordering(): List<GenericFunction> {
         body {
             """
             val sortedList = toArrayList()
-            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y)) }
+            val sortBy: Comparator<T> = compareBy(order)
             java.util.Collections.sort(sortedList, sortBy)
             return sortedList
             """
@@ -128,7 +127,7 @@ fun ordering(): List<GenericFunction> {
         body {
             """
             val sortedList = toArrayList()
-            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y)) }
+            val sortBy: Comparator<T> = compareBy(order)
             java.util.Collections.sort(sortedList, sortBy)
             return sortedList
             """
@@ -150,7 +149,7 @@ fun ordering(): List<GenericFunction> {
         body {
             """
             val sortedList = toArrayList()
-            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(y).compareTo(order(x)) }
+            val sortBy: Comparator<T> = compareByDescending(order)
             java.util.Collections.sort(sortedList, sortBy)
             return sortedList
             """