Template generics inside callables

[thomasvargiu]

Hi, I'm trying to implements templates, but psalm infer return type as callable(empty): empty and I don't understand why, is it a bug?

https://psalm.dev/r/eafedd80ab

[psalm-github-bot]

I found these snippets:

https://psalm.dev/r/eafedd80ab

<?php

/**
 * @template T
 *
 * @psalm-param callable(T): mixed $func
 * @psalm-return Closure(T):T
 */
function tee(callable $func): Closure {
    /**
     * @template A
     * @psalm-param A $a
     * @psalm-return A
     */
    return function ($a) use ($func) {
        $func($a);

        return $a;
    };
}

/** @psalm-trace $f */
$f = tee(fn (int $a): string => $a . 'foo');

/** @psalm-trace $result */
$result = $f(5);

Psalm output (using commit d47d817):

INFO: Trace - 23:1 - $f: Closure(empty):empty

ERROR: InvalidScalarArgument - 26:14 - Argument 1 expects empty, int(5) provided

INFO: Trace - 26:1 - $result: empty

INFO: UnusedVariable - 26:1 - Variable $result is never referenced

[thomasvargiu]

Sorry, this is the correct snippet:

https://psalm.dev/r/6c5b012d93

[psalm-github-bot]

I found these snippets:

https://psalm.dev/r/6c5b012d93

<?php

/**
 * @template T
 * @psalm-param callable(T): mixed $func
 * @psalm-return Closure(T): T
 */
function tee(callable $func): Closure {
    return function ($a) use ($func) {
        $func($a);

        return $a;
    };
}

/** @psalm-trace $f */
$f = tee(fn (int $a): string => $a . 'foo');

/** @psalm-trace $result */
$result = $f(5);

Psalm output (using commit d47d817):

INFO: Trace - 17:1 - $f: Closure(empty):empty

ERROR: InvalidScalarArgument - 20:14 - Argument 1 expects empty, int(5) provided

INFO: Trace - 20:1 - $result: empty

[muglug]

It's not really a bug.

You're defining a lower-bound for the param, but not an upper bound. A slightly different version of the code helps Psalm understand what's going on by providing the upper bound for T early: https://psalm.dev/r/ee47d3ca0f

In a language like Hack you could explicitly pass the template params in the call like tee<int>(fn (int $a): string => $a), setting the upper and lower bound for the value of T explicitly, but Psalm has to infer an upper bound and there's nothing for it to use.

[psalm-github-bot]

I found these snippets:

https://psalm.dev/r/ee47d3ca0f

<?php

/**
 * @template T
 * @psalm-param callable(T):mixed $func
 * @psalm-param T $a
 * @psalm-return pure-Closure(): T
 */
function tee(callable $func, $a): Closure {
    return function () use ($func, $a) {
        $func($a);

        return $a;
    };
}

function foo(int $i) : int {
    /** @psalm-trace $f */
    $f = tee(fn (int $a): string => $a . 'foo', $i);

    return $f();
}

Psalm output (using commit debedf2):

INFO: Trace - 19:5 - $f: pure-Closure():int

[thomasvargiu]

@muglug I was playing with templates, and I'm wondering why the same function with a wrapped callable works, and a simple callable not.

https://psalm.dev/r/02085aa6f8

I don't really know the internals, and I don't know if it will be possible, maybe it could be an improvement, but why a templated object works and a callable not? If it works with an object, does it means that psalm can infer types correctly even for closures?

[psalm-github-bot]

I found these snippets:

https://psalm.dev/r/02085aa6f8

<?php

/**
 * @template A
 * @template B
 */
class ClosureContainer {
    /** @var callable(A): B */
    private $f;

    /**
     * @param callable(A): B $f
     */
    public function __construct(callable $f)
    {
        $this->f = $f;
    }

    /**
     * @param A $x
     * @return B
     */
    public function __invoke($x)
    {
        return ($this->f)($x);
    }
}

/**
 * @template T
 * @psalm-param callable(T): mixed $func
 * @psalm-return callable(T): T
 */
function tee(callable $func): callable {
    return
        /**
         * @psalm-param T $value
         * @psalm-return T
         */
        function ($value) use ($func) {
            $func($value);
            return $value;
        };
}

/**
 * Wrapped closure version
 *
 * @template T
 * @param ClosureContainer<T, mixed> $func
 * @return ClosureContainer<T, T>
 */
function tee2(ClosureContainer $func): ClosureContainer {
    $f =
        /**
         * @psalm-param T $value
         * @psalm-return T
         */
        function ($value) use ($func) {
            $func($value);
            return $value;
        };
    return new ClosureContainer($f);
}

$f = fn (string $a): int => strlen($a);
/** @psalm-trace $value */
$value = tee($f)('foo');


// Wrapped closure version

/** @psalm-trace $value */
$value = tee2(new ClosureContainer($f))('foo');

Psalm output (using commit 165e0db):

ERROR: InvalidScalarArgument - 68:18 - Argument 1 expects empty, string(foo) provided

INFO: Trace - 68:1 - $value: empty

INFO: Trace - 74:1 - $value: string

[muglug]

You're right, it should, and now it does!