World: r3wp

Shorter?
g i o 'f
:)

lol :P

Is there some way to send the html of a web page to the Rebol 'browse' 
function without actually writing the html file?

the browser has to read a file...

or  stream of data.

here's a quick demo..

rebol []

theTOC: ask "Table of contents (seperate with <p></p> tags): "
theHeader: ask "Header: "
theNumOfBars: ask "Number of chart bars: "
outputPath: ask "Save path (with trailing / ie: c:/): " 


getTemplate: read http://o7o.org/files/aflax/examples/barchart/barchart.html

getSWF: read/binary http://o7o.org/files/aflax/examples/barchart/aflax.swf

replace/all getTemplate "$TOC" theTOC
replace/all getTemplate "$theHeader" theHeader
replace/all getTemplate "$numOfBars" theNumofBars

write to-rebol-file join outputPath "barExample.html" getTemplate
write/binary to-rebol-file join outputPath "aflax.swf" getSWF
browse to-rebol-file join outputpath "barExample.html"

oops wrong group

Yes, you can "browse http://127.0.0.1:123456" and have a small server 
to send the page to the browser.

is it possible to set the args of an error explicitely, instead of 
giving a string?

found it: http://www.rebol.com/docs/core23/rebolcore-17.html#section-5

What will be the closest to lisp CONS method in rebol?

thats for building lists? insert/append ?

Is for building list using mutually recursive funcs.

and at the end you have something linear, so you could use block! 
or list! ?

I tried using reduce but it didn't quite work. Append failed completely. 
Maybe I need a way to keep a block.

do you have a lisp-example?

Yes.

(define subst
  (lambda (new old slist)
    (if (null? slist)
        '()
        (cons 
         (subst-in-symbol-expression new old (car slist))
         (subst new old (cdr slist))))))

(define subst-in-symbol-expression
  (lambda (new old se)
    (if (symbol? se)
        (if (eqv? se old)
            new
            se)
        (subst new old se))))

(subst 'a 'b '((b c) (b () d)))

== ((a c) (a () d))

Here is my approach in rebol.

sub-sb: func [new old slist][
    either empty? slist [
        []
    ] [
        reduce [
            sub-sb-in-symbol new old slist/1 
            sub-sb new old next slist 
        ]
    ]
]

sub-sb-in-symbol: func [new old se][
    either word? se [
        either :se = :old [:new] [:se]
    ] [
        sub-sb new old se
    ]
]

>> 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.

:)