(Update: See Re: Ways to implement a closure for more on using closures for this kind of thing.)

ady wrote:

Well, i'd have to open the perl program and change the !~ op to the =~ op each time i want filtering on a "negated domain".

I could do that, but i prefer a way to express the regex complement directly as a new regex (to be fed to the program). -- And the way to do that was shown by Corion above.

Another option would be use "regex matchers" instead of hand-coded regex operations. The matchers can be inverted, and so you can change the matching logic of your worker code by passing in normal or inverted matchers.

One possible implementation:

    # The following small library lets us create regex-matchers
    # and inverted regex-matchers.

    sub make_regex_matcher {
        my $regex = shift;
        return sub {
            local $_ = $_[0];
            /$regex/g;
        }
    }

    sub invert_regex_matcher {
        my $matcher = shift;
        sub { wantarray
              ? die "inverted matchers are only for scalar context"
              : ! $matcher->(@_)
        }
    }
[download]

Then we can parameterize our code's matching behavior by using matchers instead of regex operators:

    # With the above library, we can write our worker code without
    # having to specifiy whether we are interested in matching (=~)
    # or non-matching (!~).  Instead, we can parameterize this
    # behavior by allowing our worker to accept a matcher as an
    # argument:

    my @candidates = map {chomp;$_} <DATA>;

    sub do_work {
        my $matcher = shift;
        foreach (@candidates) {
            if ($matcher->($_)) {  # instead of regex op
                # do something with candidate in $_
                print "$_$/";
            }
        }
    }
[download]

Here is a sample run:

    # To demonstrate this approach, let us create a matcher for
    # your example pattern:

    my $matcher = make_regex_matcher('(CX36(5|6))|(JA30[0-2])|(JA3(([2
+-8]\d)|(9[0-4])))|(JA5.*)|(JA6((0\d)|(1[0-3])))|(JA64[7-9])|(JA687.*)
+|(JA74[0-3])|(JB5.*)|(JY(((1|2)\d\d)|(3[0-3]\d)))|(JY[3-9][5-9]\d)|(J
+Z51(3|4)00.*)');

    # Now we can process matching candidates:

    print "Matches:$/";
    do_work($matcher);

    # And we can process non-matching candidates without
    # having to change a line of worker code:

    print "$/Non-matches:$/";
    do_work(invert_regex_matcher($matcher));


    ### OUTPUT:
    ###
    ### Matches:
    ### CX365-CX366
    ### JA300-JA302
    ### JA320-JA394
    ### 
    ### Non-matches:
    ### I do not match!
    ### Nor do I match, my non-matching brother!



    __DATA__
    CX365-CX366
    I do not match!
    JA300-JA302
    Nor do I match, my non-matching brother!
    JA320-JA394
[download]

I hope that this helps.

Cheers,
Tom

---

---

Posts are HTML formatted. Put <p> </p> tags around your paragraphs. Put <code> </code> tags around your code and data!

Titles consisting of a single word are discouraged, and in most cases are disallowed outright.

Read Where should I post X? if you're not absolutely sure you're posting in the right place.

Please read these before you post! —

• How do I compose an effective node title?
• How do I post a question effectively?
• Markup in the Monastery

Posts may use any of the Perl Monks Approved HTML tags:

a, abbr, b, big, blockquote, br, caption, center, col, colgroup, dd, del, details, div, dl, dt, em, font, h1, h2, h3, h4, h5, h6, hr, i, ins, li, ol, p, pre, readmore, small, span, spoiler, strike, strong, sub, summary, sup, table, tbody, td, tfoot, th, thead, tr, tt, u, ul, wbr

You may need to use entities for some characters, as follows. (Exception: Within code tags, you can put the characters literally.)

	For:		Use:
	&		&
	<		&lt;
	>		&gt;
	[		&#91;
	]		&#93;

Link using PerlMonks shortcuts! What shortcuts can I use for linking?

See Writeup Formatting Tips and other pages linked from there for more info.