Sync

Task/Greatest-subsequential-sum/D/greatest-subsequential-sum-2.d

@@ -3,32 +3,35 @@ import std.stdio, std.algorithm, std.range, std.typecons;
 mixin template InitsTails(T) {
     T[] data;
     size_t pos;
-    @property bool empty() { return pos > data.length; }
-    void popFront() { pos++; }
+    @property bool empty() pure nothrow {
+        return pos > data.length;
+    }
+    void popFront() pure nothrow { pos++; }
 }
 
 struct Inits(T) {
     mixin InitsTails!T;
-    @property T[] front() { return data[0 .. pos]; }
+    @property T[] front() pure nothrow { return data[0 .. pos]; }
 }
 
 auto inits(T)(T[] seq) { return seq.Inits!T; }
 
 struct Tails(T) {
     mixin InitsTails!T;
-    @property T[] front() { return data[pos .. $]; }
+    @property T[] front() pure nothrow { return data[pos .. $]; }
 }
 
-auto tails(T)(T[] seq) { return seq.Tails!T; }
+auto tails(T)(T[] seq) pure nothrow { return seq.Tails!T; }
 
-auto maxSubseq(T)(T[] seq) /*pure nothrow*/ {
-    //return seq.tails.map!inits.join.reduce!(max!q{ a.sum });
-    return seq
-           .tails
-           .map!inits
-           .join
-           .map!q{ tuple(reduce!q{a + b}(0, a), a) }
-           .reduce!max[1];
+T[] maxSubseq(T)(T[] seq) pure nothrow {
+    //return seq.tails.map!inits.join.reduce!(max!sum);
+    return reduce!max(tuple(0, T[].init),
+                      seq
+                      .tails
+                      .map!inits
+                      .join
+                      .map!q{ tuple(reduce!q{a + b}(0, a), a) }
+                      )[1];
 }
 
 void main() {