Re: extracting serial repeats

[Andreas Röhler]

Anselm Helbig wrote:
> Hi Andreas!
>
>   
>> thanks a lot.
>>
>> Seems I didn't describe the problem well: it's something like: "How to
>> avoid parallel implementing?".
>> Or let's say it that way:
>>
>> Given a serial or serials of lambda-forms which take arguments of the
>> same kind processing it the same way,
>> but differ in function-names, they are referring to.
>>
>> Instead of implementing the same forms repeatedly under different names,
>> we could re-use one.
>>     
>
> So you don't like the macro approach because it's still creating a lot
> of functions internally? If you'd like to share the implementation,
> the code could look like this:
>
>   (defun foo (n a b c)
>     (message "n: %d; a: %s; b: %s; c: %s" n a b c))
>
>   (defun make-foo-function (n)
>     (lexical-let ((lexical-n n))
>       (lambda (a b c)
>         (foo lexical-n a b c))))
>
>   (dotimes (i 22)
>     (fset (intern (format "foo-function-%d" i))
>           (make-foo-function i)))
>
>   (foo-function-21 1 2 3)
>
> I there's anything unclear about this code or the defmacro-approach I
> gave you before, just ask. 
>
>   
>> Can do that by hand, sure. But as the issue shows up occasionaly, a tool
>> doing these extractions might be useful.
>>     
>
> Maybe I didn't get the issue right: you've got repetetive code to
> start with and want to have it refactored automatically?

yes
> It's
> certainly possible to have such functionality, on the other hand, you
> don't have to write repetetive code in lisp in the first place,

yes, rather avoid it. The scenario is: it just happened.
Precisely while writing some tests.

Wrote one form testing a patch,
another form testing another patch,
then remarked the parallels...

Thanks again

Andreas

>  that's
> what macros are for. And, as shown above, you can also use functional
> programming techniques to the same end. 
>
> All the best, 
>
> Anselm
>
>
>