Naming convention regarding question mark

[ruv]

?foo naming form

Usually this form is used for a word that does something or does nothing depending on some condition.

The standard words that share this naming form are:

• ?dup ( 0 -- 0 | x -- x x ), which does nothing if the top item is 0.
• ?do ( u1 u2 -- ), which (in run-time) does not perform the body loop even once if u1=u2

NB: for each of them there is a corresponding word without a question mark that does its action unconditionally: dup, and do.

Other known words are:

• ?comp — do nothing if compilation, raise an error otherwise.
• ?stack — raise an error if the stack is underflow, otherwise do nothing.

Advice: don't use the naming form ?foo for a word that unconditionally returns a flag or other value.

The summary: a question mark prefix in a word name (like ?foo) makes stress that its action is conditional, usually in presence of an unconditional word variant (like foo).

foo? naming form

Any word for which this form is used returns a flag at the top (but not vice versa).

The standard words that share this naming form are:

• key? ( -- flag )
• ekey? ( -- flag )
• xkey? ( -- flag )
• emit? ( -- flag )

For each of these words there is a counterpart word without a question mark: key ( -- char ), ekey ( -- x ), xkey ( -- xchar ), emit ( x -- ).

A general form of these use cases is following: you have words foo and foo?, and behavior of foo somehow depends on what foo? returns.

Another standard word that has this naming form is environment? ( c-addr u -- false | i*x true ); but it doesn't have any counterpart word. It's unclear why this name ends in the question mark.

There are a lot of standard words without a question mark that return a flag (comparisons, search substring, converting, check availability of a word). Therefore, if a word returns a flag, it still is not enough ground to add a question mark suffix. Otherwise we would have too much question marks in code.

Advice: don't use the naming form foo? for a word if you don't have a counterpart word without a question mark foo.

[SirWumpus]

Otherwise we would have too much question marks in code.

I call into question that questionable statement. 😋

[ruv]

Otherwise we would have too much question marks in code.

I call into question that questionable statement. 😋

Well, in some languages (Scheme, Ruby), by a convention, the name ends in "?" for any function that is a predicate, and it does not seem a problem.

Then would you prefer the names u<?, >=?, 0<>?, =?, ekey>key?, search?, [defined?], etc, for the corresponding words?

If not, you probably can establish a rule — for what word kinds the name should ends in the question mark, can't you?

[ruv]

Example of use the naming form ?foo

The standard word find-name ( sd.name -- nt|0 ) returns nt if a word is found, or 0 if a word is not found by the name sd.name. You cannot deal with the resulting nt without checking whether it is 0. If the case of zero is unacceptable in your program you just throw an exception: ... find-name dup 0= -13 and throw ... . And if it's not a single case, you probably want to factor out it into a separate word.

And ?find-name is a good name for such a word:

: ?find-name ( sd.name -- nt ) find-name dup 0= -13 and throw ;

The result of this word can be used without checking: ... ?find-name name> ... .

The beginning question mark in this word name makes stress that its action is conditional, compared to the unconditional (in some sense) word find-name.