New functions plusp and minusp

* lisp/emacs-lisp/cl-lib.el (cl-plusp, cl-minusp): Move from here...
* lisp/subr.el (plusp, minusp): ...to here.  Make old names into
aliases, documented as deprecated.  Add type declarations.  Change from
defsubst to regular functions with compiler macros.
* lisp/obsolete/cl.el: Don't alias plusp and minusp.

* test/lisp/emacs-lisp/cl-lib-tests.el (cl-lib-test-plusp)
(cl-lib-test-minusp): Move tests from here...
* test/lisp/subr-tests.el (subr-test-plusp, subr-test-minusp):
...to here.

* doc/lispref/numbers.texi (Predicates on Numbers): Document plusp
and minusp.
* doc/misc/cl.texi (Predicates on Numbers): Delete cl-plusp and
cl-minusp.
* lisp/emacs-lisp/shortdoc.el (number): Document plusp and minusp
instead of cl-plusp and cl-minusp.

doc/lispref/numbers.texi

@@ -409,6 +409,16 @@ if so, @code{nil} otherwise.  The argument must be a number.
 @code{(zerop x)} is equivalent to @code{(= x 0)}.
 @end defun
 
+@defun plusp number
+This predicate tests whether its argument is positive, and returns
+@code{t} if so, @code{nil} otherwise.  The argument must be a number.
+@end defun
+
+@defun minusp number
+This predicate tests whether its argument is negative, and returns
+@code{t} if so, @code{nil} otherwise.  The argument must be a number.
+@end defun
+
 @defun oddp integer
 This predicate tests whether its argument is an odd number, and returns
 @code{t} if so, @code{nil} otherwise.  The argument must be an integer.

doc/misc/cl.texi

@@ -3055,7 +3055,7 @@ This section defines a few simple Common Lisp operations on numbers
 that were left out of Emacs Lisp.
 
 @menu
-* Predicates on Numbers::       @code{cl-plusp}, @code{cl-minusp}, etc.
+* Predicates on Numbers::       @code{cl-digit-char-p}, etc.
 * Numerical Functions::         @code{cl-floor}, @code{cl-ceiling}, etc.
 * Random Numbers::              @code{cl-random}, @code{cl-make-random-state}.
 * Implementation Parameters::   @code{cl-most-positive-float}, etc.
@@ -3068,16 +3068,6 @@ that were left out of Emacs Lisp.
 These functions return @code{t} if the specified condition is
 true of the numerical argument, or @code{nil} otherwise.
 
-@defun cl-plusp number
-This predicate tests whether @var{number} is positive.  It is an
-error if the argument is not a number.
-@end defun
-
-@defun cl-minusp number
-This predicate tests whether @var{number} is negative.  It is an
-error if the argument is not a number.
-@end defun
-
 @defun cl-digit-char-p char radix
 Test if @var{char} is a digit in the specified @var{radix} (default is
 10).  If it is, return the numerical value of digit @var{char} in

etc/NEWS

@@ -1287,6 +1287,13 @@ Previously, its argument was always evaluated using dynamic binding.
 
 * Lisp Changes in Emacs 31.1
 
++++
+** New functions 'plusp' and 'minusp'.
+They return non-nil if a number is positive or negative, respectively,
+and signal an error if they are given a non-number.  The 'cl-lib'
+functions 'cl-plusp' and 'cl-minusp' are now aliases for 'plusp' and
+'minusp'.
+
 +++
 ** New functions 'oddp' and 'evenp'.
 They return non-nil if an integer is odd or even, respectively, and

lisp/emacs-lisp/cl-lib.el

@@ -270,15 +270,17 @@ so that they are registered at compile-time as well as run-time."
 
 (define-obsolete-function-alias 'cl-floatp-safe 'floatp "24.4")
 
-(defsubst cl-plusp (number)
-  "Return t if NUMBER is positive."
-  (declare (side-effect-free t))
-  (> number 0))
+(defalias 'cl-plusp #'plusp
+  "Return t if NUMBER is positive.
 
-(defsubst cl-minusp (number)
-  "Return t if NUMBER is negative."
-  (declare (side-effect-free t))
-  (< number 0))
+This function is considered deprecated in favor of the built-in function
+`plusp' that was added in Emacs 31.1.")
+
+(defalias 'cl-minusp #'minusp
+  "Return t if NUMBER is negative.
+
+This function is considered deprecated in favor of the built-in function
+`minusp' that was added in Emacs 31.1.")
 
 (defalias 'cl-oddp #'oddp
   "Return t if INTEGER is odd.

lisp/emacs-lisp/shortdoc.el

@@ -1412,12 +1412,12 @@ A FUNC form can have any number of `:no-eval' (or `:no-value'),
    :eval (natnump -1)
    :eval (natnump 0)
    :eval (natnump 23))
-  (cl-plusp
-   :eval (cl-plusp 0)
-   :eval (cl-plusp 1))
-  (cl-minusp
-   :eval (cl-minusp 0)
-   :eval (cl-minusp -1))
+  (plusp
+   :eval (plusp 0)
+   :eval (plusp 1))
+  (minusp
+   :eval (minusp 0)
+   :eval (minusp -1))
   (oddp
    :eval (oddp 3))
   (evenp

lisp/obsolete/cl.el

@@ -272,8 +272,6 @@
                first
                svref
                copy-seq
-               minusp
-               plusp
                floatp-safe
                declaim
                proclaim

lisp/subr.el

@@ -550,6 +550,20 @@ was called."
            (compiler-macro (lambda (_) `(= 0 ,number))))
   (= 0 number))
 
+(defun plusp (number)
+  "Return t if NUMBER is positive."
+  (declare (ftype (function (number) boolean))
+           (side-effect-free t)
+           (compiler-macro (lambda (_) `(> ,number 0))))
+  (> number 0))
+
+(defun minusp (number)
+  "Return t if NUMBER is negative."
+  (declare (ftype (function (number) boolean))
+           (side-effect-free t)
+           (compiler-macro (lambda (_) `(< ,number 0))))
+  (< number 0))
+
 (defun oddp (integer)
   "Return t if INTEGER is odd."
   (declare (ftype (function (integer) boolean))

test/lisp/emacs-lisp/cl-lib-tests.el

@@ -79,38 +79,6 @@
     (should (= (cl-decf (alist-get 'a alist 0)) -1))
     (should (= (alist-get 'a alist 0) -1))))
 
-(ert-deftest cl-lib-test-plusp ()
-  (should-not (cl-plusp -1.0e+INF))
-  (should-not (cl-plusp -1.5e2))
-  (should-not (cl-plusp -3.14))
-  (should-not (cl-plusp -1))
-  (should-not (cl-plusp -0.0))
-  (should-not (cl-plusp 0))
-  (should-not (cl-plusp 0.0))
-  (should-not (cl-plusp -0.0e+NaN))
-  (should-not (cl-plusp 0.0e+NaN))
-  (should (cl-plusp 1))
-  (should (cl-plusp 3.14))
-  (should (cl-plusp 1.5e2))
-  (should (cl-plusp 1.0e+INF))
-  (should-error (cl-plusp "42") :type 'wrong-type-argument))
-
-(ert-deftest cl-lib-test-minusp ()
-  (should (cl-minusp -1.0e+INF))
-  (should (cl-minusp -1.5e2))
-  (should (cl-minusp -3.14))
-  (should (cl-minusp -1))
-  (should-not (cl-minusp -0.0))
-  (should-not (cl-minusp 0))
-  (should-not (cl-minusp 0.0))
-  (should-not (cl-minusp -0.0e+NaN))
-  (should-not (cl-minusp 0.0e+NaN))
-  (should-not (cl-minusp 1))
-  (should-not (cl-minusp 3.14))
-  (should-not (cl-minusp 1.5e2))
-  (should-not (cl-minusp 1.0e+INF))
-  (should-error (cl-minusp "-42") :type 'wrong-type-argument))
-
 (ert-deftest cl-digit-char-p ()
   (should (eql 3 (cl-digit-char-p ?3)))
   (should (eql 10 (cl-digit-char-p ?a 11)))

test/lisp/subr-tests.el

@@ -45,6 +45,38 @@
   (should-not (zerop (1- most-negative-fixnum)))
   (should-error (zerop "-5") :type 'wrong-type-argument))
 
+(ert-deftest subr-test-plusp ()
+  (should-not (plusp -1.0e+INF))
+  (should-not (plusp -1.5e2))
+  (should-not (plusp -3.14))
+  (should-not (plusp -1))
+  (should-not (plusp -0.0))
+  (should-not (plusp 0))
+  (should-not (plusp 0.0))
+  (should-not (plusp -0.0e+NaN))
+  (should-not (plusp 0.0e+NaN))
+  (should (plusp 1))
+  (should (plusp 3.14))
+  (should (plusp 1.5e2))
+  (should (plusp 1.0e+INF))
+  (should-error (plusp "42") :type 'wrong-type-argument))
+
+(ert-deftest subr-test-minusp ()
+  (should (minusp -1.0e+INF))
+  (should (minusp -1.5e2))
+  (should (minusp -3.14))
+  (should (minusp -1))
+  (should-not (minusp -0.0))
+  (should-not (minusp 0))
+  (should-not (minusp 0.0))
+  (should-not (minusp -0.0e+NaN))
+  (should-not (minusp 0.0e+NaN))
+  (should-not (minusp 1))
+  (should-not (minusp 3.14))
+  (should-not (minusp 1.5e2))
+  (should-not (minusp 1.0e+INF))
+  (should-error (minusp "-42") :type 'wrong-type-argument))
+
 (ert-deftest subr-test-oddp ()
   (should (oddp -3))
   (should (oddp 3))