[32883] in Perl-Users-Digest
Perl-Users Digest, Issue: 4161 Volume: 11
daemon@ATHENA.MIT.EDU (Perl-Users Digest)
Mon Mar 3 21:09:37 2014
Date: Mon, 3 Mar 2014 18:09:07 -0800 (PST)
From: Perl-Users Digest <Perl-Users-Request@ruby.OCE.ORST.EDU>
To: Perl-Users@ruby.OCE.ORST.EDU (Perl-Users Digest)
Perl-Users Digest Mon, 3 Mar 2014 Volume: 11 Number: 4161
Today's topics:
Re: grep $re gotcha <john@castleamber.com>
Re: grep $re gotcha <derykus@gmail.com>
Re: grep $re gotcha <ben@morrow.me.uk>
Re: last iteration of a for loop (Tim McDaniel)
Re: last iteration of a for loop <tzz@lifelogs.com>
Re: last iteration of a for loop <ben@morrow.me.uk>
Re: use strict; use warnings; <kaz@kylheku.com>
Re: use strict; use warnings; <rweikusat@mobileactivedefense.com>
Re: use strict; use warnings; <johnblack@nospam.com>
Re: use strict; use warnings; <johnblack@nospam.com>
Re: use strict; use warnings; <rweikusat@mobileactivedefense.com>
Re: use strict; use warnings; <kaz@kylheku.com>
Re: use strict; use warnings; <rweikusat@mobileactivedefense.com>
Re: use strict; use warnings; <triflemenot@protocol.invalid>
Re: use strict; use warnings; <johnblack@nospam.com>
Re: use strict; use warnings; <rweikusat@mobileactivedefense.com>
Re: use strict; use warnings; <ben@morrow.me.uk>
Digest Administrivia (Last modified: 6 Apr 01) (Perl-Users-Digest Admin)
----------------------------------------------------------------------
Date: Mon, 03 Mar 2014 13:44:04 -0600
From: John Bokma <john@castleamber.com>
Subject: Re: grep $re gotcha
Message-Id: <8738izhxtn.fsf@castleamber.com>
Uri Guttman <uri@stemsystems.com> writes:
> actually there is one other case which is not well known and should
> never be used. =~ when given an expression on the right which is not one
> of the ops s///, tr/// or m// or // will treat that expression as
> m//. we usually call it the bind operator (vs newbies who seem to think
> it is a regex or match op) as it binds the left expression to the
> operand on the right. but it will also default to making that right
> operand a regex.
You mean:
$RE_SOMETHING =~ $string
v.s.
/$RE_SOMETHING/ =~ $string
Why should the former never be used?
--
John Bokma j3b
Blog: http://johnbokma.com/ Perl Consultancy: http://castleamber.com/
Perl for books: http://johnbokma.com/perl/help-in-exchange-for-books.html
------------------------------
Date: Mon, 03 Mar 2014 14:54:22 -0800
From: Charles DeRykus <derykus@gmail.com>
Subject: Re: grep $re gotcha
Message-Id: <lf317o$irj$1@speranza.aioe.org>
On 2/28/2014 5:13 PM, Ben Morrow wrote:
>
> Quoth John Bokma <john@castleamber.com>:
>>
>> Maybe not a gotcha for everybody, but I bumped into this today:
>>
>> perl -e '
>> my $re = qr/[aeiou]/;
>> print join( ", ", grep $re, "a".."z" ), "\n";
>> print join( ", ", grep /$re/, "a".."z" ), "\n";
>> '
>> a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z
>> a, e, i, o, u
>>
>> I was expecting grep $re to be short for grep /$re/.
>
> perldoc -f grep? The first argument to grep is an expression; a qr// is
> a reference, so it's always true. split is the only builtin which
> implicitly treats its argument as a regex.
>
I wonder how daunting it'd be for the parser to detect and auto-correct
a bare qr compilation for TIMTOWTDI's sake. Or at least warn you if it
found one and had attempted to DTRT. Train wrecks still possible but
much easier to sleuth.
--
Charles DeRykus
------------------------------
Date: Tue, 4 Mar 2014 00:30:15 +0000
From: Ben Morrow <ben@morrow.me.uk>
Subject: Re: grep $re gotcha
Message-Id: <ndjfua-ed5.ln1@anubis.morrow.me.uk>
Quoth Charles DeRykus <derykus@gmail.com>:
> On 2/28/2014 5:13 PM, Ben Morrow wrote:
> > Quoth John Bokma <john@castleamber.com>:
> >>
> >> print join( ", ", grep $re, "a".."z" ), "\n";
> >> print join( ", ", grep /$re/, "a".."z" ), "\n";
> >
> > perldoc -f grep? The first argument to grep is an expression; a qr// is
> > a reference, so it's always true. split is the only builtin which
> > implicitly treats its argument as a regex.
>
> I wonder how daunting it'd be for the parser to detect and auto-correct
> a bare qr compilation for TIMTOWTDI's sake.
Impossible without data-flow analysis, which is generally considered
infeasible in Perl. $re above is not a bare qr//, it's a variable
holding a qr//.
> Or at least warn you if it found one and had attempted to DTRT.
A runtime warning if the expression passed to grep is a single variable
containing a qr// might be sensible.
Ben
------------------------------
Date: Mon, 3 Mar 2014 18:14:56 +0000 (UTC)
From: tmcd@panix.com (Tim McDaniel)
Subject: Re: last iteration of a for loop
Message-Id: <lf2gr0$p7o$1@reader1.panix.com>
In article <87lhwrbggp.fsf@lifelogs.com>,
Ted Zlatanov <tzz@lifelogs.com> wrote:
>When you have to use older Perls a lot, like I do, you tend to avoid
>when/default.
Isn't it also experimental and complicated?
--
Tim McDaniel, tmcd@panix.com
------------------------------
Date: Mon, 03 Mar 2014 14:49:30 -0500
From: Ted Zlatanov <tzz@lifelogs.com>
Subject: Re: last iteration of a for loop
Message-Id: <87ha7fawqd.fsf@lifelogs.com>
On Mon, 3 Mar 2014 18:14:56 +0000 (UTC) tmcd@panix.com (Tim McDaniel) wrote:
TM> In article <87lhwrbggp.fsf@lifelogs.com>,
TM> Ted Zlatanov <tzz@lifelogs.com> wrote:
>> When you have to use older Perls a lot, like I do, you tend to avoid
>> when/default.
TM> Isn't it also experimental and complicated?
I'm not against it, but personally prefer the semantics of Lisp's cond
or C/C++/Java's switch. Recently I've found the `pcase' macro in Emacs
Lisp, which "performs ML-style pattern matching," interesting as well.
I think at least half of the fun in programming is trying new toys :)
Ted
------------------------------
Date: Tue, 4 Mar 2014 00:24:38 +0000
From: Ben Morrow <ben@morrow.me.uk>
Subject: Re: last iteration of a for loop
Message-Id: <63jfua-ed5.ln1@anubis.morrow.me.uk>
Quoth tmcd@panix.com:
> In article <87lhwrbggp.fsf@lifelogs.com>,
> Ted Zlatanov <tzz@lifelogs.com> wrote:
> >When you have to use older Perls a lot, like I do, you tend to avoid
> >when/default.
>
> Isn't it also experimental and complicated?
Smartmatch, given and when have recently (5.18) been retroactively
marked experimental. 5.18 will warn if it sees them, unless you've
disabled the warning: see perl518delta. The semantics are rather badly
designed, and are likely to change, if the features don't simply do away
altogether.
Ben
------------------------------
Date: Mon, 3 Mar 2014 16:19:36 +0000 (UTC)
From: Kaz Kylheku <kaz@kylheku.com>
Subject: Re: use strict; use warnings;
Message-Id: <20140303081542.601@kylheku.com>
On 2014-03-03, Rainer Weikusat <rweikusat@mobileactivedefense.com> wrote:
> Kaz Kylheku <kaz@kylheku.com> writes:
>> On 2014-03-02, John Black <johnblack@nospam.com> wrote:
>>> computer programming issue, namely array indexing? Everyone in computers
>>> knows that computers start counting at 0 whereas most people if you asked
>>> them to count to 10 would say
>>>
>>> 1, 2, 3, ...
>>
>> Actually, everyone starts counting at zero.
>>
>> For instance, how do you count apples in a basket?
>>
>> If you use your fingers, for instance, you first close your fist, hiding all your
>> fingers. That's a zero. You are initializing a counter to zero.
>>
>> This is when counting beings, not when the first item is noted.
>
> Considering 'counting begins before something was counted', every
> human being on this planet must obviously be constantly counting
> everything which can conceivably be counted, IOW, this definition has no
> meaning.
No, only this nonsensical interpretation thereof.
>> In computer arrays, we use as the element index the count of the number of
>> direct and indirect predecessors which that element has in the sequence: how
>> many elements we have to skip or displace over to reach that item.
>
> That's something which happens to be true in C because of the
> equivalence of subscripting and pointer arithmetic and it has spread to
> all kinds of other languages from there.
The manual for Lisp 1.5, dated 1962, describes arrays that are 0 based.
------------------------------
Date: Mon, 03 Mar 2014 16:49:18 +0000
From: Rainer Weikusat <rweikusat@mobileactivedefense.com>
Subject: Re: use strict; use warnings;
Message-Id: <87wqgbtegh.fsf@sable.mobileactivedefense.com>
Kaz Kylheku <kaz@kylheku.com> writes:
> On 2014-03-03, Rainer Weikusat <rweikusat@mobileactivedefense.com> wrote:
>> Kaz Kylheku <kaz@kylheku.com> writes:
>>> On 2014-03-02, John Black <johnblack@nospam.com> wrote:
>>>> computer programming issue, namely array indexing? Everyone in computers
>>>> knows that computers start counting at 0 whereas most people if you asked
>>>> them to count to 10 would say
>>>>
>>>> 1, 2, 3, ...
>>>
>>> Actually, everyone starts counting at zero.
>>>
>>> For instance, how do you count apples in a basket?
>>>
>>> If you use your fingers, for instance, you first close your fist, hiding all your
>>> fingers. That's a zero. You are initializing a counter to zero.
>>>
>>> This is when counting beings, not when the first item is noted.
>>
>> Considering 'counting begins before something was counted', every
>> human being on this planet must obviously be constantly counting
>> everything which can conceivably be counted, IOW, this definition has no
>> meaning.
>
> No, only this nonsensical interpretation thereof.
That's no interpretation. You wrote that 'counting begins before
something is actually counted'. That is during indeterminate period of time
before 'the first item is counted'. It's start can't be known, only its
end.
>>> In computer arrays, we use as the element index the count of the number of
>>> direct and indirect predecessors which that element has in the sequence: how
>>> many elements we have to skip or displace over to reach that item.
>>
>> That's something which happens to be true in C because of the
>> equivalence of subscripting and pointer arithmetic and it has spread to
>> all kinds of other languages from there.
>
> The manual for Lisp 1.5, dated 1962, describes arrays that are 0
> based.
This doesn't contradict my statement. Also, on page 11, the IBM 704
FORTRAN manual states that
"The minimum value which a subscript may assume in the object
program is +1".
https://www.fortran.com/ibm.html
Not to mention the other example of "people on computing" who chose to
do differently than they monad collective named "Kaz Kylheku" which
chose to refer to itself as "we" "all of you" have chosen to ignore.
------------------------------
Date: Mon, 3 Mar 2014 10:49:38 -0600
From: John Black <johnblack@nospam.com>
Subject: Re: use strict; use warnings;
Message-Id: <MPG.2d7e6e9ee08b4f859897bf@news.eternal-september.org>
In article <3l27h9tdr4ejhur3c936qr9ubno0qo3i9q@4ax.com>, triflemenot@protocol.invalid says...
>
> On Sun, 2 Mar 2014 13:40:22 -0600, John Black <johnblack@nospam.com>
> wrote:
>
> > Everyone in computers knows that computers start counting at 0
>
> PL/I can start array index at 1. Maybe Perl too.
Whether or not you use the zeroth location, its available if you so wish...
John Black
------------------------------
Date: Mon, 3 Mar 2014 10:59:30 -0600
From: John Black <johnblack@nospam.com>
Subject: Re: use strict; use warnings;
Message-Id: <MPG.2d7e70f02dbedff29897c0@news.eternal-september.org>
In article <20140302172154.962@kylheku.com>, kaz@kylheku.com says...
> On 2014-03-02, John Black <johnblack@nospam.com> wrote:
> > computer programming issue, namely array indexing? Everyone in computers
> > knows that computers start counting at 0 whereas most people if you asked
> > them to count to 10 would say
> >
> > 1, 2, 3, ...
>
> Actually, everyone starts counting at zero.
>
> For instance, how do you count apples in a basket?
>
> If you use your fingers, for instance, you first close your fist, hiding all your
> fingers. That's a zero. You are initializing a counter to zero.
>
> This is when counting beings, not when the first item is noted.
Yes, you are right. Counting was the wrong situation. We are talking about array indexing
and arrays are a collection of locations indexed by a number. That number usually starts at
0. Yes, you can avoid using that location if you so wish, but I'm talking about what is
almost always done in the computer industry. Computer addresses (relative or absolute) are
the same kind of thing. They start at 0. The average person not in computers numbering
storage locations, like lockers, like parking spots, like mailslots, like a million examples,
does not start the indexing at 0 - they start at 1. That's why I was saying its really not
relevent how people who are not in the computer industry number storage locations. Its more
relevent how people who are in computers do it.
John Black
------------------------------
Date: Mon, 03 Mar 2014 17:22:48 +0000
From: Rainer Weikusat <rweikusat@mobileactivedefense.com>
Subject: Re: use strict; use warnings;
Message-Id: <87siqztcwn.fsf@sable.mobileactivedefense.com>
John Black <johnblack@nospam.com> writes:
> In article <20140302172154.962@kylheku.com>, kaz@kylheku.com says...
>> On 2014-03-02, John Black <johnblack@nospam.com> wrote:
>> > computer programming issue, namely array indexing? Everyone in computers
>> > knows that computers start counting at 0 whereas most people if you asked
>> > them to count to 10 would say
>> >
>> > 1, 2, 3, ...
>>
>> Actually, everyone starts counting at zero.
>>
>> For instance, how do you count apples in a basket?
>>
>> If you use your fingers, for instance, you first close your fist, hiding all your
>> fingers. That's a zero. You are initializing a counter to zero.
>>
>> This is when counting beings, not when the first item is noted.
>
> Yes, you are right. Counting was the wrong situation. We are talking about array indexing
> and arrays are a collection of locations indexed by a number. That number usually starts at
> 0.
That number "doesn't usually start at 0". It starts at 0 in some
programming languages and at 1 in some others. In yet other programming
languages, any contiguous subset of the set of integers can be used as
array indices. In yet other languages, any ordered set (aka 'type') can
be used as index set.
------------------------------
Date: Mon, 3 Mar 2014 17:31:03 +0000 (UTC)
From: Kaz Kylheku <kaz@kylheku.com>
Subject: Re: use strict; use warnings;
Message-Id: <20140303091627.291@kylheku.com>
On 2014-03-03, Rainer Weikusat <rweikusat@mobileactivedefense.com> wrote:
> Kaz Kylheku <kaz@kylheku.com> writes:
>> On 2014-03-03, Rainer Weikusat <rweikusat@mobileactivedefense.com> wrote:
>>> Kaz Kylheku <kaz@kylheku.com> writes:
>>>> On 2014-03-02, John Black <johnblack@nospam.com> wrote:
>>>>> computer programming issue, namely array indexing? Everyone in computers
>>>>> knows that computers start counting at 0 whereas most people if you asked
>>>>> them to count to 10 would say
>>>>>
>>>>> 1, 2, 3, ...
>>>>
>>>> Actually, everyone starts counting at zero.
>>>>
>>>> For instance, how do you count apples in a basket?
>>>>
>>>> If you use your fingers, for instance, you first close your fist, hiding all your
>>>> fingers. That's a zero. You are initializing a counter to zero.
>>>>
>>>> This is when counting beings, not when the first item is noted.
>>>
>>> Considering 'counting begins before something was counted', every
>>> human being on this planet must obviously be constantly counting
>>> everything which can conceivably be counted, IOW, this definition has no
>>> meaning.
>>
>> No, only this nonsensical interpretation thereof.
>
> That's no interpretation. You wrote that 'counting begins before
> something is actually counted'.
Yes; it begins with the intent to count something, followed by the preparation:
initializing a counter to zero. These occur before the first item is noted
(if there exists a first item).
> That is during indeterminate period of time
> before 'the first item is counted'. It's start can't be known, only its
> end.
>
>>>> In computer arrays, we use as the element index the count of the number of
>>>> direct and indirect predecessors which that element has in the sequence: how
>>>> many elements we have to skip or displace over to reach that item.
>>>
>>> That's something which happens to be true in C because of the
>>> equivalence of subscripting and pointer arithmetic and it has spread to
>>> all kinds of other languages from there.
>>
>> The manual for Lisp 1.5, dated 1962, describes arrays that are 0
>> based.
>
> This doesn't contradict my statement.
Yes it does; your statement clearly conveys (to a native English speaker) that
zero-based arrays originated in C, and spread to other languages.
(In Asperger English, maybe it doesn't.)
------------------------------
Date: Mon, 03 Mar 2014 18:24:08 +0000
From: Rainer Weikusat <rweikusat@mobileactivedefense.com>
Subject: Re: use strict; use warnings;
Message-Id: <87ob1nta2f.fsf@sable.mobileactivedefense.com>
John Black <johnblack@nospam.com> writes:
> In article <20140302172154.962@kylheku.com>, kaz@kylheku.com says...
>> On 2014-03-02, John Black <johnblack@nospam.com> wrote:
>> > computer programming issue, namely array indexing? Everyone in computers
>> > knows that computers start counting at 0 whereas most people if you asked
>> > them to count to 10 would say
>> >
>> > 1, 2, 3, ...
>>
>> Actually, everyone starts counting at zero.
>>
>> For instance, how do you count apples in a basket?
>>
>> If you use your fingers, for instance, you first close your fist, hiding all your
>> fingers. That's a zero. You are initializing a counter to zero.
>>
>> This is when counting beings, not when the first item is noted.
>
> Yes, you are right. Counting was the wrong situation. We are talking
> about array indexing
JFTR: The original question/ claim was NOT about array indexing which is
- traditional limitations of C-derived languages notwithstanding - a
completely different animal, but about 'ordinals' assigned to items in a
sequence, specifically, that "the 1st item" would be the one with no
items in front of it, "the 2nd item" the one with one item in front of
it and so on, this being the usual convention based on counting items as
they appear in sequence and hence, that $a[10] would be 'the eleventh
item of @a, as counted from the front'. Similarly, for an array @a of size
n, the element $a[n - x] is the x-th item of @a when counting from the
back. There's an underlying, abstract concept called 'a sequence' here
which is useful in its own right.
------------------------------
Date: Mon, 03 Mar 2014 19:39:10 +0000
From: Trifle Menot <triflemenot@protocol.invalid>
Subject: Re: use strict; use warnings;
Message-Id: <s7j9h9havnj24m6ijn170ks92vt4ukcfkm@4ax.com>
On Mon, 03 Mar 2014 18:24:08 +0000, Rainer Weikusat
<rweikusat@mobileactivedefense.com> wrote:
> There's an underlying, abstract concept called 'a sequence' here
> which is useful in its own right.
Sequence is also the first fundamental element of programming. It seems
so trivial compared to the other two, that programmers tend to disregard
its importance.
But any sequence of more than 3 steps is hard for humans to optimize.
That means programmers write a lot of sloppy programs. It also means
humans should leave DNA to God.
------------------------------
Date: Mon, 3 Mar 2014 14:17:12 -0600
From: John Black <johnblack@nospam.com>
Subject: Re: use strict; use warnings;
Message-Id: <MPG.2d7e9f2f787374079897c1@news.eternal-september.org>
In article <87siqztcwn.fsf@sable.mobileactivedefense.com>, rweikusat@mobileactivedefense.com
says...
>
> John Black <johnblack@nospam.com> writes:
> > In article <20140302172154.962@kylheku.com>, kaz@kylheku.com says...
> >> On 2014-03-02, John Black <johnblack@nospam.com> wrote:
> >> > computer programming issue, namely array indexing? Everyone in computers
> >> > knows that computers start counting at 0 whereas most people if you asked
> >> > them to count to 10 would say
> >> >
> >> > 1, 2, 3, ...
> >>
> >> Actually, everyone starts counting at zero.
> >>
> >> For instance, how do you count apples in a basket?
> >>
> >> If you use your fingers, for instance, you first close your fist, hiding all your
> >> fingers. That's a zero. You are initializing a counter to zero.
> >>
> >> This is when counting beings, not when the first item is noted.
> >
> > Yes, you are right. Counting was the wrong situation. We are talking about array indexing
> > and arrays are a collection of locations indexed by a number. That number usually starts at
> > 0.
>
> That number "doesn't usually start at 0". It starts at 0 in some
> programming languages and at 1 in some others. In yet other programming
> languages, any contiguous subset of the set of integers can be used as
> array indices. In yet other languages, any ordered set (aka 'type') can
> be used as index set.
At one point (a long time ago) I thought that Perl did not need two different types of
arrays: list array vs. associative arrays.
a[5] = 100;
a[6] = "Hello";
seemed equivalent to the hash notation:
a{5} = 100;
a{6} = "Hello";
With a hash I could also do:
a{Greeting} = "Hello";
but that just made it seem like the hash was still the same thing but just allowed for more
flexible indexing (the index didn't have to be an integer).
But then I realized that a hash was not more general and was really just a different animal.
Because you can't do push, pop, shift, unshift, splice, etc. etc. You can't do:
a{-1} to get the last element either. Arrays are ordered lists and hashes are just content
addressable memory.
John Black
------------------------------
Date: Mon, 03 Mar 2014 21:35:00 +0000
From: Rainer Weikusat <rweikusat@mobileactivedefense.com>
Subject: Re: use strict; use warnings;
Message-Id: <87vbvv7ypn.fsf@sable.mobileactivedefense.com>
John Black <johnblack@nospam.com> writes:
> In article <87siqztcwn.fsf@sable.mobileactivedefense.com>, rweikusat@mobileactivedefense.com
>> John Black <johnblack@nospam.com> writes:
[...]
>>> We are talking about array indexing and arrays are a collection of
>>> locations indexed by a number. That number usually starts at
>>> 0.
>>
>> That number "doesn't usually start at 0". It starts at 0 in some
>> programming languages and at 1 in some others. In yet other programming
>> languages, any contiguous subset of the set of integers can be used as
>> array indices. In yet other languages, any ordered set (aka 'type') can
>> be used as index set.
>
> At one point (a long time ago) I thought that Perl did not need two
> different types of arrays: list array vs. associative arrays.
>
> a[5] = 100; a[6] = "Hello";
>
> seemed equivalent to the hash notation:
>
> a{5} = 100; a{6} = "Hello";
>
> With a hash I could also do:
>
> a{Greeting} = "Hello";
>
> but that just made it seem like the hash was still the same thing but
> just allowed for more flexible indexing (the index didn't have to be
> an integer).
That's how it works in 'some programming languages', prominent examples
would be PHP and AWK.
> But then I realized that a hash was not more general and was really
> just a different animal. Because you can't do push, pop, shift,
> unshift, splice, etc. etc. You can't do:
>
> a{-1} to get the last element either. Arrays are ordered lists and
> hashes are just content addressable memory.
I think the easiest way to understand the different concepts in Perl is
to be aware of the fact that perl is something like a library sitting on
top of C. This means a Perl array is basically a C array, except that
its members are 'Perl objects' (scalars aka 'SV *'), that its memory is
managed automatically and 'some associated meta-information' is
maintained by the runtime, specifically, the current size. And 'a hash'
is just that: An associative array implemented as hash table using
separate chaining. Perl arrays are indexed in exactly the same way as C
arrays because this indexing is performed by C code working on C arrays
(I'm purposely ignoring $[ here on the pretext that it never existed
:-).
But the same isn't necessarily true for other programming languages and
in the most general case, an array is 'some kind of data structure'
supposed to map (all) members of some kind of ordered set of discrete,
unique values to 'something else' (such a set is commonly called 'a
type' or 'a subtype' if it is a subset of another set). Eg, in Pascal,
var a: array [-23 .. 5] of integer
is an array of integers whose index type is a subtype of the type
'integer'. An index type can also be an enumeration, eg, assuming
the declarations
type animals = (cat, dog, bird, cow, platypus);
var livestock : array of [animals] of integer;
this would be valid assignment statements
livestock[platypus] := 10;
livestock[cow] := 5;
But livestock still has a first element, namely, livestock[cat] and
referring to that as the 'cath element' while the first element of the a
array would be called 'the -23rd element' and the first element of a
Perl array @a 'the zeroth element' (or, more correctly, 'the $[th
element, followed by the '#[ + 1'th element
(hashmark-squareopenbracket-plus-one-th element) would just introduce an
open-ended set of different, context-dependent names for the same thing
(array element whose associated index is the smallest value in the index
set aka 'the first element').
------------------------------
Date: Tue, 4 Mar 2014 00:27:42 +0000
From: Ben Morrow <ben@morrow.me.uk>
Subject: Re: use strict; use warnings;
Message-Id: <u8jfua-ed5.ln1@anubis.morrow.me.uk>
Quoth Trifle Menot <triflemenot@protocol.invalid>:
>
> That means programmers write a lot of sloppy programs. It also means
> humans should leave DNA to God.
I've got a Dr Dawkins for you on line 3...
Ben
------------------------------
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:
To submit articles to comp.lang.perl.announce, send your article to
clpa@perl.com.
Back issues are available via anonymous ftp from
ftp://cil-www.oce.orst.edu/pub/perl/old-digests.
#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 V11 Issue 4161
***************************************
