World: r3wp

How about taking a page from Andrew Martin's book: rename REJOIN 
-> JOINS ? ie.  JOIN joins two arguments, JOINS joins any number 
of arguments.
Or it could also be ENJOIN (N-JOIN).

I think the Francophones would also like ENJOIN.

Why not simply get rid of rejoin and replace for the more useful 
DELIMIT?

delimit [1 2 3] ;== "123"
delimit/with [1 2 3] "," ;== "1,2,3"
delimit/quoted 
[1 2 3] ;== {"1","2","3"}
delimit/quoted/with [1 2 3] "|" ;== {"1"|"2"|"3"}

npa: 
703
nxx: 938
delimit [npa nxx] ;== "npa nxx"
delimit/reduce [npa 
nxx] ;= "703938"
delimit/reduce/with [npa nxx] "-" ;== "703-938"
delimit/reduce/quoted/with 
[npa nxx] "|" ;== {"703"|"938"}

Sorry for that it drives me nuts that Altme in OSX doesn't preserve 
newlines.

;; usage examples

delimit [1 2 3] ;== "123"
delimit/with [1 2 3] "," ;== "1,2,3"
delimit/quoted [1 2 3] ;== {"1","2","3"}
delimit/quoted/with [1 2 3] "|" ;== {"1"|"2"|"3"}

npa: 703
nxx: 938
delimit [npa nxx] ;== "npa nxx"
delimit/reduce [npa nxx] ;= "703938"
delimit/reduce/with [npa nxx] "-" ;== "703-938"
delimit/reduce/quoted/with [npa nxx] "|" ;== {"703"|"938"}

;; Here is my implementation, maybe in can be fine tuned.


delimit: func [data [block!] /reduce /quoted /with separator  [string! 
char!]  /local result quote][
  unless empty? data [
    result: copy {}
    unless with [separator: ""]
    quote: either quoted [
        func[x][rejoin [{"} x {"}]]
    ][
        func[x][x]
    ]

    insert result quote form either reduce [do first data][first data]
    foreach value next data [

    insert insert tail result separator quote form either reduce [do 
    value][value]
    ]
    result
  ]
]

It looks like a very fine function - *except* I would name it differently 
(I prefer GLUE).

I think the form use to produce the  reduce effect is incorrect. 
Most probablay it needs to written using DO/NEXT.

Lots of English candidate words suffer because they don't imply copy, 
whereas in rebol this is important and it would be nice to distinguish 
between when we are copying and when we are not.

I think you are right. FOREACH is stepping through each value of 
the block unevaluated, then, expecting to be able to evaluate it 
successfully. But what if it is a function expecting arguments ?

;; New version does proper reduction


delimit: func [data [block!] /reduce /quoted /with separator  [string! 
char!]  /local result quote][
  if reduce [data: system/words/reduce data]
  unless empty? data [
    result: copy {}
    unless with [separator: ""]
    quote: either quoted [
        func[x][rejoin [{"} x {"}]]
    ][
        func[x][x]
    ]
    insert result quote form first data
    foreach value next data [
      insert insert tail result separator quote form value
    ]
    result
  ]
]

;; example

>> delimit/reduce/with [npa nxx square-root 4] " "  ;== "703 938 
2.0"

Note, if this is going to be Rebol3, then you should be able to use 
APPEND instead of INSERT TAIL without penalty.

Now we need a good name. I am not sure about glue. How about CONCAT

Another one is CHAIN

concatenate: 
verb [ trans. ] formal or technical 
link (things) 
together in a chain or series : some words may be concatenated, such 
that certain sounds are omitted.

Another optin is LINK

To summarize  we have: REJOIN, GLUE, CONCAT, CONCATENATE, CHAIN, 
LINK.

And DELIMIT

'link? is already used, so it might be interpreted as 'link is somehow 
... linked to 'link? :-)

interpreted as if 'link is

weld?

Just looking at the Thesaurus:
http://thesaurus.reference.com/search?q=join&x=0&y=0
Some nice words:

adhere, affix, (agglutinate), cement, conjoin, fasten, fuse, leash, 
marry, wed, weld.

Do you want the added functionality of the DELIMIT above?

jaime, yes that would be very nice

conjoin is cool, language root are like "delimit/with"

Ah yes, Jaime, I wanted to say "DELIMIT" lies to you when it is used 
without the /WITH refinement, because DELIMIT implies delimiters. 
If there aren't any delimiters, then it is lying.

So an idea I would like to explore is to split the functionality 
of DELIMIT into perhaps two functions. As this kind of operation 
is very common, I suggest that this will save lots of typing.

How will you split it.

The description I have for DELIMIT is "Returns a string! constructed 
from the chained values in the block."

Must think about that.

I should not that I am not attached to DELIMIT. It stated like with 
a different purpose, but now I see that is more generic than REJOIN. 
So I offer it after modifying it a bit.

I like the CONJOIN word.

Currently we use REJOIN for most things, and sometimes we miss being 
able to add delimiters, after that, the next functionality is probably 
the quoting.

But CONJOIN is not very common. I thinkn CONCAT will be more mnemonic 
for newbies.

Picking names is very hard. I kind of like to have all the functionality 
cram in one function, less words to remember. So I left the naming 
decision to the community, just hope the features of delimit are 
include in R3.

So I would drop the /WITH refinement and make it implicit in a DELIMIT 
or CONJOIN function... (maybe..)

1) rejoin/quoted [...]   ; <-- this is most similar to rejoin, or 
delimit without the /WITH

2) conjoin/quoted "," [...]    ; <-- this is like delimit/with/quoted 
 (and the non-optional "with" argument is specified first)

I dislike CONCAT because it is an abbreviation.

me too, but a lot of people knows it.

I am not sure I follow your points.

The first function, REJOIN, is like the current rebol REJOIN, except 
it now has your /QUOTED refinement.

I don't really see the reason for splitting features of the function.

The second function, CONJOIN, is like your DELIMIT, except with WITH 
refinement implicit.

I think is better to keep Rebol's lexicon short.

I think the /REDUCE refinement usually isn't needed (I could be wrong), 
because if you are not going to reduce the block then you already 
know what the result is.

>> delimit [1 1 / 2 ]  ;
== "11/2"

>> delimit/reduce [1 1 / 2]  ;
== "10.5"

I think functions that are used very often with certain combinations 
of refinements ought to be split.

That can be changed easily.

If we make the right decisions about which functions are important 
enough to have their own word, we free ourselves with clearer code 
etc. Imagine if there was no DO function, but that functionality 
was a refinement of LOAD or REDUCE   --->    We would write REDUCE/DO 
 all the time.