There is a way to define a namespaced constant that is a special, built-in constant, using define function and setting the third parameter case_insensitive to false:<?phpnamespace foo;define(__NAMESPACE__ . '\NULL', 10); // defines the constant NULL in the current namespacevar_dump(NULL); // will show 10var_dump(null); // will show NULL?>  No need to specify the namespace in your call to define(), like it happens usually<?phpnamespace foo;define(INI_ALL, 'bar'); // produces notice - Constant INI_ALL already defined. But:define(__NAMESPACE__ . '\INI_ALL', 'bar'); // defines the constant INI_ALL in the current namespacevar_dump(INI_ALL); // will show string(3)"bar". Nothing unespected so far. But:define('NULL', 10); // defines the constant NULL in the current namespace...var_dump(NULL); // will show 10var_dump(null); // will show NULL?>  If the parameter case_insensitive is set to true<?phpnamespace foo;define (__NAMESPACE__ . '\NULL', 10, true); // produces notice - Constant null already defined?>

When creating classes or calling static methods from within namespaces using variables, you need to keep in mind that they require the full namespace in order for the appropriate class to be used; you CANNOT use an alias or short name, even if it is called within the same namespace. Neglecting to take this into account can cause your code to use the wrong class, throw a fatal missing class exception, or throw errors or warnings.In these cases, you can use the magic constant __NAMESPACE__, or specify the full namespace and class name directly. The function class_exists also requires the full namespace and class name, and can be used to ensure that a fatal error won't be thrown due to missing classes.<?phpnamespace Foo;class Bar {    public static function test() {        return get_called_class();    }}namespace Foo\Foo;class Bar extends \Foo\Bar {}var_dump( Bar::test() ); // string(11) "Foo\Foo\Bar"$bar = 'Foo\Bar';var_dump( $bar::test() ); // string(7) "Foo\Bar"$bar = __NAMESPACE__ . '\Bar';var_dump( $bar::test() ); // string(11) "Foo\Foo\Bar"$bar = 'Bar';var_dump( $bar::test() ); // FATAL ERROR: Class 'Bar' not found or Incorrect class \Bar used

[Editor's note: that behavior is caused by a bug in PHP 7.0, which has been fixed as of PHP 7.0.7.]

Regarding the entry "Import names cannot conflict with classes defined in the same file".
- I found that since PHP 7.0 this is no longer the case.
In PHP 7.0 you can have a class with a name that matches an imported class (or namespace or both at the same time).

<?php
namespace ns1 {
  class ns1 {
    public static function write() {
      echo "ns1\\ns1::write()\n";
    }
  }
}

namespace ns1\ns1 {
  class ns1c {
    public static function write() {
      echo "ns1\\ns1\\ns1c::write()\n";
    }
  }
}

namespace ns2 {
  use ns1\ns1 as ns1; // both a class in ns1, and a namespace ns1\ns1
    
  // the next class causes fatal error in php 5.6, not in 7.0
  class ns1 {
    public static function write() {
      echo "ns2\\ns1::write()\n";
    }
  }
    
  ns1::write(); // calls imported ns1\ns1::write()
  ns1\ns1c::write(); // calls imported ns1\ns1\ns1c::write()
  namespace\ns1::write(); // calls ns2\ns1::write()
}
?>

Regarding "Neither functions nor constants can be imported via the use statement." Actually you can do it in PHP 5.6+:<?php// importing a function (PHP 5.6+)use function My\Full\functionName;// aliasing a function (PHP 5.6+)use function My\Full\functionName as func;// importing a constant (PHP 5.6+)use const My\Full\CONSTANT;?>

Just like class names currently namespaces are not case sensitive. So no errors will be shown here:<?php declare(strict_types=1);namespace Foo;class Bar {  public function __construct() {    echo 'Map constructed';  }}$foobar = new \foo\bar();

To correct manolachef's answer: define() ALWAYS defines constants in the GLOBAL namespace.As nl-x at bita dot nl states in the note at http://www.php.net/manual/en/function.define.php, the constant "NULL" can be defined with define() case-sensitively, but can only be retrieved with constant(), leaving the meaning of NULL uppercase keyword as the only value of the type null.