cvs commit: modperl/faq mjtg-news.txt

[do...@hyperreal.org]

dougm       98/05/06 14:57:47

  Added:       faq      mjtg-news.txt
  Log:
  added
  
  Revision  Changes    Path
  1.1                  modperl/faq/mjtg-news.txt
  
  Index: mjtg-news.txt
  ===================================================================
  From: mjtg@cus.cam.ac.uk (M.J.T. Guy)
  Newsgroups: comp.lang.perl.misc
  Subject: Re: Lexical scope and embedded subroutines.
  Date: 6 Jan 1998 18:22:39 GMT
  Organization: University of Cambridge, England
  Lines: 95
  Message-ID: <68...@lyra.csx.cam.ac.uk>
  References: <34...@gcg.com> <Pi...@user1.teleport.com> <68...@brokaw.wa.com>
  NNTP-Posting-Host: taurus.cus.cam.ac.uk
  
  In article <68...@brokaw.wa.com>, Aaron Harsh <aj...@rtk.com> wrote:
  >
  >Before I read this thread (and perlsub to get the details) I would have
  >assumed the original code was fine.
  >
  >This behavior brings up the following questions:
  >  o Is Perl's behavior some sort of speed optimization?
  
  No, but see below.
  
  >  o Did the Perl gods just decide that scheme-like behavior was less
  >important than the pseduo-static variables described in perlsub?
  
  This subject has been kicked about at some length on perl5-porters.
  The current behaviour was chosen as the best of a bad job.
  In the context of Perl, it's not obvious what "scheme-like behavior"
  means.    So it isn't an option.    See below for details.
  
  >  o Does anyone else find Perl's behavior counter-intuitive?
  
  *Everyone* finds it counterintuitive.    The fact that it only generates
  a warning rather than a hard error is part of the Perl Gods policy
  of hurling thunderbolts at those so irreverent as not to use -w.
  
  >  o Did programming in scheme destroy my ability to judge a decent language
  >feature?
  
  You're still interested in Perl, so it can't have rotted your brain
  completely.
  
  >  o Have I misremembered how scheme handles these situations?
  
  Probably not.
  
  >  o Do Perl programmers really care how much Perl acts like scheme?
  
  Some do.
  
  >  o Should I have stopped this message two or three questions ago?
  
  Yes.
  
  
  
  The problem to be solved can be stated as
  
  "When a subroutine refers to a variable which is instantiated more than
   once (i.e. the variable is declared in a for loop, or in a subroutine),
   which instance of that variable should be used?"
  
  The basic problem is that Perl isn't Scheme (or Pascal or any of the
  other comparators that have been used).
  
  In almost all lexically scoped languages (i.e. those in the Algol60
  tradition), named subroutines are also lexically scoped.   So the scope
  of the subroutine is necessarily contained in the scope of any external
  variable referred to inside the subroutine.   So there's an obvious
  answer to the "which instance?" problem.
  
  But in Perl, named subroutines are globally scoped.  (But in some
  future Perl, you'll be able to write
  
         my sub lex { ... }
  
  to get lexical scoping.)    So the solution adopted by other languages
  can't be used.
  
  The next suggestion most people come up with is "Why not use the most
  recently instantiated variable?".   This Does The Right Thing in many
  cases, but fails when recursion or other complications are involved.
  
  Consider
  
  sub outer {
  
      inner();
      outer();
      my $trouble;
      inner();
      sub inner { $trouble };
      outer();
      inner();
  }
  
  Which instance of $trouble is to be used for each call of inner()?
  And why?
  
  The consensus was that an incomplete solution was unacceptable, so
  the simple rule "Use the first instance" was adopted instead.
  
  And it is more efficient than possible alternative rules.   But that's not
  why it was done.
  
  
  Mike Guy