in reply to Re^6: Aren't there code refs as well as function refs? (Update: refactoring very large sub with many variables)
in thread Aren't there code refs as well as function refs?

> I didn't know you could put multiple subs inside a bracket and share variables that way

You don't need the brackets to share variables. But they are limiting the scope the same way like your giant function did before. I tried to guaranty a pain free refactoring.

FWIW you can also nest multiple layers of brackets. See Coping with Scoping for more.

The other approach is using OOP.

kcott also mentioned passing a hash around, that's actually one criteria for needing OOP, because (most) objects are just blessed hashes which are passed inside $self.°

so this could do too: 

$obj->some_method {
    my ($self,@args) = @_;

    print $self-{many}, $self->{variables};
}

[download]

Cheers Rolf
(addicted to the 𐍀𐌴𐍂𐌻 Programming Language :)
Wikisyntax for the Monastery

°) one criteria of many, it depends on the concrete use case

  • Comment on Re^7: Aren't there code refs as well as function refs? (Update: refactoring many variables into hash or object)
  • Download Code

Replies are listed 'Best First'.
Re^8: Aren't there code refs as well as function refs? (Update: refactoring many variables into hash or object)
by cavac (Prior) on Mar 06, 2023 at 13:52 UTC

    because (most) objects are just blessed hashes

    True. Although, as you pointed out, technically not always. As for the classes these objects are blessed with... You can bless a thing with a non-existant class, rewrite the class later on the fly and you are still good.

    use strict;
use warnings;

use Data::Dumper;

# Turn stuff into blessed objects
my $foo = 'THIS IS A SCALAR';
my $bar = [qw(THIS IS AN ARRAY)];
my $baz = {'This' => 'Is', 'A' => 'Hash'};

# Bless them with a class that doesn't technically exist yet (and have
+ Perl autovivify it for us)
my $scalarobject = bless \$foo, 'This::Is::A::Dummy::Object';
my $arrayobject = bless $bar, 'This::Is::A::Dummy::Object';
my $hashobject = bless $baz, 'This::Is::A::Dummy::Object';

{
    # Force the This::Is::A::Dummy::Object class to have a print metho
+d that stringifies its own object ;-)
    no strict 'refs';
    *{'This::Is::A::Dummy::Object::stringify'} = sub{ my ($self) = @_;
+ print Dumper($self); };
}

$scalarobject->stringify();
$arrayobject->stringify();
$hashobject->stringify();

    [download]

    Result:

    $VAR1 = bless( do{\(my $o = 'THIS IS A SCALAR')}, 'This::Is::A::Dummy:
+:Object' );
$VAR1 = bless( [
                 'THIS',
                 'IS',
                 'AN',
                 'ARRAY'
               ], 'This::Is::A::Dummy::Object' );
$VAR1 = bless( {
                 'This' => 'Is',
                 'A' => 'Hash'
               }, 'This::Is::A::Dummy::Object' );

    [download]

    I love that you can do stuff like this. Not usually for production code. Although, come to think of it, it might come in handy for that "rewrite my XML config parser" thing i have had on my todo list for a decade now...

    PerlMonks XP is useless? Not anymore: XPD - Do more with your PerlMonks XP
[reply]
[d/l]
[select]
      > I love that you can do stuff like this.

      #me_too, but that's quite a thread drift, don't you think? :)

      Cheers Rolf
      (addicted to the 𐍀𐌴𐍂𐌻 Programming Language :)
      Wikisyntax for the Monastery

[reply]
[reply]

In Section Seekers of Perl Wisdom