> (define myvar 45)
myvar
> myvar
45

　一番、普通のケース。グローバルなスコープ、つまり、どこからでも参照したり変更したりできます。

関数の中で define を使って変数を定義してみます。

> (define (myfunc x)
  (define y 15)
  (+ y x)
)
myfunc
> (define y 0)
y
> (myfunc 10)
25
> y
0

　myfunc の中で define を使って y を定義しています。myfunc の中で値を 15 にしているにもかかわらず、グローバルのyは変更されていないことがわかります。つまり、関数の中で define を使って定義した変数はローカル変数になります。

> (define a 6)
a
> (if nil (define a 1) (define a2))
a
> a
1

　当たり前ですが、if の外側のスコープに定義されます。

　let は、内部ブロック内にだけ通用するローカル変数を定義するもの。このブロックの中でdefineを使ってみた。

> (define c 15)
c
> (let
  ( (a 1) (b 2) )
  (define c 3)
  c
)
3
> c
15    

　define で定義した変数のスコープは、let のブロック(body)中だけであることがわかる。

　もう少し、変な状況

> (define c 15)
c
> (let ( ( a (define c 5) ) (b c) )
    ( list a b c)
)
(c 5 5)
> c
5

　let の変数定義部分では、let の define は外側のスコープに変数を定義します。当然ですね。

　let と同様とは思いますが、ブロック内に書いてみます。

> (define (myfunc x)
   (list 
     (let* ( (a 1) (b 2) )
         (define x 10)
         (list a b x)
     )
    x
  )
)
myfunc
> (myfunc 4)
((1 2 10) 4)

　define で定義した変数のスコープは、let* のブロック(body)中だけであることがわかる。

　let* はローカル変数のバインディングを登場順に行うので、ここに define を書くと変なことが起きそう。

> (define c 0)
c
> (let* ( ( a (define c 5) ) (b c) )
    ( list a b c)
)
(c 5 5)
> c
5
> (set! c 0)
0
> (let* ( ( a 1 ) (b (define c 10)) )
    ( list a b c)
)
(1 c 10)
> c
0

　let* のローカル変数定義の最初にdefine を使った場合は、外側のスコープに定義されるけれど、二番目の変数に定義したものは、ローカルなスコープ内に定義されます。まさに、変なことが起きています。（たぶん、Schemeではこういう書き方自体が許されないと思いますが…）

　let / let* と同様とは思いますが、ブロック内に書いてみます。

> (define (myfunc x)
   (list (letrec ( (a 1) (b 2) )
                 (define c 5)
                 (list a b c)
         )
        x
  )
)
myfunc
> (define c 0)
c
> (myfunc 10)
((1 2 5) 10)
> c
0

　define で定義した変数のスコープは、letrec のブロック(body)中だけであることがわかる。

　lettrec は、ローカル変数の値を決める前に変数をまとめて定義するので、let や let* と動作が異なるようです。

> (define c 0)
c
> (letrec ( ( a (define c 5) ) (b c) )
    ( list a b c)
)

(c 5 5)
> c
0
> (letrec ( ( a 1 ) (b (define c 10)) )
    ( list a b c)
)

(1 c 10)
> c
0

　最初の変数定義に書いた define、二番目に書いた define 共にローカル変数になっていることがわかる。

> (define c 0)
c
> (begin (define c 100) )
c
> c
100

　begin では、特にローカル変数化されないことがわかった。

> (define flag #t)
flag
> (define c 0)
c
> (while flag (define c 15) (print c) (set! flag #f))
15
()
> c
0

　while のブロックの中で define で定義した変数はブロックのローカル変数になる。（MzSchemeでは書けない）

> (define flag #f)
flag
> (define c 0)
c
> (unless flag (define c 15) (print c) (set! flag #t))
15
#t
> c
15

　なんと、while とは違って、unless のブロック内で define で定義した変数はブロックのローカル変数にはならない。調べてみないとわからないものですね。

> (define c 0)
c
> (do ( (flag #f) )
     (flag (list flag c) ) 
     (define c 15) (print c) (set! flag #t)
)
15
(#t 0)
> c
0

　do のブロック内で define で定義した変数はブロックのローカル変数になることがわかる。
　また、値の返却 (list flag c) 時にはスコープが閉じてしまって、ブロックのローカル変数を参照できないことも、興味深い。