how does optional argument `ALLOW-EXTEND` in `mark-word` work?

Question

I am switching from VIM to Emacs for just a couple weeks and trying to write some Elisp. Having difficulties to adapt, I am exploring different options to do marking and reached this function.

(defun mark-word (&optional arg allow-extend)                          
  "Set mark ARG words away from point.                                 
The place mark goes is the same place \\[forward-word] would           
move to with the same argument.                                        
Interactively, if this command is repeated                             
or (in Transient Mark mode) if the mark is active,                     
it marks the next ARG words after the ones already marked."            
  (interactive "P\np")                                                 
  (cond ((and allow-extend                                             
              (or (and (eq last-command this-command) (mark t))        
                  (region-active-p)))                                  
         (setq arg (if arg (prefix-numeric-value arg)                  
                     (if (< (mark) (point)) -1 1)))                    
         (set-mark                                                     
          (save-excursion                                              
            (goto-char (mark))                                         
            (forward-word arg)                                         
            (point))))                                                 
        (t                                                             
         (push-mark                                                    
          (save-excursion                                              
            (forward-word (prefix-numeric-value arg))                  
            (point))                                                   
          nil t))))                                                    

it's pretty straight forward except allow-extend. It seems to me for this function to work, allow-extend needs to be empty. But when we do interaction, we don't really provide any prefix key to it.

So why would allow-extend be non nil in this case? Also how does "P\np" work here?

Answer 1

As @db48x pointed out, indeed C-u passes in 2 arguments down to the function if it's pressed, but it wouldn't be the case if it's not pressed in the first place.

The trick here is the second argument is p, lower case. That converts the second argument to a number when called by call-interactively regardless, which has no chance to be nil.

Examination,

M-: (defun try-it (&optional a b) (interactive "P\np") (message "a is %s and b is %s" a b))

then

M-x try-it

gives

a is nil and b is 1

while

C-u M-x try-it 

gives

a is (4) and b is 4  

Answer 2

The interactive declaration specifies that the function wants two arguments. The code letters for the arguments are P and p. If we examine the help for interactive (by typing C-h f interactive <RET>), we can see what these mean:

p -- Prefix arg converted to number.  Does not do I/O.
P -- Prefix arg in raw form.  Does not do I/O.

This means that the single prefix arg is passed to mark-word twice; first in raw form (it's a list of numbers, as I recall), then in the form of an integer.

Edit: of course, a non-interactive caller can provide any args they want, so while this command always gets a number (which is always a true value) when called interactively, there might be non-interactive callers that pass in nil to turn off that behavior. I did not consider, when I wrote this answer, that this might be not be obvious.