This example is from Common Lisp's object system, called CLOS. When you want to do some code while accessing specific slots of an object, you can use a 'with-slots form, which lets you name symbols that you'll use to reference specific slots of the object. The 'with-slots form then generates local symbol-macros for each symbol you mentioned, which expand into code to access those slots. An example, taken from PCL [1]:

  (with-slots ((bal balance)) account  ; Here 'balance is the name of the slot, and 'account is the specific object
    (when (< bal *minimum-balance*)    ; *symbol* is a CL convention for global variables
      (decf bal (* bal .01)))))        ; decf is like --

  arc> (let str "Hello world!"
         (= (str "world") "arc")
         str)
  "Hello arc!"

Call the string with an index to get the character at that position, call it with a character or string to find the index.

Maybe we should just make two scheme functions str-set! and str-ref and use those instead, as opposed to over-writing the original functions.

This sounds like a good spot for the redef macro ;)

In other words, searching for one character should return an index, while searching for a substring should return a range.

There are thus four operations which would ideally be possible through ("abc" x):

  arc> (= str "hello arc!")
  "hello arc!"
  arc> (str "arc")
  6..8     ; or some other way of representing a range
  arc> (str #\!)
  9
  arc> (str 5)
  #\space
  arc> (str 4..7)   ; same as previous comment
  "o ar"

  arc> (str #\l)
  2
  3

  arc> (str "arc")
  6

Even if call position and assignment weren't handled separately, it would still be possible to work off of the length of the argument and the index, without needing a range.

  (+ (str "world") (len "world"))

  (let (a b c) (fn-returning-list-of-3-things)
    ...)

Extending the idea of the polymorphic '+ on lists to include tables suggests what CatDancer proposed in the original post.

So I wrote up the following sketchy hacks of '+ for tables:

  ; arc3/tab-tests.arc

  (def table+ tbs
    (listtab (apply +
                    (map tablist
                         (rev tbs)))))
  ;; Conceptually transparent, but try to avoid
  ;; thinking about the wastefulness...

  (def table+-better tbs
    (w/table tb-new
      (each tb (rev tbs)
        (ontable k v tb
          (= (tb-new k) v)))))
  ;; Much better! Has a nice profile too :)

  ;; The rest is a "throw-away" test for the code
  ;; (require 'human-at-monitor-to-compare-tests)
  (with (ta (obj a 'ta
                 b 'ta)
         tb (obj b 'tb
                 c 'tb)
         tc (obj c 'tc
                 a 'tc))
    (map prn `("Consecutive lines should be identical:"
               ,(table+ ta tb tc)
               ,(table+-better ta tb tc)
               ,(table+ tb tc ta)
               ,(table+-better tb tc ta)
               ,(table+ tc ta tb)
               ,(table+-better tc ta tb))))

  ; Arc REPL
  Use (quit) to quit, (tl) to return here after an interrupt.
  arc> (load "tab-tests.arc")
  Consecutive lines should be identical:
  #hash((a . ta) (b . ta) (c . tb))
  #hash((a . ta) (b . ta) (c . tb))
  #hash((a . tc) (b . tb) (c . tb))
  #hash((a . tc) (b . tb) (c . tb))
  #hash((a . tc) (b . ta) (c . tc))
  #hash((a . tc) (b . ta) (c . tc))
  nil

  (xdef + (lambda args
             (cond ((null? args) 0)
                   ((all string? args) 
                    (apply string-append args))
                   ((all arc-list? args) 
                    (ac-niltree (apply append (map ar-nil-terminate args))))
                   (#t (apply + args)))))

try redefining + in Arc, for example

  (redef + args
    (apply (if (all [isa _ 'table] args)
                table+-better
                orig)
           args))

  (mac redef (name args . body)
    `(let orig ,name
       (= ,name (fn ,args ,@body))))

I like this 'redef macro. How come it's not in arc.arc already? I can't think of any reason to not have this be there, along with the definitions of other key macros like 'do, 'def, and 'mac.

Now, granted, this function actually contributes nothing to <insert large project here, including news.yc>. However, I think that this function strikes at the heart of the "hackable language" mentality, by making it much easier to quickly modify behavior on the fly. It also sends a message to somebody reading the source code: "One of the key principles in this language is that you can redefine behavior across the board with one macro call."

You might also like my extend macro: http://catdancer.github.com/extend.html

  arc> (redef + args
         (apply (if (sll [isa _ 'table] args)
                     table+-better
                     orig)
           args))

  arc> (redef + args
         (apply (if (all [isa _ 'table] args)
                     table+-better
                     orig)
           args))

  (= old-def (table))

  (mac redef (name args . body)
    `(let orig ,name
       (= (old-def ',name) orig)
       (= ,name (fn ,args ,@body))))

  (mac undef (name)
    `(= ,name (old-def ',name)))

Side note: compare the "profiles" of this version, and the earlier versions -- this one has a much more "functional" profile.

I'm a bit confused what you mean about atend:err. Do you basically mean that there would be function composition between a macro, and a call to, for example, (err "missing char after backslash")? Something like

  (mac atend (alert)
    `(unless (peekc (stdin))
       ,alert))

Yes, a composition, though not a function composition. Because the Arc compiler rewrites (a:b ...) as (a (b ...)) when a:b appears in the first position in an expression, it works for macros also.

Thus

  (atend:err "missing close quote")

  (atend (err "missing close quote"))

  (unless (peekc (stdin))
    (err "missing close quote"))

In the meantime, it should be easy to write a "polymorphic" lookup function:

  (def lookup (db key)       ; obviously just a sketchy
    (if (atom db) (db key)   ; definition -- but Arc is LFSP
        (alref db key)))     ; so there's no warranty :)

I copied out the code, commented it (spending about 80% of the time between www.arcfn.com and arc.arc), and then made two main changes. One is that I rewrote 'json-unicode-digits to only pass over the 4 chars once, rather than three times -- I did this by dissecting 'firstn, and putting the error checking forms inside there.

The other major change is the macro. I noticed that three functions used a similar pattern (the last one was a slight stretch, but after all, a 'let is a lambda deep inside).

My code:

  (def hexdigit (c)
    (or (<= #\a c #\f) (<= #\A c #\F) digit.c))

  (def json-backslash-char (c)
    (case c
      #\" #\"
      #\\ #\\
      #\/ #\/
      #\b #\backspace
      #\f #\page
      #\n #\newline
      #\r #\return
      #\t #\tab
      (err "invalid JSON backslash char" c) ) )

  ;; (The above two are verbatim from CatDancer's code
  ;;  Now comes some modified stuff)

  (def json-unicode-digits (j)
    (let u ((afn (n xs)
              (if (is n 0) nil
                    (or (no xs) (no:hexdigit (car xs)))
                  (err "need 4 hexadecimal digits after \u")
                    (cons (car xs) (self (-- n) (cdr xs)))))
            4 j)
      (coerce (int (coerce u 'string) 16) 'char) ) )

  (mac def-jsniffer (name c next (o arg 'cdr.j))
    `(def ,name (j)
       (if (is car.j ,c)
           (,next ,arg))))

  ;; ... because it sniffs ahead at the next char.
  
  (def-jsniffer match-json-unicode-escape #\u
    [list (nthcdr 4 _)
          (json-unicode-digits _)])

  (def-jsniffer match-json-backslash #\\
    [do (if no._ (err "missing char after backslash"))
        (or match-json-unicode-escape._
            (list cdr._ (json-backslash-char car._)) ) ] )

  (def-jsniffer match-json-string #\"
    (fn ((j a))
      (list j (coerce rev.a 'string)))
    ((afn (j a)
       (if no.j (err "missing close quote"))
       (if (is car.j #\") (list cdr.j a)
           (iflet (j c)
                 (match-json-backslash j)
               (self j (cons c a))
             (self (cdr j) (cons (car j) a)) ) ) )
     cdr.j nil))

  (mac def-jsniffer (name c next (o arg 'cdr.j))
    `(def ,name (j)

1. Put all the functions inside a surrounding lexical scope, and keep the state in some lexical variables that all the functions can access.

2. Write some macros so that you're still passing the state through all your functions, but the variables don't appear in your code.