Put this in ac.scm:

  (xdef 'print (lambda args
                 (if (pair? args)
                     (print (ac-denil (car args)) 
                              (if (pair? (cdr args)) 
                                  (cadr args)
                                  (current-output-port))))
                 (flush-output)
                 'nil))

  (def rpr args
    (map1 print args)
    (car args))

  (def rprn args
    (do1 (apply rpr args)
         (writec #\newline
                 (if (isa (car args) 'output) (car args) (stdout)))))

  > (rprn (list 'a 2 "c"))
  (a 2 "c") ; prints this
  (a 2 "c") ; returns this

  (def foo ()
    ...
    (make-local bar 'baz) ; macro call
    ,,,)

  (def foo ()
    (let bar 'baz
      ...
      ,,,))

(spliceable (let arglist '(4 5 6) (list 1 2 3 (splice arglist) 7 8 9)))

Keyword arguments.

Modules.

FFI.

So far, I'm not too keen on = for setf. Mainly for the negative reason that I like = with its comparison of numbers meaning. Perhaps (! a 0) for assignment?

  ;tail recursive, trickery to avoid reversing acc
  (def range (start end (o step (if (< end start) -1 1)))
    (= step (- step)
       end (+ end (mod (- start end) step)))
    ((afn (end acc)
       (if (or (and (< 0 step)
                    (<= end start))
               (and (< step 0)
                    (<= start end)))
           (self (+ end step) (cons end acc))
           acc))
     end nil))


  ;iterative
  (def range (start end (o step (if (< start end) 1 -1)))
    (let result nil
      (repeat (+ (truncate (/ (- end start)
                              step))
                 1)
        (push start result)
        (++ start step))
      (rev result)))

  (def range (st en (o step 1))
    (if (is step 0) (= step 1) (zap abs step))
    (let (stp-fn test) (if (> st en) `(,- ,<) `(,+ ,>))
       ((afn (i accum)
          (if (test i en) (rev accum)
                          (self (stp-fn i step) (push i accum))))
        st nil)))

  arc> (range 0 -5)
  (0 -1 -2 -3 -4 -5)
  arc> (range 5 5)
  (5)
  arc> (range 0 5)
  (0 1 2 3 4 5)
  arc> (range 0 10 2)
  (0 2 4 6 8 10)
  arc> (range 10 0 2)
  (10 8 6 4 2 0)

  (def range (st en (o step 1))
    (if (is step 0) (= step 1) (zap abs step))
      (let (stp-fn test) (if (> st en) `(,- ,<) `(,+ ,>))
        ((afn (i)
           (if (test i en) nil
                           (cons i (self (stp-fn i step)))))
         st)))

  (def range (default (o end) (o step 1))
    (with (st (if end default 0)
           en (if end end default))
      (if (is step 0) (= step 1) (zap abs step))
      (let (stp-fn test) (if (> st en) `(,- ,<) `(,+ ,>))
         ((afn (i accum)
            (if (test i en) (rev accum)
                            (self (stp-fn i step) (push i accum))))
          st nil))))

  (def foo () nil)

  (= foo (fn () nil))

To have a local function foo:

  (def foo () nil)

  (def bar ()
    (let foo (fn () t)
      (foo)))

  (bar) -> t
  (foo) -> nil

  arc> (= a '(1 2))
  (1 2)
  arc> (do (= (cddr a) a) t)
  t
  arc> (pop a)
  1
  arc> (pop a)
  2
  arc> (pop a)
  1
  arc> (pop a)
  2

    (tostring (prn "hi"))

thatexpr is like CL + .

But (%) is like (eval thatexpr), except % is a macro that gives you what the last thing entered expanded into. And so, since % is a macro, it itself is expanded away. Hence

  arc> 2
  2
  arc> (* ^ 2)
  4
  arc> (%) ; equivalent to entering (* ^ 2) again
  8
  arc> (%) ; and again
  16
  arc> (%) ; and again
  32

  arc> 2
  2
  arc> (* ^ 2)
  4
  arc> (eval thatexpr) ; i.e. (eval (* ^ 2))
  8
  arc> (eval thatexpr) ; i.e. (eval (eval thatexpr)) i.e. (eval (eval (eval thatexpr))) etc.
  [infinite loop]

  (set safeset (annotate 'mac
                 (fn (var val)
                   `(do (if (bound ',var)
                            (if (~is ',var '%)
                                (do (disp "*** redefining ")
                                    (disp ',var)
                                    (writec #\newline))))
                        (set ,var ,val)))))