Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Criando Aplicações Robustas em PHP com Tipos

Criando Aplicações Robustas em PHP com Tipos

Os tipos são ferramentas fundamentais para a construção de uma aplicação robusta. Eles são utilizados para a prevenção de erros durante a execução e auxiliam na legibilidade e manutenção do código. Nesta palestra serão apresentadas a definição de tipos e por que utilizá-los, sistema de tipos, tipagem estática e dinâmica, tipagem forte e fraca, como funciona o sistema de tipos e a evolução dos tipos em PHP. Abordaremos as novidades relacionadas a tipos que foram adicionadas ao longo do tempo na linguagem tais como enums e intersection types que estarão disponíveis na versão mais nova do PHP. E, por fim, falaremos como expandir o sistema de tipos do PHP e torná-lo ainda mais poderoso com o auxílio de ferramentas de análise estática como PHPStan e Psalm. Assista esta palestra e aprenda como tirar vantagem dos tipos na linguagem mais querida da web!

Marcel dos Santos

November 22, 2021
Tweet

More Decks by Marcel dos Santos

Other Decks in Programming

Transcript

  1. Marcel Gonçalves dos Santos
    @marcelgsantos
    T
    php
    criando aplicações
    em
    com tipos
    robustas

    View Slide

  2. pensandonaweb.com.br
    desenvolvedor web full-stack
    Marcel Gonçalves dos Santos
    @marcelgsantos

    View Slide

  3. @phpsp
    phpsp.org.br

    View Slide

  4. Interaja nas mídias sociais!


    - fale sobre o evento, palestrantes e conteúdo


    - tire fotos do evento e publique

    - interaja com outros participantes do evento


    - tire dúvidas ou dê feedbacks para os palestrantes

    View Slide

  5. O que são tipos?

    View Slide

  6. os tipos podem ser considerados como
    um conjunto de valores, isto é, os valores
    são agrupados por tipos

    View Slide

  7. eles de
    fi
    nem quais operações podem


    ser realizadas sobre um dado

    View Slide

  8. os tipos possuem cardinalidade

    View Slide

  9. eles de
    fi
    nem a forma como um valor
    é armazenado é representado

    View Slide

  10. os tipos de
    fi
    nem o signi
    fi
    cado semântico do
    valor

    View Slide

  11. um tipo é uma classi
    fi
    cação do dado que
    de
    fi
    ne a operação que pode ser feita sobre
    aquele dado, o signi
    fi
    cado do dado e o
    conjunto de valores permitidos

    View Slide

  12. Por que utilizar tipos?

    View Slide

  13. a utilização de tipos ajuda a prevenir erros
    de uma categoria especí
    fi
    ca

    View Slide

  14. a medida que a complexidade de um
    software cresce, é necessário que o código
    possua garantias de corretude

    View Slide

  15. os tipos fornecem provas genéricas de que
    o código funcionará de acordo com a entrada

    View Slide

  16. os erros que acontecem em tempo de
    execução e que podem causar problemas


    na aplicação…

    View Slide

  17. …podem ser transformados em erros em
    tempo de compilação e evitar causar sérios
    problemas na aplicação

    View Slide

  18. existem esforços para trazer type checking
    em tempo de compilação para linguagens
    dinamicamente tipadas

    View Slide

  19. o TypeScript é uma linguagem criada para
    fornecer checagem de tipo em tempo de
    compilação para o JavaScript

    View Slide

  20. os principais benefícios dos tipos são
    corretude, imutabilidade, encapsulamento,
    componibilidade e legibilidade

    View Slide

  21. O que é sistema de tipos?

    View Slide

  22. um sistema de tipos é um conjunto de regras
    que atribui e impõe tipos para elementos de
    uma linguagem de programação

    View Slide

  23. um sistema de tipos permite atribuir tipos
    através de uma notação no código ou
    implicitamente deduzindo o tipo de certos
    elementos baseados no contexto

    View Slide

  24. ele permite várias conversões de tipos e
    proíbe outras

    View Slide

  25. utiliza-se o sistema de tipos para projetar
    código menos propenso a erros, melhor
    componentizável e fácil de entender

    View Slide

  26. um código correto significa que ele se com-
    porta de acordo com a sua especi
    fi
    cação,
    produz resultados esperados e sem criar
    erros em tempo de execução

    View Slide

  27. ao utilizar um sistema de tipos transforma-se
    o que seria um erro em tempo de execução
    que poderia acontecer em produção e afetar
    o cliente final…

    View Slide

  28. …em um inofensivo erro em tempo de
    compilação que pode ser corrigido antes de
    fazer o deploy do código

    View Slide

  29. um sistema de tipos permite otimização


    em tempo de execução, funciona como
    documentação e pode ser interno ou
    externo a linguagem

    View Slide

  30. Como os tipos podem

    ser classi
    fi
    cados?

    View Slide

  31. os tipos podem ser classi
    fi
    cados como
    primitivo, composto ou recursivo

    View Slide

  32. os tipos primitivos são aqueles cujos valores
    são atômicos, ou seja, não podem ser
    decompostos em valores mais simples

    View Slide

  33. os tipos compostos são aqueles cujos
    valores são compostos por valores de


    tipos primitivos

    View Slide

  34. os tipos recursivos é de
    fi
    nido em termos de
    si e a cardinalidade de tipos recursivos é
    in
    fi
    nita

    View Slide

  35. as linguagens podem ter tipagem estática
    ou tipagem dinâmica

    View Slide

  36. uma linguagem com tipagem estática
    realiza a veri
    fi
    cação de tipos em tempo de
    compilação

    View Slide

  37. uma linguagem com tipagem dinâmica
    realiza a veri
    fi
    cação de tipos em tempo de
    execução

    View Slide

  38. as linguagens podem ter tipagem forte e
    tipagem fraca

    View Slide

  39. em uma linguagem com tipagem forte a
    conversão de tipos deve ser feita de forma
    explícita e operações entre valores de tipos
    diferentes não são permitidas

    View Slide

  40. em uma linguagem com tipagem fraca a
    conversão de tipos é feita de forma implícita
    e operações entre valores de tipos diferentes
    são permitidas e feitas de forma automática

    View Slide

  41. o PHP possui tipagem dinâmica e fraca pois
    a veri
    fi
    cação de tipos é feita em tempo de
    execução e é feita a conversão automática
    de tipos em operações com tipos diferentes

    View Slide

  42. ao utilizar ferramentas de análise estática
    como Phan, PHPStan e Psalm é possível
    realizar a veri
    fi
    cação de tipos em tempo de
    “compilação” na linguagem

    View Slide

  43. Operações comuns

    relacionadas à tipos

    View Slide

  44. a veri
    fi
    cação de tipo ou type checking é um
    processo de veri
    fi
    cação e garantia das
    restrições de tipos

    View Slide

  45. a verificação de tipo pode ser executada em
    tempo de compilação ou tempo de execução

    View Slide

  46. ela garante a integridade do dado, impõe
    restrições de acesso e interpreta os dados
    como pretendidos pelo(a) programador(a)

    View Slide

  47. a conversão de tipos pode ser realizada de
    forma implícita e explícita

    View Slide

  48. a conversão implícita ou coerção é realizada
    de forma automática pelo compilador ou
    interpretador

    View Slide

  49. a conversão explícita ou cast é realizada de
    forma manual pelo(a) programador(a)

    View Slide

  50. a inferência de tipos permite que o(a)
    programador(a) não declare o tipo mas que
    o compilador ou interpretador conheça o
    tipo com base no valor informado

    View Slide

  51. um erro de tipo ocorre se o programa executa

    uma operação com tipos incompatíveis

    View Slide

  52. Como funcionam


    os tipos no PHP?

    View Slide

  53. Conceitos básicos

    View Slide

  54. os tipos são divididos em tipos escalares,
    compostos e especiais

    View Slide

  55. escalares


    boolean, integer, float ou string

    View Slide

  56. compostos


    array, object, callable ou iterable

    View Slide

  57. especiais


    resource e null

    View Slide

  58. também existem os pseudo-tipos

    View Slide

  59. pseudo-tipos


    mixed, number, callback, array|object e
    void

    View Slide

  60. os tipos são de
    fi
    nidos em tempo de execução

    View Slide

  61. / /
    variables of several different types

    $a_boolean = true;


    $an_int = 10;


    $a_float = 3.14;


    $a_string = 'joe';


    $a_null = null;


    $a_array = [];


    $a_callable = function() { return 'Hey!'; };


    $a_object = new stdClass;

    View Slide

  62. as funções get_debug_type, gettype e
    var_dump são utilizadas para conhecer o
    tipo da variável ou expressão

    View Slide

  63. / /
    get variable type using var_dump() function


    var_dump($a_boolean);
    / /
    bool(true)


    var_dump($an_int);
    / /
    int(10)


    var_dump($a_float);
    / /
    float(3.14)


    var_dump($a_string);
    / /
    string(3) "joe"


    var_dump($a_null);
    / /
    NULL


    var_dump($a_array);
    / /
    array(0) {}


    var_dump($a_callable);
    / /
    object(Closure)#1 (0) {}


    var_dump($a_object);
    / /
    object(stdClass)#2 (0) {}

    View Slide

  64. / /
    get variable type using gettype() function


    echo gettype($a_boolean);
    / /
    boolean


    echo gettype($an_int);
    / /
    integer


    echo gettype($a_float);
    / /
    double


    echo gettype($a_string);
    / /
    string


    echo gettype($a_null);
    / /
    NULL


    echo gettype($a_array);
    / /
    array


    echo gettype($a_callable);
    / /
    object


    echo gettype($a_object);
    / /
    object

    View Slide

  65. / /
    get variable type using get_debug_type()


    / /
    function available on PHP 8.0


    echo get_debug_type($a_boolean);
    / /
    bool


    echo get_debug_type($an_int);
    / /
    int


    echo get_debug_type($a_float);
    / /
    float


    echo get_debug_type($a_string);
    / /
    string


    echo get_debug_type($a_null);
    / /
    null


    echo get_debug_type($a_array);
    / /
    array


    echo get_debug_type($a_callable);
    / /
    Closure


    echo get_debug_type($a_object);
    / /
    stdClass

    View Slide

  66. as funções is_int, is_boolean, is_string,
    is_array são utilizadas para veri
    fi
    car o tipo
    da variável ou expressão

    View Slide

  67. / /
    check if variables are from a specif
    i
    c


    / /
    type using is_*() functions


    var_dump(is_bool($a_boolean));
    / /
    bool(true)


    var_dump(is_bool($an_int));
    / /
    bool(false)

    var_dump(is_int($an_int));
    / /
    bool(true)


    var_dump(is_int($a_float));
    / /
    bool(false)

    var_dump(is_float($a_float));
    / /
    bool(true)


    var_dump(is_float($a_string));
    / /
    bool(false)

    View Slide

  68. / /
    check if variables are from a specif
    i
    c


    / /
    type using is_*() functions


    var_dump(is_string($a_string));
    / /
    bool(true)


    var_dump(is_string($a_null));
    / /
    bool(false)



    var_dump(is_array($a_array));
    / /
    bool(true)


    var_dump(is_array($a_object));
    / /
    bool(false)

    var_dump(is_null($a_null));
    / /
    bool(true)


    var_dump(is_null($a_array));
    / /
    bool(false)

    View Slide

  69. Conversão de tipos

    View Slide

  70. conversão explícita e automática

    View Slide

  71. / /
    explicit type conversion


    var_dump((bool) "1.5");
    / /
    bool(true)


    var_dump((int) "1.5");
    / /
    int(1)


    var_dump((float) "1.5");
    / /
    float(1.5)


    var_dump((string) 1.5);
    / /
    string(3) "1.5"

    View Slide

  72. / /
    explicit type conversion


    var_dump((array) 1.5);


    / /
    array(1) { [0]
    = >
    float(1.5) }


    var_dump((array) "1.5");


    / /
    array(1) { [0]
    = >
    string(3) "1.5" }


    var_dump((object) 1.5);


    / /
    object(stdClass)#1 (1) {["scalar"]
    = >



    var_dump((object) "1.5");


    / /
    object(stdClass)#1 (1) {["scalar"]
    = >

    View Slide

  73. / /
    implicit or automatic type conversion


    / /
    using `+` operator

    $var = "0";


    var_dump($var);
    / /
    string(2) "0"


    $var += 5;


    var_dump($var);
    / /
    int(5)


    $var = $var + 3.1;


    var_dump($var);
    / /
    float(8.1)

    View Slide

  74. Declaração de tipos

    View Slide

  75. as declarações de tipos garantem que o
    valor é do tipo especi
    fi
    cado no momento da
    chamada

    View Slide

  76. as declarações de tipos podem ser utiliza-
    das em argumentos de funções, retornos de
    valores e propriedades de classe

    View Slide

  77. caso o valor informado não seja do tipo
    especi
    fi
    cado na declaração do tipo a
    exceção TypeError é lançada*

    View Slide

  78. declarações de tipos


    1. tipos escalares

    2. tipos compostos

    3. classes e interfaces

    4. object, mixed, self, parent, never

    5. union types e intersection type

    6. enums

    View Slide

  79. / /
    type declaration using classes


    class Mammal {}


    class Cat extends Mammal {}


    class Duck {}


    function sayHi(Mammal $mammal) {


    echo 'Hi ' . get_class($mammal) . '!';


    }


    sayHi(new Mammal);
    / /
    Hi Mammal!


    sayHi(new Cat);
    / /
    Hi Cat!

    sayHi(new Duck);

    / /
    Uncaught TypeError: Argument 1 passed to


    / /
    sayHi() must be an instance of Mammal, instance of Duck given

    View Slide

  80. Modo estrito

    View Slide

  81. o PHP realiza, por padrão, a conversão
    automática de tipos de um valor para


    o tipo esperado quando necessário

    View Slide

  82. / /
    not using strict types


    function sum(int $a, int $b) {


    return $a + $b;


    }


    var_dump(sum(1, 2));
    / /
    int(3)


    var_dump(sum(1.5, 2.5));
    / /
    int(3)


    var_dump(sum("2", "5"));
    / /
    int(7)


    var_dump(sum(true, true));
    / /
    int(2)

    View Slide

  83. pode-se ativar o modo estrito para garantir
    que a conversão automática de tipos não
    seja realizada

    View Slide

  84. e, caso o valor tenha um tipo incompatível
    com o tipo esperado, a exceção TypeError
    será lançada

    View Slide

  85. / /
    using strict types


    declare(strict_types=1);


    / /
    throws an exception when a value


    / /
    with incompatible type are provided


    function sum(int $a, int $b) {


    return $a + $b;


    }


    var_dump(sum(1, 2));
    / /
    int(3)

    var_dump(sum(1.5, 2.5)); Uncaught TypeError: Argument 1


    passed to sum() must be of the type integer, float given

    View Slide

  86. o modo estrito funciona da mesma forma
    para declarações de tipos de retorno

    View Slide

  87. / /
    the value returned is converted


    / /
    to the correct type


    function sum($a, $b)
    :
    int {


    return $a + $b;


    }


    var_dump(sum(1, 2));
    / /
    int(3)


    var_dump(sum(1.7, 2.5));
    / /
    int(4)


    var_dump(sum(true, true));
    / /
    int(2)

    View Slide

  88. declare(strict_types=1);


    / /
    a type exception is thrown


    function sum($a, $b)
    :
    int {


    return $a + $b;


    }


    var_dump(sum(1, 2));
    / /
    int(3)


    var_dump(sum(1.7, 2.5));
    / /
    Uncaught TypeError: sum()
    :

    Return value must be of type int, float returned

    View Slide

  89. Propriedades tipadas

    View Slide

  90. as typed properties ou propriedades
    tipadas foram adicionadas no PHP 7.4

    View Slide

  91. utilizavam-se docblocks e métodos getters e
    setters para a garantia de tipos

    View Slide

  92. / /
    code with unnecessary boilerplate to enforce type contracts


    class User {


    /** @var int $id
    * /

    private $id;


    /** @var string $name
    * /

    private $name;


    public function
    _ _
    construct(int $id, string $name) {


    $this
    - >
    id = $id;


    $this
    - >
    name = $name;


    }


    public function getId()
    :
    int {


    return $this
    - >
    id;


    }


    / /
    setId, getName and setName implementation
    . . .

    }

    View Slide

  93. / /
    more concise code with same type contracts


    class User {


    public int $id;


    public string $name;




    public function
    _ _
    construct(int $id, string $name) {


    $this
    - >
    id = $id;


    $this
    - >
    name = $name;


    }


    }

    View Slide

  94. as propriedades tipadas permitem a
    garantia de tipos em tempo de execução

    View Slide

  95. se uma propriedade tipada não tiver
    um valor padrão ela será considerada não
    inicializada

    View Slide

  96. / /
    uninitialized properties and


    / /
    default null (PHP 7.3)


    class User {


    public $id;


    public $name;


    }


    $user = new User;


    var_dump($user);


    / /
    class User#1 (2) {


    / /
    public $id
    = >
    NULL


    / /
    public $name
    = >
    NULL


    / /
    }

    View Slide

  97. / /
    uninitialized properties and no


    / /
    null default (PHP 7.4)


    class User {


    public int $id;
    / /
    no null default


    public ?string $name;
    / /
    also no null default


    }


    $user = new User;


    var_dump($user);


    / /
    object(User)#1 (0) {


    / /
    ["id"]
    = >
    uninitialized(int)


    / /
    ["name"]
    = >
    uninitialized(?string)


    / /
    }

    View Slide

  98. ao tentar fazer a leitura de uma propriedade
    não inicializada será lançado um erro do tipo
    TypeError

    View Slide

  99. / /
    try to access a uninitialized property


    class User {


    public int $id;


    public string $name;


    }


    $user = new User;


    echo $user
    - >
    id;


    / /
    Uncaught Error: Typed property User
    : :
    $id must

    / /
    not be accessed before initialization

    View Slide

  100. Nullable types

    View Slide

  101. um nullable type é um tipo que pode ser de
    um tipo especí
    fi
    co ou nulo e é representado
    por ?Type

    View Slide

  102. / /
    annotate email property with nullable string type


    class Person {


    function
    _ _
    construct(


    public string $name,


    public ?string $email,


    ) {}


    }


    $person1 = new Person('Alice', '[email protected]');


    $person2 = new Person('Bob', null);

    View Slide

  103. var_dump($person1);


    var_dump($person2);


    / /
    object(Person)#1 (2) {


    / /
    ["name"]
    = >
    string(5) "Alice"


    / /
    ["email"]
    = >
    string(17) "[email protected]"


    / /
    }


    / /
    object(Person)#2 (2) {


    / /
    ["name"]
    = >
    string(3) "Bob"


    / /
    ["email"]
    = >
    NULL


    / /
    }

    View Slide

  104. Union Types

    View Slide

  105. um union type permite fazer uma anotação
    de tipos com diferentes tipos

    View Slide

  106. o PHP já possui dois tipos especiais de union
    types: nullable types e iterable

    View Slide

  107. o tipo nullable possui a sintaxe ?Type e pode
    ser do tipo Type|null, isto é, Type ou null

    View Slide

  108. o tipo iterable pode ser do tipo array|
    Traversable, isto é, array ou Traversable

    View Slide

  109. declare(strict_types=1);


    / /
    using union type to annotate a function parameter


    function power(float|int $number, int $exponent)
    :
    int|float {


    return $number
    * *
    $exponent;


    }


    echo power(3, 2);
    / /
    9


    echo power(3.5, 2);
    / /
    12.25


    echo power('3', 2.5);
    / /
    Uncaught TypeError: power()
    :
    Argument #1


    ($number) must be of type int|float, string given

    View Slide

  110. os union types são muito utilizado em
    projetos open-source e funções internas do
    PHP

    View Slide

  111. o suporte nativo permite a garantia de tipos
    pelo interpretador PHP e reduz a necessida-
    de de docblocks

    View Slide

  112. Intersection Types

    View Slide

  113. um intersection type permite anotar o tipo
    de um valor que satisfaça múltiplas
    restrições de tipos ao mesmo tempo

    View Slide

  114. / /
    using intersection type to annotate a property of a test


    / /
    class that represents a mocked object


    class CreateUserTest


    {


    private MockObject&UserRepository $userRepositoryMock;


    }

    View Slide

  115. só é posível utilizar intersection types com
    classes e interfaces

    View Slide

  116. não é permitido combinar em uma declara-
    ção union types e intersection types

    View Slide

  117. Enums

    View Slide

  118. uma enum de
    fi
    ne um novo tipo que possui
    número
    fi
    xo e limitado de valores possíveis

    View Slide

  119. / /
    creates an enum for the suits of a deck


    enum Suit {


    case Hearts;


    case Diamonds;


    case Clubs;


    case Spades;


    }


    $value = Suit
    : :
    Hearts;


    var_dump($value);
    / /
    enum(Suit
    : :
    Hearts)

    View Slide

  120. por padrão, os casos enumerados não
    possuem equivalentes escalares, isto é, eles
    são objetos singleton

    View Slide

  121. esse tipo de valor é chamado de pure case e
    uma enum que contém apenas pure cases é
    chamada de pure enum

    View Slide

  122. uma função ou método podem ser tipados
    com o tipo enum

    View Slide

  123. / /
    annotate a function parameter with an enum type


    function pick_a_card(Suit $suit) {}


    pick_a_card($value);
    / /
    ok


    pick_a_card(Suit
    : :
    Clubs);
    / /
    ok


    pick_a_card('Spades');


    / /
    Fatal error: Uncaught TypeError: pick_a_card()
    :

    Argument #1 ($suit) must be of type Suit, string given

    View Slide

  124. contudo, existem casos de usos em que é
    necessário ter equivalentes escalares para,
    por exemplo, persistir em uma base de
    dados

    View Slide

  125. / /
    create an enum backed with scalar values


    enum Suit: string {


    case Hearts = 'H';


    case Diamonds = 'D';


    case Clubs = 'C';


    case Spades = 'S';


    }


    var_dump(Suit
    : :
    Hearts);
    / /
    enum(Suit
    : :
    Hearts)


    var_dump(Suit
    : :
    Hearts
    - >
    name);
    / /
    string(6) "Hearts"


    var_dump(Suit
    : :
    Hearts
    - >
    value);
    / /
    string(1) "H"

    View Slide

  126. um case que tem um equivalente escalar é
    chamado de backed case pois é “suportado"
    por um valor mais simples

    View Slide

  127. uma enum que contém backed cases é
    chamado de backed enum

    View Slide

  128. um backed enum implementa a interface
    interna BackedEnum que expõe dois métodos
    adicionais que são from e tryFrom

    View Slide

  129. o método from() recebe um tipo escalar e
    retorna o case correspondente e, caso o
    valor não seja encontrado, a exceção
    ValueError é lançada

    View Slide

  130. o método tryFrom() possui comportamento
    similar mas, caso o valor não seja encontra-
    do, retorna nulo

    View Slide

  131. / /
    create an order status enum


    enum OrderStatus: string {


    case PendingPayment = 'pending_payment';


    case Processing = 'processing';


    case Completed = 'completed';


    case Refunded = 'refunded';


    case Cancelled = 'cancelled';


    }

    View Slide

  132. /
    /
    create an enum value using from() method with a valid value


    $orderStatus = OrderStatus
    :
    :
    from('processing');


    var_dump($orderStatus);
    /
    /
    enum(OrderStatus
    :
    :
    Processing)


    echo $orderStatus
    -
    >
    value;
    /
    /
    processing


    /
    /
    try to create an enum value using from() method with an invalid value


    $orderStatus = OrderStatus
    :
    :
    from('non_existent');


    /
    /
    Fatal error: Uncaught ValueError: "non_existent" is not a


    /
    /
    valid backing value for enum "OrderStatus"


    /
    /
    try to create an enum value using tryFrom() method with an invalid value


    $orderStatus = OrderStatus
    :
    :
    tryFrom('non_existent');


    var_dump($orderStatus);
    /
    /
    null

    View Slide

  133. Type Never

    View Slide

  134. o tipo never é um novo tipo de retorno
    adicionado no PHP 8.1

    View Slide

  135. uma função ou método declarados com
    o tipo de retorno never indica que nunca
    retornará um valor…

    View Slide

  136. …isto é, sempre lançará uma exceção ou
    terminará com die() ou exit()

    View Slide

  137. / /
    creates a function with never return type


    function redirect(string $url)
    :
    never {


    echo "redirected to $url
    . . .
    \n";


    header('Location: ' . $url);


    exit();


    }


    redirect('https:
    / / w w w
    .example.com');


    / /
    redirected to https:
    / / w w w
    .example.com
    . . . 

    / /
    The rest of the code will not be executed!


    echo 'this will not be shown
    . . .
    ';

    View Slide

  138. o objetivo do tipo de retorno never é indicar
    uma função que previne que o resto do
    código chamado seja executado

    View Slide

  139. se uma função ou método com o tipo de
    retorno never não lançar uma exceção ou
    não terminar o programa será lançada
    a exceção TypeError

    View Slide

  140. / /
    create a function with never return type


    function dispatch(string $message)
    :
    never {


    echo $message;


    }


    dispatch('test');


    / /
    Uncaught TypeError: dispatch()
    :
    never
    -
    returning


    / /
    function must not implicitly return

    View Slide

  141. o suporte ao tipo de retorno never torna
    possível não utilizar mais a annotation
    @return noreturn

    View Slide

  142. Conclusão

    View Slide

  143. o PHP tem tido uma enorme evolução em
    relação a tipos e tem se tornado uma
    linguagem mais robusta

    View Slide

  144. porém, sem perder a
    fl
    exibilidade e a
    pequena curva de aprendizado que o torna
    uma linguagem tão democrática

    View Slide

  145. as novas funcionalidades ajudarão o seu
    código a ter mais garantias, ser mais
    expressivo e te dar mais poderes

    View Slide

  146. vá em frente e divirta-se!

    View Slide

  147. Avalie!

    View Slide

  148. @marcelgsantos
    speakerdeck.com/marcelgsantos
    Obrigado.
    Perguntas?

    View Slide