What you think of as prototype inheritance, I usually think of as scope shadowing. :) Here's some untested code to show how I'd go about what you're doing:
; This kind of table can distinguish between nil and undefined.
(def singleton-table args
(when (odd len.args)
(err "Can't pair the args to 'singleton-table."))
(listtab:map [list _.0 (list _.1)] pair.args))
(def proto (parent . binds)
(annotate 'proto
(list (apply singleton-table binds) parent)))
(= empty-proto* (annotate 'proto nil))
(def proto-get-maybe (self field)
(whenlet (binds parent) rep.self
(or binds.field (proto-get-maybe parent field))))
; Here I use 'defcall, which is defined in Anarki. Rainbow has a
; variant too.
(defcall proto (self field)
(car:or (proto-get-maybe self field)
(err:+ "No field \"" (tostring write.field) "\" on "
(tostring write.self) ".")))
(extend sref (self val . args) (and (isa self 'proto) single.args)
(= (rep.self.0 car.args) list.val))
Actually, I'd get by with the longhand functions 'proto-get and 'proto-set, but that's not as nice. ^^ I only do that because I try to support plain Arc 3.1 and Jarc, which don't have 'defcall. (Supporting Jarc is nice 'cause of its debugger, and supporting Arc 3.1 is nice 'cause it's the easiest to talk about. Anarki has the most community involvement, and Rainbow is fast.)
I didn't really think of prototypes in the same way as scope, but you're right that they're basically the same thing. I suppose you could say that prototypical inheritance is scope applied to objects, rather than functions.
With that in mind, I'm curious whether prototypes would even be useful in Arc. I don't use them much in JavaScript, preferring to use plain old objects/variables/closures.
In any case, this was more of a theoretical exercise than a practical idea. It was basically me realizing that I could implement prototypes in a language that doesn't have prototypes, by using a function.
I then realized that since Arc is so malleable, I might even be able to extend the built-in eval to treat my special prototype functions as if they were hash tables. That, unfortunately, didn't work out, but I suspect I can do it with Anarki.
