[NonGNU ELPA] Loopy version 0.15.0

Version 0.15.0 of package Loopy has just been released in NonGNU ELPA.
You can now find it in M-x list-packages RET.

Loopy describes itself as:

  ===============
  A looping macro
  ===============

More at https://elpa.nongnu.org/nongnu/loopy.html

## Summary:

		   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
		    LOOPY: A LOOPING AND ITERATION MACRO
		   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━


  [file:https://elpa.nongnu.org/nongnu/loopy.svg]
  [file:https://elpa.nongnu.org/nongnu-devel/loopy.svg]
  [file:https://melpa.org/packages/loopy-badge.svg]
  [file:https://stable.melpa.org/packages/loopy-badge.svg]

  ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――

  `loopy' is a macro meant for iterating and looping.  It is similar in
  usage to [`cl-loop'] but uses symbolic expressions rather than keywords.

  For most use cases, `loopy' should be a nice substitute for `cl-loop'
  and complementary to the features provided by the [Seq] and [CL]
  libraries and Emacs's regular looping and mapping features.

## Recent NEWS:

# CHANGELOG

This document describes the user-facing changes to Loopy.

For Loopy Dash, see <https://github.com/okamsn/loopy-dash>.

## 0.15.0

### New Features

- Add the `override` special macro argument, which can be used to override
  select global settings for the current macro expansion ([#243], [#231]).  This
  can help to avoid name collisions from package authors (separate authors of
  separate packages) wanting to use the same command name for different purposes
  with their respective package.

### Bug Fixes

- `when` and `unless` now correctly work when aliased ([#234], [#240]).
- Fix variable scoping when using `set` with `at` ([#241]).

### Breaking Changes

- Loopy now requires at least Emacs version 28.1, increased from version 27.1
  ([#446]).  This allows us to remove workarounds for missing features/fixes.

- `set` now warns when it is not given a value ([#229]).  Currently, `(set VAR)`
  binds `VAR` to `nil`, but since this form is indistinguishable from a mistake,
  and since `nil` is a short word to write, this behavior is deprecated.

- Some variables were combined to simplify the code internally and make it
  easier to add local overrides in the future, which will make code which custom
  commands more portable.

  - `loopy-command-parsers` and `loopy-aliases` are both deprecated in favor of
    the newly added `loopy-parsers` ([#237]).  The new user option is a hash
    table which maps symbols to parsing functions.  There is no longer a
    separate mapping of aliases to original names.  However, `loopy-defalias`
    will continue to work.

  - `loopy-iter-bare-special-marco-arguments` and `loopy-iter-bare-commands` are
    both deprecated in favor of the newly added `loopy-iter-bare-names` ([#242],
    [#238]). The new user option is a list which by default contains all symbols
    previously listed in the old variables.

- Separate `when` and `unless` commands to have different parsing functions
  ([#234], [#240]).  The old implementation used the name of the command in the
  generated code and was written before aliases.

- The macro by default now uses the value of `loopy-result` as the implied
  return value when `loopy-result` is used as an implied accumulation variable
  and `finally-do` is used ([#244]).  Previously, the macro would store the
  implied return value in `loopy-result` when `loopy-result` was used as an
  implied accumulation variable, but any further changes made to `loopy-result`
  after the loop completed in the `finally-do` special macro argument
  would not be included in the macro's ultimate return value.

  This was inconsistent with modifying `loopy-result` in the `after-do` special
  macro argument, in which case the modification /was/ included in the implied
  return value.

  The new behavior should be less confusing in the event that a user does modify
  `loopy-result` in `finally-do`. Previously, one would have needed to use
  `finally-return` after modifying an implied `loopy-result`. The cost is
  switching from the use of `prog1` to an `if` expression with two helper
  variables.  This change only applies when an implied return value is used with
  `finally-do`.  It does not affect the macro expansion when `finally-return` is
  used.

  ```emacs-lisp
  ;; Previously required way:
  ;; => (0 1 2 3)
  (loopy (list i '(1 2 3))
         (collect i)
         (finally-do (push 0 loopy-result))
         (finally-return loopy-result))

  ;; Now, `finally-return' is not required:
  ;; => (0 1 2 3)
  (loopy (list i '(1 2 3))
         (collect i)
         (finally-do (push 0 loopy-result)))
  ```

  This is technically a breaking change for those who were modifying an implied
  `loopy-result` but did not wish those changes to be captured in the macro's
  implied return value nor used in `finally-return` (perhaps changing the value
  for side effects only).

- `loopy-default-flags` is now deprecated ([#245]).  This prevents one library
  from breaking the macro expansions in another library.  Instead of using
...
...