This page is part of the web mail archives of SRFI 9 from before July 7th, 2015. The new archives for SRFI 9 contain all messages, not just those from before July 7th, 2015.
I don't think the problem with internal record definitions is in implementation complexity - it's in generativity. If you define a new record type inside a procedure, it is natural to expect the same record type each time you enter the procedure; otherwise the objects you created before won't be recognized by record type predicate: ;; sample enumeration protocol for nonempty sequences: (define (enumerate-stuff state) ;=> obj, {next-state or #f} (define-record-type my-enum-state ...) (if (eq? state #f) ;; start enumeration (values obj1 (make-my-enum-state ...)) ;; continue enumeration (let ((next-state (if (has-next? state) (next-state state) #f))) (values (state-obj state) next-state)))) ;; display all objects: (let loop ([state #f]) (receive (obj next-state) (enumerate-stuff state) (display obj) (if next-state (loop next-state)))) This imaginary enumeration protocol uses opaque state objects existing outside the dynamic scope of enumerate-stuff invokation. To recognize them, my-enum-state should define the same record type each time enumerate-stuff is called.