ref: 96fa385727991e81a3c0d97b80720836551c8572
parent: ee670d20c66fbfaa6954c22c14437c4ed93175cb
author: Sigrid Solveig Haflínudóttir <sigrid@ftrv.se>
date: Fri Mar 21 13:30:18 EDT 2025
upcase T and NIL, prefer NIL instead of ()
--- a/boot/sl.boot
+++ b/boot/sl.boot
@@ -33,10 +33,10 @@
1 2 3 4 5))\n (set-car! q 0) → (0 6 7)\n q → (0 6 7)" cons? "Return `T` if `v` is a cons cell, `NIL` otherwise.\n\nExamples:\n\n (cons? 0) → NIL\n (cons? NIL) → NIL\n (cons? '(1)) → T" 1+ "Equivalent to `(+ n 1)`." aref "Return the sequence element specified by the subscripts. The sequence\ncan be an array, vector, a list. Multi-dimensional sequences\nof variating types are also supported.\n\nExamples:\n\n (def a '((1 #(2 (3)) 4)))\n (aref a 0) → (1 (2 (3)) 4)\n (aref a 1) → index 1 out of bounds\n (aref a 0 0) → 1\n (aref a 0 1 0) → 2\n (aref a 0 2) → 4" *properties* "All properties of symbols recorded with `putprop` are recorded in this table." vec "Return a vector constructed of the arguments.\n\nExamples:\n\n (vec) → #() ; empty vector\n (vec 1 2.5 \"a\" 'b) → #(1 2.5 \"a\" b)" >= "Return `T` if the arguments are in non-increasing order (previous\none is greater than or equal to the next one)." sym? "Return `T` if `v` is a symbol, `NIL` otherwise." void? "Return `T` if `x` is `#<void>`, `NIL` otherwise." zero? "Return `T` if `x` is zero." length= "Perform a bounded length test.\n\nUse this instead of `(= (length lst) n)`, since it avoids unnecessary\nwork and always terminates." positive? "Return `T` if `x` is greater than zero." doc-for "Define documentation for a top level term.\n\nIf `term` is a function signature and `doc` is not specified, just\nthe signature will be included in the documentation, without\nreplacing any previously defined." aset! "Modify the sequence element specified by the subscripts and return the\nnew value. The sequence can be an array, vector, a list.\nMulti-dimensional sequences of variating types are also supported.\n\nExamples:\n\n (def a '((1 #(2 (3)) 4)))\n (aset! a 1 'x) → index 1 out of bounds\n (aset! a 0 0 'x) → x\n a → ((x #(2 (3)) 4))\n (aset! a 0 1 9) → 9\n a → ((x #(9 (3)) 4))" car "Return the first element of a cons cell (head of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (car NIL) → NIL\n (car '(1 2 3)) → 1\n (car '(1 . 2)) → 1" *builtins* "VM instructions as closures." str "Convert terms to a concatenated string.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed." cons "Return a cons cell containing two arguments.\n\nExamples:\n\n (cons 1 2) → (1 . 2)\n (cons 1 '(2)) → (1 2)\n (cons 1 (cons 2 (cons 3 NIL))) → (1 2 3)" - "Return the result of subtraction. With only one argument a\nnegation is performed.\n\nExamples:\n\n (- 1.5) → -1.5\n (- 3 2) → 1" remprop "Remove a property value associated with a symbol." <= "Return `T` if the arguments are in non-decreasing order (previous\none is less than or equal to the next one)." rand "Return a random non-negative fixnum on its maximum range." void "Return the constant `#<void>` while ignoring any arguments.\n\n`#<void>` is mainly used when a function has side effects but does not\nproduce any meaningful value to return, so even though `T` or `NIL` could\nbe returned instead, in case of `#<void>` alone, REPL will not print\nit." negative? "Return `T` if `x` is negative." Instructions "VM instructions mapped to their encoded byte representation." file "Open a file for I/O.\n\nAn `io` object is returned. Without any modes specified the file\nis opened in read-only mode." rand-double "Return a random double on interval [0.0, 1.0]." 1- "Equivalent to `(- n 1)`." atom? "Return `T` if `v` is a _not_ a cons cell, `NIL` otherwise. This is\nthe opposite of `cons?`.\n\nThe term \"atom\" comes from the idea of being indivisible.\n\nExamples:\n\n (atom? \"a\") → T\n (atom? NIL) → T\n (atom? '(1)) → NIL" cdr "Return the second element of a cons cell (tail of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (cdr NIL) → NIL\n (cdr '(1 2 3)) → (2 3)\n (cdr '(1 . 2))
\ No newline at end of file
*syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref)) doc-for #fn("z10B86;35040<;J404086;35040=863H0202187e2211e22188e2e4:202187e2211e2e3:" #(sym-set-doc quote)) with-input-from #fn("z12021e1220e2e1e12315163:" #(#fn(nconc) with-bindings *io-in* #fn(copy-list))) unless #fn("z1200q211Pe4:" #(if-equences\nof variating types are also supported.\n\nExamples:\n\n (def a '((1 #(2 (3)) 4)))\n (aref a 0) → (1 (2 (3)) 4)\n (aref a 1) → index 1 out of bounds\n (aref a 0 0) → 1\n (aref a 0 1 0) → 2\n (aref a 0 2) → 4" *properties* "All properties of symbols recorded with `putprop` are recorded in this table." vec "Return a vector constructed of the arguments.\n\nExamples:\n\n (vec) → #() ; empty vector\n (vec 1 2.5 \"a\" 'b) → #(1 2.5 \"a\" b)" >= "Return `T` if the arguments are in non-increasing order (previous\none is greater than or equal to the next one)." sym? "Return `T` if `v` is a symbol, `NIL` otherwise." void? "Return `T` if `x` is `#<void>`, `NIL` otherwise." zero? "Return `T` if `x` is zero." length= "Perform a bounded length test.\n\nUse this instead of `(= (length lst) n)`, since it avoids unnecessary\nwork and always terminates." positive? "Return `T` if `x` is greater than zero." doc-for "Define documentation for a top level term.\n\nIf `term` is a function signature and `doc` is not specified, just\nthe signature will be included in the documentation, without\nreplacing any previously defined." aset! "Modify the sequence element specified by the subscripts and return the\nnew value. The sequence can be an array, vector, a list.\nMulti-dimensional sequences of variating types are also supported.\n\nExamples:\n\n (def a '((1 #(2 (3)) 4)))\n (aset! a 1 'x) → index 1 out of bounds\n (aset! a 0 0 'x) → x\n a → ((x #(2 (3)) 4))\n (aset! a 0 1 9) → 9\n a → ((x #(9 (3)) 4))" car "Return the first element of a cons cell (head of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (car NIL) → NIL\n (car '(1 2 3)) → 1\n (car '(1 . 2)) → 1" *builtins* "VM instructions as closures." str "Convert terms to a concatenated string.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed." cons "Return a cons cell containing two arguments.\n\nExamples:\n\n (cons 1 2) → (1 . 2)\n (cons 1 '(2)) → (1 2)\n (cons 1 (cons 2 (cons 3 NIL))) → (1 2 3)" - "Return the result of subtraction. With only one argument a\nnegation is performed.\n\nExamples:\n\n (- 1.5) → -1.5\n (- 3 2) → 1" remprop "Remove a property value associated with a symbol." <= "Return `T` if the arguments are in non-decreasing order (previous\none is less than or equal to the next one)." rand "Return a random non-negative fixnum on its maximum range." void "Return the constant `#<void>` while ignoring any arguments.\n\n`#<void>` is mainly used when a function has side effects but does not\nproduce any meaningful value to return, so even though `T` or `NIL` could\nbe returned instead, in case of `#<void>` alone, REPL will not print\nit." negative? "Return `T` if `x` is negative." Instructions "VM instructions mapped to their encoded byte representation." file "Open a file for I/O.\n\nAn `io` object is returned. Without any modes specified the file\nis opened in read-only mode." rand-double "Return a random double on interval [0.0, 1.0]." 1- "Equivalent to `(- n 1)`." atom? "Return `T` if `v` is a _not_ a cons cell, `NIL` otherwise. This is\nthe opposite of `cons?`.\n\nThe term \"atom\" comes from the idea of being indivisible.\n\nExamples:\n\n (atom? \"a\") → T\n (atom? NIL) → T\n (atom? '(1)) → NIL" cdr "Return the second element of a cons cell (tail of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (cdr NIL) → NIL\n (cdr '(1 2 3)) → (2 3)\n (cdr '(1 . 2)) → 2" T "A boolean \"true\".\n\nExamples:\n\n (not T) → NIL\n (if T 'yes 'no) → yes" vec? "Return `T` if `v` is a vector, `NIL` otherwise." equal? "Return `T` if both `a` and `b` are of the same value. For non-leaf\ntypes (cons cell and vector), the equality test is performed\nthroughout the whole structure of the values.\n\nExamples:\n\n (equal? 0.0 0) → NIL\
\ No newline at end of file
+equences\nof variating types are also supported.\n\nExamples:\n\n (def a '((1 #(2 (3)) 4)))\n (aref a 0) → (1 (2 (3)) 4)\n (aref a 1) → index 1 out of bounds\n (aref a 0 0) → 1\n (aref a 0 1 0) → 2\n (aref a 0 2) → 4" *properties* "All properties of symbols recorded with `putprop` are recorded in this table." vec "Return a vector constructed of the arguments.\n\nExamples:\n\n (vec) → #() ; empty vector\n (vec 1 2.5 \"a\" 'b) → #(1 2.5 \"a\" b)" >= "Return `T` if the arguments are in non-increasing order (previous\none is greater than or equal to the next one)." sym? "Return `T` if `v` is a symbol, `NIL` otherwise." void? "Return `T` if `x` is `#<void>`, `NIL` otherwise." zero? "Return `T` if `x` is zero." length= "Perform a bounded length test.\n\nUse this instead of `(= (length lst) n)`, since it avoids unnecessary\nwork and always terminates." positive? "Return `T` if `x` is greater than zero." doc-for "Define documentation for a top level term.\n\nIf `term` is a function signature and `doc` is not specified, just\nthe signature will be included in the documentation, without\nreplacing any previously defined." aset! "Modify the sequence element specified by the subscripts and return the\nnew value. The sequence can be an array, vector, a list.\nMulti-dimensional sequences of variating types are also supported.\n\nExamples:\n\n (def a '((1 #(2 (3)) 4)))\n (aset! a 1 'x) → index 1 out of bounds\n (aset! a 0 0 'x) → x\n a → ((x #(2 (3)) 4))\n (aset! a 0 1 9) → 9\n a → ((x #(9 (3)) 4))" car "Return the first element of a cons cell (head of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (car NIL) → NIL\n (car '(1 2 3)) → 1\n (car '(1 . 2)) → 1" *builtins* "VM instructions as closures." str "Convert terms to a concatenated string.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed." cons "Return a cons cell containing two arguments.\n\nExamples:\n\n (cons 1 2) → (1 . 2)\n (cons 1 '(2)) → (1 2)\n (cons 1 (cons 2 (cons 3 NIL))) → (1 2 3)" - "Return the result of subtraction. With only one argument a\nnegation is performed.\n\nExamples:\n\n (- 1.5) → -1.5\n (- 3 2) → 1" remprop "Remove a property value associated with a symbol." <= "Return `T` if the arguments are in non-decreasing order (previous\none is less than or equal to the next one)." rand "Return a random non-negative fixnum on its maximum range." void "Return the constant `#<void>` while ignoring any arguments.\n\n`#<void>` is mainly used when a function has side effects but does not\nproduce any meaningful value to return, so even though `T` or `NIL` could\nbe returned instead, in case of `#<void>` alone, REPL will not print\nit." negative? "Return `T` if `x` is negative." Instructions "VM instructions mapped to their encoded byte representation." file "Open a file for I/O.\n\nAn `io` object is returned. Without any modes specified the file\nis opened in read-only mode." rand-double "Return a random double on interval [0.0, 1.0]." 1- "Equivalent to `(- n 1)`." atom? "Return `T` if `v` is a _not_ a cons cell, `NIL` otherwise. This is\nthe opposite of `cons?`.\n\nThe term \"atom\" comes from the idea of being indivisible.\n\nExamples:\n\n (atom? \"a\") → T\n (atom? NIL) → T\n (atom? '(1)) → NIL" cdr "Return the second element of a cons cell (tail of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (cdr NIL) → NIL\n (cdr '(1 2 3)) → (2 3)\n (cdr '(1 . 2)) → 2" T "A boolean \"true\".\n\nExamples:\n\n (not T) → NIL\n (if T 'yes 'no) → yes" vec? "Return `T` if `v` is a vector, `NIL` otherwise." equal? "Return `T` if both `a` and `b` are of the same value. For non-leaf\ntypes (cons cell and vector), the equality test is performed\nthroughout the whole structure of the values.\n\nExamples:\n\n (equal? 0.0 0) → NIL\
\ No newline at end of file
(aref a 1) → index 1 out of bounds\n (aref a 0 0) → 1\n (aref a 0 1 0) → 2\n (aref a 0 2) → 4" *properties* "All properties of symbols recorded with `putprop` are recorded in this table." vec "Return a vector constructed of the arguments.\n\nExamples:\n\n (vec) → #() ; empty vector\n (vec 1 2.5 \"a\" 'b) → #(1 2.5 \"a\" b)" >= "Return `T` if the arguments are in non-increasing order (previous\none is greater than or equal to the next one)." sym? "Return `T` if `v` is a symbol, `NIL` otherwise." void? "Return `T` if `x` is `#<void>`, `NIL` otherwise." zero? "Return `T` if `x` is zero." length= "Perform a bounded length test.\n\nUse this instead of `(= (length lst) n)`, since it avoids unnecessary\nwork and always terminates." positive? "Return `T` if `x` is greater than zero." doc-for "Define documentation for a top level term.\n\nIf `term` is a function signature and `doc` is not specified, just\nthe signature will be included in the documentation, without\nreplacing any previously defined." aset! "Modify the sequence element specified by the subscripts and return the\nnew value. The sequence can be an array, vector, a list.\nMulti-dimensional sequences of variating types are also supported.\n\nExamples:\n\n (def a '((1 #(2 (3)) 4)))\n (aset! a 1 'x) → index 1 out of bounds\n (aset! a 0 0 'x) → x\n a → ((x #(2 (3)) 4))\n (aset! a 0 1 9) → 9\n a → ((x #(9 (3)) 4))" car "Return the first element of a cons cell (head of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (car NIL) → NIL\n (car '(1 2 3)) → 1\n (car '(1 . 2)) → 1" *builtins* "VM instructions as closures." str "Convert terms to a concatenated string.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed." cons "Return a cons cell containing two arguments.\n\nExamples:\n\n (cons 1 2) → (1 . 2)\n (cons 1 '(2)) → (1 2)\n (cons 1 (cons 2 (cons 3 NIL))) → (1 2 3)" - "Return the result of subtraction. With only one argument a\nnegation is performed.\n\nExamples:\n\n (- 1.5) → -1.5\n (- 3 2) → 1" remprop "Remove a property value associated with a symbol." <= "Return `T` if the arguments are in non-decreasing order (previous\none is less than or equal to the next one)." rand "Return a random non-negative fixnum on its maximum range." void "Return the constant `#<void>` while ignoring any arguments.\n\n`#<void>` is mainly used when a function has side effects but does not\nproduce any meaningful value to return, so even though `T` or `NIL` could\nbe returned instead, in case of `#<void>` alone, REPL will not print\nit." negative? "Return `T` if `x` is negative." Instructions "VM instructions mapped to their encoded byte representation." file "Open a file for I/O.\n\nAn `io` object is returned. Without any modes specified the file\nis opened in read-only mode." rand-double "Return a random double on interval [0.0, 1.0]." 1- "Equivalent to `(- n 1)`." atom? "Return `T` if `v` is a _not_ a cons cell, `NIL` otherwise. This is\nthe opposite of `cons?`.\n\nThe term \"atom\" comes from the idea of being indivisible.\n\nExamples:\n\n (atom? \"a\") → T\n (atom? NIL) → T\n (atom? '(1)) → NIL" cdr "Return the second element of a cons cell (tail of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (cdr NIL) → NIL\n (cdr '(1 2 3)) → (2 3)\n (cdr '(1 . 2)) → 2" T "A boolean \"true\".\n\nExamples:\n\n (not T) → NIL\n (if T 'yes 'no) → yes" vec? "Return `T` if `v` is a vector, `NIL` otherwise." equal? "Return `T` if both `a` and `b` are of the same value. For non-leaf\ntypes (cons cell and vector), the equality test is performed\nthroughout the whole structure of the values.\n\nExamples:\n\n (equal? 0.0 0) → NIL\n (equal? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (equal? a b) → T\n (def a '(1))\n (def b '(1))\n (equal?
\ No newline at end of file
*syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref)) doc-for #fn("z10B86;35040<;J404086;35040=863H0202187e2211e22188e2e4:202187e2211e2e3:" #(sym-set-doc-re in non-increasing order (previous\none is greater than or equal to the next one)." sym? "Return `T` if `v` is a symbol, `NIL` otherwise." void? "Return `T` if `x` is `#<void>`, `NIL` otherwise." zero? "Return `T` if `x` is zero." length= "Perform a bounded length test.\n\nUse this instead of `(= (length lst) n)`, since it avoids unnecessary\nwork and always terminates." positive? "Return `T` if `x` is greater than zero." doc-for "Define documentation for a top level term.\n\nIf `term` is a function signature and `doc` is not specified, just\nthe signature will be included in the documentation, without\nreplacing any previously defined." aset! "Modify the sequence element specified by the subscripts and return the\nnew value. The sequence can be an array, vector, a list.\nMulti-dimensional sequences of variating types are also supported.\n\nExamples:\n\n (def a '((1 #(2 (3)) 4)))\n (aset! a 1 'x) → index 1 out of bounds\n (aset! a 0 0 'x) → x\n a → ((x #(2 (3)) 4))\n (aset! a 0 1 9) → 9\n a → ((x #(9 (3)) 4))" car "Return the first element of a cons cell (head of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (car NIL) → NIL\n (car '(1 2 3)) → 1\n (car '(1 . 2)) → 1" *builtins* "VM instructions as closures." str "Convert terms to a concatenated string.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed." cons "Return a cons cell containing two arguments.\n\nExamples:\n\n (cons 1 2) → (1 . 2)\n (cons 1 '(2)) → (1 2)\n (cons 1 (cons 2 (cons 3 NIL))) → (1 2 3)" - "Return the result of subtraction. With only one argument a\nnegation is performed.\n\nExamples:\n\n (- 1.5) → -1.5\n (- 3 2) → 1" remprop "Remove a property value associated with a symbol." <= "Return `T` if the arguments are in non-decreasing order (previous\none is less than or equal to the next one)." rand "Return a random non-negative fixnum on its maximum range." void "Return the constant `#<void>` while ignoring any arguments.\n\n`#<void>` is mainly used when a function has side effects but does not\nproduce any meaningful value to return, so even though `T` or `NIL` could\nbe returned instead, in case of `#<void>` alone, REPL will not print\nit." negative? "Return `T` if `x` is negative." Instructions "VM instructions mapped to their encoded byte representation." file "Open a file for I/O.\n\nAn `io` object is returned. Without any modes specified the file\nis opened in read-only mode." rand-double "Return a random double on interval [0.0, 1.0]." 1- "Equivalent to `(- n 1)`." atom? "Return `T` if `v` is a _not_ a cons cell, `NIL` otherwise. This is\nthe opposite of `cons?`.\n\nThe term \"atom\" comes from the idea of being indivisible.\n\nExamples:\n\n (atom? \"a\") → T\n (atom? NIL) → T\n (atom? '(1)) → NIL" cdr "Return the second element of a cons cell (tail of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (cdr NIL) → NIL\n (cdr '(1 2 3)) → (2 3)\n (cdr '(1 . 2)) → 2" T "A boolean \"true\".\n\nExamples:\n\n (not T) → NIL\n (if T 'yes 'no) → yes" vec? "Return `T` if `v` is a vector, `NIL` otherwise." equal? "Return `T` if both `a` and `b` are of the same value. For non-leaf\ntypes (cons cell and vector), the equality test is performed\nthroughout the whole structure of the values.\n\nExamples:\n\n (equal? 0.0 0) → NIL\n (equal? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (equal? a b) → T\n (def a '(1))\n (def b '(1))\n (equal? a b) → T" / "Return the division of the arguments. With only one argument the\nresult of `1/x` is returned. If the result is integer-valued, it is\nreturned as an integer.\n\nExamples:\n\n (/ 2) → 0.5\n (/ 7 2 2) → 1.75\n (/ 10 -2) → -5 ; a fixnum\n (/ 6.9 1.9) → 3.6315…" eqv? "Return `T` if both `a` and `b` are of the same value and primitive\n(leaf) type, `NIL` oth
\ No newline at end of file
+re in non-increasing order (previous\none is greater than or equal to the next one)." sym? "Return `T` if `v` is a symbol, `NIL` otherwise." void? "Return `T` if `x` is `#<void>`, `NIL` otherwise." zero? "Return `T` if `x` is zero." length= "Perform a bounded length test.\n\nUse this instead of `(= (length lst) n)`, since it avoids unnecessary\nwork and always terminates." positive? "Return `T` if `x` is greater than zero." doc-for "Define documentation for a top level term.\n\nIf `term` is a function signature and `doc` is not specified, just\nthe signature will be included in the documentation, without\nreplacing any previously defined." aset! "Modify the sequence element specified by the subscripts and return the\nnew value. The sequence can be an array, vector, a list.\nMulti-dimensional sequences of variating types are also supported.\n\nExamples:\n\n (def a '((1 #(2 (3)) 4)))\n (aset! a 1 'x) → index 1 out of bounds\n (aset! a 0 0 'x) → x\n a → ((x #(2 (3)) 4))\n (aset! a 0 1 9) → 9\n a → ((x #(9 (3)) 4))" car "Return the first element of a cons cell (head of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (car NIL) → NIL\n (car '(1 2 3)) → 1\n (car '(1 . 2)) → 1" *builtins* "VM instructions as closures." str "Convert terms to a concatenated string.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed." cons "Return a cons cell containing two arguments.\n\nExamples:\n\n (cons 1 2) → (1 . 2)\n (cons 1 '(2)) → (1 2)\n (cons 1 (cons 2 (cons 3 NIL))) → (1 2 3)" - "Return the result of subtraction. With only one argument a\nnegation is performed.\n\nExamples:\n\n (- 1.5) → -1.5\n (- 3 2) → 1" remprop "Remove a property value associated with a symbol." <= "Return `T` if the arguments are in non-decreasing order (previous\none is less than or equal to the next one)." rand "Return a random non-negative fixnum on its maximum range." void "Return the constant `#<void>` while ignoring any arguments.\n\n`#<void>` is mainly used when a function has side effects but does not\nproduce any meaningful value to return, so even though `T` or `NIL` could\nbe returned instead, in case of `#<void>` alone, REPL will not print\nit." negative? "Return `T` if `x` is negative." Instructions "VM instructions mapped to their encoded byte representation." file "Open a file for I/O.\n\nAn `io` object is returned. Without any modes specified the file\nis opened in read-only mode." rand-double "Return a random double on interval [0.0, 1.0]." 1- "Equivalent to `(- n 1)`." atom? "Return `T` if `v` is a _not_ a cons cell, `NIL` otherwise. This is\nthe opposite of `cons?`.\n\nThe term \"atom\" comes from the idea of being indivisible.\n\nExamples:\n\n (atom? \"a\") → T\n (atom? NIL) → T\n (atom? '(1)) → NIL" cdr "Return the second element of a cons cell (tail of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (cdr NIL) → NIL\n (cdr '(1 2 3)) → (2 3)\n (cdr '(1 . 2)) → 2" T "A boolean \"true\".\n\nExamples:\n\n (not T) → NIL\n (if T 'yes 'no) → yes" vec? "Return `T` if `v` is a vector, `NIL` otherwise." equal? "Return `T` if both `a` and `b` are of the same value. For non-leaf\ntypes (cons cell and vector), the equality test is performed\nthroughout the whole structure of the values.\n\nExamples:\n\n (equal? 0.0 0) → NIL\n (equal? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (equal? a b) → T\n (def a '(1))\n (def b '(1))\n (equal? a b) → T" / "Return the division of the arguments. With only one argument the\nresult of `1/x` is returned. If the result is integer-valued, it is\nreturned as an integer.\n\nExamples:\n\n (/ 2) → 0.5\n (/ 7 2 2) → 1.75\n (/ 10 -2) → -5 ; a fixnum\n (/ 6.9 1.9) → 3.6315…" eqv? "Return `T` if both `a` and `b` are of the same value and primitive\n(leaf) type, `NIL` oth
\ No newline at end of file
"Return `T` if `x` is `#<void>`, `NIL` otherwise." zero? "Return `T` if `x` is zero." length= "Perform a bounded length test.\n\nUse this instead of `(= (length lst) n)`, since it avoids unnecessary\nwork and always terminates." positive? "Return `T` if `x` is greater than zero." doc-for "Define documentation for a top level term.\n\nIf `term` is a function signature and `doc` is not specified, just\nthe signature will be included in the documentation, without\nreplacing any previously defined." aset! "Modify the sequence element specified by the subscripts and return the\nnew value. The sequence can be an array, vector, a list.\nMulti-dimensional sequences of variating types are also supported.\n\nExamples:\n\n (def a '((1 #(2 (3)) 4)))\n (aset! a 1 'x) → index 1 out of bounds\n (aset! a 0 0 'x) → x\n a → ((x #(2 (3)) 4))\n (aset! a 0 1 9) → 9\n a → ((x #(9 (3)) 4))" car "Return the first element of a cons cell (head of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (car NIL) → NIL\n (car '(1 2 3)) → 1\n (car '(1 . 2)) → 1" *builtins* "VM instructions as closures." str "Convert terms to a concatenated string.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed." cons "Return a cons cell containing two arguments.\n\nExamples:\n\n (cons 1 2) → (1 . 2)\n (cons 1 '(2)) → (1 2)\n (cons 1 (cons 2 (cons 3 NIL))) → (1 2 3)" - "Return the result of subtraction. With only one argument a\nnegation is performed.\n\nExamples:\n\n (- 1.5) → -1.5\n (- 3 2) → 1" remprop "Remove a property value associated with a symbol." <= "Return `T` if the arguments are in non-decreasing order (previous\none is less than or equal to the next one)." rand "Return a random non-negative fixnum on its maximum range." void "Return the constant `#<void>` while ignoring any arguments.\n\n`#<void>` is mainly used when a function has side effects but does not\nproduce any meaningful value to return, so even though `T` or `NIL` could\nbe returned instead, in case of `#<void>` alone, REPL will not print\nit." negative? "Return `T` if `x` is negative." Instructions "VM instructions mapped to their encoded byte representation." file "Open a file for I/O.\n\nAn `io` object is returned. Without any modes specified the file\nis opened in read-only mode." rand-double "Return a random double on interval [0.0, 1.0]." 1- "Equivalent to `(- n 1)`." atom? "Return `T` if `v` is a _not_ a cons cell, `NIL` otherwise. This is\nthe opposite of `cons?`.\n\nThe term \"atom\" comes from the idea of being indivisible.\n\nExamples:\n\n (atom? \"a\") → T\n (atom? NIL) → T\n (atom? '(1)) → NIL" cdr "Return the second element of a cons cell (tail of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (cdr NIL) → NIL\n (cdr '(1 2 3)) → (2 3)\n (cdr '(1 . 2)) → 2" T "A boolean \"true\".\n\nExamples:\n\n (not T) → NIL\n (if T 'yes 'no) → yes" vec? "Return `T` if `v` is a vector, `NIL` otherwise." equal? "Return `T` if both `a` and `b` are of the same value. For non-leaf\ntypes (cons cell and vector), the equality test is performed\nthroughout the whole structure of the values.\n\nExamples:\n\n (equal? 0.0 0) → NIL\n (equal? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (equal? a b) → T\n (def a '(1))\n (def b '(1))\n (equal? a b) → T" / "Return the division of the arguments. With only one argument the\nresult of `1/x` is returned. If the result is integer-valued, it is\nreturned as an integer.\n\nExamples:\n\n (/ 2) → 0.5\n (/ 7 2 2) → 1.75\n (/ 10 -2) → -5 ; a fixnum\n (/ 6.9 1.9) → 3.6315…" eqv? "Return `T` if both `a` and `b` are of the same value and primitive\n(leaf) type, `NIL` otherwise. Neither cons cell nor vector are not\nconsidered primitive types as they may define deep structures.\n\nExamples:\n\n (eqv? 0.0 0) → N
\ No newline at end of file
*syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref)) doc-for #fn("z10B86;35040<;J404086;35040=863H0202187e2211e22188e2e4:202187e2211e2e3:" #(sym-set-doc quote)) with-input-from #fn("z12021e1220e2e1e12315163:" #(#fn(nconc) with-bindings *io-in* #fn(copy-list))) unless #fn("z1200q211Pe4:" #(if@@ -57,7 +57,7 @@
modes specified the file\nis opened in read-only mode." rand-double "Return a random double on interval [0.0, 1.0]." 1- "Equivalent to `(- n 1)`." atom? "Return `T` if `v` is a _not_ a cons cell, `NIL` otherwise. This is\nthe opposite of `cons?`.\n\nThe term \"atom\" comes from the idea of being indivisible.\n\nExamples:\n\n (atom? \"a\") → T\n (atom? NIL) → T\n (atom? '(1)) → NIL" cdr "Return the second element of a cons cell (tail of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (cdr NIL) → NIL\n (cdr '(1 2 3)) → (2 3)\n (cdr '(1 . 2)) → 2" T "A boolean \"true\".\n\nExamples:\n\n (not T) → NIL\n (if T 'yes 'no) → yes" vec? "Return `T` if `v` is a vector, `NIL` otherwise." equal? "Return `T` if both `a` and `b` are of the same value. For non-leaf\ntypes (cons cell and vector), the equality test is performed\nthroughout the whole structure of the values.\n\nExamples:\n\n (equal? 0.0 0) → NIL\n (equal? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (equal? a b) → T\n (def a '(1))\n (def b '(1))\n (equal? a b) → T" / "Return the division of the arguments. With only one argument the\nresult of `1/x` is returned. If the result is integer-valued, it is\nreturned as an integer.\n\nExamples:\n\n (/ 2) → 0.5\n (/ 7 2 2) → 1.75\n (/ 10 -2) → -5 ; a fixnum\n (/ 6.9 1.9) → 3.6315…" eqv? "Return `T` if both `a` and `b` are of the same value and primitive\n(leaf) type, `NIL` otherwise. Neither cons cell nor vector are not\nconsidered primitive types as they may define deep structures.\n\nExamples:\n\n (eqv? 0.0 0) → NIL\n (eqv? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eqv? a b) → T\n (def a '(1))\n (def b '(1))\n (eqv? a b) → NIL" io? "Return `T` if `term` is of `io` type, `NIL` otherwise." eof-object? "Return `T` if `term` is `#<eof>`, `NIL` otherwise.\n\nThis object is returned by I/O functions to signal end of file,\nwhere applicable." list "Return a list constructed of the arguments.\n\nExamples:\n\n (list) → NIL ; empty list\n (list 1 2.5 \"a\" 'b) → (1 2.5 \"a\" b)" apply "Return the result of applying a function to a list of arguments.\n\nThe last argument must always be a list which gets spliced as\narguments to the function.\n\nExamples:\n\n (apply + 1 2 '(3 4 5)) → 15\n (apply vec '(1 2 3)) → #(3 4 5)\n (apply arr 'u8 '(3 4 5)) → #vu8(3 4 5)" help "Display documentation for the specified term, if available." rand-u32 "Return a random integer on interval [0, 2³²-1]." = "Numerical equality test. Return `T` if all numbers are equal,\n`NIL` otherwise." rand-u64 "Return a random integer on interval [0, 2⁶⁴-1]." not "Return `T` if `v` is `NIL`, `T` otherwise." NIL "An empty list. Also used as the opposite of T.\n\nExamples:\n\n (not NIL) → T\n (if NIL 'yes 'no) → no\n (car NIL) → NIL\n (cdr NIL) → NIL" set-cdr! "Modify a cons cell (a list) in-place by putting `new-second` as its\nsecond element (tail of the list). Return the modified cons\ncell (list).\n\nExamples:\n\n (def q '(1 2 3 4 5))\n (set-cdr! q '(6 7)) → (1 6 7)\n q → (1 6 7)" /= "Return `T` if not all arguments are equal. Shorthand for `(not (= …))`." fn? "Return `T` if `v` is a function, `NIL` otherwise.\n\nExamples:\n\n (fn? map) → T\n (fn? macroexpand) → T" help-print-header "Format and print term's signature(s) for `(help term)` output." lz-pack "Return data compressed using Lempel-Ziv.\n\nThe data must be an array, returned value will have the same type.\nThe optional `level` is between `0` and `10`. With `level` set to\n`0` a simple LZSS using hashing will be performed. Levels between\n`1` and `9` offer a trade-off between time/space and ratio. Level\n`10` is optimal but very slow." arg-counts "VM instructions mapped to their expected arguments count." *prompt* "Function called by REPL to signal the user input is requi
\ No newline at end of file
*syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref)) doc-for #fn("z10B86;35040<;J404086;35040=863H0202187e2211e22188e2e4:202187e2211e2e3:" #(sym-set-doc quote)) with-input-from #fn("z12021e1220e2e1e12315163:" #(#fn(nconc) with-bindings *io-in* #fn(copy-list))) unless #fn("z1200q211Pe4:" #(if- → T\n (atom? '(1)) → NIL" cdr "Return the second element of a cons cell (tail of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (cdr NIL) → NIL\n (cdr '(1 2 3)) → (2 3)\n (cdr '(1 . 2)) → 2" T "A boolean \"true\".\n\nExamples:\n\n (not T) → NIL\n (if T 'yes 'no) → yes" vec? "Return `T` if `v` is a vector, `NIL` otherwise." equal? "Return `T` if both `a` and `b` are of the same value. For non-leaf\ntypes (cons cell and vector), the equality test is performed\nthroughout the whole structure of the values.\n\nExamples:\n\n (equal? 0.0 0) → NIL\n (equal? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (equal? a b) → T\n (def a '(1))\n (def b '(1))\n (equal? a b) → T" / "Return the division of the arguments. With only one argument the\nresult of `1/x` is returned. If the result is integer-valued, it is\nreturned as an integer.\n\nExamples:\n\n (/ 2) → 0.5\n (/ 7 2 2) → 1.75\n (/ 10 -2) → -5 ; a fixnum\n (/ 6.9 1.9) → 3.6315…" eqv? "Return `T` if both `a` and `b` are of the same value and primitive\n(leaf) type, `NIL` otherwise. Neither cons cell nor vector are not\nconsidered primitive types as they may define deep structures.\n\nExamples:\n\n (eqv? 0.0 0) → NIL\n (eqv? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eqv? a b) → T\n (def a '(1))\n (def b '(1))\n (eqv? a b) → NIL" io? "Return `T` if `term` is of `io` type, `NIL` otherwise." eof-object? "Return `T` if `term` is `#<eof>`, `NIL` otherwise.\n\nThis object is returned by I/O functions to signal end of file,\nwhere applicable." list "Return a list constructed of the arguments.\n\nExamples:\n\n (list) → NIL ; empty list\n (list 1 2.5 \"a\" 'b) → (1 2.5 \"a\" b)" apply "Return the result of applying a function to a list of arguments.\n\nThe last argument must always be a list which gets spliced as\narguments to the function.\n\nExamples:\n\n (apply + 1 2 '(3 4 5)) → 15\n (apply vec '(1 2 3)) → #(3 4 5)\n (apply arr 'u8 '(3 4 5)) → #vu8(3 4 5)" help "Display documentation for the specified term, if available." rand-u32 "Return a random integer on interval [0, 2³²-1]." = "Numerical equality test. Return `T` if all numbers are equal,\n`NIL` otherwise." rand-u64 "Return a random integer on interval [0, 2⁶⁴-1]." not "Return `T` if `v` is `NIL`, `T` otherwise." NIL "An empty list. Also used as the opposite of T.\n\nExamples:\n\n (not NIL) → T\n (if NIL 'yes 'no) → no\n (car NIL) → NIL\n (cdr NIL) → NIL" set-cdr! "Modify a cons cell (a list) in-place by putting `new-second` as its\nsecond element (tail of the list). Return the modified cons\ncell (list).\n\nExamples:\n\n (def q '(1 2 3 4 5))\n (set-cdr! q '(6 7)) → (1 6 7)\n q → (1 6 7)" /= "Return `T` if not all arguments are equal. Shorthand for `(not (= …))`." fn? "Return `T` if `v` is a function, `NIL` otherwise.\n\nExamples:\n\n (fn? map) → T\n (fn? macroexpand) → T" help-print-header "Format and print term's signature(s) for `(help term)` output." lz-pack "Return data compressed using Lempel-Ziv.\n\nThe data must be an array, returned value will have the same type.\nThe optional `level` is between `0` and `10`. With `level` set to\n`0` a simple LZSS using hashing will be performed. Levels between\n`1` and `9` offer a trade-off between time/space and ratio. Level\n`10` is optimal but very slow." arg-counts "VM instructions mapped to their expected arguments count." *prompt* "Function called by REPL to signal the user input is required.\n\nDefault function prints `#;> `." eq? "Return `T` if `a` and `b` are the same object, `NIL` otherwise.\n\nExamples:\n\n (eq? 0.0 0) → NIL\n (eq? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eq? a b) → NIL\n (def a '(1))\n (def b '(1))\n (eq? a b) → NIL" getprop "Get a property value associated with a symbol or `def` if missin
\ No newline at end of file
+ → T\n (atom? '(1)) → NIL" cdr "Return the second element of a cons cell (tail of a list) or `NIL` if\nnot available.\n\nExamples:\n\n (cdr NIL) → NIL\n (cdr '(1 2 3)) → (2 3)\n (cdr '(1 . 2)) → 2" T "A boolean \"true\".\n\nExamples:\n\n (not T) → NIL\n (if T 'yes 'no) → yes" vec? "Return `T` if `v` is a vector, `NIL` otherwise." equal? "Return `T` if both `a` and `b` are of the same value. For non-leaf\ntypes (cons cell and vector), the equality test is performed\nthroughout the whole structure of the values.\n\nExamples:\n\n (equal? 0.0 0) → NIL\n (equal? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (equal? a b) → T\n (def a '(1))\n (def b '(1))\n (equal? a b) → T" / "Return the division of the arguments. With only one argument the\nresult of `1/x` is returned. If the result is integer-valued, it is\nreturned as an integer.\n\nExamples:\n\n (/ 2) → 0.5\n (/ 7 2 2) → 1.75\n (/ 10 -2) → -5 ; a fixnum\n (/ 6.9 1.9) → 3.6315…" eqv? "Return `T` if both `a` and `b` are of the same value and primitive\n(leaf) type, `NIL` otherwise. Neither cons cell nor vector are not\nconsidered primitive types as they may define deep structures.\n\nExamples:\n\n (eqv? 0.0 0) → NIL\n (eqv? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eqv? a b) → T\n (def a '(1))\n (def b '(1))\n (eqv? a b) → NIL" io? "Return `T` if `term` is of `io` type, `NIL` otherwise." eof-object? "Return `T` if `term` is `#<eof>`, `NIL` otherwise.\n\nThis object is returned by I/O functions to signal end of file,\nwhere applicable." list "Return a list constructed of the arguments.\n\nExamples:\n\n (list) → NIL ; empty list\n (list 1 2.5 \"a\" 'b) → (1 2.5 \"a\" b)" apply "Return the result of applying a function to a list of arguments.\n\nThe last argument must always be a list which gets spliced as\narguments to the function.\n\nExamples:\n\n (apply + 1 2 '(3 4 5)) → 15\n (apply vec '(1 2 3)) → #(3 4 5)\n (apply arr 'u8 '(3 4 5)) → #vu8(3 4 5)" help "Display documentation for the specified term, if available." rand-u32 "Return a random integer on interval [0, 2³²-1]." = "Numerical equality test. Return `T` if all numbers are equal,\n`NIL` otherwise." rand-u64 "Return a random integer on interval [0, 2⁶⁴-1]." not "Return `T` if `v` is `NIL`, `T` otherwise." NIL "An empty list. Also used as the opposite of T.\n\nExamples:\n\n (not NIL) → T\n (if NIL 'yes 'no) → no\n (car NIL) → NIL\n (cdr NIL) → NIL" set-cdr! "Modify a cons cell (a list) in-place by putting `new-second` as its\nsecond element (tail of the list). Return the modified cons\ncell (list).\n\nExamples:\n\n (def q '(1 2 3 4 5))\n (set-cdr! q '(6 7)) → (1 6 7)\n q → (1 6 7)" /= "Return `T` if not all arguments are equal. Shorthand for `(not (= …))`." fn? "Return `T` if `v` is a function, `NIL` otherwise.\n\nExamples:\n\n (fn? map) → T\n (fn? macroexpand) → T" help-print-header "Format and print term's signature(s) for `(help term)` output." lz-pack "Return data compressed using Lempel-Ziv.\n\nThe data must be an array, returned value will have the same type.\nThe optional `level` is between `0` and `10`. With `level` set to\n`0` a simple LZSS using hashing will be performed. Levels between\n`1` and `9` offer a trade-off between time/space and ratio. Level\n`10` is optimal but very slow." arg-counts "VM instructions mapped to their expected arguments count." *prompt* "Function called by REPL to signal the user input is required.\n\nDefault function prints `#;> `." eq? "Return `T` if `a` and `b` are the same object, `NIL` otherwise.\n\nExamples:\n\n (eq? 0.0 0) → NIL\n (eq? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eq? a b) → NIL\n (def a '(1))\n (def b '(1))\n (eq? a b) → NIL" getprop "Get a property value associated with a symbol or `def` if missin
\ No newline at end of file
1 2 3)) → (2 3)\n (cdr '(1 . 2)) → 2" T "A boolean \"true\".\n\nExamples:\n\n (not T) → NIL\n (if T 'yes 'no) → yes" vec? "Return `T` if `v` is a vector, `NIL` otherwise." equal? "Return `T` if both `a` and `b` are of the same value. For non-leaf\ntypes (cons cell and vector), the equality test is performed\nthroughout the whole structure of the values.\n\nExamples:\n\n (equal? 0.0 0) → NIL\n (equal? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (equal? a b) → T\n (def a '(1))\n (def b '(1))\n (equal? a b) → T" / "Return the division of the arguments. With only one argument the\nresult of `1/x` is returned. If the result is integer-valued, it is\nreturned as an integer.\n\nExamples:\n\n (/ 2) → 0.5\n (/ 7 2 2) → 1.75\n (/ 10 -2) → -5 ; a fixnum\n (/ 6.9 1.9) → 3.6315…" eqv? "Return `T` if both `a` and `b` are of the same value and primitive\n(leaf) type, `NIL` otherwise. Neither cons cell nor vector are not\nconsidered primitive types as they may define deep structures.\n\nExamples:\n\n (eqv? 0.0 0) → NIL\n (eqv? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eqv? a b) → T\n (def a '(1))\n (def b '(1))\n (eqv? a b) → NIL" io? "Return `T` if `term` is of `io` type, `NIL` otherwise." eof-object? "Return `T` if `term` is `#<eof>`, `NIL` otherwise.\n\nThis object is returned by I/O functions to signal end of file,\nwhere applicable." list "Return a list constructed of the arguments.\n\nExamples:\n\n (list) → NIL ; empty list\n (list 1 2.5 \"a\" 'b) → (1 2.5 \"a\" b)" apply "Return the result of applying a function to a list of arguments.\n\nThe last argument must always be a list which gets spliced as\narguments to the function.\n\nExamples:\n\n (apply + 1 2 '(3 4 5)) → 15\n (apply vec '(1 2 3)) → #(3 4 5)\n (apply arr 'u8 '(3 4 5)) → #vu8(3 4 5)" help "Display documentation for the specified term, if available." rand-u32 "Return a random integer on interval [0, 2³²-1]." = "Numerical equality test. Return `T` if all numbers are equal,\n`NIL` otherwise." rand-u64 "Return a random integer on interval [0, 2⁶⁴-1]." not "Return `T` if `v` is `NIL`, `T` otherwise." NIL "An empty list. Also used as the opposite of T.\n\nExamples:\n\n (not NIL) → T\n (if NIL 'yes 'no) → no\n (car NIL) → NIL\n (cdr NIL) → NIL" set-cdr! "Modify a cons cell (a list) in-place by putting `new-second` as its\nsecond element (tail of the list). Return the modified cons\ncell (list).\n\nExamples:\n\n (def q '(1 2 3 4 5))\n (set-cdr! q '(6 7)) → (1 6 7)\n q → (1 6 7)" /= "Return `T` if not all arguments are equal. Shorthand for `(not (= …))`." fn? "Return `T` if `v` is a function, `NIL` otherwise.\n\nExamples:\n\n (fn? map) → T\n (fn? macroexpand) → T" help-print-header "Format and print term's signature(s) for `(help term)` output." lz-pack "Return data compressed using Lempel-Ziv.\n\nThe data must be an array, returned value will have the same type.\nThe optional `level` is between `0` and `10`. With `level` set to\n`0` a simple LZSS using hashing will be performed. Levels between\n`1` and `9` offer a trade-off between time/space and ratio. Level\n`10` is optimal but very slow." arg-counts "VM instructions mapped to their expected arguments count." *prompt* "Function called by REPL to signal the user input is required.\n\nDefault function prints `#;> `." eq? "Return `T` if `a` and `b` are the same object, `NIL` otherwise.\n\nExamples:\n\n (eq? 0.0 0) → NIL\n (eq? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eq? a b) → NIL\n (def a '(1))\n (def b '(1))\n (eq? a b) → NIL" getprop "Get a property value associated with a symbol or `def` if missing." vm-stats "Print various VM-related information, such as the number of GC\ncalls so far, heap and stack size, etc." * "Return product of the arguments or `1` when none specifie
\ No newline at end of file
*syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref)) doc-for #fn("z10B86;35040<;J404086;35040=863H0202187e2211e22188e2e4:202187e2211e2e3:" #(sym-set-doc quote)) with-input-from #fn("z12021e1220e2e1e12315163:" #(#fn(nconc) with-bindings *io-in* #fn(copy-list))) unless #fn("z1200q211Pe4:" #(if@@ -66,7 +66,7 @@
ne argument the\nresult of `1/x` is returned. If the result is integer-valued, it is\nreturned as an integer.\n\nExamples:\n\n (/ 2) → 0.5\n (/ 7 2 2) → 1.75\n (/ 10 -2) → -5 ; a fixnum\n (/ 6.9 1.9) → 3.6315…" eqv? "Return `T` if both `a` and `b` are of the same value and primitive\n(leaf) type, `NIL` otherwise. Neither cons cell nor vector are not\nconsidered primitive types as they may define deep structures.\n\nExamples:\n\n (eqv? 0.0 0) → NIL\n (eqv? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eqv? a b) → T\n (def a '(1))\n (def b '(1))\n (eqv? a b) → NIL" io? "Return `T` if `term` is of `io` type, `NIL` otherwise." eof-object? "Return `T` if `term` is `#<eof>`, `NIL` otherwise.\n\nThis object is returned by I/O functions to signal end of file,\nwhere applicable." list "Return a list constructed of the arguments.\n\nExamples:\n\n (list) → NIL ; empty list\n (list 1 2.5 \"a\" 'b) → (1 2.5 \"a\" b)" apply "Return the result of applying a function to a list of arguments.\n\nThe last argument must always be a list which gets spliced as\narguments to the function.\n\nExamples:\n\n (apply + 1 2 '(3 4 5)) → 15\n (apply vec '(1 2 3)) → #(3 4 5)\n (apply arr 'u8 '(3 4 5)) → #vu8(3 4 5)" help "Display documentation for the specified term, if available." rand-u32 "Return a random integer on interval [0, 2³²-1]." = "Numerical equality test. Return `T` if all numbers are equal,\n`NIL` otherwise." rand-u64 "Return a random integer on interval [0, 2⁶⁴-1]." not "Return `T` if `v` is `NIL`, `T` otherwise." NIL "An empty list. Also used as the opposite of T.\n\nExamples:\n\n (not NIL) → T\n (if NIL 'yes 'no) → no\n (car NIL) → NIL\n (cdr NIL) → NIL" set-cdr! "Modify a cons cell (a list) in-place by putting `new-second` as its\nsecond element (tail of the list). Return the modified cons\ncell (list).\n\nExamples:\n\n (def q '(1 2 3 4 5))\n (set-cdr! q '(6 7)) → (1 6 7)\n q → (1 6 7)" /= "Return `T` if not all arguments are equal. Shorthand for `(not (= …))`." fn? "Return `T` if `v` is a function, `NIL` otherwise.\n\nExamples:\n\n (fn? map) → T\n (fn? macroexpand) → T" help-print-header "Format and print term's signature(s) for `(help term)` output." lz-pack "Return data compressed using Lempel-Ziv.\n\nThe data must be an array, returned value will have the same type.\nThe optional `level` is between `0` and `10`. With `level` set to\n`0` a simple LZSS using hashing will be performed. Levels between\n`1` and `9` offer a trade-off between time/space and ratio. Level\n`10` is optimal but very slow." arg-counts "VM instructions mapped to their expected arguments count." *prompt* "Function called by REPL to signal the user input is required.\n\nDefault function prints `#;> `." eq? "Return `T` if `a` and `b` are the same object, `NIL` otherwise.\n\nExamples:\n\n (eq? 0.0 0) → NIL\n (eq? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eq? a b) → NIL\n (def a '(1))\n (def b '(1))\n (eq? a b) → NIL" getprop "Get a property value associated with a symbol or `def` if missing." vm-stats "Print various VM-related information, such as the number of GC\ncalls so far, heap and stack size, etc." * "Return product of the arguments or `1` when none specified." putprop "Associate a property value with a symbol." io->str "Return an in-memory `io` buffer converted to a string."))
*syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref)) doc-for #fn("z10B86;35040<;J404086;35040=863H0202187e2211e22188e2e4:202187e2211e2e3:" #(sym-set-doc quote)) with-input-from #fn("z12021e1220e2e1e12315163:" #(#fn(nconc) with-bindings *io-in* #fn(copy-list))) unless #fn("z1200q211Pe4:" #(if-imitive\n(leaf) type, `NIL` otherwise. Neither cons cell nor vector are not\nconsidered primitive types as they may define deep structures.\n\nExamples:\n\n (eqv? 0.0 0) → NIL\n (eqv? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eqv? a b) → T\n (def a '(1))\n (def b '(1))\n (eqv? a b) → NIL" io? "Return `T` if `term` is of `io` type, `NIL` otherwise." eof-object? "Return `T` if `term` is `#<eof>`, `NIL` otherwise.\n\nThis object is returned by I/O functions to signal end of file,\nwhere applicable." list "Return a list constructed of the arguments.\n\nExamples:\n\n (list) → NIL ; empty list\n (list 1 2.5 \"a\" 'b) → (1 2.5 \"a\" b)" apply "Return the result of applying a function to a list of arguments.\n\nThe last argument must always be a list which gets spliced as\narguments to the function.\n\nExamples:\n\n (apply + 1 2 '(3 4 5)) → 15\n (apply vec '(1 2 3)) → #(3 4 5)\n (apply arr 'u8 '(3 4 5)) → #vu8(3 4 5)" help "Display documentation for the specified term, if available." rand-u32 "Return a random integer on interval [0, 2³²-1]." = "Numerical equality test. Return `T` if all numbers are equal,\n`NIL` otherwise." rand-u64 "Return a random integer on interval [0, 2⁶⁴-1]." not "Return `T` if `v` is `NIL`, `T` otherwise." NIL "An empty list. Also used as the opposite of T.\n\nExamples:\n\n (not NIL) → T\n (if NIL 'yes 'no) → no\n (car NIL) → NIL\n (cdr NIL) → NIL" set-cdr! "Modify a cons cell (a list) in-place by putting `new-second` as its\nsecond element (tail of the list). Return the modified cons\ncell (list).\n\nExamples:\n\n (def q '(1 2 3 4 5))\n (set-cdr! q '(6 7)) → (1 6 7)\n q → (1 6 7)" /= "Return `T` if not all arguments are equal. Shorthand for `(not (= …))`." fn? "Return `T` if `v` is a function, `NIL` otherwise.\n\nExamples:\n\n (fn? map) → T\n (fn? macroexpand) → T" help-print-header "Format and print term's signature(s) for `(help term)` output." lz-pack "Return data compressed using Lempel-Ziv.\n\nThe data must be an array, returned value will have the same type.\nThe optional `level` is between `0` and `10`. With `level` set to\n`0` a simple LZSS using hashing will be performed. Levels between\n`1` and `9` offer a trade-off between time/space and ratio. Level\n`10` is optimal but very slow." arg-counts "VM instructions mapped to their expected arguments count." *prompt* "Function called by REPL to signal the user input is required.\n\nDefault function prints `#;> `." eq? "Return `T` if `a` and `b` are the same object, `NIL` otherwise.\n\nExamples:\n\n (eq? 0.0 0) → NIL\n (eq? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eq? a b) → NIL\n (def a '(1))\n (def b '(1))\n (eq? a b) → NIL" getprop "Get a property value associated with a symbol or `def` if missing." vm-stats "Print various VM-related information, such as the number of GC\ncalls so far, heap and stack size, etc." * "Return product of the arguments or `1` when none specified." putprop "Associate a property value with a symbol." io->str "Return an in-memory `io` buffer converted to a string."))
+imitive\n(leaf) type, `NIL` otherwise. Neither cons cell nor vector are not\nconsidered primitive types as they may define deep structures.\n\nExamples:\n\n (eqv? 0.0 0) → NIL\n (eqv? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eqv? a b) → T\n (def a '(1))\n (def b '(1))\n (eqv? a b) → NIL" io? "Return `T` if `term` is of `io` type, `NIL` otherwise." eof-object? "Return `T` if `term` is `#<eof>`, `NIL` otherwise.\n\nThis object is returned by I/O functions to signal end of file,\nwhere applicable." list "Return a list constructed of the arguments.\n\nExamples:\n\n (list) → NIL ; empty list\n (list 1 2.5 \"a\" 'b) → (1 2.5 \"a\" b)" apply "Return the result of applying a function to a list of arguments.\n\nThe last argument must always be a list which gets spliced as\narguments to the function.\n\nExamples:\n\n (apply + 1 2 '(3 4 5)) → 15\n (apply vec '(1 2 3)) → #(3 4 5)\n (apply arr 'u8 '(3 4 5)) → #vu8(3 4 5)" help "Display documentation for the specified term, if available." rand-u32 "Return a random integer on interval [0, 2³²-1]." = "Numerical equality test. Return `T` if all numbers are equal,\n`NIL` otherwise." rand-u64 "Return a random integer on interval [0, 2⁶⁴-1]." not "Return `T` if `v` is `NIL`, `T` otherwise." NIL "An empty list. Also used as the opposite of T.\n\nExamples:\n\n (not NIL) → T\n (if NIL 'yes 'no) → no\n (car NIL) → NIL\n (cdr NIL) → NIL" set-cdr! "Modify a cons cell (a list) in-place by putting `new-second` as its\nsecond element (tail of the list). Return the modified cons\ncell (list).\n\nExamples:\n\n (def q '(1 2 3 4 5))\n (set-cdr! q '(6 7)) → (1 6 7)\n q → (1 6 7)" /= "Return `T` if not all arguments are equal. Shorthand for `(not (= …))`." fn? "Return `T` if `v` is a function, `NIL` otherwise.\n\nExamples:\n\n (fn? map) → T\n (fn? macroexpand) → T" help-print-header "Format and print term's signature(s) for `(help term)` output." lz-pack "Return data compressed using Lempel-Ziv.\n\nThe data must be an array, returned value will have the same type.\nThe optional `level` is between `0` and `10`. With `level` set to\n`0` a simple LZSS using hashing will be performed. Levels between\n`1` and `9` offer a trade-off between time/space and ratio. Level\n`10` is optimal but very slow." arg-counts "VM instructions mapped to their expected arguments count." *prompt* "Function called by REPL to signal the user input is required.\n\nDefault function prints `#;> `." eq? "Return `T` if `a` and `b` are the same object, `NIL` otherwise.\n\nExamples:\n\n (eq? 0.0 0) → NIL\n (eq? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eq? a b) → NIL\n (def a '(1))\n (def b '(1))\n (eq? a b) → NIL" getprop "Get a property value associated with a symbol or `def` if missing." vm-stats "Print various VM-related information, such as the number of GC\ncalls so far, heap and stack size, etc." * "Return product of the arguments or `1` when none specified." putprop "Associate a property value with a symbol." io->str "Return an in-memory `io` buffer converted to a string."))
es as they may define deep structures.\n\nExamples:\n\n (eqv? 0.0 0) → NIL\n (eqv? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eqv? a b) → T\n (def a '(1))\n (def b '(1))\n (eqv? a b) → NIL" io? "Return `T` if `term` is of `io` type, `NIL` otherwise." eof-object? "Return `T` if `term` is `#<eof>`, `NIL` otherwise.\n\nThis object is returned by I/O functions to signal end of file,\nwhere applicable." list "Return a list constructed of the arguments.\n\nExamples:\n\n (list) → NIL ; empty list\n (list 1 2.5 \"a\" 'b) → (1 2.5 \"a\" b)" apply "Return the result of applying a function to a list of arguments.\n\nThe last argument must always be a list which gets spliced as\narguments to the function.\n\nExamples:\n\n (apply + 1 2 '(3 4 5)) → 15\n (apply vec '(1 2 3)) → #(3 4 5)\n (apply arr 'u8 '(3 4 5)) → #vu8(3 4 5)" help "Display documentation for the specified term, if available." rand-u32 "Return a random integer on interval [0, 2³²-1]." = "Numerical equality test. Return `T` if all numbers are equal,\n`NIL` otherwise." rand-u64 "Return a random integer on interval [0, 2⁶⁴-1]." not "Return `T` if `v` is `NIL`, `T` otherwise." NIL "An empty list. Also used as the opposite of T.\n\nExamples:\n\n (not NIL) → T\n (if NIL 'yes 'no) → no\n (car NIL) → NIL\n (cdr NIL) → NIL" set-cdr! "Modify a cons cell (a list) in-place by putting `new-second` as its\nsecond element (tail of the list). Return the modified cons\ncell (list).\n\nExamples:\n\n (def q '(1 2 3 4 5))\n (set-cdr! q '(6 7)) → (1 6 7)\n q → (1 6 7)" /= "Return `T` if not all arguments are equal. Shorthand for `(not (= …))`." fn? "Return `T` if `v` is a function, `NIL` otherwise.\n\nExamples:\n\n (fn? map) → T\n (fn? macroexpand) → T" help-print-header "Format and print term's signature(s) for `(help term)` output." lz-pack "Return data compressed using Lempel-Ziv.\n\nThe data must be an array, returned value will have the same type.\nThe optional `level` is between `0` and `10`. With `level` set to\n`0` a simple LZSS using hashing will be performed. Levels between\n`1` and `9` offer a trade-off between time/space and ratio. Level\n`10` is optimal but very slow." arg-counts "VM instructions mapped to their expected arguments count." *prompt* "Function called by REPL to signal the user input is required.\n\nDefault function prints `#;> `." eq? "Return `T` if `a` and `b` are the same object, `NIL` otherwise.\n\nExamples:\n\n (eq? 0.0 0) → NIL\n (eq? 0 0) → T\n (def a \"1\")\n (def b \"1\")\n (eq? a b) → NIL\n (def a '(1))\n (def b '(1))\n (eq? a b) → NIL" getprop "Get a property value associated with a symbol or `def` if missing." vm-stats "Print various VM-related information, such as the number of GC\ncalls so far, heap and stack size, etc." * "Return product of the arguments or `1` when none specified." putprop "Associate a property value with a symbol." io->str "Return an in-memory `io` buffer converted to a string."))
*syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref)) doc-for #fn("z10B86;35040<;J404086;35040=863H0202187e2211e22188e2e4:202187e2211e2e3:" #(sym-set-doc quote)) with-input-from #fn("z12021e1220e2e1e12315163:" #(#fn(nconc) with-bindings *io-in* #fn(copy-list))) unless #fn("z1200q211Pe4:" #(if@@ -239,7 +239,7 @@
n("n483<83=0r4G88T70018953718;727388518;528:537408=524258=1<521=P7608>827388515440r40r4G8<UMp4E8<L23A082J<0770288<63:q:" #(compile-arglistvars-to-env complex-bindings caddr box-vars #fn(nconc) compile-in emit shift) compile-let)
compile-or #fn("n470018283q21q67:" #(compile-short-circuit brnn) compile-or)-#(compile-short-circuit brnn) compile-or)
+#(compile-short-circuit brnn) compile-or)
fn("n470821E538821CF07201q83544730248263:88<El288=T893<07588=51@9076082528:3o07308937027@40288;5340r40r4GKMp47201q835440r40r4Gr/Mp47302962:7201q8354489360q@>07:2;2<82525147302=8;63:" #(lookup-symglobal compile-in emit setg vinfo:index capture-var! loada loadc set-car! error #fn(str)
"internal error: misallocated var " seta) compile-set!)
@@ -280,7 +280,7 @@
2912:52893D02;82<L23:089T?1@30q^142912<52893D02;82<L23:089T?1@30q^1412=C\\0822>d3=02??14q?2@F0822@d3=02A?14q?2@30q@30q412BC\\0822>d3=02C?14q?2@F0822@d3=02D?14q?2@30q@30q488<12EQ;3b04892FCB00E82<2G88=PPp@J0892HCB00E82<2I88=PPp@30q;J@040E7J182P8852p^140:" #(#0#
#fn("n17002162:" #(member (load0 load1 loadt loadf loadnil loadvoid)) load?) car cdr cadr pop #fn(memq)(loadv loadg setg) bcode:indexfor #fn(assq) ((loadv loadv.l) (loadg loadg.l) (setg setg.l) (loada
-d0 load1 loadt loadf loadnil loadvoid)) load?) car cdr cadr pop #fn(memq)
+r (load0 load1 loadt loadf loadnil loadvoid)) load?) car cdr cadr pop #fn(memq)
(loadv loadv.l) (loadg loadg.l) (setg setg.l) (loada
loada.l)
(seta seta.l) (box box.l)) 255 ((loadc
@@ -295,7 +295,7 @@
.42O2P8<878:>38;5242Q8<61:" #(reverse!
list->vec >= #fn(length) 65536 #fn(table) #fn(buffer) label #fn(put!)
#fn(sizeof) #fn(io-write) #fn(get) Instructions jmp jmp.l brne brne.l brnn brnn.l brn brn.l #fn(memq)
- keyargs)
+ keyargs)
#fn(get)))
#fn(io->str)) encode-byte-code)
error #fn("z020210P61:" #(#fn(raise) error) error) eval@@ -335,13 +335,12 @@
#fn("n170A0P5147160:" #(printnewline)) print newline) help-print-header)
hex5 #fn("n170210r@52r52263:" #(str-lpad #fn(num->str) #\0) hex5) identity-ty) in-env? #fn("n21B;3F042001<52;J:047101=62:" #(#fn(assq)+ identity) in-env? #fn("n21B;3F042001<52;J:047101=62:" #(#fn(assq)in-env?) in-env?)
index-of #fn("n31J40q:01<C5082:7001=82KM63:" #(index-of) index-of) inlineable? #fn("n10<85B;3u047085<51;3i047185T51;3]04727385T52;3O047485T2552S;3@047685T270=5162:" #(lambda?list? every sym? length> 255 length= #fn(length)) inlineable?)
-uffer)
- #fn(io-copy)
+61:" #(#fn(buffer)
#fn(io->str)) io-readall)
io-readline #fn("n12002162:" #(#fn(io-readuntil) #\newline) io-readline) io-readlines #fn("n17071062:" #(read-all-of io-readline) io-readlines) iota #fn("n17071062:" #(map-int@@ -454,7 +453,7 @@
9>38762:" #(#0#
#fn("n32005182P2105121151C?022232487e361:25051E76278851512888A187>4|:" #(#fn(fn-name)#fn(fn-code)
- ffound #fn(fn-vals) 1-
+ ffound #fn(fn-vals) 1-
#fn(length)
#fn("n170A0G513>0F<A0G929363:q:" #(closure?))) find-in-f) #fn("n220A01>321{863E0722374758651522662:27:" #(#fn("n02021AF>292524q:" #(#fn(for-each)--- a/src/compiler.lsp
+++ b/src/compiler.lsp
@@ -1,6 +1,6 @@
;; code generation state, constant tables, bytecode encoding
-(def (make-code-emitter) (vec () (table) 0 () 0))
+(def (make-code-emitter) (vec NIL (table) 0 NIL 0))
(defmacro (bcode:code b) `(aref ,b 0))
(defmacro (bcode:ctable b) `(aref ,b 1))
(defmacro (bcode:nconst b) `(aref ,b 2))
@@ -45,17 +45,17 @@
(if (eq? inst 'loada)
(cond ((equal? args '(0))
(set! inst 'loada0)
- (set! args ()))
+ (set! args NIL))
((equal? args '(1))
(set! inst 'loada1)
- (set! args ()))))
+ (set! args NIL))))
(if (eq? inst 'loadc)
(cond ((equal? args '(0))
(set! inst 'loadc0)
- (set! args ()))
+ (set! args NIL))
((equal? args '(1))
(set! inst 'loadc1)
- (set! args ()))))
+ (set! args NIL))))
(let ((lasti (car bc)))
(cond ((and (eq? inst 'brn)
@@ -63,7 +63,7 @@
(aset! e 0 (cons (car args) (cons 'brnn (cdr bc)))))
((eq? lasti 'eq?)
(aset! e 0 (cons (car args) (cons 'brne (cdr bc)))))
- (else nil))))
+ (else NIL))))
(else
(aset! e 0 (nreconc (cons inst args) bc)))))))
e))
@@ -86,8 +86,8 @@
(label-to-loc (table))
(fixup-to-label (table))
(bcode (buffer))
- (vi nil)
- (nxt nil))
+ (vi NIL)
+ (nxt NIL))
(while (< i n)
(set! vi (aref v i))
(if (eq? vi 'label)
@@ -133,7 +133,7 @@
; other number arguments are always u8
(io-write bcode (u8 nxt))
(set! i (+ i 1)))))
- (else nil)))))
+ (else NIL)))))
(for-each
(λ (addr labl)
@@ -166,7 +166,7 @@
(aset! g 3 (nconc ce (list s))))))))
(def (index-of item lst start)
- (cond ((not lst) nil)
+ (cond ((not lst) NIL)
((eq? item (car lst)) start)
(else (index-of item (cdr lst) (+ start 1)))))
@@ -211,9 +211,9 @@
(def (compile-aset! g env args)
(let ((nref (- (length args) 2)))
(cond ((= nref 1)
- (compile-app g env nil (cons 'aset! args)))
+ (compile-app g env NIL (cons 'aset! args)))
((> nref 1)
- (compile-app g env nil (cons 'aref (list-head args nref)))
+ (compile-app g env NIL (cons 'aref (list-head args nref)))
(let ((nargs (compile-arglist g env (list-tail args nref))))
(bcode:stack g (- nargs))
(emit g 'aset!)))
@@ -222,7 +222,7 @@
(def (compile-set! g env s rhs)
(let ((loc (lookup-sym s env 0)))
(if (eq? loc 'global)
- (begin (compile-in g env nil rhs)
+ (begin (compile-in g env NIL rhs)
(emit g 'setg s))
(let ((arg? (= (car loc) 0)))
(let ((h? (vinfo:heap? (cdr loc)))
@@ -232,11 +232,11 @@
(if h?
(begin (emit g (if arg? 'loada 'loadc) idx)
(bcode:stack g 1)
- (compile-in g env nil rhs)
+ (compile-in g env NIL rhs)
(bcode:stack g -1)
(emit g 'set-car!))
- (begin (compile-in g env nil rhs)
+ (begin (compile-in g env NIL rhs)
(unless arg? (error (str "internal error: misallocated var " s)))
(emit g 'seta idx))))))))
@@ -257,13 +257,13 @@
(then (caddr x))
(else (if (cons? (cdddr x))
(cadddr x)
- nil)))
- (cond ((eq? test t)
+ NIL)))
+ (cond ((eq? test T)
(compile-in g env tail? then))
((not test)
(compile-in g env tail? else))
(else
- (compile-in g env nil test elsel)
+ (compile-in g env NIL test elsel)
(emit g 'brn elsel)
(mark-label g thenl)
(compile-in g env tail? then)
@@ -279,15 +279,15 @@
((atom? (cdr forms))
(compile-in g env tail? (car forms)))
(else
- (compile-in g env nil (car forms))
+ (compile-in g env NIL (car forms))
(emit g 'pop)
(compile-begin g env tail? (cdr forms)))))
(def (compile-prog1 g env x)
- (compile-in g env nil (cadr x))
+ (compile-in g env NIL (cadr x))
(when (cons? (cddr x))
(bcode:stack g 1)
- (compile-begin g env nil (cddr x))
+ (compile-begin g env NIL (cddr x))
(emit g 'pop)
(bcode:stack g -1)))
@@ -294,14 +294,14 @@
(def (compile-while g env cond body)
(let ((top (make-label g))
(end (make-label g)))
- (compile-in g env nil (void))
+ (compile-in g env NIL (void))
(bcode:stack g 1)
(mark-label g top)
- (compile-in g env nil cond)
+ (compile-in g env NIL cond)
(emit g 'brn end)
(emit g 'pop)
(bcode:stack g -1)
- (compile-in g env nil body)
+ (compile-in g env NIL body)
(emit g 'jmp top)
(mark-label g end)))
@@ -319,7 +319,7 @@
((atom? (cdr forms)) (compile-in g env tail? (car forms) outl))
(else
(let ((end (or outl (make-label g))))
- (compile-in g env nil (car forms) outl)
+ (compile-in g env NIL (car forms) outl)
(bcode:stack g 1)
(unless outl (emit g 'dup))
(emit g branch end)
@@ -329,15 +329,15 @@
(unless outl (mark-label g end))))))
(def (compile-and g env tail? forms outl)
- (compile-short-circuit g env tail? forms t 'brn outl))
+ (compile-short-circuit g env tail? forms T 'brn outl))
(def (compile-or g env tail? forms)
- (compile-short-circuit g env tail? forms nil 'brnn nil))
+ (compile-short-circuit g env tail? forms NIL 'brnn NIL))
;; calls
(def (compile-arglist g env lst)
(for-each (λ (a)
- (compile-in g env nil a)
+ (compile-in g env NIL a)
(bcode:stack g 1))
lst)
(length lst))
@@ -363,7 +363,7 @@
set-car! 'set-car! car 'car for 'for
cons? 'cons? = '= vec? 'vec?)))
(λ (b)
- (get b2i b nil))))
+ (get b2i b NIL))))
(def (compile-builtin-call g env tail? x head b nargs)
(def (num-compare)
@@ -370,7 +370,7 @@
(if (= nargs 0)
(argc-error b 1)
(emit g b nargs)))
- (let ((count (get arg-counts b nil)))
+ (let ((count (get arg-counts b NIL)))
(when (and count (not (length= (cdr x) count)))
(argc-error b count))
(case b ; handle special cases of vararg builtins
@@ -441,7 +441,7 @@
head)))
(if (length> (cdr x) 255)
;; more than 255 arguments, need long versions of instructions
- (begin (compile-in g env nil head)
+ (begin (compile-in g env NIL head)
(bcode:stack g 1)
(let ((nargs (compile-arglist g env (cdr x))))
(bcode:stack g (- nargs))
@@ -452,7 +452,7 @@
(not (in-env? head env))
(equal? (top-level-value 'cadr) cadr)
(length= x 2))
- (begin (compile-in g env nil (cadr x))
+ (begin (compile-in g env NIL (cadr x))
(emit g 'cadr))
(if (and (cons? head)
(lambda? (car head))
@@ -460,7 +460,7 @@
(compile-let g env tail? x)
(begin
(unless b
- (compile-in g env nil head)
+ (compile-in g env NIL head)
(bcode:stack g 1))
(let ((nargs (compile-arglist g env (cdr x))))
(bcode:stack g (- nargs))
@@ -473,12 +473,12 @@
(def (fits-i8 x) (and (fixnum? x) (>= 127 x -128)))
-(def (compile-in g env tail? x (outl nil))
- (cond ((sym? x) (compile-sym g env x t))
+(def (compile-in g env tail? x (outl NIL))
+ (cond ((sym? x) (compile-sym g env x T))
((atom? x)
(cond ((eq? x 0) (emit g 'load0))
((eq? x 1) (emit g 'load1))
- ((eq? x t) (emit g 'loadt))
+ ((eq? x T) (emit g 'loadt))
((not x) (emit g 'loadnil))
((void? x) (emit g 'loadvoid))
((fits-i8 x) (emit g 'loadi8 x))
@@ -499,13 +499,13 @@
(begin (emit g 'loadv the-f)
(when cenv
(for-each (λ (var)
- (compile-sym g env var nil))
+ (compile-sym g env var NIL))
cenv)
(emit g 'closure (length cenv))))))
(and (compile-and g env tail? (cdr x) outl))
(or (compile-or g env tail? (cdr x)))
(while (compile-while g env (cadr x) (cons 'begin (cddr x))))
- (return (compile-in g env t (cadr x))
+ (return (compile-in g env T (cadr x))
(emit g 'ret))
(set! (let* ((name (cadr x))
(doc+value (separate-doc-from-body (cddr x)))
@@ -518,10 +518,10 @@
(lambda? (car (car value)))
(lambda:vars (car value)))))
(compile-set! g env name (car value))))
- (trycatch (compile-in g env nil `(λ () ,(cadr x)))
+ (trycatch (compile-in g env NIL `(λ () ,(cadr x)))
(unless (1arg-lambda? (caddr x))
(error "trycatch: second form must be a 1-argument lambda"))
- (compile-in g env nil (caddr x))
+ (compile-in g env NIL (caddr x))
(emit g 'trycatch))
(else (compile-app g env tail? x))))))
@@ -536,7 +536,7 @@
(def (lambda-vars l)
(def (check-formals l o opt kw)
- (cond ((or (not l) (sym? l)) t)
+ (cond ((or (not l) (sym? l)) T)
((and (cons? l) (sym? (car l)))
(if (or opt kw)
(error "compile error: invalid argument list "
@@ -548,11 +548,11 @@
(error "compile error: invalid optional argument " (car l)
" in list " o))
(if (keyword? (caar l))
- (check-formals (cdr l) o opt t)
+ (check-formals (cdr l) o opt T)
(if kw
(error "compile error: invalid argument list "
o ": keyword arguments must come last.")
- (check-formals (cdr l) o t kw))))
+ (check-formals (cdr l) o T kw))))
((cons? l)
(error "compile error: invalid formal argument " (car l)
" in list " o))
@@ -561,7 +561,7 @@
(error "compile error: invalid argument list " o)
(error "compile error: invalid formal argument " l
" in list " o)))))
- (check-formals l l nil nil)
+ (check-formals l l NIL NIL)
(map (λ (s) (if (cons? s) (keyword->sym (car s)) s))
(to-proper l)))
@@ -571,7 +571,7 @@
(let ((nxt (make-label g)))
(emit g 'brbound i)
(emit g 'brnn nxt)
- (compile-in g (extend-env env (list-head vars i) '()) nil (cadar opta))
+ (compile-in g (extend-env env (list-head vars i) NIL) NIL (cadar opta))
(emit g 'seta i)
(emit g 'pop)
(mark-label g nxt)
@@ -595,7 +595,7 @@
(def get-defined-vars
(letrec ((get-defined-vars-
(λ (expr)
- (cond ((atom? expr) ())
+ (cond ((atom? expr) NIL)
((and (eq? (car expr) 'def)
(cons? (cdr expr)))
(or (and (sym? (cadr expr))
@@ -602,11 +602,10 @@
(list (cadr expr)))
(and (cons? (cadr expr))
(sym? (caadr expr))
- (list (caadr expr)))
- ()))
+ (list (caadr expr)))))
((eq? (car expr) 'begin)
(apply nconc (map get-defined-vars- (cdr expr))))
- (else ())))))
+ (else NIL)))))
(λ (expr) (delete-duplicates (get-defined-vars- expr)))))
(def (lower-define e)
@@ -638,38 +637,38 @@
(def (lambda:vars e) (lambda-vars (cadr e)))
(def (diff s1 s2)
- (cond ((not s1) nil)
+ (cond ((not s1) NIL)
((memq (car s1) s2) (diff (cdr s1) s2))
(else (cons (car s1) (diff (cdr s1) s2)))))
;; bindings that are both captured and set!'d
(def (complex-bindings- e vars head nested capt setd)
- (cond ((not vars) nil)
+ (cond ((not vars) NIL)
((sym? e)
(when (and nested (memq e vars))
- (put! capt e t)))
- ((or (atom? e) (quoted? e)) nil)
+ (put! capt e T)))
+ ((or (atom? e) (quoted? e)) NIL)
((eq? (car e) 'set!)
(when (memq (cadr e) vars)
- (put! setd (cadr e) t)
- (if nested (put! capt (cadr e) t)))
- (complex-bindings- (caddr e) vars nil nested capt setd))
+ (put! setd (cadr e) T)
+ (if nested (put! capt (cadr e) T)))
+ (complex-bindings- (caddr e) vars NIL nested capt setd))
((lambda? (car e))
(complex-bindings- (lambda:body e)
(diff vars (lambda:vars e))
- nil
+ NIL
(or (not head) nested)
capt setd))
(else
(cons (complex-bindings- (car e) vars (inlineable? e) nested capt setd)
(map (λ (x)
- (complex-bindings- x vars nil nested capt setd))
+ (complex-bindings- x vars NIL nested capt setd))
(cdr e))))))
(def (complex-bindings e vars)
(let ((capt (table))
(setd (table)))
- (complex-bindings- e vars nil nil capt setd)
+ (complex-bindings- e vars NIL NIL capt setd)
(filter (λ (x) (has? capt x))
(table-keys setd))))
@@ -683,11 +682,11 @@
;; main entry points
-(def (compile f) (compile-f () (lower-define f)))
+(def (compile f) (compile-f NIL (lower-define f)))
(def (compile-thunk expr)
;; to eval a top-level expression we need to avoid internal define
- (compile-f () `(λ () ,(lower-define expr))))
+ (compile-f NIL `(λ () ,(lower-define expr))))
(def (compile-f env f)
(receive (ff ignore)
@@ -741,7 +740,7 @@
;; set initial stack pointer
(aset! g 4 (+ (length vars) 4))
;; compile body and return
- (compile-in g newenv t (lambda:body f))
+ (compile-in g newenv T (lambda:body f))
(emit g 'ret)
(values (fn (encode-byte-code (bcode:code g))
(const-to-idx-vec g)
@@ -763,7 +762,7 @@
(def (hex5 n)
(str-lpad (num->str n 16) 5 #\0))
-(def (fn-disasm f (ip nil) . lev?)
+(def (fn-disasm f (ip NIL) . lev?)
(when (not lev?)
(fn-disasm f ip 0)
(newline)
@@ -774,7 +773,7 @@
(def (print-val v)
(if (and (fn? v) (not (builtin? v)))
(begin (newline)
- (fn-disasm v nil (+ lev 1)))
+ (fn-disasm v NIL (+ lev 1)))
(print v)))
(def (print-inst inst s sz) (princ (if (and ip (= lev 0) (>= ip (1- s)) (< ip (+ s sz)))
" >"
@@ -788,7 +787,7 @@
(let ((inst (table-foldl (λ (k v z)
(or z (and (= v (aref code i))
k)))
- nil Instructions)))
+ NIL Instructions)))
(when (> i 0) (newline))
(dotimes (xx lev) (princ "\t"))
(set! i (+ i 1))
@@ -857,7 +856,7 @@
(def ($hash-keyword key n)
(mod0 (abs (hash key)) n))
(let loop1 ((n (length alist)))
- (let ((v (vec-alloc (* 2 n) nil)))
+ (let ((v (vec-alloc (* 2 n) NIL)))
(let loop2 ((lst alist))
(if (cons? lst)
(let ((key (caar lst)))
--- a/src/system.lsp
+++ b/src/system.lsp
@@ -26,7 +26,7 @@
(put! *syntax-environment* s v))
(def (get-syntax s)
- (get *syntax-environment* s nil))
+ (get *syntax-environment* s NIL))
(def (separate-doc-from-body body (doc NIL))
(let {[hd (car body)]@@ -53,7 +53,7 @@
,.(map void binds)))
(defmacro (let binds . body)
- (let ((lname nil))
+ (let ((lname NIL))
(when (sym? binds)
(set! lname binds)
(set! binds (car body))
@@ -73,10 +73,10 @@
(defmacro (cond . clauses)
(def (cond-clauses->if lst)
(if (atom? lst)
- nil
+ NIL
(let ((clause (car lst)))
(if (or (eq? (car clause) 'else)
- (eq? (car clause) t))
+ (eq? (car clause) T))
(if (not (cdr clause))
(car clause)
(cons 'begin (cdr clause)))
@@ -118,7 +118,7 @@
(def (putprop symbol key val)
"Associate a property value with a symbol."
- (let ((kt (get *properties* key nil)))
+ (let ((kt (get *properties* key NIL)))
(unless kt
(let ((ta (table)))
(put! *properties* key ta)
@@ -126,14 +126,14 @@
(put! kt symbol val)
val))
-(def (getprop symbol key (def nil))
+(def (getprop symbol key (def NIL))
"Get a property value associated with a symbol or `def` if missing."
- (let ((kt (get *properties* key nil)))
+ (let ((kt (get *properties* key NIL)))
(or (and kt (get kt symbol def)) def)))
(def (remprop symbol key)
"Remove a property value associated with a symbol."
- (let ((kt (get *properties* key nil)))
+ (let ((kt (get *properties* key NIL)))
(and kt (has? kt symbol) (del! kt symbol))))
;;; documentation
@@ -161,7 +161,7 @@
[final (str-join (cons hd trimmed) "\n")]}
(putprop symbol '*doc* final)))
(when (cons? funvars)
- (let* {[existing (getprop symbol '*funvars* nil)]+ (let* {[existing (getprop symbol '*funvars* NIL)]; filter out duplicates
[to-add (filter (λ (funvar) (not (member funvar existing)))
funvars)]}
@@ -186,7 +186,7 @@
(defmacro (help term (:print-header help-print-header))
"Display documentation for the specified term, if available."
(let* {[doc (getprop term '*doc*)]- [sigs (getprop term '*funvars* nil)]}
+ [sigs (getprop term '*funvars* NIL)]}
(if (or doc sigs)
`(begin (,print-header ',term ',sigs)
(when ,doc
@@ -391,10 +391,9 @@
(list-tail (cdr lst) (- n 1))))
(def (list-head lst n)
- (if (<= n 0)
- ()
- (cons (car lst)
- (list-head (cdr lst) (- n 1)))))
+ (and (> n 0)
+ (cons (car lst)
+ (list-head (cdr lst) (- n 1)))))
(def (list-ref lst n)
(car (list-tail lst n)))
@@ -404,7 +403,7 @@
Use this instead of `(= (length lst) n)`, since it avoids unnecessary
work and always terminates."
- (cond ((< n 0) nil)
+ (cond ((< n 0) NIL)
((= n 0) (atom? lst))
((atom? lst) (= n 0))
(else (length= (cdr lst) (- n 1)))))
@@ -443,9 +442,9 @@
(while (cons? lst)
(when (pred (car lst))
(set! acc
- (cdr (set-cdr! acc (cons (car lst) ())))))
+ (cdr (set-cdr! acc (cons (car lst) NIL)))))
(set! lst (cdr lst))))))
- (filter- pred lst (list ())))
+ (filter- pred lst (list NIL)))
(def (partition pred lst)
(def (partition- pred lst yes no)
@@ -454,11 +453,11 @@
(cons yes no)
(while (cons? lst)
(if (pred (car lst))
- (set! yes (cdr (set-cdr! yes (cons (car lst) ()))))
- (set! no (cdr (set-cdr! no (cons (car lst) ())))))
+ (set! yes (cdr (set-cdr! yes (cons (car lst) NIL))))
+ (set! no (cdr (set-cdr! no (cons (car lst) NIL)))))
(set! lst (cdr lst))))))
(values (cdr (car vals)) (cdr (cdr vals)))))
- (partition- pred lst (list ()) (list ())))
+ (partition- pred lst (list NIL) (list NIL)))
(def (count f l)
(def (count- f l n)
@@ -470,9 +469,8 @@
(count- f l 0))
(def (nestlist f zero n)
- (if (<= n 0)
- ()
- (cons zero (nestlist f (f zero) (- n 1)))))
+ (and (> n 0)
+ (cons zero (nestlist f (f zero) (- n 1)))))
(def (foldr f zero lst)
(if (not lst)
@@ -490,7 +488,7 @@
(reverse- (cons (car lst) zero) (cdr lst))))
(def (reverse lst)
- (reverse- () lst))
+ (reverse- NIL lst))
(def (reverse!- prev l)
(while (cons? l)
@@ -500,7 +498,7 @@
prev)
(def (reverse! l)
- (reverse!- () l))
+ (reverse!- NIL l))
(def (copy-tree l)
(if (atom? l)
@@ -511,13 +509,13 @@
(def (delete-duplicates lst)
(if (length> lst 20)
(let ((ta (table)))
- (let loop ((l lst) (acc '()))
+ (let loop ((l lst) (acc NIL))
(if (atom? l)
(reverse! acc)
(if (has? ta (car l))
(loop (cdr l) acc)
(begin
- (put! ta (car l) t)
+ (put! ta (car l) T)
(loop (cdr l) (cons (car l) acc)))))))
(if (atom? lst)
lst
@@ -612,7 +610,7 @@
(list cons (car forms) (bq-process lc d))
(nconc (cons list* forms) (list (bq-process lc d)))))))
(else
- (let loop ((p x) (q ()))
+ (let loop ((p x) (q NIL))
(cond ((not p) ;; proper list
(cons 'nconc (reverse! q)))
((cons? p)
@@ -648,15 +646,15 @@
,(cadar binds))))
(defmacro (when c . body)
- (list 'if c (cons 'begin body) nil))
+ (list 'if c (cons 'begin body) NIL))
(defmacro (unless c . body)
- (list 'if c nil (cons 'begin body)))
+ (list 'if c NIL (cons 'begin body)))
(defmacro (case key . clauses)
(def (vals->cond key v)
(cond ((eq? v 'else) 'else)
- ((not v) nil)
+ ((not v) NIL)
((sym? v) `(eq? ,key ,(quote-value v)))
((atom? v) `(eqv? ,key ,(quote-value v)))
((not (cdr v)) `(eqv? ,key ,(quote-value (car v))))
@@ -700,15 +698,14 @@
(λ (,v) ,@body))))
(def (map-int f n)
- (if (<= n 0)
- nil
- (let ((first (cons (f 0) ()))
- (acc ()))
- (set! acc first)
- (for 1 (1- n)
- (λ (i) (set-cdr! acc (cons (f i) ()))
- (set! acc (cdr acc))))
- first)))
+ (and (> n 0)
+ (let ((first (cons (f 0) NIL))
+ (acc NIL))
+ (set! acc first)
+ (for 1 (1- n)
+ (λ (i) (set-cdr! acc (cons (f i) NIL))
+ (set! acc (cdr acc))))
+ first)))
(def (iota n)
(map-int identity n))
@@ -748,7 +745,7 @@
;;; debugging utilities
(defmacro (assert expr)
- `(if ,expr t (raise '(assert-failed ,expr))))
+ `(if ,expr T (raise '(assert-failed ,expr))))
(def traced?
(let ((sample-traced-lambda (λ args (write (cons 'x args))
@@ -789,7 +786,7 @@
(for-each write args))
(def (princ . args)
- (with-bindings ((*print-readably* nil))
+ (with-bindings ((*print-readably* NIL))
(for-each write args)))
(def (newline (io *io-out*))
@@ -800,7 +797,7 @@
; call f on an io until the io runs out of data
(def (read-all-of f s)
- (let loop ((lines ())
+ (let loop ((lines NIL)
(curr (f s)))
(if (io-eof? s)
(reverse! lines)
@@ -832,7 +829,7 @@
(def (vec->list v)
(let ((n (length v))
- (l ()))
+ (l NIL))
(for 1 n
(λ (i)
(set! l (cons (aref v (- n i)) l))))
@@ -850,22 +847,22 @@
(def (table-pairs ta)
(table-foldl (λ (k v z) (cons (cons k v) z))
- nil ta))
+ NIL ta))
(def (table-keys ta)
(table-foldl (λ (k v z) (cons k z))
- nil ta))
+ NIL ta))
(def (table-values ta)
(table-foldl (λ (k v z) (cons v z))
- nil ta))
+ NIL ta))
(def (table-clone ta)
(let ((nt (table)))
(table-foldl (λ (k v z) (put! nt k v))
- nil ta)
+ NIL ta)
nt))
(def (table-invert ta)
(let ((nt (table)))
(table-foldl (λ (k v z) (put! nt v k))
- nil ta)
+ NIL ta)
nt))
;;; string functions
@@ -981,13 +978,13 @@
[name (or name-cons slot)]
[tail (or (and name-cons
(cdr slot))
- (list nil))]}
+ (list NIL))]}
(when (or (not (sym? name))
(keyword? name))
(error "invalid slot name: " name))
(list* (sym #\: name)
(if (keyword? (car tail))
- (cons nil tail)
+ (cons NIL tail)
tail))))
slots))
(let* {; first element in slots may be the doc string@@ -1095,7 +1092,7 @@
(splice-begin body)
body))
(def? (top? 'def env))
- (dvars (if def? (get-defined-vars body) ()))
+ (dvars (and def? (get-defined-vars body)))
(env (nconc (map list dvars) env)))
(if (not def?)
(map (λ (x) (expand-in x env)) body)
@@ -1213,7 +1210,7 @@
((eq? head 'def) (expand-define e env))
((eq? head 'let-syntax) (expand-let-syntax e env))
(else (default))))))
- (expand-in e ()))
+ (expand-in e NIL))
(def (eval x)
((compile-thunk (macroexpand x))))
@@ -1251,7 +1248,7 @@
(when (trycatch (prompt)
(λ (e)
(top-level-exception-handler e)
- t))
+ T))
(reploop)))
(reploop)
(newline))
@@ -1274,9 +1271,9 @@
(let ((p (catch 'ffound
(begin
(for-each (λ (topfun)
- (find-in-f topfun f ()))
+ (find-in-f topfun f NIL))
e)
- nil))))
+ NIL))))
(if p
(str-join (map str (reverse! p)) "/")
"λ")))
@@ -1356,8 +1353,8 @@
*print-pretty* *print-width* *print-readably*
*print-level* *print-length* *os-name* *interactive*
*prompt* *os-version*)))
- (with-bindings ((*print-pretty* t)
- (*print-readably* t))
+ (with-bindings ((*print-pretty* T)
+ (*print-readably* T))
(let* ((syms
(filter (λ (s)
(and (bound? s)
@@ -1385,7 +1382,7 @@
defprompt))
(set! *directory-separator* (or (and (equal? *os-name* "dos") "\\") "/"))
(set! *linefeed* "\n")
- (set! *exit-hooks* nil)
+ (set! *exit-hooks* NIL)
(set! *io-out* *stdout*)
(set! *io-in* *stdin*)
(set! *io-err* *stderr*))
@@ -1397,9 +1394,9 @@
(def (__rcscript)
(let* ((homevar (case *os-name*
- (("unknown") nil)+ (("unknown") NIL) (("plan9") "home")- (("macos") (princ "\x1b]0;StreetLISP v0.999\007") nil)+ (("macos") (princ "\x1b]0;StreetLISP v0.999\007") NIL)(else "HOME")))
(home (and homevar (os-getenv homevar)))
(rcpath (case *os-name*
@@ -1415,7 +1412,7 @@
(if (cons? (cdr argv))
(begin (set! *argv* (cdr argv))
(__script (cadr argv)))
- (set! *interactive* t))
+ (set! *interactive* T))
(when *interactive*
(__rcscript)
(repl))
--- a/test/ast/asttools.lsp
+++ b/test/ast/asttools.lsp
@@ -6,9 +6,9 @@
(cons item lst)))
(def (index-of item lst start)
- (cond ((not lst) nil)
- ((eq? item (car lst)) start)
- (else (index-of item (cdr lst) (+ start 1)))))
+ (cond ((not lst) NIL)
+ ((eq? item (car lst)) start)
+ (else (index-of item (cdr lst) (+ start 1)))))
(def (each f l)
(if (not l) l
@@ -48,20 +48,20 @@
(let ((head (and (cons? tr) (car tr))))
(cond
((eq? head 'quote) tr)
- ((or (eq? head 'the) (eq? head 'meta))
- (list head
- (cadr tr)
- (map&fold (caddr tr) zero mapper folder)))
- (else
- (let ((new-s (folder tr zero)))
- (mapper
- (if (cons? tr)
- ; head symbol is a tag; never transform it
- (cons (car tr)
- (map (lambda (e) (map&fold e new-s mapper folder))
- (cdr tr)))
- tr)
- new-s))))))
+ ((or (eq? head 'the) (eq? head 'meta))
+ (list head
+ (cadr tr)
+ (map&fold (caddr tr) zero mapper folder)))
+ (else
+ (let ((new-s (folder tr zero)))
+ (mapper
+ (if (cons? tr)
+ ; head symbol is a tag; never transform it
+ (cons (car tr)
+ (map (lambda (e) (map&fold e new-s mapper folder))
+ (cdr tr)))
+ tr)
+ new-s))))))
; convert to proper list, i.e. remove "dots", and append
(def (append.2 l tail)
@@ -73,11 +73,11 @@
; env is a list of lexical variables in effect at that point.
(def (lexical-walk f tr)
(map&fold tr () f
- (lambda (tree state)
- (if (and (eq? (car tr) 'lambda)
- (cons? (cdr tr)))
- (append.2 (cadr tr) state)
- state))))
+ (lambda (tree state)
+ (if (and (eq? (car tr) 'lambda)
+ (cons? (cdr tr)))
+ (append.2 (cadr tr) state)
+ state))))
; collapse forms like (&& (&& (&& (&& a b) c) d) e) to (&& a b c d e)
(def (flatten-left-op op e)
@@ -106,14 +106,14 @@
((cons? e)
(if (eq? (car e) 'quote)
e
- (let* ((newvs (and (eq? (car e) 'lambda) (cadr e)))
- (newenv (if newvs (cons newvs env) env)))
- (if newvs
- (cons 'lambda
- (cons (cadr e)
- (map (lambda (se) (lvc- se newenv))
- (cddr e))))
- (map (lambda (se) (lvc- se env)) e)))))
+ (let* ((newvs (and (eq? (car e) 'lambda) (cadr e)))
+ (newenv (if newvs (cons newvs env) env)))
+ (if newvs
+ (cons 'lambda
+ (cons (cadr e)
+ (map (lambda (se) (lvc- se newenv))
+ (cddr e))))
+ (map (lambda (se) (lvc- se env)) e)))))
(else e)))
(def (lexical-var-conversion e)
(lvc- e ()))
@@ -121,32 +121,32 @@
; convert let to lambda
(def (let-expand e)
(maptree-post (lambda (n)
- (if (and (cons? n) (eq? (car n) 'let))
- `((lambda ,(map car (cadr n)) ,@(cddr n))
- ,@(map cadr (cadr n)))
+ (if (and (cons? n) (eq? (car n) 'let))
+ `((lambda ,(map car (cadr n)) ,@(cddr n))
+ ,@(map cadr (cadr n)))
n))
- e))
+ e))
; alpha renaming
; transl is an assoc list ((old-sym-name . new-sym-name) ...)
(def (alpha-rename e transl)
(map&fold e
- ()
- ; mapper: replace symbol if unbound
- (lambda (te env)
- (if (sym? te)
- (let ((found (assq te transl)))
- (if (and found
- (not (memq te env)))
- (cdr found)
- te))
- te))
- ; folder: add locals to environment if entering a new scope
- (lambda (te env)
- (if (and (cons? te) (or (eq? (car te) 'let)
- (eq? (car te) 'lambda)))
- (append (cadr te) env)
- env))))
+ ()
+ ; mapper: replace symbol if unbound
+ (lambda (te env)
+ (if (sym? te)
+ (let ((found (assq te transl)))
+ (if (and found
+ (not (memq te env)))
+ (cdr found)
+ te))
+ te))
+ ; folder: add locals to environment if entering a new scope
+ (lambda (te env)
+ (if (and (cons? te) (or (eq? (car te) 'let)
+ (eq? (car te) 'lambda)))
+ (append (cadr te) env)
+ env))))
; flatten op with any associativity
(defmacro (flatten-all-op op e)
@@ -162,6 +162,6 @@
(let ((m (match ',pat expr)))
(if m
; matches; perform expansion
- (apply ,expander (map (lambda (var) (cdr (or (assq var m) '(0 . nil))))
+ (apply ,expander (map (lambda (var) (cdr (or (assq var m) '(0 . NIL))))
',args))
- nil)))))
+ NIL)))))
--- a/test/ast/match.lsp
+++ b/test/ast/match.lsp
@@ -2,11 +2,10 @@
; by Jeff Bezanson
(def (unique lst)
- (if (not lst)
- nil
- (cons (car lst)
- (filter (lambda (x) (not (eq? x (car lst))))
- (unique (cdr lst))))))
+ (and lst
+ (cons (car lst)
+ (filter (λ (x) (not (eq? x (car lst))))
+ (unique (cdr lst))))))
; list of special pattern symbols that cannot be variable names
(def metasymbols '(_ ...))
@@ -13,7 +12,7 @@
; expression tree pattern matching
; matches expr against pattern p and returns an assoc list ((var . expr) (var . expr) ...)
-; mapping variables to captured subexpressions, or nil if no match.
+; mapping variables to captured subexpressions, or NIL if no match.
; when a match succeeds, __ is always bound to the whole matched expression.
;
; p is an expression in the following pattern language:
@@ -39,54 +38,53 @@
;
(def (match- p expr state)
(cond ((sym? p)
- (cond ((eq? p '_) state)
- (else
- (let ((capt (assq p state)))
- (if capt
- (and (equal? expr (cdr capt)) state)
- (cons (cons p expr) state))))))
+ (cond ((eq? p '_) state)
+ (else
+ (let ((capt (assq p state)))
+ (if capt
+ (and (equal? expr (cdr capt)) state)
+ (cons (cons p expr) state))))))
- ((fn? p)
- (and (p expr) state))
+ ((fn? p)
+ (and (p expr) state))
- ((cons? p)
- (cond ((eq? (car p) '-/) (and (equal? (cadr p) expr) state))
- ((eq? (car p) '-^) (and (not (match- (cadr p) expr state)) state))
- ((eq? (car p) '--)
- (and (match- (caddr p) expr state)
- (cons (cons (cadr p) expr) state)))
- ((eq? (car p) '-$) ; greedy alternation for toplevel pattern
- (match-alt (cdr p) nil (list expr) state nil 1))
- (else
- (and (cons? expr)
- (equal? (car p) (car expr))
- (match-seq (cdr p) (cdr expr) state (length (cdr expr)))))))
+ ((cons? p)
+ (cond ((eq? (car p) '-/) (and (equal? (cadr p) expr) state))
+ ((eq? (car p) '-^) (and (not (match- (cadr p) expr state)) state))
+ ((eq? (car p) '--)
+ (and (match- (caddr p) expr state)
+ (cons (cons (cadr p) expr) state)))
+ ((eq? (car p) '-$) ; greedy alternation for toplevel pattern
+ (match-alt (cdr p) NIL (list expr) state NIL 1))
+ (else
+ (and (cons? expr)
+ (equal? (car p) (car expr))
+ (match-seq (cdr p) (cdr expr) state (length (cdr expr)))))))
- (else
- (and (equal? p expr) state))))
+ (else
+ (and (equal? p expr) state))))
; match an alternation
(def (match-alt alt prest expr state var L)
- (if (not alt)
- nil ; no alternatives left
- (let ((subma (match- (car alt) (car expr) state)))
- (or (and subma
- (match-seq prest (cdr expr)
- (if var
- (cons (cons var (car expr))
- subma)
- subma)
- (- L 1)))
- (match-alt (cdr alt) prest expr state var L)))))
+ (and alt
+ (let ((subma (match- (car alt) (car expr) state)))
+ (or (and subma
+ (match-seq prest (cdr expr)
+ (if var
+ (cons (cons var (car expr))
+ subma)
+ subma)
+ (- L 1)))
+ (match-alt (cdr alt) prest expr state var L)))))
; match generalized kleene star (try consuming min to max)
(def (match-star- p prest expr state var min max L sofar)
(cond ; case 0: impossible to match
- ((> min max) nil)
+ ((> min max) NIL)
; case 1: only allowed to match 0 subexpressions
((= max 0) (match-seq prest expr
(if var (cons (cons var (reverse sofar)) state)
- state)
+ state)
L))
; case 2: must match at least 1
((> min 0)
@@ -98,36 +96,36 @@
(or (match-star- p prest expr state var 0 0 L sofar)
(match-star- p prest expr state var 1 max L sofar)))))
(def (match-star p prest expr state var min max L)
- (match-star- p prest expr state var min max L nil))
+ (match-star- p prest expr state var min max L NIL))
; match sequences of expressions
(def (match-seq p expr state L)
- (cond ((not state) nil)
- ((not p) (if (not expr) state nil))
- (else
- (let ((subp (car p))
- (var nil))
- (if (and (cons? subp)
- (eq? (car subp) '--))
- (begin (set! var (cadr subp))
+ (cond ((not state) NIL)
+ ((not p) (if (not expr) state NIL))
+ (else
+ (let ((subp (car p))
+ (var NIL))
+ (if (and (cons? subp)
+ (eq? (car subp) '--))
+ (begin (set! var (cadr subp))
(set! subp (caddr subp)))
- nil)
- (let ((head (if (cons? subp) (car subp) nil)))
- (cond ((eq? subp '...)
- (match-star '_ (cdr p) expr state var 0 L L))
- ((eq? head '-*)
- (match-star (cadr subp) (cdr p) expr state var 0 L L))
- ((eq? head '-+)
- (match-star (cadr subp) (cdr p) expr state var 1 L L))
- ((eq? head '-?)
- (match-star (cadr subp) (cdr p) expr state var 0 1 L))
- ((eq? head '-$)
- (match-alt (cdr subp) (cdr p) expr state var L))
- (else
- (and (cons? expr)
- (match-seq (cdr p) (cdr expr)
- (match- (car p) (car expr) state)
- (- L 1))))))))))
+ NIL)
+ (let ((head (if (cons? subp) (car subp) NIL)))
+ (cond ((eq? subp '...)
+ (match-star '_ (cdr p) expr state var 0 L L))
+ ((eq? head '-*)
+ (match-star (cadr subp) (cdr p) expr state var 0 L L))
+ ((eq? head '-+)
+ (match-star (cadr subp) (cdr p) expr state var 1 L L))
+ ((eq? head '-?)
+ (match-star (cadr subp) (cdr p) expr state var 0 1 L))
+ ((eq? head '-$)
+ (match-alt (cdr subp) (cdr p) expr state var L))
+ (else
+ (and (cons? expr)
+ (match-seq (cdr p) (cdr expr)
+ (match- (car p) (car expr) state)
+ (- L 1))))))))))
(def (match p expr) (match- p expr (list (cons '__ expr))))
@@ -139,10 +137,10 @@
((cons? p)
(if (eq? (car p) '-/)
- nil
- (unique (apply append (map patargs- (cdr p))))))
+ NIL
+ (unique (apply append (map patargs- (cdr p))))))
- (else nil)))
+ (else NIL)))
(def (patargs p)
(cons '__ (patargs- p)))
@@ -151,14 +149,14 @@
(def (apply-patterns plist expr)
(if (not plist) expr
(if (fn? plist)
- (let ((enew (plist expr)))
- (if (not enew)
- expr
- enew))
- (let ((enew ((car plist) expr)))
- (if (not enew)
- (apply-patterns (cdr plist) expr)
- enew)))))
+ (let ((enew (plist expr)))
+ (if (not enew)
+ expr
+ enew))
+ (let ((enew ((car plist) expr)))
+ (if (not enew)
+ (apply-patterns (cdr plist) expr)
+ enew)))))
; top-down fixed-point macroexpansion. this is a typical algorithm,
; but it may leave some structure that matches a pattern unexpanded.
@@ -173,9 +171,9 @@
(if (not (cons? expr))
expr
(let ((enew (apply-patterns plist expr)))
- (if (eq? enew expr)
+ (if (eq? enew expr)
; expr didn't change; move to subexpressions
- (cons (car expr)
- (map (lambda (subex) (pattern-expand plist subex)) (cdr expr)))
- ; expr changed; iterate
- (pattern-expand plist enew)))))
+ (cons (car expr)
+ (map (lambda (subex) (pattern-expand plist subex)) (cdr expr)))
+ ; expr changed; iterate
+ (pattern-expand plist enew)))))
--- a/test/color.lsp
+++ b/test/color.lsp
@@ -1,15 +1,15 @@
; dictionaries ----------------------------------------------------------------
-(def (dict-new) ())
+(def (dict-new) NIL)
(def (dict-extend dl key value)
(cond ((not dl) (list (cons key value)))
((equal? key (caar dl)) (cons (cons key value) (cdr dl)))
- (else (cons (car dl) (dict-extend (cdr dl) key value)))))
+ (else (cons (car dl) (dict-extend (cdr dl) key value)))))
(def (dict-lookup dl key)
- (cond ((not dl) nil)
+ (cond ((not dl) NIL)
((equal? key (caar dl)) (cdar dl))
- (else (dict-lookup (cdr dl) key))))
+ (else (dict-lookup (cdr dl) key))))
(def (dict-keys dl) (map car dl))
@@ -28,7 +28,7 @@
(def (graph-nodes g) (dict-keys g))
-(def (graph-add-node g n1) (dict-extend g n1 ()))
+(def (graph-add-node g n1) (dict-extend g n1 NIL))
(def (graph-from-edges edge-list)
(if (not edge-list)
@@ -44,7 +44,7 @@
(map
(λ (n)
(let ((color-pair (assq n coloring)))
- (if (cons? color-pair) (cdr color-pair) ())))
+ (and (cons? color-pair) (cdr color-pair))))
(graph-neighbors g node-to-color)))))
(def (try-each f lst)
@@ -65,7 +65,7 @@
(def (color-graph g colors)
(if (not colors)
(and (not (graph-nodes g)) nil)
- (color-node g () colors (graph-nodes g) (car colors))))
+ (color-node g NIL colors (graph-nodes g) (car colors))))
(def (color-pairs pairs colors)
(color-graph (graph-from-edges pairs) colors))
@@ -79,7 +79,7 @@
(or (= x1 x2) (= y1 y2) (= (abs (- y2 y1)) (abs (- x2 x1))))))
(def (generate-5x5-pairs)
- (let ((result ()))
+ (let ((result NIL))
(dotimes (x 25)
(dotimes (y 25)
(when (and (/= x y) (can-attack x y))
--- a/test/hashtest.lsp
+++ b/test/hashtest.lsp
@@ -6,7 +6,7 @@
(def (hread h)
(dotimes (n 200000)
- (get h (mod (rand) 10000) nil)))
+ (get h (mod (rand) 10000) NIL)))
(time (dotimes (i 100000)
(table :a 1 :b 2 :c 3 :d 4 :e 5 :f 6 :g 7 :foo 8 :bar 9)))
--- a/test/perf.lsp
+++ b/test/perf.lsp
@@ -40,7 +40,7 @@
(time (dotimes (n 5000) (macroexpand '(dotimes (i 100) body1 body2))))
(def (my-append . lsts)
- (cond ((not lsts) nil)
+ (cond ((not lsts) NIL)
((not (cdr lsts)) (car lsts))
(else (letrec ((append2 (λ (l d)
(if (not l)
--- a/test/torus.lsp
+++ b/test/torus.lsp
@@ -1,7 +1,5 @@
(def (maplist f l)
- (if (not l)
- nil
- (cons (f l) (maplist f (cdr l)))))
+ (and l (cons (f l) (maplist f (cdr l)))))
; produce a beautiful, toroidal cons structure
; make m copies of a CDR-circular list of length n, and connect corresponding
@@ -37,7 +35,7 @@
(set! b (cdr b))))
l))
-(time (begin (print (torus 100 100)) ()))
+(time (print (torus 100 100)))
;(time (dotimes (i 1) (load "100x100.lsp")))
; with ltable
; printing time: 0.415sec
--- a/test/unittest.lsp
+++ b/test/unittest.lsp
@@ -1,5 +1,5 @@
(defmacro (assert-fail expr . what)
- `(assert (trycatch (begin ,expr nil)
+ `(assert (trycatch (begin ,expr NIL)
(λ (e) ,(if (not what) t
`(eq? (car e) ',(car what)))))))
@@ -11,7 +11,7 @@
(list (fixnum n) (s8 n) (s16 n) (s32 n) (s64 n) (float n) (double n) (bignum n)))
(def (each f l)
- (if (atom? l) ()
+ (if (atom? l) NIL
(begin (f (car l))
(each f (cdr l)))))
@@ -195,16 +195,16 @@
(for 1 10 (λ (i) 0))
; and, or
-(assert (equal? t (and)))
-(assert (equal? nil (or)))
+(assert (equal? T (and)))
+(assert (equal? NIL (or)))
(assert (equal? 1 (and '(1) 'x 1)))
-(assert (equal? 1 (or nil nil nil nil nil 1 nil nil nil nil)))
+(assert (equal? 1 (or NIL NIL NIL NIL NIL 1 NIL NIL NIL NIL)))
(assert (equal? 2 (if (and '(1) 'x 1) 2 0)))
-(assert (equal? 2 (if (or nil nil nil nil nil 1 nil nil nil nil) 2 0)))
-(assert (equal? nil (and '(1) 1 'x nil)))
-(assert (equal? nil (or nil nil nil nil nil nil nil nil nil nil)))
-(assert (equal? 0 (if (and '(1) 1 'x nil) 2 0)))
-(assert (equal? 0 (if (or nil nil nil nil nil nil nil nil nil nil) 2 0)))
+(assert (equal? 2 (if (or NIL NIL NIL NIL NIL 1 NIL NIL NIL NIL) 2 0)))
+(assert (equal? NIL (and '(1) 1 'x NIL)))
+(assert (equal? NIL (or NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)))
+(assert (equal? 0 (if (and '(1) 1 'x NIL) 2 0)))
+(assert (equal? 0 (if (or NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL) 2 0)))
; failing applications
(assert-fail ((λ (x) x) 1 2))
@@ -254,7 +254,7 @@
(assert (equal? ((λ (a (b 2) (c 3)) (list a b c)) 1) '(1 2 3)))
(assert (equal? ((λ (a (b 2) (c 3)) (list a b c)) 1 8) '(1 8 3)))
(assert (equal? ((λ (a (b 2) (c 3)) (list a b c)) 1 8 9) '(1 8 9)))
-(assert (equal? ((λ ((x 0) . r) (list x r))) '(0 ())))
+(assert (equal? ((λ ((x 0) . r) (list x r))) '(0 NIL)))
(assert (equal? ((λ ((x 0) . r) (list x r)) 1 2 3) '(1 (2 3))))
; keyword arguments
@@ -375,7 +375,7 @@
(io->str b)))
(let ((c #\a))
- (assert (equal? (with-output-to-str nil (λ () (print (list c c))))
+ (assert (equal? (with-output-to-str NIL (λ () (print (list c c))))
"(#\\a #\\a)")))
(assert-fail (eval '(set! (car (cons 1 2)) 3)))
@@ -384,10 +384,10 @@
(assert (equal? ````x '```x))
(assert-fail (eval '(append 1)))
-(assert-fail (eval '(append '() 1)))
-(assert (equal? (append) '()))
-(assert (equal? (append '()) '()))
-(assert (equal? (append '() '()) '()))
+(assert-fail (eval '(append NIL 1)))
+(assert (equal? (append) NIL))
+(assert (equal? (append NIL) NIL))
+(assert (equal? (append NIL NIL) NIL))
(assert (equal? (append '(1 2)) '(1 2)))
(assert (equal? (append '(1 2) '(3 4)) '(1 2 3 4)))
@@ -399,22 +399,22 @@
;; unbinding
(def abc 1)
-(assert (equal? (bound? 'abc) t))
+(assert (equal? (bound? 'abc) T))
(assert (equal? (eval '(+ abc 1)) 2))
(makunbound 'abc)
-(assert (equal? (bound? 'abc) nil))
+(assert (equal? (bound? 'abc) NIL))
(assert-fail (eval '(+ abc 1)))
;; c***r of empty list
-(assert (not (car '())))
-(assert (not (cdr '())))
-(assert (not (cadr '())))
-(assert (not (cdar '())))
-(assert (not (caaar '())))
-(assert (not (cdddr '())))
+(assert (not (car NIL)))
+(assert (not (cdr NIL)))
+(assert (not (cadr NIL)))
+(assert (not (cdar NIL)))
+(assert (not (caaar NIL)))
+(assert (not (cdddr NIL)))
;; for-each with multiple lists
-(def q '())
+(def q NIL)
(for-each (λ (x y) (set! q (cons (+ x y) q))) #(1 2 3) #vu8(4 5 6))
(assert (equal? q '(9 7 5)))
(def q 0)
@@ -444,8 +444,8 @@
(assert (equal? (fixnum #\o) (aref #("hello") 0 (1+ 3)))) (assert-fail (aref #("hello") 0 5)) (assert-fail (aref #("hello") 1 0))-(assert-fail (aref '(()) 0 0))
-(assert-fail (apply aref '((()) 0 0)))
+(assert-fail (aref '(NIL) 0 0))
+(assert-fail (apply aref '((NIL) 0 0)))
;; aset with multiple indices
(def a #(#(0 1 2) #(3 (4 5 6) 7)))
@@ -454,8 +454,8 @@
(assert (equal? "hello" (aset! a (1+ 0) 2 "hello")))
(assert-fail (aset! a 1 1 3 "nope"))
(assert (equal? a #(#(8 1 2) #(3 (4 5 9) "hello"))))
-(assert-fail (aset! '(()) 0 0 1))
-(assert-fail (apply aset! '((()) 0 0 1)))
+(assert-fail (aset! '(NIL) 0 0 1))
+(assert-fail (apply aset! '((NIL) 0 0 1)))
;; apply with multiple args
(assert (equal? 15 (apply + 1 2 '(3 4 5))))