The real problem is that you are trying to get a single function to accept two different styles of arguments. As you see, that can get you in trouble.

If you want to change the check, eval { %{$_[0]} } works best to detect a hash.

sub better {
   my %params = eval { %{$_[0]} } ||  @_;
}
[download]

But in this case, the following should do fine:

sub better {
   my %params = @_ == 1 ? %{$_[0]} : @_;
}
[download]

Of course, you could always give the sub what it wants:

bad_but_typical("$i18n");  # Force stringification
[download]

Update: Added missing curlies.

"teach your fellow developers to program more defensively" is good in any case.

Update: Actually this would work.

If you had your function return tied scalars instead of blessed references, this problem would go away. This is one of those places where the tie mechanism just seems to make more sense.

That's interesting - I've never used the tie interface before - I remember reading years ago that it is slow, and so just avoided it. Also, I thought that, because the variable is blessed into a package, it would still return it's class name when queried by ref. But you're right, it doesn't.

It is slower, especially tie'ing vs bless'ing, but FETCH'ing vs overload'ed stringification is only about 15% different:

    #==============================
    package i18n::String;
    #==============================

    use strict; use warnings;
    no warnings 'once';
    
    use overload q{""} =>
        sub { $i18n::Current_Lang->maketext( ${ $_[0] } ) };

    sub new {
        my $class  = shift;
        my $string = shift;
        return bless( \$string, $class );
    }

    #==============================
    package i18n::String2;
    #==============================

    use strict;
    use warnings FATAL => 'all', NONFATAL => 'redefine';

    sub TIESCALAR {
        my $class  = shift;
        my $string = shift;
        return bless( \$string, $class );
    }

    sub FETCH {
     $i18n::Current_Lang->maketext( ${ $_[0] } )
    }

    # BENCHMARK INIT ##############
    use Benchmark qw(cmpthese);

    cmpthese(1000000, {
        bless_string => sub { my $s = Burro::i18n::String->new('Januar
+y'); },
        tie_string =>   sub {tie my $s,Burro::i18n::String2,'January'}
    });
    
                     Rate   tie_string bless_string
    tie_string   395257/s           --         -30%
    bless_string 561798/s          42%           --

    # BENCHMARK FETCH  ###########
     use Benchmark qw(cmpthese);
     
     my $s = i18n::String->new('January');
     tie my $n,i18n::String2,'January';
     
     cmpthese(1000000, {
         fetch_blessed => sub {"$s"  },
         fetch_tied    => sub {"$n"}
     });
     
     
                      Rate    fetch_tied fetch_blessed
    fetch_tied    168634/s            --          -11%
    fetch_blessed 190476/s           13%            --
[download]

That said, as far as I can see, tie works only on named variables:

   my @months = map { tie my $var, i18n::String2, $_ } qw(January Febr
+uary);
   print Dumper(\@months);

   $VAR1 = [
             bless( do{\(my $o = 'January')}, 'i18n::String2' ),
             bless( do{\(my $o = 'February')}, 'i18n::String2' )
           ];
[download]

So in the process of solving one issue, I could be introducing many more.

Defensive programming it is!

thanks for the suggestion BrowserUK

Clint

That said, as far as I can see, tie works only on named variables:

So in the process of solving one issue, I could be introducing many more.

Um. The problem is that your map is returning the return value from tie, instead of the tied variable.

If you change the map so:

   my @months = map{tie my $var, i18n::String2, $_; $var } qw(January 
+February);
[download]

That problem goes away also. (I made a similar error myself earlier:)

Provided that your _(...) sub does the right thing, your users need never be aware that they are dealing with anything other than simple scalars.

So, trade your (one-time, up-front) care (and a little getting up to speed with the ins and outs of tie), as you develop your solution, for ongoing and continuous care by all your programmers?

Your choice, but I know which way I would go :)

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."

HTH,
SSF

That wouldn't help for a few reasons:

• I don't want to translate all strings, so strings to be translated should be explicitly labelled.
• This is a webapp, so the current language could change for each request, so strings shouldn't be translated at compile time
• The app is 60,000 lines of code, plus CPAN modules - running a filter over that would be slow and error prone.

clint

How is that possible? Sure you can redefine _, but that won't do any blessing at compile time.

Quite possible. My webapp is large, and runs within mod_perl, so I have an initialisation process which loads most required modules at the beginning. In my i18n class, which gets loaded as early as possible, I have this code:

    {
        no warnings 'redefine';

        sub compile_mode {
            *::_ = sub { i18n::String->new(@_) };
        }

        sub run_mode {
            *::_ = sub { $i18n::Current_Lang->maketext(@_) };
        }
    }

    BEGIN {
        compile_mode();
    }
[download]

Once initialisation is finished, my loader calls i18n::run_mode. If I need to require any large modules that belong to my app during runtime, instead of using the require builtin, I call i18n::i18n_require('Module::Name'):

    sub i18n_require {
        my $original = my $path = shift;
        i18n::compile_mode();
        $path=~s{::}{/}g;

        my $error;
        eval {require $path.'.pm'}
         or $error = $@ || 'Unknown error';
        
        i18n::run_mode();

        die( sprintf( "Error loading '%s' at %s line %d:\n%s\n",
                      $original, (caller)[ 1, 2 ], $error
             )
        ) if $error;

        return $INC{$path};
    }
[download]

I tried overriding UNIVERSAL::require, but certain modules outside my control didn't appreciate that. Anyway, doing it this way is explicit, and only a few characters more.

I was thinking

use yourblah;
my $foo = _('this is blahblah');
[download]

at compile time, $foo doesn't get blessed.