Vertel over functioneel programmeren en de principes…

Functionele programmeren (FP) is een programmeerparadigma dat berekeningen beschouwt als de evaluatie van wiskundige functies, waarbij het veranderen van toestand en mutable gegevens wordt vermeden.

Belangrijkste principes:

Pure functies: Een functie wordt als puur beschouwd als:

Het altijd hetzelfde resultaat oplevert voor dezelfde argumenten.
Het geen bijwerkingen heeft (wijzigt geen globale toestand, voert geen invoer/uitvoer uit, etc.).

<?php
// Pure functie
function add(int $a, int $b): int {
    return $a + $b;
}

// Onzuivere functie (heeft bijwerking - wijzigt een globale variabele)
$count = 0;
function increment_and_get(): int {
    global $count;
    $count++;
    return $count;
}

Onveranderlijkheid van gegevens: Na creatie kunnen gegevens niet worden gewijzigd. In plaats van een bestaand object te wijzigen, wordt een nieuw object gemaakt met de benodigde wijzigingen.

<?php
// Voorbeeld van onveranderlijkheid (in PHP is dit geen strikt principe, maar het kan worden geïmplementeerd)
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;
    }

    // In plaats van te wijzigen, geeft het een nieuw object
    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 blijft (1, 2), $p2 wordt (2, 3)

Functies als first-class objecten: Functies kunnen worden doorgegeven als argumenten aan andere functies, worden geretourneerd uit functies, en worden aan variabelen toegewezen.

<?php
// Functies als variabelen
$greeter = function(string $name): string {
    return "Hello, " . $name;
};

echo $greeter("World"); // Output: Hello, World

// Functies als argumenten
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]

Afwezigheid van bijwerkingen: Berekeningen beïnvloeden de toestand van het programma niet buiten hun scope.
Declaratief: Richt zich op wat moet worden berekend, niet op hoe.

Voordelen:

Verbeterde testbaarheid (puur functies zijn gemakkelijk te testen).
Vereenvoudiging van parallelisme (het ontbreken van mutable toestand vermindert synchronisatieproblemen).
Betere debugging.
Meer voorspelbaar gedrag van de code.

Vertel over functioneel programmeren en de principes ervan.