question about "package" and variable scope...

Hi all,

I wrote a file that contains two packages:

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

# "main" package, implicitly
sub foo {
    print "sub foo in main\n";
}
our $foo = "scalar foo in main";

foo();             # no problem
print "$foo\n";    # no problem

# "Test" package begins here
package Test;

foo();             # This is an error, because this calls
"&Test::foo()" that doesn't exist
----------------------------

The last "foo();" results in an error, as you know, because "&foo"
exists in "main", not in "Test". It should be "main::foo();".


Ok, then... here is my question...

----------------------------
# (omit the same code as above)

# "Test" package begins here
package Test;

print "$foo\n";    # I think this is an error, too.
----------------------------

Execution result:

sub foo in main
scalar foo in main
scalar foo in main  -- $main::foo is printed...


I thought that the last line would result in an error (just like the
above case).
And I thought it would, if "use strict" is ignored in the scope of
"Test", print null string (the value of $Test::foo).
But the last line printed the value of "$main::foo" variable...

I can't understand this.. Any help would be apprecieated.

Raymundo < XXXX@XXXXX.COM > writes:


It isn't an error, it's just confusing. There are two things going on:

* Scoping. 

  our() has lexical scope, so as far as scope is concerned, it doesn't
  care about packages at all. It works basically the same as:

  my $foo = "lexical foo"; # lexicals are NOT bound to any package
  package Test;
  print "$foo\n";

* Association between the variable name and the package variable. 

  As I understand it, our() works as if it creates a new lexical
  variable that is aliased to a package variable of the same name in the
  current package. That is: the current package *at the our()
  statement*, NOT the current package at whatever time you use the
  variable.

See also perldoc -f our:

  ''An "our" declaration declares a global variable that will be visible
  across its entire lexical scope, even across package boundaries.  The
  package in which the variable is entered is determined at the point of
  the declaration, not at the point of use.''

-- 
Joost Diepenmaat | blog:  http://www.**--****.com/ | work:  http://www.**--****.com/ 

Raymundo < XXXX@XXXXX.COM > writes:


That's just "our" doing its job as designed. Your code is basically
the same as the example given in "perldoc -f our":

    An "our" declaration declares a global variable that will be
    visible across its entire lexical scope, even across package
    boundaries.  The package in which the variable is entered is
    determined at the point of the declaration, not at the point of
    use.  This means the following behavior holds:
    
       package Foo;
       our $bar;           # declares $Foo::bar for rest of lexical scope
       $bar = 20;
    
       package Bar;
       print $bar;         # prints 20, as it refers to $Foo::bar
    
sherm--

-- 
My blog:  http://www.**--****.com/ 
Cocoa programming in Perl:  http://www.**--****.com/ 

Oh my God... I misunderstood "our" completely...;;;

Thank you very much.

So, both "our" and "my" have lexical scope... Then, if I want to
declare a variable that is visible in "only this package"... is there
any way to do so? (other than using braces that enclose the entire
package)

Raymundo < XXXX@XXXXX.COM > writes:


You can use vars (which is also useful in some other situations):

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

use vars qw($foo);

$foo = "scalar foo in main";

package Test;

print "$foo\n";    # error: Global symbol "$foo" requires explicit package name


-- 
Joost Diepenmaat | blog:  http://www.**--****.com/ | work:  http://www.**--****.com/ 

Ooops.. I couldn't even imagine that "our" and "use vars" have
different scope rule...

Thanks again Joost for your helpful post.

Simply read their documentation...

    perldoc -f our

        ... within the lexical scope of the C<our> declaration ...

    perldoc vars

        the "use vars" and "use subs" declarations are not BLOCKcoped.  
        They are thus effective for the entire file in which they appear...


-- 
Tad McClellan
email: perl -le "print scalar reverse qq/moc.noitatibaher\100cmdat/"

Package variables are global in scope: you can access them from anywhere
using the $package::name notation.

 > (other than using braces that enclose the entire package)

Even that won't help:

$foo = "foo from main\n";

{
         package Foo;

         $foo = "foo from Foo\n";
}

print $foo;       # foo from main
print $Foo::foo;  # foo from Foo

You can use the $Foo::foo notation to access variables in packages
that aren't mentioned anywhere else in your script.  Perl will
silently create the package if that's what it takes to make this work.

If you want to restrict visibility, you'll have to use "my".  But "my"
pays attention only to braces and file boundaries, not to packages.

Hope this helps,

-- HansM

Sherm Pendley wrote :
This does not work("print $bar" will not print anything in this case),
if Bar is in a separate file Bar.pm and included with 'use Bar;

Why?
How can I use variables across Packages wich are in separate files?

Thanks in advance
regards
Martin

-- 
perl -e '$S=[[73,116,114,115,31,96],[108,109,114,102,99,112],
[29,77,98,111,105,29],[100,93,95,103,97,110]];
for(0..3){for$s(0..5){print(chr($S->[$_]->[$s]+$_+1))}}'

Martin Kier < XXXX@XXXXX.COM > writes:


Our declares variables as being global within a lexical context; a
different file is in a different lexical context.


Use the full package name - i.e. "print $Foo::bar;"

Or, have a look at 'perldoc Exporter' if you'd like to make the
"short" form available to code that uses your module.

sherm--

-- 
My blog:  http://www.**--****.com/ 
Cocoa programming in Perl:  http://www.**--****.com/ 

Quoth Martin =?UTF-8?Q?Ki=C3=9Fner?= < XXXX@XXXXX.COM >:

No. Seperate files have separate lexical scopes: 'my' variables are
never visible across files, and 'our' variables must be referred to by
their full package name.


The first question is: are you sure you need to? It's often a bad idea
to do this; it may be better to provide a function or OO interface to
the variable.

That said, you have three options:

    1. Refer to the variable by its fully-qualified name, $Foo::bar.

    2. Export the variable into the 'Bar' namespace with Exporter,
    something like this:

        package Foo;

        use base qw/Exporter/;
        our @EXPORT_OK = qw/$bar/;

        1;

        package Bar;

        use Foo qw/$bar/;

        1;

    3. Make a new 'our' variable in the second file that refers to
    $Foo::bar:

        package Bar;

        #...

        package Foo;
        our $bar;
        package Bar;

        #...

        1;

Ben

-- 
The Earth is degenerating these days. {*filter*} and corruption abound.
Children no longer mind their parents, every man wants to write a book,
and it is evident that the end of the world is fast approaching.
       Assyrian stone tablet, c.2800 BC                         XXXX@XXXXX.COM 

 http://www.**--****.com/ 

-- 
John     http://www.**--****.com/ 

Perl help in exchange for a gift:
 http://www.**--****.com/ 

Sherm Pendley wrote :


Thank you. I wasn't aware of this.


'perldoc Exporter' explains how to use Exporter in modules (I didn't
read it thoroughly yet).
Is it also possible to use it in the main script to make variables
declared in the main script accessible inside the module?

I know I can use '$main::variablename' but I am just interested if I
could could also use Exporter for this.

regards
Martin

-- 
perl -e '$S=[[73,116,114,115,31,96],[108,109,114,102,99,112],
[29,77,98,111,105,29],[100,93,95,103,97,110]];
for(0..3){for$s(0..5){print(chr($S->[$_]->[$s]+$_+1))}}'

Tad J McClellan wrote :



I wasn't aware that the lexical scope is restricted to the file.
Thanks to sherm I am now.

regards
Martin


-- 
perl -e '$S=[[73,116,114,115,31,96],[108,109,114,102,99,112],
[29,77,98,111,105,29],[100,93,95,103,97,110]];
for(0..3){for$s(0..5){print(chr($S->[$_]->[$s]+$_+1))}}'

Martin Kier < XXXX@XXXXX.COM > writes:


Not that I know of, and for good reason. Modules should be self-
contained, with as little knowledge as possible of anything outside of
their own package. If the main program needs to provide some variable
to the module, it should either set a variable in the module's
package, or pass it to a function (or method) that the module
supplies.

For example, when you're using the CGI.pm module, you use a variable
in the module's name space ($CGI::POST_MAX) to set the maximum amount
of data that will be accepted from a form.

sherm--

-- 
My blog:  http://www.**--****.com/ 
Cocoa programming in Perl:  http://www.**--****.com/