consecutive 'let

[Yaroslav Kavenchuk <kavenchuk at jenty dot by>]

In macro - analog CL's 'time:

(define-syntax time
 (syntax-rules ()
   ((time expression)
    (let ((mem-bean :: <java.lang.management.MemoryMXBean>
           (java.lang.management.ManagementFactory:getMemoryMXBean)))
      (mem-bean:gc) (mem-bean:gc) (mem-bean:gc) ;; Why? I do not know :)
      (let ((begin-time :: <gnu.math.IntNum> 
(java.lang.System:currentTimeMillis))
            (begin-non-heap-memo :: <java.lang.management.MemoryUsage> 
(mem-bean:getNonHeapMemoryUsage))
            (begin-heap-memo :: <java.lang.management.MemoryUsage> 
(mem-bean:getHeapMemoryUsage))
            (ret expression)
            (end-heap-memo :: <java.lang.management.MemoryUsage> 
(mem-bean:getHeapMemoryUsage))
            (end-non-heap-memo :: <java.lang.management.MemoryUsage> 
(mem-bean:getNonHeapMemoryUsage))
            (end-time :: <gnu.math.IntNum> 
(java.lang.System:currentTimeMillis)))
        (format #t "Value: ~A\n" ret)
        (format #t "Duration: ~A sec.\n" (/ (- end-time begin-time) 
1000.0))
        (format #t "Memory usage:\n  Heap memory:\n")
        (format #t "    init:      ~A\n" (- end-heap-memo:init 
begin-heap-memo:init))
        (format #t "    used:      ~A\n" (- end-heap-memo:used 
begin-heap-memo:used))
        (format #t "    committed: ~A\n" (- end-heap-memo:committed 
begin-heap-memo:committed))
        (format #t "    max:       ~A\n" (- end-heap-memo:max 
begin-heap-memo:max))
        (format #t "  Non heap memory:\n")
        (format #t "    init:      ~A\n" (- end-non-heap-memo:init 
begin-non-heap-memo:init))
        (format #t "    used:      ~A\n" (- end-non-heap-memo:used 
begin-non-heap-memo:used))
        (format #t "    committed: ~A\n" (- end-non-heap-memo:committed 
begin-non-heap-memo:committed))
        (format #t "    max:       ~A\n" (- end-non-heap-memo:max 
begin-non-heap-memo:max)))
      (mem-bean:gc)))))

I can rely on consistent second 'let? Or I should write so:

(define-syntax time
 (syntax-rules ()
   ((time expression)
    (let ((mem-bean :: <java.lang.management.MemoryMXBean>
           (java.lang.management.ManagementFactory:getMemoryMXBean))
          (begin-time :: <gnu.math.IntNum> 0)
          (begin-non-heap-memo :: <java.lang.management.MemoryUsage> 
#!null)
          (begin-heap-memo :: <java.lang.management.MemoryUsage> #!null)
          (ret ())
          (end-heap-memo :: <java.lang.management.MemoryUsage> #!null)
          (end-non-heap-memo :: <java.lang.management.MemoryUsage> #!null)
          (end-time :: <gnu.math.IntNum> 0))
      (mem-bean:gc) (mem-bean:gc) (mem-bean:gc) ;; Why? I do not know :)
      (set! begin-time (java.lang.System:currentTimeMillis))
      (set! begin-non-heap-memo (mem-bean:getNonHeapMemoryUsage))
      (set! begin-heap-memo (mem-bean:getHeapMemoryUsage))
      (set! ret expression)
      (set! end-heap-memo (mem-bean:getHeapMemoryUsage))
      (set! end-non-heap-memo (mem-bean:getNonHeapMemoryUsage))
      (set! end-time (java.lang.System:currentTimeMillis))
      (format #t "Value: ~A\n" ret)
      (format #t "Duration: ~A sec.\n" (/ (- end-time begin-time) 1000.0))
      (format #t "Memory usage:\n  Heap memory:\n")
      (format #t "    init:      ~A\n" (- end-heap-memo:init 
begin-heap-memo:init))
      (format #t "    used:      ~A\n" (- end-heap-memo:used 
begin-heap-memo:used))
      (format #t "    committed: ~A\n" (- end-heap-memo:committed 
begin-heap-memo:committed))
      (format #t "    max:       ~A\n" (- end-heap-memo:max 
begin-heap-memo:max))
      (format #t "  Non heap memory:\n")
      (format #t "    init:      ~A\n" (- end-non-heap-memo:init 
begin-non-heap-memo:init))
      (format #t "    used:      ~A\n" (- end-non-heap-memo:used 
begin-non-heap-memo:used))
      (format #t "    committed: ~A\n" (- end-non-heap-memo:committed 
begin-non-heap-memo:committed))
      (format #t "    max:       ~A\n" (- end-non-heap-memo:max 
begin-non-heap-memo:max))
      (mem-bean:gc)))))

And maybe I "invented the bicycle"? :)

--
WBR, Yaroslav Kavenchuk.