Re: help with regexp function

["B. T. Raven" <btraven@nihilo.net>]

On 11/23/2017 09:20, Stephen Berman wrote:

>>> Here's a pretty direct translation of the interactive substitution:
>> This works correctly but it isn't exactly what regexp-quote returns.
> 
> Note that (regexp-quote "\(^[0-9]+ \)\(.+\)") returns this string:
> "(\\^\\[0-9]\\+ )(\\.\\+)", which matches only the literal string
> "(^[0-9]+ )(.+)", so it's not what you want.
> 
>> Is there a function that produces "^\\([0-9]+\\) \\(.*\\)$" from
>> "\(^[0-9]+ \)\(.+\)" ?
> 
> I don't know of any.  But in order for the Lisp reader to recognize a
> backslash in a string as a backslash, you have to double it (because the
> backslash is used as the escape character is the Lisp read syntax).  So
> you can just write your regexp as you would when using
> query-replace-regexp and then double each of the backslashes to use it
> in a Lisp program.

Okay, thanks.

> 
>> Did you replace .+ with .* just for greater generality?
> 
> Yep.
> 

>>
>> No, I don't understand that notation. I started with other regexp
>> functions like query-replace-regexp but was getting type errors and
>> general confusion.
> 
> I still can't tell how such errors arose, but it's probably not worth
> pursuing now.
> 
>>>> ;; I have a function which is a black box to to me but it works in
>>>> the larger context I have it in. Does match-string do something like
>>>> this implicitly (casting a list as a string?)
>>>
>>> Not AFAIK.
>>
>> Here is the function I was talking about:
>> (defun reverse-string (str)
>>    (apply #'string (nreverse (string-to-list str))))
>>
>> It sounded like (append #'string ... was recasting a list to a string.
>                     ^^^^^^
>                     apply
Yes, because I tried to type rather than copypaste.
I was distracted by the # (what does it mean?)


> 
> I'm not sure it's helpful to think of it like that, since using a list
> is an artefact of the function definition here: `string' takes one or
> more characters but Emacs Lisp functions cannot return multiple values,
> only single values such as a list of characters.  But you can dispense
> with that intermediate step:
> 
> (defun reverse-string (str)
>    (let ((l (length str))
> 	(nstr ""))
>      (dotimes (i l nstr)
>        (setq nstr (concat (string (aref str i)) nstr)))))
> 
> In fact, this is essentially how `nreverse' (and 'reverse') operate on
> strings (so there's no need for `reverse-string').  In any case, I don't
> see what this has to do with match-string.

That looks like it may be faster than what
I have now. Is it? Everything is in C except dotimes and string-to-list 
according to the function docs.


Thanks again.

> 
> Steve Berman
> 
>