Alright, great, thanks for responses...I think I've got something that works now. I split hashify_word into 2 routines and like it better. The list gets read and trimmed correctly, and that seeemed to solve the problem that I had with the regex.

sub get_list{
use strict;
use warnings;
use 5.010;
use File::Slurp;

my $file = shift;
my @lines = read_file($file);
chomp(@lines); 
s/^\s+|\s+$//g for @lines;
@lines = grep length, @lines;
return @lines;
}

sub zip_lists  {
use strict;
use warnings;
use 5.010;
use List::MoreUtils qw( zip );

my ($file1, $file2) = @_;
my @file1lines = get_list($file1);
my @file2lines = get_list($file2);
say "keys are @file1lines";
say "values are @file2lines";
my %hash = zip @file1lines, @file2lines;
return \%hash;
}
[download]

My filesizes are not large for the purpose at hand, but I wonder what changes one would consider if the lists were long and you were worried about performance. Caller looks like this now:

my $word_hash_ref = zip_lists($vars{'words'},$vars{'subs'});
say "in main";
my %hash = %$word_hash_ref;

# main control
my $check = join '|', keys %hash;
 
binmode STDOUT, ":utf8";
open(my $hh, "<:encoding(UTF-8)", $vars{'source'})
    || die "can't open UTF-8 encoded filename: $!";
while(<$hh>){
chomp;
$_ =~ s/($check)/$hash{$1}/gi;
say "$_";
}
[download]

Again, I don't want to bore you with the actual output, but I think this works now, and again thanks....

I wonder what changes one would consider if the lists were long and you were worried about performance.

Hashes are relatively fast; if you're worried about loading the whole thing into memory, a database (such as DBD::SQLite) or maybe DBM file come to mind.

But first, how large are the files? How much memory and CPU usage is "too much"? If you're not approaching those limits don't worry just yet :-)

(By the way, while it doesn't really hurt anything except readability, you don't need to declare use strict; use warnings; etc. at the top of every sub if you've already declared it at the top of the file.)

Are you sure about that? I was cleaning up these routines and modules and thought I saw output that was unitialized that would otherwise have drawn an error.

To be honest, I'd rather have the output than the error. I can see when the data hasn't been initialized. Short of any criticisms I receive, this represents what I was trying to achieve on this thread: Typical output

I'm fascinated by quines, and wrote a couple routines that are quine-ish:

sub write_script  {
use Text::Template;
use File::Slurp;
use 5.010;
my $rvars = shift;
my %vars = %$rvars;
my $tmpl = $vars{"code_tmpl"};
say "tmpl is $tmpl";
my $file = $vars{"script_file"};
my $text = read_file($file);
my %data = ('script', $text);
my $template = Text::Template->new(SOURCE => $tmpl)
          or die "Couldn't construct template: $!";
my $result = $template->fill_in(HASH =>\%data);
return \$result;
}

sub write_module  {
use 5.010;
use File::Spec;
use File::Slurp;
my $rvars = shift;
my %vars = %$rvars;
my $tmpl = $vars{"module_tmpl"};
say "tmpl is $tmpl";
my $fspecfile = File::Spec->rel2abs(__FILE__);
my $text = read_file($fspecfile);
my %data = ('module', $text);
my $template = Text::Template->new(SOURCE => $tmpl)
          or die "Couldn't construct template: $!";
my $result = $template->fill_in(HASH =>\%data);
return \$result;
}
[download]

They almost work, but the code tags for html can't quite pull it off, yet it gives as much of a listing as most people would be interested in.