This is the best comparison of Rebol to another language!
Will it get turned into a webpage, so it can be put on
the www.rebol.org links page?
>
>JB, you may not be familiar with REBOL history, but the 1.x
>versions of REBOL were based on Scheme semantics. REBOL was
>much slower back then, and had a larger executable, both the
>result of using the Scheme model. I've got a copy of 1.0.3
>for Windows if you're curious.
>
>I have been using Scheme for about 8 years now and have done
>my own Scheme compiler/interpreter, so I know what you mean
>when you sing its praises. REBOL and Scheme are more similar
>than you realize, though. For the most part you can simply
>translate from Scheme to REBOL with no loss of functionality,
>and more speed too. For example:
>
>First-class closures:
>- Scheme: (set f (lambda (x) x + 1)) or (define (f x) x + 1)
>- REBOL: f: func [x] [x + 1]
>
>Symbol/Object distinction:
>- Both: 'symbol object
>
>Lexical scoping (other than in functions):
>- Scheme: (let ((x 1) (y 2)) x + y)
>- REBOL: use [x y] [x: 1 y: 2 x + y]
>The "main" REBOL dialect implements lexical scoping as its
>default behavior, just in a different way than Scheme does.
>Scheme (interpreted) has dynamic binding, so all variables
>are mapped to values in a lexical context, but symbols are
>bound to variables at runtime, at every reference. With
>REBOL the symbols are bound to variables once, before the
>code is executed. Direct binding makes REBOL more similar
>to compiled Scheme, even when it is interpreted.
>
>Fluid variables: Scheme needs this as a hack to get around
>the limitations of lexical scoping. REBOL doesn't need them
>because direct binding is much more powerful.
>
>Macros: With Scheme, code only looks like data, so it needs
>a macro mechanism. With REBOL, code IS data, so there is no
>distinction needed between macros and other functions. The
>REBOL functions for code-building are more powerful too.
>
>Language and execution model:
>- Scheme: Lisp-like lexically scoped language (conceptually)
> built on a continuation engine - pretends to be stack-based
> for implementation efficiency, at least if you avoid call/cc.
>- REBOL: Unique, two-level language (dialects on data language)
> built on a Forth-like stack engine for efficiency that Scheme
> only gets after heavy optimization (sometimes not even then).
>
>Tail-recursion: Scheme has it (side effect of the continuation
>engine, hacked when stacks are used); REBOL dropped it when it
>switched to 2.x for efficiency reasons (whoops!). I guess you
>have to use REBOL's extensive iterative functions instead.
>
>Continuations: Scheme has them (base of its execution model);
>REBOL dropped these too when it switched to a stack engine.
>Continuations don't make much sense with a stack engine - they
>only work well when the execution model is continuation-based.
>If you can't refactor your code to use callbacks or some such,
>you probably don't understand it well enough to be programming
>with continuations. Take a look at Icon - its goal-directed
>evaluation beats continuations any day of the week.
>
>Numerics: REBOL is comparable to most Schemes, but that is only
>because most Schemes don't implement the entire capabilities of
>the Scheme standard. Most people don't do much numerics in an
>interpreted language anyway, but I miss bignums :(
>
>List manipulation and data structures: REBOL does all of what
>Scheme does, and usually does it faster. The map functions are
>missing, but easily replaced, like replacing this:
> (set y (map (lamda (x) x + 1) '(1 2 3)))
>with this:
> y: copy [1 2 3]
> forall y [change y (first y) + 1]
> y: head y
>or if you really want map, you can make it easily yourself.
>Other changes (mostly to factor out some recursion) are just
>as easy to do. Most data manipulations are easier in REBOL.
>
>String manipulation and parsing: Throw your Scheme code away -
>you'll never regret it. The incredible REBOL parse dialect gets
>better every day - you'll wonder how you got by without it in
>primitive languages like Scheme :)
>
>As for unified, formal approaches, well Scheme wins there.
>REBOL is easily as unified as Scheme, but Scheme has been
>formalized to death - no contest. Hey Gabriele, do you want to
>help turn our context argument into a formal paper, tutorial
>or something? Any one else up for papers?
>
>By the way, there is nothing about REBOL's GC problem that is
>inherent in its execution model. It can be fixed, and it can
>be avoided easily until it is fixed. As GC bugs go, I've seen
>much worse than that. I'd still like it fixed, though :(
>
>Over all, I've found REBOL to be better at almost everything
>Scheme is supposed to be good at, with few exceptions. Scheme
>has been a great tool for years, but REBOL is much better.
>
>>Unsolicited $0.02,
>>
>>jb
>
>I think I've put in at least $0.04, no less unsolicited :)
>
>Brian Hawley
>
>
