[Pre-RFC] Idea: named parameter lists

4 hours ago by Henrik Skov — view source — reply

unread

Hi list !

Just got an idea:

params COOKIE_PARAMS {
time() + 3600, // Duration - NOTE: any expression is allowed
here except pure variables
'/', // Path
'', // Can't remember what this is...
(! IS_DEV), // secure — set true once served over HTTPS
(production)
TRUE, // httpOnly
'Lax', // Lax|Strict
}

Instead of this: (I am using Swoole)

$response->cookie(
self::COOKIE_NAME,
$token,
time() + 3600,
'/',
'',
(! IS_DEV), // secure — set true once served over HTTPS
TRUE, // httpOnly
'Lax',
);

we could do:

$response->cookie(
self::COOKIE_NAME,
$token,
:::COOKIE_PARAMS
);

I know it is kind of similar to the spread operator but not quite.

What do you guys think ?

/Henrik

Med venlig hilsen

Henrik Skov
/HSK Consulting/
Blegdamsvej 128B, 4
DK-2100 Copenhagen O
Tel.: +45 27 62 83 01
Email: henry.wood.dk@gmail.com

3 hours ago by AllenJB — view source — reply

unread

Hi list !

Just got an idea:

params COOKIE_PARAMS {
time() + 3600, // Duration - NOTE: any expression is allowed
here except pure variables
'/', // Path
'', // Can't remember what this is...
(! IS_DEV), // secure — set true once served over HTTPS
(production)
TRUE, // httpOnly
'Lax', // Lax|Strict
}

Instead of this: (I am using Swoole)

$response->cookie(
self::COOKIE_NAME,
$token,
time() + 3600,
'/',
'',
(! IS_DEV), // secure — set true once served over HTTPS
TRUE, // httpOnly
'Lax',
);

we could do:

$response->cookie(
self::COOKIE_NAME,
$token,
:::COOKIE_PARAMS
);

I know it is kind of similar to the spread operator but not quite.

What do you guys think ?Email:

PHP already has named parameters[0], and this can be combined with array
unpacking[1] to produce basically the same as you're requesting here:
https://3v4l.org/kD27a#v

(Note: I've purposely moved the samesite parameter to prove the named
array keys are mapping to the named function parameters, and not just
working because they happen to be in order)

[0]
https://www.php.net/manual/en/functions.arguments.php#functions.named-arguments
[1]
https://www.php.net/manual/en/language.types.array.php#language.types.array.unpacking

3 hours ago by Henrik Skov — view source — reply

unread

Hi again !
The important part is that any instantiations and function calls are
evaluated at call-time and not compile time !

So time() would return the timestamp at time of call and not when
compiler first encounters the COOKIE_PARAMS const array. The new params
keyword would make this clear to the compiler

/Henrik

Thanks for the feedback.

Problem with your re-written example is that it works with/depends on
global variables...

I was the code below actually worked:

<?php
const COOKIE_PARAMS = [
"samesite" => "Lax",
"expires_or_options" => time() + 3600, // Let's say time
is 1787047184
"path" => "/",
"domain" => "",
"secure" => false,
"httponly" => true,
];

function fakeSetCookie(
string $name,
string $value = "",
int $expires_or_options = 0,
string $path = "",
string $domain = "",
bool $secure = false,
bool $httponly = false,
string $samesite = "Strict",
) {
var_dump([
"name" => $name,
"value" => $value,
"expires_or_options" => $expires_or_options,
"path" => $path,
"domain" => $domain,
"secure" => $secure,
"httponly" => $httponly,
"samesite" => $samesite,
]);
}

sleep(100);

var_dump(time()); // -> 1787047284

fakeSetCookie("testName", "testValue", ...COOKIE_PARAMS); so
expires_or_options become 1787050884

But sadly, it does not work:

Fatal error: Constant expression contains invalid operations in
/tmp/x.php on line 2

/Henrik

Hi list !

Just got an idea:

params COOKIE_PARAMS {
time() + 3600, // Duration - NOTE: any expression is
allowed here except pure variables
'/', // Path
'', // Can't remember what this is...
(! IS_DEV), // secure — set true once served over
HTTPS (production)
TRUE, // httpOnly
'Lax', // Lax|Strict
}

Instead of this: (I am using Swoole)

$response->cookie(
self::COOKIE_NAME,
$token,
time() + 3600,
'/',
'',
(! IS_DEV), // secure — set true once served over HTTPS
TRUE, // httpOnly
'Lax',
);

we could do:

$response->cookie(
self::COOKIE_NAME,
$token,
:::COOKIE_PARAMS
);

I know it is kind of similar to the spread operator but not quite.

What do you guys think ?Email:

PHP already has named parameters[0], and this can be combined with
array unpacking[1] to produce basically the same as you're requesting
here: https://3v4l.org/kD27a#v

(Note: I've purposely moved the samesite parameter to prove the named
array keys are mapping to the named function parameters, and not just
working because they happen to be in order)

[0]
https://www.php.net/manual/en/functions.arguments.php#functions.named-arguments
[1]
https://www.php.net/manual/en/language.types.array.php#language.types.array.unpacking

--

Med venlig hilsen

Henrik Skov
/HSK Consulting/
Blegdamsvej 128B, 4
DK-2100 Copenhagen O
Tel.: +45 27 62 83 01
Email: henry.wood.dk@gmail.com
--

Med venlig hilsen

Henrik Skov
/HSK Consulting/
Blegdamsvej 128B, 4
DK-2100 Copenhagen O
Tel.: +45 27 62 83 01
Email: henry.wood.dk@gmail.com

2 hours ago by AllenJB — view source — reply

unread

Hi again !
The important part is that any instantiations and function calls are
evaluated at call-time and not compile time !

So time() would return the timestamp at time of call and not when
compiler first encounters the COOKIE_PARAMS const array. The new params
keyword would make this clear to the compiler

/Henrik

Thanks for the feedback.

Problem with your re-written example is that it works with/depends on
global variables...

I was the code below actually worked:

<?php
const COOKIE_PARAMS = [
"samesite" => "Lax",
"expires_or_options" => time() + 3600, // Let's say time
is 1787047184
"path" => "/",
"domain" => "",
"secure" => false,
"httponly" => true,
];

[...]

sleep(100);

var_dump(time()); // -> 1787047284

fakeSetCookie("testName", "testValue", ...COOKIE_PARAMS); so
expires_or_options become 1787050884

Ah, I think I understand now.

What you're proposing is a structure where you can define a value as an
expression, and that expression is only evaluated when the structure is
used (rather than when it's defined).

So, even in a long-lived application, the expires_or_options value would
always be evaluated as time() + 3600

If this were to be implemented, I think it would be better to look at
values, rather than defining an entire structure. I can see it being
used for more than parameters.

Something like an IIFE that's invoked when used rather than when defined.

As a side-note, one way to achieve this in current PHP would be to use a
callable:

$params = function() {
     return [
         "samesite" => "Lax",
         "expires_or_options" => `time()` + 3600,
         "path" => "/",
         "domain" => "",
         "secure" => false,
         "httponly" => true,
     ];
};

fakeSetCookie("testName", "testValue", ...$params());
sleep(2);
fakeSetCookie("testName", "testValue", ...$params());

(3v4l refused to save this, probably because it takes too long)

This can also be written using arrow functions:

$params = fn() => [
     "samesite" => "Lax",
     "expires_or_options" => `time()` + 3600,
     "path" => "/",
     "domain" => "",
     "secure" => false,
     "httponly" => true,
];

1 hour ago by Henrik Skov — view source — reply

unread

Hi again !
The important part is that any instantiations and function calls are
evaluated at call-time and not compile time !

So time() would return the timestamp at time of call and not when
compiler first encounters the COOKIE_PARAMS const array. The new
params keyword would make this clear to the compiler

/Henrik

Thanks for the feedback.

Problem with your re-written example is that it works with/depends
on global variables...

I was the code below actually worked:

<?php
const COOKIE_PARAMS = [
"samesite" => "Lax",
"expires_or_options" => time() + 3600, // Let's say time
is 1787047184
"path" => "/",
"domain" => "",
"secure" => false,
"httponly" => true,
];

[...]

sleep(100);

var_dump(time()); // -> 1787047284

fakeSetCookie("testName", "testValue", ...COOKIE_PARAMS); so
expires_or_options become 1787050884

Ah, I think I understand now.

What you're proposing is a structure where you can define a value as
an expression, and that expression is only evaluated when the
structure is used (rather than when it's defined).

So, even in a long-lived application, the expires_or_options value
would always be evaluated as time() + 3600

If this were to be implemented, I think it would be better to look at
values, rather than defining an entire structure. I can see it being
used for more than parameters.

Something like an IIFE that's invoked when used rather than when defined.

As a side-note, one way to achieve this in current PHP would be to use
a callable:
$params = function() {
    return [
        "samesite" => "Lax",
        "expires_or_options" => `time()` + 3600,
        "path" => "/",
        "domain" => "",
        "secure" => false,
        "httponly" => true,
    ];
};

fakeSetCookie("testName", "testValue", ...$params());
sleep(2);
fakeSetCookie("testName", "testValue", ...$params());
(3v4l refused to save this, probably because it takes too long)

This can also be written using arrow functions:
$params = fn() => [
    "samesite" => "Lax",
    "expires_or_options" => `time()` + 3600,
    "path" => "/",
    "domain" => "",
    "secure" => false,
    "httponly" => true,
];

Yes, but I think one should consider params COOKIE_PARAMS {...} more of
a type !

Med venlig hilsen

Henrik Skov
/HSK Consulting/
Blegdamsvej 128B, 4
DK-2100 Copenhagen O
Tel.: +45 27 62 83 01
Email: henry.wood.dk@gmail.com

1 hour ago by Kamil Tekiela — view source — reply

unread

Hi again !
The important part is that any instantiations and function calls are evaluated at call-time and not compile time !

So time() would return the timestamp at time of call and not when compiler first encounters the COOKIE_PARAMS const array. The new params keyword would make this clear to the compiler

/Henrik

Thanks for the feedback.

Problem with your re-written example is that it works with/depends on global variables...

I was the code below actually worked:

<?php
const COOKIE_PARAMS = [
"samesite" => "Lax",
"expires_or_options" => time() + 3600, // Let's say time is 1787047184
"path" => "/",
"domain" => "",
"secure" => false,
"httponly" => true,
];

[...]

sleep(100);

var_dump(time()); // -> 1787047284

fakeSetCookie("testName", "testValue", ...COOKIE_PARAMS); so
expires_or_options become 1787050884

Ah, I think I understand now.

What you're proposing is a structure where you can define a value as an expression, and that expression is only evaluated when the structure is used (rather than when it's defined).

So, even in a long-lived application, the expires_or_options value would always be evaluated as time() + 3600

If this were to be implemented, I think it would be better to look at values, rather than defining an entire structure. I can see it being used for more than parameters.

Something like an IIFE that's invoked when used rather than when defined.

As a side-note, one way to achieve this in current PHP would be to use a callable:
$params = function() {
    return [
        "samesite" => "Lax",
        "expires_or_options" => `time()` + 3600,
        "path" => "/",
        "domain" => "",
        "secure" => false,
        "httponly" => true,
    ];
};

fakeSetCookie("testName", "testValue", ...$params());
sleep(2);
fakeSetCookie("testName", "testValue", ...$params());
(3v4l refused to save this, probably because it takes too long)

This can also be written using arrow functions:
$params = fn() => [
    "samesite" => "Lax",
    "expires_or_options" => `time()` + 3600,
    "path" => "/",
    "domain" => "",
    "secure" => false,
    "httponly" => true,
];
--

Yes, but I think one should consider params COOKIE_PARAMS {...} more of a type !

Then why not create a type for it https://3v4l.org/lNjSX#vgit.master