unofficial mirror of help-gnu-emacs@gnu.org
 help / color / mirror / Atom feed
* I'd like to marry while and mapcar...
@ 2015-02-06 12:56 Marcin Borkowski
  2015-02-06 13:18 ` Rasmus
                   ` (6 more replies)
  0 siblings, 7 replies; 16+ messages in thread
From: Marcin Borkowski @ 2015-02-06 12:56 UTC (permalink / raw)
  To: Help Gnu Emacs mailing list

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.



^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
  2015-02-06 12:56 I'd like to marry while and mapcar Marcin Borkowski
@ 2015-02-06 13:18 ` Rasmus
  2015-02-06 13:53   ` Marcin Borkowski
  2015-02-06 13:36 ` Eli Zaretskii
                   ` (5 subsequent siblings)
  6 siblings, 1 reply; 16+ messages in thread
From: Rasmus @ 2015-02-06 13:18 UTC (permalink / raw)
  To: help-gnu-emacs

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




^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
  2015-02-06 12:56 I'd like to marry while and mapcar Marcin Borkowski
  2015-02-06 13:18 ` Rasmus
@ 2015-02-06 13:36 ` Eli Zaretskii
  2015-02-06 13:50   ` Marcin Borkowski
  2015-02-06 13:44 ` Doug Lewan
                   ` (4 subsequent siblings)
  6 siblings, 1 reply; 16+ messages in thread
From: Eli Zaretskii @ 2015-02-06 13:36 UTC (permalink / raw)
  To: help-gnu-emacs

> 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?



^ permalink raw reply	[flat|nested] 16+ messages in thread

* RE: I'd like to marry while and mapcar...
  2015-02-06 12:56 I'd like to marry while and mapcar Marcin Borkowski
  2015-02-06 13:18 ` Rasmus
  2015-02-06 13:36 ` Eli Zaretskii
@ 2015-02-06 13:44 ` Doug Lewan
       [not found] ` <mailman.19396.1423229779.1147.help-gnu-emacs@gnu.org>
                   ` (3 subsequent siblings)
  6 siblings, 0 replies; 16+ messages in thread
From: Doug Lewan @ 2015-02-06 13:44 UTC (permalink / raw)
  To: Marcin Borkowski, Help Gnu Emacs mailing list

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.




^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
  2015-02-06 13:36 ` Eli Zaretskii
@ 2015-02-06 13:50   ` Marcin Borkowski
  0 siblings, 0 replies; 16+ messages in thread
From: Marcin Borkowski @ 2015-02-06 13:50 UTC (permalink / raw)
  To: help-gnu-emacs


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



^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
  2015-02-06 13:18 ` Rasmus
@ 2015-02-06 13:53   ` Marcin Borkowski
  2015-02-06 14:14     ` Rasmus
  0 siblings, 1 reply; 16+ messages in thread
From: Marcin Borkowski @ 2015-02-06 13:53 UTC (permalink / raw)
  To: help-gnu-emacs


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



^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
       [not found] <mailman.19392.1423227427.1147.help-gnu-emacs@gnu.org>
@ 2015-02-06 14:13 ` Pascal J. Bourguignon
  2015-02-06 14:54 ` Joost Kremers
  1 sibling, 0 replies; 16+ messages in thread
From: Pascal J. Bourguignon @ 2015-02-06 14:13 UTC (permalink / raw)
  To: help-gnu-emacs

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


^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
  2015-02-06 13:53   ` Marcin Borkowski
@ 2015-02-06 14:14     ` Rasmus
  0 siblings, 0 replies; 16+ messages in thread
From: Rasmus @ 2015-02-06 14:14 UTC (permalink / raw)
  To: help-gnu-emacs

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




^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
       [not found] <mailman.19392.1423227427.1147.help-gnu-emacs@gnu.org>
  2015-02-06 14:13 ` Pascal J. Bourguignon
@ 2015-02-06 14:54 ` Joost Kremers
  2015-02-06 17:47   ` Joost Kremers
  1 sibling, 1 reply; 16+ messages in thread
From: Joost Kremers @ 2015-02-06 14:54 UTC (permalink / raw)
  To: help-gnu-emacs

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)


^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
       [not found] ` <mailman.19396.1423229779.1147.help-gnu-emacs@gnu.org>
@ 2015-02-06 16:25   ` Barry Margolin
  2015-02-06 16:52     ` Pascal J. Bourguignon
  0 siblings, 1 reply; 16+ messages in thread
From: Barry Margolin @ 2015-02-06 16:25 UTC (permalink / raw)
  To: help-gnu-emacs

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 ***


^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
  2015-02-06 16:25   ` Barry Margolin
@ 2015-02-06 16:52     ` Pascal J. Bourguignon
  0 siblings, 0 replies; 16+ messages in thread
From: Pascal J. Bourguignon @ 2015-02-06 16:52 UTC (permalink / raw)
  To: help-gnu-emacs

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


^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
  2015-02-06 14:54 ` Joost Kremers
@ 2015-02-06 17:47   ` Joost Kremers
  0 siblings, 0 replies; 16+ messages in thread
From: Joost Kremers @ 2015-02-06 17:47 UTC (permalink / raw)
  To: help-gnu-emacs

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)


^ permalink raw reply	[flat|nested] 16+ messages in thread

* RE: I'd like to marry while and mapcar...
  2015-02-06 12:56 I'd like to marry while and mapcar Marcin Borkowski
                   ` (3 preceding siblings ...)
       [not found] ` <mailman.19396.1423229779.1147.help-gnu-emacs@gnu.org>
@ 2015-02-06 22:49 ` Drew Adams
  2015-02-07 21:09   ` Robert Thorpe
  2015-02-07 23:37 ` Thien-Thi Nguyen
       [not found] ` <mailman.19494.1423352465.1147.help-gnu-emacs@gnu.org>
  6 siblings, 1 reply; 16+ messages in thread
From: Drew Adams @ 2015-02-06 22:49 UTC (permalink / raw)
  To: Marcin Borkowski, Help Gnu Emacs mailing list

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))))



^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
  2015-02-06 22:49 ` Drew Adams
@ 2015-02-07 21:09   ` Robert Thorpe
  0 siblings, 0 replies; 16+ messages in thread
From: Robert Thorpe @ 2015-02-07 21:09 UTC (permalink / raw)
  To: Marcin Borkowski; +Cc: help-gnu-emacs

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



^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
  2015-02-06 12:56 I'd like to marry while and mapcar Marcin Borkowski
                   ` (4 preceding siblings ...)
  2015-02-06 22:49 ` Drew Adams
@ 2015-02-07 23:37 ` Thien-Thi Nguyen
       [not found] ` <mailman.19494.1423352465.1147.help-gnu-emacs@gnu.org>
  6 siblings, 0 replies; 16+ messages in thread
From: Thien-Thi Nguyen @ 2015-02-07 23:37 UTC (permalink / raw)
  To: Help Gnu Emacs mailing list

[-- 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 --]

^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: I'd like to marry while and mapcar...
       [not found] ` <mailman.19494.1423352465.1147.help-gnu-emacs@gnu.org>
@ 2015-02-08  0:28   ` Emanuel Berg
  0 siblings, 0 replies; 16+ messages in thread
From: Emanuel Berg @ 2015-02-08  0:28 UTC (permalink / raw)
  To: help-gnu-emacs

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


^ permalink raw reply	[flat|nested] 16+ messages in thread

end of thread, other threads:[~2015-02-08  0:28 UTC | newest]

Thread overview: 16+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2015-02-06 12:56 I'd like to marry while and mapcar Marcin Borkowski
2015-02-06 13:18 ` Rasmus
2015-02-06 13:53   ` Marcin Borkowski
2015-02-06 14:14     ` Rasmus
2015-02-06 13:36 ` Eli Zaretskii
2015-02-06 13:50   ` Marcin Borkowski
2015-02-06 13:44 ` Doug Lewan
     [not found] ` <mailman.19396.1423229779.1147.help-gnu-emacs@gnu.org>
2015-02-06 16:25   ` Barry Margolin
2015-02-06 16:52     ` Pascal J. Bourguignon
2015-02-06 22:49 ` Drew Adams
2015-02-07 21:09   ` Robert Thorpe
2015-02-07 23:37 ` Thien-Thi Nguyen
     [not found] ` <mailman.19494.1423352465.1147.help-gnu-emacs@gnu.org>
2015-02-08  0:28   ` Emanuel Berg
     [not found] <mailman.19392.1423227427.1147.help-gnu-emacs@gnu.org>
2015-02-06 14:13 ` Pascal J. Bourguignon
2015-02-06 14:54 ` Joost Kremers
2015-02-06 17:47   ` Joost Kremers

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).