How to write a function that handles its argument

Question

I would like to implement a sensible strategy for handling optional arguments. In this instance, I want the function to be as for a function like abbrev-mode (although not in the context of a minor mode):

If called interactively, toggle the ‘Abbrev mode’ mode. If the prefix argument is positive, enable the mode, and if it is zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is ‘toggle’. Enable the mode if ARG is nil, omitted, or is a positive number. Disable the mode if ARG is a negative number.

Have started with this simple implementation.

(defun roto-abbrev (&optional n)
  "Enables words to be expanded as one types."
  (interactive)
  (unless n (setq n 1))
  (abbrev-mode n))

How do I make it behave similar to abbrev-mode function with respect to its argument handling?

Answer 1

It is unclear what is your final goal, but this replicates the behaviour described in the quoted part of your answer. Indeed, it entails the large part of the call-type/prefix combinations, so it could be useful in different contexts.

(defvar my-minor-mode-active nil)
(defun  my-minor-mode-set (activate)
  "Activate my-minor-mode if ACTIVATE is non-nil, else deactivate it."
  (cond
   (activate
    (setq my-minor-mode-active t)
    ;; More initialising code here
    )
   ((not activate)
    (setq my-minor-mode-active nil)
    ;; More deinitialising code here
    )))
(defun f (&optional prefix)
  (interactive "P")
;; Manage user interactive calls
  (when (called-interactively-p 'interactive)
    (cond
     ((null prefix)
      (my-minor-mode-set (not my-minor-mode-active))
      (message (concat "Inter. call with nil prefix, hence the mode is toggled to "
               (if my-minor-mode-active "active." "inactive."))))
 ((> (prefix-numeric-value prefix) 0)
  (my-minor-mode-set t)
  (message "Inter. call with positive prefix, hence the mode is activated."))
 ((<= (prefix-numeric-value prefix) 0)
  (my-minor-mode-set nil)
  (message "Inter. call with non-positive prefix, hence the mode is deactivated."))))


;; Manage Lisp calls (including keyboard macros)
  (when (not (called-interactively-p 'interactive))
    (cond
     ((equal prefix 'toggle)
      (my-minor-mode-set (not my-minor-mode-active))
      (message (concat "Lisp call with 'toggle prefix, hence the mode is toggled to "
               (if (not my-minor-mode-active) "active." "inactive."))))
     ((or (null prefix) (> (prefix-numeric-value prefix) 0))
      (my-minor-mode-set t)
      (message "Lisp call with nil/positive prefix, hence the mode is activated."))
     ((<= (prefix-numeric-value prefix) 0)
      (my-minor-mode-set nil)
      (message "Lisp. call with non-positive prefix, hence the mode is deactivated.")))))

Test is with the lisp calls:

(f 'toggle)
(f)
(f 0)
(f 1)
(f -1)

And with the interactive calls:

M-f
C-u M-f
C-u 0 M-f
C-u 1 M-f
C-u -1 M-f

The requested behaviour of (f 0) is not immediately clear. I am assuming that non-positive prefixes trigger deactivation.

Answer 2

At some point I thought I had understood what the OP wanted and edited the question to reflect that understanding, but the OP demurred and changed it back a bit, so I don't know if this will answer his current question. It is really an answer to the previous form of the question after my edit, but I still think there is a chance that this is really what the OP is after.

The basic idea is that we want a function that handles its argument exactly the way a minor mode does, so we figure out what a "real" minor mode function does and strip way all the minor mode paraphernalia, leaving only the argument handling. But the argument is supposed to enable or disable something, so we emulate this enabling/disabling by defining a variable and set it to t to "enable" or to nil to "disable" whatever it is we are enabling or disabling. For a "real" minor mode, the variable is a buffer-local variable with the same name as the mode function (e.g. abbrev-mode is the name of the mode function and also the name of the mode variable), so we follow that convention.

With that as explanation, here's a minimal function that handles its argument the way the quoted paragraph in the question describes and "enables"/"disables" whatever it is we are trying to enable/disable by setting the corresponding variable. Here's the minimal code:

(defvar-local foo-bar nil)
(defun foo-bar (&optional arg)
    (interactive
     (list
      (if current-prefix-arg
          (prefix-numeric-value current-prefix-arg)
        'toggle)))
(setq foo-bar
        (cond
         ((eq arg 'toggle) (not foo-bar))
         ((and (numberp arg) (< arg 1)) nil)
         (t t)))
foo-bar)

I assume that the variable should be buffer-local here, but it could be made global: just change the defvar-local to defvar. Initially, foo-bar is nil, so it is "disabled".

The tests that @antonio describes in his answer can be used to verify that everything is as it should be: after every test, you can evaluate the foo-bar variable in the appropriate buffer to make sure its value is as expected.

BTW, I did this by macroexpanding a fictitious (define-minor-mode foo-bar "foo-bar docstring") and ruthlessly eliminating everything but the argument handling and the state variable.

Although I hope this will answer the OP's "real" question, I am not holding my breath. Depending on how it goes, I might keep it, amend it or delete it.