Making variables visible between calls.

[ambs]

Hello.

What I really want (if the code worked as I was expecting):

sub create_f {
    my $func = shift;
    return sub {
        my $var = "xpto";
        &$func;
    }
}

my $function = create_f( 
    sub { print ">> $var <<\n" }
);

I mean, supply a function that uses a variable that is declared outside. Of course I do not want this on this context, this is just my test code.

I do not want to make the variable global to the package.

Any hints?

Thanks! :)

[kennethk]

So you want the behavior of a global variable without a global variable? Are you trying to limit access to the value, or are you just trying to create persistent parameters? In either case, sounds like you want to go OOP-esque.

package Parameters;
use strict;

use Exporter;
our @ISA = qw(Exporter);
our @EXPORT = qw(get_var);
my $var = "xpto";

sub get_var{
    return $var;
}

1;

and then call it as

use Parameters;

print get_var;

This has the added benefit that $var is completely inaccessible outside of any accessor methods you give the user.

[ikegami]

sub create_f {
    my $func = shift;
    return sub { $func->("xpto"); }
}

my $function = create_f( 
    sub {
        my $var = shift;
        print ">> $var <<\n"
    }
);

It's technically possible using dynamic scoping (local), but that increases coupling. What I presented is a much better alternative.

[ambs]

Yes, at the moment that is my own solution, but that forces the user to get a set of predefined parameters. It works, but not as clean as I would like it to be to the user. ;)

Thanks

[ikegami]

A set? No. You could pass a hash or an object.

Not as clean? Any method of passing arguments without using parameters would be less clean than using parameters.

[kyle]

Allow the function to take an argument.

sub create_f {
    my $func = shift;
    return sub {
        my $var = 'xpto';
        $func->( $var );
    }
}

my $f = create_f( sub {
                  my $var = shift;
                  print ">> $var <<\n";
              } );

Otherwise, I don't see a way to do it. The sub can't reach outside its scope for variables that aren't global.

You could cook up something with eval, maybe.

sub create_f {
    my $func = shift;
    return sub {
        my $var = "xpto";
        eval $func;
    }
}

my $function = create_f( 'print ">> $var <<\n"' );

$function->();
__END__
>> xpto <<

I'm not sure if that fits with your real problem or not.

[Arunbear]

You could put the variables into some other package which exists just to hold them e.g.

#!/usr/bin/perl
use strict;
use warnings;

sub create_f {
    my $func = shift;
    return sub {
        $MyBucket::var = "xpto";
        &$func;
    }
}

my $function = create_f( 
    sub { print ">> $MyBucket::var <<\n" }
);

$function->();

[friedo]

Your anonymous subroutine can't see $var since it's compiled in a lexical scope separate from where it's executed. But it can have values passed into it as arguments.

sub create_f {
        my $func = shift;
        return sub {
                my $var = "xpto";
                $func->( $var );
        }
}

my $function = create_f(
        sub { print ">> $_[0] <<\n" }
);


$function->();

Update: And if you want to specify the value at runtime, it's as easy as passing it into create_f.

sub create_f {
        my $func = shift;
        my $var = shift;
        return sub {
                $func->( $var );
        }
}

my $function = create_f(
        sub { print ">> $_[0] <<\n"  }, 'xpto'
);


$function->();

[jeffa]

How about just this?

my $function = sub {
    my $var = 'xpto'; print ">> $var <<\n"
};

$function->();

[ambs]

That doesn't help. I need to let the user define his own function, and give him the possibility to access some pre-defined variables in case he wish to.

My only possibility at the moment is to force the user defined function to receive a set of predefined parameters. But that will mess up some things later...

But thanks, anyway ;)

[eric256]

It sounds like you realy want to pass it a hash. Then just preload the hash with values that it should have access to.

  my $function = sub {my $v = shift; print ">> $v->{var} <<\n" };
  my $params = {var => 'exto'};
  $function->($params);