Keywords as function arguments for control flow

Keywords as function arguments for control flow

[Heime via Users list for the GNU Emacs text editor]

How cam one use function arguments that use keywords for 
applying control operations with pcase or cond?

Consider this as example

(defun cuprat (seqr)

    (if (eq seqr 'global)
          (global-whitespace-mode 1)
      (whitespace-mode 1)) )

(cuprat 'global) 

Re: Keywords as function arguments for control flow

[Tassilo Horn]

Heime via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> writes:

> How cam one use function arguments that use keywords for 
> applying control operations with pcase or cond?
>
> Consider this as example
>
> (defun cuprat (seqr)
>
>     (if (eq seqr 'global)
>           (global-whitespace-mode 1)
>       (whitespace-mode 1)) )
>
> (cuprat 'global) 

Your example uses symbols not keywords.  Here are three versions which
just return the keywords :global / :not-global instead of activating a
mode just for better experimentation.  You can replace :global and
:not-global with (global-whitespace-mode 1) and (whitespace-mode 1) to
get your actual function.

--8<---------------cut here---------------start------------->8---
(defun cuprat (seqr)
  (cl-case seqr
    (global   :global)
    ;; Fallback case with `otherwise' or `t'.
    (otherwise :not-global)))

(cuprat 'global)
;;=> :global
(cuprat nil)
;;=> :not-global
(cuprat 'foobar)
;;=> :not-global

(defun cuprat2 (seqr)
  (pcase seqr
    ('global :global)
    (t       :not-global)))

(cuprat2 'global)
;;=> :global
(cuprat2 nil)
;;=> :not-global
(cuprat2 'foobar)
;;=> :not-global

(defun cuprat3 (seqr)
  (cond
   ((eq seqr 'global) :global)
   (t                 :not-global)))

(cuprat3 'global)
;;=> :global
(cuprat3 nil)
;;=> :not-global
(cuprat3 'foobar)
;;=> :not-global
--8<---------------cut here---------------end--------------->8---

You can easily go from symbols (global) to keywords (:global) just by
replacing global with :global in which case you can also drop all
quoting, i.e., 'global becomes just :global.

Bye,
Tassilo

RE: [External] : Re: Keywords as function arguments for control flow

[Drew Adams]

> Your example uses symbols not keywords.

And one can Ask Emacs.  This is what the Elisp manual
has to say about keywords:

  A symbol whose name starts with a colon (':') is
  called a keyword symbol. These symbols automatically
  act as constants, and are normally used only by
  comparing an unknown symbol with a few specific
  alternatives. See "Variables that Never Change".

https://www.gnu.org/software/emacs/manual/html_node/elisp/Symbol-Type.html

That "Variables that Never Change" link takes you here:

https://www.gnu.org/software/emacs/manual/html_node/elisp/Constant-Variables.html

where it says this:

  Function: keywordp object ¶
  function returns t if object is a symbol whose
  name starts with ':', interned in the standard
  obarray, and returns nil otherwise.

RE: [External] : Re: Keywords as function arguments for control flow

[Heime via Users list for the GNU Emacs text editor]

On Saturday, November 30th, 2024 at 9:06 AM, Drew Adams <drew.adams@oracle.com> wrote:

> > Your example uses symbols not keywords.

Correct.  But because there was the suggestion of keywords, I thought
of looking into them as well.  It seems that the only difference in
using :this rather than 'this.  Symbol checking with pcase is 

(pcase some-variable

  ('this (do-something))

and for keywords it would be

(pcase some-variable

  (:this (do-something))

Can one just pass :tabtail as an argument to a function?

In my case, would this be as so?

  (poulatuk '(72 :tabtrail :global)) 

> And one can Ask Emacs. This is what the Elisp manual
> has to say about keywords:
> 
> A symbol whose name starts with a colon (':') is
> called a keyword symbol. These symbols automatically
> act as constants, and are normally used only by
> comparing an unknown symbol with a few specific
> alternatives. See "Variables that Never Change".
> 
> https://www.gnu.org/software/emacs/manual/html_node/elisp/Symbol-Type.html
> 
> That "Variables that Never Change" link takes you here:
> 
> https://www.gnu.org/software/emacs/manual/html_node/elisp/Constant-Variables.html
> 
> where it says this:
> 
> Function: keywordp object ¶
> function returns t if object is a symbol whose
> name starts with ':', interned in the standard
> obarray, and returns nil otherwise.

Re: Keywords as function arguments for control flow

[Jean Louis]

(defun cuprat (seqr)
  (pcase seqr
    ('global (global-whitespace-mode 1))  ;; if seqr is 'global
    (_ (whitespace-mode 1))))             ;; default case for other values

(cuprat 'global)
(cuprat 'other)


Explanation

pcase matches the argument seqr to specific patterns (like 'global).

If seqr is 'global, it applies (global-whitespace-mode 1).

The underscore (_) is a catch-all pattern that matches anything else, so in that case, (whitespace-mode 1) is called.


(defun cuprat (seqr)
  (cond
   ((eq seqr 'global) (global-whitespace-mode 1))  ;; if seqr is 'global
   (t (whitespace-mode 1))))                        ;; default case for other values

(cuprat 'global)
(cuprat 'other)


Explanation

The cond form evaluates each condition in order.

The first condition checks if seqr is 'global, and if so, it runs (global-whitespace-mode 1).

The (t ...) clause is a fallback that handles all other cases, applying (whitespace-mode 1).


Personally I have not ever used pcase



Jean

Re: Keywords as function arguments for control flow

[Heime via Users list for the GNU Emacs text editor]

Sent with Proton Mail secure email.

On Saturday, November 30th, 2024 at 11:47 PM, Jean Louis <bugs@gnu.support> wrote:

> (defun cuprat (seqr)
> (pcase seqr
> ('global (global-whitespace-mode 1)) ;; if seqr is 'global
> (_ (whitespace-mode 1)))) ;; default case for other values
> 
> (cuprat 'global)
> (cuprat 'other)
> 
> 
> Explanation
> 
> pcase matches the argument seqr to specific patterns (like 'global).
> 
> If seqr is 'global, it applies (global-whitespace-mode 1).
> 
> The underscore (_) is a catch-all pattern that matches anything else, so in that case, (whitespace-mode 1) is called.
> 
> 
> (defun cuprat (seqr)
> (cond
> ((eq seqr 'global) (global-whitespace-mode 1)) ;; if seqr is 'global
> (t (whitespace-mode 1)))) ;; default case for other values
> 
> (cuprat 'global)
> (cuprat 'other)
> 
> 
> Explanation
> 
> The cond form evaluates each condition in order.
> 
> The first condition checks if seqr is 'global, and if so, it runs (global-whitespace-mode 1).
> 
> The (t ...) clause is a fallback that handles all other cases, applying (whitespace-mode 1).
> 
> 
> Personally I have not ever used pcase - Jean

I have used both.  The question is about how to pass keywords 
(i.e. with :something) as function arguments. 

Re: Keywords as function arguments for control flow

[Jean Louis]

(defun cuprat (args)
  (let ((seqr (plist-get args :seqr)))
    (cond
     ((eq seqr 'global) (global-whitespace-mode 1))  ;; if seqr is 'global
     (t (whitespace-mode 1)))))                      ;; default case for other values

(cuprat '(:seqr global))  ;; Pass the :seqr keyword as part of the plist
(cuprat '(:seqr other))   ;; Pass the :seqr keyword with a different value

Jean