World: r3wp

because every time I use "find" I have to check the return value

@Davide: I've actually thought the same thing about none, with respect 
to joining (though I think [0 = length? none] would be unwise, just 
as [true = true? 0] would be a mistake).

Yet in Rebol sometimes the "tail wags the dog"... there are often 
deeply entrenched reasons where some implementation detail of how 
X functionality is built on top of Y functionality means you get 
a certain behavior... like, if none didn't print as "none" it would 
break the reflection model or something with MOLD.  The go-to person 
on telling you the underlying facts of the matter is generally BrianH. 
 :)

Rebol programming can be very much like a trapeze without a safety 
net.  I have bent some of the rules in a dialect I made where (for 
instance) you can use constants or words as the clauses in if or 
either conditions.  So you can write things like [str: either condition 
"truestring" "falsestring"], instead of [str: either condition ["truestring"] 
["falsestring"]]

Rebol could do this by default, but people screw up enough as it 
is.  Is it worth the potential errors to allow this?  Absolutely 
not...

I think your "none = next none" falls in that category as well... 
it can be useful here or there, sure, but most of the time you're 
probably masking bugs.

Or making them harder to find...

fork you probably are right, but I still think that  length? none 
should not stop the script with an error.
Could'n it produce a "warnig" only or a catchable error instead?

like "error_reporting(x)" in php let me choose which kind of error 
intercept

Well Rebol is very flexible, if you disagree with the choices made 
you can indeed write your own LENG? or whatever which reacts specially 
to NONE and says 0.

what I do is normally wrap such code in an ALL block. NONE can mean 
so many things and it's best to trap a NONE where you know it appears 
during an operation that requires a series as input.

But 90% of the time, when you find a Rebol decision when you are 
not used to the language and study it after a time you will find 
it was made after a lot of deliberation.

Right. Many designs in later REBOL versions are based on code patterns 
after writing many scripts in early REBOL versions.

For better or worse, this thing has been cooked and tweaked for far 
more than a decade... so there's a lot of experience guiding the 
choices, especially if you're using R3.  (R2 had rather more clunky 
edges to it when viewed in hindsight.)

most of the time you're probably masking bugs
 - exactly.

Now if all these accepted NONE and returned 0 at the end:

length? find find find my-string "a" "b" "c"
== 0

where would the error be?

in an opposite, REMOVE supports NONE:

remove find string "something"

I think we had a similar discussion about index? .. it errors when 
find returns none

Yep, this discussion is recurring. There are pros and cons.
I would like to know the opinion of Carl about this.

#[none] could be a special "transient" value which impacts the behavior 
of DO .

Allowing to passthru a chain of functions without breaking the flow.

That would destroy the locality of errors. Every time you pass through 
none, it takes you further away from the code that resulted in the 
none in the first place. The further you pass it through, the harder 
it is to figure out where it came from. We have been careful about 
the balance about where none is passed through, but there are still 
some tweaks to go.

The INDEX? case has been covered by a CureCode discussion, and it 
looks like a good idea. For LENGTH?, the same behavior of returning 
none when passed none would make just as much sense. Under no circumstances 
should INDEX? or LENGTH? return an integer when passed none, not 
even 0.

Davide, REBOL doesn't have a neutral value for any type. This is 
by design. What we have instead is a value that can be used to mean 
nothing: none. And we have control structures to convert non-values 
to a default value: ANY and DEFAULT. R3's control structures are 
built around that principle, including the changes to the ordinal 
functions and EXTRACT.

@BrianH: Agree on that point 100%, but...

>> append "mystring" none   
== "mystringnone"

That does not have the right "feeling" to me.

Again, this is the awkward dynamic between consistency and intuition. 
 If you can state an invariant, like "If S is a string, then append 
S FOO is equivalent to append S to-string FOO" (for example) then 
it might be like "oh, it makes sense once you know that rule".  But 
you've got to find the layer at which people program, and this is 
when I start using the phrase "tail wagging the dog" because people 
are being asked to program at the APPEND layer so the implementation 
details of append should be secondary to what is sensible.

We can't make it trigger an error, because appending none is valid 
in some circumstances. And having the word "none" appended is good 
for flagging errors in developers' code. Really, the error is that 
you didn't screen for none when clearly (by your reaction) you didn't 
want to append none.

But we can only know that not screening for none was an error by 
your reaction. For others, it wouldn't be an error.

And since REBOL can't see your reaction, it has to go by what you 
said to do, not what think you wanted it to do.

join "a" any [ find "x" "abc" copy "" ]

One just has to be prepared for the failed find

I know what you mean, as appending none to a block does add a "none". 
 Though APPEND [A B] NONE currently seems to do the same thing as 
APPEND [A B] 'NONE.  I would be interested to know the side effects 
of saying APPEND [A B] NONE gave [A B] while APPEND [A B] 'NONE gave 
[A B NONE].

What you said to do is append none to a string. By your reaction, 
you wanted to append an empty string to the string. That means this 
(assuming that you don't know that the none is there):
>> append "mystring" any [none ""]
== "mystring"

The need for none to be explicitly converted to other values, rather 
than implicitly, is an intentional design choice that has been applied 
to a great deal of R3. It is not an error.

It wasn't Fork , it was DavidE

Sorry, you're right, I was using Fork's example code.

As for the side effects of not appending none, Fork, that woulld 
ruin blocks that contain fixed-length records of positionally accessed 
data, a common useage pattern. If nothing is appended, the positions 
of the subsequent stuff would be off.

<<Note: Though it's weird to be called Fork (blame Reichart, he made 
this account for me)... I think it would be more confusing with another 
Brian.>>

I see your point.  Hmm.

Ever consdier an operator which converts none! types into none words 
and passes everything else through unmodified?

>> join "a" any [ find "x" "abc" copy "" ]
pretty common idiom (though, you don't need of the copy)

Why would we need to convert #[none] to 'none ? The value #[none] 
is more useful; because of ANY and DEFAULT. Neither of those will 
convert 'none to a default value, but they will convert #[none].

when seeing the "NONE stuff" discussed, the expression like


 parse "123" [(r: copy "result: ") copy s any "x" (append r s) to 
 end]


looks as the situation, where the result obtained from R3 is more 
useful.

>> join "a" any [ find "x" "abc" copy "" ] 

I will use this idiom, thanks. 

But still I think that having "idioms" in programming language  is 
a  symptom of something not really correct.

All programming languages are inherently limited. You have a limited 
number of built-in words and concepts. Because of this there will 
only be a limited number of concepts that can directly be supported 
by the language without combining words. To form other concepts, 
you need to combine words - aka composing functions. As more concepts 
are shared, the best combination of words to express them will be 
shared and refined as well. These combinations of words are idioms. 
Idioms are not a symptom of something which is not correct, quite 
the opposite. The ability to form idioms is a sign of a healthy language 
that is more powerful, able to handle more complex concepts. Idioms 
are always an inherently good thing.

Ladislav, for PARSE yes.

The trick for language design is not to get rid of idioms, but instead 
to do whatever you can to make possible to make simple idioms more 
powerful. This is usually done by making the different parts of the 
language fit together better, and and more flexibly. You get more 
flexibility by making the core concepts simpler, and then making 
them as widely and consistently applicable as you can without breaking 
them. Consistency is key here, and not just key in a positive way. 
More consistency means that you can fit more of the parts of the 
language together better. However, you have to limit consistency 
to places where it makes sense, and has real benefits. False consistency 
can get in your way.

Added bug#1626 (LENGTH?) and bug#1627 (APPEND and INSERT) about #[none] 
passthrough. #1627 was added to be dismissed.

>> append #{} 15
== #{3135}
>> append #{} "15"
== #{3135}


Why if I append an integer to a binary it is first converted to an 
ascii string?

IMHO it should be like this:
>> append #{} to-char 15
== #{0F}

R3 has the kind of behaviour you want. R2 won't be changed as it 
will break many scripts. I agree with you that R3 method is more 
logical.

It is consistent with to-binary:
    to-binary 15
    == #{3135}
    to-binary "15"
    == #{3135}

Yes, R3 seems more logical !

>> append #{} 10
== #{0A}