I'd like to marry while and mapcar...

I'd like to marry while and mapcar...

[Marcin Borkowski]

Hello Emacsers and Elispers!

What I'd need is kind of a marriage of while and mapcar: I'd like to run
some function until it returns nil and make a list of all results it
gives back until then.

Mu use case is that I'm getting some info from a LaTeX file.  For
instance, assume that I want to make a list of all files \include'd by
a LaTeX document.  I've written a function `get-TeX-macro-arguments'
which finds the next occurence of a given TeX command, moves point past
it and returns its arguments; if it does not find any such occurrence,
it returns nil.  So I can say something like this:

(let (current-include (list-of-includes ()))
  (while (setq current-include (get-TeX-macro-arguments "include"))
    (setq list-of-includes (append list-of-includes current-include)))
  list-of-includes)

This, however, looks a bit, let's say, Fortran-ish;-); I'm after a more
Lispy way.  (Of course, one step would be to use anaphoric while, but
that doesn't help my main problem of ditching list-of-includes.)

Yes, I know, I have too much time on my hands, and I bother about style.
But I'm also curious whether there is any "standard" way, or whether
I should indeed wrap something like the above code in a macro, or
something.  (Or maybe just don't care...)

TIA,

-- 
Marcin Borkowski               This email was proudly sent
http://mbork.pl                from my Emacs.

Re: I'd like to marry while and mapcar...

[Rasmus]

Marcin Borkowski <mbork@wmi.amu.edu.pl> writes:

> Hello Emacsers and Elispers!
>
> What I'd need is kind of a marriage of while and mapcar: I'd like to run
> some function until it returns nil and make a list of all results it
> gives back until then.
>
> Mu use case is that I'm getting some info from a LaTeX file.  For
> instance, assume that I want to make a list of all files \include'd by
> a LaTeX document.  I've written a function `get-TeX-macro-arguments'
> which finds the next occurence of a given TeX command, moves point past
> it and returns its arguments; if it does not find any such occurrence,
> it returns nil.  So I can say something like this:
>
> (let (current-include (list-of-includes ()))
>   (while (setq current-include (get-TeX-macro-arguments "include"))
>     (setq list-of-includes (append list-of-includes current-include)))
>   list-of-includes)

How about:

(cl-loop while (search-forward-regexp
                "^[ \t]*\\\\include{\\([^}]+\\)}[ \t]*$" nil t)
         collect (match-string 1))

–Rasmus

-- 
It was you, Jezebel, it was you

Re: I'd like to marry while and mapcar...

[Marcin Borkowski]

On 2015-02-06, at 14:18, Rasmus <rasmus@gmx.us> wrote:

> Marcin Borkowski <mbork@wmi.amu.edu.pl> writes:
>
>> Hello Emacsers and Elispers!
>>
>> What I'd need is kind of a marriage of while and mapcar: I'd like to run
>> some function until it returns nil and make a list of all results it
>> gives back until then.
>>
>> Mu use case is that I'm getting some info from a LaTeX file.  For
>> instance, assume that I want to make a list of all files \include'd by
>> a LaTeX document.  I've written a function `get-TeX-macro-arguments'
>> which finds the next occurence of a given TeX command, moves point past
>> it and returns its arguments; if it does not find any such occurrence,
>> it returns nil.  So I can say something like this:
>>
>> (let (current-include (list-of-includes ()))
>>   (while (setq current-include (get-TeX-macro-arguments "include"))
>>     (setq list-of-includes (append list-of-includes current-include)))
>>   list-of-includes)
>
> How about:
>
> (cl-loop while (search-forward-regexp
>                 "^[ \t]*\\\\include{\\([^}]+\\)}[ \t]*$" nil t)
>          collect (match-string 1))
>
> –Rasmus

Thanks, this is a nice idea, even though some might tsk-tsk the use of
cl-loop.

Best,

-- 
Marcin Borkowski
http://octd.wmi.amu.edu.pl/en/Marcin_Borkowski
Faculty of Mathematics and Computer Science
Adam Mickiewicz University

Re: I'd like to marry while and mapcar...

[Rasmus]

Marcin Borkowski <mbork@wmi.amu.edu.pl> writes:

> Thanks, this is a nice idea, even though some might tsk-tsk the use of
> cl-loop.

Why do you say this?  A grep over /usr/share/emacs/25.0.50/ suggests that
"(loop" or "(cl-loop" occur 431 times. . .

—Rasmus

-- 
Got mashed potatoes. Ain't got no T-Bone. No T-Bone

Re: I'd like to marry while and mapcar...

[Eli Zaretskii]

> From: Marcin Borkowski <mbork@wmi.amu.edu.pl>
> Date: Fri, 06 Feb 2015 13:56:48 +0100
> 
> What I'd need is kind of a marriage of while and mapcar: I'd like to run
> some function until it returns nil and make a list of all results it
> gives back until then.

Can't you use 'throw' from within the function called by mapcar?

Re: I'd like to marry while and mapcar...

[Marcin Borkowski]

On 2015-02-06, at 14:36, Eli Zaretskii <eliz@gnu.org> wrote:

>> From: Marcin Borkowski <mbork@wmi.amu.edu.pl>
>> Date: Fri, 06 Feb 2015 13:56:48 +0100
>> 
>> What I'd need is kind of a marriage of while and mapcar: I'd like to run
>> some function until it returns nil and make a list of all results it
>> gives back until then.
>
> Can't you use 'throw' from within the function called by mapcar?

I'm not sure whether I understood you...  How can `throw' help me with
this?  And, `mapcar' already wants a list; I want yet to construct it...

-- 
Marcin Borkowski
http://octd.wmi.amu.edu.pl/en/Marcin_Borkowski
Faculty of Mathematics and Computer Science
Adam Mickiewicz University

RE: I'd like to marry while and mapcar...

[Doug Lewan]

There are already a few small programming paradigms for such things.

(dolist (VAR LIST [RESULT]) BODY...) might do the right kind of thing for you, but it never feels lisp-ish to me. And on a long list you might not get the efficiency you expect.

(while (and magic-condition the-list) ... (setq the-list (cdr the-list)) seems closer.

(throw) and (catch) provide another style:
(catch 'foo
  (mapcar (lambda (e)
             ...
             (if (not (magic-test e))
                (throw 'foo t)))))

I hope this helps.

-- 
,Doug
Douglas Lewan
Shubert Ticketing
(201) 489-8600 ext 224 or ext 4335

The human brain is the most complex thing known to man, according to the human brain.


> -----Original Message-----
> From: help-gnu-emacs-bounces+dougl=shubertticketing.com@gnu.org
> [mailto:help-gnu-emacs-bounces+dougl=shubertticketing.com@gnu.org] On
> Behalf Of Marcin Borkowski
> Sent: Friday, 2015 February 06 07:57
> To: Help Gnu Emacs mailing list
> Subject: I'd like to marry while and mapcar...
> 
> Hello Emacsers and Elispers!
> 
> What I'd need is kind of a marriage of while and mapcar: I'd like to
> run
> some function until it returns nil and make a list of all results it
> gives back until then.
> 
> Mu use case is that I'm getting some info from a LaTeX file.  For
> instance, assume that I want to make a list of all files \include'd by
> a LaTeX document.  I've written a function `get-TeX-macro-arguments'
> which finds the next occurence of a given TeX command, moves point past
> it and returns its arguments; if it does not find any such occurrence,
> it returns nil.  So I can say something like this:
> 
> (let (current-include (list-of-includes ()))
>   (while (setq current-include (get-TeX-macro-arguments "include"))
>     (setq list-of-includes (append list-of-includes current-include)))
>   list-of-includes)
> 
> This, however, looks a bit, let's say, Fortran-ish;-); I'm after a more
> Lispy way.  (Of course, one step would be to use anaphoric while, but
> that doesn't help my main problem of ditching list-of-includes.)
> 
> Yes, I know, I have too much time on my hands, and I bother about
> style.
> But I'm also curious whether there is any "standard" way, or whether
> I should indeed wrap something like the above code in a macro, or
> something.  (Or maybe just don't care...)
> 
> TIA,
> 
> --
> Marcin Borkowski               This email was proudly sent
> http://mbork.pl                from my Emacs.

Re: I'd like to marry while and mapcar...

[Barry Margolin]

In article <mailman.19396.1423229779.1147.help-gnu-emacs@gnu.org>,
 Eli Zaretskii <eliz@gnu.org> wrote:

> > From: Marcin Borkowski <mbork@wmi.amu.edu.pl>
> > Date: Fri, 06 Feb 2015 13:56:48 +0100
> > 
> > What I'd need is kind of a marriage of while and mapcar: I'd like to run
> > some function until it returns nil and make a list of all results it
> > gives back until then.
> 
> Can't you use 'throw' from within the function called by mapcar?

That would allow you to terminate the loop, but how will it return the 
list of the results? The function doesn't get a reference to the list of 
results, so what value would you throw?

-- 
Barry Margolin, barmar@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***

Re: I'd like to marry while and mapcar...

[Pascal J. Bourguignon]

Barry Margolin <barmar@alum.mit.edu> writes:

> In article <mailman.19396.1423229779.1147.help-gnu-emacs@gnu.org>,
>  Eli Zaretskii <eliz@gnu.org> wrote:
>
>> > From: Marcin Borkowski <mbork@wmi.amu.edu.pl>
>> > Date: Fri, 06 Feb 2015 13:56:48 +0100
>> > 
>> > What I'd need is kind of a marriage of while and mapcar: I'd like to run
>> > some function until it returns nil and make a list of all results it
>> > gives back until then.
>> 
>> Can't you use 'throw' from within the function called by mapcar?
>
> That would allow you to terminate the loop, but how will it return the 
> list of the results? The function doesn't get a reference to the list of 
> results, so what value would you throw?

And worse: with mapcar, you'd have to duplicate the result list
building.  You can avoid it with mapc, but you need to return it both
when the list is exhausted and in the early exit, which is clearly not
pretty:


    (defun map-while (pred-fun list)
      (catch 'result
        (let ((results '()))
          (mapc (lambda (x) 
                  (let ((result (funcall pred-fun x)))
                    (if result
                        (push result results)
                        (throw 'result (nreverse results))))) 
                list)
          (nreverse results))))

    (map-while 'oddp '(1 3 5 4 6 8))
    --> (t t t)

-- 
__Pascal Bourguignon__                 http://www.informatimago.com/
“The factory of the future will have only two employees, a man and a
dog. The man will be there to feed the dog. The dog will be there to
keep the man from touching the equipment.” -- Carl Bass CEO Autodesk

RE: I'd like to marry while and mapcar...

[Drew Adams]

FWIW, what you wrote in the first place, Marcin, is pretty
much what I would do.  Call it Fortranesque, if you like.
But it's classic Lispiness, IMO.  Lisp is not Haskell.

This is what I would do:

(let ((includes  ())
      include)
  (while (setq include  (get-TeX-macro-arguments "include"))
    (push include includes))
  (setq includes  (nreverse includes)))

I wouldn't bother with `(cl-)loop' or `mapcar' or `mapc' here.

Since you have a function that gets the next thingie you want,
and it returns nil when there are no more, there is no reason
at all to use `catch'+`throw' here.

`catch'+`throw' is useful when, e.g., you have an existing
list that you iterate over (e.g., using `dolist'), and you
do not want to continue iterating over the rest of that
list as soon as you know that you no longer need to.

Here is a typical, end-the-looping-early use of `catch'+`throw':

(defun take (n xs)
  "Return a new list containing only the first N elements of list XS.
If N is greater than the length of XS, return (a copy of) XS."
  (let ((takes  ()))
    (catch 'take
      (dolist (x  xs)
        (when (>= (length takes) n) (throw 'take takes))
        (push x takes)))
    (setq takes  (nreverse takes))))

Or if you don't want the inefficiency of evaluating `length'
at each iteration, add a counter:

(defun take (n xs)
  "..."
  (let ((takes  ())
        (len    0))
    (catch 'take
      (dolist (x  xs)
        (when (>= len n) (throw 'take takes))
        (push x takes)
        (cl-incf len)))
    (setq takes  (nreverse takes))))

Re: I'd like to marry while and mapcar...

[Robert Thorpe]

Drew Adams <drew.adams@oracle.com> writes:

> FWIW, what you wrote in the first place, Marcin, is pretty
> much what I would do.  Call it Fortranesque, if you like.
> But it's classic Lispiness, IMO.  Lisp is not Haskell.

I agree.  I wrote a message yesterday saying many of the things Drew
said here, but I accidentally deleted the buffer.

Small loops of this sort are unlikely to be sources of error.
"Improving" them by phrasing them as map operations has little benefit.

I see two things wrong with the original code:
> (let (current-include (list-of-includes ()))
>   (while (setq current-include (get-TeX-macro-arguments "include"))
>     (setq list-of-includes (append list-of-includes current-include)))
>   list-of-includes)

Firstly, "push" is preferable for the 2nd setq as Drew mentions.

More importantly, the function get-TeX-macro-arguments is badly named.
It both gets arguments and it moves point across the buffer.  It's name
doesn't announce that it changes point.  It's a long name already, but
in my view it should announce that it changes point in the name.  It may
be best to have get-TeX-macro-arguments leave point unchanged and to
move point explicitly separately.  To do that, get-TeX-macro-arguments
could return the buffer position after the last macro it found.

From your comment about the loop being "un-lispy", I expect your absorbed
the idea that functional operations such as maps and reduces are
preferable to loops.  This is because loops often involve complex
mutation of state, and that's error prone.  It's most important to
improve situations where there's complex or hidden mutation of state.
In my view, simple loops are not really a problem.

In Drew's code he nreverse's the list at the end.  It would be best to
avoid that.  Does the subsequent code really need the list reversed?  Or
should that code really process the list in the opposite order?  If that
code is doing things the right way then what about
get-TeX-macro-arguments?  Should it move through the buffer from the
beginning to the end or from end to beginning?

BR,
Robert Thorpe

Re: I'd like to marry while and mapcar...

[Thien-Thi Nguyen]

[-- Attachment #1: Type: text/plain, Size: 640 bytes --]

() Marcin Borkowski <mbork@wmi.amu.edu.pl>
() Fri, 06 Feb 2015 13:56:48 +0100

   Yes, I know, I have too much time on my hands,
   and I bother about style.

These are the prerequisites of cultural development.
Better the refinement of Emacs Lisp sensibilities than
drinking oneself asleep (w/ vomitus) after a discussion
on keyboard proclivities in an underground restaurant,
like someone i know...

-- 
Thien-Thi Nguyen
   GPG key: 4C807502
   (if you're human and you know it)
      read my lisp: (responsep (questions 'technical)
                               (not (via 'mailing-list)))
                     => nil

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 197 bytes --]

Re: I'd like to marry while and mapcar...

[Emanuel Berg]

Thien-Thi Nguyen <ttn@gnu.org> writes:

>> Yes, I know, I have too much time on my hands, and
>> I bother about style.
>
> These are the prerequisites of cultural development.
> Better the refinement of Emacs Lisp sensibilities
> than drinking oneself asleep (w/ vomitus) after a
> discussion on keyboard proclivities in an
> underground restaurant, like someone i know...

Yes, everything except craft and details is so boring!
Those people who ridicule it say it doesn't matter,
but they fail to understand that the supposedly "big"
things don't matter one bit either. Better stick with
craft and details because that at least makes us happy
the very short time we are here.

-- 
underground experts united

Re: I'd like to marry while and mapcar...

[Pascal J. Bourguignon]

Marcin Borkowski <mbork@wmi.amu.edu.pl> writes:

> Hello Emacsers and Elispers!
>
> What I'd need is kind of a marriage of while and mapcar: I'd like to run
> some function until it returns nil and make a list of all results it
> gives back until then.
>
> Mu use case is that I'm getting some info from a LaTeX file.  For
> instance, assume that I want to make a list of all files \include'd by
> a LaTeX document.  I've written a function `get-TeX-macro-arguments'
> which finds the next occurence of a given TeX command, moves point past
> it and returns its arguments; if it does not find any such occurrence,
> it returns nil.  So I can say something like this:
>
> (let (current-include (list-of-includes ()))
>   (while (setq current-include (get-TeX-macro-arguments "include"))
>     (setq list-of-includes (append list-of-includes current-include)))
>   list-of-includes)
>
> This, however, looks a bit, let's say, Fortran-ish;-); I'm after a more
> Lispy way.  (Of course, one step would be to use anaphoric while, but
> that doesn't help my main problem of ditching list-of-includes.)
>
> Yes, I know, I have too much time on my hands, and I bother about style.
> But I'm also curious whether there is any "standard" way, or whether
> I should indeed wrap something like the above code in a macro, or
> something.  (Or maybe just don't care...)

Nothing standard really.


The technique is simple: just write what you want to use:

 
    (map-while (function get-TeX-macro-arguments) list-of-includes)


How map-while is implemented is irrelevant, and an exercise left to the
readers (see other posts).

\f
Well, I'm a reader too ;-)


    (require 'cl)
    (defun map-while (pred-fun list)
        (loop for item in list
              for result = (funcall pred-fun item)
              while result
              collect result))


-- 
__Pascal Bourguignon__                 http://www.informatimago.com/
“The factory of the future will have only two employees, a man and a
dog. The man will be there to feed the dog. The dog will be there to
keep the man from touching the equipment.” -- Carl Bass CEO Autodesk

Re: I'd like to marry while and mapcar...

[Joost Kremers]

Marcin Borkowski wrote:
> Hello Emacsers and Elispers!
>
> What I'd need is kind of a marriage of while and mapcar: I'd like to run
> some function until it returns nil and make a list of all results it
> gives back until then.

Sounds like a job for -take-while from the dash library:

https://github.com/magnars/dash.el


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

Re: I'd like to marry while and mapcar...

[Joost Kremers]

Joost Kremers wrote:
> Marcin Borkowski wrote:
>> Hello Emacsers and Elispers!
>>
>> What I'd need is kind of a marriage of while and mapcar: I'd like to run
>> some function until it returns nil and make a list of all results it
>> gives back until then.
>
> Sounds like a job for -take-while from the dash library:

Actually, reading the question again (and this time properly,) it's
not... I'd use cl-loop for this.

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