Tipos de retorno anulables en PHP7

PHP 7 presenta declaraciones de tipo de retorno . Lo que significa que ahora puedo indicar que el valor de retorno es una determinada clase, interfaz, matriz, invocable o uno de los tipos escalares recién imprimibles, como es posible para los parámetros de función.

function returnHello(): string {
    return 'hello';
}

A menudo sucede que un valor no siempre está presente y que puede devolver algo de algún tipo o nulo. Si bien puede hacer que los parámetros sean anulables estableciendo su valor predeterminado en nulo ( DateTime $time = null), no parece haber una forma de hacerlo para los tipos de retorno. ¿Es ese el caso, o de alguna manera no encuentro cómo hacerlo? Estos no funcionan:

function returnHello(): string? {
    return 'hello';
}

function returnHello(): string|null {
    return 'hello';
}

PHP 7.1 ahora admite tipos de retorno anulables . El primer RFC al que me vinculé es el que eligieron:

function nullOrString(int $foo) : ?string
{
    return $foo%2 ? "odd" : null;
}

vieja respuesta:

Como mi comentario fue en realidad una respuesta a la pregunta:

PHP 7 todavía no admitirá tipos de retorno anulables, pero hay un RFC para abordar eso, apunta a aterrizar en PHP 7.1. Si se aprueba, la sintaxis afectaría a todas las sugerencias de tipo (tanto los tipos de retorno como las sugerencias de tipo):

public function returnStringOrNull(?array $optionalArray) : ?string
{
    if ($optionalArray) {
        return implode(', ', $optionalArray);//string returned here
    }
    return null;
}

También hay una RFC competitiva para agregar tipos de unión, que podría hacer lo mismo, pero se vería diferente:

public function returnStringOrNull(array|null $optionalArray) : string|null
{
    if ($optionalArray) {
        return implode(', ', $optionalArray);//string returned here
    }
    return null;
}

Por ahora, sin embargo, tendrás que escribir:

public function returnStringOrNull( array $optionalArray = null)
{
    if ($optionalArray) {
        return implode(', ', $optionalArray);
    }
}

O simplemente devuelva una cadena vacía para que sea consistente con el tipo de retorno, y verifique el valor falso:

public function returnStringOrNull( array $optionalArray = null) : string
{
    if ($optionalArray) {
        return implode(', ', $optionalArray);
    }
    return '';
}
//call
$string = $x->returnStringOrNull();
if (!$string) {
    $string = $x->returnStringOrNull(range(1, 10));
}

Los tipos anulables están disponibles en PHP 7.1.

Este es un ejemplo de sintaxis:

public function getName(): ?string
{
    return $this->name; // name can be null
}

PHP 7.1 ahora es GA y puede actualizar desde PHP 7.0 (solo hay algunos cambios incompatibles con versiones anteriores que debe verificar)

Funciona con cualquier tipo.
Ejemplo:

public function getOpportunity(): ?Opportunity
{
    return $this->opportunity;
}