Re: canonical name ending "-p"

Re: canonical name ending "-p"

[Pascal J. Bourguignon]

ken <gebser@mousecar.com> writes:

> Lots of things in elisp end in "-p"... is there some particular meaning
> in this?

They are predicates.  Predicates are functions that usually take a
single argument, and return a boolean attribute of this argument.

In some cases, it may be a generalized boolean, with an interesting
value for true.

For example, (digit-char-p ?9) --> 9 which is true, but more
interesting, since it's also the numeric value of the digit character.


Notice also, as this example shows, that some classical predicates don't
have the p or -p suffix.  For example: atom

   (atom x) == (not (consp x))



A single word predicate would end with p, a multiword one with -p:

   integerp
   upper-case-p 


-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
A bad day in () is better than a good day in {}.

Re: canonical name ending "-p"

[Evans Winner]

,------ ken wrote ------
|    Lots of things in elisp end in "-p"... is there some
|    particular meaning in this?

On a related note (since Pascal already explained it) I have
wondered why the rather odd use of the term "predicate" was
chosen.

When I hear the term "predicate" I usually think of its
meaning in grammar and logic.  But there is also the use in
which one says that if one thing (A) depends on another
thing (B) that A is "predicated on B."  I suspect it is
because one might verbally reason that in:

   (if (atom t) t nil)

the answer to whether Lisp will return t or nil is
predicated on the results of (atom t), therefore by
extension we call the function itself a predicate.  It's a
little confusing because it is not one of the common uses of
the noun "predicate."  I would be interested to hear from
someone who knows if this is indeed the sense on which the
term was chosen.

Re: canonical name ending "-p"

[rusi]

On Mar 19, 1:36 am, Evans Winner <ego...@gmail.com> wrote:
> ,------ ken wrote ------
> |    Lots of things in elisp end in "-p"... is there some
> |    particular meaning in this?
>
> On a related note (since Pascal already explained it) I have
> wondered why the rather odd use of the term "predicate" was
> chosen.
>
> When I hear the term "predicate" I usually think of its
> meaning in grammar and logic.  But there is also the use in
> which one says that if one thing (A) depends on another
> thing (B) that A is "predicated on B."  I suspect it is
> because one might verbally reason that in:
>
>    (if (atom t) t nil)
>
> the answer to whether Lisp will return t or nil is
> predicated on the results of (atom t), therefore by
> extension we call the function itself a predicate.  It's a
> little confusing because it is not one of the common uses of
> the noun "predicate."  I would be interested to hear from
> someone who knows if this is indeed the sense on which the
> term was chosen.

Maybe you are assuming the grammar use and not the logic use?
See disambiguating wikipedia page http://en.wikipedia.org/wiki/Predicate

canonical name ending "-p"

[ken]

Lots of things in elisp end in "-p"... is there some particular meaning
in this?

-- 
Anything is easy if you know how to do it.

Re: canonical name ending "-p"

[Allan Gottlieb]

From: ken <gebser@mousecar.com>
Date: Friday, March 18, 2011 1:39 pm

> Lots of things in elisp end in "-p"... is there some particular meaning
>  in this?

Yes.  I believe it stands for "predicate".  It is a boolean.  So active-p
would be true if the item in question was "active".

allan
  

Re: canonical name ending "-p"

[Perry Smith]

On Mar 18, 2011, at 12:39 PM, ken wrote:

> Lots of things in elisp end in "-p"... is there some particular meaning
> in this?

I was told it means "predicate" long ago by the guy who introduced me to lisp and emacs.  In Ruby, they use a '?' so they have 'blank?' -- but '?' isn't a legal character in a symbol so they append "p" for predicate.

I'm curious if I have this right or not...

pedz

RE: canonical name ending "-p"

[Drew Adams]

> > Lots of things in elisp end in "-p"... is there some 
> > particular meaning in this?
> 
> I was told it means "predicate" long ago by the guy who 
> introduced me to lisp and emacs.

Yes.  It is an old Lisp idiom, not just Emacs Lisp.

> In Ruby, they use a '?' so they have 'blank?'
> -- but '?' isn't a legal character in a 
> symbol so they append "p" for predicate.

This part is incorrect.  `?' is perfectly legal in a Lisp symbol.
Put your cursor on a `?' char in Emacs Lisp mode and do `C-u C-x ='.  You will
see this: "syntax: _    which means: symbol".  Then try it:

(defun foo? () (forward-char 1))

[Unfortunately, vanilla Emacs completion treats `?' specially, so you'll need to
quote it using `C-q ?' if you want to use `C-h f' to get help on `foo?': `C-h
foo C-q ?']

> I'm curious if I have this right or not...

Yes, except for `?'.

Re: canonical name ending "-p"

[Tom Rauchenwald]

ken <gebser@mousecar.com> writes:

> Lots of things in elisp end in "-p"... is there some particular meaning
> in this?

It means predicate. Functions ending in -p return either t or nil, and
variables ending in -p contain either t or nil.

-tom

-- 
Computers are useless.  They can only give you answers.
                -- Pablo Picasso

RE: canonical name ending "-p"

[Drew Adams]

> It means predicate. Functions ending in -p return either t
> or nil, and variables ending in -p contain either t or nil.

Actually, either non-nil (true) or nil (false).

"Boolean" in Lisp can mean this or it can mean strictly `t' or `nil'.
Generally, any non-nil value is taken to mean true, but for `defcustom' the
:type `boolean' limits the value to t or nil.

Also, most people do _not_ use `-p' when naming a boolean variable.  I use it
that way quite often, but some Emacs developers frown on this use.

For user options, some people (including me) use the suffix `-flag' for a
boolean option.  I tend to use `-p' for internal variables (non-options).

Re: canonical name ending "-p"

[Stefan Monnier]

> It means predicate. Functions ending in -p return either t or nil, and
> variables ending in -p contain either t or nil.

Actually the use for variables is discouraged.  Among other things these
aren't "predicates" in the mathematical logic sense.


        Stefan "Who'd be happy to use ? instead, like in Scheme"