Address some checkdoc warnings (#495)

for #233

[no important files changed]

Author: keiravillekode

exercises/practice/affine-cipher/.meta/example.el

@@ -48,11 +48,14 @@
     (+ (mod (* (mmi a m) (- (- char ?a) b)) m) ?a)))
 
 (defun mmi (a m)
-  "Find the modular multiplicative inverse (MMI) of A mod M using the extended Euclidean algorithm."
+  "Find the modular multiplicative inverse (MMI) of A mod M
+using the extended Euclidean algorithm."
   (let ((tt 0) ;; t is already used as constant for truth
         (newtt 1)
         (r m)
         (newr a))
+
+    ;; use the extended Euclidean algorithm
     (while (not (= newr 0))
       (let ((quotient (/ r newr))
             temp)

exercises/practice/circular-buffer/.meta/example.el

@@ -4,6 +4,7 @@
 
 ;;; Code:
 
+(require 'eieio)
 
 (define-error 'empty-buffer-error "buffer is empty")
 

exercises/practice/circular-buffer/circular-buffer.el

@@ -4,6 +4,7 @@
 
 ;;; Code:
 
+(require 'eieio)
 
 (define-error 'empty-buffer-error
               (error "Delete this S-Expression and write your own implementation"))

exercises/practice/gigasecond/gigasecond-test.el

@@ -6,7 +6,7 @@
 
 
 (load-file "gigasecond.el")
-(declare-function add "gigasecond.el" (moment))
+(declare-function add "gigasecond.el" (second minute hour day month year))
 
 
 (ert-deftest date-only-specification-of-time ()

exercises/practice/isogram/.meta/example.el

@@ -19,7 +19,7 @@
          (characters (cl-coerce (upcase phrase) 'list))
          (letters (cl-remove-if-not 'upper-char-p characters)))
     (cl-loop for c in letters
-      do (setq updated (logior bitset (lsh 1 (- c ?A))))
+      do (setq updated (logior bitset (ash 1 (- c ?A))))
       always (> updated bitset)
       do (setq bitset updated))))
 

exercises/practice/say/.meta/example.el

@@ -4,6 +4,8 @@
 
 ;;; Code:
 
+(require 'cl-lib)
+
 (define-error 'out-of-range "input out of range")
 
 (defun say (number)
@@ -14,40 +16,40 @@
         (tens '("" "" "twenty" "thirty" "forty" "fifty" "sixty" "seventy" "eighty" "ninety"))
         (powers '("" "thousand" "million" "billion")))
 
-    (defun number-to-words (n)
-      (let ((parts '()))
-        (while (> n 0)
-          (let* ((power (if (> n 999999999) 3 (if (> n 999999) 2 (if (> n 999) 1 0))))
-                 (unit (expt 1000 power))
-                 (quotient (/ n unit))
-                 (remainder (% n unit)))
+    (cl-labels
+      ((number-to-words (n)
+        (let ((parts '()))
+          (while (> n 0)
+            (let* ((power (if (> n 999999999) 3 (if (> n 999999) 2 (if (> n 999) 1 0))))
+              (unit (expt 1000 power))
+              (quotient (/ n unit))
+              (remainder (% n unit)))
             (if (> quotient 0)
-                (push (concat (number-to-words-1000 quotient) (if (> power 0) (concat " " (nth power powers)) "")) parts))
+              (push (concat (number-to-words-1000 quotient) (if (> power 0) (concat " " (nth power powers)) "")) parts))
             (setq n remainder)))
-        (string-join (reverse parts) " ")))
-
-    (defun number-to-words-1000 (n)
-      (cond
-       ((< n 10) (nth n ones))
-       ((< n 20) (nth (- n 10) teens))
-       ((< n 100)
-        (let ((ten (nth (/ n 10) tens))
+          (string-join (reverse parts) " ")))
+
+      (number-to-words-1000 (n)
+        (cond
+          ((< n 10) (nth n ones))
+          ((< n 20) (nth (- n 10) teens))
+          ((< n 100)
+            (let ((ten (nth (/ n 10) tens))
               (one (nth (% n 10) ones)))
-          (if (= (% n 10) 0)
+            (if (= (% n 10) 0)
               ten
-            (concat ten "-" one))))
-       ((< n 1000)
-        (let ((hundred (nth (/ n 100) ones))
+              (concat ten "-" one))))
+          ((< n 1000)
+            (let ((hundred (nth (/ n 100) ones))
               (remainder (% n 100)))
-          (if (= remainder 0)
+            (if (= remainder 0)
               (concat hundred " hundred")
-            (concat hundred " hundred " (number-to-words-1000 remainder)))))))
+              (concat hundred " hundred " (number-to-words-1000 remainder))))))))
 
-    (when (and (>= number 0) (< number (expt 10 12)))
-      (if (= number 0)
+      (when (and (>= number 0) (< number (expt 10 12)))
+        (if (= number 0)
           "zero"
-        (string-trim (number-to-words number))))))
-
+          (string-trim (number-to-words number)))))))
 
 (provide 'say)
 ;;; say.el ends here

exercises/practice/secret-handshake/.meta/example.el

@@ -15,7 +15,7 @@
             if (/= (logand number action) 0)
               do (setq result (cons (car pending) result))
             do (setq pending (cdr pending))
-            do (setq action (lsh action shift))
+            do (setq action (ash action shift))
             finally return result)))
       (if (= (logand number 16) 0)
         (funcall #'extract 8 -1 (reverse all-commands))

exercises/practice/variable-length-quantity/.meta/example.el

@@ -6,13 +6,13 @@
 
 
 (defun encode (hex-numbers)
-  "Encode a list of hexadecimal numbers into VLQ format, returning a list of hexadecimal values."
+  "Encode a list of hexadecimal numbers into VLQ format."
   (let ((encode-single (lambda (number)
                          (let ((byte-string (list (logand number #x7F)))) ; Initialize with the least significant byte
-                           (setq number (lsh number -7)) ; Shift right before the loop
+                           (setq number (ash number -7)) ; Shift right before the loop
                            (while (> number 0)
                              (push (logior (logand number #x7F) #x80) byte-string)
-                             (setq number (lsh number -7)))
+                             (setq number (ash number -7)))
                            byte-string))))
     (apply #'append (mapcar encode-single hex-numbers))))
 
@@ -23,7 +23,7 @@
         (number 0)
         (incomplete t))
     (dolist (byte hex-values)
-      (setq number (lsh number 7))
+      (setq number (ash number 7))
       (setq number (logior number (logand byte #x7F)))
       (if (= (logand byte #x80) 0)
           (progn