CLJ-2772 Fix regression in drop nthrest nthnext on n != positive integer

Author: puredanger

src/clj/clojure/core.clj

@@ -2942,7 +2942,11 @@
                   (rf result input))))))))
   ([n coll]
      (if (instance? clojure.lang.IDrop coll)
-       (or (.drop ^clojure.lang.IDrop coll n) ())
+       (or
+        (if (pos? n)
+          (.drop ^clojure.lang.IDrop coll (if (int? n) n (Math/ceil n)))
+          (seq coll))
+        ())
        (let [step (fn [n coll]
                     (let [s (seq coll)]
                       (if (and (pos? n) s)
@@ -3170,7 +3174,9 @@
    :static true}
   [coll n]
   (if (instance? clojure.lang.IDrop coll)
-    (.drop ^clojure.lang.IDrop coll n)
+    (if (pos? n)
+      (.drop ^clojure.lang.IDrop coll (if (int? n) n (Math/ceil n)))
+      (seq coll))
     (loop [n n xs (seq coll)]
       (if (and xs (pos? n))
         (recur (dec n) (next xs))
@@ -3182,7 +3188,9 @@
    :static true}
   [coll n]
   (if (instance? clojure.lang.IDrop coll)
-    (or (.drop ^clojure.lang.IDrop coll n) ())
+    (if (pos? n)
+      (or (.drop ^clojure.lang.IDrop coll (if (int? n) n (Math/ceil n))) ())
+      coll)
     (loop [n n xs coll]
       (if-let [xs (and (pos? n) (seq xs))]
         (recur (dec n) (rest xs))

src/jvm/clojure/lang/IDrop.java

@@ -20,11 +20,8 @@ public interface IDrop{
      * useful if the returned coll implements IDrop for subsequent use in a
      * partition-like scenario.
      *
-     * If n is <= 0, return this.
-     * If n drops to or past the end of the collection, return null.
-     *
-     * @param n Items to drop
-     * @return Collection that is Sequential, ISeq, and IReduceInit
+     * @param n Items to drop, must be > 0
+     * @return Collection that is Sequential, ISeq, and IReduceInit, or null if past the end
      */
     Sequential drop(int n);
 }

src/jvm/clojure/lang/PersistentVector.java

@@ -366,9 +366,7 @@ public Object kvreduce(IFn f, Object init){
 }
 
 public Sequential drop(int n) {
-	if(n < 0) {
-		return this;
-	} else if(n < cnt) {
+	if(n < cnt) {
 		int offset = n%32;
 		return new ChunkedSeq(this, this.arrayFor(n), n-offset, offset);
 	} else {
@@ -617,7 +615,7 @@ public int count(){
 		ensureEditable();
 		return cnt;
 	}
-	
+
 	Node ensureEditable(Node node){
 		if(node.edit == root.edit)
 			return node;

test/clojure/test_clojure/sequences.clj

@@ -855,7 +855,9 @@
 
     (take 0 [1 2 3 4 5]) ()
     (take -1 [1 2 3 4 5]) ()
-    (take -2 [1 2 3 4 5]) () ))
+    (take -2 [1 2 3 4 5]) ()
+
+    (take 1/4 [1 2 3 4 5]) '(1) ))
 
 
 (deftest test-drop
@@ -867,8 +869,52 @@
 
     (drop 0 [1 2 3 4 5]) '(1 2 3 4 5)
     (drop -1 [1 2 3 4 5]) '(1 2 3 4 5)
-    (drop -2 [1 2 3 4 5]) '(1 2 3 4 5) ))
+    (drop -2 [1 2 3 4 5]) '(1 2 3 4 5)
+
+    (drop 1/4 [1 2 3 4 5]) '(2 3 4 5) )
+
+  (are [coll] (= (drop 4 coll) (drop -2 (drop 4 coll)))
+    [0 1 2 3 4 5]
+    (seq [0 1 2 3 4 5])
+    (range 6)
+    (repeat 6 :x))
+  )
+
+(deftest test-nthrest
+  (are [x y] (= x y)
+    (nthrest [1 2 3 4 5] 1) '(2 3 4 5)
+    (nthrest [1 2 3 4 5] 3) '(4 5)
+    (nthrest [1 2 3 4 5] 5) ()
+    (nthrest [1 2 3 4 5] 9) ()
+
+    (nthrest [1 2 3 4 5] 0) '(1 2 3 4 5)
+    (nthrest [1 2 3 4 5] -1) '(1 2 3 4 5)
+    (nthrest [1 2 3 4 5] -2) '(1 2 3 4 5)
+
+    (nthrest [1 2 3 4 5] 1/4) '(2 3 4 5)
+    (nthrest [1 2 3 4 5] 1.2) '(3 4 5) )
+
+  ;; (nthrest coll 0) should return coll
+  (are [coll] (let [r (nthrest coll 0)] (and (= coll r) (= (class coll) (class r))))
+    [1 2 3]
+    (seq [1 2 3])
+    (range 10)
+    (repeat 10 :x)
+    (seq "abc") ))
+
+(deftest test-nthnext
+  (are [x y] (= x y)
+    (nthnext [1 2 3 4 5] 1) '(2 3 4 5)
+    (nthnext [1 2 3 4 5] 3) '(4 5)
+    (nthnext [1 2 3 4 5] 5) nil
+    (nthnext [1 2 3 4 5] 9) nil
+
+    (nthnext [1 2 3 4 5] 0) '(1 2 3 4 5)
+    (nthnext [1 2 3 4 5] -1) '(1 2 3 4 5)
+    (nthnext [1 2 3 4 5] -2) '(1 2 3 4 5)
 
+    (nthnext [1 2 3 4 5] 1/4) '(2 3 4 5)
+    (nthnext [1 2 3 4 5] 1.2) '(3 4 5) ))
 
 (deftest test-take-nth
   (are [x y] (= x y)