$ ./6.MY.translate.pl --configfile C --from tja --infile /home/bob/Documents/meditations/Algorithm-Markov-Multiorder-Learner-master/data/2.short.shelley.txt --outfile /home/bob/Desktop/1.state
input  is “The ancient teachers of this science,” said he,
“promised impossibilities and performed nothing. The modern masters
...
unfold to the world the deepest mysteries of creation.


----------------
begin block to change
property is TO
type is zilch
expected type is zilch
did execution get here?
property is key
type is zilch
expected type is zilch
did execution get here?
property is FROM
type is zilch
expected type is zilch
did execution get here?
after block to change, self is
bless({ format => 5.23, FROM => "en", key => 321, START => 1562878454, TO => "ru" }, "My::Module")
in new, param_hr is
{
  CONTENT => "\x{201C}The ancient teachers of this science,\x{201D} said he,\n\x{201C}promised impossibilities and performed nothing. The modern masters\npromise very little; they know that metals 
... 
the steps\nalready marked, I will pioneer a new way, explore unknown powers, and\nunfold to the world the deepest mysteries of creation.\n\n",
  FROM => "tja",
  key => 123,
  TO => undef,
}
in new, self is 
bless({ format => 5.23, FROM => "en", key => 321, START => 1562878454, TO => "ru" }, "My::Module")
in sub key
akey is  123 
you called key() method on object 'My::Module=HASH(0x56161e3a1cb0)'
key() : changing key to '123'
in sub key
Use of uninitialized value $akey in concatenation (.) or string at ./6.MY.translate.pl line 62.
akey is   
you called key() method on object 'My::Module=HASH(0x56161e3a1cb0)'
my key: 123
--- mod is
bless({ format => 5.23, FROM => "en", key => 123, START => 1562878454, TO => "ru" }, "My::Module")
$ 


##</code><code>##

#!/usr/bin/perl -w
use 5.011;
binmode STDOUT, ":utf8";
use open IN  => ':crlf';
use open OUT => ':utf8';

package My::Module;

sub new {
  my ( $class, $param_hr ) = @_;
  $param_hr = {} unless defined $param_hr;
  my %self = (
    key    => 321,
    format => 5.23,
    START  => time(),
    'FROM'   => 'en',
    'TO'     => 'ru',
  );

  say "begin block to change";
  use Carp;
  my $self = \%self;
  for my $property ( keys %self ) {
    if ( exists $param_hr->{$property} ) {
      say "property is $property";
      my $type = ref $param_hr->{$property} || 'zilch';
      say "type is $type";
      my $expected_type = ref $self{$property} || 'zilch';
      say "expected type is $expected_type";

      croak "$property should be a $expected_type"
        if $expected_type ne $type;
      say "did execution get here?";

      #$self{$property} = delete $param_hr->{$property};
    }
  }
  say "after block to change, self is"; 
  

  bless $self, $class;    
dd $self;
  if ( exists $param_hr->{'key'} ) {
    say "in new, param_hr is";
    use Data::Dump;
    dd $param_hr;
    say "in new, self is ";
    dd $self;

  }

  if ( exists $param_hr->{'key'} ) { $self->key( $param_hr->{'key'} ) }
  else { warn "param 'key' is required."; return undef }
  return $self;    # return  hash, now blessed into a class instance, hallelujah
}

# get or set the key
sub key {
  say "in sub key";
  my $self = $_[0];
  my $akey = $_[1];    # optional key
  say "akey is  $akey ";
  print "you called key() method on object '$self'\n";
  if ( defined $akey ) {
    print "key() : changing key to '$akey'\n";
    $self->{'key'} = $akey;
  }
  return $self->{'key'};
}
1;

package main;

use Getopt::Long;
my $outfile    = undef;
my $configfile = undef;
my $infile     = undef;
my $from       = undef;
my $to         = undef;

if (
  !Getopt::Long::GetOptions(
    "outfile=s",
    \$outfile,
    "infile=s",
    \$infile,
    "configfile=s",
    \$configfile,
    "from=s",
    \$from,
    "to=s",
    \$to,
    "help",
    sub {
      print "Usage : $0 --configfile C [--outfile O] [--infile I] [--help]\n";
      exit 0;
    },
  )
  )
{
  die "error, commandline";
}
die "configfile is needed (via --configfile)" unless defined $configfile;
my $inFH;

if ( defined($infile) ) {

  open( $inFH, '<:crlf:encoding(UTF-8)', $infile )
    or die "opening input file $infile, $!";
}
my $instr;
{ local $/ = undef; $instr = <$inFH> }
close $inFH;
if ( defined($instr) ) {

  say "input  is $instr";

}
say "----------------";

# uncomment only if My::Module is in separate file:
#use My::Module;

my $mod = My::Module->new(
  {
    'key'     => 123,
    'CONTENT' => $instr,
    'FROM'      => $from,
    'TO'        => $to,

  }
);
die unless defined $mod;

print "my key: " . $mod->key() . "\n";
say "--- mod is";
dd $mod;
__END__ 

##</code><code>##

----------------
begin block to change
property is TO
type is zilch
expected type is zilch
did execution get here?
property is key
type is zilch
expected type is zilch
did execution get here?
property is FROM
type is zilch
expected type is zilch
did execution get here?
after block to change, self is
bless({ format => 5.23, FROM => "tja", key => 123, START => 1562881061, TO => undef }, "My::Module")
param 'key' is required. at ./6.MY.translate.pl line 53.
Died at ./6.MY.translate.pl line 133.
$ 


##</code><code>##

    SCALAR
    ARRAY
    HASH
    CODE
    REF
    GLOB
    LVALUE
    FORMAT
    IO
    VSTRING
    Regexp

##</code><code>##

  say "begin block to change";
  use Carp;
  my $self = \%self;
  for my $property ( keys %self ) {
    if ( exists $param_hr->{$property} ) {
      say "property is $property";
      my $type = ref $param_hr->{$property} || 'zilch';
      say "type is $type";
      my $expected_type = ref $self{$property} || 'zilch';
      say "expected type is $expected_type";

      croak "$property should be a $expected_type"
        if $expected_type ne $type;
      say "did execution get here?";

      $self{$property} = delete $param_hr->{$property};
    }
  }
  say "after block to change, self is";