World: r3wp

(thranslation should be able to adjust the order according to the 
language requirements)

Sounds then the cases are quite different and should have different 
functions

Ladislav, the advantage would be that you don't have to allocate 
a substitution argument for that % escaping, especially if some of 
your template strings might need a %1 in them and others might not.

I am thinking of the code-generation posibilities, where instead 
of Russian you are generating ASP or something.

Or RSP if you like.

the advantage would be that you don't have to allocate a substitution 
argument for that % escaping

 - yes, understood, I was originally for that alternative, but, Cyphre 
 convinced me, that for human writers, actualy the substitution is 
 more readable

Ah, sticking to the natural language translation usage model, even 
though you are allocating a more generally applicable name to the 
function.

substitute ( "%1" "translate" )

Well, yes, the name may be conflicting, sure

But, "translate" is not a good name, since the translation is what 
is being performed as well, besides the substitution

Well, given my current business needs I would use SUBSTITUTE more 
for code generation than for translation, but it would be useful 
for generating English as well.

Sure, I expect there *are* other uses. As for the %% case, I am still 
not sure, it might be intersting to know what would Robert prefer.

In general, I do not expect the #"%" character to be contained in 
the texts being followed by a digit. At least not frequently enough 
to normally matter.

But, sure, in strings that are not meant to communicate something 
to humans, the frequency of "%" may be higher.

Hi, I found the following text part in the Replacement article: "ENLINE 
any-block!,". Forgive my ignorance, please. What exactly is ENLINE 
meant to do in case its SERIES argument is a block?

I am especially curious, if it really qualifies as non-modifying 
function in that case.

aha, nevermind, I just used some tests to find out what it does

I really wish the ENLINE/with ticket would be implemented. I could 
use this function daily.

In R3 we have got the

    system/state/last-error


, which is great for convenience. Is there a corresponding variable 
in R2?

If it does not, it would be great to have this feature backported...

Today's Moment of REBOL Zen:

>> s: "A"
== "A"
>> lowercase s
== "a"
>> s
== "a"
>> c: #"A"
== #"A"
>> lowercase c
== #"a"
>> c
== #"A"

:-)

I hope you know why?

Yes, I do.

And I'm thinking, if it would be an idea to let functions like that 
take word arguments handling them like call-by-reference. Then it 
would be possible to change chars too.

You mean also
>> i: 5
== 5
>> multiply i 4
== 20
>> i
== 20 (?)

That would be
	multiply 'i 4

then. Maybe not too useful in that case. Or though, the ++ operation 
(function) could use this too. Which then reminds me, that NEXT should 
be used for what ++ does. :)

There was a discusson in Carl's blog about this long time ago.

move-next 'series
 looks ok but multiply looks weird.
but ++ already works for series as you say.

++ : "Increment an integer or series index."

Has anyone said the following before?

call-by-word

I didn't hear that before.

I suggest: skip ++ and use NEXT with call-by-word to do the same. 
Less functions to remember that way.

using NEXT with call-by-word (I like the name :) ) looks ok to me, 
but I remember that, "guru"s may say "it leads performance overhead 
for next, as it is a native and used a lot. it should check the argument 
and get-value if it is a word."

I'm not too sure about additional overhead, depending on how NEXT 
is implemented today. My guess is, NEXT already test for different 
datatypes, as it can handle blocks, strings, etc. To in that SWITCH 
(guessiong) in the source code, it just have to include the word! 
type also and handle that, and default: give the error.

To -> So

and *guessing* :) Getting late = more typing errors.

Then we could have things like:

>> a: 41
>> next a
== 42
>> a
== 41
>> next 'a
== 42
>> a
== 42

NEXT already test for different datatypes, as it can handle blocks, 
strings, etc.

But it's all series type. So no type checking I think. It supports 
only series and port values.

If it supports those actions, then it should be everywhere:

SKIP, ADD, DIV, NEXT, NEGATIVE, AND etc.. then it leads a overhead.

I would guess, the code is different for doing next string, next 
block and next port.

I like the idea, but it looks it needs using too much GET value in 
all the actions above.

Yeah, and some may argue, it's less readable with call-by-word options. 
But some probably also finds it strange, that NEXT string doesn't 
alter the string, while LOWERCASE string does.

A lot of things like

var: var + something	; or
var: add var something

could be changed to

add 'var something

It's kinda like the += in C.

'var + something
hmm... that's not too readable.

infix functions, op!s should not support this, because it is really 
not readable

Yeah, I tend to agree.

what about writing a bunch of new functions suffixed with '
ADD'
NEXT'

Yes, REBOL makes it possible to do all this already. In fact, all 
the natives could be recreated as mezzanines supporting call-by-name, 
but that'll be slow of course.

You can easily see the extra overhead:
SOURCE ++
additional IF, GET, SET and CASEs..