ar.sh:

    #! /bin/sh
    #|
    exec mzscheme -fmv "$0" ${1+"$@"}
    |#
    (require mzscheme)
    (load "ac.scm") 
    (require "brackets.scm")
    (use-bracket-readtable)
    (aload "arc.arc")
    (aload "libs.arc")
    (aload (car (vector->list (current-command-line-arguments))))

    (whilet line (readline)
      (prn line))

    chmod +x ar.sh
    ar.sh main.arc

"$0" expands to the program name ("ar.sh" in his example).

${1+"$@"} is conditional:

if $1 (the first positional parameter) is unset it expands to nothing.

1 - Paste the following code into a new document test.ss and save in servlet example folder (/usr/plt/collects/web-server/default-web-root/servlets/examples/test.ss) If document name test.ss changes, change the module name on first line.

(module test mzscheme (require (lib "servlet.ss" "web-server")) (provide (all-defined)) (define interface-version 'v1) (define timeout +inf.0)

  (define cc (make-parameter #f))

  (define (input name) `(input ((type "text") (name ,(format "~a" name)))))
  (define (submit) `(input ((type "submit"))))
  (define (form . body) `(form ((action ,(cc))) ,@body))
  (define (a ref . body) `(a ((href ,ref)) ,@body))
  (define-syntax page
    (syntax-rules ()
      [(page x ...) (send/suspend (lambda (k) (cc k) `(html (body ,x ...))))]))
  (define (get name req)
    (extract-binding/single name (request-bindings req)))

  (define (start initial-request)
    (define foo (get 'foo (page (form (input 'foo) (submit)))))
    (page (a (cc) "click here"))
    (page "you said: " foo))
  

2 - Start the PLT web server sudo /usr/plt/bin/plt-web-server

3 - Open a web browser and navigate to http://localhost/servlets/examples/test.ss

http://arclanguage.com/item?id=804

    (define (ac-call fn args env)
      (let ((macfn (ac-macro? fn)))
        (if macfn
          (ac-mac-call macfn args env)
          (let ((afn (ac fn env))
                (aargs (map (lambda (x) (ac x env)) args))
                (nargs (length args)))
            (cond 
              ((eqv? (xcar fn) 'fn)
               `(,afn ,@aargs))
              ((and (>= nargs 0) (<= nargs 4))
               `(,(string->symbol (string-append "ar-funcall" (number->string nargs)))
                                  ,afn ,@aargs))
               (#t
                `(ar-apply ,afn (list ,@aargs))))))))

    (define (ac-macex e . once)
      (let ((m (ac-macro? (xcar e))))
        (if m
          (let ((expansion (ac-denil (apply m (map ac-niltree (cdr e))))))
            (if (null? once) (ac-macex expansion) expansion))
          e))
      )

    (define (ac-complex-args? args)
      (cond ((eqv? args '()) #f)
            ((symbol? args) #f)
            ((symbol? (xcar args))
             (ac-complex-args? (cdr args)))
            (#t #t)))

    (define (ac-qq1 level x env)
      (cond ((= level 0)
             (ac x env))
            ((eqv? (xcar x) 'unquote)
             (list 'unquote (ac-qq1 (- level 1) (cadr x) env)))
            ((and (eqv? (xcar x) 'unquote-splicing) (= level 1))
             (list 'unquote-splicing
                   (list 'ar-nil-terminate (ac-qq1 (- level 1) (cadr x) env))))
            ((eqv? (xcar x) 'quasiquote)
             (list 'quasiquote (ac-qq1 (+ level 1) (cadr x) env)))
            ((pair? x)
             (map (lambda (x) (ac-qq1 level x env)) x))
            (#t x)))

    1) Not evaluate arguments directly in ac-call, but keep the original arguments and envs
    2) Add a clause in ar-apply to deal with macros
    3) Make sure that in ar-apply, arguments are evaluated for the case where it is still a function/list/hashtable and not a macro

While exploring this, I modified the code some more, notice that w.r.t. to the other suggestion I made to ac-call (which was completely backwards compatible), the ac-call here changes only by -1- letter.

    (define (ac-call fn args env)
      (let ((afn (ac fn env))
            (macfn (ac-macro? afn)))
        (cond (macfn
               (ac-mac-call macfn args env))
              ((and (pair? fn) (eqv? (car fn) 'fn))
               `(,afn ,@(map (lambda (x) (ac x env)) args)))
              ((= (length args) 0)
               `(ar-funcall0 ,afn ,@(map (lambda (x) (ac x env)) args)))
              ((= (length args) 1)
               `(ar-funcall1 ,afn ,@(map (lambda (x) (ac x env)) args)))
              ((= (length args) 2)
               `(ar-funcall2 , afn ,@(map (lambda (x) (ac x env)) args)))
              ((= (length args) 3)
               `(ar-funcall3 ,afn ,@(map (lambda (x) (ac x env)) args)))
              ((= (length args) 4)
               `(ar-funcall4 ,afn ,@(map (lambda (x) (ac x env)) args)))
              (#t
               `(ar-apply ,afn
                          (list ,@(map (lambda (x) (ac x env)) args)))))))
    
    ; returns #f or the macro function
    (define (ac-macro? fn)
      (let ((v
              (if (symbol? fn)
                (namespace-variable-value fn
                                          #t
                                          (lambda () #f))
                fn)))
        (if (and v
                 (ar-tagged? v)
                 (eq? (ar-type v) 'mac))
          (ar-rep v)
          #f)))