Here's some test code I threw together. If you want to preserve the other slots, you'll likely have to use Symbol's gensym to make a new typeglob and assign all of the other slots to it, then use it to replace the old symbol. If you're comfortable with the following code, there you go:

#!/usr/bin/perl -w

use strict;

package destination;

package main;

use Test::More 'no_plan';

{
    no strict 'refs';
    *{'destination::foo'} = sub { 'foo' };
}

is( destination::foo(), 'foo',   'install a sub' );

{
    no strict 'refs';
    my $d = *{ 'main::destination::' };
    delete $d->{foo};
}

ok( ! destination->can( 'foo' ), '... now remove it' );
[download]

Cool, thanks much. I'll look into the Symbol package for my needs. The code you presented is very instructive though. As much as I'm not too concerned about the rest of the glob, i'd rather not risk killing things that i wasn't targeting, just in case it comes back to bite me in the future.

If you make the changes within a scope, you can localize them such that they'll be automagically undone when the scope exits.

sub foo { print "foo\n" }

{
    local *foo = sub { print "bar\n" };
    foo();
}

foo();
__END__
bar
foo
[download]

sub foo {
  print "yep\n";
}

@foo = $foo = 'a string';
my $f = 'foo';

foo() if defined &foo;

undef &$f;

print "nope\n" unless defined &foo;

print "\$foo: $foo\n";
print "\@foo: @foo\n";

__output__

yep
nope
$foo: a string
@foo: a string
[download]

Well, say that my way is better is easy, soo I will show what happens in the 3 different types:

    my $d = *{ 'main::destination::' };
    delete $d->{foo};
[download]

But one of the problems here is that you remove all the references, soo, if you have a $foo and &foo, you will erase both.

Just make a undef to the &sub actually works, but you will still have a *foo{CODE} value in the GLOB, what will use memory.

Note that undef is the standar way to do that, and is the recomended way, but you won't have the GLOB exactly as you have it before set the sub.

In Perl is impossible to create a GLOB that exists only in the scope. Soo, gensym() creates a new GLOB at Symbol::GENx, where x is a number. Soo, it won't be cleanned when you go out of the scope. Again you will be just duplicating everything.

Since a GLOB really need to be in the symbol table, local(*FOO) will create a GLOB that replaces the already existing GLOB in the symbol table for the given scope. Soo, after go out of the scope, the previous will be back. The biggest problem is when you make references to the local(*GLOB) after go out of the scope. Soo, if you make local(*FOO), and want to make something like a closure of it to $holder = \*FOO, it won't work.

Also for recursion or loop codes, the last local(*FOO) will change the previous sets.

Is easy, we just create a holder for the different types inside the GLOB, make a undef, than reset the values, unless the removed type:

  *FOO = sub { print "SUB FOO OK!\n" } ;
  $FOO = 123 ;

  print ">>>>>>>>>> BEFORE RM:\n" ;
  
  eval{ FOO() } ; warn($@) if $@ ;
  print "CODE: " . *FOO{CODE} . "\n" ;
  print "SCALAR: $FOO\n" ;
  
  glob_rm( \*FOO , 'CODE' ) ;
  
  print ">>>>>>>>>> AFTER RM:\n" ;
  
  eval{ FOO() } ; warn($@) if $@ ;
  print "CODE: " . *FOO{CODE} . "\n" ;
  print "SCALAR: $FOO\n" ;

sub glob_rm {
  my $glob = shift ;
  my $type = uc( shift(@_) ) ;

  my %holder ;
  foreach my $tp ( qw(SCALAR ARRAY HASH CODE IO FORMAT) ) {
    $holder{$tp} = *{$glob}{$tp} if $tp ne $type ;
  }
  
  if    ($type eq 'SCALAR') { undef ${*{$glob}} ;}
  elsif ($type eq 'ARRAY')  { undef @{*{$glob}} ;}
  elsif ($type eq 'HASH')   { undef %{*{$glob}} ;}
  elsif ($type eq 'CODE')   { undef &{*{$glob}} ;}
  elsif ($type eq 'IO')     { close *{$glob} ;}
  
  undef *{$glob} ;
  
  foreach my $Key ( keys %holder ) { *{$glob} = $holder{$Key} ;}
}
[download]

>>>>>>>>>> BEFORE RM:
SUB FOO OK!
CODE: CODE(0x1a72bac)
SCALAR: 123
>>>>>>>>>> AFTER RM:
Undefined subroutine &main::FOO called at tmp.pl line 17.
CODE: 
SCALAR: 123
[download]

Actually all of this depends of what you need. If you wan't speed, use just undef &FOO, but if you want to save memory I recomend the glob_rm() function.

Enjoy! ;-P

it didn't occur to me that i didn't have to use a typeglob as my holder. good idea, and although it's a core module, this approach means i have one less use statement. Can anybody tell me why do this:

if    ($type eq 'SCALAR') { undef ${*{$glob}} ;}
  elsif ($type eq 'ARRAY')  { undef @{*{$glob}} ;}
  elsif ($type eq 'HASH')   { undef %{*{$glob}} ;}
  elsif ($type eq 'CODE')   { undef &{*{$glob}} ;}
  elsif ($type eq 'IO')     { close *{$glob} ;}
[download]

instead of this:

($type eq 'IO') ? close *{$glob} : undef *{$glob}{$type};
[download]

and i have to wonder if just using this would not work:

undef *{$glob}{$type};
[download]

update: I should note that completely eradicating the sub from memory isn't necessarily the problem here, as sometimes the created CODE glob is simply an alias from another package rather than a brand new anonymous sub.

If I'm not wrong we can't change a glob key/element, only access it. Soo, this won't work:

undef *{$glob}{$type} ;
[download]

And I make this:

if    ($type eq 'SCALAR') { undef ${*{$glob}} ;}
  elsif ($type eq 'ARRAY')  { undef @{*{$glob}} ;}
  elsif ($type eq 'HASH')   { undef %{*{$glob}} ;}
  elsif ($type eq 'CODE')   { undef &{*{$glob}} ;}
  elsif ($type eq 'IO')     { close *{$glob} ;}
[download]

Not to remove the element from the GLOB, but to ensure that it goes out of the memory, since undef *{$glob} already remove all the keys/elements. Actually for your needs you can remove all the if ( $type eq '...' ).

Graciliano M. P.
"Creativity is the expression of the liberty".

Symbol::gensym
In Perl is impossible to create a GLOB that exists only in the scope. Soo, gensym() creates a new GLOB at Symbol::GENx, where x is a number. Soo, it won't be cleanned when you go out of the scope. Again you will be just duplicating everything.

Symbol::gensym does create its symbols in the Symbol:: package, but then removes them from the package, so when a returned symbol goes out of scope it does get garbage collected. If you think you get a leak doing this, report it as a bug, with a short test case.

Also, your undefs of each type (and close of the file handle) should never be needed; if you can come up with a short test case that shows a problem, please report this as a perl bug also.

"Symbol::gensym does create its symbols in the Symbol:: package, but then removes them from the package, so when a returned symbol goes out of scope it does get garbage collected"

Are you sure about that? I can guarantee to you that it won't make garbage collection! First because we don't have any note about that in the POD of Symbol, and because gensym() just return a reference of a GLOB in the package Symbol::, and any GLOB reference doesn't have scope, since it's a GLOBAL "object". The best way is to see the source of gensym():

sub gensym () {
    my $name = "GEN" . $genseq++;
    my $ref = \*{$genpkg . $name};
    delete $$genpkg{$name};
    $ref;
}
[download]

Soo, when the $ref goes out, the GLOB still exists in the package Symbol::.

Here's a test of that:

  {
    my $glob = gensym() ;
    ${*$glob} = 123 ;
    print "SCOPED: " . "${*$glob}\n" ;
  }
  print "OUT: " . ${*Symbol::GEN0} . "\n";
[download]

And the output:

SCOPED: 123
OUT: 123
[download]

About the undef of types, well, this was already discussed here in PM, and is all about memory usage. If we make a undef in all the different types of a GLOB to clean a package from the memory, we will free much more memory than just make a undef *GLOB. And the memory difference is big. In my tests after 1000 executions I have the interpreter with 8Mb, and with the simple undef *GLOBS I have 150Mb!

Graciliano M. P.
"Creativity is the expression of the liberty".

use Symbol qw( gensym );

my $old;
{
    no strict 'refs';
    $old = \*{ "package::func_name" };
}

my $new = gensym;
*$new = *$old{$_} foreach ( grep { defined *$old{$_} } qw( SCALAR ARRA
+Y HASH IO FORMAT ) );

{
    no strict 'refs';
    *{ "package::func_name" } = *$new;
}
[download]

Edit by tye, change PRE to CODE

Just a warning: *foo{FORMAT} isn't available before 5.8.0, so the above code will silently remove formats.

good to know, but i'm honestly not too concerned about it. I included it for completeness, but to be honest i expect most globs going through this process of mine will only have a subref in it anyway.