Re: Lexically bound macro, with lexically bound transformer

[Taylan Kammer]

On 24.07.2024 19:10, spacecadet wrote:
>> I think the guile-user list might be more appropriate.
> 
> Noted
> 
>>    (let-syntax ((outer (lambda (x) #'(+ 1 2))))
>>      (let-syntax ((inner (lambda (x) (outer x))))
>>        (inner)))
> 
> That works, but I guess this isn't possible then
> 
> (lambda* (#:key outer)
>   (let-syntax ((inner outer))
>     (inner ...)))
> 
> Since that would require evaluating run-time code at compile-time
> 
> Is there a way to write a macro that's expanded at run-time?
> 
> It feels like I'm asking the wrong question now, but I'm
> really looking for a way to bind macros at run-time
> so they can be used functionally
> 
> I guess the right answer is to use functions instead of macros?

Yeah, it's generally a good idea to reserve macros for things that regular 
procedures (functions) simply can't do.

Many things where one thinks of using a macro can be done using a higher-order 
functions instead. (I.e. a procedure that takes another procedure as an 
argument and executes it in some special context.)

For example, let's say I want a way to time (benchmark) code. I could create a 
macro to do it like this:

;; Example code only, may not work properly

(define-syntax time
  (syntax-rules ()
    ((_ body ...)
     (let ((start-time (current-time)))
       body ...
       (- (current-time) start-time)))))

(time
 (do-thing)
 (do-other-thing)
 (very-complicated-thing))

Or I could just use a higher-order function:

(define (time thunk)
  (let ((start-time (current-time)))
    (thunk)
    (- (current-time) start-time)))

(time
  (lambda ()
    (do-thing)
    (do-other-thing)
    (very-complicated-thing)))

-- 
Taylan