empty-line-p

empty-line-p

[Andreas Roehler]

Hi,

needed a check at several occassions, if the current line
contains printable characters.

What about the following to solve this?

(defun empty-line-p ()
  "Returns t if cursor is at an empty line "
  (interactive)
  (save-excursion
    (beginning-of-line)
  (if
      (looking-at "^[ \t\f\r]*$")
      t
    nil)))


__
Andreas Roehler

Re: empty-line-p

[Joost Kremers]

Andreas Roehler wrote:
> needed a check at several occassions, if the current line
> contains printable characters.
>
> What about the following to solve this?
>
> (defun empty-line-p ()
>   "Returns t if cursor is at an empty line "
>   (interactive)
>   (save-excursion
>     (beginning-of-line)
>   (if
>       (looking-at "^[ \t\f\r]*$")
>       t
>     nil)))

you don't need the if-statement here:

(defun empty-line-p ()
  "Returns t if cursor is at an empty line "
  (interactive)
  (save-excursion
    (beginning-of-line)
    (looking-at "^[ \t\f\r]*$")))

looking-at already returns t or nil.

-- 
Joost Kremers                                      joostkremers@yahoo.com
Selbst in die Unterwelt dringt durch Spalten Licht
EN:SiS(9)

Re: empty-line-p

[David Hansen]

On 29 Mar 2007 14:32:05 GMT Joost Kremers wrote:

> Andreas Roehler wrote:
>> needed a check at several occassions, if the current line
>> contains printable characters.
>>
>> What about the following to solve this?
>>
>> (defun empty-line-p ()
>>   "Returns t if cursor is at an empty line "
>>   (interactive)
>>   (save-excursion
>>     (beginning-of-line)
>>   (if
>>       (looking-at "^[ \t\f\r]*$")
>>       t
>>     nil)))
>
> you don't need the if-statement here:
>
> (defun empty-line-p ()
>   "Returns t if cursor is at an empty line "
>   (interactive)
>   (save-excursion
>     (beginning-of-line)
>     (looking-at "^[ \t\f\r]*$")))
>
> looking-at already returns t or nil.

And to avoid some painful bug hunting (happened to me with nearly
the same code) wrap it in a `save-match-data'.

David

Re: empty-line-p

[Andreas Roehler]

David Hansen schrieb:
> On 29 Mar 2007 14:32:05 GMT Joost Kremers wrote:
>
>   
>> Andreas Roehler wrote:
>>     
>>> needed a check at several occassions, if the current line
>>> contains printable characters.
>>>
>>> What about the following to solve this?
>>>
>>> (defun empty-line-p ()
>>>   "Returns t if cursor is at an empty line "
>>>   (interactive)
>>>   (save-excursion
>>>     (beginning-of-line)
>>>   (if
>>>       (looking-at "^[ \t\f\r]*$")
>>>       t
>>>     nil)))
>>>       
>> you don't need the if-statement here:
>>
>> (defun empty-line-p ()
>>   "Returns t if cursor is at an empty line "
>>   (interactive)
>>   (save-excursion
>>     (beginning-of-line)
>>     (looking-at "^[ \t\f\r]*$")))
>>
>> looking-at already returns t or nil.
>>     
>
> And to avoid some painful bug hunting (happened to me with nearly
> the same code)
What about to collect minor tools like this somewhere?

>  wrap it in a `save-match-data'.
>
> David
>   

OK, thanks. So I got this now:

(defcustom empty-line-p-chars "^[ \t\f\r]*$"
  "empty-line-p-chars"
 :type 'regexp
 :group 'convenience)

(defun empty-line-p (&optional ispec)
  "Returns t if cursor is at an empty line, nil otherwise.
Displays result in minibuffer when called interactive."
  (interactive "p")
  (save-excursion
    (beginning-of-line)
    (save-match-data
      (when ispec
    (message "%s" (looking-at empty-line-p-chars)))
      (looking-at empty-line-p-chars))))


;;;;;

Andreas

Re: empty-line-p

[Xavier Maillard]

   >  wrap it in a `save-match-data'.
   >
   > David
   >   

   OK, thanks. So I got this now:

Here is what I would do instead:

(defun empty-line-p (&optional ispec)
  "Returns t if cursor is at an empty line, nil otherwise.
Displays result in minibuffer when called interactive."
  (interactive "p")
  (save-excursion
    (beginning-of-line)
    (save-match-data
      (let ((res (looking-at empty-line-p-chars)))
	(or (and ispec
		 (message "%s" res))
	    res)))))


Xavier

Re: empty-line-p

[Andreas Roehler]

Xavier Maillard schrieb:
>    >  wrap it in a `save-match-data'.
>    >
>    > David
>    >   
>
>    OK, thanks. So I got this now:
>
> Here is what I would do instead:
>
> (defun empty-line-p (&optional ispec)
>   "Returns t if cursor is at an empty line, nil otherwise.
> Displays result in minibuffer when called interactive."
>   (interactive "p")
>   (save-excursion
>     (beginning-of-line)
>     (save-match-data
>       (let ((res (looking-at empty-line-p-chars)))
> 	(or (and ispec
> 		 (message "%s" res))
> 	    res)))))
>
>
> Xavier
>

That would probably work, however, as far as the form
is conceived as a subroutine, it doesn't seem the best
solution.

Assume you introduced `let', because in

    (when ispec
      (message "%s" (looking-at empty-line-p-chars)))
      (looking-at empty-line-p-chars))))

`looking-at' is performed two times.

Thought that repeat won't matter, because when called
interactively, time isn't at stake.

Otherwise `let' would maybe called again and
again from inside a program, whereas `let' isn't really
needed here.

Meanwhile thought to reconcile
`save-match-data' proposed by David Hansen with Stefan
Monnier's objections concerning speed.

The form below should `save-match-data', when called as

(empty-line-p t)

and without arg not.

(defun empty-line-p (&optional arg ispec)
  "Returns t if cursor is at an empty line, nil otherwise.
Displays result in minibuffer when called interactive."
  (interactive "P\np")
  (save-excursion
    (beginning-of-line)
    (if arg
    (save-match-data
      (if ispec
          (message "%s" (looking-at empty-line-p-chars))
        (looking-at empty-line-p-chars)))
      (if ispec
      (message "%s" (looking-at empty-line-p-chars))
    (looking-at empty-line-p-chars)))))

(defcustom empty-line-p-chars "^[ \t\f\r]*$"
  "empty-line-p-chars"
 :type 'regexp
 :group 'convenience)


Thanks all

Andreas Roehler

Re: empty-line-p

[Stefan Monnier]

> And to avoid some painful bug hunting (happened to me with nearly
> the same code) wrap it in a `save-match-data'.

I'd advise against such a change.

The cost of save-match-data is fairly high, so instead of using it
everywhere, the coding convention in elisp is to be careful that between
a regexp-match and the use of match-beginning (and friends) there should be
almost no other operation since most operations (other than the few known
safe ones) may trash the match-data.


        Stefan

Re: empty-line-p

[Stefan Monnier]

>  (if (looking-at "^[ \t\f\r]*$")
>      t
>    nil)))

  (if <foo> t nil)

is an eta-regexp, which can be advantageously reduced to just <foo>.


        Stefan


PS: The classical eta-regexp is (lambda (x) (<foo> x)), which is equivalent to
just <foo>.  Another variant is (cons (car <foo>) (cdr <foo>)), which
eta-reduces to just <foo>.

Re: empty-line-p

[Barry Margolin]

In article <jwv648j70t5.fsf-monnier+gnu.emacs.help@gnu.org>,
 Stefan Monnier <monnier@iro.umontreal.ca> wrote:

> >  (if (looking-at "^[ \t\f\r]*$")
> >      t
> >    nil)))
> 
>   (if <foo> t nil)
> 
> is an eta-regexp, which can be advantageously reduced to just <foo>.
> 
> 
>         Stefan
> 
> 
> PS: The classical eta-regexp is (lambda (x) (<foo> x)), which is equivalent to
> just <foo>.  Another variant is (cons (car <foo>) (cdr <foo>)), which
> eta-reduces to just <foo>.

That last one is different, because the new cons is not eq to the 
original <foo>.

-- 
Barry Margolin, barmar@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
*** PLEASE don't copy me on replies, I'll read them in the group ***

Re: empty-line-p

[Stefan Monnier]

>> >  (if (looking-at "^[ \t\f\r]*$")
>> >      t
>> >    nil)))
>> 
>> (if <foo> t nil)
>> 
>> is an eta-regexp, which can be advantageously reduced to just <foo>.
>> 
>> 
>> Stefan
>> 
>> 
>> PS: The classical eta-regexp is (lambda (x) (<foo> x)), which is equivalent to
>> just <foo>.  Another variant is (cons (car <foo>) (cdr <foo>)), which
>> eta-reduces to just <foo>.

> That last one is different, because the new cons is not eq to the 
> original <foo>.

Indeed, the eta rules are generally not supported 100% by most languages:
there are always some "minor" semantic differences.  Aside from the problem
you mentioned for the `cons' case, the `if' case changes the result when the
tested value can be non-t and non-nil, and the `lambda' case can change the
behavior when the function is called with more than 1 argument.

So most compilers don't apply such "optimizations", which makes it that much
more valuable to apply them by hand.


        Stefan

Re: empty-line-p

[Andreas Roehler]

Stefan Monnier schrieb:
>>  (if (looking-at "^[ \t\f\r]*$")
>>      t
>>    nil)))
>>     
>
>   (if <foo> t nil)
>
> is an eta-regexp, which can be advantageously reduced to just <foo>.
>
>
>         Stefan
>
>
> PS: The classical eta-regexp is (lambda (x) (<foo> x)), which is equivalent to
> just <foo>.  Another variant is (cons (car <foo>) (cdr <foo>)), which
> eta-reduces to just <foo>.
>   

Thanks a lot both.

Rewrote it in order to let the user decide, which chars
should be considered as "empty".

Also provided an interactive spec.

__
Andreas Roehler


(defcustom empty-line-p-chars "^[ \t\f\r]*$"
  "Permitted chars on a line,
which should be considered as \"empty\" nonetheless"
 :type 'regexp
 :group 'convenience)

(defun empty-line-p (&optional ispec)
  "Returns t if cursor is at an empty line, nil otherwise.
Displays result in minibuffer when called interactive."
  (interactive "p")
  (save-excursion
    (beginning-of-line)
    (when ispec
      (message "%s" (looking-at empty-line-p-chars)))
    (looking-at empty-line-p-chars)))