World: r3wp

>> sub-sb 'a 'b [[b c] [b [] d]]
== [[a [c 
            []
        ]] [[a [
                [] [d 
                    []
                ]
            ]] 
        []
    ]]

So not linear, but a tree. And you use blocks as lisp-pairs.

Do you need a rebol-version for this problem, or general a cons-emulation?

I think I can contruct CONS myself. But I was wondering if we could 
do it just with rebol constructs. I would also like to see you CONS.

In this case i would not cons a new tree, but change the old (or 
a copy of it).

if i understand right, we could use a block for a lisp-pair, and 
'first and 'second for car/cadr ?

and a list (a b c) would look like
 [a [b [c nil] ] ]

Have to remember my little bit lisp..

http://www.rattlesnake.com/intro/cons.html#cons?

something like
cons: func[a b][
 reduce[ first a  b  ]
]

cons: func[a b][ reduce[ first a  b  ] ]
 probe cons[a none] cons [b none ][c none]
== [a [b [c none]]]
and 
(cons 'a (cons 'b '(c)))
== (a b c)

This is my cons it works well. I think there is a problem with yours. 
cons: func [
	[catch] car cdr [series!]
][
	either empty? cdr [
		either all [series? car empty? car] [
			[]
		][
			reduce [car]
		]
	][
		head insert tail reduce [car] cdr
	]
]

>> cons [a b c] [d e]
This is a list of test from lisp.

> (cons 'a '())
(list 'a)
> (cons '() '())
(list empty)
> (cons '() 'a)
cons: second argument must be of type <list>, given empty and 'a
> (cons '(a b c) 'a)

cons: second argument must be of type <list>, given (list 'a 'b 'c) 
and 'a
> (cons '(a b c) '(d e))
(list (list 'a 'b 'c) 'd 'e)

I guess i represent lisp-nodes differnetly, and maybe wrong.

for me a lisp-node has always two values, there is no empty one. 
So i use always a block of length 2.

btw here is a rebol-version of subst:

l: first[ ((b c) (b () d)) ]
subst: func[l old new][
 forall l[
  either any-block? l/1 [
   subst l/1 old new
  ][
   if old == l/1 [ l/1: new ]
  ]
 ]
 l
]
probe l
probe subst l 'b 'a

Nice. Replace on place. ;-)

Hmm, no, there are atoms and lists. So i have to dig a bit deeper. 
then cons is really a 'reduce. but lisp has no lists with multiple 
elements, thats mold-sugar. WHile we have in rebol and your cons 
can deal with that.

(AFAIK, i am longtime lisp newbie)

But isnt that what insert/only does? putting a new value in front 
of a series? To match exactly it would be into a copy of the series, 
but i guess that does not matter.

I hope i got the lisp right

cons: func[left rest][
 head insert/only copy rest left
]
subst: func[new old slist /local left rest][
 if tail? slist[return head slist]
 (cons 
  subst-in-symbol-expression new old first slist
  subst new old copy next 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

(and it must be a copy, on several places)

Only one problem with you cons

cons [] [] ;== [[]] 

it should be

cons [] [] ;== []

But together with the rest it works.

:)

Is this the only problem left?

I think. Very nice and short cons.

Maybe it should be part of the mezz.

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
]