-> (define intro (make-introducer))
intro
-> (define Ai ((intro 'first) 'A))
ai
-> (define Bi ((intro 'first) 'B))
bi
-> ((intro 'second) 'A Ai Bi)
#f
-> ((intro 'second) 'B Bi Ai)
#f  ; should be A

(define (make-introducer)

  (define table '())
  (define counter 0)

  (define (allot pair)
    (set! counter (+ counter 1))
    (set! table (cons (cons counter pair) table))
    counter)

  (define (unallot n)
    (set! table (filter (lambda (entry)
                          (not (= (car entry) n)))
                        table)))

  (define  (at n)
    (cond ((assv n table) => cdr)
          (else #f)))

  (define (match? pair ref index)
    (write (list "m?" pair ref index))
    (and pair
         (begin (write "gdd") #t)
         (eq? ref (car pair))
         (begin (write "gde") #t)
         (= index (cdr pair))
         (begin (write "gdf") #t)
         ))

    (define (self message)
     (case message
       ((first)
        (lambda (r)
          (allot (cons r -1))))
       ((second)
        (lambda (r m h)
          (write (list "table is" table))
          (let ((at-m (at m)) (at-h (at h)))
            (write (list r m h at-m at-h))
            (if (and (match? at-m r -1) at-h)
                (cond ((= (cdr at-h) m)
                       (unallot m)
                       (unallot h)
                       (car at-h))
                      ((= (cdr at-h) -1)
                       (set-cdr! at-m h)
                       #f)
                      (else #f))
                #f))))))

  self)

(define (filter ok? ls)
  (cond ((null? ls) '())
        ((ok? (car ls))
         (cons (car ls) (filter ok? (cdr ls))))
        (else (filter ok? (cdr ls)))))