subsection3.xml

<SUBSECTION>
  <NAME>
    Evaluator Data Structures
  </NAME>

  <LABEL NAME="sec:eval-data-structures"/>
  <TEXT>
    In addition to defining the external syntax of expressions, the
    evaluator implementation must also define the data structures that the
    evaluator manipulates internally, as part of the execution of a
    program, such as the representation of
    <SPLITINLINE>
      <SCHEME>procedures</SCHEME>
      <JAVASCRIPT>functions</JAVASCRIPT>
    </SPLITINLINE>
    and environments and the representation of true and false.
  </TEXT>

  <SUBHEADING>
    <NAME>Testing of predicates</NAME>
  </SUBHEADING>


  <INDEX>metacircular evaluator for Scheme
  <SUBINDEX>representation of true and false</SUBINDEX></INDEX>

  <TEXT>
    <SPLIT>
      <SCHEME>
	For conditionals, we accept anything to be true that is not the explicit
	<SCHEMEINLINE>false</SCHEMEINLINE> object.
      </SCHEME>
      <JAVASCRIPT>
	To enter the consequent of a conditional, we expect the predicate to
	evaluate to the value <JAVASCRIPTINLINE>true</JAVASCRIPTINLINE>, and
	thus we define the evaluator function
	<JAVASCRIPTINLINE>is_true</JAVASCRIPTINLINE> as follows:
      </JAVASCRIPT>
    </SPLIT>
    <SNIPPET PAGE="365" HIDE="yes" EVAL="no">
      <NAME>headline_4_1_3</NAME>
      <JAVASCRIPT>
// functions from SICP JS 4.1.3
      </JAVASCRIPT>
    </SNIPPET>
    <SNIPPET PAGE="377">
      <NAME>true</NAME>
      <EXAMPLE>true_example</EXAMPLE>
      <EXPECTED>false</EXPECTED>
      <SCHEME>
(define (true? x)
  (not (eq? x false)))

(define (false? x)
  (eq? x false))
      </SCHEME>
      <JAVASCRIPT>
function is_true(x) {
    return x === true;
}
      </JAVASCRIPT>
    </SNIPPET>
    <SNIPPET PAGE="377" HIDE="yes">
      <NAME>true_example</NAME>
      <JAVASCRIPT>
is_true(1); // should return false because only true is true
      </JAVASCRIPT>
    </SNIPPET>
    With the definition of the function
    <JAVASCRIPTINLINE>eval_conditional_expression</JAVASCRIPTINLINE> of
    section<SPACE/><REF NAME="sec:core-of-evaluator"/>, this means that our
    evaluator evaluates the alternative statement for any predicate value other
    than <JAVASCRIPTINLINE>true</JAVASCRIPTINLINE>.
  </TEXT>

  <SUBHEADING>
    <NAME>Representing
    <SPLITINLINE>
      <SCHEME>procedures</SCHEME>
    <JAVASCRIPT>functions</JAVASCRIPT></SPLITINLINE>
    </NAME>
  </SUBHEADING>

  <INDEX>metacircular evaluator for Scheme<SUBINDEX>representation of
  <SPLITINLINE><SCHEME>procedures</SCHEME>
  <JAVASCRIPT>functions</JAVASCRIPT></SPLITINLINE></SUBINDEX></INDEX>

  <TEXT>
    To handle primitives, we assume that we have available the following
    <SPLITINLINE>
      <SCHEME>procedures:</SCHEME>
      <JAVASCRIPT>functions:</JAVASCRIPT>
    </SPLITINLINE>
    <UL>
      <LI>
	<!--  \indcode{apply-primitive-procedure} -->
	<SPLITINLINE>
	  <SCHEME>
	    <SCHEMEINLINE>(apply-primitive-procedure</SCHEMEINLINE>
	    <LATEXINLINE>proc args</LATEXINLINE><SCHEMEINLINE>)</SCHEMEINLINE>
	  </SCHEME>
	  <JAVASCRIPT>
	    <JAVASCRIPTINLINE>apply_primitive_function(</JAVASCRIPTINLINE>
	    <LATEXINLINE>$\textit{fun}$, $\textit{args}$</LATEXINLINE>
	    <JAVASCRIPTINLINE>)</JAVASCRIPTINLINE>
	  </JAVASCRIPT>
	</SPLITINLINE>
	<BREAK/>
	applies the given primitive
	<SPLITINLINE>
	  <SCHEME>procedure</SCHEME>
	  <JAVASCRIPT>function</JAVASCRIPT>
	</SPLITINLINE>
	to the argument values in the list
	<LATEXINLINE>$\textit{args}$</LATEXINLINE> and returns the result of
	the application.
      </LI>
      <LI>
	<!--  \indcode{primitive-procedure?} -->
        <SPLITINLINE>
	  <SCHEME><SCHEMEINLINE>(primitive-procedure?</SCHEMEINLINE>
	  <LATEXINLINE>proc</LATEXINLINE><SCHEMEINLINE>)</SCHEMEINLINE></SCHEME>
	  <JAVASCRIPT>
	    <JAVASCRIPTINLINE>is_primitive_function(</JAVASCRIPTINLINE><LATEXINLINE>$\textit{fun}$</LATEXINLINE><JAVASCRIPTINLINE>)</JAVASCRIPTINLINE>
	  </JAVASCRIPT>
	</SPLITINLINE>
	<BREAK/>
	tests whether
	<SPLITINLINE>
	  <SCHEME><LATEXINLINE>proc</LATEXINLINE></SCHEME>
          <JAVASCRIPT><LATEXINLINE>$\textit{fun}$</LATEXINLINE></JAVASCRIPT>
	</SPLITINLINE>
        is a primitive
        <SPLITINLINE>
          <SCHEME>procedure.</SCHEME>
          <JAVASCRIPT>function.</JAVASCRIPT>
        </SPLITINLINE>
      </LI>
    </UL>

    These mechanisms for handling primitives are further described in
    section<SPACE/><REF NAME="sec:running-eval"/>.
  </TEXT>

  <TEXT>
    Compound
    <SPLITINLINE>
      <SCHEME>procedures</SCHEME>
      <JAVASCRIPT>functions</JAVASCRIPT>
    </SPLITINLINE>
    are constructed from parameters,
    <SPLITINLINE>
      <SCHEME>procedure</SCHEME>
      <JAVASCRIPT>function</JAVASCRIPT>
    </SPLITINLINE>
    bodies, and environments using the constructor 
    <SPLITINLINE>
      <SCHEME><SCHEMEINLINE>make-procedure</SCHEMEINLINE>:</SCHEME>
      <JAVASCRIPT><JAVASCRIPTINLINE>make_function</JAVASCRIPTINLINE>:
      </JAVASCRIPT>
    </SPLITINLINE>
    <SNIPPET PAGE="377">
      <NAME>make_procedure</NAME>
      <REQUIRES>tagged_list</REQUIRES>
      <EXAMPLE>make_procedure_example</EXAMPLE>
      <EXPECTED>[ 'x', [ 'y', null ] ]</EXPECTED>
      <SCHEME>
(define (make-procedure parameters body env)
  (list \&apos;procedure parameters body env))

(define (compound-procedure? p)
  (tagged-list? p \&apos;procedure))

(define (procedure-parameters p) (cadr p))
(define (procedure-body p) (caddr p))
(define (procedure-environment p) (cadddr p))
      </SCHEME>
      <JAVASCRIPT>
function make_function(parameters, body, env) {
    return list("compound_function",
                parameters, body, env);
}
function is_compound_function(f) {
    return is_tagged_list(f, "compound_function");
}
function function_parameters(f) {
    return list_ref(f, 1);
}
function function_body(f) {
    return list_ref(f, 2);
}
function function_environment(f) {
    return list_ref(f, 3);
}
      </JAVASCRIPT>
    </SNIPPET>
    <SNIPPET PAGE="377"  HIDE="yes">
      <NAME>make_procedure_example</NAME>
      <REQUIRES>enclosing_environment</REQUIRES>
      <JAVASCRIPT>
const my_function = 
    make_function(
        list("x", "y"),
        list("return_statement", parse("x + y;")),
        the_empty_environment);
display(is_compound_function(my_function));
display(function_parameters(my_function));
display(function_body(my_function));
display(function_environment(my_function));
      </JAVASCRIPT>
      <JAVASCRIPT_TEST>
const my_function = 
    make_function(
        list("x", "y"),
        list("return_statement", parse("x + y;")),
        the_empty_environment);
is_compound_function(my_function);
function_body(my_function);
function_environment(my_function);
function_parameters(my_function);
      </JAVASCRIPT_TEST>
    </SNIPPET>
  </TEXT>

  <SPLIT>
    <SCHEME>
    </SCHEME>
    
    <JAVASCRIPT>
      
      <SUBHEADING>
	<NAME>Representing return values</NAME>
      </SUBHEADING>

      <TEXT>
	We saw in section<SPACE/><REF NAME="sec:core-of-evaluator"/> that the
	evaluation of sequences terminates when the first return statement
	encountered, and that the evaluation of function applications needs to
	return the value <JAVASCRIPTINLINE>undefined</JAVASCRIPTINLINE> if the
	evaluation of the function body does not encounter a
	<JAVASCRIPTINLINE>return</JAVASCRIPTINLINE> statement. In order to
	identify the evaluation of <JAVASCRIPTINLINE>return</JAVASCRIPTINLINE>
	statements, we introduce <JAVASCRIPTINLINE>return</JAVASCRIPTINLINE>
	values as evaluator data structures.
	<SNIPPET PAGE="366">
	  <NAME>return_value</NAME>
	  <REQUIRES>tagged_list</REQUIRES>
	  <EXAMPLE>return_value_example</EXAMPLE>
	  <EXPECTED>42</EXPECTED>
	  <JAVASCRIPT>
function make_return_value(content) {
    return list("return_value", content);
}
function is_return_value(value) {
    return is_tagged_list(value, "return_value");
}
function return_value_content(value) {
    return head(tail(value));
}
	  </JAVASCRIPT>
	</SNIPPET>
	<SNIPPET PAGE="377"  HIDE="yes">
	  <NAME>return_value_example</NAME>
	  <REQUIRES>enclosing_environment</REQUIRES>
	  <JAVASCRIPT>
const my_return_value = make_return_value(42);
display(is_return_value(my_return_value));
display(return_value_content(my_return_value));
	  </JAVASCRIPT>
	  <JAVASCRIPT_TEST>
const my_return_value = make_return_value(42);
is_return_value(my_return_value);
return_value_content(my_return_value);
	  </JAVASCRIPT_TEST>
	</SNIPPET>
      </TEXT>
    </JAVASCRIPT>
  </SPLIT>

  <SUBHEADING>
    <NAME>Operations on Environments</NAME>
  </SUBHEADING>

  <LABEL NAME="sec:operations-on-environments"/>
  <INDEX>metacircular evaluator for Scheme
  <SUBINDEX>environment operations</SUBINDEX></INDEX>
  <TEXT>
    The evaluator needs operations for manipulating environments.  As explained
    in section<SPACE/><REF NAME="sec:environment-model"/>, an environment is a
    sequence of frames, where each frame is a table of bindings that associate
    <SPLITINLINE>
      <SCHEME>variables</SCHEME>
      <JAVASCRIPT>names</JAVASCRIPT>
    </SPLITINLINE>
    with their corresponding values.  We use the following operations for
    manipulating environments:
    <SPLIT>
      <SCHEME>
	<UL>
	  <!--  \indcode{lookup-variable-value} -->
	  <LI>
	    <SCHEMEINLINE>(lookup-variable-value </SCHEMEINLINE>
	    <LATEXINLINE>var env</LATEXINLINE><SCHEMEINLINE>)</SCHEMEINLINE>
	  <P>
	    returns the value that is bound to the symbol
	    <LATEXINLINE>var</LATEXINLINE> in the environment
	    <LATEXINLINE>env</LATEXINLINE>, or signals an error if the variable
	    is unbound.
	  </P>
	  </LI>
	  <LI>
	    <!--  \indcode{extend-environment} -->
	    <SCHEMEINLINE>(extend-environment </SCHEMEINLINE>
	    <LATEXINLINE>variables values base-env</LATEXINLINE>
	    <SCHEMEINLINE>)</SCHEMEINLINE>
	    <P>
	      returns a new environment, consisting of a new frame in which the
	      symbols in the list <LATEXINLINE>variables</LATEXINLINE> are bound
	      to the corresponding elements in the list
	      <LATEXINLINE>values</LATEXINLINE>, where the enclosing environment
	      is the environment <LATEXINLINE>base-env</LATEXINLINE>.
	    </P>
	  </LI>
	  <LI>
	    <!--  \indcode{define-variable!} -->
	    <SCHEMEINLINE>(define-variable! </SCHEMEINLINE>
	    <LATEXINLINE>var value env</LATEXINLINE>
	    <SCHEMEINLINE>)</SCHEMEINLINE>
	    <P>
	      adds to the first frame in the environment
	      <LATEXINLINE>env</LATEXINLINE> a new binding that associates the
	      variable <LATEXINLINE>var</LATEXINLINE> with the value
	      <LATEXINLINE>value</LATEXINLINE>.
	    </P>
	  </LI>
	  <LI>
	    <!--  \indcode{set-variable-value!} -->
	    <SCHEMEINLINE>(set-variable-value! </SCHEMEINLINE>
	    <LATEXINLINE>var value env</LATEXINLINE>
	    <SCHEMEINLINE>)</SCHEMEINLINE>
	    <P>
	      changes the binding of the variable <LATEXINLINE>var</LATEXINLINE>
	      in the environment <LATEXINLINE>env</LATEXINLINE> so that the
	      variable is now bound to the value
	      <LATEXINLINE>value</LATEXINLINE>, or signals an error if the
	      variable is unbound.
	    </P>
	  </LI>

	</UL>
      </SCHEME>
      <JAVASCRIPT>
	<UL>
	  <!--  \indcode{lookup-variable-value} -->
	  <LI>
	    <JAVASCRIPTINLINE>lookup_symbol_value(</JAVASCRIPTINLINE>
	    <LATEXINLINE>$\textit{symbol}$</LATEXINLINE>,
	    <LATEXINLINE>$\textit{env}$</LATEXINLINE>
	    <JAVASCRIPTINLINE>)</JAVASCRIPTINLINE>
	  <BREAK/>
	  returns the value that is bound to the
	  <LATEXINLINE>$\textit{symbol}$</LATEXINLINE> in the environment
	  <LATEXINLINE>env</LATEXINLINE>, or signals an error if the
	  <LATEXINLINE>$\textit{symbol}$</LATEXINLINE> is unbound.
	  </LI>
	  <LI>
	    <!--  \indcode{extend-environment} -->
	    <JAVASCRIPTINLINE>extend_environment(</JAVASCRIPTINLINE>
	    <LATEXINLINE>$\textit{symbols}$, $\textit{values}$,
	    $\textit{base-env}$</LATEXINLINE>
	    <JAVASCRIPTINLINE>)</JAVASCRIPTINLINE>
	    <BREAK/>
	    returns a new environment, consisting of a new frame in which the
	    symbols in the list <LATEXINLINE>$\textit{symbols}$</LATEXINLINE>
	    are bound to the corresponding elements in the list
	    <LATEXINLINE>$\textit{values}$</LATEXINLINE>, where the enclosing
	    environment is the environment
	    <LATEXINLINE>$\textit{base-env}$</LATEXINLINE>.
	  </LI>
	  <LI>
	    <!--  \indcode{set-variable-value!} -->
	    <JAVASCRIPTINLINE>assign_symbol_value(</JAVASCRIPTINLINE>
	    <LATEXINLINE>$\textit{symbol}$, $\textit{value}$,
	    $\textit{env}$</LATEXINLINE>
	    <JAVASCRIPTINLINE>)</JAVASCRIPTINLINE>
	    <BREAK/>
	    finds the innermost frame of
	    <LATEXINLINE>$\textit{env}$</LATEXINLINE>
	    in which the <LATEXINLINE>$\textit{symbol}$</LATEXINLINE>
	    is bound, and changes that frame
	    so that the symbol is now bound to the given
	    <LATEXINLINE>$\textit{value}$</LATEXINLINE>.
	  </LI>
	</UL>
      </JAVASCRIPT>
    </SPLIT>

    <INDEX>metacircular evaluator for Scheme
    <SUBINDEX>representation of environments|(</SUBINDEX></INDEX>
    To implement these operations we represent an environment as a list of
    frames.  The enclosing environment of an environment is the
    <SPLITINLINE>
      <SCHEME><SCHEMEINLINE>cdr</SCHEMEINLINE></SCHEME>
      <JAVASCRIPT><JAVASCRIPTINLINE>tail</JAVASCRIPTINLINE></JAVASCRIPT>
    </SPLITINLINE>
    of the list.  The empty environment is simply the empty list.
    <SNIPPET PAGE="378">
      <NAME>enclosing_environment</NAME>
      <EXAMPLE>enclosing_environment_example</EXAMPLE>
      <EXPECTED>null</EXPECTED>
      <SCHEME>
(define (enclosing-environment env) (cdr env))

(define (first-frame env) (car env))

(define the-empty-environment \&apos;())
      </SCHEME>
      <JAVASCRIPT>
function enclosing_environment(env) {
    return tail(env);
}
function first_frame(env) {
    return head(env);
}
function enclose_by(frame, env) {    
    return pair(frame, env);
}
const the_empty_environment = null;
      </JAVASCRIPT>  
    </SNIPPET>
    <SNIPPET PAGE="378" HIDE="yes">
      <NAME>enclosing_environment_example</NAME>
      <JAVASCRIPT>
the_empty_environment;	
      </JAVASCRIPT>
    </SNIPPET>
  </TEXT>

  <TEXT>
    Each frame of an environment is represented as a pair of lists: a list
    of the variables bound in that frame and a list of the associated
    values.<FOOTNOTE>Frames are not really a data abstraction in the following
    code:
    <SPLITINLINE>
      <SCHEME><SCHEMEINLINE>set-variable-value!</SCHEMEINLINE></SCHEME>
      <JAVASCRIPT><JAVASCRIPTINLINE>assign_symbol_value</JAVASCRIPTINLINE>
      </JAVASCRIPT>
    </SPLITINLINE>
    and 
    <SPLITINLINE>
      <SCHEME><SCHEMEINLINE>define-variable!</SCHEMEINLINE></SCHEME>
      <JAVASCRIPT><JAVASCRIPTINLINE>define_variable</JAVASCRIPTINLINE>
      </JAVASCRIPT>
    </SPLITINLINE>
    use 
    <SPLITINLINE><SCHEME><SCHEMEINLINE>set-car!</SCHEMEINLINE></SCHEME>
    <JAVASCRIPT><JAVASCRIPTINLINE>set_head</JAVASCRIPTINLINE></JAVASCRIPT>
    </SPLITINLINE>
    to directly modify the values in a frame.  The purpose of the frame
    <SPLITINLINE><SCHEME>procedures</SCHEME>
    <JAVASCRIPT>functions</JAVASCRIPT></SPLITINLINE>
    is to make the environment-manipulation
    <SPLITINLINE><SCHEME>procedures</SCHEME>
    <JAVASCRIPT>functions</JAVASCRIPT></SPLITINLINE>
    easy to read.</FOOTNOTE>
    <SNIPPET PAGE="378" HIDE="yes">
      <NAME>make_frame_example</NAME>
      <JAVASCRIPT>
const my_frame = make_frame(list("x", "y"), list(1, 2));
frame_symbols(my_frame);
      </JAVASCRIPT>
    </SNIPPET>
    <SNIPPET PAGE="378">
      <NAME>make_frame</NAME>
      <EXAMPLE>make_frame_example</EXAMPLE>
      <EXPECTED>[ 'x', [ 'y', null ] ]</EXPECTED>
      <SCHEME>
(define (make-frame variables values)
  (cons variables values))

(define (frame-variables frame) (car frame))
(define (frame-values frame) (cdr frame))

(define (add-binding-to-frame! var val frame)
  (set-car! frame (cons var (car frame)))
  (set-cdr! frame (cons val (cdr frame))))
      </SCHEME>
      <JAVASCRIPT>
function make_frame(symbols, values) {
    return pair(symbols, values);
}
function frame_symbols(frame) {    
    return head(frame);
}
function frame_values(frame) {    
    return tail(frame);
}
      </JAVASCRIPT>
    </SNIPPET>
  </TEXT>

  <TEXT>
    To extend an environment by a new frame that associates
    <SPLITINLINE>
      <SCHEME>variables</SCHEME>
      <JAVASCRIPT>symbols</JAVASCRIPT>
    </SPLITINLINE>
    with values, we make a frame consisting of the list of
    <SPLITINLINE>
      <SCHEME>variables</SCHEME>
      <JAVASCRIPT>symbols</JAVASCRIPT>
    </SPLITINLINE>
    and the list of values, and we adjoin this to the environment.  We signal
    an error if the number of
    <SPLITINLINE>
      <SCHEME>variables</SCHEME>
      <JAVASCRIPT>symbols</JAVASCRIPT>
    </SPLITINLINE>
    does not match the number of values.
    <SNIPPET PAGE="379">
      <NAME>extend_environment</NAME>
      <EXAMPLE>extend_environment_example</EXAMPLE>
      <EXPECTED>[ 1, [ 2, [ 3, null ] ] ]</EXPECTED>
      <SCHEME>
(define (extend-environment vars vals base-env)
  (if (= (length vars) (length vals))
      (cons (make-frame vars vals) base-env)
      (if (&lt; (length vars) (length vals))
          (error "Too many arguments supplied" vars vals)
          (error "Too few arguments supplied" vars vals))))
      </SCHEME>
      <JAVASCRIPT>
function extend_environment(symbols, vals, base_env) {
    return length(symbols) === length(vals)
           ? pair(make_frame(symbols, vals), base_env)
           : length(symbols) &lt; length(vals)
             ? error("Too many arguments supplied")
             : error("Too few arguments supplied");
}
      </JAVASCRIPT>
      <JAVASCRIPT_RUN>
function extend_environment(symbols, vals, base_env) {
    return length(symbols) === length(vals)
           ? pair(make_frame(symbols, vals), base_env)
           : length(symbols) &lt; length(vals)
             ? error("Too many arguments supplied: " + 
                     stringify(symbols) + ", " + 
                     stringify(vals))
             : error("Too few arguments supplied: " + 
                     stringify(symbols) + ", " + 
                     stringify(vals));
}
      </JAVASCRIPT_RUN>
    </SNIPPET>
    <SNIPPET PAGE="378" HIDE="yes">
      <NAME>extend_environment_example</NAME>
      <REQUIRES>enclosing_environment</REQUIRES>
      <REQUIRES>make_frame</REQUIRES>
      <SCHEME>
      </SCHEME>
      <JAVASCRIPT>
extend_environment(list("x", "y", "z"),
                   list(1, 2, 3),
                   the_empty_environment);
      </JAVASCRIPT>
      <JAVASCRIPT_TEST>
tail(head(extend_environment(list("x", "y", "z"),
                   list(1, 2, 3),
                   the_empty_environment)));
      </JAVASCRIPT_TEST>
    </SNIPPET>
    <SPLITINLINE>
      <JAVASCRIPT>
	The function <JAVASCRIPTINLINE>extend_environment</JAVASCRIPTINLINE>
	is used by <JAVASCRIPTINLINE>apply</JAVASCRIPTINLINE> in
	section<SPACE/><REF NAME="sec:core-of-evaluator"/> to bind the
	parameters of a function to its arguments. 
      </JAVASCRIPT>
    </SPLITINLINE>
  </TEXT>

  <TEXT>
    To look up a
    <SPLITINLINE>
      <SCHEME>variable</SCHEME>
      <JAVASCRIPT>symbol</JAVASCRIPT>
    </SPLITINLINE>
    in an environment, we scan the list of
    <SPLITINLINE>
      <SCHEME>variables</SCHEME>
      <JAVASCRIPT>symbols</JAVASCRIPT>
    </SPLITINLINE>
    in the first frame.  If we find the desired
    <SPLITINLINE>
      <SCHEME>variable,</SCHEME>
      <JAVASCRIPT>symbol,</JAVASCRIPT>
    </SPLITINLINE>
    we return the corresponding element in the list of values. If we do not
    find the
    <SPLITINLINE>
      <SCHEME>variable</SCHEME>
      <JAVASCRIPT>symbol</JAVASCRIPT>
    </SPLITINLINE>
    in the current frame, we search the enclosing environment, and so on.
    If we reach the empty environment, we signal an
    <SPLITINLINE>
      <SCHEME>
	<QUOTE>unbound
	variable</QUOTE>
      </SCHEME>
      <JAVASCRIPT>
	<QUOTE>unbound
	name</QUOTE>
      </JAVASCRIPT>
    </SPLITINLINE>  
    error.
    <SNIPPET PAGE="379">
      <NAME>lookup_variable_value</NAME>
      <REQUIRES>unassigned</REQUIRES>
      <EXAMPLE>lookup_variable_value_example</EXAMPLE>
      <EXPECTED>1</EXPECTED>
      <SCHEME>
(define (lookup-variable-value var env)
  (define (env-loop env)
    (define (scan vars vals)
      (cond ((null? vars)
             (env-loop (enclosing-environment env)))
            ((eq? var (car vars))
             (car vals))
            (else (scan (cdr vars) (cdr vals)))))
    (if (eq? env the-empty-environment)
        (error "Unbound variable" var)
        (let ((frame (first-frame env)))
          (scan (frame-variables frame)
                (frame-values frame)))))
  (env-loop env))
      </SCHEME>
      <JAVASCRIPT>
function lookup_symbol_value(symbol, env) {
    function env_loop(env) {
        function scan(symbols, vals) {
            return is_null(symbols)
                   ? env_loop(
                       enclosing_environment(env))
                   : symbol === head(symbols)
                     ? head(vals)
                     : scan(tail(symbols), tail(vals));
        }
        if (env === the_empty_environment) {
            error(symbol, "Unbound symbol: ");
        } else {
            const frame = first_frame(env);
            return scan(frame_symbols(frame),
                        frame_values(frame));
        }
    }
    return env_loop(env);
}
      </JAVASCRIPT>
    </SNIPPET>
    <SNIPPET PAGE="378" HIDE="yes">
      <NAME>lookup_variable_value_example</NAME>
      <REQUIRES>enclosing_environment</REQUIRES>
      <REQUIRES>extend_environment</REQUIRES>
      <REQUIRES>make_frame</REQUIRES>
      <SCHEME>
      </SCHEME>
      <JAVASCRIPT>
const my_environment =
    extend_environment(list("x", "y", "z"),
                       list(1, 2, 3),
                       the_empty_environment);

lookup_symbol_value("x", my_environment);
      </JAVASCRIPT>
    </SNIPPET>
  </TEXT>

  <TEXT>
    <SPLIT>
      <SCHEME>To set a variable
      to a new value in a specified environment, we scan
      for the variable, just as in 
      <SCHEMEINLINE>lookup-variable-value</SCHEMEINLINE>,
      and change the corresponding value when we find it.
      </SCHEME>
      <JAVASCRIPT>To assign a name
      to a new value in a specified environment, we scan
      for the symbol of the name, just as in 
      <JAVASCRIPTINLINE>lookup_symbol_value</JAVASCRIPTINLINE>,
      and change the corresponding value when we find it.
      </JAVASCRIPT>
    </SPLIT>
    <SNIPPET PAGE="379">
      <NAME>assign_name_value</NAME>
      <EXAMPLE>assign_name_value_example</EXAMPLE>
      <EXPECTED>2</EXPECTED>
      <SCHEME>
(define (set-variable-value! var val env)
  (define (env-loop env)
    (define (scan vars vals)
      (cond ((null? vars)
             (env-loop (enclosing-environment env)))
            ((eq? var (car vars))
             (set-car! vals val))
            (else (scan (cdr vars) (cdr vals)))))
    (if (eq? env the-empty-environment)
        (error "Unbound variable - - SET!" var)
        (let ((frame (first-frame env)))
          (scan (frame-variables frame)
                (frame-values frame)))))
  (env-loop env))
      </SCHEME>
      <JAVASCRIPT>
function assign_symbol_value(symbol, val, env) {
    function env_loop(env) {
        function scan(symbols, vals) {
            return is_null(symbols)
                ? env_loop(
                    enclosing_environment(env))
                : symbol === head(symbols)
                  ? set_head(vals, val)
                  : scan(tail(symbols), tail(vals));
        } 
        if (env === the_empty_environment) {
            error(symbol, "Unbound symbol in assignment:");
        } else {
            const frame = first_frame(env);
            return scan(frame_symbols(frame),
                        frame_values(frame));
        }
    }
    return env_loop(env);
}
      </JAVASCRIPT>
    </SNIPPET>
    <SNIPPET PAGE="378" HIDE="yes">
      <NAME>assign_name_value_example</NAME>
      <REQUIRES>functions_4_1_1</REQUIRES>
      <REQUIRES>functions_4_1_2</REQUIRES>
      <REQUIRES>functions_4_1_3</REQUIRES>
      <REQUIRES>functions_4_1_4</REQUIRES>
      <SCHEME>
      </SCHEME>
      <JAVASCRIPT>
const my_block = parse("{ let x = 1; x = 2; }");
evaluate(my_block, the_global_environment);
      </JAVASCRIPT>
    </SNIPPET>
  </TEXT>

  <SPLIT>
    <SCHEME>
      <TEXT>
        To define a variable,
        we search the first frame for a binding for
        the variable, and change the binding if it exists
	(just as in 
	<SPLITINLINE>
	  <SCHEME><SCHEMEINLINE>set-variable-value!</SCHEMEINLINE>.</SCHEME>
	  <JAVASCRIPT><JAVASCRIPTINLINE>assign_variable_value</JAVASCRIPTINLINE>.
	  </JAVASCRIPT>
	</SPLITINLINE>
	If no such binding exists, we adjoin one to the first frame.
	<SNIPPET PAGE="380">
	  <NAME>define_variable</NAME>
	  <SCHEME>
(define (define-variable! var val env)
  (let ((frame (first-frame env)))
    (define (scan vars vals)
      (cond ((null? vars)
             (add-binding-to-frame! var val frame))
            ((eq? var (car vars))
             (set-car! vals val))
            (else (scan (cdr vars) (cdr vals)))))
    (scan (frame-variables frame)
          (frame-values frame))))
	  </SCHEME>
	</SNIPPET>
      </TEXT>
    </SCHEME>
    <JAVASCRIPT>
    </JAVASCRIPT>
  </SPLIT>

  <TEXT>
    <INDEX>metacircular evaluator for Scheme
    <SUBINDEX>data abstraction in</SUBINDEX></INDEX>
    The method described here is only one of many plausible ways to represent
    environments.  Since we used data abstraction to isolate the rest of the
    evaluator from the detailed choice of representation, we could change the
    environment representation if we wanted to.  (See
    exercise<SPACE/><REF NAME="ex:alternate-frame-representation"/>.)  In a
    production-quality
    <SPLITINLINE>
      <SCHEME>Lisp</SCHEME>
      <JAVASCRIPT>JavaScript</JAVASCRIPT>
    </SPLITINLINE>
    system, the speed of the evaluator<APOS/>s environment
    operations<EMDASH/>especially that of variable lookup<EMDASH/>has a major
    impact on the performance of the system.  The representation described here,
    although conceptually simple, is not efficient and would not ordinarily be
    used in a production system.<FOOTNOTE>The drawback of this representation (as
    well as the variant in
    exercise<SPACE/><REF NAME="ex:alternate-frame-representation"/>) is that the
    evaluator may have to search through many frames in order to find the binding
    for a given variable.
    <INDEX>deep binding</INDEX><INDEX>binding<SUBINDEX>deep</SUBINDEX></INDEX>
    (Such an approach is referred to as <EM>deep binding</EM>.) One way to avoid
    this inefficiency is to make use of a strategy called
	<EM>lexical addressing</EM>, which will be discussed in
	section<SPACE/><REF NAME="sec:lexical-addressing"/>.
  </FOOTNOTE>
  <INDEX>metacircular evaluator for Scheme
  <SUBINDEX>representation of environments|)</SUBINDEX></INDEX>
  </TEXT>

  <SNIPPET PAGE="383" HIDE="yes">
    <NAME>functions_4_1_3</NAME>
    <REQUIRES>headline_4_1_3</REQUIRES>
    <REQUIRES>true</REQUIRES>
    <REQUIRES>make_procedure</REQUIRES>
    <REQUIRES>return_value</REQUIRES>
    <REQUIRES>enclosing_environment</REQUIRES>
    <REQUIRES>make_frame</REQUIRES>
    <REQUIRES>extend_environment</REQUIRES>
    <REQUIRES>lookup_variable_value</REQUIRES>
    <REQUIRES>assign_name_value</REQUIRES>
    <JAVASCRIPT></JAVASCRIPT>
  </SNIPPET>

  <EXERCISE>
    <LABEL NAME="ex:alternate-frame-representation"/>
    Instead of representing a frame as a pair of lists, we can represent a frame
    as a list of bindings, where each binding is a symbol-value pair. Rewrite the
    environment operations to use this alternative representation.            
  </EXERCISE>

  <EXERCISE>
    The
    <SPLITINLINE>
      <SCHEME>procedures</SCHEME>
      <JAVASCRIPT>functions</JAVASCRIPT>
    </SPLITINLINE>
    <SPLITINLINE>
      <SCHEME>
	<SCHEMEINLINE>set-variable-value!</SCHEMEINLINE>,
	<SCHEMEINLINE>define-variable!</SCHEMEINLINE>, and
	<SCHEMEINLINE>lookup-variable-value</SCHEMEINLINE> 
      </SCHEME>
      <JAVASCRIPT>
	<JAVASCRIPTINLINE>lookup_symbol_value</JAVASCRIPTINLINE> and
	<JAVASCRIPTINLINE>assign_symbol_value</JAVASCRIPTINLINE>
      </JAVASCRIPT>
    </SPLITINLINE>
    can be expressed in terms of 
    <SPLITINLINE>
      <SCHEME>more abstract procedures</SCHEME>
      <JAVASCRIPT>a more abstract function</JAVASCRIPT>
    </SPLITINLINE>
    for traversing the environment structure. 
    <SPLITINLINE>
      <SCHEME>
	Define abstractions that capture the common patterns and redefine the
	three procedures in terms of these abstractions.
      </SCHEME>
      <JAVASCRIPT>
	Define an abstraction that captures the common pattern and redefine the
	two functions in terms of this abstraction.
      </JAVASCRIPT>
    </SPLITINLINE>
  </EXERCISE>
  
  <EXERCISE>
    <LABEL NAME="ex:mutable"/>
    <SPLIT>
      <SCHEME>
	Scheme allows us to create new bindings for variables by means of
	<SCHEMEINLINE>define</SCHEMEINLINE>, but provides no way to get rid of
	bindings.  Implement for the evaluator a special form
	<SCHEMEINLINE>make-unbound!</SCHEMEINLINE> that removes the binding of a
	given symbol from the environment in which the
	<SCHEMEINLINE>make-unbound!</SCHEMEINLINE> expression is evaluated. This
	problem is not completely specified.  For example, should we remove only
	the binding in the first frame of the environment?  Complete the
	specification and justify any choices you make.
	<LABEL NAME="ex:make-unbound_scheme"/>
      </SCHEME>
      <JAVASCRIPT>
	Our language distinguishes constants from variables by using 
	two different keywords: <JAVASCRIPTINLINE>const</JAVASCRIPTINLINE>
	and <JAVASCRIPTINLINE>let</JAVASCRIPTINLINE>. However, our interpreter
	does not make use of this distinction; the function
	<JAVASCRIPTINLINE>assign_symbol_value</JAVASCRIPTINLINE> will happily
	assign a new value to a given symbol, regardless whether it is declared
	as a constant or a variable. Correct this flaw by calling the function
	<JAVASCRIPTINLINE>error</JAVASCRIPTINLINE> whenever an attempt is
	made to use a constant on the left hand side of an assignment.
	You may proceed as follows:
	<UL>
	  <LI>
	    Change the functions
	    <JAVASCRIPTINLINE>scan_out_declarations</JAVASCRIPTINLINE>
	    and (if necessary)
	    <JAVASCRIPTINLINE>extend_environment</JAVASCRIPTINLINE>
	    such that constants are distinguishable from variables in
	    the frames in which they are bound.
	  </LI>
	  <LI>
	    Change the function
	    <JAVASCRIPTINLINE>assign_symbol_value</JAVASCRIPTINLINE> such
	    that it checks whether the given symbol has been declared as
	    a variable or as a constant, and in the latter case signals
	    an error that assignment operations are not allowed on contants.
	  </LI>
	</UL>
      </JAVASCRIPT>
    </SPLIT>
  </EXERCISE>
</SUBSECTION>