in reply to Re: Re^2: A simple import() for those special moments
in thread A simple import() for those special moments

I knew there was a reason I didn't feel comfortable with it:
#!/usr/bin/perl BEGIN { $SIG{__WARN__} = sub { print "Warn in package ".caller().": ", + @_ }; package X; $foo = "I'm in X, export me!"; *Y::foo = *foo } package Y; sub foo { "Oh dear.. I wasn't meant to be outside Y" } warn $foo; package X; warn foo(); __END__ Warn in package Y: I'm in X, export me! at line 11. Warn in package X: Oh dear.. I wasn't meant to be outside Y at li +ne 14.

In other words.. all globals exported by copying the entire typeglob will have all the packages that import them sharing all globals with the respective names - and this is more than "just" a heavy caveat.

Makeshifts last the longest.

Replies are listed 'Best First'.
Re: Re^4: A simple import() for those special moments
by ihb (Deacon) on Jan 22, 2003 at 19:53 UTC

    This is more of a theoretical danger though. Yes, it can leak and we both know you shouldn't actually do this. It's not very safe to use a pattern to decide what to export to begin with. Stuff like this should be done explicitly, so you know what you have and what you get, etc.

    But when is this leaking a problem? Sure, X gets an extra subroutine. But what difference does that make? When would X be calling this &foo, if it doesn't exist? Sure, there's the AUTOLOAD issue, but we have to believe that whoever uses the technique in the root node is knowing what he's doing and knows not to use AUTOLOAD since he implicitly aliases symbols. Symbols, I repeat.

    "But what if X has its own &foo", I hear you (or someone else) say. If defined before the import, no problem. That can be detected and issue a warning. (A glob overwrite warning.) If defined after the import, well, then you get a debugging hell--if you're not using warnings. Because a "Subroutine %s redefined" warnings will be issue. If not using warnings, well, I don't want to think about it. The package will change the exporting module's &foo and that will in its turn change all &foo's out there that has been imported. (It doesn't actually do this chain. They're all just one and the same.)

    To put this in context of your code in the root node: The importing module shouldn't have any symbol names what-so-ever that matches the pattern that the exporting module uses. (Of course documented in the exporting module.) Neither module should be using AUTOLOAD, since symbols are aliased implicitly. The &foo issue above can be generalized: all importing modules will share the same symbol, meaning that if one importing module modifies the symbol then all importing modules will also get the symbol modified.

    This all might seem scary as hell, and yeah, it can be. But this is also a quick'n'dirty hack. Since when is "arbitrary" imports considered OK by the purists anyway?


    PS. I'm not actually arguing with you, even though it may sound like it. I'm just elaborating on the subject.

      It sure was meant as a quick hack. What it was not meant to be though, was something you have to take into consideration at two levels down the code - not inside the module that makes use of this importer, but inside a package that uses a module that makes use of this importer. That falls under action at a distance and is IMO to be avoided at all cost. The fact that warnings will be thrown in case of collisions is not as important as the fact that working around the approach's caveats is very difficult. Esp considering that it puts the burden on someone who shouldn't have to think about it in the first place: the module's user, rather than the module's author. My conclusion remains that I'm not going to use this particular idiom, not even for throw-away code.

      Makeshifts last the longest.