I, too, am a bit confused about just what you want. See much more about working with complex data structures in the Perl Data Structures Cookbook.

However, here's an approach that might be useful:

Win8 Strawberry 5.8.9.5 (32)  Sun 09/24/2023 19:20:01
C:\@Work\Perl\monks
>perl

use strict;
use warnings;

# Subscription DATA sets
my @Subscription = (
    { 'Sub_Name' => "Morph",  'Archive_File' => "Morph Archive.txt", }
+,
    { 'Sub_Name' => "Cat",    'Archive_File' => "Cat Archive.txt",   }
+,
    { 'Sub_Name' => "Hydro",  'Archive_File' => "Hydro Archive.txt", }
+,
    { 'Sub_Name' => "Foo",    'Zip'          => "Xyzzy Archive.txt", }
+,
    { 'Sub_Name' => "Bar",                                           }
+,
    { 'Xyzzy'    => "Foo",    'Archive_File' => "Xyzzy Archive.txt", }
+,
    { 'Xyzzy'    => "Foo",    'Zot'          => "Xyzzy Archive.txt", }
+,
    { 'Xyzzy'    => "Bar",                                           }
+,
    );

key_extract_and_handle(\@Subscription, 'Sub_Name', \&hashref_handler_e
+xample);

exit;

sub key_extract_and_handle {

    my ($ar_hashes,      # required: ref to array of refs to hashes (A
+oH)
        $key_to_handle,  # required: string: key in each hash to handl
+e
        $cr_handle,      # required: ref to code of handler
        ) = @_;

    for my $hash_ref (@$ar_hashes) {
        $cr_handle->($hash_ref, $key_to_handle);
        }

    }

sub hashref_handler_example {

    my ($hashref,        # required: ref to hash
        $key_to_handle,  # required: string: key in hash to handle
        ) = @_;

    print "checking subscription ";
    if (exists $hashref->{$key_to_handle}) {
        print "'$hashref->{$key_to_handle}' ";
        }
    else {
        print "(exception: subscription key '$key_to_handle' absent) \
+n";
        return;  # or maybe warn or die
        }

    print "via archive file ";
    if (exists $hashref->{'Archive_File'}) {
        print "'$hashref->{'Archive_File'}': ";
        }
    else {
        print "(exception: archive file absent) \n";
        return;
        }

    # do actual subscription currency check here
    print "ok \n";  # or whatever...

    }

^Z
checking subscription 'Morph' via archive file 'Morph Archive.txt': ok
checking subscription 'Cat' via archive file 'Cat Archive.txt': ok
checking subscription 'Hydro' via archive file 'Hydro Archive.txt': ok
checking subscription 'Foo' via archive file (exception: archive file 
+absent)
checking subscription 'Bar' via archive file (exception: archive file 
+absent)
checking subscription (exception: subscription key 'Sub_Name' absent)
checking subscription (exception: subscription key 'Sub_Name' absent)
checking subscription (exception: subscription key 'Sub_Name' absent)
[download]

Update: Posting error at about line 18
    key_extract_and_handle(\@Subscription, 'Sub_Name', \&hashref_handler_example);
Semicolon was missing at end of statement. Fixed.

If you feel the for loop is too verbose, you can switch to map:

List_Subscriptions(map $_->{Sub_Name}, @Subscription);
[download]

G'day ObiPanda,

From your description, I think you're after something like this:

$ perl -e '
    use Data::Dump;

    my @Subscription = (
         {
         Sub_Name               => "Morph",
         Archive_File           => "Morph Archive.txt",
         },
         {
         Sub_Name               => "Analogue",
         Archive_File           => "Analogue Archive.txt",
         },
         {
         Sub_Name               => "Cat",
         Archive_File           => "Cat Archive.txt",
         },
         {
         Sub_Name               => "Zoonotic",
         Archive_File           => "Zoonotic Archive.txt",
         },
         {
         Sub_Name               => "Hydro",
         Archive_File           => "Hydro Archive.txt",
         },
    );

    some_sub([map +{Sub_Name => $_->{Sub_Name}}, @Subscription]);

    sub some_sub {
        my ($single_scalar) = @_;
        dd $single_scalar;
        return;
    }
'
[
  { Sub_Name => "Morph" },
  { Sub_Name => "Analogue" },
  { Sub_Name => "Cat" },
  { Sub_Name => "Zoonotic" },
  { Sub_Name => "Hydro" },
]
[download]

Breaking that down into more manageable chunks:

• In some_sub(...), the ... represents what you "send ... to a subroutine".
• What you're sending is [...]. That's an arrayref and covers "preferably by reference". Here, the ... represents the contents of the arrayref.
• The arrayref contents are generated using map. You'll note that there are two forms: map BLOCK LIST and map EXPR,LIST. The second is used here but, as the EXPR is a hashref ({...}), the leading '{' can be confused with the leading '{' of a BLOCK. Adding a plus, "map +{...", removes that confusion — this is described in more detail about two-thirds of the way down the map page (look for the paragraph beginning with "{ starts both hash references and blocks ...").
• The hashref EXPR is a key/value pair. The key is Sub_Name; the value is $_->{Sub_Name}; your OP code suggests you understand this — ask if that's not the case. The LIST is @Subscription.
• In sub some_sub {...}, I've used dd, from Data::Dump, to show that a single scalar is received which is an arrayref with "one key & value per array/hash" as you put it.

for (@Subscription) {
    Display_Subs(\%$_);
}
[download]

\%$_ says to take a reference to a hash $_ and de-reference it as a hash %$_ and then take a reference to that hash \%$_. Since you are not modifying that hash you could just do:

for (@Subscription) {
    Display_Subs($_);
}
[download]

sub List_Subscriptions {
    my (@Sub_ARRAY) = @{$_[0]};
#    my (@Sub_ARRAY) = @_;

    print "The Current Subscription List:\n\n";
    for (@Sub_ARRAY) { print " \t$_ \n"; }
    print "\n\n";
}
[download]

You are de-referencing the array (copying the whole array) when you could just use the reference:

sub List_Subscriptions {
    my ($Sub_ARRAY) = @_;
#    my (@Sub_ARRAY) = @_;

    print "The Current Subscription List:\n\n";
    for (@$Sub_ARRAY) { print " \t$_ \n"; }
    print "\n\n";
}
[download]

I'd say just share \@Subscription with your sub and let it browse your data there instead of a costly copy.