Originally published at Perl Weekly 753

Hi there!

There was not a lot of action this week, but I had a live session on contributing to a Perl project and then another one contributing to a Python project. There were more guests at the Python event, but we were more productive during the Perl event. Partially as the packaging and dependency management system of Perl is more standardized than that of Python. Who would have thought :-)

I've scheduled a new event to contribute to a Perl module. I really hope that these sessions will encourage more people to start contributing. First relatively small things and then as we run out of the smaller things we can work on more difficult tasks.

If you are looking for a New Year's resolution here is a challenge: Make one contribution to an open source project every week! At the last event I organized we sent 4 Pull-Request in 1.5 hour. If you have not contributed yet then at first it might take a bit longer for you, but with some practice you can make some contribution within an hour. So one hour every week for the next 52 weeks. Here is an issue on GitHub where you can mention your work. That will help all of us to keep doing it.

Oh and if you are looking to explore new, web-related development in the Perl ecosystem, I'd suggest you take a serious look at PAGI

Enjoy your week and have a healthy and fruitful New Year!

--
Your editor: Gabor Szabo.

Announcements

New App. OPC-UA Pipe Gateway

opcua_pipe_gateway is an OPC-UA client that allows reading and writing OPC-UA variables via command line interface, using STDIN for commands and STDOUT for results. The application is available in two implementations: a Perl version (opcua_pipe_gateway.pl) and a Python version (opcua_pipe_gateway.py).

ANNOUNCE: Perl.Wiki V 1.36

Articles

Supercharge Event Loops with Thread::Subs

There are two issues with event loop coding, related to the need to maintain an asynchronous, non-blocking style: It's harder to write and maintain than linear, blocking code. Despite all the asynchronous behaviour, it's still single threaded.

Anyone actually use LinkedList::Single?

There is a new release, but is it just an exercise in rewriting code, or is it used?

JSON::Schema::Validate example

We used this example during an online session. I would want to continue playing with the module and possibly sending PRs, but unfortunately the ones I already sent have not been accepted yet.

NOAA::Aurora for Space Weather Forecasts

Dimitrios writes: "With the current solar maximum, I wanted to add aurora forecasting features to my iOS weather app, Xasteria. Instead of fetching text files from NOAA, I thought it would be nice for my weather proxy server to handle that. Hence I developed NOAA::Aurora and released it to CPAN."

Discussion

Writing Perl is Vibe Coding

Is it? Or is this a misunderstanding of what Vibe Coding is?

Perl's feature.pm and backwards incompatibility

Shouldn't new features at least emit a warning if they are "overwriting" an existing sub with a new built-in?

Perl Advent Calendar

Bit vectors save space on Santa's list

A Quick Response

Pecan's Tale: Migrating a terminal application from Term::ReadLine to Tickit

Web

Perl PAGI tutorial early access

For anyone interested in helping Joh shakedown PAGI docs in preparation for publishing to CPAN, he'd love feedback on the tutorial.

Perl PAGI Project Update

PAGI (Perl Asynchronous Gateway Interface) is a new web specification and reference server for Perl, designed to bring first-class async/await support to web development. Think of it as Perl's answer to Python's ASGI - a modern foundation for WebSocket, Server-Sent Events, and HTTP applications using Future and Future::AsyncAwait syntax.

The Weekly Challenge

The Weekly Challenge by Mohammad Sajid Anwar will help you step out of your comfort-zone. You can even win prize money of $50 by participating in the weekly challenge. We pick one champion at the end of the month from among all of the contributors during the month, thanks to the sponsor Lance Wicks.

The Weekly Challenge - 354

Welcome to a new week with a couple of fun tasks "Min Abs Diff" and "Shift Grid". If you are new to the weekly challenge then why not join us and have fun every week. For more information, please read the FAQ.

RECAP - The Weekly Challenge - 353

Enjoy a quick recap of last week's contributions by Team PWC dealing with the "Max Words" and "Validate Coupon" tasks in Perl and Raku. You will find plenty of solutions to keep you busy.

Max Validate

The blog post provides high-quality, idiomatic Raku code. It successfully solves the programming challenges while acting as an effective demonstration of Raku's expressiveness and unique programming paradigms. The solutions are practical, well-explained, and ready for use.

To each (array) his own

Bob Lied's solutions represent high-quality, thoughtful Perl programming that balances elegance, performance, and maintainability. The dual implementation approach for Task 2 with accompanying benchmarks shows a deep understanding of Perl's performance characteristics.

Perl Weekly Challenge: Week 353

Jaldhar provides concise, one-liner-inspired solutions for both challenges, with a focus on achieving the result in a single line of code for Raku and a similar spirit for Perl.

waiting for Santa...

The primary strength is demonstrating the same logic implemented idiomatically across very different paradigms. This is highly educational. The solutions are not overly golfed.

Perl Weekly Challenge 353

Solutions are technically impressive, highly original, and demonstrate expert-level Perl mastery. The functional style, robust error handling, and sophisticated use of zip make these solutions outstanding from an engineering perspective.

Validate to the Max

Matthias provides exceptionally well-considered and pedagogically rich solutions that focus heavily on code design, readability, and the thoughtful evaluation of Perl idioms, TIMTOWTDI. Solutions are characterised by a deliberate choice of clarity and maintainability over mere conciseness, backed by explicit reasoning.

Ok, swing code… SWING!

Packy's core philosophy is to solve the problem once, then port the functional, pipeline-based logic to other languages. This results in consistent, readable, and idiomatic solutions across the board.

Words and shopping

Peter's solutions are methodically crafted, resembling production-grade scripts one might write for a business system. The code is not minimalistic but is instead self-contained, well-documented, and robust, with a focus on teachable insights.

The Weekly Challenge #353

The post presents a detailed plan or pseudocode for solving the problems before showing the final code. The solutions follow a direct, procedural style in Perl. They are correct but emphasize a straightforward implementation over brevity or exploring advanced language features.

Max Validation

Roger provides a brief and focused look at the challenges for blog post, solving them efficiently in JavaScript and Raku. The solutions prioritize solving the problem directly over extensive commentary. Solutions are technically proficient, concise, and modern.

Validating Words

Simon implements both tasks using straightforward, loop-based logic that prioritizes clarity and correct input handling. The solutions are methodical and include explicit checks for edge cases.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Perl Maven online: Live Open Source contribution

January 08, 2025

Boston.pm - online

January 13, 2025

German Perl/Raku Workshop 2026 in Berlin

March 16-18, 2025

You joined the Perl Weekly to get weekly e-mails about the Perl programming language and related topics.

Want to see more? See the archives of all the issues.

Not yet subscribed to the newsletter? Join us free of charge!

(C) Copyright Gabor Szabo
The articles are copyright the respective authors.

What We Learned Shipping PAGI

PAGI (Perl Asynchronous Gateway Interface) is a new web specification and reference server for Perl, designed to bring first-class async/await support to web development. Think of it as Perl's answer to Python's ASGI - a modern foundation for WebSocket, Server-Sent Events, and HTTP applications using Future and Future::AsyncAwait syntax.

Since the first stable release on December 24th, we've shipped seven releases in four days. This pace wasn't planned - it emerged from squashing bugs reported by CPAN Testers, especially on important but less common platforms like FreeBSD, along with rapid iteration on the API. Here's what we learned along the way.

Sometimes the Right Code is No Code

One of the more interesting decisions we made was removing a feature: built-in sendfile support.

The initial implementation used IO::Async::FileStream with Sys::Sendfile to efficiently stream large files directly from disk to socket, bypassing userspace copying. It worked beautifully on Linux. Then we tested on FreeBSD.

The problem wasn't just FreeBSD - it was the interaction between sendfile and non-blocking sockets, edge cases with partial writes, and the complexity of handling all the ways different operating systems implement (or don't implement) zero-copy file transfers. We found ourselves writing increasingly elaborate platform-specific workarounds.

We stepped back and asked: what problem are we actually solving? In production, large file serving should go through a reverse proxy anyway. Nginx's X-Sendfile (or X-Accel-Redirect) and Apache's mod_xsendfile exist precisely for this use case. They're battle-tested, optimized, and someone else maintains them.

So we removed sendfile entirely and created PAGI::Middleware::XSendfile instead. Your PAGI application returns a special header, and your reverse proxy handles the actual file transfer. The Unix philosophy wins again: do one thing well, and compose with specialized tools.

That said, this isn't ideological. If someone wants to contribute a robust, cross-platform sendfile implementation, we'd welcome the PR. The current solution is pragmatic, not dogmatic.

Async Error Handling Done Right

Asynchronous programming has a dirty secret: errors love to disappear.

In synchronous code, an exception bubbles up naturally. In async code with fire-and-forget Futures, exceptions can vanish into the void. Your background task fails, nobody notices, and you spend hours wondering why something silently stopped working.

PAGI originally used a pattern called retain() to keep Futures alive:

$self->retain($self->some_async_operation());

This worked for keeping the Future from being garbage collected, but it had a problem: if some_async_operation() failed, the error was quietly swallowed. The Future failed, nobody was listening, and life went on - except for the bug you didn't know about.

We replaced this with adopt_future():

$self->adopt_future($self->some_async_operation());

The difference is crucial. When an adopted Future fails, the error propagates to the parent context and gets logged. You see it. You can debug it. The failure is observable.

This applies throughout PAGI's internals - connection handling, protocol parsing, worker lifecycle management. Errors that previously might have disappeared now surface properly. It's a small API change that dramatically improves debuggability.

For application developers, the pattern extends to your own code. When you spawn background work in a request handler, adopt it rather than retaining it. Your future self debugging a production issue will thank you.

Making PAGI Feel Like Perl

One principle guided several of our developer experience decisions: PAGI should feel like Perl, not like a foreign framework that happens to run on Perl.

The clearest example is the new -e and -M flags for pagi-server:

# Inline app, just like perl -e
pagi-server -e 'sub { my ($scope, $receive, $send) = @_; ... }'

# Load modules first, like perl -M
pagi-server -MPAGI::App::File -e 'PAGI::App::File->new(root => ".")->to_app'

If you've used perl -e for quick scripts, this syntax is immediately familiar. No ceremony, no boilerplate files for simple cases.

This philosophy extends to other areas:

Test::Client now traps exceptions by default, matching how Perl developers expect test failures to behave. Multi-value headers, query parameters, and form fields work naturally.

Environment modes follow the pattern established by Plack: -E development enables debugging middleware, -E production optimizes for performance. The detection is automatic based on TTY.

Signal handling follows Unix conventions. SIGTERM and SIGINT trigger graceful shutdown. SIGHUP reloads workers. SIGTTIN/SIGTTOU adjust worker counts. It behaves like the system tools Perl developers already know.

The goal is reducing cognitive overhead. You shouldn't need to learn "the PAGI way" for things Perl and Unix already have conventions for.

What's Next

PAGI is stabilizing, but there's plenty of interesting work ahead.

Documentation has been a major focus. We split the original Tutorial into two documents: a Tutorial for getting started with core concepts, and a Cookbook for advanced patterns like background tasks, database connection pooling, JWT authentication, and Redis-backed sessions. The goal is progressive disclosure - you shouldn't need to read about WebSocket heartbeat strategies before you've served your first HTTP response.

The middleware collection continues to grow. We have 37 middleware components now (authentication, rate limiting, CORS, sessions, and more), but there's always room for more.

We're considering a repository split and would love community feedback. Currently PAGI ships everything in one distribution: core spec, reference server, 37 middleware components, 19 apps, and test utilities. This is convenient (cpanm PAGI gets you everything) but means installing the full stack even if you only need parts.

Options we're weighing:

• Keep unified (current) - simpler while the spec is still evolving
• Split server - separate PAGI::Server as "reference implementation," enabling alternative servers
• Three-way split - core spec, server, and contrib (middleware/apps) as separate distributions

What would serve you better? Lighter installs? Easier contribution workflow? Alternative server implementations? We'd appreciate hearing your use case.

Most importantly, we're looking for contributors. The codebase is approachable - modern Perl with async/await, comprehensive tests, and documented internals. Whether you want to tackle something meaty like cross-platform sendfile, or something focused like a new middleware component, there's room for your ideas.

Get Involved

• GitHub: github.com/jjn1056/pagi
• CPAN: PAGI on MetaCPAN
• CONTRIBUTING.md: Guidelines for contributors, including our approach to AI-assisted development
• SECURITY.md: How to report vulnerabilities

PAGI is licensed under the Artistic License 2.0. It's a volunteer project - no timeline commitments, but serious about quality. If your organization needs priority support or custom development, contract work is available.

Async Perl web development is here. Let's build it together.

Weekly Challenge 353

Each week Mohammad S. Anwar sends out The Weekly Challenge, a chance for all of us to come up with solutions to two weekly tasks. My solutions are written in Python first, and then converted to Perl. It's a great way for us all to practice some coding.

Challenge, My solutions

Task 1: Max Words

Task

You are given an array of sentences.

Write a script to return the maximum number of words that appear in a single sentence.

My solution

There was a error in the original example. Like a good hacker, I raised a pull request to fix it.

This seems pretty straight forward. I strip any leading and trailing white space, and then count the words in the string (separate the sentence by any white space). I have a variable called max_words that has a running total of the maximum word count so far.

def max_words(sentences: list) -> int:
    max_words = 0

    for sentence in sentences:
        word_count = len(sentence.strip().split())
        if word_count > max_words:
            max_words = word_count


    return max_words

The Perl code follows the same logic. It has a Perl-ism that using a scalar for an array (using the split function in this case) will assign the number of elements to the variable.

sub main (@sentences) {
    my $max_words = 0;

    foreach my $sentence (@sentences) {
        $sentence =~ s/^\s+|\s+$//g;

        my $word_count = split( /\s+/, $sentence );
        if ( $word_count > $max_words ) {
            $max_words = $word_count;
        }
    }

    say $max_words;
}

Examples

$ ./ch-1.py "Hello world" "This is a test" "Perl is great"
4

$ ./ch-1.py "Single"
1

$ ./ch-1.py "Short" "This sentence has seven words in total" "A B C" "Just four words here"
7

$ ./ch-1.py "One" "Two parts" "Three part phrase" ""
3

$ ./ch-1.py "The quick brown fox jumps over the lazy dog" "A" "She sells seashells by the seashore" "To be or not to be that is the question"
10

Task 2: Validate Coupon

Task

You are given three arrays, @codes, @names and @status.

Write a script to validate codes in the given array.

A code is valid when the following conditions are true:

• codes[i] is non-empty and consists only of alphanumeric characters (a-z, A-Z, 0-9) and underscores (_).
• names[i] is one of the following four categories: "electronics", "grocery", "pharmacy", "restaurant".
• status[i] is true.

Return an array of booleans indicating validity: output[i] is true if and only if codes[i], names[i] and status[i] are all valid.

My solution

For input from the command line, I take triplets of a code, a name and a status.

For this task, I start with an empty list (array in Perl) called output. I then have a loop - with the variable i - that starts at 0 to one less than the length of the list.

For each iteration I start by setting the is_valid variable to True (the string true in Perl). I check that the specified criteria are met and set the is_valid variable to False if it isn't. Finally I append the is_valid variable to the output list.

def validate_codes(codes: list, names: list, status: list) -> list:
    output = []

    for i in range(len(codes)):
        is_valid = True
        if re.match(r'^[A-Za-z0-9_]+$', codes[i]) is None:
            is_valid = False
        elif names[i] not in ["electronics", "grocery", "pharmacy", "restaurant"]:
            is_valid = False
        elif status[i].lower() == "false":
            # The status is a string of 'true' or 'false', not boolean type.
            is_valid = False
        elif status[i].lower() != 'true':
            raise ValueError(f"Status must be 'true' or 'false', not '{status[i].lower()}'")
        output.append(is_valid)

    return output

The Perl solution follows the same logic.

Examples

$ ./ch-1.py A123 electronics true B_456 restaurant false C789 electronics true D@1 pharmacy true E123 grocery true
1

$ ./ch-2.py A123 electronics true B_456 restaurant false C789 electronics true D@1 pharmacy true E123 grocery true
[True, False, True, False, True]

$ ./ch-2.py Z_9 pharmacy true AB_12 electronics true G01 grocery false X99 electronics true test unknown true
[True, True, False, True, False]

$ ./ch-2.py _123 restaurant true 123 electronics true "" electronics false Coupon_A pharmacy true Alpha grocery true
[True, True, False, True, True]

$ ./ch-2.py ITEM_1 electronics true ITEM_2 electronics true ITEM_3 grocery true ITEM_4 grocery true
[True, True, True, True]

$ ./ch-2.py CAFE_X restaurant true ELEC_100 electronics true FOOD_1 grocery true DRUG_A pharmacy true ELEC_99 electronics false
[True, True, True, True, False]

With the current solar maximum, I wanted to add aurora forecasting features to my iOS weather app, Xasteria. Instead of fetching text files from NOAA, I thought it would be nice for my weather proxy server to handle that. Hence I developed NOAA::Aurora and released it to CPAN.

The module provides a convenient interface to the NOAA Space Weather Prediction Center (SWPC), handling data fetching, parsing, and caching.

Usage

Simple OO interface, you can get short term aurora probability either as a map:

use NOAA::Aurora;

my $aurora = NOAA::Aurora->new();

# Short-term forecast map for the Northern hemisphere
$aurora->get_image(hemisphere => 'north', output => 'aurora_n.jpg');

Or as a probability:

# Get short-term aurora probability for a given location
my $probability = $aurora->get_probability(lat => 51, lon => -2);

You can also get a forecast timeseries for the next 3 or 27 days:

# Let's switch to RFC 3339 format for the timeseries
my $aurora = NOAA::Aurora->new(date_format => 'rfc');

# Get 3-day kp forecast as a timeseries
my $forecast = $aurora->get_forecast();
# [
#   {
#     'kp'   => '3.67',
#     'time' => '2025-12-25 00:00:00Z'
#   },
#   {
#     'kp'   => '2.67',
#     'time' => '2025-12-25 03:00:00Z'
#   },
#   ...
# ]

# Get 27-day outlook as a timeseries
my $outlook = $aurora->get_outlook();
# [
#   {
#     'ap'   => '28',
#     'flux' => '130',
#     'kp'   => '5',
#     'time' => '2025-12-22 00:00:00Z'
#   },
#   {
#     'ap'   => '22',
#     'flux' => '135',
#     'kp'   => '5',
#     'time' => '2025-12-23 00:00:00Z'
#   },
#   ...
# ]

This week's challenges were early and on the easy side, which was appreciated as the holidays loom. The musical interlude this week ignores the challenge tasks in favor of seasonal light jazz; I have Spotify playing "Winter's Songs: A Windham Hill Christmas."

Task 1: Max Words

The Task

You are given an array of sentences. Write a script to return the maximum number of words that appear in a single sentence.

• Example 1:
  • Input: @sentences = ("Hello world", "This is a test", "Perl is great")
  • Output: 4

The Solution

An easy one -- an early Xmas gift? Split each sentence into words and count them, then take the maximum. Completely ignoring all the complexities of punctuation and internationalization, it's a one-liner:

sub maxWords(@sentence)
{
    use List::Util qw/max/;
    return max map { scalar(split(" ", $_)) } @sentence;
}

The only thing mildly tricky here is transforming the list of words into a count. Inside the body of the map block, we're in array context, so split will return a list. Coercing it with scalar gives the count.

Task 2: Validate Coupon

The Task

You are given three arrays, @codes, @names and @status. Write a script to validate codes in the given array. A code is valid when the following conditions are true:

• codes[i] is non-empty and consists only of alphanumeric characters (a-z, A-Z, 0-9) and underscores (_).
• names[i] is one of the following four categories: "electronics", "grocery", "pharmacy", "restaurant".
• status[i] is true.

Return an array of booleans indicating validity: output[i] is true if and only if codes[i], names[i] and status[i] are all valid.

• Example 1:
  • Input:
    • @codes = ("A123", "B_456", "C789", "D@1", "E123")
    • @names = ("electronics", "restaurant", "electronics", "pharmacy", "grocery")
    • @status = ("true", "false", "true", "true", "true")
  • Output: (true, false, true, false, true)

Thoughts

The volume of text for this one was daunting at first glance, but it turns out to be mostly example data and actually quite easy.

The validation is straight-forward. @codes is a regular expression match; @names is a keyword lookup from a dictionary table (hash); and @status is just a string compare.

We'll be operating on parallel arrays. I see two ways of doing it. First, we could use a variable to loop over the indexes. That's going to yield code with a lot of array subscripts. Or second, we could use each_array from List::More::Utils to do the indexing for us. I'm curious which is more efficient.

To the code-sleigh, Rudolph!

Loop with indexed

sub valid($code, $name, $status)
{
    state %ValidName = ( electronics => true, grocery => true,
                         pharmacy => true, restaurant => true );
    my @valid = (true) x $code->@*;

    for my ($i, $c) ( indexed $code->@* )
    {
        $valid[$i] &&= ( $code->[$i] !~ m/[^a-zA-Z0-9_]/ );
        $valid[$i] &&= ( exists $ValidName{$name->[$i]} );
        $valid[$i] &&= $status->[$i] eq "true";
    }
    return \@valid;
}

Notes:

• Passing multiple arrays as subroutine parameters implies using references. We could use traditional prototype attributes to make it possible to pass arrays, but let's not.
• state %ValidName -- These are valid keywords for the @names input array. Using state makes this a static table, initialized only the first time the subroutine is entered.
• @valid -- Our output array, same size as the input array. Assume they're all valid and turn elements false if any check fails.
• indexed -- My favorite recent Perl improvement. Returns both the index and the value from an array during a for loop.
• valid->[$i] &&= ... -- Any failing test will turn the value to false.
• $code->[$i] !~ m/[^a-zA-Z0-9_]/ -- The code has to consist entirely of valid characters, or conversely, it must not match (!~) anything that contains a character other than those. Later I went back to look up exactly what \w and \W mean in Perl regular expressions and realized that I could have used that instead of the character classes.
• exists $ValidName{...} -- Use exists explicitly to return a boolean value. A simple lookup that fails would return undef, and will make the result of the expression undef instead of false. Although undef is treated as false in many contexts, it failed the unit test.
• return \@valid -- Return a reference. This is convenient for the is() function from the Test2::V0 unit testing framework, and returning a reference also improves performance by avoiding an array copy.

Loop with array iterator

sub validEach($code, $name, $status)
{
    state %ValidName = ( electronics => true, grocery => true,
                         pharmacy => true, restaurant => true );
    my @valid;

    use List::MoreUtils qw/each_arrayref/;
    my $ea = each_arrayref($code, $name, $status);
    while ( my ($c, $n, $s) = $ea->() )
    {
        push @valid, ( $c !~ m/[^a-zA-Z0-9_]/ )
                  && ( exists $ValidName{$n}    )
                  && ( $s eq "true"             );
    }
    return \@valid;
}

Notes:

• This is basically the same function, except that the explicit indexing has been replaced by an iterator.
• each_arrayref -- There's an each_array function, but since we have array references, this one is convenient.
• my $ea = ... -- Creates an iterator over the three arrays.
• ea->() -- Call the iterator. ea is the equivalent of a function pointer, and this is function dereference syntax.
• while ( my ($c, $n, $s) = ea->() ) -- Each call to the iterator returns a tuple of the next element from each of the $code, $name, and $status arrays.
• push @valid, ... -- The same three checks as before, but building the list instead of modifying it, because we don't have an index in hand.

Performance check

I think the iterator version is a little cleaner, because it eliminates the clutter of repeated array subscripts. But I was curious how it compared in efficiency, so I set up a quick benchmark using the examples.

It turns out that the explicit indexing is about twice as efficient as the each_arrayref iterator. Still gonna use it, though.

$ perl ch-2.pl -b 100000
             Rate iterator forindex
iterator  72464/s       --     -47%
forindex 136986/s      89%       --

To do the benchmarking, I set up the examples as an array of test cases, and used Benchmark::cmpthese to do a lot of iterations.

sub runBenchmark($repeat)
{
    use Benchmark qw/cmpthese/;

    cmpthese($repeat, {
            forindex => sub {
                for ( @case )
                {
                    valid($_->{codes}, $_->{names}, $_->{status});
                }
            },
            iterator => sub {
                for ( @case )
                {
                    validEach($_->{codes}, $_->{names}, $_->{status});
                }
            },
        });
}

And the input data looks like this:

my @case = (
    { id     => 'Example 1',
      codes  => [ 'A123',        'B_456',      'C789',        'D@1',      'E123' ],
      names  => [ 'electronics', 'restaurant', 'electronics', 'pharmacy', 'grocery' ],
      status => [ 'true',        'false',      'true',        'true',     'true' ],
      expect => [ true, false, true, false, true ],
    },
    { id     => 'Example 2',
      codes  => [ 'Z_9',      'AB_12',       'G01',     'X99',         'test' ],
      names  => [ 'pharmacy', 'electronics', 'grocery', 'electronics', 'unknown' ],
      status => [ 'true',     'true',        'false',   'true',        'true' ],
      expect => [ true, true, false, true, false ],
    },
    { id     => 'Example 3',
      codes  => [ '_123',       '123',         '',            'Coupon_A', 'Alpha' ],
      names  => [ 'restaurant', 'electronics', 'electronics', 'pharmacy', 'grocery' ],
      status => [ 'true',       'true',        'false',       'true',     'true' ],
      expect => [ true, true, false, true, true ],
    },
    { id     => 'Example 4',
      codes  => [ 'ITEM_1',      'ITEM_2',      'ITEM_3',  'ITEM_4' ],
      names  => [ 'electronics', 'electronics', 'grocery', 'grocery' ],
      status => [ 'true',        'true',        'true',    'true' ],
      expect => [ true, true, true, true ],
    },
    { id     => 'Example 5',
      codes  => [ 'CAFE_X',     'ELEC_100',    'FOOD_1',  'DRUG_A',   'ELEC_99' ],
      names  => [ 'restaurant', 'electronics', 'grocery', 'pharmacy', 'electronics' ],
      status => [ 'true',       'true',        'true',    'true',     'false' ],
      expect => [ true, true, true, true, false ],
    },
);