World: r3wp

This all should move to advocacy :-)

Why?

(it discusses the function naming if I am allowed to remind you)

Because when I got back to home, it feels like arguing :-) i know 
we are discussing consistency here, and I am the first one who always 
screams when something is feeling inconsistent, but - I would 100 
times prefer Carl being back, ending his 2-3 months R3 black-out 
period, instead of caring, if one function is going to be called 
faces-of, or faces?, because in the end the discussion started because 
of that. And even more - whatever we think, will have to be agreed 
by Carl anyway ...

Ladislav - it was exagerration on my part :-), but I just try to 
explain, that we have imo more important things to care about :-) 
No offense here ....

The importance is in the eye of the beholder. If I saw it the way 
you do, I would not have written the code I wrote today.

I am not disrespecting the REBOL function naming convention, I am 
respecting REBOL's founding principle and trying to make you see 
that it means that things are context dependent, instead of black 
and white

Analysing conventions in current naming of standard REBOL functions 
(that is, the practice instead of the documentation about the practice) 
two conventions can be seen in R2 and now three conventions in R3

The simplest, most abstract and thus most flexible convention is 
to use a word as-is, just like in English. As you observed, this 
applies to the math functions, for example, such as SINE

The second convention in R2 is to add the ? qualifier. Most of the 
functions this applies to return a logic value, but some return other 
values, such as LENGTH?

R3 has added a third convention with just a few examples to date, 
such as words-of and body-of

This makes it clear that there is a reason not to use the ? for all 
these cases, because otherwise they could have been WORDS? and BODY?

It seems reasonable to me to assume that R2 only used ? because there 
weren't many cases yet, and this seemed consistent. But with more 
cases now, consistency is being lost, so this may not have been the 
greatest idea

I think the best example of this is TYPE?. It returns the datatype, 
while you might have expected it to return a logic value. But there's 
another function with a more elaborate name, DATATYPE?, that does 
that

In hindsight, I think it would have been better to have DATATYPE? 
be just TYPE? so that it is consistent with the other <type>? functions, 
and to have TYPE? be TYPE-OF

Leaving TYPE free to use as your own word

What irks my language sensibility most is to use ? for non-logic 
values where -of could have been used

Not because "property of?" is a wrong question, but because a REBOL 
program is full of such evaluations. So if you would use ? consistently, 
every expression would be full of question marks, whereas in human 
language it only marks the end of a complete sentence (and the beginning 
in Spanish)

I'd rather have an expression full of -of words, because that resembles 
English more, even though this, too, is too much, as Steeve says

just like in English

 - the naming of math function is not just like in English, it is 
 just like in mathematics

Yes, so not consistent according to your black and white interpretation

In many cases when you ask a question in human language, you want 
to make a decision. So I associate a question mark in REBOL with 
control flow, and would thus rather limit the ? qualifier to logic 
values

that is you speaking about "inconsistency", no problem for me, exactly 
like it is you reinventing non-existent conventions, like non-logic 
versus logic return values

You're the one who wants to make the convention black and white, 
not me

I do want to respect the convention when possible, and, frankly, 
you cannot do anything about my will in that respect

The current convention works for me, but I don't think of it in verb/noun 
terms but question/non-question terms.


 length? and none? are both questions, whether they return a logic! 
 or not can be deduced by their name(s) ... ("What is the length?" 
 versus "Is this a none value?")

A question must return a logic, none or scalar value.


The best we can say about non-questions is that they generally "do" 
or change something.

Ladislav, I added some comments to http://issue.cc/r3/1818- apparently 
the docs hadn't been updated with the *-OF convention.

Unfortunately (at times) we are still stuck with the legacy name 
rule (with some exceptions for rarely used functions).

We are trying to cut down on the number of *? conventions. Look at 
the comments for details.

The noun-OF convention is usually reserved for intrinsic properties 
rather than contents, at least for the mezzanines, but you might 
consider it for contents in the GUI code if it seems appropriate.

Only modifying or action functions should have verbs, not all functions. 
The *-OF convention comes from English, not C.

This decision came out of the early R3 project a few years ago, back 
when you were still taking a break from REBOL :)

In the case of your faces question, "faces" is a collective noun, 
and in function form is a request for a property or contents of its 
argument (don't know which), so FACES-OF would probably be preferred, 
leaving the 'faces word available to be used as a variable. Or GET-FACES 
if you prefer to emphasize the action of retrieving that value and 
have a corresponding SET-FACES function.

I added my two cents to the CC discussion.

Look at my reply :)

Some *? functions that might be better off as *-OF: ENCODING?, FILE-TYPE?, 
INDEX?, LENGTH?, SIGN? and SIZE?. Except for the first two the old 
names would need to stick around because of the legacy naming rules. 
Strangely enough, UTF? is OK because it is short for "UTF what?". 
The series contents functions have an implicit -OF :)

INFO? is iffy because "info" is not an adjective and makes a poor 
question word, but it can be used in a conditional context (it returns 
none if there is no info) and the legacy naming rule applies so it's 
probably not worth adding INFO-OF.

I'd be willing to let the series actions that return contents to 
continue to have the -OF be implicit, especially since they are legacy 
:)

And HEAD and TAIL can still have -OF be implicit too, IMO.

I think to,  I think the rule is most usefull in cases like bind 
where we need multiple variants of a word to mean different things. 
  in such a case, the  ? should always tend toward the most obvious/usefull 
conditional safe function.   :-)

(even if it does return a value instead of true)

for example, I feel that binding?  would have been a much better 
word than bind?

since we understand that if something has a value, we might as well 
receive the value instead of just knowing that this is true.

Sounds excellent, Brian

This is one of those weird circumstances where I know the answer 
to the question because I was there when the original decision was 
made. The reflectors (the *-OF functions that call REFLECT) were 
my idea in the first place, as a security measure, though obviously 
Carl wrote them and came up with the nouns :)

The word "binding" is two different nouns (one referring to the act 
of binding, one referring to the result of binding), so it doesn't 
fit the adjective? model very well. The word "bound" is the adjective 
form. See http://issue.cc/r3/1819for details.

this naming convention doesn't work with MAXIMUM-OF and MINIMUM-OF, 
which don't actually return the maximum or minimum of a series, they 
return the series at the position of the maximum or minimum. Gregg 
has suggested that these be renamed to FIND-MAX and FIND-MIN instead, 
and this will probably happen (rarely used, really badly named). 

 - I have got absolutely no problem with MAXIMUM-OF or MINIMUM-OF, 
 FIND-MAX and FIND-MIN aren't any better, because they express the 
 same, just in a less fortunate way (find is less descriptive than 
 maximum/minimum)

To describe something else we would need to use something line INDEX-OF-MAXIMUM?, 
which is more accurate, but unnecessarily long to my taste

It is a good idea to only use noun-of for intrinsic properties, rather 
than contents of container types.

 - it looks to me that you suggest, that for you, the preferable way 
 is:

    faces? face

, and not

    faces-of face


As far as I am concerned, I used the convention as written now, but, 
probably, the majority of users prefer the latter.

(in this specific case)