nydp 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1360fe08561240c0e05c70a69629b42b38078275
-  data.tar.gz: 70c0dfe6df1a0b2bf24ef39aca70646d7f8c3cac
+  metadata.gz: '06876fcb6832d6737b4763607cfe7b4c0ca003c3'
+  data.tar.gz: b45d30570c913940f93585241c1dad9cc71c5872
 SHA512:
-  metadata.gz: 5db0e86f33a7ebe4afc33478d1fe6a2da5a6a8d07b85d66532cd155adb9b8b567d6edbe90f3ab0b437f59a03ec2047ca51778c2d0923355131b8e9b718260c83
-  data.tar.gz: 0d4491009c98301ab947668fd396bf7f3544b229de8d1820065073f0bfb01e7db509cba3f749f07f6575b791222d1aa7870c3d0e86d96dce4e95a1ddac8cba00
+  metadata.gz: d874e4fbbba55a5995f699451bbf305fe7667f4058cdab2e713fe64900bc96ed285fe5ae8d0c460c73001f0a44fb22699c634c2017a723e9c79d818779d38b7e
+  data.tar.gz: 5d5f3aeb4e7c0e65af1024990fdfa5f73a8f4657a06dfd11aaeec172709615a3879f0bdff0efd19475a223add58ee1dd6379951548979eda5b80f30861967e61

data/README.md

@@ -55,6 +55,22 @@ answer = Nydp.apply_function ns, :question, :life, ["The Universe", and_also(eve
 
 You can maintain multiple `ns` instances without mutual interference. In other words, assigning global variables while one `ns` is in scope will not affect the values of variables in any other `ns` (unless you've specifically arranged it to be so by duplicating namespaces or some such sorcery).
 
+
+#### Facing the Truth
+
+In conditional statements, nil is false, anything else is true
+
+```lisp
+(if)           ;; same as (if nil)
+(if a)         ;; same as a
+(if a b)       ;; same as (if a b nil)
+(if a b c)     ;; if a is nil, return c, otherwise return b
+(if a b c d)   ;; same as (if a b (if c d))
+(if a b c d e) ;; same as (if a b (if c d e))
+
+;; and so on
+```
+
 ## Different from Arc :
 
 #### 1. Macro-expansion runs in lisp
@@ -151,8 +167,36 @@ nydp > (map &lastname german-composers)   ; ampersand-syntax creates a function
 
 As with all other syntax, you can of course override the `ampersand-syntax` macro to handle your special needs.
 
+You can combine special syntaxes ("%td" comes from nydp-html gem)
+
+```lisp
+
+nydp > (map %td:&lastname german-composers)
+
+"<td>Bach</td><td>Beethoven</td><td>Wagner</td><td>Mozart</td>"
+
+```
+
+So, @%td@ expands to @(percent-syntax || td)@, @&lastname@ to @(ampersand-syntax || lastname)@, and the whole @%td:&lastname@
+to @(colon-syntax (percent-syntax || td) (ampersand-syntax || lastname))@. Luckily for you, there's a fine @colon-syntax@ macro
+that knows how to build a function out of these bits and pieces.
+
+
 Look for `SYMBOL_OPERATORS` in [parser.rb](lib/nydp/parser.rb) to see which syntax is recognised and in which order. The order of these definitions defines special-syntax-operator precedence.
 
+Any character that is not special syntax will be recognised as part of a symbol. At time of writing, this includes the plus sign, hyphen, and slash.
+
+```lisp
+
+;; nonsense code illustrating the use of certain
+;; characters as function and variable names
+(def //-+ (x y z)
+  (let -*- (x y)
+    (if z (//-+ x y -*-) -*-)))
+
+```
+
+
 #### 3. Special list syntax
 
 The parser detects alternative list delimiters

data/lib/lisp/core-015-documentation.nydp

@@ -83,17 +83,20 @@
      (def dox-new (item)
        (hash-cons dox (hash-get item 'name) item)
        (hash-cons types (hash-get item 'what) item)
-       (dox-add-to-chapters item (hash-get item 'what) (hash-get item 'chapters)))
+       (dox-add-to-chapters item (hash-get item 'what) (hash-get item 'chapters) (hash)))
 
      (def dox-add-doc (name what texts args src chapters more)
        (cond (no (privately))
              (dox-new (dox-build (if more more (hash)) name what texts args src chapters))))
 
-     (def dox-add-to-chapters (item type chapters)
+     (def dox-add-to-chapters (item type chapters already)
        (cond chapters
-             (do (chapter-add-item    item (car chapters))
-                 (hash-cons types-chapters (inspect (cons type (car chapters))) item)
-                 (dox-add-to-chapters item type (cdr chapters)))
+         (cond (no (hash-get already (car chapters)))
+           (do (hash-set            already        (car chapters)                       t)
+               (chapter-add-item    item           (car chapters))
+               (hash-cons           types-chapters (inspect (cons type (car chapters))) item)
+               (dox-add-to-chapters item           type (cdr chapters) already))
+           item)
              item))
 
      (def dox-add-examples (name example-exprs)
@@ -171,10 +174,12 @@
   (hash-set hsh 'chapter nil)
   hsh)
 
+(def dox-build-def-name (name) name)
+
 ;; used internally by 'mac
 (def define-mac-expr (name args body-forms)
   `(do (hash-set macs ',name (fun ,args ,@(hash-get body-forms nil)))
-       (dox-add-doc ',name
+       (dox-add-doc ',(dox-build-def-name name)
                     'mac
                     ',(+ (fetch-and-clear-comments) (map car (hash-get body-forms 'comment)))
                     ',args
@@ -204,7 +209,7 @@
 ;; used internally by 'def
 (def define-def-expr (name args body-forms)
   `(do (def-assign ,name (fun ,args ,@(filter-comments (hash-get body-forms nil))))
-       (dox-add-doc ',name
+       (dox-add-doc ',(dox-build-def-name name)
                     'def
                     ',(+ (fetch-and-clear-comments) (map car (hash-get body-forms 'comment)))
                     ',args

data/lib/lisp/core-017-builtin-dox.nydp

@@ -1,6 +1,7 @@
 (dox-add-doc 'cons      'def '("with args a and b, returns a new cons cell, (a . b)")                                                                            '(a b)                nil '(list-manipulation))
 (dox-add-doc 'car       'def '("with args a, where a is a cons cell (x . y), return x." "Commonly used to get the first element of a list")                      '(a)                  nil '(list-manipulation))
 (dox-add-doc 'cdr       'def '("with args a, where a is a cons cell (x . y), return y." "Commonly used to get contents of a list, excluding the first element")  '(a)                  nil '(list-manipulation))
+(dox-add-doc 'log       'def '("write arg to Nydp.logger ; be sure to assign Nydp.logger first!")                                                                '(arg)                nil '(nydp-core))
 (dox-add-doc '+         'def '("with rest-args things, return the sum of the elements of things." "Will also increment dates and concatenate strings and lists") 'things               nil '(math))
 (dox-add-doc '-         'def '("return the result of subtracting all other args from the first arg." "(- a b c d) is equivalent to (- a (+ b c d))")             'things               nil '(math))
 (dox-add-doc '*         'def '("with rest-args things, return the product of the elements of things.")                                                           'things               nil '(math))
@@ -35,21 +36,21 @@
 (dox-add-doc 'pair?     'def '("t if arg is a cons cell or (equivalently) the start of a list")                                                                  '(arg)                nil '(nydp-core))
 (dox-add-doc 'hash?     'def '("t if arg is a hash")                                                                                                             '(arg)                nil '(nydp-core))
 (dox-add-doc 'sym?      'def '("t if arg is a symbol, nil otherwise")                                                                                            '(arg)                nil '(nydp-core))
-(dox-add-doc 'ensuring  'def '("execute 'tricky-f, then 'ensure-f afterwards"
-                               "'ensure-f will always be executed, even if there is an error in 'tricky-f"
-                               "returns the return value of 'tricky-f")                                                                                          '(ensure-f tricky-f)  nil '(flow-control))
+(dox-add-doc 'ensuring  'def '("execute 'try-f, then 'ensure-f afterwards"
+                               "'ensure-f will always be executed, even if there is an error in 'try-f"
+                               "returns the return value of 'try-f. Similar to try/finally in java, or begin/ensure in ruby.")                                   '(ensure-f try-f)  nil '(flow-control))
 (dox-add-doc 'inspect   'def '("return a string representing 'arg, potentially (but not always) in a way that can be parsed back in to get the original object") '(arg)                nil '(nydp-core))
 (dox-add-doc 'comment   'def '("does nothing at all." "Intercepted inside 'def and 'mac and used for documentation")                                             '(arg)                nil '(nydp-core))
 (dox-add-doc 'parse-in-string 'def '("parse the given string assuming a string-open delimiter has already been encountered")                                     '(str)                nil '(nydp-core))
 (dox-add-doc 'rand            'def '("return a random number ; with no args, between 0 and 1"
                                      "with 1 arg, an integer less than arg"
-                                     "with two args, an integer >= arg 0 and < arg 1")                                                                           'args                 nil '(math))
-(dox-add-doc 'random-string   'def '("return a random string of length 'len (default 10)")                                                                       '(len)                nil '(string-manipulation))
-(dox-add-doc 'to-string       'def '("return a human-readable string representation of 'arg")                                                                    '(arg)                nil '(string-manipulation))
-(dox-add-doc 'string-length   'def '("return the length of 'arg")                                                                                                '(arg)                nil '(string-manipulation))
-(dox-add-doc 'string-replace  'def '("replace 'pattern with 'insert in 'str")                                                                                    '(pattern insert str) nil '(string-manipulation))
-(dox-add-doc 'string-split    'def '("split 'str delimited by 'delim")                                                                                           '(str delim)          nil '(string-manipulation))
-(dox-add-doc 'string-match    'def '("if 'str matches 'pattern, return hash with keys 'match and 'captures ; otherwise nil")                                     '(str pattern)        nil '(string-manipulation))
+                                     "with two args, an integer >= arg 0 and < arg 1")                                                                           'args                      nil '(math))
+(dox-add-doc 'random-string   'def '("return a random string of length 'len (default 10)")                                                                       '(len)                     nil '(string-manipulation))
+(dox-add-doc 'to-string       'def '("return a human-readable string representation of 'arg")                                                                    '(arg)                     nil '(string-manipulation))
+(dox-add-doc 'string-length   'def '("return the length of 'arg")                                                                                                '(arg)                     nil '(string-manipulation))
+(dox-add-doc 'string-replace  'def '("replace 'pattern with 'replacement in 'str")                                                                               '(pattern replacement str) nil '(string-manipulation))
+(dox-add-doc 'string-split    'def '("split 'str delimited by 'delim")                                                                                           '(str delim)               nil '(string-manipulation))
+(dox-add-doc 'string-match    'def '("if 'str matches 'pattern, return hash with keys 'match and 'captures ; otherwise nil")                                     '(str pattern)             nil '(string-manipulation))
 (dox-add-doc 'time            'def '("with no args, return the current time."
                                      "With one arg, if 'arg-0 is a number, return the current time plus 'arg-0 seconds."
                                      "With one arg, if 'arg-0 is a date, return the time at the beginning of the given date."
@@ -57,9 +58,9 @@
                                      "With two args, 'arg-0 must be a time."
                                      "If 'arg-1 is a number, return 'arg-0 plus 'arg-1 seconds as a time object."
                                      "If 'arg-1 is a time, return the number of seconds between the two (- 'arg-0 arg-1)."
-                                     "Otherwise, expect 3, 4, 5, or 6 args, to construct a time from"
+                                     "Otherwise, expect 3 or more args, to construct a time from"
                                      "year, month, date, hours, minutes, seconds, milliseconds, reading arguments in that order,"
-                                     "where hours, minutes, seconds, and milliseconds are optional")                                                             'args                 nil '(date-time))
+                                     "where hours, minutes, seconds, and milliseconds are optional")                                                               'args                 nil '(date-time))
 (dox-add-doc 'thread-locals     'def '("return a hash bound to the current thread")                                                                                nil                   nil '(nydp-core))
 (dox-add-doc 'type-of           'def '("return a symbol for the type of 'arg")                                                                                     '(arg)                nil '(nydp-core))
 (dox-add-doc 'eq?               'def '("return 't if 'arg-0 and 'arg-1 are equal, nil otherwise")                                                                  '(arg-0 arg-1)        nil '(nydp-core))

data/lib/lisp/core-030-syntax.nydp

@@ -94,6 +94,8 @@ scoping, assignment, anonymous functions and more...")
       (cons (list (car things) (cadr things))
             (pairs (cddr things)))))
 
+;; like 'let, but creates and assigns multiple local variables.
+;; for example, "(with (a 1 b 2) (+ a b))" returns 3
 (mac with (parms . body)
      `((fun ,(map car (pairs parms))
             ,@body)
@@ -217,29 +219,23 @@ scoping, assignment, anonymous functions and more...")
   (and (pair? name)
        (caris 'ampersand-syntax (car name))))
 
+;; (= (&key (expr)) (val))
+;; (= ((ampersand-syntax key) (expr)) (val))
+;; 'place is ((ampersand-syntax || key) (expr))
+;; we need (hash-set (expr) 'key (val))
+;; however,
+;; (= (&key.subkey (expr)) (val))
+;; 'place is ((ampersand-syntax || (dot-syntax key subkey)) (expr))
+;; we need (hash-set (hash-get (expr) 'key) 'subkey (val))
 (def ampersand-expression-assignment (place value)
-  ; (= (&key (expr)) (val))
-  ; (= ((ampersand-syntax key) (expr)) (val))
-  ; 'place is ((ampersand-syntax || key) (expr))
-  ; we need (hash-set (expr) 'key (val))
-  ; however,
-  ; (= (&key.subkey (expr)) (val))
-  ; 'place is ((ampersand-syntax || (dot-syntax key subkey)) (expr))
-  ; we need (hash-set (hash-get (expr) 'key) 'subkey (val))
   (with (k   (cadr:cdar place)
          hsh (cadr place))
     (if (caris 'dot-syntax k)
         (dot-syntax-assignment (cons hsh (cdr k)) value)
         `(hash-set ,hsh ',k ,value))))
 
-(mac = (name value)
-  ; generic assignment which unlike builtin 'assign, knows how to assign
-  ; to hash keys
-  ; (= (hash-get (expr) 'key) (val) => (hash-set (expr) 'key (val))
-  ; (= h.k (val))                   => (hash-set h 'k (val))
-  ; (= h.j.k (val))                 => (hash-set (hash-get h 'j) 'k (val))
-  ; (= (&key (expr)) (val))         => (hash-set (expr) 'key (val))
-  ; (= (&j.k (expr)) (val))         => (hash-set (hash-get (expr) 'j) 'k (val))
+;; used internally by '= macro
+(def assign-expr (name value)
   (if (isa 'symbol name)
       `(assign ,name ,value)
       (caris 'dot-syntax name)
@@ -252,6 +248,18 @@ scoping, assignment, anonymous functions and more...")
       `(hash-set @ ',(caddr name) ,value)
       (error "unknown assignment to place: ~(inspect name)")))
 
+;; generic assignment which unlike builtin 'assign, knows how to assign
+;; to hash keys
+;; (= (hash-get (expr) 'key) (val) => (hash-set (expr) 'key (val))
+;; (= h.k (val))                   => (hash-set h 'k (val))
+;; (= h.j.k (val))                 => (hash-set (hash-get h 'j) 'k (val))
+;; (= (&key (expr)) (val))         => (hash-set (expr) 'key (val))
+;; (= (&j.k (expr)) (val))         => (hash-set (hash-get (expr) 'j) 'k (val))
+(mac = (name value . more)
+  (if more
+      `(do ,(assign-expr name value) (= ,@more))
+      (assign-expr name value)))
+
 ;; quiet assignment ; like =, but expression returns nil
 (mac #= (name value)
   `(do (= ,name ,value) nil))

data/lib/lisp/core-037-list-utils.nydp

@@ -60,14 +60,3 @@
 ; a 'key, returns vx from 'al where kx is equal to 'key
 ; #attribution: lifted almost directly from arc.arc
 (def alref (key al) (cadr (assoc key al)))
-
-;; returns the first non-empty item in 'args
-;; mac equivalent of (detect present? args)
-(mac dp args
-  (if args
-      (w/uniq nearg
-        `(let ,nearg ,(car args)
-           (if (empty? ,nearg)
-               (dp ,@(cdr args))
-               ,nearg)))
-      nil))

data/lib/lisp/core-040-utils.nydp

@@ -90,3 +90,14 @@
   (chapter string-manipulation)
   (chapter hash-manipulation)
   (!empty? thing))
+
+;; returns the first non-empty item in 'args
+;; mac equivalent of (detect present? args)
+(mac dp args
+  (if args
+      (w/uniq nearg
+        `(let ,nearg ,(car args)
+           (if (empty? ,nearg)
+               (dp ,@(cdr args))
+               ,nearg)))
+      nil))

data/lib/lisp/core-041-string-utils.nydp

@@ -2,7 +2,7 @@
 
 ; return a new string with leading and trailing whitespace removed
 (def string-strip (txt)
-  (string-replace "(^\\s+|\\s+$)" "" txt))
+  (string-replace "(\\A\\s+|\\s+\\z)" "" txt))
 
 (def joinstr (txt . things)
   ; flatten 'things into a single list (ie unnest lists)

data/lib/lisp/core-043-list-utils.nydp

@@ -198,8 +198,8 @@
                list))
 
 (def all? (f things)
-  ; if 'things is a list, true when all items are non-nil
-  ; if 'things is an atom, true when non-nil
+  ; if 'things is a list, true when f(thing) is non-nil for each thing in things
+  ; if 'things is an atom, true when f(things) is non-nil
   (if (pair? things)
       (and (f:car things)
            (or (no:cdr things)
@@ -207,8 +207,8 @@
       (f things)))
 
 (def any? (f things)
-  ; if 'things is a list, true when at least one item is non-nil
-  ; if 'things is an atom, true when non-nil
+  ; if 'things is a list, true when f(thing) is non-nil for at least one thing in things
+  ; if 'things is an atom, true when f(thing) is non-nil
   (if (pair? things)
       (or (f:car things)
           (and (cdr things)
@@ -216,8 +216,8 @@
       (f things)))
 
 (def none? (f things)
-  ; if 'things is a list, true when all items are nil
-  ; if 'things is an atom, true when nil
+  ; if 'things is a list, true when f(thing) is nil for each thing in things
+  ; if 'things is an atom, true when f(things) is nil
   (if (pair? things)
       (and (no:f:car things)
            (none? f (cdr things)))

data/lib/lisp/core-080-pretty-print.nydp

@@ -199,3 +199,8 @@
 ;; use the pretty-printer to elegantly display the given source code
 (def dox-show-src (src)
   (pp src))
+
+;; use 'pp/unsyntax to convert 'def and 'mac names back to a symbol
+;; so (mac dsl.foo (a1 a2) ...) will be documented as "dsl.foo"
+(def dox-build-def-name (name)
+  (pp/unsyntax name))

data/lib/lisp/core-090-hook.nydp

@@ -35,13 +35,25 @@
     (each hook (hooks-for hook-name)
           (apply hook args))))
 
-; install a hook for a particular kind of event
-;
-; example
-; (on transaction (account amount) (update account total (+ account.total amount)))
-;
-; same as (add-hook 'transaction (fn (account amount) (update account total (+ account.total amount))))
-;
+;; install a hook for a particular kind of event
+;;
+;; example
+;; (on transaction (account amount) (update account total (+ account.total amount)))
+;;
+;; same as (add-hook 'transaction (fn (account amount) (update account total (+ account.total amount))))
+;;
+;; if 'body is nil and 'args is a symbol, for example
+;;
+;; (on transaction notify)
+;;
+;; 'notify must be a predefined function accepting any arguments to the 'transaction event ; the example is equivalent to
+;;
+;; (add-hook 'transaction (fn args (apply notify args)))
+;;
+;; or more simply
+;;
+;; (add-hook 'transaction (fn (account amount) (notify account amount)))
+;;
 (mac on (event args . body)
   (let hookfn (if (isa 'symbol (car body))
                   (car body)

data/lib/lisp/core-120-settings.nydp

@@ -35,12 +35,12 @@
                       '(def-setting ,name ,initial)
                       '(,(sym "settings/~context"))
                       { setting { default ',initial context ',context name ',name } })
-         (hash-set initial-settings ',(sym name) ,initial)
+         (hash-set initial-settings ',(sym name) ',initial)
          (set-setting ,(sym name) ,initial))))
 
 ; get the value of the given setting. Raises an error if the setting is unknown
 (def setting (name)
   (aif (hash-get settings (sym name))
-       (on-err (error "can't get value of setting ~name")
+       (on-err (error "can't get value of setting ~name : stored object is ~(inspect it)")
                (it name))
        (error "unknown setting ~(inspect name)")))

data/lib/lisp/core-130-validations.nydp

@@ -0,0 +1,51 @@
+(chapter-start 'validations "utilities to record and run validation routines")
+
+(let validations {}
+  (def validate/reset ()
+    (= validations {}))
+  (def validate/fns (thing context)
+    (hash-get validations (list (type-of thing) context)))
+  (def validate/fn+ (type context f)
+    (hash-cons validations (list type context) f)))
+
+;;
+;; returns a hash of error-name to list of error messages
+;;
+;; An empty return value signifies an error-free 'thing
+;;
+(def validate (thing context)
+  (returnlet msgs {}
+    (let msgf λem(hash-cons msgs e m)
+      (eachl λv(v thing context msgf)
+             (validate/fns thing context)))))
+
+;; declare a validation routine for type 'type in context 'context
+;;
+;; 'type must be a symbol
+;; 'context must be a symbol
+;; 'body is one or more nydp expressions.
+;;
+;; 'body will be embedded in a function with access to the following variables :
+;;
+;; * the value of the 'type argument
+;; * ctx
+;; * mf
+;;
+;; 'mf ("message function") is a function that takes two arguments and is used to store
+;; the validation error message
+;; example: (mf "Last name" "Last name must not be empty")
+;;
+;; example usage:
+;;
+;; (validate/def invoice issue
+;;   (if (no invoice.account)
+;;       (mf "Account" "Account must be a client account"))
+;;   (if (!> invoice.total 0)
+;;       (mf "Amount"  "Amount must be greater than zero"))
+;;   (if (any? !&group invoice.invoice-items)
+;;       (mf "Group"   "Each line must be assigned to a group")))
+;;
+;; if your routine makes no call to 'mf then 'validate will return an empty hash, which should be
+;; interpreted as signifying that the object in question is error free in the given context.
+(mac validate/def (type context . body)
+  `(validate/fn+ ',type ',context (fn (,type ctx mf) ,@body)))

data/lib/lisp/core-900-benchmarking.nydp

@@ -201,6 +201,63 @@
 
 
 
+;; ================================================
+;; Benchmark: string concatenation     - 10 runs of 20000 iterations each
+;;   took: 0.702480166 ms, 3.51240083e-05 ms per iteration
+;;   took: 0.71368384 ms, 3.5684192e-05 ms per iteration
+;;   took: 0.722608668 ms, 3.61304334e-05 ms per iteration
+;;   took: 0.716350427 ms, 3.5817521349999995e-05 ms per iteration
+;;   took: 0.72145049 ms, 3.60725245e-05 ms per iteration
+;;   took: 0.745082221 ms, 3.725411105e-05 ms per iteration
+;;   took: 0.722694129 ms, 3.613470645e-05 ms per iteration
+;;   took: 0.71999777 ms, 3.59998885e-05 ms per iteration
+;;   took: 0.727236822 ms, 3.63618411e-05 ms per iteration
+;;   took: 0.73657519 ms, 3.68287595e-05 ms per iteration
+;; total 7.228159722999999, average 0.7228159722999999 per run
+;; ================================================
+;;    string concatenation     : total 7.228159722999999, average 0.7228159722999999 per run
+;; (def bm-string-concat ()
+;;   (+
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")))
+
+
+;; ================================================
+;; Benchmark: random string     - 10 runs of 20000 iterations each
+;;   took: 0.693267608 ms, 3.4663380399999996e-05 ms per iteration
+;;   took: 0.763436112 ms, 3.8171805599999996e-05 ms per iteration
+;;   took: 0.682000681 ms, 3.410003405e-05 ms per iteration
+;;   took: 0.687733846 ms, 3.43866923e-05 ms per iteration
+;;   took: 0.686838878 ms, 3.43419439e-05 ms per iteration
+;;   took: 0.681588034 ms, 3.40794017e-05 ms per iteration
+;;   took: 0.689589352 ms, 3.44794676e-05 ms per iteration
+;;   took: 0.690437907 ms, 3.4521895349999996e-05 ms per iteration
+;;   took: 0.683199842 ms, 3.4159992099999995e-05 ms per iteration
+;;   took: 0.696863126 ms, 3.48431563e-05 ms per iteration
+;; total 6.954955385999999, average 0.6954955385999999 per run
+;; ================================================
+;;    random string     : total 6.954955385999999, average 0.6954955385999999 per run
+
+;; (def bm-random-string ()
+;;   (list (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)))
+
 (def bm-repeat (f n)
   ; used in benchmarking
   (for b 1 n (f)))
@@ -223,7 +280,8 @@
 
 (def rbs (name)
   (let summary nil
-    (push (bm "no-closures    "   bm-no-closures             10  20000) summary)
+    ;; (push (bm "random string    "   bm-random-string             10  20000) summary)
+    ;; (push (bm "string concatenation    "   bm-string-concat             10  20000) summary)
     ;; (push (bm "type-of    "   bm-type-of             10  20000) summary)
     ;; (push (bm "accum    "   bm-acc             10  500) summary)
     ;; (push (bm "accum    "   bm-facc            10  500) summary)