;;; mosa-lisp.el --- mosa lisp -*- lexical-binding: t -*-
;;
;;; Commentary:
;;
;;    __  __  ___  ____    _      _     ___ ____  ____
;;   |  \/  |/ _ \/ ___|  / \    | |   |_ _/ ___||  _ \
;;   | |\/| | | | \___ \ / _ \   | |    | |\___ \| |_) |
;;   | |  | | |_| |___) / ___ \  | |___ | | ___) |  __/
;;   |_|  |_|\___/|____/_/   \_\ |_____|___|____/|_|
;;
;;   updated `today' at 2026-05-19 09:20:21 CEST +0200
;;
;;; Code:

(require 'cl-lib)

(defalias 'str-match 'posix-string-match)
(defalias '$         'message)
(defalias '@f        'format)
(defalias '@i        'insert)

(defmacro & (&rest conditions) `(and ,@conditions))
(defmacro ! (&rest conditions) `(not ,@conditions))

;; -------
;; strings
;; -------

(defmacro lpad (len str &optional chr)  `(string-pad       ,str ,len ,chr t))
(defmacro rpad (len str &optional chr)  `(string-pad       ,str ,len ,chr))
(defmacro s2n  (str     &optional base) `(string-to-number ,str     ,base))
(defmacro s2b  (str     &optional base) `(string-to-number ,str (or ,base 2)))
(defmacro s<   (s1  s2)                 `(string-lessp     ,s1 ,s2))
(defmacro s=   (s1  s2)                 `(string-equal     ,s1 ,s2))

;; -------
;; logical
;; -------

(defun nand (&rest conditions) (when   (member nil conditions) t))
(defun nor  (&rest conditions) (unless (member t   conditions) t))

;; -----------
;; `goto-char'
;; -----------

(defmacro goto-beg () `(goto-char ,(point-min)))
(defmacro goto-end () `(goto-char ,(point-max)))

;; --------------------------
;; `interactive' and `lambda'
;; --------------------------

(defmacro i () `(interactive))
(defmacro L (arglist &rest body) `(lambda ,arglist (interactive) ,@body))

;; ----
;; math
;; ----

(defmacro ** (arg1 arg2) `(expt ,arg1 ,arg2))

(defun // (number &rest divisors)
  (or (numberp number) (setf number 1))
  (apply #'/ number
	 `(,@(cl-delete-if-not
	      (lambda (d) (and (numberp d) (not (zerop d))))
	      divisors)
	   1.0)))

;; ---------------
;; increment field
;; ---------------

(defmacro ++ (place &optional x) (or x (setf x 1)) `(cl-incf ,place ,x))
(defmacro -- (place &optional x) (or x (setf x 1)) `(cl-decf ,place ,x))

;; -----
;; types
;; -----

(defalias 'l   'listp)
(defalias 's   'stringp)
(defalias 'seq 'sequencep)
(defalias 'v   'vectorp)

(defun !l    (obj) (! (l   obj)))
(defun !s    (obj) (! (s   obj)))
(defun !v    (obj) (! (v   obj)))
(defun !seq  (obj) (! (seq obj)))

(defun lu    (obj) (& (l   obj) (<= 1 (length obj))))
(defun su    (obj) (& (s   obj) (<= 1 (length obj))))
(defun vu    (obj) (& (v   obj) (<= 1 (length obj))))
(defun sequ  (obj) (& (seq obj) (<= 1 (length obj))))

(defun !lu   (obj) (! (lu   obj)))
(defun !su   (obj) (! (su   obj)))
(defun !sequ (obj) (! (sequ obj)))

;; -------
;; numbers
;; -------

(defun in (a b c)                 (& (<= 0 a b) (< b c)))
(defun m  (x   &optional y)       (mod   x   (if (z y)       1   y)))
(defun r  (arg &optional devisor) (round arg (if (z devisor) 1.0 devisor)))

(defalias 'n  #'numberp)
(defalias 'ni #'integerp)
(defalias 'nf #'floatp)

(defun z   (num) (when (numberp num) (zerop num)))
(defun !z  (num) (not  (and (numberp (zerop num)))))
(defun !n  (obj) (not  (numberp  obj)))
(defun !ni (obj) (not  (integerp obj)))
(defun !nf (obj) (not  (floatp   obj)))

;; -------
;; buffers
;; -------

(defun buf-str (&optional beg end prop)
  (or beg (setf beg (point-min)))
  (or end (setf end (point-max)))
  (if prop (buffer-substring beg end)
    (buffer-substring-no-properties beg end)))

(defun pop-buf (&optional buffer-or-name action norecord)
  (or (bufferp buffer-or-name)
      (member  buffer-or-name (mapcar #'buffer-name (buffer-list)))
      (setf buffer-or-name (current-buffer)))
  (pop-to-buffer buffer-or-name action norecord))

(defun new-buf (name)
  (cl-assert (su name))
  (pop-to-buffer (get-buffer-create name))
  (erase-buffer)
  name)

;; ----
;; time
;; ----

(defun luki-hz    () (luki-time nil t))
(defun luki-ticks () (luki-time t))

(defun luki-time (&optional ticks hz)
  (pcase-let* ((current-time-list nil)
               (`(,ti . ,hi) (time-convert nil nil)))
    (cond (ticks ti)
          (hz    hi)
          ((/ ti hi 1.0)))))

(provide 'mosa-lisp)
;;; mosa-lisp.el ends here