Noob trying to understand simple Perl grep statement

Discussion in 'Perl Misc' started by walterbyrd, Dec 2, 2008.

  1. walterbyrd

    walterbyrd Guest

    This is from the perl objects book.

    my @required = qw(preserver sunscreen water_bottle jacket);
    my @skipper = qw(blue_shirt hat jacket preserver sunscreen);
    for my $item (@required) {
    unless (grep $item eq $_, @skipper) { # not found in list?
    print "skipper is missing $item.\n";
    }
    }

    I don't understand this line:

    unless (grep $item eq $_, @skipper)

    I understand that $item is each item in the @required array. I am
    guessing that the @required array is what is being grep'd. But what is
    $_ ? Is that also each item from the @required array? If so, why not
    just use the $item variable again? And what does >>$_, @skipper<<
    mean? What is with the comma? Is that supposed to mean: grep $item
    @skipper?

    Is this supposed to check if the skipper is missing any required item?
    Why not:

    unless (grep $item @required eq grep $item @skipper)
    walterbyrd, Dec 2, 2008
    #1
    1. Advertising

  2. walterbyrd

    Willem Guest

    walterbyrd wrote:
    ) I don't understand this line:
    )
    ) unless (grep $item eq $_, @skipper)

    Let's break it into pieces then:

    grep $item eq $_ , @skipper

    grep <something> @skipper
    Means: Return each item from @skipper for which <something> is true.

    Furthermore, inside <something>, the variable $_ is the current item from
    @skipper under consideration.

    So:
    grep $item eq $_ , @skipper

    Means:
    Return each item from @skipper for which >> $item eq $_ << is true.
    Or in other words:
    Return each item from @skipper that is equal to $item.

    And the last bit is unless(), which means that the returned array is being
    looked at as a truth value. An array is true if it contains elements.


    Simple, huh ? Well, that's Perl for you. ;-)



    SaSW, Willem
    --
    Disclaimer: I am in no way responsible for any of the statements
    made in the above text. For all I know I might be
    drugged or something..
    No I'm not paranoid. You all think I'm paranoid, don't you !
    #EOT
    Willem, Dec 2, 2008
    #2
    1. Advertising

  3. Willem <> wrote:
    > walterbyrd wrote:
    > ) I don't understand this line:
    > )
    > ) unless (grep $item eq $_, @skipper)


    > And the last bit is unless(), which means that the returned array is being
    > looked at



    There is no returned array. There is not even a returned list.

    There is only the return value from grep() in a scalar context.

    perldoc -f grep

    In scalar context, returns the number of times the expression was true.


    --
    Tad McClellan
    email: perl -le "print scalar reverse qq/moc.noitatibaher\100cmdat/"
    Tad J McClellan, Dec 2, 2008
    #3
  4. walterbyrd <> wrote:
    > This is from the perl objects book.
    >
    > my @required = qw(preserver sunscreen water_bottle jacket);
    > my @skipper = qw(blue_shirt hat jacket preserver sunscreen);
    > for my $item (@required) {
    > unless (grep $item eq $_, @skipper) { # not found in list?
    > print "skipper is missing $item.\n";
    > }
    > }
    >
    > I don't understand this line:
    >
    > unless (grep $item eq $_, @skipper)
    >
    > I understand that $item is each item in the @required array. I am
    > guessing that the @required array is what is being grep'd.



    No, the @skipper array is what is being grep'd.


    > But what is
    > $_ ?



    One of the elements from the @skipper array.


    > And what does >>$_, @skipper<<
    > mean? What is with the comma?



    That is the syntax for calling grep:

    perldoc -f grep

    =item grep EXPR,LIST

    It says that a comma is required after the expression.

    (The expression for grep() is the "$item eq $_" part above).


    > Is that supposed to mean: grep $item
    > @skipper?



    No, because that would be a syntax error.


    > unless (grep $item @required eq grep $item @skipper)



    More syntax errors...


    --
    Tad McClellan
    email: perl -le "print scalar reverse qq/moc.noitatibaher\100cmdat/"
    Tad J McClellan, Dec 2, 2008
    #4
  5. walterbyrd wrote:
    > This is from the perl objects book.
    >
    > my @required = qw(preserver sunscreen water_bottle jacket);
    > my @skipper = qw(blue_shirt hat jacket preserver sunscreen);
    > for my $item (@required) {
    > unless (grep $item eq $_, @skipper) { # not found in list?
    > print "skipper is missing $item.\n";
    > }
    > }


    That can also be written as:

    my @required = qw(preserver sunscreen water_bottle jacket);
    my @skipper = qw(blue_shirt hat jacket preserver sunscreen);
    for my $item (@required) {
    my $count;
    for $_ (@skipper) {
    $count++ if $item eq $_;
    }
    unless ($count) { # not found in list?
    print "skipper is missing $item.\n";
    }
    }

    > I don't understand this line:
    >
    > unless (grep $item eq $_, @skipper)
    >
    > I understand that $item is each item in the @required array. I am
    > guessing that the @required array is what is being grep'd.


    No, the @skipper array is being grep'd.

    > But what is $_ ?


    The value of the elements of @skipper.

    > Is that also each item from the @required array? If so, why not
    > just use the $item variable again? And what does >>$_, @skipper<<
    > mean? What is with the comma? Is that supposed to mean: grep $item
    > @skipper?


    perldoc -f grep

    grep EXPR,LIST

    > Is this supposed to check if the skipper is missing any required item?
    > Why not:
    >
    > unless (grep $item @required eq grep $item @skipper)


    Because Perl does not work that way.



    John
    --
    Perl isn't a toolbox, but a small machine shop where you
    can special-order certain sorts of tools at low cost and
    in short order. -- Larry Wall
    John W. Krahn, Dec 2, 2008
    #5
  6. walterbyrd

    Guest

    walterbyrd <> wrote:
    > This is from the perl objects book.
    >
    > my @required = qw(preserver sunscreen water_bottle jacket);
    > my @skipper = qw(blue_shirt hat jacket preserver sunscreen);
    > for my $item (@required) {
    > unless (grep $item eq $_, @skipper) { # not found in list?
    > print "skipper is missing $item.\n";
    > }
    > }


    This would probably best be done with a hash rather than an array for at
    least one of those structures.

    >
    > I don't understand this line:
    >
    > unless (grep $item eq $_, @skipper)
    >
    > I understand that $item is each item in the @required array. I am
    > guessing that the @required array is what is being grep'd.


    @skipper is what is being grepped. One time for each thing in @required

    > But what is
    > $_ ? Is that also each item from the @required array?


    In the grep, $_ is set to each thing in the @skipper array in turn.

    > If so, why not
    > just use the $item variable again? And what does >>$_, @skipper<<
    > mean?


    In this context, nothing. You broken down the code incorrectly. The
    grouping is
    ($item eq $_), @skipper
    not
    $item eq ($_,skipper)

    Where the parentheses are meta language that indicate grouping for our
    discussion, not necessarily to be taken as literal Perl syntax.


    > What is with the comma? Is that supposed to mean: grep $item
    > @skipper?


    No, it means (about) the same thing as:

    grep {$item eq $_} @skipper.

    You provide grep with either a block with no comma, then a list; or an
    expression then comma then a list. That is just how grep works.

    See perldoc -f grep:

    grep BLOCK LIST
    grep EXPR,LIST



    > Is this supposed to check if the skipper is missing any required item?


    The overall code, yes. The grep part of the code just return a count
    (Because it is invoked in a scalar context) of the things in @skipper which
    equal whatever happens to be in $item at the moment. if the contents of
    @skipper is unique, then this count will either be 0 (considered false) or
    1 (considered true)

    > Why not:
    >
    > unless (grep $item @required eq grep $item @skipper)


    Because that wouldn't work. It is a syntax error at several levels,
    and semantic error at several more.

    Xho

    --
    -------------------- http://NewsReader.Com/ --------------------
    The costs of publication of this article were defrayed in part by the
    payment of page charges. This article must therefore be hereby marked
    advertisement in accordance with 18 U.S.C. Section 1734 solely to indicate
    this fact.
    , Dec 2, 2008
    #6
  7. walterbyrd

    J.D. Baldwin Guest

    In the previous article, walterbyrd <> wrote:
    > This is from the perl objects book.
    >
    > my @required = qw(preserver sunscreen water_bottle jacket);
    > my @skipper = qw(blue_shirt hat jacket preserver sunscreen);
    > for my $item (@required) {
    > unless (grep $item eq $_, @skipper) { # not found in list?
    > print "skipper is missing $item.\n";
    > }
    > }
    >
    > I don't understand this line:
    >
    > unless (grep $item eq $_, @skipper)
    >
    > I understand that $item is each item in the @required array. I am
    > guessing that the @required array is what is being grep'd. But what
    > is $_ ? Is that also each item from the @required array? If so, why
    > not just use the $item variable again? And what does >>$_,
    > @skipper<< mean? What is with the comma? Is that supposed to mean:
    > grep $item @skipper?


    grep is taking two arguments, separated by the comma. They are:

    1. $item eq $_

    and

    2. @skipper

    The effect of this is to go through elements of @skipper, creating a
    list out of the ones that equal $item (i.e., when the first arg
    evaluates to "true." For any given $item, there will be only one
    matching element (assuming items in @skipper are unique).

    So, when $item is a member of @skipper, the grep will return a
    one-element list consisting of that item. When $item is not found in
    @skipper, the grep will return an empty list.

    In the latter case, when grep returns an empty list, it will trigger
    the block after the unless, printing the value of $item.

    > Is this supposed to check if the skipper is missing any required item?
    > Why not:
    >
    > unless (grep $item @required eq grep $item @skipper)


    OK, first off, grep requires a comma or a block to be syntactically
    correct.

    Second, the first argument of grep is a truth-test, which determines
    whether each given element of the array argument is passed into the
    result list. If $item is non-null, then

    grep $item, @required

    will just be the same as @required (since $item is always true for a
    non-empty string).

    A revised version of your line:

    unless (grep $item, @required eq grep $item, @skipper)

    still has problems because the expression will be true if @required
    and @skipper evaluate to the same value in scalar context. Probably
    not what you intended.
    --
    _+_ From the catapult of |If anyone objects to any statement I make, I am
    _|70|___:)=}- J.D. Baldwin |quite prepared not only to retract it, but also
    \ / |to deny under oath that I ever made it.-T. Lehrer
    ***~~~~----------------------------------------------------------------------
    J.D. Baldwin, Dec 2, 2008
    #7
  8. walterbyrd <> wrote:
    >This is from the perl objects book.
    >
    >my @required = qw(preserver sunscreen water_bottle jacket);
    >my @skipper = qw(blue_shirt hat jacket preserver sunscreen);
    >for my $item (@required) {
    > unless (grep $item eq $_, @skipper) { # not found in list?
    > print "skipper is missing $item.\n";
    > }
    >}
    >
    >I don't understand this line:
    >
    > unless (grep $item eq $_, @skipper)
    >
    >I understand that $item is each item in the @required array.


    Correct.

    > I am
    >guessing that the @required array is what is being grep'd.


    Wrong. It is the @skipper array, that is filtered. After all, that is
    the one, that is passed as argument to grep.

    >But what is
    >$_ ? Is that also each item from the @required array?


    No, it is subsequently set to each element of @skipper to test if $item
    is equal to that element.

    >If so, why not
    >just use the $item variable again? And what does >>$_, @skipper<<
    >mean? What is with the comma?


    You are reading it wrong, adding some parenthesis to make the precedence
    clearer:
    grep ( {$item eq $_},
    @skipper);

    jue
    Jürgen Exner, Dec 2, 2008
    #8
  9. J.D. Baldwin <> wrote:

    > If $item is non-null, then
    >
    > grep $item, @required
    >
    > will just be the same as @required (since $item is always true for a
    > non-empty string).



    $item = '0'; # a non-empty string that is NOT true...


    --
    Tad McClellan
    email: perl -le "print scalar reverse qq/moc.noitatibaher\100cmdat/"
    Tad J McClellan, Dec 2, 2008
    #9
  10. Jürgen Exner <> wrote:
    > walterbyrd <> wrote:


    > You are reading it wrong,



    writing it wrong will probably not help... :)


    > adding some parenthesis to make the precedence
    > clearer:
    > grep ( {$item eq $_},

    ^
    ^
    > @skipper);



    grep ( {$item eq $_} # grep BLOCK LIST
    @skipper);

    or

    grep ( $item eq $_, # grep EXPR,LIST
    @skipper);


    --
    Tad McClellan
    email: perl -le "print scalar reverse qq/moc.noitatibaher\100cmdat/"
    Tad J McClellan, Dec 2, 2008
    #10
  11. walterbyrd

    walterbyrd Guest

    Thank you, that makes more sense.

    On Dec 2, 10:29 am, Willem <> wrote:
    > walterbyrd wrote:
    >
    > ) I don't understand this line:
    > )
    > )   unless (grep $item eq $_, @skipper)
    >
    > Let's break it into pieces then:
    >
    >   grep         $item eq $_              , @skipper
    >
    >   grep    <something>    @skipper
    > Means:  Return each item from @skipper for which <something> is true.
    >
    > Furthermore, inside <something>, the variable $_ is the current item from
    > @skipper under consideration.
    >
    > So:
    >   grep  $item eq $_   , @skipper
    >
    > Means:
    >   Return each item from @skipper for which   >>  $item eq $_  <<  is true.
    > Or in other words:
    >   Return each item from @skipper that is equal to $item.
    >
    > And the last bit is unless(), which means that the returned array is being
    > looked at as a truth value.  An array is true if it contains elements.
    >
    > Simple, huh ?  Well, that's Perl for you. ;-)
    >
    > SaSW, Willem
    > --
    > Disclaimer: I am in no way responsible for any of the statements
    >             made in the above text. For all I know I might be
    >             drugged or something..
    >             No I'm not paranoid. You all think I'm paranoid, don't you !
    > #EOT
    walterbyrd, Dec 2, 2008
    #11
  12. walterbyrd

    J.D. Baldwin Guest

    In the previous article, Tad J McClellan <> wrote:
    > > If $item is non-null, then
    > >
    > > grep $item, @required
    > >
    > > will just be the same as @required (since $item is always true for a
    > > non-empty string).

    >
    >
    > $item = '0'; # a non-empty string that is NOT true...


    Oh, yeah, good point, thanks.
    --
    _+_ From the catapult of |If anyone objects to any statement I make, I am
    _|70|___:)=}- J.D. Baldwin |quite prepared not only to retract it, but also
    \ / |to deny under oath that I ever made it.-T. Lehrer
    ***~~~~----------------------------------------------------------------------
    J.D. Baldwin, Dec 2, 2008
    #12
  13. walterbyrd

    Guest

    On Tue, 2 Dec 2008 09:16:42 -0800 (PST), walterbyrd <> wrote:

    >This is from the perl objects book.
    >
    >my @required = qw(preserver sunscreen water_bottle jacket);
    >my @skipper = qw(blue_shirt hat jacket preserver sunscreen);
    >for my $item (@required) {
    > unless (grep $item eq $_, @skipper) { # not found in list?
    > print "skipper is missing $item.\n";
    > }
    >}
    >
    >I don't understand this line:
    >
    > unless (grep $item eq $_, @skipper)
    >
    >I understand that $item is each item in the @required array. I am
    >guessing that the @required array is what is being grep'd. But what is
    >$_ ? Is that also each item from the @required array? If so, why not
    >just use the $item variable again? And what does >>$_, @skipper<<
    >mean? What is with the comma? Is that supposed to mean: grep $item
    >@skipper?
    >
    >Is this supposed to check if the skipper is missing any required item?
    >Why not:
    >
    > unless (grep $item @required eq grep $item @skipper)


    I don't know what book that is but it looks like you are trying
    to find the intersection of two arrays, which is a FAQ here somewhere.

    Understand that grep just searches the ENTIRE array for whatever it is
    you wan't to find. Each time it finds whatever it is, it collects that
    element into an array. In list/scalar context, returns list or count of
    matched elements.

    This is very inefficient. Whatever grep returns in the list should be
    considerred read-only as well.

    This from perlfunc:

    Similarly, grep returns aliases into the original list, much as a for
    loop's index variable aliases the list elements. That is, modifying an
    element of a list returned by grep (for example, in a foreach, map or
    another grep) actually modifies the element in the original list.
    This is usually something to be avoided when writing clear code.

    In my opinion, this is a major fopah. Only because it aliases en masse,
    as opposed to a temporary itterator.

    Perl grep() is no different than itterating over an ENTIRE array and searching
    for a conditional. If want array, the intermediate variable $_ (an alias for
    the list element) is pushed onto a temporary array. If count, the count is tracked.
    Then returned. There is no way to break out of it, it plods along, mindleslly checking
    every element. This is ok when the possiblity exists on variable pattern matching,
    but when searching for a single existence, not so good.

    So grep would be the slowest in your case.
    A quicker method is this:

    for $req_item (@required)
    {
    $found = 0;
    for $skip_item (@skipper)
    {
    next if ($req_item ne $skip_item);
    $found = 1;
    last; # <- see, you wan't last, why continue?
    }
    print "skipper is missing $req_item.\n" if (!found);
    }

    So then, say you wan't something a little quicker.
    Move up to a hash:

    %skipper;
    for $key (@skipper)
    {
    $skipper{$key}++;
    }
    for $req_item (@required)
    {
    if (!exists ($skipper{$req_item})
    {
    print "skipper is missing $req_item.\n"
    }
    }

    If you have very large arrays, with very large words,
    you might even be able to set up a binary search mechanism,
    half, half again, then again, and again, etc..

    Good luck!

    sln
    , Dec 3, 2008
    #13
  14. walterbyrd

    walterbyrd Guest

    On Dec 3, 3:05 pm, wrote:

    > I don't know what book that is but it looks like you are trying


    The book is called: "Learning Perl Objects, References, and Modules."
    The book is supposed to pick up where "Learning Perl" left off. I read
    "Learning Perl" and consider it to be a great book.

    I found out the book has been updated, the new book is called
    "Intermediate Perl" so I got the new book.

    I am presently trying to read, and understand, the stuff about
    referencing, and de-referencing, arrays. And it is giving me a serious
    headache.
    walterbyrd, Dec 6, 2008
    #14
  15. walterbyrd

    Guest

    On Sat, 6 Dec 2008 09:07:27 -0800 (PST), walterbyrd <> wrote:

    >On Dec 3, 3:05 pm, wrote:
    >
    >> I don't know what book that is but it looks like you are trying

    >
    >The book is called: "Learning Perl Objects, References, and Modules."
    >The book is supposed to pick up where "Learning Perl" left off. I read
    >"Learning Perl" and consider it to be a great book.
    >
    >I found out the book has been updated, the new book is called
    >"Intermediate Perl" so I got the new book.
    >
    >I am presently trying to read, and understand, the stuff about
    >referencing, and de-referencing, arrays. And it is giving me a serious
    >headache.


    I wouldn't think too hard on references. Its actually the 'syntax' for
    de-referencing in the doc's that makes most readers candidates for thorozine.

    The Perl universe is so cluttered with 'meta' it makes deciphering code almost
    impossible. The reason boils down to one thing: "One-liners". Yep, the little thing
    penchant Perl fanatics drivel over and one-up each other with.

    In reality, it is so busy because some dope decided to let people think short
    contractions with 'meta' will give some other dope the illusion his/her code
    is not only spiffy and unintelligable, but (this is the worst) will somehow
    magically run faster. Emacs on steriods, but let's let it be syntactically
    part of the language.

    Hey well, give enough rope, get a good hanging.

    References are very easy if you don't read too much into it.

    Keep at it and good luck!


    sln
    , Dec 7, 2008
    #15
  16. >>>>> "sln" == sln <> writes:

    sln> In reality, it is so busy because some dope decided to let people think
    sln> short contractions with 'meta' will give some other dope the illusion
    sln> his/her code is not only spiffy and unintelligable, but (this is the
    sln> worst) will somehow magically run faster. Emacs on steriods, but let's
    sln> let it be syntactically part of the language.

    I still regret inventing JAPHs, which encouraged obfuperl, and in some
    sense was the motivation for Perl golf. All three items today harm Perl's
    public perception more than they help, and I'm sad for that.

    print "Just another Perl hacker,"; # the original
    --
    Randal L. Schwartz - Stonehenge Consulting Services, Inc. - +1 503 777 0095
    <> <URL:http://www.stonehenge.com/merlyn/>
    Smalltalk/Perl/Unix consulting, Technical writing, Comedy, etc. etc.
    See http://methodsandmessages.vox.com/ for Smalltalk and Seaside discussion
    Randal L. Schwartz, Dec 7, 2008
    #16
  17. walterbyrd

    Tim Greer Guest

    Greg Bacon wrote:

    > Worrying about people who *choose* to be ignorant, as with any
    > form of bigotry, is a complete waste of time. Don't try to teach
    > a pig to dance, as the saying goes.


    Alright then, I won't interrupt your reply to Randal about what you
    feel.
    --
    Tim Greer, CEO/Founder/CTO, BurlyHost.com, Inc.
    Shared Hosting, Reseller Hosting, Dedicated & Semi-Dedicated servers
    and Custom Hosting. 24/7 support, 30 day guarantee, secure servers.
    Industry's most experienced staff! -- Web Hosting With Muscle!
    Tim Greer, Dec 14, 2008
    #17
  18. walterbyrd

    C.DeRykus Guest

    On Dec 13, 8:09 pm, (Greg Bacon) wrote:
    > In article <>,
    > Randal L. Schwartz <> wrote:
    >
    > : I still regret inventing JAPHs, which encouraged obfuperl, and in
    > : some sense was the motivation for Perl golf. All three items
    > : today harm Perl's public perception more than they help, and I'm
    > : sad for that.
    >
    > Don't be a puritan. Perl is fun, and that's great! Snobs who look
    > down their noses at jam sessions aren't worth worrying about.
    >


    I agree totally. Dismissive comments are for snobs -- Perl brings fun
    back to programming. And seriously, an "Obfuscated C Contest" or a
    Perl "golf" contest is often
    serendipitous because you're looking in a language's nooks and
    crannies to explore its capabilities. At times the bugs and mis-
    features of a languare are exposed; at others, you reveal how the
    gears and gizmos work under the covers. The "Obfuscated C contest"
    regularly attracts world class C programmers. Larry's won a couple of
    times as I recall.
    Just think.. Perl may have been the result of his mis-spent
    youth :)

    --
    Charles DeRykus
    C.DeRykus, Dec 14, 2008
    #18
  19. walterbyrd

    C.DeRykus Guest

    On Dec 15, 6:22 am, Dave Stratford <> wrote:
    > In article
    > <>,
    > C.DeRykus <> wrote:
    >
    >
    >
    > > On Dec 13, 8:09 pm, (Greg Bacon) wrote:
    > > > In article <>,
    > > > Randal L. Schwartz <> wrote:

    >
    > > > : I still regret inventing JAPHs, which encouraged obfuperl, and in
    > > > : some sense was the motivation for Perl golf. All three items
    > > > : today harm Perl's public perception more than they help, and I'm
    > > > : sad for that.

    >
    > > > Don't be a puritan. Perl is fun, and that's great! Snobs who look
    > > > down their noses at jam sessions aren't worth worrying about.

    >
    > > I agree totally. Dismissive comments are for snobs -- Perl brings fun
    > > back to programming. And seriously, an "Obfuscated C Contest" or a
    > > Perl "golf" contest is often
    > > serendipitous because you're looking in a language's nooks and
    > > crannies to explore its capabilities. At times the bugs and mis-
    > > features of a languare are exposed; at others, you reveal how the
    > > gears and gizmos work under the covers. The "Obfuscated C contest"
    > > regularly attracts world class C programmers. Larry's won a couple of
    > > times as I recall.
    > > Just think.. Perl may have been the result of his mis-spent
    > > youth :)

    >
    > That's all very well, and indeed amusing and fun in the right place.
    > Unfortunately people do write obfuscated code in the wrong place and at
    > the wrong time. Sadly, about four years ago, and after repeated warnings,
    > I eventually had to sack someone who continued to write obfuscated code in
    > our application programs. He was merely one of a team of five programmers
    > working on the same system, all of whom at some point would have had to
    > amend that code. There are people on that team now who were not in the
    > company at the time, those programs are still being updated and amended,
    > and it would have been grossly unfair to them, and the rest of the team,
    > to have allowed him to continue to do so.
    >
    > Be careful, be sensible!


    Good advice. But, obfuscated code can be written
    in all the langugages I'm aware of. Clearly, there are
    major benefits to exploration and a sense of fun with
    language. No one here is advocating "golf" constructs
    for production code.

    Sadly, though, the "O" word is often hurled by language
    zealots arguing their special agendas and attempting
    to sway the uninformed. Perl 6 should help with that.

    --
    Charles DeRykus
    C.DeRykus, Dec 16, 2008
    #19
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Carnell, James E
    Replies:
    2
    Views:
    235
    Marc 'BlackJack' Rintsch
    Sep 5, 2007
  2. walterbyrd
    Replies:
    5
    Views:
    193
    Dave Angel
    May 21, 2009
  3. cayenne
    Replies:
    3
    Views:
    247
    Brian McCauley
    May 26, 2004
  4. Patrick

    Trying to understand Perl

    Patrick, Nov 30, 2004, in forum: Perl Misc
    Replies:
    6
    Views:
    104
  5. Replies:
    10
    Views:
    183
    Dr.Ruud
    Jun 27, 2006
Loading...

Share This Page