diff --git a/std/algorithm/iteration.d b/std/algorithm/iteration.d
diff --git a/std/algorithm/package.d b/std/algorithm/package.d
@@ -59,14 +59,13 @@ $(TR $(TDNW Comparison)
 $(TR $(TDNW Iteration)
     $(TDNW $(SUBMODULE iteration))
     $(TD
-        $(SUBREF iteration, aggregate)
         $(SUBREF iteration, cache)
         $(SUBREF iteration, cacheBidirectional)
+        $(SUBREF iteration, chunkBy)
         $(SUBREF iteration, each)
         $(SUBREF iteration, filter)
         $(SUBREF iteration, filterBidirectional)
         $(SUBREF iteration, group)
-        $(SUBREF iteration, groupBy)
         $(SUBREF iteration, joiner)
         $(SUBREF iteration, map)
         $(SUBREF iteration, reduce)

diff --git a/std/conv.d b/std/conv.d
@@ -1989,7 +1989,7 @@ Target parse(Target, Source)(ref Source s)
             Target v = cast(Target)c;
             while (!s.empty)
             {
-                c = s.front - '0';
+                c = cast(typeof(c)) (s.front - '0');
                 if (c > 9)
                     break;
 
@@ -2206,6 +2206,22 @@ Lerr:
     assertThrown!ConvOverflowException("-92233720368547758080".to!long());
 }
 
+// Issue 14396
+@safe pure unittest
+{
+    struct StrInputRange
+    {
+        this (string s) { str = s; }
+        char front() const @property { return str[front_index]; }
+        char popFront() { return str[front_index++]; }
+        bool empty() const @property { return str.length <= front_index; }
+        string str;
+        size_t front_index = 0;
+    }
+    auto input = StrInputRange("777");
+    assert(parse!int(input) == 777);
+}
+
 /// ditto
 Target parse(Target, Source)(ref Source s, uint radix)
     if (isSomeChar!(ElementType!Source) &&

diff --git a/std/experimental/logger/core.d b/std/experimental/logger/core.d
@@ -1852,7 +1852,7 @@ version (unittest)
         string msg = null;
         LogLevel lvl;
 
-        this(const LogLevel lv = LogLevel.info) @safe
+        this(const LogLevel lv = LogLevel.all) @safe
         {
             super(lv);
         }

diff --git a/std/experimental/logger/multilogger.d b/std/experimental/logger/multilogger.d
@@ -27,14 +27,14 @@ class MultiLogger : Logger
 
     Params:
       lv = The $(D LogLevel) for the $(D MultiLogger). By default the
-      $(D LogLevel) for $(D MultiLogger) is $(D LogLevel.info).
+      $(D LogLevel) for $(D MultiLogger) is $(D LogLevel.all).
 
     Example:
     -------------
     auto l1 = new MultiLogger(LogLevel.trace);
     -------------
     */
-    this(const LogLevel lv = LogLevel.info) @safe
+    this(const LogLevel lv = LogLevel.all) @safe
     {
         super(lv);
     }

diff --git a/std/experimental/logger/nulllogger.d b/std/experimental/logger/nulllogger.d
@@ -14,9 +14,9 @@ class NullLogger : Logger
 
     Params:
       lv = The $(D LogLevel) for the $(D NullLogger). By default the $(D LogLevel)
-      for $(D NullLogger) is $(D LogLevel.info).
+      for $(D NullLogger) is $(D LogLevel.all).
     */
-    this(const LogLevel lv = LogLevel.info) @safe
+    this(const LogLevel lv = LogLevel.all) @safe
     {
         super(lv);
         this.fatalHandler = delegate() {};

diff --git a/std/range/package.d b/std/range/package.d
@@ -7142,6 +7142,17 @@ sgi.com/tech/stl/binary_search.html, binary_search).
         }
         return false;
     }
+
+// groupBy
+/**
+Returns a range of subranges of elements that are equivalent according to the
+sorting relation.
+ */
+    auto groupBy()()
+    {
+        import std.algorithm.iteration : chunkBy;
+        return _input.chunkBy!((a, b) => !predFun(a, b) && !predFun(b, a));
+    }
 }
 
 ///
@@ -7271,6 +7282,14 @@ that break its sortedness, $(D SortedRange) will work erratically.
     auto s = assumeSorted(arr);
 }
 
+unittest
+{
+    import std.algorithm.comparison : equal;
+    int[] arr = [100, 101, 102, 200, 201, 300];
+    auto s = assumeSorted!((a, b) => a / 100 < b / 100)(arr);
+    assert(s.groupBy.equal!equal([[100, 101, 102], [200, 201], [300]]));
+}
+
 // Test on an input range
 unittest
 {