RFC: autoconst View as Markdown

Hello!

This is my first RFC proposal. I have an idea about introducing autoconst keyword.
Motivation:
reduce duplicated code (copy/pasting constant name as value)
reducing potential typo errors in constant values

instead of defining constants like:
const FOO = 'FOO';

they could be defined like:
autoconst FOO; // defines a constant FOO with the value 'FOO'

Also, modifiers could be useful:
autoconst uppercase foo; // defines a constant foo with value 'FOO'
autoconst lowercase FOO; // defines a constant FOO with value 'foo';

and maybe:
autoconst camelcase FOO_BAR; // defines a constant FOO_BAR with value 'fooBar'
autoconst snakecase fooBar; // defines a constant fooBar with value 'foo_bar'

could be listed like:
autoconst FOO, BAR, BAZ;
autoconst lowercase FOO, BAR, BAZ;

What do you think about that? If you like my idea, I would request a karma for creating this RFC in the wiki. Hope you'll like the idea!

Hi Serhii,
With Enums supported in PHP 8.1, I think this pattern of using
constant names with identical values will see fewer use cases.
I also don't think that a proposal to add new common keywords like
uppercase / snakecase, or adding any magic to constant names
(because PHP 7 supported case-insensitive constants) will be received
well either.

Thanks,
Ayesh.

вс, 1 авг. 2021 г., 14:22 Serhii Smirnov free.smilesrg@gmail.com:

instead of defining constants like:
const FOO = 'FOO';

they could be defined like:
autoconst FOO; // defines a constant FOO with the value 'FOO'

Sorry, but I'm not a fan of this proposal. Features should not be aiming at
minor savings of keystrokes at the expense of readability and
maintainability. Remember, we write code once but afterwards it might end
up being read hundreds of times. This proposal makes code less readable,
and unintuitively works differently from enums where cases without explicit
values don't default to anything.

Also, modifiers could be useful:

autoconst uppercase foo; // defines a constant foo with value 'FOO'
autoconst lowercase FOO; // defines a constant FOO with value 'foo';

and maybe:
autoconst camelcase FOO_BAR; // defines a constant FOO_BAR with value
'fooBar'
autoconst snakecase fooBar; // defines a constant fooBar with value
'foo_bar'

This one saves even fewer keystrokes and harms maintainability even more:
imagine you're debugging your program and you've dumped some value. You see
"MyConstant". Now you search the code for the source of that value but find
nothing because instead of MyConstant there's only MY_CONSTANT.

instead of defining constants like:
const FOO = 'FOO';

they could be defined like:
autoconst FOO; // defines a constant FOO with the value 'FOO'

While I've certainly seen constants like this in the past, I think they
mostly fall into two categories:

A) Constants where the value doesn't actually matter, and you just need
something to compare input against. As of PHP 8.1, we will have enums,
where you can just write "case FOO;" and not assign any value at all,
which can probably be used in most of these situations.

B) Constants where the value matters, but the constant name isn't
actually conveying anything. Given your suggestion of built-in
transforms for lower-case etc, these seem like what you're interested in.

These often arise from a misunderstanding of the dogma to "avoid magic
numbers and hard-coded values", and result in code that looks like it's
SHOUTING without conveying any extra information. For instance, people
start with this:

echo "Hello, " . $name ?? "World";

And think that they can "avoid hard-coding" like this:

private const HELLO='Hello, ';
private const WORLD='World';
// ...
echo self::HELLO . $name ?? self::WORLD;

But these constants aren't actually doing anything useful - the code is
harder to read not easier, and it would be very odd to later change the
value of "const WORLD" without also changing its name.

In order to actually be useful, the name of the constant needs to convey
something other than its value, like this:

private const MESSAGE_GREETING='Hello, ';
private const MESSAGE_DEFAULT_NAME='World';
// ...
echo self::MESSAGE_GREETING . $name ?? self::MESSAGE_DEFAULT_NAME;

I think if you eliminate constants which can now be enums, and fix
constants which are badly named, there won't be enough uses left for
this new feature to justify its inclusion in the language.

Regards,

--
Rowan Tommins
[IMSoP]