fix conflict with CL’s count function (GitLab issue #1)

  (a b c))

(deftest repeat.1

    (iter (repeat 9) (count 1))

    (iter (repeat 9) (counting 1))

  9)

(deftest repeat.2

    (iter (repeat -1.5f0) (counting t))

  0)

(deftest count.1

    (ignore-errors

      ;; a regression test for a bug formerly added to iterate, but now repaired, where

      ;; "count" was mistakenly a synonym of "counting" -- if it recurs this test will

      ;; fail cleanly

      (iter (for list in '((1 2 1) (t nil 1 t)))

            (collect (count 1 list))))

  (2 1))

(deftest locally.1

    (iterate (for i in '(1 2 3)) (repeat 2)

             (locally (collect i) (collect 0)))

        (incf sym-count))

      (= sym-count

	 (iterate (for () in-package '#:iterate external-only t)

                  (count 1))))

		  (counting 1))))

  t)

(deftest in-package.generator

(deftest next-iteration.1

    (iter (for i below 10)

	  (when (oddp i) (next-iteration))

          (count t))

	  (counting t))

  5)

(deftest next-iteration.2

  (1 2))

(deftest dotted.3

    (values (ignore-errors (iter (for i in '(1 2 . 3)) (count t))))

    (values (ignore-errors (iter (for i in '(1 2 . 3)) (counting t))))

  nil)

(deftest dotted.4

(deftest type.3

    (iter (declare (iterate:declare-variables))

	  (for el in '(1 2 3 4 5))

          (count (oddp el) into my-result)

	  (counting (oddp el) into my-result)

	  (declare (integer my-result))

	  (finally (return my-result)))

  3)

      (iter (for (k1 v1) in-hashtable ht1)

	    (counting

	     (iter (for (k2 nil) in-hashtable ht2)

                   (count k2)))))

		   (counting k2)))))

  1)

(deftest nested.in-hashtable.3

      (iter (for (k1 v1) in-hashtable ht1)

	    (progn

	     (iter (for (nil v2) in-hashtable v1)

                   (count v2))

		   (counting v2))

	     (collect k1))))

  (a))

  (< 6

     (print

      (iter (for scl in-package '#:iterate :external-only t)

            (count ; Iterate exports ~50 symbols

	    (counting ; Iterate exports ~50 symbols

	     (iter (for si in-package #.*package*)

		   (thereis (eq si scl))))))

     80)

                          (problem-because-i-return-nil))))

             (tags (all-tagbody-tags form)))

         (iter (for tag in tags)

              ;; invoke cl:count, not the Iterate clause:

              (always (= 1 (funcall #'count tag tags :from-end nil))))))

              (always (= 1 (count tag tags :from-end nil))))))

  t)

(deftest walk.tagbody.1

;;;           used, to avoid compiler warnings from some compilers (Allegro)

;;;  3/4/91 - treat cond as a special form for allegro

;;;  (v. 1.1.1)

;;;  2019-02-10 - Don Morrison (dfm@ringing.org): removed defsynonym defining

;;;               count, per section 2.3 or the Iterate Manual

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; OUTSTANDING PROBLEMS & QUESTIONS:

			   `((if ,test-expr ,update-code ,var))

			   (list update-code)))))

(defsynonym count counting)

;;; (COUNTING &optional INTO)

(defclause (counting expr &optional into var)

  "Increment a variable if expression is non-nil"