Sorting buffer with string-collate-lessp

Sorting buffer with string-collate-lessp

[Rasmus]

Hi,

How can I easily sort a buffer using string-collate-lessp?

Info: I would like to sort a buffer using string-collate-lessp (line by
line).  Sort-lines is the obvious candidate but it uses string<.  I tried
to write my own sort-lines using sort-subr, as it has a predicate
argument.  However, for buffers, it needs something like
compare-buffer-substrings, which takes no predicate and is in the C-level
and pretty long.

I could write a wrapper that convert each buffer-chunk into its
buffer-substring first, and then compares it with string-collate-lessp, I
guess, but that seems like a lot of boiler plate.  So maybe a better
solution exists?

Bonus point if one can specify something simple and intuitive as
string-collate-lessp in a defcustom.

Thanks,
Rasmus

-- 
History is what should never happen again

Re: Sorting buffer with string-collate-lessp

[Tassilo Horn]

Rasmus <rasmus@gmx.us> writes:

Hi Rasmus,

> How can I easily sort a buffer using string-collate-lessp?
>
> Info: I would like to sort a buffer using string-collate-lessp (line
> by line).  Sort-lines is the obvious candidate but it uses string<.  I
> tried to write my own sort-lines using sort-subr, as it has a
> predicate argument.  However, for buffers, it needs something like
> compare-buffer-substrings, which takes no predicate and is in the
> C-level and pretty long.
>
> I could write a wrapper that convert each buffer-chunk into its
> buffer-substring first, and then compares it with
> string-collate-lessp, I guess, but that seems like a lot of boiler
> plate.  So maybe a better solution exists?

I think you can use `cl-left' to temporarily change the definition of
`string<' to `string-collate-lessp', so this should work in theory.

--8<---------------cut here---------------start------------->8---
(cl-letf (((symbol-function 'string<) #'string-collate-lessp))
  (sort-lines nil (point-min) (point-max)))
--8<---------------cut here---------------end--------------->8---

However, I've tried it with (lambda (a b) (string-collate-lessp b a))
which should use `string-collate-lessp' and sort in reverse (note the
switched arguments) and that didn't change anything.

So either my `cl-letf' usage is wrong or `sort-lines' doesn't really use
`string<'.  (Actually, `string<' is an alias to `string-lessp', so I
also tried changing that accordingly, but still no effect...)

Bye,
Tassilo

Re: Sorting buffer with string-collate-lessp

[Rasmus]

Tassilo Horn <tsdh@gnu.org> writes:

> So either my `cl-letf' usage is wrong or `sort-lines' doesn't really use
> `string<'.  (Actually, `string<' is an alias to `string-lessp', so I
> also tried changing that accordingly, but still no effect...)

I though sort-lines used compare-buffer-substrings, but this is just based
on the docstring.

It seems the nesting of parentheses is wrong in your example, but I guess
it just the example.  I did not try to letf to temporarily rename string<.

Thanks,
Rasmus

-- 
Send from my Emacs

Re: Sorting buffer with string-collate-lessp

[Emanuel Berg]

Rasmus <rasmus@gmx.us> writes:

> How can I easily sort a buffer using
> string-collate-lessp?

I don't have string-collate-lessp - where did you get it?

-- 
underground experts united
http://user.it.uu.se/~embe8573

Re: Sorting buffer with string-collate-lessp

[Rasmus]

Emanuel Berg <embe8573@student.uu.se> writes:

> I don't have string-collate-lessp - where did you get it?

Emacs-25.

-- 
You people at the NSA are becoming my new best friends!

Re: Sorting buffer with string-collate-lessp

[Rasmus]

Rasmus <rasmus@gmx.us> writes:

> Emanuel Berg <embe8573@student.uu.se> writes:
>
>> I don't have string-collate-lessp - where did you get it?
>
> Emacs-25.

That was a bit short.  From the news file of 25.1.

    ** The new functions `string-collate-lessp' and `string-collate-equalp'
    preserve the collation order as defined by the system's locale(1)
    environment.  For the time being this is implemented for modern POSIX
    systems and for MS-Windows, for other systems they fall back to their
    counterparts `string-lessp' and `string-equal'.


-- 
It was you, Jezebel, it was you

Re: Sorting buffer with string-collate-lessp

[Emanuel Berg]

Rasmus <rasmus@gmx.us> writes:

>>> I don't have string-collate-lessp - where did you
>>> get it?
>>
>> Emacs-25.
>
> That was a bit short. From the news file of 25.1.
>
>     ** The new functions `string-collate-lessp' and
> `string-collate-equalp' preserve the collation order
> as defined by the system's locale(1) environment.
> For the time being this is implemented for modern
> POSIX systems and for MS-Windows, for other systems
> they fall back to their counterparts `string-lessp'
> and `string-equal'.

Cool - I didn't know there was a new version.
That will be interesting to see if that breaks any of
my code. But it isn't in the Debian repos so probably
you compiled it yourself, ay?

Anyhow, that function name ends with a "p" so it is
a unary function which returns a boolean, I take it.
So why doesn't it work to do just as you suggested
with `sort-subr' with that as the third optional
argument, namely PREDICATE?

-- 
underground experts united
http://user.it.uu.se/~embe8573

Re: Sorting buffer with string-collate-lessp

[Rasmus]

Emanuel Berg <embe8573@student.uu.se> writes:

> Cool - I didn't know there was a new version.
> That will be interesting to see if that breaks any of
> my code. But it isn't in the Debian repos so probably
> you compiled it yourself, ay?

Indeed.  The Emacs wiki suggest that there is a Debian repo with Emacs
snapshots.

> Anyhow, that function name ends with a "p" so it is
> a unary function which returns a boolean, I take it.
> So why doesn't it work to do just as you suggested
> with `sort-subr' with that as the third optional
> argument, namely PREDICATE?

Yeah, but you get bufferf pointers.  As I hinted in my first post you can
write a boilerplate around it,

    (with-temp-buffer
      (save-excursion (insert (mapconcat 'symbol-name '(c b a á) "\n")))
      (sort-subr nil 'forward-line 'end-of-line nil nil
                 (lambda (a b) (funcall
                           (if (fboundp 'string-collate-lessp)
                               'string-collate-lessp
                             'string-lessp)
                           (buffer-substring (car a) (cdr a))
                           (buffer-substring (car b) (cdr b)))))
      (buffer-string))

But this seems like a lot of trouble just to get locale-aware sorting...

Rasmus

-- 
Bang bang

Re: Sorting buffer with string-collate-lessp

[Rasmus]

Rasmus <rasmus@gmx.us> writes:

>> Anyhow, that function name ends with a "p" so it is
>> a unary function which returns a boolean, I take it.
>> So why doesn't it work to do just as you suggested
>> with `sort-subr' with that as the third optional
>> argument, namely PREDICATE?
>
> Yeah, but you get bufferf pointers.  As I hinted in my first post you can
> write a boilerplate around it,
>
>     (with-temp-buffer
>       (save-excursion (insert (mapconcat 'symbol-name '(c b a á) "\n")))
>       (sort-subr nil 'forward-line 'end-of-line nil nil
>                  (lambda (a b) (funcall
>                            (if (fboundp 'string-collate-lessp)
>                                'string-collate-lessp
>                              'string-lessp)
>                            (buffer-substring (car a) (cdr a))
>                            (buffer-substring (car b) (cdr b)))))
>       (buffer-string))

I should have given this function as well:

     (with-temp-buffer
       (save-excursion (insert (mapconcat 'symbol-name '(c b a á) "\n")))
       (sort-subr nil 'forward-line 'end-of-line nil nil
                  (if (fboundp 'string-collate-lessp)
                      'string-collate-lessp
                    'string-lessp))
       (buffer-string))

It results in an error (on my system).

Rasmus

-- 
May contains speling mistake

Re: Sorting buffer with string-collate-lessp

[Tassilo Horn]

Rasmus <rasmus@gmx.us> writes:

>> So either my `cl-letf' usage is wrong or `sort-lines' doesn't really use
>> `string<'.  (Actually, `string<' is an alias to `string-lessp', so I
>> also tried changing that accordingly, but still no effect...)
>
> I though sort-lines used compare-buffer-substrings, but this is just based
> on the docstring.

Ah, that's the reason it had no effect. :-)

> It seems the nesting of parentheses is wrong in your example, but I
> guess it just the example.  I did not try to letf to temporarily
> rename string<.

No, indeed you have to replace `compare-buffer-substrings'.  This seems
to do the trick although my replacement lambda doesn't really satisfy
the contract of the return value of `compare-buffer-substrings' but it
seems to be good enough for usage in `sort-lines'.

--8<---------------cut here---------------start------------->8---
(cl-letf (((symbol-function 'compare-buffer-substrings)
           (lambda (b1 s1 e1 b2 s2 e2)
             (if (string-collate-lessp (buffer-substring s1 e1)
                                       (buffer-substring s2 e2))
                 -1
               1))))
  (sort-lines nil (point-min) 191))
--8<---------------cut here---------------end--------------->8---

The (point-min) and 191 when performed in *scratch* sort the initial
scratch message comment lines.

Bye,
Tassilo

Re: Sorting buffer with string-collate-lessp

[Tassilo Horn]

Emanuel Berg <embe8573@student.uu.se> writes:

> Anyhow, that function name ends with a "p" so it is
> a unary function which returns a boolean, I take it.

No, the "p" just stands for predicate which only implies that it returns
a generalized boolean.  It still might have arbitrary arity, e.g.,
`buffer-narrowed-p' has zero arguments, `consp` has one argument,
`string-lessp' has two arguments, etc.

Bye,
Tassilo

Re: Sorting buffer with string-collate-lessp

[Emanuel Berg]

Rasmus <rasmus@gmx.us> writes:

>> Anyhow, that function name ends with a "p" so it is
>> a unary function which returns a boolean, I take
>> it. So why doesn't it work to do just as you
>> suggested with `sort-subr' with that as the third
>> optional argument, namely PREDICATE?
>
> Yeah, but you get bufferf pointers.  As I hinted in my first post you can
> write a boilerplate around it,
>
>     (with-temp-buffer
>       (save-excursion (insert (mapconcat 'symbol-name '(c b a .) "\n")))
>       (sort-subr nil 'forward-line 'end-of-line nil nil
>                  (lambda (a b) (funcall
>                            (if (fboundp 'string-collate-lessp)
>                                'string-collate-lessp
>                              'string-lessp)
>                            (buffer-substring (car a) (cdr a))
>                            (buffer-substring (car b) (cdr b)))))
>       (buffer-string))
>
> But this seems like a lot of trouble just to get
> locale-aware sorting...

"Locale aware" stuff is always trouble which is why
I don't care for it but eat, sleep and dream an
assimilated Anglo-American when it comes to computing,
and with no shame or blame attached - that said,
I don't think ten lines of Elisp is "a lot of
trouble".

That code looks a bit complicated - perhaps some
things can be extracted, and in particular the
predicate?

But I don't see anything reoccurring so if it works
why not just put it in some init file and move on?

-- 
underground experts united
http://user.it.uu.se/~embe8573

Re: Sorting buffer with string-collate-lessp

[Rasmus]

Emanuel Berg <embe8573@student.uu.se> writes:

> "Locale aware" stuff is always trouble which is why
> I don't care for it but eat, sleep and dream an
> assimilated Anglo-American when it comes to computing,
> and with no shame or blame attached

Maybe you'd care if your name was Émanuel given the fact that
(string< "É" "å") is non-nil.

Diacritics are used in English as well.

> But I don't see anything reoccurring so if it works
> why not just put it in some init file and move on?

It's for package.  It seems bewildering that it's so "hard" to sort a
buffer in this way.

—Rasmus

-- 
Need more coffee. . .

Re: Sorting buffer with string-collate-lessp

[Emanuel Berg]

Rasmus <rasmus@gmx.us> writes:

>> "Locale aware" stuff is always trouble which is why
>> I don't care for it but eat, sleep and dream an
>> assimilated Anglo-American when it comes to
>> computing, and with no shame or blame attached
>
> Maybe you'd care if your name was Émanuel given the
> fact that (string< "É" "å") is non-nil.

It is only impractical to bother with all that.
You can call me Manny if that feels better.

> Diacritics are used in English as well.

Not in Computer English.

>> But I don't see anything reoccurring so if it works
>> why not just put it in some init file and move on?
>
> It's for package. It seems bewildering that it's so
> "hard" to sort a buffer in this way.

OK, put it in a package then. That's beside the point.
I don't understand the problem. Did you solve it but
your are unhappy with the solution? Why? What's wrong
with it?

-- 
underground experts united
http://user.it.uu.se/~embe8573

Re: Sorting buffer with string-collate-lessp

[Michael Heerdegen]

Tassilo Horn <tsdh@gnu.org> writes:

> (cl-letf (((symbol-function 'compare-buffer-substrings)
>            (lambda (b1 s1 e1 b2 s2 e2)
>              (if (string-collate-lessp (buffer-substring s1 e1)
>                                        (buffer-substring s2 e2))
>                  -1
>                1))))
>   (sort-lines nil (point-min) 191))


Alternatively one could call `sort-subr' directly to avoid `cl-letf':

--8<---------------cut here---------------start------------->8---
(sort-subr
 nil
 #'forward-line #'end-of-line
 (lambda () (buffer-substring-no-properties
        (point) (line-end-position)))
 nil
 #'string-collate-lessp)
--8<---------------cut here---------------end--------------->8---


Michael.