World: r3wp

Not much rebol left:

cons: func[left rest][
 if all[ [] = left [] = rest ][ return copy [] ]
 head insert/only copy rest left
]
car: :first
null?: :tail?
cdr: func[series][ copy next series ]
subst: func[new old slist /local left rest][
 if null? slist[return make slist 0] ; same series-type please
 (cons 
  subst-in-symbol-expression new old car slist
  subst new old cdr slist
 )
]
subst-in-symbol-expression: func[new old se][
 if not any-block? se[
  if equal? se old [ return new ]
  return se
 ]
 subst new old se  
]
print "10 9 8 7 6 5 4 3 2 1 0 ??"
probe l: first[ ((b c) (b () d)) ]
probe subst 'a 'b l

I think this CONS could be added to the mezz.

cons: func [left rest [series!]][

    if all [series? left empty? left empty? rest] [return copy rest] 
    head insert/only copy rest left
]

Maybe a set of lisp-porting-tools? In rebol itself i use more iteration 
and insert/append. No need for cons. In lisp its recursion and list-building, 
there it is helpfull.

Your version is better, keeping the type on empty lists.

Which lisp do you use? emacs, scheme, common?

PLT Scheme

Would you teach me? :)

I rather point you the two best books I have read on this:
- How to Design Programs http://www.htdp.org/

- Essentials of Programmin Languages http://www.cs.indiana.edu/eopl/

I am started to read the 'EoPL' book this week. It has been an eye 
opener. Both books a very easy to follo the HTDP book is completely 
online.

EoPL is about how to create programming languages.

I start a bit with the online-version.

And learn EoPL in discussions here :)

That EoPL looks interesting. got contents and foreword http://www.cs.indiana.edu/eopl/front.ps
. Like it.

I got it, it is a hard book. I haven't gotten the time to get through 
it with my job and kids, but what I have done was well worth it. 
EopL and the "book with the dragons" by Aho et al about complier 
design are books that change your view on programming.

hard book as in hard back or hard to understand ?

Both (at least for me ;-)

ahh ... so it was a pun

Latest CONS it takes into account that rebol has different types 
of series!

cons: func [left rest [series!]][
	if all [
		series? :left 
		equal? type? :left type? :rest
		empty? :left empty? :rest
	] [return copy :rest]
    head insert/only copy :rest :left
]

http://polly.rebol.it/test/test/cons/cons.rupdated :)

how can I get some deeper context words? :-) I just wanted to check, 
if request-date finally uses system structure month/day names, so 
I sourced it:

request-date: func ["Requests a date." /offset xy][
    result: none
    if none? base [init]
    either offset [inform/offset date-lay xy] [inform date-lay]
    result
]

then I tried to add following:

insert at second :request-date 11 [probe date-lay]

but it does not know date-lay, like the word I added this way would 
not be bound to the context of the function? But looking at source 
it seems correct :-)

IIRC I successfully used such aproach in the past :-)

About request-date, I had reworked it for the "first" View 1.3 project 
(2 years ago). It use locales and some other enhancements. Just test-it 
directly :

do http://www.rebol.org/cgi-bin/cgiwrap/rebol/download-a-script.r?script-name=request-date
.r

Or have a look to the req-funcs object (with anamonitor ).

Pekr, you can do it by binding your 'date-lay to the 'date-lay that 
is already in the function body.

 insert second :request-date bind [probe date-lay] pick pick second 
 :request-date 10 2

(Mmm... request-date is quite an ill-behaved function. It sets 5 
words in the global context.)

Above I have bound your whole block of code to the existing 'date-lay 
word.

It could be better (a more reliable way in other situations) to bind 
just the 'date-lay word in your new code
(ie. only the words which need binding):

 insert second :request-date compose [probe (bind 'date-lay pick pick 
 second :request-date 10 2)]

Should 'forskip not take a block ?  As it is, it only takes a word.

same with forall. a tad annoying, me thinks

Rambo it ?

If it took a block, how would you make a reference to where you are 
in the block?

if you wish to parse a literal which changes ... how would you do 
that?

parse phrase [  'literal ]

can't be done this way

parse phrase compose [ '(literal) ]

have you tried  parse phrase to block! join "'" 'literal

what would the source of 'sixth be? (something like   sixth: func 
[ serease ] [pick serease 6] ;but how to make it be an action value?

Actions are like natives. They are built in and you can't make them 
yourself.

What makes you want to do that, though ?

Grham: use subrule
changing: ['literal]
parse phrase [changing]

Or do you want to catch any lit-word?

Anton...I was afraid that would be the answer...course, maybe it 
works anyway...where a function! is used in the place of an action! 
(however, I dread there might be some side-effect if action! needs 
a context, and that context it needs is not provided by the function! 
substitute.

I will let you know if I reach a pitfall with my approach (so far, 
so good...;-)

Volker, the parse rule occurs in a BEER callback .. and I need to 
change the parse rule depending upon which BEER function I am calling. 
 Of course, there are always workrounds one can set up, but was wondering 
if there was some way to relax the REBOL interpreter when building 
up dynamic code like this.

I found myself writing lots of BEER code that all looked the same 
...

Seems the 'case statement is not in the encap from July last year 
and it's a native.
Anyone have source for a mezzanine case statement ?

Ahh... someone just posted one to rebol.org, but it doesn't work 
the same way as the native.

Ladislav's PIF function appears to be functionally similar to the 
new case construct

The old domain still seems to work

http://www.fm.vslib.cz/%7Eladislav/rebol/pif.r

Great! A case statement! I have been waiting for that!

I like the functionality too. nice!

if you rename PIF to CASE (in the PIF source too), you hardly can 
find a difference