FW: Simple Namespace Proposal View as Markdown

I am going to commit this patch on Wednesday.

Thanks. Dmitry.

-----Original Message-----
From: Dmitry Stogov [mailto:dmitry@zend.com]
Sent: Wednesday, July 04, 2007 4:46 PM
To: 'internals@lists.php.net'
Subject: Simple Namespace Proposal

Hi,

Please review the following concept and patch for php6...

http://dev.daylessday.org/diff/ns-06.diff.txt
http://dev.daylessday.org/diff/tests.tar.gz

Main assumption of the model is that the problem that we are
to solve is the problem of the very long class names in PHP
libraries. We would not attempt to take autoloader's job or
create packaging model - only make names manageable.

Namespaces are defined the following way:

Zend/DB/Connection.php:
<?php
namespace Zend::DB;

class Connection {
}

function connect() {
}
?>

Namespace definition does the following:
All class and function names inside are automatically
prefixed with namespace name. Inside namespace, local name
always takes precedence over global name. It is possible to
use the same namespace in several PHP files. The namespace
declaration statement must be the very first statement in file.

Every class and function from namespace can be referred to by
the full name - e.g. Zend::DB::Connection or
Zend::DB::connect - at any time.

<?php
require 'Zend/Db/Connection.php';
$x = new Zend::DB::Connection;
Zend::DB::connect();
?>

Namespace or class name can be imported:

<?php
require 'Zend/Db/Connection.php';
import Zend::DB;
import Zend::DB::Connection as DbConnection;
$x = new Zend::DB::Connection();
$y = new DB::connection();
$z = new DbConnection();
DB::connect();
?>

import statement only defines name aliasing. It may create
name alias for namespace or class. The simple form of
statement "import A::B::C::D;" is equivalent to "import
A::B::C::D as D;". Import statement can be used at any time
in global scope (not inside function/class) and takes effect
from the point of definition down to the end of file. It is
recommended however to place imports at the beginning of the
file. Import statements have effect only on file where they
are written.

The special "empty" namespace (:: prefix) is useful as
explicit global namespace qualification. All class and
function names started from :: interpreted as global. <?php
namespace A::B::C;

$con = ::mysql_connect(...);
?>

A special constant NAMESPACE indicates the current
namespace. It can be used to construct fully-qualified names
to pass them as callbacks.

<?php
namespace A::B::C;

function foo() {
}

set_error_handler(NAMESPACE . "::foo");
?>

In global namespace NAMESPACE constant has value of empty string.

Names inside namespace are resolved according to the following rules.

1. all qualified names are translated during compilation
   according to current import rules. So if we have "import
   A::B::C;" and then "C::D::e();" it is translated to "A::B::C::D::e()"

2. unqualified class names translated during compilation
   according to current import rules. So if we have "import
   A::B::C;" and then "new C();" it is translated to "new A::B::C()"

3. calls to unqualified functions that are defined in current
   namespace interpreted as calls to corresponding functions

4. calls to unqualified functions that are not defined in
   current namespace are resolved in run-time. The call to
   function foo() inside namespace (A::B) first tries to find
   and call function from current namespace A::B::foo() and if
   it doesn't exist PHP tries to call internal function foo().
   Note that using foo() in namespace you can call only internal
   PHP functions, however using ::foo() you are able to call any
   function from global namespace.

5. unqualified class names are resolved at run-time. E.q.
   "new Exception()" first tries to use (end even __autoload())
   class from current namespace and in case of failure uses
   internal PHP class. Note that using "new A" in namespace you
   can call only create internal PHP class, however using "new
   ::A" you are able to create any class from global namespace

6. Calls to qualified functions are resolved at run-time.
   Call to "A::B::foo()" first tries to call function foo() from
   namespace "A::B", then it tries to find class "A::B
   (__autoload() it if necessary) and call its static function foo()

7. qualified class names are interpreted as class from
   corresponding namespace. So "new A::B::C()" creates class "C"
   from namespace "A::B".

Thanks. Dmitry.