Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:93384
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: error (pb1.pair.com: domain mindplay.dk from 209.85.218.51 cause and error)
MIME-Version: 1.0
In-Reply-To: <b3f54e07-a19c-83d6-6ad5-e8e4ee56e9d9@gmail.com>
References: <CADqTB_i5WL+rzCuFHkRmXsPj16WDc4eWmpAoFmyeuYXvuOP_NQ@mail.gmail.com>
	<CAEPJdunJ-67CqJq2hzvmnEmuOFQRGpxv8iycq3CnocXR4r20vw@mail.gmail.com>
	<CADqTB_iUDGHXUR5cYUDuzL4XrqJk-Jf0oce_uj6ZUtEYr7fTYw@mail.gmail.com>
	<CAEPJdunVsJWkOez3ERdpsKjFx8oxPmWVropZ5n9VKTfKdokpXg@mail.gmail.com>
	<CADqTB_jzRPG2CNXniyyo2XA36GGy_s29i5SGPfYe4c8gcpnK6g@mail.gmail.com>
	<61e6a083-91c2-799f-9757-02f56fe184e9@gmail.com>
	<CADqTB_jB-bXU5FjJoEqx-qTCiX6NSoo9YtxxHiX1X40FqmJ9Pg@mail.gmail.com>
	<ec6a9d04-83d0-1b70-4418-281e4b3f5a54@fleshgrinder.com>
	<CADqTB_jNcQ24=KC68vrpvXAEmeTJH9Xk4kB9Yr4Pi+3vRWsJiw@mail.gmail.com>
	<CADqTB_jM4-3JZt_t2yQtroDfS7ZSSLp6FNmHWVa+kqh3znsNBQ@mail.gmail.com>
	<b3f54e07-a19c-83d6-6ad5-e8e4ee56e9d9@gmail.com>
Date: Tue, 17 May 2016 19:47:06 +0200
Message-ID: <CADqTB_jF+5ARpCn1-sAeM_R0iAzagCXpM65aX3NdPws3HLBqbw@mail.gmail.com>
To: Rowan Collins <rowan.collins@gmail.com>
Cc: PHP internals <internals@lists.php.net>
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Subject: Re: [PHP-DEV] [RFC] Simple Annotations
From: rasmus@mindplay.dk (Rasmus Schultz)

> I don't really understand what closures have to do with annotations, or h=
ow that relates to capturing context.

The point is that, rather than trying to capture context, you can just
as well ask for what you need.

I'm going to use a very contrived example, because I really can't
think of any real case that requires context:

class User
{
    << new Validation(function ($value) { return false !=3D=3D
filter_var($value, FILTER_VALIDATE_EMAIL); }) >>
    public $email;
}

Like I said, extremely contrived - in practice, you wouldn't need to
attach functionality in that way.

> An example from the other thread of a context-bound annotation would be i=
mplementing validation like this

You're not annotating the function - this is just a round-about way of
annotating the argument.

You would do that directly, like this:

function foo(
    << ValidateRange(0, 100) >>
    int $percentage
) { ... }

> If the expression would have to be made up entirely of constants anyway, =
might the same "constant expressions" used in class const definitions be a =
better fit than "any valid PHP expression" - plus a specific exception for =
creating objects out of those constant expressions.

Probably not - what happens with what is today "nested annotations"
then? Or will you make an exception for those too?

The problem is, you're just reinventing a subset of the programming
language, and I'm sure you can keep expanding on that indefinitely.
What for? Just use the facilities already defined by the language.

This fear of any feature that lets you do "evil" is incomprehensible
to me. Most features of almost any programming language can be used
for "evil". IMO, the real question is whether a feature accomplishes
what you want. If you insist on something that also prevents things
you don't want, you're bound to end up with something a lot more
complex that fits into the language a lot less naturally...


On Tue, May 17, 2016 at 5:28 PM, Rowan Collins <rowan.collins@gmail.com> wr=
ote:
> On 17/05/2016 15:22, Rasmus Schultz wrote:
>>
>> The other issue is the dependency (context) injection example - no one
>> seems to be able to cite an actual use-case, and if that's the case, I
>> should probably just remove it from the RFC entirely?
>>
>> @Larry can you think of a case example in the myriad annotations
>> you've seen in Drupal code? :-)
>>
>> Anyone else using Doctrine Annotations actually seen anyone making use
>> of a closure in an annotation?
>
>
> Possibly nobody's responded to your call for an example because they're n=
ot
> sure what it is you're asking for an example of. I don't really understan=
d
> what closures have to do with annotations, or how that relates to capturi=
ng
> context.
>
> An example from the other thread of a context-bound annotation would be
> implementing validation like this:
>
> <<ValidateRange($percentage, 0, 100)>>
> function foo(int $percentage)
>
>
> This would appear to be unsupported as such by your proposal, so you woul=
d
> instead just have to use strings to represent how it needed to be accesse=
d:
>
> <<new ValidateRangeAnnotation('$percentage', 0, 100)>>
>
> and then have extra machinery in the reflection logic to extract the
> parameters and pass them to the object, e.g.
> $annotation->validate($reflected_parameters)
>
>
> This might be the more sensible approach to such an annotation anyway, bu=
t
> without any access to variables, I don't really understand the value of
> evaluating an expression for the annotation, just to get a constant value
> that is cached by the Reflection infrastructure.
>
> If the expression would have to be made up entirely of constants anyway,
> might the same "constant expressions" used in class const definitions be =
a
> better fit than "any valid PHP expression" - plus a specific exception fo=
r
> creating objects out of those constant expressions.
>
>
> Regards,
> --
> Rowan Collins
> [IMSoP]
>
> --
> PHP Internals - PHP Runtime Development Mailing List
> To unsubscribe, visit: http://www.php.net/unsub.php
>