#lang racket


;; Def'n [Scott, Sect.3.3]: Scope: 
;; The textual region of a program in which a binding is active.
;;
;;
; Syntax of `let`:
; <LetExpr> ->   ( let { <Bindings> }   <Expr> )
;
; <Binding> ->  [ <Id> <Expr> ]
; <Bindings> -> ϵ | <Binding> <Bindings>


(let {[n 3]}
  (+ 3
     (let {[k (* 7 n)]}
       (* k 2))
     n))

; In `let`, the scope of the introduced-bindings is the let's body.

(let {[n 3]}
  (+ 3
     (let {[k 7]}
       (* k
          (let {[j 99]}
            (/ j 3))
          2))
     n))



#|
 
 You can also have shadowing:
[1] (let {[n 3]}
[2]   (let {[n 5]}
[3]     (* n 2)))

returns 10; the binding-occurence on line [2] is what is
  used on line [3];  I'll write "[2] -> [3]"  (non-standard terminology).

[1] (let {[n 3]}
[2]   (+ (let {[n 5]}
[3]         (* n 2)))
[4]      n)
evaluates to 13 -- [2]->[3], and [1]->[4].

So the scope of the `n` on [2] is line [3] (but not [2]).

So the scope of the `n` one line[1] is lines[2]-[4] ...
except we say that the inner `n` "shadows" the outer one, for line[3].





; Lisp/Scheme/Racket have "let*" which corresponds to nested-lets:
; 
;



#| Compare to java -- a very common pitfall for beginners:

class Stuff {
   int[] nums;

   Stuff() {
       int[] nums = new int[365];
       for (int i=0;  i<nums.length;  ++i) {
            nums[i] = 0;
            }
       }


    // Consider also variations of:
    Stuff( int[] _nums ) { nums = _nums; }

   }


// same example, but easier to notice w/o the array obscuring what's happening, perhaps?:
class Stuff {
   int myField;

   Stuff() {
       int myField = 17;
       }

   }

Cf.  `main.java`

|#

void foo( int n ) {
   int n = n * 7;
   ...
   }


|#

(let {[n 3]}
   (+ (let {[n (* n 7)]}
         (* n 2)))
      n)
(define extrafun 99)
(define a 17)
(define b -2)
(define c 3)

(let* {[extrafun (- extrafun 100)]
       [discriminant (- (sqr b) (* 4 a c) extrafun)]
       [numerator (+ (- b) (sqrt discriminant))]
       }
  (/ numerator (* 2 a)))







;;;; scope;  binding-occurrence [the place that *defines* an id];
;;;;         "x occurs free E"
;;;; let's lifting/renaming ("alpha renaming"):
;;;; compare to function body: subst args for params (beta reduction).








; let: the scope of all identifiers is
;  (just) the let's body.
; let*: the scope of an identifer is
;    the let's body, *and* all right-hand-sides following its definition.

;; The scope of each is well-defined.
;; Cf. C:
;;       void foo( int x ) { int x = x; }
;; The meaning of this changed between gcc-3.7.0 and gcc-3.7.1 (?)
;; We'd like well-defined semantics, not just English descriptions!
;;   (But we'll defer that to later.)