Re: [O] Elisp programming style

[Eric Schulte]

Tassilo Horn <address@hidden> writes:

> Thorsten <address@hidden> writes:
>
>>> Too bad you didn't give any concrete examples.
>>
>> The problem can be described easily: 
>>
>> problem-specific helper-funcions (some redundancy avoided)
>> ,-----------------------------------------------------------
>> | (defun main-function (args)                               
>> | (let ((var (assoc :key1 args)))  ; extracting var once
>> | ...                                                       
>> | (helper-function1 ...) ; inside let using var             
>> | (helper-function2 ...) ; inside let using var             
>> | ))                                                        
>> |                                                           
>> | (defun helper-function1 ()                                
>> | ...                                                       
>> | )                                                         
>> |                                                           
>> | (defun helper-function2 ()                                
>> | ...                                                       
>> | )                                                         
>> `-----------------------------------------------------------
>>
>> vs
>>
>> standalone helper-functions (but redundancy)
>> ,-------------------------------------------------------------
>> | (defun main-function (args)                                 
>> | (let ((value (assoc :key1 args))   ; extracting var 1st time
>> | ...                                                         
>> | )                                                           
>> | (helper-function1 ...) ; outside let                        
>> | (helper-function2 ...) ; outside let                        
>> | )                                                           
>> |                                                             
>> | (defun helper-function1 (args)                              
>> | (let ((var (assoc :key1 args)))  ; extracting var 2nd time  
>> | ...                                                         
>> | ))                                                          
>> |                                                             
>> | (defun helper-function2 (args)                              
>> | (let ((var (assoc :key1 args)))  ; extracting var 3rd time  
>> | ...                                                         
>> | ))                                                          
>> `-------------------------------------------------------------
>
> That's still very vague.  If `args' is some structure that has some
> meaning and its parts belong together, say, an org entry, then it makes
> sense to have the helper functions defined on that structure in order to
> provide a consistent interface throughout the library.  And I wouldn't
> tell multiple similar let-bindings duplicate code.
>

To clarify my earlier reply, I would agree with Tassilo above.  If args
is a global variable (declared with defvar or defconst) then using it
without accepting it as an argument is not a problem (and the emacs-lisp
compiler will not complain).

Best -- Eric

-- 
Eric Schulte
http://cs.unm.edu/~eschulte/