World: r3wp

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

The default behaviour could be to reduce.

That might be an idea. Closer to current rebol behaviour too.

delimit [1 1 / 2] ;== "10.5"
delimit/literal [1 1 / 2] ;== "11/2"

Yes, I think that's better. That refinement is the "weakest" of the 
three.

Please excuse me if I'm a little hazy today. Feeling a bit quantum 
mechanical today.

I like 'conjoin

anton, don't go phase into higher dimensions jus yet. :-)

it is ... too late... for me...

but then also think about form vs reform

wasn't there supposed to be kind of formatting dialect at one time? 
IIRC Carl never added it to rebol. Maybe 'form could be used even 
for joining, although its purpose is slightly different.

I think, there are more important issues than renaming rejoin