Fale sobre programação funcional e seus princípios…

A programação funcional (PF) é um paradigma de programação que considera os cálculos como a avaliação de funções matemáticas, evitando alterações de estado e dados mutáveis.

Princípios básicos:

Funções puras: Uma função é considerada pura se:

Sempre retorna o mesmo resultado para os mesmos argumentos.
Não tem efeitos colaterais (não altera o estado global, não realiza entrada/saída, etc.).

<?php
// Função pura
function add(int $a, int $b): int {
    return $a + $b;
}

// Função não pura (tem efeito colateral - altera uma variável global)
$count = 0;
function increment_and_get(): int {
    global $count;
    $count++;
    return $count;
}

Imutabilidade dos dados: Uma vez criados, os dados não podem ser modificados. Em vez de alterar um objeto existente, cria-se um novo com as modificações necessárias.

<?php
// Exemplo de imutabilidade (em PHP não é um princípio estrito da linguagem, mas pode ser implementado)
class ImmutablePoint {
    private int $x;
    private int $y;

    public function __construct(int $x, int $y) {
        $this->x = $x;
        $this->y = $y;
    }

    public function getX(): int {
        return $this->x;
    }

    public function getY(): int {
        return $this->y;
    }

    // Em vez de modificar, retorna um novo objeto
    public function move(int $dx, int $dy): self {
        return new self($this->x + $dx, $this->y + $dy);
    }
}

$p1 = new ImmutablePoint(1, 2);
$p2 = $p1->move(1, 1); // $p1 permanece em (1, 2), $p2 torna-se (2, 3)

Funções como objetos de primeira classe: Funções podem ser passadas como argumentos para outras funções, retornadas de funções, atribuídas a variáveis.

<?php
// Funções como variáveis
$greeter = function(string $name): string {
    return "Hello, " . $name;
};

echo $greeter("World"); // Saída: Hello, World

// Funções como argumentos
function apply_transform(array $data, callable $transform): array {
    $result = [];
    foreach ($data as $item) {
        $result[] = $transform($item);
    }
    return $result;
}

$numbers = [1, 2, 3];
$doubled_numbers = apply_transform($numbers, function(int $n): int {
    return $n * 2;
}); // $doubled_numbers = [2, 4, 6]

Ausência de efeitos colaterais: Os cálculos não afetam o estado do programa fora de seu escopo.
Declaratividade: Foca no o que precisa ser calculado, e não no como.

Vantagens:

Melhor testabilidade (funções puras são fáceis de testar).
Simplificação do paralelismo (a ausência de estado mutável reduz problemas de sincronização).
Melhor depuração.
Comportamento do código mais previsível.

Fale sobre programação funcional e seus princípios.