World: r3wp

JOIN takes 2 parameters, REJOIN just takes one, and is slightly slower 
because it has to retrieve the first parameter from what would be 
the second parameter of JOIN.

A different outcome.

Looks like a bug to me, Graham.

Opinions?

Looks like a bug to me too.

R2 work around?
    to-string rejoin [#{} "hello" #{}]
    == "hello"

not for me .. thanks!

I was constructing a payload for a http post, and need a combination 
of string and binary data.  I used rejoin... and got an unexpected 
outcome.

So, I guess I'll just have to use repeated appends instead to build 
the payload.

ajoin: funco [
	"Reduces and joins a block of values into a new string."
	[throw]
	block [block!]
][
	make string! reduce block
]

Faster than JOIN or REJOIN.

Sorry about the funco, I copied that from R2/Forward.

let me guess .. part of your rebol3 backport ??

Of course.

does it build a series without corrupting binary data ??

perhaps i need 'bjoin :)

Yes. The mezzanine is faster than the native version, but the native 
doesn't have the intermediate block overhead.

Where is it?

'funco i.e.

It's just another name for FUNC (where FUNC is redefined in R2/Forward).

ask-brian: funco [ ask-brian ]

oops... missing the second block!

Just use FUNC :)

Nope... seems to give the same problems as rejoin

ajoin: func [[throw!] block [block!]][make string! reduce block]
>> ajoin [ "hello" make binary! 1 ]
== "hello#{}"

apologies .. Sunanda's workround works  viz to-string rejoin [ #{} 
.... ]

Wow, that make string! change to join/rejoin yields about a 300% 
speed increase! Definiately one to backport to R2.

doesn't help with 'ajoin though ... need to coerce to binary first

Graham -- glad the workaround  works.
But it is R2 only. R3 has other problems.

not too fast .. it exhibits different behaviours

Just needs a bit of datatype coercing added.

this has always got me
 rejoin [ <text> "hello" </text> ]
== <texthello</text>>

rejoin [ "" <text> "hello" </text> ]
== "<text>hello</text>"

which is I guess one should use 'reform when constructing strings 
for web output.

this fix allows me to upload a binary document using the googleapi 
.. eg. docx

First cut QAD on join/rejoin, still about twice as fast the originals:

	join: make function! [
		"Concatenates values."
		value "Base value"
		rest "Value or block of values"
	][
		either series? value [
			make type? value reduce [value rest]
		][
			make string! reduce [value rest]
		]
	]


	rejoin: make function! [
		"Reduces and joins a block of values."
		block [block!] "Values to reduce and join"
	][
		either empty? block: reduce block [block] [

   make either series? first block [type? first block] [string!] block
		]

	]

try rejoin with using #{} as the first element!

Ashley, that JOIN doesn't work for block types. It should be:
>> join [a b] [1 2]
== [a b 1 2]
Yours returns  [[a b] [1 2]]]

Anyone can tell me why my googledocs object won't clone?

http://rebol.wik.is/Googledocs

gdoc: make object! googledocs []
** Script Error: Invalid argument: object
** Near: gdoc: make object! googledocs []

crap

still asleep ...

ignore

Has anyone done any work with OAUTH ie. open authentication?

REPEAT is a native. Can it be made as a mezzanine using WHILE? It 
takes 3 arguments:
'word value body


The first is seen as a lit-word by the function. This should be bound 
to body and only be used as a local variable in the function context. 
My first attemp to make a REPEAT mezzanine didn't go well:

my-repeat: func [
	'word value body
][
	bind/copy body word
	word: 0
	while [(word: word + 1) <= value] body
]

>> my-repeat i 10 [print i]
** Script Error: i has no value

Suggestions?

One problem is, that WORD become an integer, when I set it to zero. 
If I write:
set word 0

instead, I create a global variable. I'm wondering, if this can be 
done at all!?

my-repeat: func ['w v b][use reduce [w] compose/deep [(to-set-word 
w) 0 while [v >= (to-set-word w) (w) + 1][(b)]]]

(sorry for abbreviations, using small keyboard)

Nice Chris! I expected, it could be done somehow. Do you know, if 
REPEAT was a mezzanine in some of the first versions of REBOL?

Can it be made without COMPOSE?

This version without COMPOSE seems to work:

my-repeat: func [
	'word value body
][
	use reduce [word] reduce [
		to set-word! word 0

  'while reduce ['value to word! ">=" to set-word! word word '+ 1]
			body
	]
]


I'm not quite sure, why it works without using BIND to connect body 
with word?

...why it works without using BIND to connect body with word?
 - of course it binds the body, USE takes care of that