shithub: sl

--- a/boot/sl.boot

+++ b/boot/sl.boot

@@ -21,32 +21,58 @@

                                                (name (:type vec) (:named T) (:constructor T) (:conc-name

   NIL)

                                                      (:predicate NIL) . slots))  compare ((x y))  buffer (NIL)  num? ((v))  add-exit-hook ((fun))  rand-float (NIL)  builtin? ((v))  set-car! ((cell

-  new-first))  cons? ((v))  1+ ((n))  aref ((sequence subscript0 . rest))  zero? ((x))  vec (rest)  >= ((a . rest))  sym? ((v))  void? ((x))  length= ((lst

+  new-first))  cons? ((v))  doc-group ((group-name doc))  1+ ((n))  aref ((sequence subscript0 . rest))  zero? ((x))  vec (rest)  >= ((a . rest))  sym? ((v))  void? ((x))  length= ((lst

   n))  positive? ((x))  doc-for ((term . doc))  aset! ((sequence subscripts… new-value))  car ((lst))  <= ((a . rest))  str (term)  cons ((first

   second))  - ((a . rest))  remprop ((symbol key))  negative? ((x))  rand (NIL)  void (rest)  file ((path

   (:read NIL) (:write NIL) (:create NIL) (:truncate NIL) (:append NIL)))  rand-double (NIL)  1- ((n))  atom? ((value))  cdr ((lst))  vec? ((v))  / ((x . rest))  equal? ((a

   b))  eqv? ((a b))  io? ((term))  eof-object? ((term))  list (rest)  apply ((fn arg . rest))  help ((term

-  (:print-header help-print-header)))  rand-u32 (NIL)  = ((a . rest))  rand-u64 (NIL)  not ((v))  separate-doc-from-body ((body

-  (doc NIL)))  set-cdr! ((cell new-second))  fn? ((v))  help-print-header ((term sigs))  lz-pack ((data

+  (kind NIL) (:print-header help-print-header)))  rand-u32 (NIL)  = ((a . rest))  rand-u64 (NIL)  not ((v))  separate-doc-from-body ((body

+  (doc NIL)))  set-cdr! ((cell new-second))  fn? ((v))  help-print-header ((term sigs (:kind NIL)

+                                                                                 (:lpad "")))  lz-pack ((data

   (level 0)))  *prompt* (NIL)  eq? ((a b))  getprop ((symbol key (def NIL)))  vm-stats (NIL)  * (rest)  putprop ((symbol

-  key val))  io->str ((io)))  *doc* #table(identity "Return `x`."  bound? "Return `T` if `symbol` has a value associated with it, `NIL` otherwise."  sym-set-doc "Set the documentation for the symbol."  io-eof? "Return `T` if `io` is currently in the \"end of file\" state, `NIL`\notherwise."  < "Return `T` if the arguments are in strictly increasing order (next\none is greater than the previous one).  With a single argument\nthe result is always `T`."  cadr "Shorthand for `(car (cdr cell))`, that is, \"first element of the\nsecond element\".\n\nExamples:\n\n    (cadr '(1 2 3)) → 2\n    (cadr '(1))     → NIL\n    (cadr NIL)      → NIL"  nan? "Return `T` if `v` is a floating point representation of NaN, either\nnegative or positive, `NIL` otherwise."  for "Call the function `fn` with a single integer argument, starting from\n`min` and ending with `max`.\n\nExamples:\n\n    (for 0 2 (λ (i) (print (- 2 i)))) → 210"  fixnum? "Return `T` if `v` is of a fixnum type, `NIL` otherwise."  exit "Terminate the process with the specified status.  Does not return.\nThe status is expected to be a string in case of an error.\n\nExamples:\n\n    (exit) ; exit with status 0 (nil on Plan 9)\n    (exit \"error\") ; exit with status 1 (\"error\" on Plan 9)"  > "Return `T` if the arguments are in strictly decreasing order (previous\none is greater than the next one)."  + "Return sum of the arguments or `0` when none specified."  div0 "Return the quotient of two numbers.  For non-integers this is\nequivalent to `(div0 (floor a) (floor b))`.  The result is always an\ninteger.\n\nExamples:\n\n    (div0 7 2)     → 3\n    (div0 10 -2)   → -5\n    (div0 6.9 1.9) → 6"  __finish "A function called right before exit by the VM."  lz-unpack "Return decompressed data previously compressed using lz-pack.\n\nEither destination for the decompressed data or the expected size of\nthe decompressed data must be specified.  In the latter case a new\narray is allocated."  defstruct "Defines a structure type with a specific name and slots.\n\nThe default underlying type is a \"named\" vector (`:type vec`),\nwhere the first element is the name of the structure's type, the\nrest are the slot values.  If the name as the first element isn't\nrequired, `:named NIL` should be used.  A list can be used instead\nof a vector by adding `:type list` option.\n\nAn example of a default constructor signature, based on structure\ndefinition:\n\n    (defstruct blah \"Return stuff.\" :doc-group stuff a b c) →\n      (make-blah (:a NIL) (:b NIL) (:c NIL))\n\nIt can be customized in several ways. For example:\n\n    ; disable the constructor altogether\n    (defstruct :constructor NIL a b c)\n    ; only change its name\n    (defstruct blah :constructor blargh a b c)\n    ; rename AND avoid using keywords\n    (defstruct blah :constructor (blah a b c) a b c)\n\nThe option `:conc-name` specifies the slot accessor prefix, which\ndefaults to `name-`.\n\nDefault predicate name (`name?`) can be changed:\n\n    ; use \"blargh?\" instead of \"blah?\"\n    (defstruct blah :predicate blargh? a b c)"  compare "Return -1 if `x` is less than `y`, 0 if equal, and `1` if `y` is\ngreater than `x`.\n\nExamples:\n\n    (compare 'a 'b)       → -1\n    (compare 1 1)         → 0\n    (compare \"b\" \"a\") → 1"  buffer "Return an in-memory buffer for I/O, of `io` type.\n\nA buffer can be used for both reading and writing at the same\ntime."  num? "Return `T` if `v` is of a numerical type, `NIL` otherwise.\n\nNumerical types include floating point, fixnum, bignum, etc.\nNote: ironically, a NaN value is considered a number by this function\nsince it's only testing the _type_ of the value."  add-exit-hook "Puts an one-argument function on top of the list of exit hooks.\n\nOn shutdown each exit hook is called with the exit status as a single\nargument, which is (usually) `NIL` on success and a string describing\nan error otherwise."  rand-float "Return a random float on [0.0, 1.0] interval."  builtin? "Return `T` if `v` is a built-in function implemented in C, `NIL`\notherwise.\n\nExamp

\ No newline at end of file

-  props)  vec ((:doc-group . builtin))  >= ((:doc-group . compare))  sym? ((:doc-group . builtin))  zero? ((:doc-group . compare))  length= ((:doc-group . list))  positive? ((:doc-group . compare))  doc-for ((:doc-group . doc))  aset! ((:doc-group . builtin))  car ((:doc-group . builtin))  *builtins* ((:doc-group . builtin))  str ((:doc-group . string))  cons ((:doc-group . builtin))  - ((:doc-group . builtin))  remprop ((:doc-group . props))  <= ((:doc-group . compare))  rand ((:doc-group . random))  negative? ((:doc-group . compare))  Instructions ((:doc-group . builtin))  file ((:doc-group . io))  rand-double ((:doc-group . random))  atom? ((:doc-group . builtin))  cdr ((:doc-group . builtin))  T ((:doc-see))  vec? ((:doc-group . builtin))  equal? ((:doc-group . builtin))  / ((:doc-group . builtin))  eqv? ((:doc-group . builtin))  io? ((:doc-group . io))  eof-object? ((:doc-group . io))  list ((:doc-group . builtin))  apply ((:doc-group . builtin))  help ((:doc-group . doc))  rand-u32 ((:doc-group . random))  = ((:doc-group . builtin))  rand-u64 ((:doc-group . random))  not ((:doc-group . builtin))  NIL ((:doc-see . T))  set-cdr! ((:doc-group . builtin))  separate-doc-from-body ((:doc-group . doc))  fn? ((:doc-group . builtin))  help-print-header ((:doc-group . doc))  lz-pack ((:doc-group . compress))  arg-counts ((:doc-group . builtin))  eq? ((:doc-group . builtin))  getprop ((:doc-group . props))  vm-stats ((:doc-group . vm))  * ((:doc-group . builtin))  putprop ((:doc-group . props))  io->str ((:doc-group . io))))

+  key val))  io->str ((io)))  *doc* #table(identity "Return `x`."  (doc group vm) "VM-related functions."  bound? "Return `T` if `symbol` has a value associated with it, `NIL` otherwise."  sym-set-doc "Set the documentation for the symbol."  io-eof? "Return `T` if `io` is currently in the \"end of file\" state, `NIL`\notherwise."  < "Return `T` if the arguments are in strictly increasing order (next\none is greater than the previous one).  With a single argument\nthe result is always `T`."  cadr "Shorthand for `(car (cdr cell))`, that is, \"first element of the\nsecond element\".\n\nExamples:\n\n    (cadr '(1 2 3)) → 2\n    (cadr '(1))     → NIL\n    (cadr NIL)      → NIL"  nan? "Return `T` if `v` is a floating point representation of NaN, either\nnegative or positive, `NIL` otherwise."  for "Call the function `fn` with a single integer argument, starting from\n`min` and ending with `max`.\n\nExamples:\n\n    (for 0 2 (λ (i) (print (- 2 i)))) → 210"  fixnum? "Return `T` if `v` is of a fixnum type, `NIL` otherwise."  exit "Terminate the process with the specified status.  Does not return.\nThe status is expected to be a string in case of an error.\n\nExamples:\n\n    (exit) ; exit with status 0 (nil on Plan 9)\n    (exit \"error\") ; exit with status 1 (\"error\" on Plan 9)"  (doc

+  group compare) "Comparison operators."  (doc group compress) "Compression."  + "Return sum of the arguments or `0` when none specified."  (doc

+  group builtin) "Built-in operators."  div0 "Return the quotient of two numbers.  For non-integers this is\nequivalent to `(div0 (floor a) (floor b))`.  The result is always an\ninteger.\n\nExamples:\n\n    (div0 7 2)     → 3\n    (div0 10 -2)   → -5\n    (div0 6.9 1.9) → 6"  lz-unpack "Return decompressed data previously compressed using lz-pack.\n\nEither destination for the decompressed data or the expected size of\nthe decompressed data must be specified.  In the latter case a new\narray is allocated."  > "Return `T` if the arguments are in strictly decreasing order (previous\none is greater than the next one)."  __finish "A function called right before exit by the VM."  defstruct "Defines a structure type with a specific name and slots.\n\nThe default underlying type is a \"named\" vector (`:type vec`),\nwhere the first element is the name of the structure's type, the\nrest are the slot values.  If the name as the first element isn't\nrequired, `:named NIL` should be used.  A list can be used instead\nof a vector by adding `:type list` option.\n\nAn example of a default constructor signature, based on structure\ndefinition:\n\n    (defstruct blah \"Return stuff.\" :doc-group stuff a b c) →\n      (make-blah (:a NIL) (:b NIL) (:c NIL))\n\nIt can be customized in several ways. For example:\n\n    ; disable the constructor altogether\n    (defstruct :constructor NIL a b c)\n    ; only change its name\n    (defstruct blah :constructor blargh a b c)\n    ; rename AND avoid using keywords\n    (defstruct blah :constructor (blah a b c) a b c)\n\nThe option `:conc-name` specifies the slot accessor prefix, which\ndefaults to `name-`.\n\nDefault predicate name (`name?`) can be changed:\n\n    ; use \"blargh?\" instead of \"blah?\"\n    (defstruct blah :predicate blargh? a b c)"  (doc

+  group io) "I/O functionality."  compare "Return -1 if `x` is less than `y`, 0 if equal, and `1` if `y` is\ngreater than `x`.\n\nExamples:\n\n    (compare 'a 'b)       → -1\n    (compare 1 1)         → 0\n    (compare \"b\" \"a\") → 1"  buffer "Return an in-memory buffer for I/O, of `io` type.\n\nA buffer can be used for both reading and writing at the same\ntime."  num? "Return `T` if `v` is of a numerical type, `NIL` otherwise.\n\nNumerical types include floating point, fixnum, bignum, etc.\nNote: ironically, a NaN value is considered a number by this function\nsince it's only testing the _type_ of the value."  add-exit-hook "Puts an one-argument function on top of the list of exit hooks.\n\nOn shutdown each exit hook is called with the exit status as a single\nargument, which is (usually) `NIL` on success and a string describing\nan error otherwise."  rand-float "Return a random float on [0.0, 1.0] interval."  builtin? "Return `T` if `v` is a built-in function implemented in C, `NIL`\notherwise.\n\nExamples:\n\n    (builtin? map)         → T\n    (builtin? macroexpand) → NIL"  set-car! "Modify a cons cell (a list) in-place by putting `new-first` as its\nfirst element (head of the list).  Return the modified cons\ncell (list).\n\nExamples:\n\n    (def q '(1 2 3 4 5))\n    (set-car! q 0) → (0 6 7)\n    q              → (0 6 7)"  doc-group "Define documentation for a group."  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."  (doc

+  group string) "String-related functionality."  void? "Return `T` if `x` is `#<void>`, `NIL` otherwise."  zero? "Return `T` if `x` is zero."  (doc

+  group list) "Working with lists."  positive? "Return `T` if `x` is greater than zero."  length= "Perform a bounded length test.\n\nUse this instead of `(= (length lst) n)`, since it avoids unnecessary\nwork and always terminates."  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.\n\nFirst `doc` argument is supposed to be a string with the description\nof the term.  The following arguments are expected to be optional tag\npairings that provide grouping for multiple symbols and \"see also\"\nreferences.\n\nUseful in cases where setting the documentation for a term can't\n(or not preferred to) be made during the definition of said term.\nOne of those reasons is that the term is a built-in function\nimplemented in C.\n\nExamples:\n\n    (doc-for (func arg (arg2 0))\n      \"Return something about the `arg` and `arg2`.  This is a short\n       description.\n\n       This is the longer description, following the short one.\n\n       Examples:\n\n           (func 0)   → T\n           (func 1 3) → NIL\"\n      :doc-group stuff\n      :doc-see func2)\n    (doc-for (func arg (:another-variant NIL)))"  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 "Return concatenation of terms formatted as strings.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed.\n\nExamples:\n\n    (str \"a\" 'b 1 #(0)) → \"ab1#(0)\""  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 the 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]."  (doc

+  group sys) "OS-specific functions."  (doc group rand) "Random numbers generation."  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"  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"  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."  (doc

+  group prop) "Dealing with symbols' properties."  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"  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)"  / "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…"  help "Display documentation the specified term, if available.\n\nThe optional parameter `kind` can be set to `group` to show\ndocumentation for the specified group instead of a single term.\nAll available documentation groups can be displayed with `(help\ngroups)`."  1- "Equivalent to `(- n 1)`."  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.  Can be used as the opposite of T in boolean\nexpressions.\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)"  (doc

+  group doc) "Writing and reading documentation."  fn? "Return `T` if `v` is a function, `NIL` otherwise.\n\nExamples:\n\n    (fn? map)         → T\n    (fn? macroexpand) → T"  separate-doc-from-body "Take a list of terms and return a pair `(doc . body)`, where the first\nelement contains a list of documentation-related terms, and the second\ncontains the rest of the terms."  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."  help-print-header "Format and print signature(s) of the term for `(help term)` output."  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"  *prompt* "Function called by REPL to signal the user input is required.\n\nDefault function prints `#;> `."  getprop "Return a property value associated with the symbol or `def` if\nmissing."  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 the symbol."  io->str "Return an in-memory `io` buffer converted to a string.")  *doc-extra* #table(bound? ((:doc-group . builtin))  sym-set-doc ((:doc-group . doc))  io-eof? ((:doc-group . io))  < ((:doc-group . compare)

+  (:doc-group . builtin))  cadr ((:doc-group . list) (:doc-group . builtin))  nan? ((:doc-group . builtin))  for ((:doc-group . builtin))  fixnum? ((:doc-group . builtin))  exit ((:doc-group . sys))  > ((:doc-group . compare))  + ((:doc-group . builtin))  div0 ((:doc-group . builtin))  lz-unpack ((:doc-group . compress))  compare ((:doc-group . builtin))  buffer ((:doc-group . io))  num? ((:doc-group . builtin))  rand-float ((:doc-group . rand))  builtin? ((:doc-group . builtin))  set-car! ((:doc-group . list)

+  (:doc-group . builtin))  cons? ((:doc-group . builtin))  doc-group ((:doc-group . doc))  aref ((:doc-group . builtin))  *properties* (:doc-group

+  prop)  vec ((:doc-group . builtin))  >= ((:doc-group . compare))  sym? ((:doc-group . builtin))  zero? ((:doc-group . compare))  length= ((:doc-group . list))  positive? ((:doc-group . compare))  doc-for ((:doc-group . doc))  aset! ((:doc-group . builtin))  car ((:doc-group . list)

+  (:doc-group . builtin))  *builtins* ((:doc-group . builtin))  str ((:doc-group . string))  cons ((:doc-group . list)

+  (:doc-group . builtin))  - ((:doc-group . builtin))  remprop ((:doc-group . prop))  <= ((:doc-group . compare))  rand ((:doc-group . rand))  negative? ((:doc-group . compare))  Instructions ((:doc-group . builtin))  file ((:doc-group . io))  rand-double ((:doc-group . rand))  atom? ((:doc-group . builtin))  cdr ((:doc-group . list)

+  (:doc-group . builtin))  T ((:doc-see))  vec? ((:doc-group . builtin))  equal? ((:doc-group . compare)

+                                                                                  (:doc-group . builtin))  / ((:doc-group . builtin))  eqv? ((:doc-group . compare)

+  (:doc-group . builtin))  io? ((:doc-group . io))  eof-object? ((:doc-group . io))  list ((:doc-group . builtin))  apply ((:doc-group . builtin))  help ((:doc-group . doc))  rand-u32 ((:doc-group . rand))  = ((:doc-group . compare)

+  (:doc-group . builtin))  rand-u64 ((:doc-group . rand))  not ((:doc-group . builtin))  NIL ((:doc-see . T))  set-cdr! ((:doc-group . list)

+  (:doc-group . builtin))  separate-doc-from-body ((:doc-group . doc))  fn? ((:doc-group . builtin))  help-print-header ((:doc-group . doc))  lz-pack ((:doc-group . compress))  arg-counts ((:doc-group . builtin))  eq? ((:doc-group . compare)

+  (:doc-group . builtin))  getprop ((:doc-group . prop))  vm-stats ((:doc-group . vm))  * ((:doc-group . builtin))  putprop ((:doc-group . prop))  io->str ((:doc-group . io))))

 ry\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.\n\nFirst `doc` argument is supposed to be a string with the description\nof the term.  The following arguments are expected to be optional tag\npairings that provide grouping for multiple symbols and \"see also\"\nreferences.\n\nUseful in cases where setting the documentation for a term can't\n(or not preferred to) be made during the definition of said term.\nOne of those reasons is that the term is a built-in function\nimplemented in C.\n\nExamples:\n\n    (doc-for (func arg (arg2 0))\n      \"Return something about the `arg` and `arg2`.  This is a short\n       description.\n\n       This is the longer description, following the short one.\n\n       Examples:\n\n           (func 0)   → T\n           (func 1 3) → NIL\"\n      :doc-group stuff\n      :doc-see func2)\n    (doc-for (func arg (:another-variant NIL)))"  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 "Return concatenation of terms formatted as strings.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed.\n\nExamples:\n\n    (str \"a\" 'b 1 #(0)) → \"ab1#(0)\""  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 the 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)

\ No newline at end of file

   props)  vec ((:doc-group . builtin))  >= ((:doc-group . compare))  sym? ((:doc-group . builtin))  zero? ((:doc-group . compare))  length= ((:doc-group . list))  positive? ((:doc-group . compare))  doc-for ((:doc-group . doc))  aset! ((:doc-group . builtin))  car ((:doc-group . builtin))  *builtins* ((:doc-group . builtin))  str ((:doc-group . string))  cons ((:doc-group . builtin))  - ((:doc-group . builtin))  remprop ((:doc-group . props))  <= ((:doc-group . compare))  rand ((:doc-group . random))  negative? ((:doc-group . compare))  Instructions ((:doc-group . builtin))  file ((:doc-group . io))  rand-double ((:doc-group . random))  atom? ((:doc-group . builtin))  cdr ((:doc-group . builtin))  T ((:doc-see))  vec? ((:doc-group . builtin))  equal? ((:doc-group . builtin))  / ((:doc-group . builtin))  eqv? ((:doc-group . builtin))  io? ((:doc-group . io))  eof-object? ((:doc-group . io))  list ((:doc-group . builtin))  apply ((:doc-group . builtin))  help ((:doc-group . doc))  rand-u32 ((:doc-group . random))  = ((:doc-group . builtin))  rand-u64 ((:doc-group . random))  not ((:doc-group . builtin))  NIL ((:doc-see . T))  set-cdr! ((:doc-group . builtin))  separate-doc-from-body ((:doc-group . doc))  fn? ((:doc-group . builtin))  help-print-header ((:doc-group . doc))  lz-pack ((:doc-group . compress))  arg-counts ((:doc-group . builtin))  eq? ((:doc-group . builtin))  getprop ((:doc-group . props))  vm-stats ((:doc-group . vm))  * ((:doc-group . builtin))  putprop ((:doc-group . props))  io->str ((:doc-group . io))))

             *syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref))  doc-for #fn("z10B86;35040<;J404086;35040=70151<863I0212287e22289e22288e2e4:212287e22289e2e3:" #(separate-doc-from-body

   sym-set-doc quote))  with-input-from #fn("z12021e1220e2e1e12315163:" #(#fn(nconc) with-bindings

                                                                          *io-in* #fn(copy-list)))  unless #fn("z1200q211Pe4:" #(if

-those reasons is that the term is a built-in function\nimplemented in C.\n\nExamples:\n\n    (doc-for (func arg (arg2 0))\n      \"Return something about the `arg` and `arg2`.  This is a short\n       description.\n\n       This is the longer description, following the short one.\n\n       Examples:\n\n           (func 0)   → T\n           (func 1 3) → NIL\"\n      :doc-group stuff\n      :doc-see func2)\n    (doc-for (func arg (:another-variant NIL)))"  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 "Return concatenation of terms formatted as strings.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed.\n\nExamples:\n\n    (str \"a\" 'b 1 #(0)) → \"ab1#(0)\""  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 the 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\nExample

\ No newline at end of file

+  #:g431 time-now prog1 princ "Elapsed time: " - " seconds" *linefeed*))  cond #fn("z0Ib520852185>1_51485<061:" #(#0=#fn("z0I:" #() void)

 something about the `arg` and `arg2`.  This is a short\n       description.\n\n       This is the longer description, following the short one.\n\n       Examples:\n\n           (func 0)   → T\n           (func 1 3) → NIL\"\n      :doc-group stuff\n      :doc-see func2)\n    (doc-for (func arg (:another-variant NIL)))"  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 "Return concatenation of terms formatted as strings.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed.\n\nExamples:\n\n    (str \"a\" 'b 1 #(0)) → \"ab1#(0)\""  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 the 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) → NIL\n    (eqv? 0 0)   → T\n    (def a \"1\")\n    (def b \"1\")\n    (eqv? a b)   → T\n    (def a '(1))\n

\ No newline at end of file

   props)  vec ((:doc-group . builtin))  >= ((:doc-group . compare))  sym? ((:doc-group . builtin))  zero? ((:doc-group . compare))  length= ((:doc-group . list))  positive? ((:doc-group . compare))  doc-for ((:doc-group . doc))  aset! ((:doc-group . builtin))  car ((:doc-group . builtin))  *builtins* ((:doc-group . builtin))  str ((:doc-group . string))  cons ((:doc-group . builtin))  - ((:doc-group . builtin))  remprop ((:doc-group . props))  <= ((:doc-group . compare))  rand ((:doc-group . random))  negative? ((:doc-group . compare))  Instructions ((:doc-group . builtin))  file ((:doc-group . io))  rand-double ((:doc-group . random))  atom? ((:doc-group . builtin))  cdr ((:doc-group . builtin))  T ((:doc-see))  vec? ((:doc-group . builtin))  equal? ((:doc-group . builtin))  / ((:doc-group . builtin))  eqv? ((:doc-group . builtin))  io? ((:doc-group . io))  eof-object? ((:doc-group . io))  list ((:doc-group . builtin))  apply ((:doc-group . builtin))  help ((:doc-group . doc))  rand-u32 ((:doc-group . random))  = ((:doc-group . builtin))  rand-u64 ((:doc-group . random))  not ((:doc-group . builtin))  NIL ((:doc-see . T))  set-cdr! ((:doc-group . builtin))  separate-doc-from-body ((:doc-group . doc))  fn? ((:doc-group . builtin))  help-print-header ((:doc-group . doc))  lz-pack ((:doc-group . compress))  arg-counts ((:doc-group . builtin))  eq? ((:doc-group . builtin))  getprop ((:doc-group . props))  vm-stats ((:doc-group . vm))  * ((:doc-group . builtin))  putprop ((:doc-group . props))  io->str ((:doc-group . io))))

-lue.  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 "Return concatenation of terms formatted as strings.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed.\n\nExamples:\n\n    (str \"a\" 'b 1 #(0)) → \"ab1#(0)\""  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 the 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) → 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\

\ No newline at end of file

+  car cadr #fn("n170051B38071061:0<:" #(cddr caddr)) letrec #:g403 λ if #fn(nconc) begin #fn(copy-list)))  mark-label #fn("n22002122e21e4:" #(emit

 ((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 "Return concatenation of terms formatted as strings.\n\nThis is equivalent to `(princ terms…)`, except the string is\nreturned, rather than printed.\n\nExamples:\n\n    (str \"a\" 'b 1 #(0)) → \"ab1#(0)\""  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 the 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) → 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\narg

\ No newline at end of file

   props)  vec ((:doc-group . builtin))  >= ((:doc-group . compare))  sym? ((:doc-group . builtin))  zero? ((:doc-group . compare))  length= ((:doc-group . list))  positive? ((:doc-group . compare))  doc-for ((:doc-group . doc))  aset! ((:doc-group . builtin))  car ((:doc-group . builtin))  *builtins* ((:doc-group . builtin))  str ((:doc-group . string))  cons ((:doc-group . builtin))  - ((:doc-group . builtin))  remprop ((:doc-group . props))  <= ((:doc-group . compare))  rand ((:doc-group . random))  negative? ((:doc-group . compare))  Instructions ((:doc-group . builtin))  file ((:doc-group . io))  rand-double ((:doc-group . random))  atom? ((:doc-group . builtin))  cdr ((:doc-group . builtin))  T ((:doc-see))  vec? ((:doc-group . builtin))  equal? ((:doc-group . builtin))  / ((:doc-group . builtin))  eqv? ((:doc-group . builtin))  io? ((:doc-group . io))  eof-object? ((:doc-group . io))  list ((:doc-group . builtin))  apply ((:doc-group . builtin))  help ((:doc-group . doc))  rand-u32 ((:doc-group . random))  = ((:doc-group . builtin))  rand-u64 ((:doc-group . random))  not ((:doc-group . builtin))  NIL ((:doc-see . T))  set-cdr! ((:doc-group . builtin))  separate-doc-from-body ((:doc-group . doc))  fn? ((:doc-group . builtin))  help-print-header ((:doc-group . doc))  lz-pack ((:doc-group . compress))  arg-counts ((:doc-group . builtin))  eq? ((:doc-group . builtin))  getprop ((:doc-group . props))  vm-stats ((:doc-group . vm))  * ((:doc-group . builtin))  putprop ((:doc-group . props))  io->str ((:doc-group . io))))

             *syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref))  doc-for #fn("z10B86;35040<;J404086;35040=70151<863I0212287e22289e22288e2e4:212287e22289e2e3:" #(separate-doc-from-body

   sym-set-doc quote))  with-input-from #fn("z12021e1220e2e1e12315163:" #(#fn(nconc) with-bindings

-taining 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 the 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) → 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.  Can be used as the opposite of T in boolean\nexpressions.\n\nExamples:\n\n    (not NIL)         → T\n    (if NIL 'yes 'no) → no\n    (car NIL)         → NIL\n    (cdr NI

\ No newline at end of file

-  props)  vec ((:doc-group . builtin))  >= ((:doc-group . compare))  sym? ((:doc-group . builtin))  zero? ((:doc-group . compare))  length= ((:doc-group . list))  positive? ((:doc-group . compare))  doc-for ((:doc-group . doc))  aset! ((:doc-group . builtin))  car ((:doc-group . builtin))  *builtins* ((:doc-group . builtin))  str ((:doc-group . string))  cons ((:doc-group . builtin))  - ((:doc-group . builtin))  remprop ((:doc-group . props))  <= ((:doc-group . compare))  rand ((:doc-group . random))  negative? ((:doc-group . compare))  Instructions ((:doc-group . builtin))  file ((:doc-group . io))  rand-double ((:doc-group . random))  atom? ((:doc-group . builtin))  cdr ((:doc-group . builtin))  T ((:doc-see))  vec? ((:doc-group . builtin))  equal? ((:doc-group . builtin))  / ((:doc-group . builtin))  eqv? ((:doc-group . builtin))  io? ((:doc-group . io))  eof-object? ((:doc-group . io))  list ((:doc-group . builtin))  apply ((:doc-group . builtin))  help ((:doc-group . doc))  rand-u32 ((:doc-group . random))  = ((:doc-group . builtin))  rand-u64 ((:doc-group . random))  not ((:doc-group . builtin))  NIL ((:doc-see . T))  set-cdr! ((:doc-group . builtin))  separate-doc-from-body ((:doc-group . doc))  fn? ((:doc-group . builtin))  help-print-header ((:doc-group . doc))  lz-pack ((:doc-group . compress))  arg-counts ((:doc-group . builtin))  eq? ((:doc-group . builtin))  getprop ((:doc-group . props))  vm-stats ((:doc-group . vm))  * ((:doc-group . builtin))  putprop ((:doc-group . props))  io->str ((:doc-group . io))))

-            *syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref))  doc-for #fn("z10B86;35040<;J404086;35040=70151<863I0212287e22289e22288e2e4:212287e22289e2e3:" #(separate-doc-from-body

+  < reverse))  when #fn("z1200211Pqe4:" #(if begin))  help #fn("O100010003000W1000J60q?14W2000J7071?24Ib7228723_514024CG0252687>12778295252@\x08013;02:10e3@3007;8829527;882<q531;3<042=2>1520P2?89;J5048:3\x8d082888:2@1544893@07A895147B50@30q413_07B5047A2C5147B504252D8;8<>2277829525247B50@30q47E50@g07A2F13<02G12H52@402I05341JE00R3@00ZJ;07A2J51@30q47B50^1^1^1^1^147E60:" #(#(:print-header

+  0) help-print-header #0# #fn("n12002152853;0220E8563:0:" #(#fn(str-find) "\n" #fn(str-sub)) first-line)

+  groups #fn(for-each) #fn("n20B3\\00<20CU00T21CN0727305124A<7502652515347760:q:" #(doc group princ

+                                                                                    caddr ": "

+                                                                                    getprop *doc*

+                                                                                    newline))

+  #fn(get) *properties* *doc* doc getprop *formals-list* #fn(sym) ":doc-" #fn("n313?02021820>2162:72825147305147460:" #(#fn(for-each)

+  #fn("n170A51471F0P5147260:" #(princ print newline)) princ print newline)) :kind princ newline "Members:"

+  #fn("n20H3P070A7102252523A0F071023q532463:q:" #(member getprop *doc-extra* *formals-list* "    "))

+  void "no help for " #fn(str) " " "" " (undefined)"))  defstruct #fn("O10005000*///W1000J7071?14W2000J60D?24W3000J60D?34W4000J60q?44W5000J60q?54z6IIb;228;230>1_5142224?<5147586518=<8==268?5127288?528<8?512912:5285;J:042902:5283;3\\0483H;3M0483DQ;3:04292;052;J504838BP;J5048382;36040e184;J:042<02=528>3<07>08>52@30q42?2@e12A8D2Be22C8C2Be22D2E2F8Fe2e22G2H2BEe32F0e2e3e32I2J2Be2268F518@Me3e4e3e18E3X02A8E2?1e12?2Fe12K8F5152e12K8A5153e3@30qe12K7L2M8;8B8A8G8D8F0>78@525164:" #(#(NIL

  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) → 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.  Can be used as the opposite of T in boolean\nexpressions.\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)"  separate-doc-from-body "Take a list of terms and return a pair `(doc . body)`, where the first\nelement contains a list of documentation-related terms, and the second\ncontains the rest of the terms."  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 signature(s) of the term for `(help term)` output."  lz-pack "Return data compressed using Lempe

\ No newline at end of file

   props)  vec ((:doc-group . builtin))  >= ((:doc-group . compare))  sym? ((:doc-group . builtin))  zero? ((:doc-group . compare))  length= ((:doc-group . list))  positive? ((:doc-group . compare))  doc-for ((:doc-group . doc))  aset! ((:doc-group . builtin))  car ((:doc-group . builtin))  *builtins* ((:doc-group . builtin))  str ((:doc-group . string))  cons ((:doc-group . builtin))  - ((:doc-group . builtin))  remprop ((:doc-group . props))  <= ((:doc-group . compare))  rand ((:doc-group . random))  negative? ((:doc-group . compare))  Instructions ((:doc-group . builtin))  file ((:doc-group . io))  rand-double ((:doc-group . random))  atom? ((:doc-group . builtin))  cdr ((:doc-group . builtin))  T ((:doc-see))  vec? ((:doc-group . builtin))  equal? ((:doc-group . builtin))  / ((:doc-group . builtin))  eqv? ((:doc-group . builtin))  io? ((:doc-group . io))  eof-object? ((:doc-group . io))  list ((:doc-group . builtin))  apply ((:doc-group . builtin))  help ((:doc-group . doc))  rand-u32 ((:doc-group . random))  = ((:doc-group . builtin))  rand-u64 ((:doc-group . random))  not ((:doc-group . builtin))  NIL ((:doc-see . T))  set-cdr! ((:doc-group . builtin))  separate-doc-from-body ((:doc-group . doc))  fn? ((:doc-group . builtin))  help-print-header ((:doc-group . doc))  lz-pack ((:doc-group . compress))  arg-counts ((:doc-group . builtin))  eq? ((:doc-group . builtin))  getprop ((:doc-group . props))  vm-stats ((:doc-group . vm))  * ((:doc-group . builtin))  putprop ((:doc-group . props))  io->str ((:doc-group . io))))

             *syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref))  doc-for #fn("z10B86;35040<;J404086;35040=70151<863I0212287e22289e22288e2e4:212287e22289e2e3:" #(separate-doc-from-body

@@ -59,7 +85,7 @@

 mples:\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.  Can be used as the opposite of T in boolean\nexpressions.\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)"  separate-doc-from-body "Take a list of terms and return a pair `(doc . body)`, where the first\nelement contains a list of documentation-related terms, and the second\ncontains the rest of the terms."  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 signature(s) of the term 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 "Return a property value associated with the symbol or `def` if\nmissing."  vm-stats "Print various VM-related information, such as the number of GC\ncalls so far, hea

\ No newline at end of file

   props)  vec ((:doc-group . builtin))  >= ((:doc-group . compare))  sym? ((:doc-group . builtin))  zero? ((:doc-group . compare))  length= ((:doc-group . list))  positive? ((:doc-group . compare))  doc-for ((:doc-group . doc))  aset! ((:doc-group . builtin))  car ((:doc-group . builtin))  *builtins* ((:doc-group . builtin))  str ((:doc-group . string))  cons ((:doc-group . builtin))  - ((:doc-group . builtin))  remprop ((:doc-group . props))  <= ((:doc-group . compare))  rand ((:doc-group . random))  negative? ((:doc-group . compare))  Instructions ((:doc-group . builtin))  file ((:doc-group . io))  rand-double ((:doc-group . random))  atom? ((:doc-group . builtin))  cdr ((:doc-group . builtin))  T ((:doc-see))  vec? ((:doc-group . builtin))  equal? ((:doc-group . builtin))  / ((:doc-group . builtin))  eqv? ((:doc-group . builtin))  io? ((:doc-group . io))  eof-object? ((:doc-group . io))  list ((:doc-group . builtin))  apply ((:doc-group . builtin))  help ((:doc-group . doc))  rand-u32 ((:doc-group . random))  = ((:doc-group . builtin))  rand-u64 ((:doc-group . random))  not ((:doc-group . builtin))  NIL ((:doc-see . T))  set-cdr! ((:doc-group . builtin))  separate-doc-from-body ((:doc-group . doc))  fn? ((:doc-group . builtin))  help-print-header ((:doc-group . doc))  lz-pack ((:doc-group . compress))  arg-counts ((:doc-group . builtin))  eq? ((:doc-group . builtin))  getprop ((:doc-group . props))  vm-stats ((:doc-group . vm))  * ((:doc-group . builtin))  putprop ((:doc-group . props))  io->str ((:doc-group . io))))

             *syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref))  doc-for #fn("z10B86;35040<;J404086;35040=70151<863I0212287e22289e22288e2e4:212287e22289e2e3:" #(separate-doc-from-body

-→ 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.  Can be used as the opposite of T in boolean\nexpressions.\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)"  separate-doc-from-body "Take a list of terms and return a pair `(doc . body)`, where the first\nelement contains a list of documentation-related terms, and the second\ncontains the rest of the terms."  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 signature(s) of the term 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 "Return a property value associated with the symbol or `def` if\nmissing."  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 the symbol."  io->str "Return an in-memory `io` buffer converted to a string.")  *doc-extra* #table(bound? ((:doc-group . builtin))  sym-set-doc ((:doc-group . doc))  io-eof? ((:doc-group . io))  < ((:doc-group . builtin))  cadr ((:doc-group

\ No newline at end of file

+  λ #:g426 if and cons? eq? car quote thrown-value cadr caddr raise))  let* #fn("z10H3E02021e1qe12215153e1:2021e173051e1e1220=B3H02024e10=e12215153e1@301515375051e2:" #(#fn(nconc)

 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.  Can be used as the opposite of T in boolean\nexpressions.\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)"  separate-doc-from-body "Take a list of terms and return a pair `(doc . body)`, where the first\nelement contains a list of documentation-related terms, and the second\ncontains the rest of the terms."  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 signature(s) of the term 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 "Return a property value associated with the symbol or `def` if\nmissing."  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 the symbol."  io->str "Return an in-memory `io` buffer converted to a string.")  *doc-extra* #table(bound? ((:doc-group . builtin))  sym-set-doc ((:doc-group . doc))  io-eof? ((:doc-group . io))  < ((:doc-group . builtin))  cadr ((:doc-group . builtin))  nan? ((:doc-group . builtin))  for ((:doc-group . builtin))  fixnum? ((:doc-group . builtin))  exit ((:doc-group . system))  > ((:doc-group . compare))  + ((:doc-group

\ No newline at end of file

   props)  vec ((:doc-group . builtin))  >= ((:doc-group . compare))  sym? ((:doc-group . builtin))  zero? ((:doc-group . compare))  length= ((:doc-group . list))  positive? ((:doc-group . compare))  doc-for ((:doc-group . doc))  aset! ((:doc-group . builtin))  car ((:doc-group . builtin))  *builtins* ((:doc-group . builtin))  str ((:doc-group . string))  cons ((:doc-group . builtin))  - ((:doc-group . builtin))  remprop ((:doc-group . props))  <= ((:doc-group . compare))  rand ((:doc-group . random))  negative? ((:doc-group . compare))  Instructions ((:doc-group . builtin))  file ((:doc-group . io))  rand-double ((:doc-group . random))  atom? ((:doc-group . builtin))  cdr ((:doc-group . builtin))  T ((:doc-see))  vec? ((:doc-group . builtin))  equal? ((:doc-group . builtin))  / ((:doc-group . builtin))  eqv? ((:doc-group . builtin))  io? ((:doc-group . io))  eof-object? ((:doc-group . io))  list ((:doc-group . builtin))  apply ((:doc-group . builtin))  help ((:doc-group . doc))  rand-u32 ((:doc-group . random))  = ((:doc-group . builtin))  rand-u64 ((:doc-group . random))  not ((:doc-group . builtin))  NIL ((:doc-see . T))  set-cdr! ((:doc-group . builtin))  separate-doc-from-body ((:doc-group . doc))  fn? ((:doc-group . builtin))  help-print-header ((:doc-group . doc))  lz-pack ((:doc-group . compress))  arg-counts ((:doc-group . builtin))  eq? ((:doc-group . builtin))  getprop ((:doc-group . props))  vm-stats ((:doc-group . vm))  * ((:doc-group . builtin))  putprop ((:doc-group . props))  io->str ((:doc-group . io))))

             *syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref))  doc-for #fn("z10B86;35040<;J404086;35040=70151<863I0212287e22289e22288e2e4:212287e22289e2e3:" #(separate-doc-from-body

@@ -66,9 +92,11 @@

 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.  Can be used as the opposite of T in boolean\nexpressions.\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)"  separate-doc-from-body "Take a list of terms and return a pair `(doc . body)`, where the first\nelement contains a list of documentation-related terms, and the second\ncontains the rest of the terms."  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 signature(s) of the term 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 "Return a property value associated with the symbol or `def` if\nmissing."  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 the symbol."  io->str "Return an in-memory `io` buffer converted to a string.")  *doc-extra* #table(bound? ((:doc-group . builtin))  sym-set-doc ((:doc-group . doc))  io-eof? ((:doc-group . io))  < ((:doc-group . builtin))  cadr ((:doc-group . builtin))  nan? ((:doc-group . builtin))  for ((:doc-group . builtin))  fixnum? ((:doc-group . builtin))  exit ((:doc-group . system))  > ((:doc-group . compare))  + ((:doc-group . builtin))  div0 ((:doc-group . builtin))  lz-unpack ((:doc-group . compress))  compare ((:doc-group . builtin))  buffer ((:doc-group . io))  num? ((:doc-group . builtin))  rand-float ((:doc-group . random))  builtin? ((:doc-group . builtin))  set-car! ((:doc-group . builtin))  cons? ((:doc-gr

\ No newline at end of file

   props)  vec ((:doc-group . builtin))  >= ((:doc-group . compare))  sym? ((:doc-group . builtin))  zero? ((:doc-group . compare))  length= ((:doc-group . list))  positive? ((:doc-group . compare))  doc-for ((:doc-group . doc))  aset! ((:doc-group . builtin))  car ((:doc-group . builtin))  *builtins* ((:doc-group . builtin))  str ((:doc-group . string))  cons ((:doc-group . builtin))  - ((:doc-group . builtin))  remprop ((:doc-group . props))  <= ((:doc-group . compare))  rand ((:doc-group . random))  negative? ((:doc-group . compare))  Instructions ((:doc-group . builtin))  file ((:doc-group . io))  rand-double ((:doc-group . random))  atom? ((:doc-group . builtin))  cdr ((:doc-group . builtin))  T ((:doc-see))  vec? ((:doc-group . builtin))  equal? ((:doc-group . builtin))  / ((:doc-group . builtin))  eqv? ((:doc-group . builtin))  io? ((:doc-group . io))  eof-object? ((:doc-group . io))  list ((:doc-group . builtin))  apply ((:doc-group . builtin))  help ((:doc-group . doc))  rand-u32 ((:doc-group . random))  = ((:doc-group . builtin))  rand-u64 ((:doc-group . random))  not ((:doc-group . builtin))  NIL ((:doc-see . T))  set-cdr! ((:doc-group . builtin))  separate-doc-from-body ((:doc-group . doc))  fn? ((:doc-group . builtin))  help-print-header ((:doc-group . doc))  lz-pack ((:doc-group . compress))  arg-counts ((:doc-group . builtin))  eq? ((:doc-group . builtin))  getprop ((:doc-group . props))  vm-stats ((:doc-group . vm))  * ((:doc-group . builtin))  putprop ((:doc-group . props))  io->str ((:doc-group . io))))

             *syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref))  doc-for #fn("z10B86;35040<;J404086;35040=70151<863I0212287e22289e22288e2e4:212287e22289e2e3:" #(separate-doc-from-body

-v? 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.  Can be used as the opposite of T in boolean\nexpressions.\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)"  separate-doc-from-body "Take a list of terms and return a pair `(doc . body)`, where the first\nelement contains a list of documentation-related terms, and the second\ncontains the rest of the terms."  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 signature(s) of the term 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 "Return a property value associated with the symbol or `def` if\nmissing."  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 the symbol."  io->str "Return an in-memory `io` buffer converted to a string.")  *doc-extra* #table(bound? ((:doc-group . builtin))  sym-set-doc ((:doc-group . doc))  io-eof? ((:doc-group . io))  < ((:doc-group . builtin))  cadr ((:doc-group . builtin))  nan? ((:doc-group . builtin))  for ((:doc-group . builtin))  fixnum? ((:doc-group . builtin))  exit ((:doc-group . system))  > ((:doc-group . compare))  + ((:doc-group . builtin))  div0 ((:doc-group . builtin))  lz-unpack ((:doc-group . compress))  compare ((:doc-group . builtin))  buffer ((:doc-group . io))  num? ((:doc-group . builtin))  rand-float ((:doc-group . random))  builtin? ((:doc-group . builtin))  set-car! ((:doc-group . builtin))  cons? ((:doc-group . builtin))  aref ((:doc-group . builtin))  *properties* (:doc-group

-  props)  vec ((:doc-group . builtin))  >= ((:doc-group . compare))  sym? ((:doc-group . builtin))  zero? ((:doc-group . compare))  length= ((:doc-group . list))  positive? ((:doc-group . compare))  doc-for ((:doc-group . doc))  aset! ((:doc-group . builtin))  car ((:doc-group . builtin))  *builtins* ((:doc-group . builtin))  str ((:doc-group . string))  cons ((:doc-group . builtin))  - ((:doc-group . builtin))  remprop ((:doc-group . props))  <= ((:doc-group . compare))  rand ((:doc-group . random))  negative? ((:doc-group . compare))  Instructions ((:doc-group . builtin))  file ((:doc-group . io))  rand-double ((:doc-group . random))  atom? ((:doc-group . builtin))  cdr ((:doc-group . builtin))  T ((:doc-see))  vec? ((:doc-group . builtin))  equal? ((:doc-group . builtin))  / ((:doc-group . builtin))  eqv? ((:doc-group . builtin))  io? ((:doc-group . io))  eof-object? ((:doc-group . io))  list ((:doc-group . builtin))  apply ((:doc-group . builtin))  help ((:doc-group . doc))  rand-u32 ((:doc-group . random))  = ((:doc-group . builtin))  rand-u64 ((:doc-group . random))  not ((:doc-group . builtin))  NIL ((:doc-see . T))  set-cdr! ((:doc-group . builtin))  separate-doc-from-body ((:doc-group . doc))  fn? ((:doc-group . builtin))  help-print-header ((:doc-group . doc))  lz-pack ((:doc-group . compress))  arg-counts ((:doc-group . builtin))  eq? ((:doc-group . builtin))  getprop ((:doc-group . props))  vm-stats ((:doc-group . vm))  * ((:doc-group . builtin))  putprop ((:doc-group . props))  io->str ((:doc-group . io))))

-            *syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref))  doc-for #fn("z10B86;35040<;J404086;35040=70151<863I0212287e22289e22288e2e4:212287e22289e2e3:" #(separate-doc-from-body

+  #fn(gensym) let #fn(nconc) cond #fn(map) #fn("n1A<F0<520=P:")))  doc-group #fn("n22021222324e22325e2230e2e41e3e2:" #(begin

+  sym-set-doc list quote doc group))  receive #fn("z22021q1e32221e10e123825153e3:" #(call-with-values

+                                                                                     λ #fn(nconc)

+                                                                                     #fn(copy-list)))  unwind-protect #fn("n2202122q1e3e2e1232402225e121e12625e2e4e321e1e3e3:" #(let

+  #:g427 λ prog1 trycatch #:g428 raise))  dotimes #fn("z10<0T20E2187Ke32223e186e1e12415153e4:" #(for

 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.  Can be used as the opposite of T in boolean\nexpressions.\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)"  separate-doc-from-body "Take a list of terms and return a pair `(doc . body)`, where the first\nelement contains a list of documentation-related terms, and the second\ncontains the rest of the terms."  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 signature(s) of the term 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 "Return a property value associated with the symbol or `def` if\nmissing."  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 the symbol."  io->str "Return an in-memory `io` buffer converted to a string.")  *doc-extra* #table(bound? ((:doc-group . builtin))  sym-set-doc ((:doc-group . doc))  io-eof? ((:doc-group . io))  < ((:doc-group . builtin))  cadr ((:doc-group . builtin))  nan? ((:doc-group . builtin))  for ((:doc-group . builtin))  fixnum? ((:doc-group . builtin))  exit ((:doc-group . system))  > ((:doc-group . compare))  + ((:doc-group . builtin))  div0 ((:doc-group . builtin))  lz-unpack ((:doc-group . compress))  compare ((:doc-group . builtin))  buffer ((:doc-group . io))  num? ((:doc-group . builtin))  rand-float ((:doc-group . random))  builtin? ((:doc-group . builtin))  set-car! ((:doc-group . builtin))  cons? ((:doc-group . builtin))  aref ((:doc-group . builtin))  *properties* (:doc-group

   props)  vec ((:doc-group . builtin))  >= ((:doc-group . compare))  sym? ((:doc-group . builtin))  zero? ((:doc-group . compare))  length= ((:doc-group . list))  positive? ((:doc-group . compare))  doc-for ((:doc-group . doc))  aset! ((:doc-group . builtin))  car ((:doc-group . builtin))  *builtins* ((:doc-group . builtin))  str ((:doc-group . string))  cons ((:doc-group . builtin))  - ((:doc-group . builtin))  remprop ((:doc-group . props))  <= ((:doc-group . compare))  rand ((:doc-group . random))  negative? ((:doc-group . compare))  Instructions ((:doc-group . builtin))  file ((:doc-group . io))  rand-double ((:doc-group . random))  atom? ((:doc-group . builtin))  cdr ((:doc-group . builtin))  T ((:doc-see))  vec? ((:doc-group . builtin))  equal? ((:doc-group . builtin))  / ((:doc-group . builtin))  eqv? ((:doc-group . builtin))  io? ((:doc-group . io))  eof-object? ((:doc-group . io))  list ((:doc-group . builtin))  apply ((:doc-group . builtin))  help ((:doc-group . doc))  rand-u32 ((:doc-group . random))  = ((:doc-group . builtin))  rand-u64 ((:doc-group . random))  not ((:doc-group . builtin))  NIL ((:doc-see . T))  set-cdr! ((:doc-group . builtin))  separate-doc-from-body ((:doc-group . doc))  fn? ((:doc-group . builtin))  help-print-header ((:doc-group . doc))  lz-pack ((:doc-group . compress))  arg-counts ((:doc-group . builtin))  eq? ((:doc-group . builtin))  getprop ((:doc-group . props))  vm-stats ((:doc-group . vm))  * ((:doc-group . builtin))  putprop ((:doc-group . props))  io->str ((:doc-group . io))))

             *syntax-environment* #table(bcode:nconst #fn("n1200r2e3:" #(aref))  doc-for #fn("z10B86;35040<;J404086;35040=70151<863I0212287e22289e22288e2e4:212287e22289e2e3:" #(separate-doc-from-body

@@ -252,9 +280,9 @@

 in prog1

   compile-prog1 λ call-with-values #fn("n070AF62:" #(compile-f-))

   #fn("n270A21053413K02223AF>2152470A242515163:q:" #(emit loadv #fn(for-each)

-d or compile-or while compile-while cddr return ret set! separate-doc-from-body

-  error "set!: name must be a symbol" sym-set-doc lambda? lambda:vars compile-set! trycatch

-  1arg-lambda? caddr "trycatch: second form must be a 1-argument lambda") compile-in)

+            help-print-header #fn("O200020004000W2000J60q?24W3000J7021?3413A02223830>2152@V07483514823@074750512652@70770514785047860:" #(#(:kind

+  0 NIL NIL :lpad 1 NIL NIL) "" #fn(for-each) #fn("n170A51471F0P5147260:" #(princ print newline))

+  princ caddr " (group)" print newline) help-print-header)

 ambda") compile-in)

             compile-let #fn("n483<83=0r4G88T70018953718;727388518;528:537408=524258=1<521=P7608>827388515440r40r4G8<UMp4E8<L23A082J<0770288<63:q:" #(compile-arglist

   vars-to-env complex-bindings caddr box-vars #fn(nconc) compile-in emit shift) compile-let)

@@ -461,7 +489,7 @@

      #fn("z070qw042185>1220>12386>1{86504:" #(*print-readably* #fn("n0Aw0:" #(*print-readably*))

                                                      #fn("n02071A62:" #(#fn(for-each) write))

                                                      #fn("n1A50420061:" #(#fn(raise)))) princ)

-t) print-exception

+  traced? #fn(set-top-level-value!) eval λ #:g429 write cons quote newline apply void) trace)

 e00B3Z00<29CS0710r3523I0722:760512;534780T51@\xe100B3P00<2<CI0710r2523?0722=0T2>53@\xbe00B3I00<2?CB0722@514720=f2@\xa200B3N00<2ACG07B76051514722C0T52@\x8107D0513m0710r2523c0780<51472275140T2E8551;J60485R37072@40788551^1@>0722F514780514727G61:" #(type-error

   length= princ "type error: expected " ", got " #fn(typeof) caddr ": " print bounds-error "index "

   " out of bounds for " unbound-error "eval: variable " " has no value" error "error: " load-error

--- a/src/docs.sl

+++ b/src/docs.sl

@@ -40,11 +40,29 @@

         `(sym-set-doc ',sym ',doc ',callvars)

         `(sym-set-doc ',sym ',doc))))

+(defmacro (doc-group group-name doc)

+  "Define documentation for a group."

+  :doc-group doc

+  `(begin

+    (sym-set-doc (list 'doc 'group ',group-name) ,doc)))

+(doc-group doc

+  "Writing and reading documentation.")

+(doc-group prop

+  "Dealing with symbols' properties.")

+(doc-group vm

+  "VM-related functions.")

 (doc-for (vm-stats)

   "Print various VM-related information, such as the number of GC

    calls so far, heap and stack size, etc."

   :doc-group vm)

+(doc-group compress

+  "Compression.")

 (doc-for (lz-pack data (level 0))

   "Return data compressed using Lempel-Ziv.

@@ -64,26 +82,32 @@

    array is allocated."

   :doc-group compress)

+(doc-group rand

+  "Random numbers generation.")

 (doc-for (rand)

   "Return a random non-negative fixnum on its maximum range."

-  :doc-group random)

+  :doc-group rand)

 (doc-for (rand-u64)

   "Return a random integer on interval [0, 2⁶⁴-1]."

-  :doc-group random)

+  :doc-group rand)

 (doc-for (rand-u32)

   "Return a random integer on interval [0, 2³²-1]."

-  :doc-group random)

+  :doc-group rand)

 (doc-for (rand-double)

   "Return a random double on interval [0.0, 1.0]."

-  :doc-group random)

+  :doc-group rand)

 (doc-for (rand-float)

   "Return a random float on [0.0, 1.0] interval."

-  :doc-group random)

+  :doc-group rand)

+(doc-group sys

+  "OS-specific functions.")

 (doc-for (exit (status NIL))

   "Terminate the process with the specified status.  Does not return.

    The status is expected to be a string in case of an error.

@@ -92,8 +116,11 @@

        (exit) ; exit with status 0 (nil on Plan 9)

        (exit \"error\") ; exit with status 1 (\"error\" on Plan 9)"

-  :doc-group system)

+  :doc-group sys)

+(doc-group io

+  "I/O functionality.")

 (doc-for (file path (:read NIL)

                     (:write NIL)

                     (:create NIL)

@@ -152,6 +179,9 @@

        (not T)         → NIL

        (if T 'yes 'no) → yes"

   :doc-see NIL)

+(doc-group string

+  "String-related functionality.")

 (doc-for (str . term)

   "Return concatenation of terms formatted as strings.

--- a/src/str.c

+++ b/src/str.c

@@ -296,6 +296,8 @@

 		argcount(nargs, 2);

 	char *s = tostr(args[0]);

 	usize sbytes = cv_len(ptr(args[0]));

+	if(sbytes == 0)

+		return sl_nil;

 	// needle

 	char *nd;

@@ -317,6 +319,9 @@

 	if(ndbytes == 0)

 		return size_wrap(startrune);

+	if(ndbytes > sbytes)

+		return sl_nil;

 	usize i, n;

 	// first iterate to the starting rune

 	for(i = n = 0; n < startrune && i < sbytes; n++)

--- a/src/system.sl

+++ b/src/system.sl

@@ -109,7 +109,7 @@

 (def (putprop symbol key val)

   "Associate a property value with the symbol."

-  :doc-group props

+  :doc-group prop

   (let ((kt (get *properties* key NIL)))

     (unless kt

         (let ((ta (table)))

@@ -121,13 +121,13 @@

 (def (getprop symbol key (def NIL))

   "Return a property value associated with the symbol or `def` if

    missing."

-  :doc-group props

+  :doc-group prop

   (let ((kt (get *properties* key NIL)))

     (or (and kt (get kt symbol def)) def)))

 (def (remprop symbol key)

   "Remove a property value associated with the symbol."

-  :doc-group props

+  :doc-group prop

   (let ((kt (get *properties* key NIL)))

     (and kt (has? kt symbol) (del! kt symbol))))

@@ -189,36 +189,78 @@

 (sym-set-doc

   '*properties*

   '("All properties of symbols recorded with `putprop` are recorded in this table."

-    :doc-group props))

+    :doc-group prop))

-(def (help-print-header term sigs)

+(def (help-print-header term sigs (:kind NIL) (:lpad ""))

   "Format and print signature(s) of the term for `(help term)` output."

   :doc-group doc

   (if sigs

-      (for-each (λ (sig) (print (cons term sig))

+      (for-each (λ (sig) (princ lpad)

+                         (print (cons term sig))

                          (newline))

                 sigs)

-      (begin (print term)

-             (newline)))

+      (begin

+        (princ lpad)

+        (if kind

+            (princ (caddr term) " (group)")

+            (print term))

+        (newline)))

   (newline))

-(defmacro (help term (:print-header help-print-header))

-  "Display documentation for the specified term, if available."

+(defmacro (help term (kind NIL) (:print-header help-print-header))

+  "Display documentation the specified term, if available.

+   The optional parameter `kind` can be set to `group` to show

+   documentation for the specified group instead of a single term.

+   All available documentation groups can be displayed with `(help

+   groups)`."

   :doc-group doc

-  (let* {[doc (getprop term '*doc*)]

-         [formals-list (getprop term '*formals-list* NIL)]}

-    (if (or doc formals-list)

-        `(begin (,print-header ',term ',formals-list)

-                (when ,doc

-                  (princ ,doc)

-                  (newline))

-                (void))

-        (begin (princ "no help for " term)

-               (when (and (sym? term)

-                          (not (bound? term)))

-                 (princ " (undefined)"))

-                 (newline))

-               (void))))

+  (def (first-line s)

+    (let* {[nl (str-find s "\n")]}

+      (if nl (str-sub s 0 nl) s)))

+  (if (eq? term 'groups)

+      (for-each (λ (k v) (when (and (cons? k)

+                                    (eq? (car k) 'doc)

+                                    (eq? (cadr k) 'group))

+                           (princ (caddr k) ": " (first-line (getprop k '*doc*)))

+                           (newline)))

+                (get *properties* '*doc*))

+      (let* {[docterm (if kind (list 'doc kind term) term)]

+             [doc (getprop docterm '*doc*)]

+             [formals-list (getprop docterm '*formals-list* NIL)]

+             [doc-extra-term (and kind (cons (sym ":doc-" kind) term))]

+             [print-sig (λ (term sigs lpad) (if sigs

+                                                (for-each (λ (sig) (princ lpad)

+                                                                   (print (cons term sig))

+                                                                   (newline))

+                                                          sigs)

+                                                (begin

+                                                  (princ lpad)

+                                                  (print term)

+                                                  (newline))))]}

+        (if (or doc formals-list)

+            (begin (print-header docterm formals-list :kind kind)

+                   (when doc

+                     (princ doc)

+                     (newline))

+                   (when kind

+                     (newline)

+                     (princ "Members:")

+                     (newline)

+                     (for-each (λ (k v) (when (and (atom? k)

+                                                   (member doc-extra-term

+                                                           (getprop k '*doc-extra*)))

+                                          (print-sig k [getprop k '*formals-list* NIL] "    ")))

+                               (get *properties* '*doc*))

+                     (newline))

+                   (void))

+            (begin (princ "no help for " (if kind (str kind " ") "") term)

+                   (when (and (not kind)

+                              (sym? term)

+                              (not (bound? term)))

+                     (princ " (undefined)"))

+                     (newline)))))

+  (void))

 ;;; standard procedures

@@ -238,6 +280,9 @@

   (cond ((eqv? (caar lst) item) (car lst))

         (lst                    (assv item (cdr lst)))))

+(doc-group compare

+  "Comparison operators.")

 (def (> a . rest)

   "Return `T` if the arguments are in strictly decreasing order (previous

    one is greater than the next one)."

@@ -419,6 +464,9 @@

 (def (list-ref lst n)

   (car (list-tail lst n)))

+(doc-group list

+  "Working with lists.")

 (def (length= lst n)

   "Perform a bounded length test.

--- a/tools/gen.sl

+++ b/tools/gen.sl

@@ -45,7 +45,8 @@

            (car NIL)      → NIL

            (car '(1 2 3)) → 1

-           (car '(1 . 2)) → 1"]})

+           (car '(1 . 2)) → 1"

+      :doc-group list]})

   (op cdr 1 (λ (x) (cdr x))

     {[(lst)

       "Return the second element of a cons cell (tail of a list) or `NIL` if

@@ -55,7 +56,8 @@

            (cdr NIL)      → NIL

            (cdr '(1 2 3)) → (2 3)

-           (cdr '(1 . 2)) → 2"]})

+           (cdr '(1 . 2)) → 2"

+      :doc-group list]})

   (op closure)

   (op seta)

   (op jmp)

@@ -93,7 +95,8 @@

     {[(a . rest)

       "Return `T` if the arguments are in strictly increasing order (next

        one is greater than the previous one).  With a single argument

-       the result is always `T`."]}

+       the result is always `T`."

+      :doc-group compare]}

     :cname "LT")

   (op add2)

   (op set-cdr! 2 (λ (x y) (set-cdr! x y))

@@ -106,7 +109,8 @@

            (def q '(1 2 3 4 5))

            (set-cdr! q '(6 7)) → (1 6 7)

-           q                   → (1 6 7)"]})

+           q                   → (1 6 7)"

+      :doc-group list]})

   (op keyargs)

   (op cons 2 (λ (x y) (cons x y))

     {[(first second)

@@ -116,7 +120,8 @@

            (cons 1 2)                     → (1 . 2)

            (cons 1 '(2))                  → (1 2)

-           (cons 1 (cons 2 (cons 3 NIL))) → (1 2 3)"]})

+           (cons 1 (cons 2 (cons 3 NIL))) → (1 2 3)"

+      :doc-group list]})

   (op eq? 2 (λ (x y) (eq? x y))

     {[(a b)

       "Return `T` if `a` and `b` are the same object, `NIL` otherwise.

@@ -130,7 +135,8 @@

            (eq? a b)   → NIL

            (def a '(1))

            (def b '(1))

-           (eq? a b)   → NIL"]})

+           (eq? a b)   → NIL"

+      :doc-group compare]})

   (op sym? 1 (λ (x) (sym? x))

     {[(v)

       "Return `T` if `v` is a symbol, `NIL` otherwise."]})

@@ -146,7 +152,8 @@

            (cadr '(1 2 3)) → 2

            (cadr '(1))     → NIL

-           (cadr NIL)      → NIL"]})

+           (cadr NIL)      → NIL"

+      :doc-group list]})

   (op neg)

   (op nan? 1 (λ (x) (nan? x))

     {[(v)

@@ -197,7 +204,8 @@

            (def q '(1 2 3 4 5))

            (set-car! q 0) → (0 6 7)

-           q              → (0 6 7)"]})

+           q              → (0 6 7)"

+      :doc-group list]})

   (op jmp.l)

   (op brn.l)

   (op box)

@@ -216,7 +224,8 @@

            (eqv? a b)   → T

            (def a '(1))

            (def b '(1))

-           (eqv? a b)   → NIL"]})

+           (eqv? a b)   → NIL"

+      :doc-group compare]})

   (op equal? 2 (λ (x y) (equal? x y))

     {[(a b)

       "Return `T` if both `a` and `b` are of the same value.  For non-leaf

@@ -232,7 +241,8 @@

            (equal? a b)   → T

            (def a '(1))

            (def b '(1))

-           (equal? a b)   → T"]})

+           (equal? a b)   → T"

+      :doc-group compare]})

   (op list T (λ rest rest)

     {[rest

       "Return a list constructed of the arguments.

@@ -298,7 +308,8 @@

   (op = -1 (λ rest (apply = rest))

     {[(a . rest)

       "Numerical equality test.  Return `T` if all numbers are equal,

-       `NIL` otherwise."]}

+       `NIL` otherwise."

+      :doc-group compare]}

     :cname "NUMEQP")

   (op compare 2 (λ (x y) (compare x y))

     {[(x y)

@@ -398,6 +409,7 @@

       (let {[lop (sym (op-name op))]

             [argc (op-nargs op)]}

         (io-write c-header (str "\t" (op-cname op) ",\n"))

+        (write `(doc-group builtin "Built-in operators.") docs-ops)

         (for-each (λ (doc)

                     (let* {[formals (car doc)]

                            [signature (cons lop formals)]