bounds for strings with - between subwords

bounds for strings with - between subwords

[steve-humphreys]

I am using the following function that gets me the bounds for each word.

But I have strings like

bibl-bellerive-etal-2016

which I want to get the bounds for strings with - between subwords.

--------

(defun alpha-bounds ()
   "Gets bounds of a subword unit defined by regular expression [a-zA-Z]."

   (let ( ($bounds nil) $ma $mb )

      (skip-chars-backward "[:alpha:]")
      (setq $ma (point))
      (skip-chars-forward "[:alpha:]")
      (setq $mb (point))
      (setq $bounds (bounds-of-thing-at-point 'word))
      (cons $ma $mb) ))

Re: bounds for strings with - between subwords

[Emanuel Berg via Users list for the GNU Emacs text editor]

steve-humphreys wrote:

> I am using the following function that gets me the bounds
> for each word.
>
> But I have strings like
>
> bibl-bellerive-etal-2016
>
> which I want to get the bounds for strings with -
> between subwords.

I'm not following 100% but you can add digits and a dash to
your below work if that helps?

(skip-chars-forward "[:alnum:]-")

> (defun alpha-bounds ()
>    "Gets bounds of a subword unit defined by regular expression [a-zA-Z]."
>    (let ( ($bounds nil) $ma $mb )
>       (skip-chars-backward "[:alpha:]")
>       (setq $ma (point))
>       (skip-chars-forward "[:alpha:]")
>       (setq $mb (point))
>       (setq $bounds (bounds-of-thing-at-point 'word))
>       (cons $ma $mb) ))

You can put all that in the `let' to avoid the use of `setq'.

Also $bounds doesn't seem to do anything?

And what's the purpose of the $?

-- 
underground experts united
https://dataswamp.org/~incal

Re: bounds for strings with - between subwords

[Christopher Dimech]

> Sent: Friday, May 07, 2021 at 10:49 AM
> From: "Emanuel Berg via Users list for the GNU Emacs text editor" <help-gnu-emacs@gnu.org>
> To: help-gnu-emacs@gnu.org
> Subject: Re: bounds for strings with - between subwords
>
> steve-humphreys wrote:
>
> > I am using the following function that gets me the bounds
> > for each word.
> >
> > But I have strings like
> >
> > bibl-bellerive-etal-2016
> >
> > which I want to get the bounds for strings with -
> > between subwords.
>
> I'm not following 100% but you can add digits and a dash to
> your below work if that helps?
>
> (skip-chars-forward "[:alnum:]-")
>
> > (defun alpha-bounds ()
> >    "Gets bounds of a subword unit defined by regular expression [a-zA-Z]."
> >    (let ( ($bounds nil) $ma $mb )
> >       (skip-chars-backward "[:alpha:]")
> >       (setq $ma (point))
> >       (skip-chars-forward "[:alpha:]")
> >       (setq $mb (point))
> >       (setq $bounds (bounds-of-thing-at-point 'word))
> >       (cons $ma $mb) ))
>
> You can put all that in the `let' to avoid the use of `setq'.
>
> Also $bounds doesn't seem to do anything?

bounds are used in another function.  You can see there is (cons $ma $mb) at the end,
which is used as output when you call "alpha-bounds".

> And what's the purpose of the $?

I use $ no tell me the variable is local and not being modified from outside.
It is coming from the $1, $2, $3, ... function parameter idea.

> --
> underground experts united
> https://dataswamp.org/~incal
>
>
>

Re: bounds for strings with - between subwords

[Emanuel Berg via Users list for the GNU Emacs text editor]

Christopher Dimech wrote:

>> > (defun alpha-bounds ()
>> >    "Gets bounds of a subword unit defined by regular expression [a-zA-Z]."
>> >    (let ( ($bounds nil) $ma $mb )
>> >       (skip-chars-backward "[:alpha:]")
>> >       (setq $ma (point))
>> >       (skip-chars-forward "[:alpha:]")
>> >       (setq $mb (point))
>> >       (setq $bounds (bounds-of-thing-at-point 'word))
>> >       (cons $ma $mb) ))
>>
>> You can put all that in the `let' to avoid the use of `setq'.
>>
>> Also $bounds doesn't seem to do anything?
>
> bounds are used in another function. You can see there is
> (cons $ma $mb) at the end,
> which is used as output when you call "alpha-bounds".

$bounds still isn't used anywhere else and cannot be, either.

>> And what's the purpose of the $?
>
> I use $ no tell me the variable is local and not being
> modified from outside. It is coming from the $1, $2, $3, ...
> function parameter idea.

But they cannot be modified from the outside so no need to
worry about that.

-- 
underground experts united
https://dataswamp.org/~incal

Re: bounds for strings with - between subwords

[Christopher Dimech]

> Sent: Friday, May 07, 2021 at 11:44 AM
> From: "Emanuel Berg via Users list for the GNU Emacs text editor" <help-gnu-emacs@gnu.org>
> To: help-gnu-emacs@gnu.org
> Subject: Re: bounds for strings with - between subwords
>
> Christopher Dimech wrote:
>
> >> > (defun alpha-bounds ()
> >> >    "Gets bounds of a subword unit defined by regular expression [a-zA-Z]."
> >> >    (let ( ($bounds nil) $ma $mb )
> >> >       (skip-chars-backward "[:alpha:]")
> >> >       (setq $ma (point))
> >> >       (skip-chars-forward "[:alpha:]")
> >> >       (setq $mb (point))
> >> >       (setq $bounds (bounds-of-thing-at-point 'word))
> >> >       (cons $ma $mb) ))
> >>
> >> You can put all that in the `let' to avoid the use of `setq'.
> >>
> >> Also $bounds doesn't seem to do anything?
> >
> > bounds are used in another function. You can see there is
> > (cons $ma $mb) at the end,
> > which is used as output when you call "alpha-bounds".
>
> $bounds still isn't used anywhere else and cannot be, either.

You are right, the use of the function is merely to set $ma and $mb.
The last $bounds can be removed.

> >> And what's the purpose of the $?
> >
> > I use $ no tell me the variable is local and not being
> > modified from outside. It is coming from the $1, $2, $3, ...
> > function parameter idea.
>
> But they cannot be modified from the outside so no need to
> worry about that.

It is a question of readability, particularly for long functions so not
to get confused when making changes or debugging.  The function is very
short as you say.  It is simply a standard I put in anyway.

> --
> underground experts united
> https://dataswamp.org/~incal
>
>
>

Re: bounds for strings with - between subwords

[steve-humphreys]

This is what I've got

But when I get to option 5, the string e.g. "Bibl-Stockwell-Mansinha-Lowe-1996"
is not being downcased.

--------

(defun alpha-bounds ()
   "Gets bounds of a subword unit defined by regular expression [a-zA-Z]."

   (let ( ($bounds nil) $ma $mb )        ; var initially bound to nil

      (skip-chars-backward "[:alpha:]")  ; equivalent to [a-zA-Z]
      (setq $ma (point))
      (skip-chars-forward "[:alpha:]")
      (setq $mb (point))
      (setq $bounds (bounds-of-thing-at-point 'word))
      (cons $ma $mb) ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun alnum-dash-bounds ()
   "Gets bounds of a subword unit defined by [:alnum:] and dash."

   (let ( ($bounds nil) $ma $mb )

      (skip-chars-backward "[:alnum:]-")  ; same as ""[a-zA-Z0-9]-"
      (setq $ma (point))
      (skip-chars-forward "[:alnum:]-")
      (setq $mb (point))
      (cons $ma $mb) ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun letter-shape-shift ()
   "Toggles letter between majiscule and miniscule at cursor point."
   (interactive)

   (let ( (case-fold-search nil) )

      (cond
         ((looking-at "[[:lower:]]")
             (upcase-region (point) (1+ (point))))
         ((looking-at "[[:upper:]]")
             (downcase-region (point) (1+ (point)))) )))

;; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

(defun shape-sweep ()
  "Shifts letters between majuscule and minuscule."
  (interactive)

   (let ( (deactivate-mark nil) $bounds $ma $mb $dbounds $mc $md)

      ;; sets $ma and $mb
      (if (use-region-p)
         ;; -----------------------------------------------------------------------------
         ;; [if] using a region
         (setq $ma (region-beginning) $mb (region-end))
         ;; -----------------------------------------------------------------------------
         ;; [else] not using a region, focus on word
         (save-excursion
            ;; Get bounds for words [:alpha:]
            (setq $bounds (alpha-bounds))
            (setq $ma (car $bounds) $mb (cdr $bounds)) )
         (save-excursion
            ;; get bounds for word ligatures, e.g. "bibl-stockwell-1996"
            (setq $dbounds (alnum-dash-bounds))
            (setq $mc (car $dbounds) $md (cdr $dbounds)) ))

      ;; Prints bounds to the message buffer when sub-string exists.
      (when (string-match-p (regexp-quote "noprint") "print-bounds")
         (message "\n----- gilgamesh-shape-sweep -----")
         (message "Bounds: %s %s %s" $bounds $ma $mb)
         (message "Region: [%s]\n" (buffer-substring $ma $mb)) )

      (when (not (eq last-command this-command))
         (put this-command 'state 0))

      (cond
         ;; ---------------------------------------------------------------------------------
         ((equal 0 (get this-command 'state))
             (gilgamesh-letter-shape-shift)    ;; shifts letter to majuscule or miniscule
             (put this-command 'state 1))
         ;; ---------------------------------------------------------------------------------
         ((equal 1 (get this-command 'state))
             (gilgamesh-letter-shape-shift)    ;; shifts letter to original shape
             (put this-command 'state 2))
         ;; ---------------------------------------------------------------------------------
         ((equal 2 (get this-command 'state))
             (upcase-initials-region $ma $mb)  ;; first letter of each word to majuscule
             (put this-command 'state 3))
         ;; ---------------------------------------------------------------------------------
         ((equal 3 (get this-command 'state))
             (upcase-region $ma $mb)           ;; region to majuscule
             (put this-command 'state 4))
         ;; ---------------------------------------------------------------------------------
         ((equal 4 (get this-command 'state))
             (downcase-region $ma $mb)         ;; region to miniscule
             (put this-command 'state 5))
         ;; ---------------------------------------------------------------------------------
         ((equal 5 (get this-command 'state))
             (downcase-region $mc $md)
             (put this-command 'state 0)) ))





> Sent: Friday, May 07, 2021 at 11:44 AM
> From: "Emanuel Berg via Users list for the GNU Emacs text editor" <help-gnu-emacs@gnu.org>
> To: help-gnu-emacs@gnu.org
> Subject: Re: bounds for strings with - between subwords
>
> Christopher Dimech wrote:
>
> >> > (defun alpha-bounds ()
> >> >    "Gets bounds of a subword unit defined by regular expression [a-zA-Z]."
> >> >    (let ( ($bounds nil) $ma $mb )
> >> >       (skip-chars-backward "[:alpha:]")
> >> >       (setq $ma (point))
> >> >       (skip-chars-forward "[:alpha:]")
> >> >       (setq $mb (point))
> >> >       (setq $bounds (bounds-of-thing-at-point 'word))
> >> >       (cons $ma $mb) ))
> >>
> >> You can put all that in the `let' to avoid the use of `setq'.
> >>
> >> Also $bounds doesn't seem to do anything?
> >
> > bounds are used in another function. You can see there is
> > (cons $ma $mb) at the end,
> > which is used as output when you call "alpha-bounds".
>
> $bounds still isn't used anywhere else and cannot be, either.
>
> >> And what's the purpose of the $?
> >
> > I use $ no tell me the variable is local and not being
> > modified from outside. It is coming from the $1, $2, $3, ...
> > function parameter idea.
>
> But they cannot be modified from the outside so no need to
> worry about that.
>
> --
> underground experts united
> https://dataswamp.org/~incal
>
>
>