define renamed to def, defun renamed to defn

2022-01-25 19:50:59 +01:00
parent 62015c2ff8
commit e6f61c9d9f
14 changed files with 189 additions and 189 deletions
--- a/stdlib/doc.lsp
+++ b/stdlib/doc.lsp
@@ -1,17 +1,17 @@
 (include "/usr/local/var/mlisp/terminal.lsp")


-(defun doc::strip-backticks (s)
+(defn doc::strip-backticks (s)
 	(if (and (> (string-len s) 2) 
 			(= (string-substr s 0 1) "`")
 			(= (string-substr s -1 1) "`"))
 		(string-substr s 1 (- (string-len s) 2))
 		s))

-(defun doc::read-doc-file (filename)
-(do	(define parse-line (lambda (ln) 
+(defn doc::read-doc-file (filename)
+(do	(def parse-line (lambda (ln) 
 		(if (string-regex? ln "^|.*|")
-			(do  (define tokens (tail (string-split (string-rltrim ln " \n\r\t" "trim") "\|")))	; first element is "" 
+			(do  (def tokens (tail (string-split (string-rltrim ln " \n\r\t" "trim") "\|")))	; first element is "" 
 				(if (= (len tokens) 4)
 					(insert tokens 0 (string-replace-re (first (string-split (first tokens) "\s+|\)")) "`|\(" ""))
 					nil)
@@ -19,19 +19,19 @@
 			nil)
 		))

-	(define lines (string-split (read-file filename) "\n") )
-	(define lines (map (lambda (ln) (parse-line ln)) lines))
-	(define lines (filter (lambda (e) (!= e nil)) lines))
+	(def lines (string-split (read-file filename) "\n") )
+	(def lines (map (lambda (ln) (parse-line ln)) lines))
+	(def lines (filter (lambda (e) (!= e nil)) lines))
 	(set! doc::doc_entries lines)
 	'loaded
 ))

-(defun doc::print (entry)
+(defn doc::print (entry)
 (do	(print (term-green (doc::strip-backticks (second entry))) "-" (third entry))
 	; (print (last entry) "\n")	; doc section
 	(if (> (string-len (fourth entry)) 2)
-		(do	(define examp (doc::strip-backticks (fourth entry)))
-			(define pos (string-find examp "=>" 0))
+		(do	(def examp (doc::strip-backticks (fourth entry)))
+			(def pos (string-find examp "=>" 0))
 			(if (and pos (> pos 0))
 				(print (term-magenta
 					  (+ (string-substr examp 0 (- pos 1)) 
@@ -43,21 +43,21 @@
 	nil
 ))

-(defun doc::man (what)
-(do	(define man (filter (lambda (x) (= (first x) what)) doc::doc_entries))
+(defn doc::man (what)
+(do	(def man (filter (lambda (x) (= (first x) what)) doc::doc_entries))
 	(if man
 		(doc::print (first man))
 		(print (term-red (+ "No entry for " what)))
 	)
 ))

-(defun doc::look (what)
-(do	(define what_list (string-split (string-downcase what) "\s+"))
-	(define scores '())	; ((score entry)..)
+(defn doc::look (what)
+(do	(def what_list (string-split (string-downcase what) "\s+"))
+	(def scores '())	; ((score entry)..)
 			
 	(for entry doc::doc_entries
 		; ("throw-exception" "`(throw-exception exp_desc)`" "Throws an exception with exp_desc describing what happened " "" "Exceptions"
-		(define entry_score 0)
+		(def entry_score 0)
 		(for kw what_list
 			; name matches
 			(if (= (string-downcase (first entry)) kw)
@@ -73,23 +73,23 @@
 			(set! scores (push scores (list entry_score entry))))
 	)
 	
-	(define sorted (quick-sort-by scores (lambda (a b) (< (first a) (first b)))))
+	(def sorted (quick-sort-by scores (lambda (a b) (< (first a) (first b)))))
 	(for e (take sorted 10)
-		(define entry (second e))
-		(define call (doc::strip-backticks (second entry)))
-		(define desc (doc::strip-backticks (third entry)))
+		(def entry (second e))
+		(def call (doc::strip-backticks (second entry)))
+		(def desc (doc::strip-backticks (third entry)))
 		(print (term-red (first entry)) "-" (term-green (doc::strip-backticks (second entry))) "-" (third entry))
 	)
 	(if (> (len sorted) 10) (print "..."))
 ))

-(defun doc::appropos (which)
+(defn doc::appropos (which)
 	(doc::look which))

-;(defun doc::section (which)
+;(defn doc::section (which)
 ;	(print (term-red "implement me!")))

-(define doc::doc_entries '())	; must be here
+(def doc::doc_entries '())	; must be here

 ; read doc into memory
 (doc::read-doc-file "/usr/local/var/mlisp/Doc.md")
--- a/stdlib/stdlib.lsp
+++ b/stdlib/stdlib.lsp
@@ -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)))
--- a/stdlib/terminal.lsp
+++ b/stdlib/terminal.lsp
@@ -1,22 +1,22 @@

-(define term-rst-esc "\x1B[0m")
-(define term-red-esc '"\x1B[31m")
-(define term-green-esc "\x1B[32m")
-(define term-yellow-esc "\x1B[33m")
-(define term-blue-esc "\x1B[34m")
-(define term-magenta-esc "\x1B[35m")
-(define term-cyan-esc "\x1B[36m")
-(define term-white-esc "\x1B[37m")
-(define term-bold-esc "\x1B[1m")
-(define term-underline-esc "\x1B[4m")
+(def term-rst-esc "\x1B[0m")
+(def term-red-esc '"\x1B[31m")
+(def term-green-esc "\x1B[32m")
+(def term-yellow-esc "\x1B[33m")
+(def term-blue-esc "\x1B[34m")
+(def term-magenta-esc "\x1B[35m")
+(def term-cyan-esc "\x1B[36m")
+(def term-white-esc "\x1B[37m")
+(def term-bold-esc "\x1B[1m")
+(def term-underline-esc "\x1B[4m")

-(defun term-red (str) (sprintf (+ term-red-esc (string-replace str "%" "%%") term-rst-esc)))
-(defun term-green (str) (sprintf (+ term-green-esc (string-replace str "%" "%%") term-rst-esc)))
-(defun term-yellow (str) (sprintf (+ term-yellow-esc (string-replace str "%" "%%") term-rst-esc)))
-(defun term-blue (str) (sprintf (+ term-blue-esc (string-replace str "%" "%%") term-rst-esc)))
-(defun term-magenta (str) (sprintf (+ term-magenta-esc (string-replace str "%" "%%") term-rst-esc)))
-(defun term-cyan (str) (sprintf (+ term-cyan-esc (string-replace str "%" "%%") term-rst-esc)))
-(defun term-white (str) (sprintf (+ term-white-esc (string-replace str "%" "%%") term-rst-esc)))
-(defun term-bold (str) (sprintf (+ term-bold-esc (string-replace str "%" "%%") term-rst-esc)))
-(defun term-underline (str) (sprintf (+ term-underline-esc (string-replace str "%" "%%") term-rst-esc)))
+(defn term-red (str) (sprintf (+ term-red-esc (string-replace str "%" "%%") term-rst-esc)))
+(defn term-green (str) (sprintf (+ term-green-esc (string-replace str "%" "%%") term-rst-esc)))
+(defn term-yellow (str) (sprintf (+ term-yellow-esc (string-replace str "%" "%%") term-rst-esc)))
+(defn term-blue (str) (sprintf (+ term-blue-esc (string-replace str "%" "%%") term-rst-esc)))
+(defn term-magenta (str) (sprintf (+ term-magenta-esc (string-replace str "%" "%%") term-rst-esc)))
+(defn term-cyan (str) (sprintf (+ term-cyan-esc (string-replace str "%" "%%") term-rst-esc)))
+(defn term-white (str) (sprintf (+ term-white-esc (string-replace str "%" "%%") term-rst-esc)))
+(defn term-bold (str) (sprintf (+ term-bold-esc (string-replace str "%" "%%") term-rst-esc)))
+(defn term-underline (str) (sprintf (+ term-underline-esc (string-replace str "%" "%%") term-rst-esc)))

--- a/stdlib/ut.lsp
+++ b/stdlib/ut.lsp
@@ -1,23 +1,23 @@
 (include "/usr/local/var/mlisp/terminal.lsp")

-(defun ut::assert-equal (expected form) (do 
-		(define returned (eval form))
+(defn ut::assert-equal (expected form) (do 
+		(def returned (eval form))
 		(if (= expected returned)
 			(list #t expected returned)
 			(list nil expected returned))
 	))

-(defun ut::assert-true (test) (ut::assert-equal #t test))
-(defun ut::assert-false (test) (ut::assert-equal nil test))
-(defun ut::assert-nil (test) (ut::assert-false test))
+(defn ut::assert-true (test) (ut::assert-equal #t test))
+(defn ut::assert-false (test) (ut::assert-equal nil test))
+(defn ut::assert-nil (test) (ut::assert-false test))


-(defun ut::define-test (name exp_list)
+(defn ut::define-test (name exp_list)
    (set! ut::tests_list (push ut::tests_list (list name exp_list)))) 


-(defun ut::exec-test (test_name code) (do
-		(define test_result (eval code)) 
+(defn ut::exec-test (test_name code) (do
+		(def test_result (eval code)) 
 		(if (first test_result) 
 				(do (print (+ (term-green "OK") "  -> " test_name))
 					#t
@@ -28,15 +28,15 @@
 				))
 ))

-(defun ut::run-test (name)
+(defn ut::run-test (name)
 		(for t ut::tests_list
 			(if (= (first t) name)
 				(ut::exec-test (first t) (second t)))
 		))

-(defun ut::run-tests () (do 
-		(define oks 0)
-		(define errs 0)
+(defn ut::run-tests () (do 
+		(def oks 0)
+		(def errs 0)
 		(for t ut::tests_list
 			(if (ut::exec-test (first t) (second t))
 				(set! oks (+ oks 1))	
@@ -48,7 +48,7 @@
 			(print (term-red (+ (string errs) " test(s) FAILED"))))
 		))

-(define ut::tests_list '())
+(def ut::tests_list '())


 ;; example of usage