define renamed to def, defun renamed to defn

This commit is contained in:
vaclavt
2022-01-25 19:50:59 +01:00
parent 62015c2ff8
commit e6f61c9d9f
14 changed files with 189 additions and 189 deletions

View File

@@ -1,72 +1,72 @@
; not a bool
(defun not (x) (if x nil #t))
(defn not (x) (if x nil #t))
(defun is-pos? (n) (> n nil))
(defun is-neg? (n) (< n nil))
(defn is-pos? (n) (> n nil))
(defn is-neg? (n) (< n nil))
(defun neg (n) (- 0 n))
(defun dec (n) (- n 1))
(defun inc (n) (+ n 1))
(defn neg (n) (- 0 n))
(defn dec (n) (- n 1))
(defn inc (n) (+ n 1))
(defun string-ltrim (str)
(defn string-ltrim (str)
(string-rltrim str " \n\r\t" "ltrim"))
(defun string-rtrim (str)
(defn string-rtrim (str)
(string-rltrim str " \n\r\t" "rtrim"))
(defun string-trim (str)
(defn string-trim (str)
(string-rltrim str " \n\r\t" "trim"))
(defun string-rpad (str length pad_char)
(defn string-rpad (str length pad_char)
(string-pad str length pad_char "rpad"))
(defun string-lpad (str length pad_char)
(defn string-lpad (str length pad_char)
(string-pad str length pad_char "lpad"))
(defun string-upcase (str)
(defn string-upcase (str)
(string-case str "upper"))
(defun string-downcase (str)
(defn string-downcase (str)
(string-case str "lower"))
(defun string-join (lst sep)
(defn string-join (lst sep)
(do
(define rslt "")
(define i 0)
(def rslt "")
(def i 0)
(for e lst
(if (= i 0)
(do (define rslt (display e)) (define i 1))
(define rslt (+ rslt (display sep) (display e)))
(do (def rslt (display e)) (def i 1))
(def rslt (+ rslt (display sep) (display e)))
))
rslt
))
(defun itok (ascii) (sprintf "%c" (list ascii)))
(defun ktoi (char) (int (sprintf "%d" (list char))))
(defn itok (ascii) (sprintf "%c" (list ascii)))
(defn ktoi (char) (int (sprintf "%d" (list char))))
; pause for interval of seconds
(defun sleep (time)
(defn sleep (time)
(system-cmd (+ "sleep " (string time))))
(defun get-env (var)
(defn get-env (var)
(second (system-cmd (+ "echo ${" var "} | tr -d \"\n\""))))
(defun third (l) (index l 2))
(defun fourth (l) (index l 3))
(defun fifth (l) (index l 4))
(defun sixth (l) (index l 5))
(defun seventh (l) (index l 6))
(defun eight (l) (index l 7))
(defun nineth (l) (index l 8))
(defun tenth (l) (index l 9))
(defun nth (i l) (index l (- i 1)))
(defn third (l) (index l 2))
(defn fourth (l) (index l 3))
(defn fifth (l) (index l 4))
(defn sixth (l) (index l 5))
(defn seventh (l) (index l 6))
(defn eight (l) (index l 7))
(defn nineth (l) (index l 8))
(defn tenth (l) (index l 9))
(defn nth (i l) (index l (- i 1)))
; return 1 when list contains item otherwise nil
(defun member (lst itm)
(defn member (lst itm)
(do
; TODO check if is empty list
(define found_index -1)
(define i 0)
(define lst_len (len lst))
(def found_index -1)
(def i 0)
(def lst_len (len lst))
(while (and (< i lst_len) (= found_index -1))
(if (= itm (index lst i))
@@ -79,59 +79,59 @@
nil)
))
(defun make-list-of (size val)
(defn make-list-of (size val)
(do
(define lst '())
(define i 0)
(def lst '())
(def i 0)
(while (< i size)
(define lst (push lst val))
(define i (inc i)))
(def lst (push lst val))
(def i (inc i)))
lst
))
(defun make-list (size)
(defn make-list (size)
(make-list-of size nil))
(defun empty-list? (lst) (and (= (type lst) "list") (= (len lst) 0)))
(defn empty-list? (lst) (and (= (type lst) "list") (= (len lst) 0)))
(defun uniq (lst)
(defn uniq (lst)
(do
(define rslt '())
(define i 0)
(define lst_len (len lst))
(def rslt '())
(def i 0)
(def lst_len (len lst))
(while (< i lst_len)
(define e (index lst i))
(def e (index lst i))
(if (not (member rslt e))
(define rslt (push rslt e)))
(def rslt (push rslt e)))
(define i (inc i)))
(def i (inc i)))
rslt
))
(defun flatten (lst)
(defn flatten (lst)
(do
(define rslt '())
(def rslt '())
(for e lst
(if (= (type e) "list")
(do
(for ee (flatten e)
(define rslt (push rslt ee))))
(define rslt (push rslt e))
(def rslt (push rslt ee))))
(def rslt (push rslt e))
))
rslt
))
(defun take (lst n)
(defn take (lst n)
(if (> (len lst) n)
(map (lambda (i) (index lst i)) (range 0 n))
lst))
(defun quick-sort-by (l cmp)
(defn quick-sort-by (l cmp)
(if (<= (len l) 1)
l
(do
(define pivot (first l))
(def pivot (first l))
(+
(quick-sort-by (filter (lambda (n) (cmp pivot n)) l) cmp)
(list pivot)
@@ -139,57 +139,57 @@
))
))
(defun quick-sort (l)
(defn quick-sort (l)
(quick-sort-by l (lambda (a b) (> a b))))
(defun quick-sort-reverse (l)
(defn quick-sort-reverse (l)
(quick-sort-by l (lambda (a b) (> b a))))
(defun start-of-day (datetime) (str-to-date (+ (date-to-str datetime "%Y-%m-%d") " " "00:00:00") "%Y-%m-%d %H:%M:%S"))
(defun end-of-day (datetime) (str-to-date (+ (date-to-str datetime "%Y-%m-%d") " " "23:59:59") "%Y-%m-%d %H:%M:%S"))
(defun start-of-month (datetime) (str-to-date (+ (date-to-str datetime "%Y-%m") "-01 00:00:00") "%Y-%m-%d %H:%M:%S"))
(defun start-of-next-month (datetime) (date-add (start-of-month datetime) 1 "month"))
(defun end-of-next-month (datetime) (date-add (end-of-month datetime) 1 "month"))
(defun end-of-month (datetime) (date-add (date-add (start-of-month datetime) 1 "month") -1 "second"))
(defun start-of-prev-month (datetime) (date-add (start-of-month datetime) -1 "month"))
(defun end-of-prev-month (datetime) (date-add (end-of-month datetime) -1 "month"))
(defun start-of-year (datetime) (str-to-date (+ (date-to-str datetime "%Y") "-01-01 00:00:00") "%Y-%m-%d %H:%M:%S"))
(defun end-of-year (datetime) (str-to-date (+ (date-to-str datetime "%Y") "-12-31 23:59:59") "%Y-%m-%d %H:%M:%S"))
(defn start-of-day (datetime) (str-to-date (+ (date-to-str datetime "%Y-%m-%d") " " "00:00:00") "%Y-%m-%d %H:%M:%S"))
(defn end-of-day (datetime) (str-to-date (+ (date-to-str datetime "%Y-%m-%d") " " "23:59:59") "%Y-%m-%d %H:%M:%S"))
(defn start-of-month (datetime) (str-to-date (+ (date-to-str datetime "%Y-%m") "-01 00:00:00") "%Y-%m-%d %H:%M:%S"))
(defn start-of-next-month (datetime) (date-add (start-of-month datetime) 1 "month"))
(defn end-of-next-month (datetime) (date-add (end-of-month datetime) 1 "month"))
(defn end-of-month (datetime) (date-add (date-add (start-of-month datetime) 1 "month") -1 "second"))
(defn start-of-prev-month (datetime) (date-add (start-of-month datetime) -1 "month"))
(defn end-of-prev-month (datetime) (date-add (end-of-month datetime) -1 "month"))
(defn start-of-year (datetime) (str-to-date (+ (date-to-str datetime "%Y") "-01-01 00:00:00") "%Y-%m-%d %H:%M:%S"))
(defn end-of-year (datetime) (str-to-date (+ (date-to-str datetime "%Y") "-12-31 23:59:59") "%Y-%m-%d %H:%M:%S"))
; from list of lists creates csv string
; (print (make-csv '(("r1c1" "r1c2") ("r2c1" "r2c2"))))
(defun make-csv (csv_list)
(defn make-csv (csv_list)
(do
(define rows_str "")
(define r 0)
(def rows_str "")
(def r 0)
(for row csv_list
(define cols_str "")
(define c 0)
(def cols_str "")
(def c 0)
(for col row
(if (= c 0)
(define cols_str col)
(define cols_str (+ cols_str "," (display col))))
(define c (inc c)))
(def cols_str col)
(def cols_str (+ cols_str "," (display col))))
(def c (inc c)))
(if (= r 0)
(define rows_str cols_str)
(define rows_str (+ rows_str "\n" cols_str)))
(define r (inc r)))
(def rows_str cols_str)
(def rows_str (+ rows_str "\n" cols_str)))
(def r (inc r)))
rows_str
))
; looks into lst's elements and when there is a list with first item with name, it returns the _second_ element of that list
(defun find-val-in-list (lst name)
(defn find-val-in-list (lst name)
(do
(define found_val nil)
(define i 0)
(def found_val nil)
(def i 0)
(define list_len (len lst))
(def list_len (len lst))
(while (and (>= i 0) (< i list_len))
(define e (index lst i))
(def e (index lst i))
(set! i (inc i))
(if (= (type e) "list")
(if (= (type (first e)) "list")
@@ -223,12 +223,12 @@
))
(defun min (l)
(defn min (l)
(if (or (not l) (= (len l) 0))
nil
(do
(define minn (index l 0))
(define i 1)
(def minn (index l 0))
(def i 1)
(while (< i (len l))
(if (< (index l i) minn)
(set! minn (index l i)))
@@ -238,12 +238,12 @@
)
))
(defun max (l)
(defn max (l)
(if (or (not l) (= (len l) 0))
nil
(do
(define maxx (index l 0))
(define i 1)
(def maxx (index l 0))
(def i 1)
(while (< i (len l))
(if (> (index l i) maxx)
(set! maxx (index l i)))