[REBOL] Does REBOL cons?
From: massung:gmai:l at: 15-Mar-2006 16:15
Okay, so, I've been trying something out, comparing REBOL to Lisp. The
functions in REBOL make it appear as though the lists (series!) in REBOL are
just your average conses (first, next, associations, etc). Because of this
and constant data optimizations, etc, this function in REBOL makes sense:
foo: func [/local a] [
a: [a b c]
append a [d]
]
>> foo
== [a b c d]
>> foo
== [a b c d d]
This makes sense, at least, until after the second call. The above function
would be akin to the following Lisp code, which does *almost* the same
thing:
(defun foo ()
(let ((a '(a b c)))
(nconc a '(d))))
The main difference being that the second call to (foo) will result in an
infinite list, because '(d) is scoped data, just like '(a b c), and the
second call will cons '(d) with itself, giving us '(a b c d d d d d ...).
In REBOL, everything seems to match up, except that [d] doesn't cons with
itself. Now, IMO, this is good, desired behavior (not generating an infinite
list). However, what this implies "under-the-hood" is that REBOL doesn't use
traditional consing for lists, but does something else instead.
I was wondering if anyone could shed a little light on this. If REBOL does
use consing, then why don't I end up with an infinite, self-referencing
list? If it doesn't using consing, what does it use (not that it matters,
I'm just curious)? This is actually a little exciting to me, because if it
isn't using your typical consing, then that means REBOL's associated lists
could potentially be a lot faster than Lisp's (which, of course, have O(n)
access times).
Jeff M.
--
massung-gmail.com
