Clojure Подсчитать сколько раз встречается каждая буква

(defun count-char (string)
            (let ((table (make-hash-table)))
              (loop
                 for el across string
                 do (incf (gethash el table 0))
                 finally 
                   (maphash #'(lambda (k v)
                                (format t "~A : ~A~%"
                                        (string k) v))
                            table))))

(ns aeon.core)
 
(defn task [s]
  (doseq [[k v] (frequencies s)
          :when (Character/isLetter k)]
    (printf "%s:%s " k v)))
;; => #'aeon.core/task
 
(task "hello world")
;; h:1 e:1 l:3 o:2 w:1 r:1 d:1 
;; => nil

(defn foo (l) (
    (defn collect (x l)
        (cond (null? l) (cons (cons x 1) nil)
              (eq? x (car (car l))) (cons (cons x (+ 1 (car (cdr (car l))))) (cdr l))
              (cons (car l) (collect x (cdr l)))))
    (foldl collect nil l)))
 
(defn show-pair (l) (str (car l) : (car (cdr l))))
(defn print-pair (l) (begin (print _) (print (car l)) (print :) (print (car (cdr l)))))
 
(def l (cons h (cons e (cons l (cons l (cons o (cons w (cons o (cons r (cons l d))))))))))
(printLn (str входящий список: l))
(def r (foo l))
(printLn (str результат: r))
(printLn (str или так: (map show-pair r)))
(printLn форматированный_результат:) (map print-pair r) (printLn _)

(defun count-letters (pathname)
  (with-open-file (s pathname :direction :input)
    (loop for line = (read-line s nil nil)
          while line
          nconc (list-symb (drop-noise line)) into words
          finally (return (sort (list-pair words) #'> :key #'cdr)))))
 
(defun list-symb (s)
  (read-from-string (concatenate 'string "(" s ")")))
 
(defun drop-noise (s)
  (delete-if-not
   #'(lambda (x) (or (alpha-char-p x)
                     (equal x #\space)))
   s))
 
(defun list-pair (words &aux (hash (make-hash-table)) acc)
  (dolist (word words) (incf (gethash word hash 0)))
  (maphash #'(lambda (e n) (push `(,e . ,n) acc)) hash) acc)
 
> (count-letters "test.txt")
((A . 2) (E . 1) (V . 1) (S . 1))

(defun count-letters (s &aux (z (remove-duplicates s)))
  (loop for a across z collect (List a (count a s))))
 
> (count-letters "aaabbc")
((#\a 3) (#\b 2) (#\c 1))

(defun count-letters (s &aux (z (remove-duplicates s)))
  (loop for a across z collect `(,a ,(count a s))))
 
> (count-letters "aaabbc")
((#\a 3) (#\b 2) (#\c 1))

(defun freq (txt)
  (let ((arr (replicate 0 256))
        (res ""))
    (iter (for a in-string txt)
      (let ((p (strAsc a)))
        (setf (nth p arr) (+ 1 (nth p arr)))))
    (iter (for i in arr) (for j from 0 to 255)
          (if (> i 0) (setq res (strCat res (strChr j) ": " (fix2str i) " "))))
    res ))
 
 
==> freq
 
(freq "Проба пера")
 
==> " : 1 П: 1 а: 2 б: 1 е: 1 о: 1 п: 1 р: 2 "

(defun freq (txt)
  (let ((arr (replicate 0 256))
        (res ""))
    (iter (for a in-string txt)
      (let* ((p (strAsc a))
             (pp (+ p 1)) 
             (z (+ 1 (getEl arr pp))))
            (putEl arr pp z))) 
    (iter (for i in arr) (for j from 0 to 255)
          (if (> i 0) (setq res (strCat res (strChr j) ": " (fix2str i) " "))))
    res ))