Have you seen/tried Overriding-Built-in-Functions?

Yes. "CORE::GLOBAL::" is too aggressive. It is process wide supposedly.

Update: I assuming from your typically terse description that you goal is to override the function of the built-in select only within the IO::Select module without overriding the select method it presents to its callers.

If that is not the case, perhaps you could clarify your requirements?

Yes. "CORE::GLOBAL::" is too aggressive.

Hm. The CORE::GLOBAL discussion is only a one part of the discussion referenced.

There is also use REGlob 'glob';            # override glob() in Foo:: only, amongst others.

But, to answer your specific problem, I'd suggest adding:

sub yourSelect {
    ...
}

sub select {
   local *CORE::GLOBAL::select = *yourSelect;
  shift
    if defined $_[0] && !ref($_[0]);

  my($r,$w,$e,$t) = @_;
  my @result = ();

  my $rb = defined $r ? $r->[VEC_BITS] : undef;
  my $wb = defined $w ? $w->[VEC_BITS] : undef;
  my $eb = defined $e ? $e->[VEC_BITS] : undef;

  if(select($rb,$wb,$eb,$t) > 0)
 ################################################
}
[download]

Wherever select is used in IO::Select. Make it conditional if appropriate.

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

But I don't really understand your intention (or better mistrust the idea)

If you want to make sure that the original built-in is called use CORE::select, if you need a different select better name it select2 or new::select and change the source accordingly.

update

the only way I can think of is to delete all subs with name select and to use AUTOLOAD to try to distinguish if its called as a method or a built-in (the first argument is blessed)

update

AUTOLOAD is even not necessary, write your own select to check the caller and switch accordingly.

If it's called within the package/module delegate to your pseudo-built-in otherwise call the method.

package Your::Class::_internal;

use Custom::Select 'select';    # Replaces CORE select()

sub Your::Class::select {
    ...
    select( ... )
    ...
}
[download]

Within your custom select function you are trying to call the "real" select function. However, you are actually recursively calling your own custom select function. Prefix the call to the "real" select function with CORE:: to prevent this recursion.

use subs 'select';
sub select {
    my ($fh) = @_;
    warn "inside my custom select\n";
    CORE::select $fh;
}

select STDERR;
print "Hello to STDERR!\n";
select STDOUT;
[download]

Update: Meh; I see now that you want to do the above, but also provide another sub called select which is what will be available to outside code. This can be done with a little namespace::clean magic...

use v5.12;
use warnings;

package MyModule;

# This is the override for the select built-in.
#
use subs 'select';
sub select {
    my ($fh) = @_;
    warn "inside my custom select\n";
    CORE::select($fh);
}

# Here's the select function we're going to expose to outside
# code.
#
require namespace::clean;
namespace::clean->clean_subroutines(__PACKAGE__, 'select');
no strict 'refs';
*{'select'} = sub
{
    # Note that we can use the select override even within
    # this sub!!
    select *STDERR;
    print "Hello to STDERR!\n";
    select *STDOUT;
};

1;
[download]