[23305] in Perl-Users-Digest
Perl-Users Digest, Issue: 5525 Volume: 10
daemon@ATHENA.MIT.EDU (Perl-Users Digest)
Thu Sep 18 21:10:41 2003
Date: Thu, 18 Sep 2003 18:10:10 -0700 (PDT)
From: Perl-Users Digest <Perl-Users-Request@ruby.OCE.ORST.EDU>
To: Perl-Users@ruby.OCE.ORST.EDU (Perl-Users Digest)
Perl-Users Digest Thu, 18 Sep 2003 Volume: 10 Number: 5525
Today's topics:
referencing, closures, classes <x12code-del@del-yahoo.com>
Re: referencing, closures, classes <mpapec@yahoo.com>
Re: referencing, closures, classes <uri@stemsystems.com>
Re: referencing, closures, classes <cwilbur@mithril.chromatico.net>
Re: referencing, closures, classes <x12code-del@del-yahoo.com>
Re: referencing, closures, classes <x12code-del@del-yahoo.com>
Re: referencing, closures, classes <emschwar@pobox.com>
Re: referencing, closures, classes <bwalton@rochester.rr.com>
Re: Regex to detect patterns that do not start with // <abigail@abigail.nl>
Re: sort issue (Bogdan)
Re: string to integer <bart.lateur@pandora.be>
Re: XML ( WML in particular) (Shambo)
Re: <bwalton@rochester.rr.com>
Digest Administrivia (Last modified: 6 Apr 01) (Perl-Users-Digest Admin)
----------------------------------------------------------------------
Date: Thu, 18 Sep 2003 13:48:50 -0500
From: David McDivitt <x12code-del@del-yahoo.com>
Subject: referencing, closures, classes
Message-Id: <r5tjmv8eg4igt9rflbttkt6lp6ml0rtqjo@4ax.com>
I am new to Perl going through the book by Deitel, "Perl How to Program". I
went through the first half the book pretty fast and only did a few of the
programming examples to understand. I even made a good application with what
I read this far having four web pages, CGI functionality, functions, hashes,
Perl default variables, and code optimizations.
I seem to be stuck on the conceptual matter of referencing, closures, and
classes. The book is good to the extent it covers the whole language and
represents a good plan for learning the language. Unfortunately, I have
found the book lacking in description of a few key points. They are glossed
over with sentences lacking sufficient detail or are ambiguous. It is as if
the author is impatient to move on. Not only am I learning the language
myself to write production applications, but I am also leaving behind a
methodology for others here to follow. When parts of the book need
clarification I find it for my own benefit, then create a text document
having the problem chapter and section. It is my hope others can go through
the book and read these little text files for clarification when necessary.
I don't like to assume things, and I don't like to do things just because
the book or so-and-so says so. I have read several articles on referencing,
closures, and classes, but am unable to understand exactly why it works and
what Perl is doing with these. I could move on in the book then get what I
want through osmosis later on, but prefer to understand these points right
now. Sometimes I make things too complicated, too.
The key seems to be basic referencing, which is easy to understand, coupled
with anonymous referencing, which is also easy to understand. With closures
and classes, the problem is understanding what is being left behind and why.
What exactly is the syntax doing? It seems the way closures are created is
the manner in which a routine exits. The author left a good trail, with all
the preliminaries in place, but failed to put everything together at the end
to enable whatever visualization. I read
http://www.perldoc.com/perl5.6/pod/perltoot.html. Though quite good, it
still did not complete the picture for me. Any comments would be
appreciated. Thanks
------------------------------
Date: Thu, 18 Sep 2003 21:41:40 +0200
From: Matija Papec <mpapec@yahoo.com>
Subject: Re: referencing, closures, classes
Message-Id: <mb2kmvk01ck074h593ss188p4eb1e08tec@4ax.com>
X-Ftn-To: David McDivitt
David McDivitt <x12code-del@del-yahoo.com> wrote:
>The key seems to be basic referencing, which is easy to understand, coupled
>with anonymous referencing, which is also easy to understand. With closures
>and classes, the problem is understanding what is being left behind and why.
>What exactly is the syntax doing? It seems the way closures are created is
>the manner in which a routine exits. The author left a good trail, with all
>the preliminaries in place, but failed to put everything together at the end
>to enable whatever visualization. I read
>http://www.perldoc.com/perl5.6/pod/perltoot.html. Though quite good, it
>still did not complete the picture for me. Any comments would be
>appreciated. Thanks
Closure is a /subroutine/ which refers to lexical variables declared outside
the subroutine itself.. so Damian defines closures in OO Perl.
What you're missing in your picture?
--
Matija
------------------------------
Date: Thu, 18 Sep 2003 20:07:51 GMT
From: Uri Guttman <uri@stemsystems.com>
Subject: Re: referencing, closures, classes
Message-Id: <x7znh1svvt.fsf@mail.sysarch.com>
>>>>> "DM" == David McDivitt <x12code-del@del-yahoo.com> writes:
DM> I am new to Perl going through the book by Deitel, "Perl How to
DM> Program". I went through the first half the book pretty fast and
DM> only did a few of the programming examples to understand. I even
DM> made a good application with what I read this far having four web
DM> pages, CGI functionality, functions, hashes, Perl default
DM> variables, and code optimizations.
get a better book. there is no need for most newbies to use closures.
DM> I seem to be stuck on the conceptual matter of referencing,
DM> closures, and classes. The book is good to the extent it covers
DM> the whole language and represents a good plan for learning the
DM> language. Unfortunately, I have found the book lacking in
DM> description of a few key points. They are glossed over with
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
see, it is a bad book if it does that. go to learn.perl.org for more on
better books (including a good one that is free online).
DM> sentences lacking sufficient detail or are ambiguous. It is as if
DM> the author is impatient to move on. Not only am I learning the
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
another sign of a bad book.
DM> language myself to write production applications, but I am also
DM> leaving behind a methodology for others here to follow. When parts
DM> of the book need clarification I find it for my own benefit, then
DM> create a text document having the problem chapter and section. It
DM> is my hope others can go through the book and read these little
DM> text files for clarification when necessary.
DM> I don't like to assume things, and I don't like to do things just
DM> because the book or so-and-so says so. I have read several
DM> articles on referencing, closures, and classes, but am unable to
DM> understand exactly why it works and what Perl is doing with
DM> these. I could move on in the book then get what I want through
DM> osmosis later on, but prefer to understand these points right
DM> now. Sometimes I make things too complicated, too.
why do you think you need closures? closures are not really related to
references (even though closures are made with anon code refs) in general.
DM> The key seems to be basic referencing, which is easy to
DM> understand, coupled with anonymous referencing, which is also easy
DM> to understand. With closures and classes, the problem is
references don't know if they are 'regular' or 'anonymous', they are
just references. if your book separates them like that, then get a
better book.
DM> understanding what is being left behind and why. What exactly is
DM> the syntax doing? It seems the way closures are created is the
DM> manner in which a routine exits. The author left a good trail,
DM> with all the preliminaries in place, but failed to put everything
DM> together at the end to enable whatever visualization. I read
DM> http://www.perldoc.com/perl5.6/pod/perltoot.html. Though quite
DM> good, it still did not complete the picture for me. Any comments
DM> would be appreciated. Thanks
get a better book. this one sounds awful from only your description.
here are a few to start with. search google in this group for more
recommendations.
learning perl
elements of programming with perl
programming perl
uri
--
Uri Guttman ------ uri@stemsystems.com -------- http://www.stemsystems.com
--Perl Consulting, Stem Development, Systems Architecture, Design and Coding-
Search or Offer Perl Jobs ---------------------------- http://jobs.perl.org
Damian Conway Class in Boston - Sept 2003 -- http://www.stemsystems.com/class
------------------------------
Date: Thu, 18 Sep 2003 21:30:06 GMT
From: Charlton Wilbur <cwilbur@mithril.chromatico.net>
Subject: Re: referencing, closures, classes
Message-Id: <87wuc594fc.fsf@mithril.chromatico.net>
>>>>> "UG" == Uri Guttman <uri@stemsystems.com> writes:
UG> get a better book. this one sounds awful from only your
UG> description.
The Deitel & Deitel _C: How to Program_ was a very good book; it's the
one I was taught C from. I've since replaced it with K&R2 (which got
stolen) and with Harbison & Steele, but it was a very good book all
the same.
Their _C++: How to Program_ was disappointing, as was their _Java: How
to Program_. I'm not surprised that the Perl one is horrible, alas.
Charlton
--
cwilbur at chromatico dot net
cwilbur at mac dot com
------------------------------
Date: Thu, 18 Sep 2003 16:51:25 -0500
From: David McDivitt <x12code-del@del-yahoo.com>
Subject: Re: referencing, closures, classes
Message-Id: <av9kmv07ekpd01udevhj2ul8f4bikbirer@4ax.com>
Here is what the book says:
*********
Anonymous functions come into existence at runtime. The part of the code in
which an anonymous function is created has it's own lexical context <ok>.
The values of variables created in the same lexical context as an anonymous
function can be used by the anonymous function when it is called later in
the program <ok>. Anonymous functions save the information about the context
in which they were created and execute as if they were still in that
context. The anonymous functions act as "closures" with respect to lexical
variables <taken for granted but OK>.
5 use warnings;
6 use strict;
7
8 print( "The number is square( 5 ).\n" );
9 print( "The number is ${ \square( 5 ) }.\n" );
10
11 sub square
12 {
13 my $x = shift();
14 return $x * $x;
15 }
The number is square( 5 ).
The number is 25.
fig 13.7
An example where this can be useful is when a function returns an anonymous
function reference. The function reference will contain the state
information pertaining for the lexical context in which it was created.
Figure 13.8 demonstrates this concept.
Function "animalInFood"(lines 8-16) returns a reference to an anonymous
function (defined at lines 11 thru 15). Line 10 creates a lexical variable
"$x", which stores the value passed to function "animalInFood" as an
argument. Note that the anonymous function uses the lexical variable "$x" in
line 14. Each time the "animalInFood" function is called, a new "$x" is
created because it is declared with the "my" keyword. When the anonymous
function is created on line 11, the "$x" it refers to is the specific "$x"
that exists at the time the function is created, not the value that "$x"
holds when the anonymous function is called. This association of the
variable "$x" in the closure with the specific instance of "$x", rather than
the name "$x", is known as "deep binding". Only lexical variables provide
deep binding. If we used the "local" keyword on line 10 instead of "my", we
would not have deep binding and the anonymous function returned would not be
a closure.
5 use warnings;
6 use strict;
7
8 sub animalInFood
9 {
10 my $x = shift();
11 return sub #what the hell does return sub mean?
12 { #no description given anywhere
13 my $y = shift();
14 print( "There is a $x in my $y!\n" );
15 };
16 }
17
18 my &$flyInFood = animalInFood( "fly" );
19 my &$frogInFood = animalInFood( "frog" );
20
21 &$flyInFood( "soup" );
22 &$frogInFood( "coffee" );
There is a fly in my soup!
There is a frog in my coffee!
fig 13.8
You can see that "animalInFood returns closures because when we assign
variable "$flyInFood" the closure returned by passing "animalInFood" the
word "fly", then call "animalInFood" again with the value "frog". Each
closure is stored in a reference. These references are used at lines 21 and
22 to invoke each closure. Note that the closure invoked at line 21 prints a
string containing the word "fly", which was passed to the first call to
"animalInFood". Similarly, the closure invoked at line 22 prints a string
containing the word "frog", which was passed to the second call to
"animalInFood".
********************************
I don't know what I'm supposed to get from this. It is not well written in
my opinion and I fail to get the point of even reading it. Closures seem to
be very important however, and understanding closures would seem to help one
understand classes, too. Thanks
>Subject: Re: referencing, closures, classes
>Date: Thu, 18 Sep 2003 21:41:40 +0200
>
>X-Ftn-To: David McDivitt
>
>David McDivitt <x12code-del@del-yahoo.com> wrote:
>>The key seems to be basic referencing, which is easy to understand, coupled
>>with anonymous referencing, which is also easy to understand. With closures
>>and classes, the problem is understanding what is being left behind and why.
>>What exactly is the syntax doing? It seems the way closures are created is
>>the manner in which a routine exits. The author left a good trail, with all
>>the preliminaries in place, but failed to put everything together at the end
>>to enable whatever visualization. I read
>>http://www.perldoc.com/perl5.6/pod/perltoot.html. Though quite good, it
>>still did not complete the picture for me. Any comments would be
>>appreciated. Thanks
>
>Closure is a /subroutine/ which refers to lexical variables declared outside
>the subroutine itself.. so Damian defines closures in OO Perl.
>
>What you're missing in your picture?
------------------------------
Date: Thu, 18 Sep 2003 17:15:36 -0500
From: David McDivitt <x12code-del@del-yahoo.com>
Subject: Re: referencing, closures, classes
Message-Id: <7sakmv4t55mqej430t2qbd93h2qa9hkqle@4ax.com>
The book has been OK to present. When things get too complex it breaks down,
and the book seems a recital to someone already knowledgeable. It does give
a good plan. One thing I don't like is the way it talks in ridiculously
simple terms sometimes, as if to an infant, then glosses over crucial stuff
with no descriptive effort at all. Each little thing has one time slice. If
easy, the one thing is spread monotonously across the entire timeslice. If
difficult, the one thing is crammed into the same size timeslice.
I took two Java classes and in the second Deitel, "Java How to Program" was
used. For the most part it was OK. The entire book was also on the
accompanying CD, as well as program and runtime examples I could just click
on.
I was hoping to get the same thing this time; CD version of the book, etc.
Boy am I disappointed.
>From: Charlton Wilbur <cwilbur@mithril.chromatico.net>
>Subject: Re: referencing, closures, classes
>Date: Thu, 18 Sep 2003 21:30:06 GMT
>
>>>>>> "UG" == Uri Guttman <uri@stemsystems.com> writes:
>
> UG> get a better book. this one sounds awful from only your
> UG> description.
>
>The Deitel & Deitel _C: How to Program_ was a very good book; it's the
>one I was taught C from. I've since replaced it with K&R2 (which got
>stolen) and with Harbison & Steele, but it was a very good book all
>the same.
>
>Their _C++: How to Program_ was disappointing, as was their _Java: How
>to Program_. I'm not surprised that the Perl one is horrible, alas.
>
>Charlton
>
------------------------------
Date: Thu, 18 Sep 2003 17:20:43 -0600
From: Eric Schwartz <emschwar@pobox.com>
Subject: Re: referencing, closures, classes
Message-Id: <eton0d1d6pg.fsf@wormtongue.emschwar>
David McDivitt <x12code-del@del-yahoo.com> writes:
> 5 use warnings;
> 6 use strict;
Yaay for these, anyway! Too many books omit them.
> 8 sub animalInFood
> 9 {
> 10 my $x = shift();
Here, x is a lexical. Don't obsess about the fact that it exists in a sub.
> 11 return sub #what the hell does return sub mean?
> 12 { #no description given anywhere
I assume you know what return does (returns a value or values from a
function) and what sub does (defines a subroutine). This combines the
two-- defines a subroutine, and returns a reference to it.
> 13 my $y = shift();
The subroutine being created has one parameter.
> 14 print( "There is a $x in my $y!\n" );
Here's where "closure" comes into it. Notice that this anonymous
subroutine refers to $x. Since $x is a lexical variable outside the
scope of this subroutine, its value is captured /as of the time the
sub is defined/, and that value will be used whenever the sub is
returned.
> 15 };
> 16 }
> 17
> 18 my &$flyInFood = animalInFood( "fly" );
The & is unnecessary here. animalInFood is returning a reference to
an anonymous sub that takes one argument. In that sub, $x is set to
"fly", since that's the value it had at the time the sub was defined,
and $y will take whatever value you give it when you call the sub.
> 19 my &$frogInFood = animalInFood( "frog" );
Likewise, remove the &. Here, animalInFood returns a reference to a
subroutine in which takes one argument, and where $x is set to "frog".
> 21 &$flyInFood( "soup" );
> 22 &$frogInFood( "coffee" );
Here, you dereference the subroutines you created by calling
animalInFood above, and pass them arguments. They retain the value of
$x from when they were defined, and take $y from the arguments you
pass to them.
You can also call these sub refs as:
$flyInFood->("soup")
$frogInFood->("coffee")
> I don't know what I'm supposed to get from this. It is not well written in
> my opinion and I fail to get the point of even reading it. Closures seem to
> be very important however, and understanding closures would seem to help one
> understand classes, too. Thanks
99% of the Perl programs I write don't need or use closures. I'd say
100%, except that I'll bet I've done it once or twice, and just forgot
about it. I have no idea whether my experience will reflect yours,
however.
It's confusing and hard to follow when things are upside-down.
Why not?
Also, please do not top-post.
If you read the Posting Guidelines, which are posted here regularly,
you'll be more likely to get better responses than mine, I'm sure.
-=Eric
--
Come to think of it, there are already a million monkeys on a million
typewriters, and Usenet is NOTHING like Shakespeare.
-- Blair Houghton.
------------------------------
Date: Fri, 19 Sep 2003 00:12:42 GMT
From: Bob Walton <bwalton@rochester.rr.com>
Subject: Re: referencing, closures, classes
Message-Id: <3F6A49F0.4060404@rochester.rr.com>
David McDivitt wrote:
...
>
> 5 use warnings;
> 6 use strict;
> 7
> 8 sub animalInFood
> 9 {
> 10 my $x = shift();
> 11 return sub #what the hell does return sub mean?
> 12 { #no description given anywhere
The "return sub {...}" is returning a code reference to the anonymous
sub consisting of the code between the braces (see perldoc -f sub to see
what the sub function does). Bear in mind that when there is no
semicolon or ending brace, the Perl expression isn't over yet -- it
continues on subsequent lines. In this case, that anonymous sub is a
closure because it uses $x, a lexical variable which was already defined
in the scope of the sub at the time the sub was defined. You will note
that if you call the returned code reference, it remembers the value of
the in-scope lexical at the time the sub was defined. There is no magic
to this, and actually, it barely warrants the special name "closure"
(which name, as far as I can tell, might as well be any made-up name, as
the ordinary concept of "closure" seems to bear no relation to this).
It is simply a matter of the normal behavior of scoped lexical
variables. Each time "animalInFood" is called, another anonymous code
reference consisting of a sub with $x already in its scope with the
value is has at the moment is created. When that code reference is
executed later, it remembers its $x. That's all there is to it. For
fun, try writing closures which modify their already-in-scope variables.
> 13 my $y = shift();
> 14 print( "There is a $x in my $y!\n" );
> 15 };
> 16 }
> 17
> 18 my &$flyInFood = animalInFood( "fly" );
> 19 my &$frogInFood = animalInFood( "frog" );
> 20
> 21 &$flyInFood( "soup" );
> 22 &$frogInFood( "coffee" );
>
> There is a fly in my soup!
> There is a frog in my coffee!
> fig 13.8
>
> You can see that "animalInFood returns closures because when we assign
> variable "$flyInFood" the closure returned by passing "animalInFood" the
> word "fly", then call "animalInFood" again with the value "frog". Each
> closure is stored in a reference. These references are used at lines 21 and
> 22 to invoke each closure. Note that the closure invoked at line 21 prints a
> string containing the word "fly", which was passed to the first call to
> "animalInFood". Similarly, the closure invoked at line 22 prints a string
> containing the word "frog", which was passed to the second call to
> "animalInFood".
>
> ********************************
>
> I don't know what I'm supposed to get from this. It is not well written in
> my opinion and I fail to get the point of even reading it. Closures seem to
> be very important however, and understanding closures would seem to help one
> understand classes, too. Thanks
Well, it seems fairly clear to me, but I do think it would be better to
describe the phenomenon as simply the expected behavior of scoped
lexical variables, just exactly like what happens in any other scope. I
don't know how important they are -- I guess they can be pretty
important for generating obfuscated code, maybe. And they do let you
create truly private variables which absolutely nothing can touch other
than your own methods when you create modules. But that probably isn't
very important either (hey, someone can just modify the code of your
module if they really want to, so what did it really gain? Oh, yeah, it
obfuscated it to the point where they couldn't understand it anyway, so
maybe it did keep your module private :-).).
...
--
Bob Walton
------------------------------
Date: 18 Sep 2003 19:34:06 GMT
From: Abigail <abigail@abigail.nl>
Subject: Re: Regex to detect patterns that do not start with // or <!--
Message-Id: <slrnbmk25e.5ci.abigail@alexandra.abigail.nl>
Mike Grandmasion (surfer97301@yahoo.com) wrote on MMMDCLXX September
MCMXCIII in <URL:news:75821f06.0309181001.377b455b@posting.google.com>:
:) > m{^(?!//|<!--).*the }
:)
:) Yeah I would have though I could negate a grouping like that too but
:) if I change my pattern from:
:)
:) 'out.print.*?[^/][^/].*?the'
What do you think that matches?
:) to
:)
:) 'out.print.*?^(//).*?the'
:)
:) I get no output.
And that surprises you? ^ matches the beginning of the string, so you
are saying you want to match strings that have something before the
beginning of the string. I don't think there are many such strings.
:) > Well, that doesn't compile.
:)
:) Right it is using a perl regular expression being executed through
:) grep on the unix commandline.
That isn't going to work. You can ask questions about Perl regular
expressions here, but for grep, there are other places.
Abigail
--
A perl rose: perl -e '@}>-`-,-`-%-'
------------------------------
Date: 18 Sep 2003 14:36:44 -0700
From: bogdan_czyz@hotmail.com (Bogdan)
Subject: Re: sort issue
Message-Id: <98bf9157.0309181336.2afcc8ff@posting.google.com>
Thanks a lot for remarks and suggestions.
Bogdan
------------------------------
Date: Thu, 18 Sep 2003 22:32:02 GMT
From: Bart Lateur <bart.lateur@pandora.be>
Subject: Re: string to integer
Message-Id: <8eckmvs2su0a1pc2a2m9fi6kr1nhkthng2@4ax.com>
Helgi Briem wrote:
>For posting guidelines ot comp.lang.perl.misc,
>read the regular Posting Guidelines:
>
>http://mail.augustmail.com/~tadmc/clpmisc.shtml
Note to the OP: even though this page is written by and posted on the
website of Tad McClellan, here also present, the regulars here have
generally approved it. These aren't Tad's rules, these are OUR rules.
--
Bart.
------------------------------
Date: 18 Sep 2003 13:04:15 -0700
From: shambo_p@yahoo.com (Shambo)
Subject: Re: XML ( WML in particular)
Message-Id: <72190192.0309181204.616b9724@posting.google.com>
"Brian" <b.dara@tester.com> wrote in message news:<xW3ab.1961$DM5.18462@newsfep4-glfd.server.ntli.net>...
> Hi,
>
> I have a script that generates some WML, and I would like this to be written
> to a file using the UTF-8 characterset. Currently it is just written
> normally , with the affect that my phone wont recognise it.
>
> How is this done in Perl?
>
> Thanks
open (FILE, ">:utf8", "/somepath/somefile.wml")
This will write your file as UTF-8, change "somepath" to your target
path and file name.
(Slightly OT to Perl) WML is very unforgiving with its range of
displayable characters. Others here may disagree with this method, but
I've found it to be very helpful.
s/([\x{80}-\x{FFFF}])/'&#' . ord($1) . ';'/gse;
That line will change characters above the first 128 ASCII characters
to their numeric equivalent, which WML should be able to display. I
have not personally encountered very high range characters in my WML,
such as "?" and other ligature type characters, but letters with
accents and umlauts display fine in WML when they are converted to
their numeric equivalent.
Also (off-topic to Perl), make sure you keep your file sizes under
1400 bytes. Older phone browsers don't support larger bytestreams.
------------------------------
Date: Sat, 19 Jul 2003 01:59:56 GMT
From: Bob Walton <bwalton@rochester.rr.com>
Subject: Re:
Message-Id: <3F18A600.3040306@rochester.rr.com>
Ron wrote:
> Tried this code get a server 500 error.
>
> Anyone know what's wrong with it?
>
> if $DayName eq "Select a Day" or $RouteName eq "Select A Route") {
(---^
> dienice("Please use the back button on your browser to fill out the Day
> & Route fields.");
> }
...
> Ron
...
--
Bob Walton
------------------------------
Date: 6 Apr 2001 21:33:47 GMT (Last modified)
From: Perl-Users-Request@ruby.oce.orst.edu (Perl-Users-Digest Admin)
Subject: Digest Administrivia (Last modified: 6 Apr 01)
Message-Id: <null>
Administrivia:
The Perl-Users Digest is a retransmission of the USENET newsgroup
comp.lang.perl.misc. For subscription or unsubscription requests, send
the single line:
subscribe perl-users
or:
unsubscribe perl-users
to almanac@ruby.oce.orst.edu.
To submit articles to comp.lang.perl.announce, send your article to
clpa@perl.com.
To request back copies (available for a week or so), send your request
to almanac@ruby.oce.orst.edu with the command "send perl-users x.y",
where x is the volume number and y is the issue number.
For other requests pertaining to the digest, send mail to
perl-users-request@ruby.oce.orst.edu. Do not waste your time or mine
sending perl questions to the -request address, I don't have time to
answer them even if I did know the answer.
------------------------------
End of Perl-Users Digest V10 Issue 5525
***************************************
