Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:107961
Content-Type: multipart/alternative;
	boundary="Apple-Mail=_860CF432-EE08-469A-9490-7F1A6D2F529C"
Mime-Version: 1.0 (Mac OS X Mail 12.4 \(3445.104.11\))
Message-ID: <74F2DBFC-E63C-428C-A37F-2D0CEE15AD0F@newclarity.net>
References: <5e0d723f.1c69fb81.e2ae8.24e2SMTPIN_ADDED_MISSING@mx.google.com>
To: PHP internals <internals@lists.php.net>
Date: Thu, 2 Jan 2020 12:35:11 -0500
Subject: Initializing constants once, with code?
From: mike@newclarity.net (Mike Schinkel)

--Apple-Mail=_860CF432-EE08-469A-9490-7F1A6D2F529C
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain;
	charset=utf-8

Happy New Year Internals!

One of the areas I have been agonizing over in 2019 has been constants =
=E2=80=94 especially class constants =E2=80=94 and Mark Randall's =
following comment from the other thread cause me to remember that I had =
been planned to ask the list to discuss for a while.

> Begin forwarded message:
> From: Mark Randall <marandall@php.net>
> Subject: [PHP-DEV] Re: [RFC] "use global functions/consts" statement
> Date: January 1, 2020 at 11:31:48 PM EST
> To: internals@lists.php.net
>=20
> That doesn't cover defined constants, but IMO we should be pushing =
those to be moved into class constants, simply because in the absense of =
function / constant / anything-but-class level autoloading, things might =
as well be in a readily available location.

I have found namespaced class constants as a great usable syntax for =
DRYing out code during refactoring related to typically hardcoded =
literal values, or when writing code initially. Once such example might =
be:
namespace Example;
class API {
   const BASE_URL =3D 'http://api.example.com';
}
With this a developer can use like so:
namespace Example;
....
$api_url =3D sprintf( '%s/%s', API::BASE_URL, '/widgets' );
Instead of writing this 20 different places across a codebase:
$api_url =3D 'http://api.example.com/widgets';

The problem with using constants is that the value is still hardcoded =
and if we later want to change to pulling the data from a config file we =
have to change all the code that uses those constants. =20

Yes we could use methods instead, but frankly constants feel more =
natural for things that typically get hardcoded.

We all know that constants need to be, by definition, constant (a.k.a. =
immutable), but is there any reason we could not allow constants a =
one-time initialization via code?  That way we would allow a developer =
to hardcode a constant and then later come back and convert that =
constant to be initialized from a configuration file without having to =
modify any code that uses the constant?

If others agree with this concern then three (3) approaches come to =
mind, either of which would satisfactory to me although the first would =
be best IMO.  That said, I am open to any approach that allows constants =
to be one-time initialized with code.

Approach #1: Extend the const keyword to allow function-like syntax

Extend the constant keyword to support all the syntax supported by =
methods except parameters, but only run the code the first time the =
constant is accessed, on demand:

namespace Example;
class API {
   const BASE_URL:string {
      return Config::get_options('api_base_url');
   }
}
$api_url =3D sprintf( '%s/%s', API::BASE_URL, '/widgets' );
Approach #2: Allow one-time assignment to a constant

Alternately we could allow one-time assignment to a constant, although =
this would be much less preferable because it would require the =
initialization to be explicitly called by a developer, and the developer =
would have to implement all their own on demand logic, or just =
initialize all classes on page load which most people would probably =
fall back to doing:
namespace Example;
class API {
   const BASE_URL;
   static function initialize() {
      self::BASE_URL =3D Config::get_options('api_base_url');
    }
}
API::initialize();
$api_url =3D sprintf( '%s/%s', API::BASE_URL, '/widgets' );
Approach #3:Magic methods!

A magic method could work too, but I know many others have reasons to =
dislike them no the least of which is lack of static typing. I include =
here more for completeness rather than as a serious suggestion:
namespace Example;
class API {
   static function __const(string $const_name) {
      $value =3D null;
      if ( 'BASE_URL' =3D=3D=3D $const_name ) {
         $value =3D Config::get_options('api_base_url');
      } else {
         trigger_error( sprintf("constant %s::%s has not been defined.",
            get_called_class(),
            $const_name
         ));
      }
      return $value;
   }
}
$api_url =3D sprintf( '%s/%s', API::BASE_URL, '/widgets' );
Thank you for considering and I look forward to your thoughts.

-Mike



=20=

--Apple-Mail=_860CF432-EE08-469A-9490-7F1A6D2F529C--