Re: How to implement lexical closures?

On Sat, 15 May 2010 03:52:50 -0400, George Neuner
<gneuner2@comcast.net> wrote:


Our esteemed moderator wrote:


>[PL/I doesn't do garbage collection, so you can't use an entry
>outside the block where its variables were allocated. Looks to
>me like this came straight out of Algol60. -John]


Strictly speaking, GC isn't necessary ... if you are masochistic
enough, closures certainly can be managed manually like any other
program object.


In languages like standard Scheme and ML, which have closures but are
not OO, it is traditional to roll your own objects using closures.
Anonymous closures that represent the "methods" of the "object" are
typically packaged into an array or structure and are accompanied by
named helper functions as in:


    (define (make-queue)
        (let ((head '())
                    (tail '()))
            (vector
                (lambda () head); show function
                (lambda (obj) ; put function
                    (cond
                        ((pair? tail)
                          (set-cdr! tail (cons obj '()))
                          (set! tail (cdr tail)))
                        (#t
                          (set! head (cons obj '()))
                          (set! tail head))
                        ))
                (lambda () ; get function
                    (if (pair? head)
                            (let ((obj (car head)))
                                (set! head (cdr head))
                                  obj)
                            'EMPTY))
                (lambda () ; peek function
                    (if (pair? head)
                            (car head)
                            'EMPTY))
          )))


    (define (queue-show q) ((vector-ref q 0)))
    (define (queue-put q obj) ((vector-ref q 1) obj))
    (define (queue-get q) ((vector-ref q 2)))
    (define (queue-peek q) ((vector-ref q 3)))




A queue object then is an vector of 4 closures which share 'head' and
'tail' variables. Although they share state, the use of closures in
this manner is reasonably self contained and the resulting "object"
can be deleted with the same caveats that exist for deleting any data.


George

Return to the comp.compilers page.
Search the comp.compilers archives again.