supporting the final keyword for properties

C# does this with the readonly keyword, sounds like a good idea.

Hi,

The recent internals@lists.php.net/msg59301.html" rel="nofollow" target="_blank">http://www.mail-archive.com/internals@lists.php.net/msg59301.html
discussion
made me wonder why did we decide not supporting the final keywords for
properties as it would provide an easy way for read-only attributes (const
would be a better choice in performance wise, but then you can only set it
in your declaration where no dynamic expression is allowed.)

I would like it to work the same way as it does in java(
http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.12.4) eg.
you can set the initial value either in the declaration or later on, but
after it is set, you can't change it, trying to do that would create a
recoverable fatal error (or throwing an exception which extends
RuntimeException).

What do you think? Would this be viable? Is there any still-present reason
why we shouldn't support that?

--
Ferenc Kovács
@Tyr43l - http://tyrael.hu

--
Andrew Faulds (AJF)
http://ajf.me/

Ferenc,

Hi,

The recent
internals@lists.php.net/msg59301.html" rel="nofollow" target="_blank">http://www.mail-archive.com/internals@lists.php.net/msg59301.html
discussion
made me wonder why did we decide not supporting the final keywords for
properties as it would provide an easy way for read-only attributes (const
would be a better choice in performance wise, but then you can only set it
in your declaration where no dynamic expression is allowed.)

I would like it to work the same way as it does in java(
http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.12.4)
eg.
you can set the initial value either in the declaration or later on, but
after it is set, you can't change it, trying to do that would create a
recoverable fatal error (or throwing an exception which extends
RuntimeException).

What do you think? Would this be viable? Is there any still-present reason
why we shouldn't support that?

My question would be where in code would this be enforced? A trivial
implementation could be done in the object.write_property handler. But
wouldn't things like references and the such (read_property and
get_property_ptr_ptr, as well as get_properties) also be paths to
writability?

Would that then mean that this would need to be added to the zval type
directly, and not just the property table? And if that's the case, why not
make it final for the entire engine (meaning that I can declare a global
property as final using final $var = 1;)... Thereby making this a rather
significant engine changes? Or is there an easier way that I'm missing...?

Anthony

Hi,

The recent internals@lists.php.net/msg59301.html" rel="nofollow" target="_blank">http://www.mail-archive.com/internals@lists.php.net/msg59301.html
discussion
made me wonder why did we decide not supporting the final keywords for
properties as it would provide an easy way for read-only attributes (const
would be a better choice in performance wise, but then you can only set it
in your declaration where no dynamic expression is allowed.)

I would like it to work the same way as it does in java(
http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.12.4) eg.
you can set the initial value either in the declaration or later on, but
after it is set, you can't change it, trying to do that would create a
recoverable fatal error (or throwing an exception which extends
RuntimeException).

What do you think? Would this be viable? Is there any still-present reason
why we shouldn't support that?

I don't like this overloaded meaning of "final". "final" currently
means "cannot be overwritten by inheritance". This would add a second
meaning which would be somewhat similar to "const" (but only
somewhat).

Nikita

hi,

The recent internals@lists.php.net/msg59301.html" rel="nofollow" target="_blank">http://www.mail-archive.com/internals@lists.php.net/msg59301.html
discussion
made me wonder why did we decide not supporting the final keywords for
properties as it would provide an easy way for read-only attributes (const
would be a better choice in performance wise, but then you can only set it
in your declaration where no dynamic expression is allowed.)

Final and readonly are too totally different concepts.

Read only properties can be implemented by doing something using the
nice getter/setter RFC
(https://wiki.php.net/rfc/propertygetsetsyntax-as-implemented).

Cheers,

Pierre

@pierrejoye | http://blog.thepimp.net | http://www.libgd.org

It could be useful (given the example of Java usage).
But still, if the goal is to have read-only attributes, I think my proposal
(separate reading and writing visibilities) is more precise and powerful.

2012/7/16 Ferenc Kovacs tyra3l@gmail.com

Hi,

The recent
internals@lists.php.net/msg59301.html" rel="nofollow" target="_blank">http://www.mail-archive.com/internals@lists.php.net/msg59301.html
discussion
made me wonder why did we decide not supporting the final keywords for
properties as it would provide an easy way for read-only attributes (const
would be a better choice in performance wise, but then you can only set it
in your declaration where no dynamic expression is allowed.)

I would like it to work the same way as it does in java(
http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.12.4)
eg.
you can set the initial value either in the declaration or later on, but
after it is set, you can't change it, trying to do that would create a
recoverable fatal error (or throwing an exception which extends
RuntimeException).

What do you think? Would this be viable? Is there any still-present reason
why we shouldn't support that?

--
Ferenc Kovács
@Tyr43l - http://tyrael.hu

Hi,

The recent
internals@lists.php.net/msg59301.html" rel="nofollow" target="_blank">http://www.mail-archive.com/internals@lists.php.net/msg59301.html discussion
made me wonder why did we decide not supporting the final keywords for
properties as it would provide an easy way for read-only attributes (const
would be a better choice in performance wise, but then you can only set it
in your declaration where no dynamic expression is allowed.)

I would like it to work the same way as it does in java(
http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.12.4)
eg. you can set the initial value either in the declaration or later on,
but after it is set, you can't change it, trying to do that would create a
recoverable fatal error (or throwing an exception which extends
RuntimeException).

What do you think? Would this be viable? Is there any still-present reason
why we shouldn't support that?

--
Ferenc Kovács
@Tyr43l - http://tyrael.hu

the accessors rfc got rejected, so I'm bringing this up again.

--
Ferenc Kovács
@Tyr43l - http://tyrael.hu

2013/5/28 Amaury Bouchard amaury@amaury.net

2013/5/28 Maciek Sokolewicz maciek.sokolewicz@gmail.com

It’s a good idea in general but what about having it for variables as

well? Could open interesting possibilities for an optimizer.

final $foo = "str";
$foo = "bar"; // bails out

Don't we already have that? It just has a different name: constants.

It's different. You can manipulate variables in some ways you can't with
constants.

This code, for example:
$a = 'abc';
$b = 'a';
print($$b);

It will display "abc". It's currently not possible to do something similar
with constants.

define('FOO', 'bar');
$b = 'FOO';
print(constant($b));

and yes, constant() works for namespace- and class-constants too.

I think the subject was already debated, but I wonder why we should write
that:
final $foo = 'bar';
instead of:
const $foo = 'bar';

--
github.com/KingCrunch