Re: is_predicate_p?

Re: is_predicate_p?

[Robert Dewar]

> Predicates in GCC come in a wide variety of spellings.  Some end in _p,
> some start with is_, some have _is_ in the middle, some just expect you to
> know they're predicates based on the meaning of the name.  Should we set
> some sort of standard spelling for future additions?

I would have guidelines rather than a standard here. I would avoid the use
of _p unless you do decide to standardize on this (which seems very dubious
to me). The use of _p is simply not intuitive. All the other three cases
sound plausible to me, and I would hesitate to mandate any one over the others.

Re: is_predicate_p?

[Jason Merrill]

>>>>> "Robert" == Robert Dewar <dewar@gnat.com> writes:

>> Predicates in GCC come in a wide variety of spellings.  Some end in _p,
>> some start with is_, some have _is_ in the middle, some just expect you to
>> know they're predicates based on the meaning of the name.  Should we set
>> some sort of standard spelling for future additions?

> I would have guidelines rather than a standard here. I would avoid the use
> of _p unless you do decide to standardize on this (which seems very dubious
> to me). The use of _p is simply not intuitive. All the other three cases
> sound plausible to me, and I would hesitate to mandate any one over the others.

_p is intuitive to folks coming from a Lisp background, including those of
us who were indoctrinated into the Emacs cult at an early age.  But since
this code has little to do with Lisp, I agree that it is probably the wrong
choice.  It does have a significant representation in the current sources,
though; try a grep of rtl.h.

Jason

Re: is_predicate_p?

[Daniel Jacobowitz]

On Sun, Jun 09, 2002 at 04:27:29PM -0400, Robert Dewar wrote:
> <<call, it'll always be
>         if (is_foo ())
> >>
> 
> Yes, and by your same argument if I write
> 
>    if (stmt_ends_bb (foo))
> 
> it is also pretty obvious that this a predicate

Maybe... it could just as easily be returning a bb* to the block that
foo ends or NULL in some exceptional error condition.  I'm in favor of
some (any; I don't care) consistence naming convention for all
predicate functions.

-- 
Daniel Jacobowitz                           Carnegie Mellon University
MontaVista Software                         Debian GNU/Linux Developer

Re: is_predicate_p?

[Robert Dewar]

<<call, it'll always be
        if (is_foo ())
>>

Yes, and by your same argument if I write

   if (stmt_ends_bb (foo))

it is also pretty obvious that this a predicate

<<No. I now can't tell whether stmt_ends_bb (foo) is commanding that foo
end a statement, or questioning whether foo ends a statment.
>>

I would find stmt_ends_bb a very poor choice of name for the command. I find
it a well chosen name for the predicate. For the command I would use
something like require_end_bb or ensure_end_bb or some such

Re: is_predicate_p?

[Nathan Sidwell]

Diego Novillo wrote:
> <<I personally tend to use is_foo for adjectives (e.g.,
> is_binary_expr) and foo_p for verbs (e.g., stmt_ends_bb_p).
I'd think of 'binary_expr' as a noun, and as we all know nouns
and verbs are somewhat interchangable. I would have great
difficulty with is_noun and verb_p. Are you thinking of foo
as a property the object has collected (is_noun), or as
a process it has undergone (verb_p)? They're pretty inter-
changable, why make them different?

Robert Dewar wrote:
> But the _p here seems gratuitous, stmt_ends_bb is a perfectly reasonable
> name for a predicate and reads just fine.
No. I now can't tell whether stmt_ends_bb (foo) is commanding that foo
end a statement, or questioning whether foo ends a statment.
Now sometimes it's obvious and sometimes it's not, but I think
we should have some convention to mark predicate functions, it makes
intent more obvious.

Diego Novillo wrote:
> We also have uses of _p for pointers.  If we are going to use a
> new convention I would rather get rid of _p entirely.
good point, I'd not noticed those typedefs (they appear confined
to gentype). Perhaps is_ is better because of that, and as Gaby
points out, you'll never see a naked
	is_foo ()
call, it'll always be
	if (is_foo ())
which I think is pretty damn obvious. 

I have been persuaded by the arguments that is_ is better than _p.
oh, and I was wrong, the spanish version should be is_foo_si ;-)

nathan
-- 
Dr Nathan Sidwell   ::   http://www.codesourcery.com   ::   CodeSourcery LLC
         'But that's a lie.' - 'Yes it is. What's your point?'
nathan@codesourcery.com : http://www.cs.bris.ac.uk/~nathan/ : nathan@acm.org

Re: is_predicate_p?

[Diego Novillo]

On Sun, 09 Jun 2002, Robert Dewar wrote:

> <<I personally tend to use is_foo for adjectives (e.g.,
> is_binary_expr) and foo_p for verbs (e.g., stmt_ends_bb_p).
> >>
> 
> But the _p here seems gratuitous, stmt_ends_bb is a perfectly reasonable
> name for a predicate and reads just fine.
>
Right, hence my conclusion that we should probably get rid of the
_p suffix.


Diego.

Re: is_predicate_p?

[Robert Dewar]

<<I personally tend to use is_foo for adjectives (e.g.,
is_binary_expr) and foo_p for verbs (e.g., stmt_ends_bb_p).
>>

But the _p here seems gratuitous, stmt_ends_bb is a perfectly reasonable
name for a predicate and reads just fine.

Re: is_predicate_p?

[Diego Novillo]

On Sun, 09 Jun 2002, Nathan Sidwell wrote:

> I'd vote for the _p convention. FWIW I used to use the is_ convention and
> found it more awkward. I think the reason may be that with predicates
> you are asking a question, and in english you'd use a ? at the end of the
> sentance. The is_foo form looks a little like an assertion. May be a
> spanish speaker would prefer the is_ convention (or even is_foo_p :-)
> 
In spanish we surround questions around two markers: ¿?.  So, if
anything it looks even less like a question to us :)

I personally tend to use is_foo for adjectives (e.g.,
is_binary_expr) and foo_p for verbs (e.g., stmt_ends_bb_p).  

We also have uses of _p for pointers.  If we are going to use a
new convention I would rather get rid of _p entirely.


Diego.

Re: is_predicate_p?

[Gabriel Dos Reis]

Nathan Sidwell <nathan@codesourcery.com> writes:

| Jason Merrill wrote:
| > 
| > Predicates in GCC come in a wide variety of spellings.  Some end in _p,
| > some start with is_, some have _is_ in the middle, some just expect you to
| > know they're predicates based on the meaning of the name.  Should we set
| > some sort of standard spelling for future additions?
| 
| I'd vote for the _p convention. FWIW I used to use the is_ convention and
| found it more awkward. I think the reason may be that with predicates
| you are asking a question, and in english you'd use a ? at the end of the
| sentance. The is_foo form looks a little like an assertion.

However, note that predicates are barely used alone.  There are used
in conditional expressions and the question being asked is part of the
expression:

   if (is_explicit_specialization (decl) && is_type (decl))
      post_process_explicit_type_specialization (decl);

is much more readable to me as a non-native speaker (neither
English, nor LISP), than 

   if (explicit_specialization_p (decl) && type_p (decl))
      post_process_explicit_type_specialization (decl);
    
But, hey:

| May be a
| spanish speaker would prefer the is_ convention (or even is_foo_p :-)

:-) :-)

-- Gaby

Re: is_predicate_p?

[Nathan Sidwell]

Jason Merrill wrote:
> 
> Predicates in GCC come in a wide variety of spellings.  Some end in _p,
> some start with is_, some have _is_ in the middle, some just expect you to
> know they're predicates based on the meaning of the name.  Should we set
> some sort of standard spelling for future additions?

I'd vote for the _p convention. FWIW I used to use the is_ convention and
found it more awkward. I think the reason may be that with predicates
you are asking a question, and in english you'd use a ? at the end of the
sentance. The is_foo form looks a little like an assertion. May be a
spanish speaker would prefer the is_ convention (or even is_foo_p :-)

Although I use lisp, I don't consider myself as coming from a lisp
background.

nathan
-- 
Dr Nathan Sidwell   ::   http://www.codesourcery.com   ::   CodeSourcery LLC
         'But that's a lie.' - 'Yes it is. What's your point?'
nathan@codesourcery.com : http://www.cs.bris.ac.uk/~nathan/ : nathan@acm.org

Re: is_predicate_p?

[Kaveh R. Ghazi]

 > From: Tim Hollebeek <tim@hollebeek.com>
 > 
 > > | FWIW, I also think we should standardize on all of them returning
 > > | bool. 
 > > 
 > > I think that was agreed upon, in past discussions.
 > 
 > It might also be worthwhile insisting that they be pure.
 > -Tim

Unfortunately, that's almost impossible given our various "checking"
functions make unpure noreturn calls when an error is found.

		--Kaveh
--
Kaveh R. Ghazi			Director of Systems Architecture
ghazi@caip.rutgers.edu		Qwest Solutions

Re: is_predicate_p?

[Tim Hollebeek]

> | FWIW, I also think we should standardize on all of them returning
> | bool. 
> 
> I think that was agreed upon, in past discussions.

It might also be worthwhile insisting that they be pure.

-Tim

Re: is predicate p?

[Marc Espie]

In article <m3ptz26ol5.fsf@merlin.nerim.net> you write:
>kenner@vlsi1.ultra.nyu.edu (Richard Kenner) writes:
>
>|     I would have guidelines rather than a standard here. I would avoid the
>|     use of _p unless you do decide to standardize on this (which seems
>|     very dubious to me). The use of _p is simply not intuitive. 
>| 
>| Perhaps, but it was the earliest conventions used in GCC to distinguish
>| predicates (where the term doesn't have the technical MD file meaning), so
>| most follow this "rule".  This is from LISP conventions and RMS was the
>| origin of its use.

>Writing LISP in C always seems to me to be an intriguing idea 8-\

>-- Gaby


Then why are you writing gcc code ?

gcc is still lisp, mostly.

In fact, I would tend to believe LISP is the only language RMS really knows,
based on his code...

One thing though: gcc would probably be faster if it was truely a dialect
of lisp, like schemes... note that most of the speed trouble we've seen so far
has to do with shared structures, GC, and list processing. (which doesn't
surprise me), and part of the robustness trouble had to do with ubiquitous
structures with actually little or no type at all (e.g., tree nodes, for 
instance). Those are both traditionally plagues of old functional languages...

Food for thought. Or pure jest. You decide.

Re: is_predicate_p?

[Gabriel Dos Reis]

"Kaveh R. Ghazi" <ghazi@caip.rutgers.edu> writes:

|  > From: Jason Merrill <jason@redhat.com> 
|  > 
|  > Predicates in GCC come in a wide variety of spellings.  Some end in
|  > _p, some start with is_, some have _is_ in the middle, some just
|  > expect you to know they're predicates based on the meaning of the
|  > name.  Should we set some sort of standard spelling for future
|  > additions?
|  > Jason
| 
| Probably, care to suggest one?

All but the _p thingy seems a bit intriguing to me (although I know
where ot comes from -- I just believe that we shouldn't be insisting
to write LISP in C :-\)

| FWIW, I also think we should standardize on all of them returning
| bool. 

I think that was agreed upon, in past discussions.

-- Gaby

Re: is_predicate_p?

[Kaveh R. Ghazi]

 > From: Jason Merrill <jason@redhat.com> 
 > 
 > Predicates in GCC come in a wide variety of spellings.  Some end in
 > _p, some start with is_, some have _is_ in the middle, some just
 > expect you to know they're predicates based on the meaning of the
 > name.  Should we set some sort of standard spelling for future
 > additions?
 > Jason

Probably, care to suggest one?

FWIW, I also think we should standardize on all of them returning
bool.  It helps to emphasize the nature/purpose of the function.

		--Kaveh
--
Kaveh R. Ghazi			Director of Systems Architecture
ghazi@caip.rutgers.edu		Qwest Solutions

Re: is_predicate_p?

[Robert Dewar]

> Perhaps, but it was the earliest conventions used in GCC to distinguish
> predicates (where the term doesn't have the technical MD file meaning), so
> most follow this "rule".  This is from LISP conventions and RMS was the
> origin of its use.

OK, if this is a well established and well used convention, that's reasonable,
but I still find it odd to use a Hungarian-like convention like this and not
enforce it.

Re: is_predicate_p?

[Gabriel Dos Reis]

kenner@vlsi1.ultra.nyu.edu (Richard Kenner) writes:

|     I would have guidelines rather than a standard here. I would avoid the
|     use of _p unless you do decide to standardize on this (which seems
|     very dubious to me). The use of _p is simply not intuitive. 
| 
| Perhaps, but it was the earliest conventions used in GCC to distinguish
| predicates (where the term doesn't have the technical MD file meaning), so
| most follow this "rule".  This is from LISP conventions and RMS was the
| origin of its use.

Writing LISP in C always seems to me to be an intriguing idea 8-\

-- Gaby

Re: is_predicate_p?

[Richard Kenner]

    I would have guidelines rather than a standard here. I would avoid the
    use of _p unless you do decide to standardize on this (which seems
    very dubious to me). The use of _p is simply not intuitive. 

Perhaps, but it was the earliest conventions used in GCC to distinguish
predicates (where the term doesn't have the technical MD file meaning), so
most follow this "rule".  This is from LISP conventions and RMS was the
origin of its use.

is_predicate_p?

[Jason Merrill]

Predicates in GCC come in a wide variety of spellings.  Some end in _p,
some start with is_, some have _is_ in the middle, some just expect you to
know they're predicates based on the meaning of the name.  Should we set
some sort of standard spelling for future additions?

Jason