bug#20924: 25.0.50; (elisp) `Sticky Properties`

bug#20924: 25.0.50; (elisp) `Sticky Properties`

[Drew Adams]

> > The first sentence is misleading:
> >
> >   Self-inserting characters normally take on the same properties
> >   as the preceding character.
> >
> > Is it about the characters themselves or about self-insertion of
> > those characters?
> 
> The latter, because of the plural tense.  "Self-inserting
> characters" is a shorthand for "characters bound to a command
> that just inserts the character which invoked it".
> 
> > The rest of the node says, for example, that `insert' inserts
> > without inheritance.  Doesn't that mean that if you pass a string of
> > self-inserting chars to `insert' then they will not inherit from
> > the char before the insertion?
> 
> No.  According to my clarification above, there's no such thing as
> "a string of self-inserting characters", only "a string of characters".
> Any character can be inserted by an explicit call to 'insert'.
> 
> I guess the confusion here is between 'insert' the name of a
> primitive and "insert" as part of "self-inserting", where "insert"
> is used in its everyday meaning.  I see no other unclear issues here.
> 
> > It would be clearer to just say that: they inherit when they are
> > self-inserted.
> 
> We cannot "self-insert" a character, so saying that would be a
> mistake.

Isn't that the distinction you are trying to make?  When a char is
inserted by way of being "bound to a command that just inserts the
character which invoked it", then it "normally take[s] on the same
properties as the preceding character"?

Anyway, I submit that the text is unclear.  The specific behavior
(e.g., what function `insert' does) described in the rest of the
node is clear.  The first paragraph is not clear.  Please try to
find some other way to say what you think the message of the first
paragraph is.  Under what conditions does a character "normally
take on the same properties as the preceding character"?  Thx.

bug#20924: 25.0.50; (elisp) `Sticky Properties`

[Eli Zaretskii]

> Date: Mon, 29 Jun 2015 07:51:17 -0700 (PDT)
> From: Drew Adams <drew.adams@oracle.com>
> Cc: 20924@debbugs.gnu.org
> 
> Isn't that the distinction you are trying to make?  When a char is
> inserted by way of being "bound to a command that just inserts the
> character which invoked it", then it "normally take[s] on the same
> properties as the preceding character"?

That's what the manual says, yes.

> Anyway, I submit that the text is unclear.  The specific behavior
> (e.g., what function `insert' does) described in the rest of the
> node is clear.  The first paragraph is not clear.  Please try to
> find some other way to say what you think the message of the first
> paragraph is.

I don't see what's unclear.  The first paragraph contrasts the rest
with what happens with self-inserting characters.  In a nutshell, it
says: when users insert characters by typing, they inherit ...; by
contrast, a Lisp program that inserts text can choose not to.

> Under what conditions does a character "normally
> take on the same properties as the preceding character"?

When it is inserted by typing that character.  That's what the first
paragraph says.

bug#20924: 25.0.50; (elisp) `Sticky Properties`

[Drew Adams]

> In a nutshell, it
> says: when users insert characters by typing, they inherit ...; by
> contrast, a Lisp program that inserts text can choose not to.
> 
> > Under what conditions does a character "normally
> > take on the same properties as the preceding character"?
> 
> When it is inserted by typing that character.  That's what the first
> paragraph says.

I think it would be a lot clearer if the text said just what you
said here.  Something like this:
When you insert a char by typing it, it inherits....
But Lisp code that inserts text might not inherit...

I'm OK with whatever you decide to do (including nothing).  I hope
the text will be made a little clearer, but if not, OK.  Thx.

bug#20924: 25.0.50; (elisp) `Sticky Properties`

[Eli Zaretskii]

> Date: Mon, 29 Jun 2015 09:22:47 -0700 (PDT)
> From: Drew Adams <drew.adams@oracle.com>
> Cc: 20924@debbugs.gnu.org
> 
> I think it would be a lot clearer if the text said just what you
> said here.  Something like this:
> When you insert a char by typing it, it inherits....
> But Lisp code that inserts text might not inherit...

I improved the wording along these lines.  Thanks.

bug#20924: 25.0.50; (elisp) `Sticky Properties`

[Drew Adams]

The first sentence is misleading:

  Self-inserting characters normally take on the same properties as the
  preceding character.

Is it about the characters themselves or about self-insertion of
those characters?

The rest of the node says, for example, that `insert' inserts without
inheritance.  Doesn't that mean that if you pass a string of
self-inserting chars to `insert' then they will not inherit from the
char before the insertion?  That is contradicted by the first sentence
of the node.

You might claim that the hand-waving word "normally" there means that
they do so only when self-inserted.  That's not obvious.  It would be
clearer to just say that: they inherit when they are self-inserted.

And if that is not always the case then add a waffle word "normally" or
"usually" back: usually they inherit when they are self-inserted.



In GNU Emacs 25.0.50.1 (i686-pc-mingw32)
 of 2014-10-20 on LEG570
Bzr revision: 118168 rgm@gnu.org-20141020195941-icp42t8ttcnud09g
Windowing system distributor `Microsoft Corp.', version 6.1.7601
Configured using:
 `configure --enable-checking=yes,glyphs CPPFLAGS=-DGLYPH_DEBUG=1'

bug#20924: 25.0.50; (elisp) `Sticky Properties`

[Eli Zaretskii]

> Date: Sun, 28 Jun 2015 18:47:28 -0700 (PDT)
> From: Drew Adams <drew.adams@oracle.com>
> 
> The first sentence is misleading:
> 
>   Self-inserting characters normally take on the same properties as the
>   preceding character.
> 
> Is it about the characters themselves or about self-insertion of
> those characters?

The latter, because of the plural tense.  "Self-inserting characters"
is a shorthand for "characters bound to a command that just inserts
the character which invoked it".

> The rest of the node says, for example, that `insert' inserts without
> inheritance.  Doesn't that mean that if you pass a string of
> self-inserting chars to `insert' then they will not inherit from the
> char before the insertion?

No.  According to my clarification above, there's no such thing as "a
string of self-inserting characters", only "a string of characters".
Any character can be inserted by an explicit call to 'insert'.

I guess the confusion here is between 'insert' the name of a primitive
and "insert" as part of "self-inserting", where "insert" is used in
its everyday meaning.  I see no other unclear issues here.

> It would be clearer to just say that: they inherit when they are
> self-inserted.

We cannot "self-insert" a character, so saying that would be a
mistake.