Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:116231
Content-Type: text/plain;
	charset=utf-8
Content-Transfer-Encoding: quoted-printable
Mime-Version: 1.0 (Mac OS X Mail 13.4 \(3608.120.23.2.7\))
Message-ID: <29103CC9-22A5-4507-A982-CFFC20450435@newclarity.net>
Date: Tue, 5 Oct 2021 13:47:27 -0400
To: PHP Internals List <internals@lists.php.net>
Subject: Function list declaration syntax?
From: mike@newclarity.net (Mike Schinkel)

Hi all,

This email proposes a shorthand syntax for declaring a list of =
single-expression functions.=20

A similar albeit more verbose attempt to provide short functions[1] =
failed late last year, but I was recently inspired by Sebastian =
Bergmann's Type library[2] that he referenced in a comment on another =
thread.

Consider the `Type` class[3] in the `SebastianBergmann\Type` namespace. =
It contains 60 lines of function declaration to define 14 functions that =
all return `false`.  Even though it really is a simple class it is =
rather hard to wrap one's head around quickly because of all the =
bloating boilerplate required. At least IMO.

Consider instead if we had the following syntax?

public function list: bool
{
  isCallable() =3D> false,
  isFalse() =3D> false,
  isGenericObject() =3D> false,
  isIntersection() =3D> false,
  isIterable() =3D> false,
  isMixed() =3D> false,
  isNever() =3D> false,
  isNull() =3D> false,
  isObject() =3D> false,
  isSimple() =3D> false,
  isStatic() =3D> false,
  isUnion() =3D> false,
  isUnknown() =3D> false,
  isVoid() =3D> false,
}

The idea here is to group a 'list' of functions =E2=80=94 in this case =
of the same type =E2=80=94 and then use shortened single expression fn() =
syntax for each function. And with a monospace font in your editor of =
choice this code could be made even easier to grok by left-aligning the =
return values.

I chose the keyword `list` because it is already a reserved word, but =
the word `case` could also be used for the same reason, if people prefer =
that.

Further, instead of `function list` or `function case` we could have `fn =
list`, `fn case`, `fn() list` or `fn() case`, whichever feels best to =
the most people.

This could also work for abstract functions noting that the typehint is =
applied to each function instead of the list declaration, e.g.:

abstract public function list=20
{
  isAssignable(self $other): bool;
  name(): string;
  allowsNull(): bool;
}

Those two changes shorten Type.php from 140 lines down to 90 lines, and =
IMO, make the class much easier to read. You can see it here[4].

One more example, this time his `NullType` class[5] using mixed type =
hints and going from a total of 38 lines down to 26 lines[6]:

public function list
{
    name(): string =3D> 'null',
    asString(): string =3D> 'null',
    allowsNull(): bool =3D> true,
    isNull(): bool =3D> true,
}

What do you think?  Is this approach any more appealing than the last =
one proposed?

-Mike

[1] https://wiki.php.net/rfc/short-functions
[2] https://github.com/sebastianbergmann/type
[3] =
https://github.com/sebastianbergmann/type/blob/master/src/type/Type.php
[4] =
https://gist.github.com/mikeschinkel/6f8c9cf6700a75e75e2725db1ed4da61
[5] =
https://github.com/sebastianbergmann/type/blob/master/src/type/NullType.ph=
p
[6] =
https://gist.github.com/mikeschinkel/a93aabd61127b0c3ba28c5caf4ebe005=