Hi! I've tried to build pxp from https://pxplang.org/getting-started/installation.html#setup but I failed to issue. See log below:

Some errors have detailed explanations: E0026, E0308, E0412, E0432, E0433, E0532, E0769.
For more information about an error, try `rustc --explain E0026`.
error: could not compile `pxp` due to 65 previous errors
warning: build failed, waiting for other jobs to finish...
error: failed to compile `pxp v0.0.0-b1 (https://github.com/pxp-lang/pxp#9f0adde0)`, intermediate artifacts can be found at `/tmp/cargo-installULorXc`  

Here is my config

❯ cargo -V
cargo 1.66.1 (ad779e08b 2023-01-10)

~ 
❯ uname -a
Linux asus 5.18.19-051819-generic #202208211443 SMP PREEMPT_DYNAMIC Sun Aug 21 15:10:27 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

~
❯ cat /etc/*release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=22.04
DISTRIB_CODENAME=jammy
DISTRIB_DESCRIPTION="Ubuntu 22.04.1 LTS"
PRETTY_NAME="Ubuntu 22.04.1 LTS"
NAME="Ubuntu"
VERSION_ID="22.04"
VERSION="22.04.1 LTS (Jammy Jellyfish)"
VERSION_CODENAME=jammy
ID=ubuntu
ID_LIKE=debian

openssl version
OpenSSL 3.0.2 15 Mar 2022 (Library: OpenSSL 3.0.2 15 Mar 2022)

What I'm doing wrong?

Great project. I really like it and I am looking forward to more momentum in this space.

I don't know if you are already open for suggestions but I am going to post it anyway so it gets tracked. ;-)

I know that you, @ryangjchandler, are also familiar with Go. One of the things I really like about golang is the possibility to define multiple return values, so I don't have to create a class for e.g. a min and a max value returned by a function.

Current situation

/**
* Here could be some array shape
*/
function calculate(): array {}

The result of this function could be accessed by destructuring the resulting array.

[$min, $max] = calculate();
['min' => $min, 'max' => $max] = calculate();

Please note that the syntax might not be 100 % correct as I am only typing it out of my mind. However, you should be able to get the gist of it.

Alternatively one could create a class containing only the both values like this:

readonly class {
  public function __construct(
    public int $min,
    public int $max,
  )
}

However, this might become tedious as I don't want to create a new class (and a new file) for each simple return type.

Proposed solution

function calculate(): int, int {}

$min, $max = calculate();
$min2, _ = calculate();
_, $max2 = calculate();

This would/could transpile down to the following PHP code:

// Here needs to be the correct array syntax for this
function calculate(): array {}

// Or take another var name
$result = calculate();
$min = $result[0];
$max = $result[1];
$result = calculate();
$min2 = $result[0];
$result = calculate();
$max2 = $result[1];

Please note that I made the array of the type array<int, mixed> to make it simpler. Other methods may also work.

Conclusion

I think this could be a nice addition to the syntax. You might also have already thought about this. Please let me know what you think.

Highlighting them the same way as strings is fine for now. We could do some smarter stuff in the future with embedded languages, but not essential right now.

Doesn't work right now. The PHP grammar file is overly complex and does a lot of contextual highlighting which I'm not bothered about right now, but would still be good to get HTML highlighting working.

My suggestion is to improve upon PHP's current Attributes system (https://www.php.net/manual/en/language.attributes.overview.php) by allowing them access to manipulate the way a function is interacted with. This would allow an attribute to "wrap" or "be wrapped by" a function it is applied to.

This would allow things like this to be possible: (Original idea by @enunomaduro on Twitter)

#[Dd]
public function foo() {
    return "bar";
}

This attribute would automatically dd the return value of the function it is applied to.

A possible implementation of this could be as follows:

#[Attribute]
class Dd {
    public function __after($retval) {
        dd($retval);
    }
}

Here I present the __after method that is triggered after a function has been called and is provided with the return value of the function. This idea could be expanded to include a __before method that could allow mutating the input parameters to a function, or even conditionally avoid calling the function entirely. This could be useful for validation purposes.

e.g.

#[GreaterThan(4)]
public function foo(int $a) {
    // Here I am certain that $a is > 4
    return $a + 2;
}

#[Attribute]
class GreaterThan {

    protected $val;

    public function __construct($val) {
        $this->val = $val;
    }

    public function __before($params) {
        if($params[0] <= $this->val) {
            throw new ValidationException("...");
        }
        return $params;
    }
}

I'm quite sure there are better ways of accessing parameters in the __before function, as well as many other aspects of this that can be improved upon. All feedback is welcome.

Original thread about this concept on Twitter: https://twitter.com/ryangjchandler/status/1614611643253530624

Somethig that I'm missing in current PHP is this:

match ($a) {
    instanceof Admin => ...
    instanceof User => ...
}

Only way to do that in pxp is doing:

match {
    $a instanceof Admin => ...
    $a instanceof User => ...
}

which feels a bit repetive.

Another idea could be:

match ($a instanceof) {
   Admin => ...
   User => ...
}