function g;
{
  int x;
  {
    def f() {
      return x;
    }
    g = f;
  }
  g(); // fine
} 
g(); // runtime error, f was destroyed when x was destroyed. 

PROGRAMMING LANGUAGE DESIGN

  It is impossible to begin a discussion of psychological principles of
programming language design without recalling the story of ``Levine the
Genious Tailor.'' It seems that a man had gone to Levine to have a suit
made cheaply, but when the suit was finished and he went to try it on, it
didn't fit him at all. ``Look,'' he said, ``the jacket is much too big in
back.''
  ``No problem,'' replied Levine, showing him how to hunch over his back
to take up the slack in the jacket.
  ``But then what about the right arm? It's three inches too long.''
  ``No problem,'' Levine repeated, demonstrating how, by leaning to one
side and stretching out his right arm, the sleeve could be made to fit.
  ``And what about these pants? The left leg is too short.''
  ``No problem,'' said Levine for the third time, and proceeded to teach
him how to pull up his leg at the hip so that, though he limped badly, the
suit appeared to fit.
  Having no more complaints, the man set off hobbling down the street,
feeling slightly duped by Levine. Before he went two blocks, he was
stopped by a stranger who said, ``I beg your pardon, but is that a new suit
you're wearing?''
  The man was a little pleased that someone had noticed his suit, so he
took no offense. ``Yes it is,'' he replied. ``Why do you ask?''
  ``Well, I'm in the market for a new suit myself. Who's your tailor?''
  ``It's Levine---right down the street.''
  ``Well, thanks very much,'' said the stranger, hurrying off. ``I do
believe I'll go to Levine for my suit. Why, he must be a genious to fit a
cripple like you!''
  Would it be inappropriate to concot a version of this story called
``Levine the Genius Language Designer''? The first problem in discussing
language design is that we do not know the answer to that question. We do
not know whether the language designers are geniuses, or we ordinary
programmers are cripples. Generally speaking, we only know how bad our
present programming language is when we finally overcome the psychological
barriers and learn a new one. Our standards, in other words, are shifting
ones---a fact that has to be taken into full consideration in programming
language design.

(let ((g nil))
  (let* ((x "value of x")
         (f (lambda () (insert x))))
    (setq g f)
    (funcall g))
  (funcall g))

> def output_all(list a)
> {
>   int x; 
>   def out(object o) { 
>     write(x++); 
>     write(" : ");
>     write(o); 
>     write('\n');
>   }
>   a.witheach(out);
> }

{
  int x = 42; 
  def f() : function {
    def g() : int {
      return x;
    }
    return g;
  }
  object o = f();
  int y = o();
}