Re: Define in let

[Panicz Maciej Godek]

2013/8/20 David Pirotte <address@hidden>

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)))))