rename long preds to int and cover all fixed precision integer types

same as Clojure 20f67081

Author: dnolen

src/main/cljs/cljs/core.cljs

@@ -8,6 +8,7 @@
 
 (ns cljs.core
   (:require goog.math.Long
+            goog.math.Integer
             [goog.string :as gstring]
             [goog.object :as gobject]
             [goog.array :as garray])
@@ -2124,25 +2125,57 @@ reduces them without incurring seq initialization"
        (not (identical? n js/Infinity))
        (== (js/parseFloat n) (js/parseInt n 10))))
 
-(defn ^boolean long?
-  "Return true if x is an instance of goog.math.Long"
-  [x] (instance? goog.math.Long x))
-
-(defn ^boolean pos-long?
-  "Return true if x is a positive Long"
-  [x] (and (instance? goog.math.Long x)
-           (not (.isNegative x))
-           (not (.isZero x))))
-
-(defn ^boolean neg-long?
-  "Return true if x is a negative Long"
-  [x] (and (instance? goog.math.Long x)
-           (.isNegative x)))
-
-(defn ^boolean nat-long?
-  "Return true if x is a non-negative Long"
-  [x] (and (instance? goog.math.Long x)
-           (or (not (.isNegative x)) (.isZero x))))
+(defn ^boolean int?
+  "Return true if x is an integer"
+  [x]
+  (or (integer? x)
+      (instance? goog.math.Integer x)
+      (instance? goog.math.Long x)))
+
+(defn ^boolean pos-int?
+  "Return true if x is a positive integer"
+  [x]
+  (cond
+    (integer? x) (pos? x)
+
+    (instance? goog.math.Integer x)
+    (and (not (.isNegative x))
+         (not (.isZero x)))
+
+    (instance? goog.math.Long x)
+    (and (not (.isNegative x))
+         (not (.isZero x)))
+
+    :else false))
+
+(defn ^boolean neg-int?
+  "Return true if x is a negative integer"
+  [x]
+  (cond
+    (integer? x) (neg? x)
+
+    (instance? goog.math.Integer x)
+    (.isNegative x)
+
+    (instance? goog.math.Long x)
+    (.isNegative x)
+
+    :else false))
+
+(defn ^boolean nat-int?
+  "Return true if x is a non-negative integer"
+  [x]
+  (cond
+    (integer? x)
+    (or (not (neg? x)) (zero? x))
+
+    (instance? goog.math.Integer x)
+    (or (not (.isNegative x)) (.isZero x))
+
+    (instance? goog.math.Long x)
+    (or (not (.isNegative x)) (.isZero x))
+
+    :else false))
 
 (defn ^boolean contains?
   "Returns true if key is present in the given collection, otherwise

src/main/cljs/cljs/spec.cljc

@@ -384,11 +384,11 @@ specified, return speced vars from all namespaces."
               (gen/fmap mkdate#
                 (gen/large-integer* {:min st# :max et#}))))))
 
-(defmacro long-in
+(defmacro int-in
   "Returns a spec that validates longs in the range from start
   (inclusive) to end (exclusive)."
   [start end]
-  `(spec (and c/long? #(long-in-range? ~start ~end %))
+  `(spec (and c/int? #(int-in-range? ~start ~end %))
      :gen #(gen/large-integer* {:min ~start :max (dec ~end)})))
 
 (defmacro instrument

src/main/cljs/cljs/spec.cljs

@@ -1124,9 +1124,18 @@
          (let [t (inst-ms inst)]
            (c/and (<= (inst-ms start) t) (< t (inst-ms end))))))
 
-(defn long-in-range?
+(defn int-in-range?
   "Return true if start <= val and val < end"
   [start end val]
-  (c/and (long? val)
-         (.lessThanOrEqual (goog.math.Long.fromNumber start) val)
-         (.lessThan val  (goog.math.Long.fromNumber end))))
+  (cond
+    (integer? val) (and (<= start val) (< val end))
+
+    (instance? goog.math.Long val)
+    (c/and (.lessThanOrEqual start val)
+           (.lessThan val end))
+
+    (instance? goog.math.Integer val)
+    (c/and (.lessThanOrEqual start val)
+           (.lessThan val end))
+
+    :else false))

src/main/cljs/cljs/spec/impl/gen.cljs

@@ -89,10 +89,10 @@ gen-builtins
     (let [simple (simple-type-printable)]
       {number? (one-of [(large-integer) (double)])
        integer? (large-integer)
-       long? (large-integer)
-       pos-long? (large-integer* {:min 1})
-       neg-long? (large-integer* {:max -1})
-       nat-long? (large-integer* {:min 0})
+       int? (large-integer)
+       pos-int? (large-integer* {:min 1})
+       neg-int? (large-integer* {:max -1})
+       nat-int? (large-integer* {:min 0})
        ;float? (double)
        string? (string-alphanumeric)
        ident? (one-of [(keyword-ns) (symbol-ns)])