2013/8/20 David Pirotte <david@altosw.be>

> Hello,
>
> > It seems following is invalid:
> >
> >    (let ((a 2))
> >         (define (foo x) (+ a x)))
> >
> > I prefer to reduce scope of variable as much as possible, so
> > I find this restriction unconvinent. Is is part of standard or technical
> > limitation? Is it any workaround?
>

The Scheme's idiomatic way to achieve the effect that you
probably want would be
(define foo #f)
(let ((a 2))
  (set! foo (lambda (x) (+ a x))))

Although it allows to achieve the desired effect, it doesn't
express the programmer's intention quite clearly.
If you're interested, I recently wrote a macro that would
allow to get the same in a IMHO slightly more elegant way, i.e.

(publish
  (define (foo x) (+ a x))
 where
  (define a 2))

The macro's definition (procedural) follows.
Regards.

=============================
(define-macro (publish . definitions)
  (define (interface-name interface)
    (match interface
      ((head . tail)
       (interface-name head))
      ((? symbol? name)
       name)))
  (let-values (((public-definitions where&private-definitions)
                (split-before (equals? 'where) definitions)))
    `(begin ,@(map (match-lambda
                       ((define-variant interface . body)
                        `(define ,(interface-name interface) #f)))
                   public-definitions)
            (let ()
              ,@(match where&private-definitions
                  (('where . private-definitions)
                   private-definitions)
                  (() '()))
              ,@(map (match-lambda
                         ((define-variant interface . body)
                          (let ((name (interface-name interface)))
                            `(set! ,name
                                   (let ()
                                     (,define-variant ,interface . ,body)
                                     ,name)))))
                     public-definitions)))))