akkartik, I was wondering if you might like to test this approach and see how fast it is compared to your version? (I could test the speed myself if you wanted, but without your JSON data my results might not be representative).

I believe the particular require planet line below requires MzScheme version 4, let me know if you're using version 3...

  (def deepcopylist (xs)
    (if (no xs)
         nil
         (cons (deepcopy (car xs)) (deepcopylist (cdr xs)))))

  (= scheme-f (read "#f"))
  (= scheme-t (read "#t"))

  (def deepcopy (x)
    (if (is x scheme-t)
         t
        (is x scheme-f)
         nil
        (is x #\nul)
         nil
         (case (type x)
           table (w/table new
                   (each (k v) x
                     (= (new (deepcopy k)) (deepcopy v))))
           cons (deepcopylist x)
           x)))

  ($ (require (planet dherman/json:3:0)))

  (= scheme-read-json ($ read-json))

  (def read-json (s)
    (deepcopy (scheme-read-json s)))

The idea is we run the original unmodified Scheme module, and then convert its Scheme return value to Arc.

  (def deepcopylist (xs)
    (if (no xs)
         nil
         (cons (deepcopy (car xs)) (deepcopylist (cdr xs)))))

  (= scheme-f (read "#f"))
  (= scheme-t (read "#t"))
  (= scheme-vector? ($ vector?))
  (= scheme-void? ($ void?))
  (= vector->list ($ vector->list))
          
  (def deepcopy (x)
    (if (is x scheme-t)
         t
        (is x scheme-f)
         nil
        (scheme-void? x)
         nil
        (scheme-vector? x)
         (w/table new
           (each (k . v) (vector->list x)
             (= (new (deepcopy k)) (deepcopy v))))
        (acons x)
         (deepcopylist x)
         x))

  ; ($ (require (file "/tmp/json-scheme-20050827134102/json.ss")))

  (= scheme-json-read ($ json-read))

  (def json-read (s)
    (deepcopy (scheme-json-read s)))

I tried running it but got a parse error.

  default-load-handler: cannot open input file: "/usr/lib/plt/collects/scribble/base.ss" (No such file or directory; errno=2)
  default-load-handler: cannot open input file: "/usr/lib/plt/collects/scribble/base.ss" (No such file or directory; errno=2)
  setup-plt: error: during making for <planet>/dherman/json.plt/3/0 (json)
  setup-plt:   default-load-handler: cannot open input file: "/usr/lib/plt/collects/scribble/base.ss" (No such file or directory; errno=2)
  setup-plt: error: during Building docs for /home/pair0/.plt-scheme/planet/300/4.1.3/cache/dherman/json.plt/3/0/json.scrbl
  setup-plt:   default-load-handler: cannot open input file: "/usr/lib/plt/collects/scribble/base.ss" (No such file or directory; errno=2)
  Error: "read: expected: digits, got: ."

  $ mzscheme
  Welcome to MzScheme v4.1.5 [3m], Copyright (c) 2004-2009 PLT Scheme Inc.
  > (require (planet dherman/json:3:0))
  > (read-json (open-input-string "3.1"))
  read: expected: digits, got: .

  (time:deepcopy:w/infile f "x" (json-read f))
  time: 5874 msec.
  (time:w/infile f "x" (json-read f))
  time: 3953 msec.

  $ hack ycombinator.com/arc/arc3.1.tar \
         awwx.ws/ac0.hack \
         awwx.ws/scheme-json0.hack

  arc> (= a (table))
  #hash()
  arc> (= k (fromstring "[1,2]" (json-read (stdin))))
  (1 2)
  arc> (= (a k) 'foo)
  foo
  arc> k
  (1 2)
  arc> (a k)
  foo
  arc> (a '(1 2))
  nil

  arc> (is nil (ac-scheme '()))
  t

  arc> (is nil ($ '()))
  t

Not sure what you mean by getting the reader to recognize #t, #f, #<void>?

  (require "../ac.scm")

  arc> ($ (require (file "lib/json.ss")))
  #<void>
  arc> ($ (xdef json-read json-read))
  #<procedure:json-read>
  arc> (fromstring "true" (json-read (stdin)))
  t

Problem is, I can't do it without literally hardcoding a string literal: ($ (require (file "/path/to/json.ss")))

I've tried defining a helper function, but require must be at the top level. I've tried saying (require (file (+ dir "json.ss"))), but it seems the inside of the require form isn't lisp but some toy, bizarro universe.

This whole experience is bringing home just how much I hate the mzscheme module system. Lisp is all flowing lines; require is a brick. Just one way to use it; once you release it all it can do is sink.

  (= json-path "/tmp/json-scheme-20050827134102/json.ss")

  (mac load-json ()
    `($ (require (file ,json-path))))

  (load-json)

  (mac load-scheme(f)
    `($ (require (file ,(+ ($ start-dir*) f)))))
  (load-scheme "json.ss")

see http://arclanguage.org/item?id=10942 - I fixed it on my own.

Here was the original case example:

  (fromjson "{\"RESULT\" : {\"SUCCESS\" : true} , \"SERVER\" : \"cool dude\"}")

  $ hack ycombinator.com/arc/arc3.1.tar awwx.ws/parsecomb0.arc awwx.ws/fromjson0.arc
  /tmp/4uG5ClxUqg
  ycombinator.com/arc/arc3.1.tar
  awwx.ws/parsecomb0.arc
  awwx.ws/fromjson0.arc
  mzscheme -f as.scm
  Use (quit) to quit, (tl) to return here after an interrupt.
  arc> (fromjson "{\"RESULT\" : {\"SUCCESS\" : true} , \"SERVER\" : \"cool dude\"}")
  #hash(("SERVER" . "cool dude") ("RESULT" . #hash(("SUCCESS" . t))))
  arc>