World: r3wp

Unfortunately this is not easily accomplish with rebol, unless you 
throw away the CFG and with this you loss dialecting flexibility.

I thought about that a bit. IMHO it is not that impossible. But may 
need new core-features.
The idea is that argument-lists rarely change.

Rebol lets us inspect the last values a function used. So from the 
source i cant be sure 'append is really that global 'append. But 
after the function has run, i can look what the last append was, 
and see that it got two arguments. And then i can "insert parens" 
and process it like lisp.

Needs a profile-run, or would work really well with a jit. And the 
interpreter needs to stay in the background for very hart blocks.

Jaime - from my limited understanding - you would like to see rebol 
kind of grammar to be defined and used as a wrapper running upon 
another environment?

If so - would it be easier with other functional languages, or even 
possible (if such grammar would exist), in languages like Java?

Henrik - imo with more media friendly features and rebol overal extensibility 
(as was promissed earlier for rebol), we could see Rebol being a 
tool for some nice demos ....

You haven't seen Web 2.0 till you've seen the latest Framewerks.

Semantics is key.. just ask Sir Tim Berners-Lee

How about this, a single piece of code to handle any web form.. just 
add a new field to the html and you're all set... don't need to alter 
the DB or the serverside processing.

Let's see rails do that.

hear hear  for semantics!  love how REBOL is already half there with 
the lit-word - word - value.  it all ends up being triples anyway.

and TBL, although I think he's lost himself somewhere about 60,000 
feet

MY EYES ARE BLEEDING

3Tera's AppLogic - http://www.3tera.com/applogic.html

cool.  mine are burnt from all the white.

Terry, Rails already do that. It is called Migrations, a kind of 
versioned schema, and yes you just add a field and everything works.

Volker, compiling Rebol is not impossible, it is just very difficult 
exponentially difficult because " the order evaluation" for the a 
function call can change at any time. Depending on how the words 
in the body are defined. This is the CFG feature and problem.

>> test: func[][foo bar]
>> f1: func[][probe "foo first"]
>> f2: func[x][probe "foo first"]
>> bar: func[][probe "bar second"]
>> foo: :f1
>> test
foo first

bar second

>> foo: :f2
>> test   ;;; Surprise order of evaluation changed
!
bar second

foo first

This gets more complex as the body of the function grows, the problem 
of compilation becomes exponential

That is currently true. But makes it sense? What if  such things 
are simply forbidden for compilable code?

Now you could use fix the body of a function maybe not allowing for 
function! values to change dynamically, but this will limit the language. 
I think the best approach for getting closer to the metal is REBCode. 
But I am not sure you can hav a Metacircular Rebol.

I dont think it limitsthe language. I never used that  as a feature. 
Well maybe setting 'print to none, but i can live with "print: func[value][]"

For sourcecode that paren-saving is an advantage. But if i enforce 
that the number of arguments stays the same all thetime, i see no 
problems.

How about generators or dialects, they depend of such feature. I 
mean dialect that don't use parse.

The problem is that you can not assume that the environment hasn't 
change, because if you assumed the you have broken the semantics.

Can you give an example?

Example for which part?

Where changing argument-lists make sense.

APPLY

I can only imagine cases where that is a bug.

With a bit code around?

I can simulate lisp APPLY with a dialect. APPLY require variable 
number of args>

Same for lisp MAP.

In rebol i put those args in a block.

So some of the higher-order techniques.

Lisp does that too in a way, because it puts things always in parens.

Ah. But the point is not that you code in Rebol, the point is that 
if you implement a DIALECT that has different semantics and shares 
the value types! of rebol then you can compile such dialect.

So it would be 
  apply reduce[arg1 arg2]
istead of 
 (apply arg1 arg2)
Or do i miss something?

Yes. Lisp parens are its compilation unit.

And in lisp arg1 none of the args causes evauluation while in rebol 
the may.

I meant ".... value types! of rebol then you CAN'T compile such dialect."

And in rebol we have none when looking at sourcecode.

But actually, when a function runs, its "compilation-units" are always 
the same. Meanswhen a function is run, the lisp-parens can be inserted 
by reflection. (except of strange hacks)

Basically the eval form of lisp is fixed, it is part of syntax, and 
it is (func args ...)

And in rebol it is [func arg arg2 block-of-variable-args]

At least that would work for 95% of rebol.

Not to expensive to get a lot more speed. (interpreter would be always 
available too.)

In rebol the is not special *eval form*, evaluation depends on the 
specific  expression.

But the expression does not change. its "parens" are always on the 
same places, in each evaluation.

do [val1 val2 val3 val4] ?? What this program produce?

So that part can be compiled.

Run it once.