Overriding Built-in Functions (Perl Cookbook, 2nd Edition)

## 12.12. Overriding Built-in Functions

### 12.12.1. Problem

You want to replace a standard, built-in function with your own version.

### 12.12.2. Solution

Import that function from another module into your own namespace.

### 12.12.3. Discussion

Suppose you want to give a function of your own the same name as one of Perl's core built-ins. If you write:

>     sub time { "it's howdy doody time" }
>     print time( );

then you won't get your function called—you'll still get Perl's original, built-in version. You could use an explicit ampersand to call the function:

>     print &time( );

because that always gets your function, never the built-in. But then you forego any prototype checking and context coercion on the function's arguments. However, there is a way to override that.

Many (but not all) of Perl's built-in functions may be overridden. This is not something to be attempted lightly, but it is possible. You might do this, for example, if you are running on a platform that doesn't support the function that you'd like to emulate. Or, you might want to add your own wrapper around the built-in.

Not all reserved words have the same status. Those that return a negative number in the C-language `keyword( )` function in the toke.c file in your Perl source kit may be overridden. Keywords that cannot be overridden as of v5.8.1 are `defined`, `delete`, `do`, `else`, `elsif`, `eval`, `exists`, `for`, `foreach`, `format`, `glob`, `goto`, `grep`, `if`, `last`, `local`, `m`, `map`, `my`, `next`, `no`, `our`, `package`, `pos`, `print`, `printf`, `prototype`, `q`, `qq`, `qr`, `qw`, `qx`, `redo`, `require`, `return`, `s`, `scalar`, `sort`, `split`, `study`, `sub`, `tie`, `tied`, `tr`, `undef`, `unless`, `untie`, `until`, `use`, `while`, and `y`. The rest can.

A standard Perl module that overrides a built-in is Cwd, which can overload `chdir`. Others are the by-name versions of functions that return lists: File::stat, Net::hostent, Net::netent, Net::protoent, Net::servent, Time::gmtime, Time::localtime, Time::tm, User::grent, and User::pwent. These modules all override built-in functions like `stat` or `getpwnam` to return an object that can be accessed using a name, like `getpwnam("daemon")->dir`. To do this, they have to override the original, list-returning versions of those functions.

Overriding may be done uniquely by importing the function from another package. This import only takes effect in the importing package, not in all possible packages. It's not enough simply to predeclare the function. You have to import it. This is a guard against accidentally redefining built-ins.

Let's say that you'd like to replace the built-in `time` function, whose return value is in integer seconds, with one that returns a floating-point number instead. You could make a Time::HiRes module with an optionally exported `time` function as follows:

>     package Time::HiRes;
>     use strict;
>     require Exporter;
>     use vars qw(@ISA @EXPORT_OK);
>     @ISA = qw(Exporter);
>     @EXPORT_OK = qw(time);

>     sub time( ) { ..... }  # TBA

Then the user who wants to use this augmented version of `time` would say something like:

>     use Time::HiRes qw(time);
>     $start = time( );
>     1 while print time( ) - $start, "\n";

This code assumes that your system has a function you can stick in the "TBA" definition shown previously. It just so happens, however, that you don't have to figure that part out, because the Time::HiRes module (which is included standard with the Perl distribution) does indeed behave as we've outlined it here. You can import its `time( )` function to get the one that is fancier than the core built-in, just as we did here.

If you don't want to take the trouble to create a full module file, set up its exports, and all the rest of the rigamarole, there's a shortcut approach via the `subs` pragma. It works like this:

>     use subs qw(time);
>     sub time { "it's howdy doody time" }
>     print time( );

Now you'd get your own function, even without the ampersand.

Even when you override a built-in by importing a function, that built-in is always still accessible if you fully qualify it using the (pseudo)package named CORE. Thus, even if you imported `time( )` from FineTime, overriding the built-in, that original built-in can be called as `CORE::time( )`.

For overriding of methods and operators, see Chapter 13.

### 12.12.4. See Also

The section on "Overriding Built-in Functions" in Chapter 11 of Programming Perl and in perlsub(1); Recipe 10.11

Copyright © 2003 O'Reilly & Associates. All rights reserved.