Emacs 26.2.90 is out!

Emacs 26.2.90 is out!

[Nicolas Petton]

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

Hi!

The first pretest for what will be the 26.2 release of Emacs (the
extensible text editor) is available at

  https://alpha.gnu.org/gnu/emacs/pretest/emacs-26.2.90.tar.xz

You can get the PGP signature at

  https://alpha.gnu.org/gnu/emacs/pretest/emacs-26.2.90.tar.xz.sig

The tarball is signed with the following GPG key, which can be found on
PGP key servers

  D405AA2C862C54F17EEE6BE0E8BCD7866AFCF978

Please give it as much testing as you can.

As always, if you encounter problems building or using Emacs,
send a report to bug-gnu-emacs@gnu.org with full details
(if possible, use M-x report-emacs-bug).

Thanks for helping to test Emacs.

Cheers,
Nico

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

Re: Emacs 26.2.90 is out!

[Nicolas Petton]

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

Nicolas Petton <nicolas@petton.fr> writes:

I wrote:

> The first pretest for what will be the 26.2 release of Emacs (the

But of course I meant to write:

> The first pretest for what will be the 26.3 release of Emacs (the

Sorry for the confusion.

Cheers,
Nico

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

Re: Emacs 26.2.90 is out!

[Phillip Lord]

And windows binaries available.

https://alpha.gnu.org/gnu/emacs/pretest/windows/emacs-26/

Nicolas Petton <nicolas@petton.fr> writes:

> Hi!
>
> The first pretest for what will be the 26.2 release of Emacs (the
> extensible text editor) is available at
>
>   https://alpha.gnu.org/gnu/emacs/pretest/emacs-26.2.90.tar.xz
>
> You can get the PGP signature at
>
>   https://alpha.gnu.org/gnu/emacs/pretest/emacs-26.2.90.tar.xz.sig
>
> The tarball is signed with the following GPG key, which can be found on
> PGP key servers
>
>   D405AA2C862C54F17EEE6BE0E8BCD7866AFCF978
>
> Please give it as much testing as you can.
>
> As always, if you encounter problems building or using Emacs,
> send a report to bug-gnu-emacs@gnu.org with full details
> (if possible, use M-x report-emacs-bug).
>
> Thanks for helping to test Emacs.
>
> Cheers,
> Nico

stream.el (was: Emacs 26.2.90 is out!)

[Michael Heerdegen]

Hi,

while you're here - completely different story:

how should we proceed if we want to make fixes/changes to stream.el and
the other Elisp stuff you maintain?  The last time we tried to contact
you was some days ago when Noam and I discussed the fix for Bug#30626.
We got no reply to our questions - did these mails go through?

If you are short on time - I don't mind, happens to most of us sooner or
later.  But is it ok if we just fix bugs in your libs, or continue
developing them?  Do you plan to continue maintaining these files?

Thanks,

Michael.

Re: stream.el (was: Emacs 26.2.90 is out!)

[Nicolas Petton]

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

Michael Heerdegen <michael_heerdegen@web.de> writes:

> Hi,

Hi Michael,

> how should we proceed if we want to make fixes/changes to stream.el and
> the other Elisp stuff you maintain?  The last time we tried to contact
> you was some days ago when Noam and I discussed the fix for Bug#30626.
> We got no reply to our questions - did these mails go through?

I've been short on time lately, but I definitely plan to keep
maintaining those packages.

> But is it ok if we just fix bugs in your libs, or continue developing
> them?  Do you plan to continue maintaining these files?

It's ok to fix them, but I'd like to stay involved at least.

Cheers,
Nico

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

Enhance seq-min and seq-max (was: stream.el)

[Michael Heerdegen]

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

Nicolas Petton <nicolas@petton.fr> writes:

> It's ok to fix them, but I'd like to stay involved at least.

Ok, great.

I would like to extend seq-min and seq-max to allow (a) arbitrary
comparison functions and (b) key functions like in cl, so that you can
find e.g. the longest string in a sequence of strings.  I miss this
functionality, AFAIK cl-lib also can't do it.

Like this, maybe?


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-WIP-Enhance-seq-min-and-seq-max.patch --]
[-- Type: text/x-diff, Size: 2201 bytes --]

From 3cbaf1316de41687a6a3a6d67e4cc773769999c3 Mon Sep 17 00:00:00 2001
From: Michael Heerdegen <michael_heerdegen@web.de>
Date: Fri, 10 May 2019 15:08:57 +0200
Subject: [PATCH] WIP: Enhance seq-min and seq-max

---
 lisp/emacs-lisp/seq.el | 34 +++++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

diff --git a/lisp/emacs-lisp/seq.el b/lisp/emacs-lisp/seq.el
index 3413cd1513..ddd8f3161c 100644
--- a/lisp/emacs-lisp/seq.el
+++ b/lisp/emacs-lisp/seq.el
@@ -451,15 +451,35 @@ seq-group-by
    (seq-reverse sequence)
    nil))

-(cl-defgeneric seq-min (sequence)
+(cl-defgeneric seq-min (sequence &optional predicate key)
   "Return the smallest element of SEQUENCE.
-SEQUENCE must be a sequence of numbers or markers."
-  (apply #'min (seq-into sequence 'list)))
-
-(cl-defgeneric seq-max (sequence)
+With PREDICATE given, use it to compare elements.  The default is
+`<'.
+With function KEY given, call it on the individual elements and
+compare the results instead of the elements."
+  (if predicate
+      (seq-reduce
+       (if key
+           (lambda (x y)
+             (if (funcall predicate (funcall key y) (funcall key x)) y x))
+         (lambda (x y) (if (funcall predicate y x) y x)))
+       sequence (car sequence))
+    (apply #'min (seq-into sequence 'list))))
+
+(cl-defgeneric seq-max (sequence &optional predicate key)
   "Return the largest element of SEQUENCE.
-SEQUENCE must be a sequence of numbers or markers."
-  (apply #'max (seq-into sequence 'list)))
+With PREDICATE given, use it to compare elements.  The default is
+`<'.
+With function KEY given, call it on the individual elements and
+compare the results instead of the elements."
+  (if predicate
+      (seq-reduce
+       (if key
+           (lambda (x y)
+             (if (funcall predicate (funcall key x) (funcall key y)) y x))
+         (lambda (x y) (if (funcall predicate x y) y x)))
+       sequence (car sequence))
+    (apply #'max (seq-into sequence 'list))))

 (defun seq--count-successive (pred sequence)
   "Return the number of successive elements for which (PRED element) is non-nil in SEQUENCE."
--
2.20.1


[-- Attachment #3: Type: text/plain, Size: 175 bytes --]


I made it so that if the result is ambiguous (e.g. multiple strings with
equal length), the first one is returned, but that is not explicitly
documented.

Regards,

Michael.

Re: Enhance seq-min and seq-max (was: stream.el)

[Eli Zaretskii]

> From: Michael Heerdegen <michael_heerdegen@web.de>
> Date: Sat, 15 Jun 2019 02:25:06 +0200
> Cc: Emacs Devel <emacs-devel@gnu.org>
> 
> I would like to extend seq-min and seq-max to allow (a) arbitrary
> comparison functions and (b) key functions like in cl, so that you can
> find e.g. the longest string in a sequence of strings.  I miss this
> functionality, AFAIK cl-lib also can't do it.

If this is pushed, please update the documentation as well.

Thanks.

Re: Enhance seq-min and seq-max

[Michael Heerdegen]

Eli Zaretskii <eliz@gnu.org> writes:

> If this is pushed, please update the documentation as well.

The manual?  I would have forgotten that, didn't remember that seq.el
was already mentioned there.  Thanks for the hint.

Michael.

Re: Enhance seq-min and seq-max

[Eli Zaretskii]

> From: Michael Heerdegen <michael_heerdegen@web.de>
> Cc: nicolas@petton.fr,  emacs-devel@gnu.org
> Date: Sun, 16 Jun 2019 01:00:38 +0200
> 
> Eli Zaretskii <eliz@gnu.org> writes:
> 
> > If this is pushed, please update the documentation as well.
> 
> The manual?

Yes.  But also NEWS, as I think this change is worthy of being
mentioned there.

> I would have forgotten that, didn't remember that seq.el was already
> mentioned there.  Thanks for the hint.

You are welcome.  Thanks for working on this.

Re: Enhance seq-min and seq-max

[Michael Heerdegen]

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

Michael Heerdegen <michael_heerdegen@web.de> writes:

> Like this, maybe?

Here is an update.  I improved the documentation and optimized the code
to avoid repeated calls of the KEY function on the same element.  There
are now more cases, but the code should be more efficient.

If this is accepted, I will care about the update of the manual.


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-WIP-Enhance-seq-min-and-seq-max.patch --]
[-- Type: text/x-diff, Size: 3443 bytes --]

From 8c870d37e9f6c67f6eb1566cb1307465675b4d8a Mon Sep 17 00:00:00 2001
From: Michael Heerdegen <michael_heerdegen@web.de>
Date: Fri, 10 May 2019 15:08:57 +0200
Subject: [PATCH] WIP: Enhance seq-min and seq-max

---
 lisp/emacs-lisp/seq.el | 62 +++++++++++++++++++++++++++++++++++++-----
 1 file changed, 55 insertions(+), 7 deletions(-)

diff --git a/lisp/emacs-lisp/seq.el b/lisp/emacs-lisp/seq.el
index 3413cd1513..b681adb393 100644
--- a/lisp/emacs-lisp/seq.el
+++ b/lisp/emacs-lisp/seq.el
@@ -451,15 +451,63 @@ seq-group-by
    (seq-reverse sequence)
    nil))

-(cl-defgeneric seq-min (sequence)
+(cl-defgeneric seq-min (sequence &optional predicate key)
   "Return the smallest element of SEQUENCE.
-SEQUENCE must be a sequence of numbers or markers."
-  (apply #'min (seq-into sequence 'list)))
-
-(cl-defgeneric seq-max (sequence)
+With PREDICATE given, use it to compare elements.
+With function KEY given, call it with the individual elements as
+arguments and compare the results instead of the elements.
+
+PREDICATE doesn't need to define a total order.  The return value is
+always the first element X of SEQUENCE so that for no following Y
+
+  (funcall PREDICATE (funcall KEY Y) (funcall KEY X))
+
+yields non-nil, where PREDICATE defaults to #'< and KEY to
+#'identity."
+  (if predicate
+      (if key
+          (let ((first (car sequence)))
+            (cdr (seq-reduce
+                  (lambda (key-x-and-x y)
+                    (let ((key-y-and-y (cons (funcall key y) y)))
+                      (if (funcall predicate (car key-y-and-y) (car key-x-and-x))
+                          key-y-and-y
+                        key-x-and-x)))
+                  (cdr sequence)
+                  (cons (funcall key first) first))))
+        (seq-reduce
+         (lambda (x y) (if (funcall predicate y x) y x))
+         (cdr sequence) (car sequence)))
+    (apply #'min (seq-into sequence 'list))))
+
+(cl-defgeneric seq-max (sequence &optional predicate key)
   "Return the largest element of SEQUENCE.
-SEQUENCE must be a sequence of numbers or markers."
-  (apply #'max (seq-into sequence 'list)))
+With PREDICATE given, use it to compare elements.
+With function KEY given, call it with the individual elements as
+arguments and compare the results instead of the elements.
+
+PREDICATE doesn't need to define a total order.  The return value is
+always the first element X of SEQUENCE so that for no following Y
+
+  (funcall PREDICATE (funcall KEY X) (funcall KEY Y))
+
+yields non-nil, where PREDICATE defaults to #'< and KEY to
+#'identity."
+  (if predicate
+      (if key
+          (let ((first (car sequence)))
+            (cdr (seq-reduce
+                  (lambda (key-x-and-x y)
+                    (let ((key-y-and-y (cons (funcall key y) y)))
+                      (if (funcall predicate (car key-x-and-x) (car key-y-and-y))
+                          key-y-and-y
+                        key-x-and-x)))
+                  (cdr sequence)
+                  (cons (funcall key first) first))))
+        (seq-reduce
+         (lambda (x y) (if (funcall predicate x y) y x))
+         (cdr sequence) (car sequence)))
+    (apply #'max (seq-into sequence 'list))))

 (defun seq--count-successive (pred sequence)
   "Return the number of successive elements for which (PRED element) is non-nil in SEQUENCE."
--
2.20.1


[-- Attachment #3: Type: text/plain, Size: 20 bytes --]



Thanks,

Michael.

Re: Enhance seq-min and seq-max

[Nicolas Petton]

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

Michael Heerdegen <michael_heerdegen@web.de> writes:

> Michael Heerdegen <michael_heerdegen@web.de> writes:

Hi Michael,

>> Like this, maybe?

I like the idea!  In addition to documentation, could you also add
unit tests? (for seq.el, I like when my unit tests test multiple
sequence types).

I left some comments below.

> +  (if predicate
         ^^^^^^^^^
What if `predicate' is nil but `key' is non-nil?
> +      (if key
> +          (let ((first (car sequence)))
                           ^^^
                           You cannot use `car' here
> +            (cdr (seq-reduce
> +                  (lambda (key-x-and-x y)
> +                    (let ((key-y-and-y (cons (funcall key y) y)))
> +                      (if (funcall predicate (car key-y-and-y) (car key-x-and-x))
> +                          key-y-and-y
> +                        key-x-and-x)))
> +                  (cdr sequence)
                      ^^^
                      You cannot use `cdr' either
> +                  (cons (funcall key first) first))))
> +        (seq-reduce
> +         (lambda (x y) (if (funcall predicate y x) y x))
> +         (cdr sequence) (car sequence)))
> +    (apply #'min (seq-into sequence 'list))))
                     ^^^^^^^^^^^^^^^^^^^^^^^
                     I think your version of `seq-min' will break when
                     `predicate' is used for all sequence types but lists,
                     since you don't convert the sequence, but use `car'
                     and `cdr'.

Thanks!
Nico

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

Re: Enhance seq-min and seq-max

[Michael Heerdegen]

Nicolas Petton <nicolas@petton.fr> writes:

> In addition to documentation, could you also add unit tests? (for
> seq.el, I like when my unit tests test multiple sequence types).

Sure.

> I left some comments below.
>
> > +  (if predicate
>          ^^^^^^^^^
> What if `predicate' is nil but `key' is non-nil?

Then it does nonsense.  Ok, we get one more case.  I wonder if I should
rather give one general definition in the function body and handle the
four cases (KEY/PREDICATE given/not given) in a compiler macro.  Then in
compiled code there would be no runtime tests and it would be optimized
for the respective case.

> > +    (apply #'min (seq-into sequence 'list))))
>                      ^^^^^^^^^^^^^^^^^^^^^^^ I think your version of
>                      `seq-min' will break when `predicate' is used for
>                      all sequence types but lists, since you don't
>                      convert the sequence, but use `car' and `cdr'.

Correct.  I changed it to use seq-first and seq-rest instead of car/cdr
- an intermediate conversion step is not necessary I think.


Thanks,

Michael.

Re: Enhance seq-min and seq-max

[Nicolas Petton]

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

Michael Heerdegen <michael_heerdegen@web.de> writes:

>> I left some comments below.
>>
>> > +  (if predicate
>>          ^^^^^^^^^
>> What if `predicate' is nil but `key' is non-nil?
>
> Then it does nonsense.  Ok, we get one more case.

If it's documented, I'm fine with it.

> I wonder if I should rather give one general definition in the
> function body and handle the four cases (KEY/PREDICATE given/not
> given) in a compiler macro.  Then in compiled code there would be no
> runtime tests and it would be optimized for the respective case.

As you wish, but depending on what exactly you have in mind, it might be
better not to do it, so that `seq-min' and `seq-max' can still easily be
overwritten for custom seq types.

Nico

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

Re: Enhance seq-min and seq-max

[Michael Heerdegen]

Nicolas Petton <nicolas@petton.fr> writes:

> > I wonder if I should rather give one general definition in the
> > function body and handle the four cases (KEY/PREDICATE given/not
> > given) in a compiler macro.  Then in compiled code there would be no
> > runtime tests and it would be optimized for the respective case.
>
> As you wish, but depending on what exactly you have in mind, it might be
> better not to do it, so that `seq-min' and `seq-max' can still easily be
> overwritten for custom seq types.

I guess what I planned is nonsense: If the method is chosen at run-time,
it doesn't make sense to optimize the method for lists with a compiler
macro.  It's not a critical issue anyway, so I'll just go with what I
have so far (and finish the documentation stuff).


Michael.

Re: Enhance seq-min and seq-max

[Nicolas Petton]

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

Michael Heerdegen <michael_heerdegen@web.de> writes:

> I guess what I planned is nonsense: If the method is chosen at run-time,
> it doesn't make sense to optimize the method for lists with a compiler
> macro.  It's not a critical issue anyway, so I'll just go with what I
> have so far (and finish the documentation stuff).

Great, thank!

Nico

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