This page is part of the web mail archives of SRFI 5 from before July 7th, 2015. The new archives for SRFI 5 contain all messages, not just those from before July 7th, 2015.
sperber@xxxxxxxxxxxxxxxxxxxxxxxxxxx (Michael Sperber [Mr. Preprocessor]) writes: > - You're essentially arguing for replacing R5RS let with the one you propose. > This is totally valid. > > As it SRFI, your proposal is still only a suggestion for an addition to the > language. Why not rename it to something other than let? I proposed SRFI-5 specifically to patch two little holes that I perceived in the R5RS let form, inconsistencies with respect to other R5RS features. I like to think that these little holes are oversights that would have been corrected at the time the named-let and signature-style define features were introduced, had they been noticed. Providing the functionality of SRFI-5's let form under a different name would defeat much of the reason why it was submitted. > This would also make it easier to use for people dealing with legacy code. SRFI-5 is backward-compatible with R5RS's let and uses only one syntactic extension (symbols in the binding list) to implement its two new facets. How serious can a legacy problem be? > - Is there a way to define the construct using standard R5RS macros rather > than explicit renaming (which is only supported by one or two Scheme > systems)? Heh heh, R5RS template-style macros? See bottom. I wouldn't be surprised if a template wizard were able to optimize it a bit, so I'd appreciate it if someone gave it a sound thrashing. Not heavily tested, but it appears to work. Regards, [Ag] Andy Gaynor silver@xxxxxxxxxxxxxxxx _______________________________________________________________________________ (define-syntax let (syntax-rules () ;; In the (let 0 name normals rest arguments body bindings) form: ;; name: The name to assign to the lambda, or #f if none. ;; normals: The normal parameters of the lambda. ;; rest: The rest parameter for the lambda, or () if none. ;; Using () saves a rule for (normal ... . rest). ;; arguments: The arguments to the lambda. ;; body: The body of the lambda. ;; bindings: Bindings remaining to be processed. ;; Terminating cases ;; No name, use an anonymous lambda call ((let 0 #f (normal ...) rest arguments body ()) ((lambda (normal ... . rest) . body) . arguments)) ;; Name, use a letrec and call ((let 0 name (normal ...) rest arguments body ()) (letrec ((name (lambda (normal ... . rest) . body))) (name . arguments))) ;; Deconstructing bindings ;; Shuffle a normal binding ((let 0 name (normal ...) () (argument ...) body ((variable value) . bindings)) (let 0 name (normal ... variable) () (argument ... value) body bindings)) ;; Shuffle a rest binding (its values are shuffled below) ((let 0 name normals () arguments body (rest-variable . rest-values)) (let 0 name normals rest-variable arguments body rest-values)) ;; Shuffle a rest value ((let 0 name normals rest (argument ...) body (rest-value . rest-values)) (let 0 name normals rest (argument ... rest-value) body rest-values)) ;; Top-level interface ;; Straight let, no bindings ((let () . body) (let 0 #f () () () body ())) ;; Straight let, bindings ((let ((variable value) . bindings) . body) (let 0 #f (variable) () (value) body bindings)) ;; Signature-style named let ((let (name . bindings) . body) (let 0 name () () () body bindings)) ;; Non-signature-style named let ((let name bindings . body) (let 0 name () () () body bindings))))