Online PHP editor | perf for g3OlH

<?php declare(strict_types=1); /** * ========================================================================== * SISTEMA BANCÁRIO FUNCIONAL COM IDEMPOTÊNCIA EM PHP MODERN * ========================================================================== * * Conceitos aplicados do Mapa Mental: * 1. Pure Functions * 2. Higher-Order Functions (array_reduce, array_walk) * 3. Immutability (Readonly DTOs) * 4. Function Composition * 5. Currying * 6. Lazy Evaluation with Generators (yield) * 7. Pattern Matching (match) */ /** * -------------------------------------------------------------------------- * 1. IMUTABILIDADE (Readonly DTOs) * -------------------------------------------------------------------------- * As estruturas de dados são imutáveis. Alterações geram novas instâncias. */ readonly class Conta { public function __construct( public string $id, public float $saldo ) {} } readonly class Transacao { public function __construct( public string $idempotencyKey, public string $tipo, // 'DEPOSITO' ou 'SAQUE' public float $valor, public string $contaId ) {} } /** * -------------------------------------------------------------------------- * 2. PURE FUNCTIONS (Funções Puras) * -------------------------------------------------------------------------- * Sem efeitos colaterais. Entrada idêntica = Nova saída idêntica. */ function depositar(Conta $conta, float $valor): Conta { return new Conta($conta->id, $conta->saldo + $valor); } function sacar(Conta $conta, float $valor): Conta { if ($valor > $conta->saldo) { throw new InvalidArgumentException("Saldo insuficiente na conta {$conta->id}!"); } return new Conta($conta->id, $conta->saldo - $valor); } /** * -------------------------------------------------------------------------- * 3. PATTERN MATCHING (PHP 8 `match`) * -------------------------------------------------------------------------- * Avaliação declarativa de tipos de operação. */ function aplicarTransacao(Conta $conta, Transacao $tx): Conta { return match ($tx->tipo) { 'DEPOSITO' => depositar($conta, $tx->valor), 'SAQUE' => sacar($conta, $tx->valor), default => throw new InvalidArgumentException("Tipo de transação desconhecido: {$tx->tipo}") }; } /** * -------------------------------------------------------------------------- * 4. CURRYING * -------------------------------------------------------------------------- * Decompõe funções de múltiplos argumentos para pré-configuração. */ function criarValidadorValorMinimo(float $valorMinimo): callable { return fn(float $valor) => fn(callable $operacao) => $valor < $valorMinimo ? throw new InvalidArgumentException("Valor mínimo deve ser R$ {$valorMinimo}") : $operacao(); } /** * -------------------------------------------------------------------------- * 5. FUNCTION COMPOSITION (Composição de Funções) * -------------------------------------------------------------------------- * Pipeline de execução encadeando funções puras. */ function compor(callable ...$funcoes): callable { return fn($input) => array_reduce( $funcoes, fn($acc, $fn) => $fn($acc), $input ); } /** * -------------------------------------------------------------------------- * 6. HIGHER-ORDER FUNCTIONS & IDEMPOTÊNCIA (`array_reduce`) * -------------------------------------------------------------------------- * Substitui o loop foreach imperativo por uma redução funcional que * acumula imutavelmente o estado de contas e chaves processadas. */ function processarComIdempotencia(array $contasIniciais, iterable $transacoes): array { $listaTransacoes = is_array($transacoes) ? $transacoes : iterator_to_array($transacoes); $estadoInicial = [ 'contas' => $contasIniciais, 'chaves' => [] ]; $estadoFinal = array_reduce( $listaTransacoes, function (array $estado, Transacao $tx): array { // Garantia de Idempotência if (in_array($tx->idempotencyKey, $estado['chaves'], true)) { echo "⚠️ [IDEMPOTÊNCIA] Transação {$tx->idempotencyKey} ignorada (já processada).\n"; return $estado; } $contaAtual = $estado['contas'][$tx->contaId] ?? new Conta($tx->contaId, 0.0); $novaConta = aplicarTransacao($contaAtual, $tx); echo "✅ Transação {$tx->tipo} de R$ {$tx->valor} na conta {$tx->contaId} concluída. Saldo atual: R$ {$novaConta->saldo}\n"; return [ 'contas' => array_merge($estado['contas'], [$tx->contaId => $novaConta]), 'chaves' => array_merge($estado['chaves'], [$tx->idempotencyKey]) ]; }, $estadoInicial ); return $estadoFinal['contas']; } /** * -------------------------------------------------------------------------- * 7. LAZY EVALUATION WITH GENERATORS (`yield`) * -------------------------------------------------------------------------- * Stream de transações consumido sob demanda com baixa pegada de memória. */ function gerarStreamTransacoes(): Generator { yield new Transacao('tx_key_001', 'DEPOSITO', 500.0, 'conta_A'); yield new Transacao('tx_key_002', 'SAQUE', 150.0, 'conta_A'); yield new Transacao('tx_key_001', 'DEPOSITO', 500.0, 'conta_A'); // Duplicada (Ignorada) yield new Transacao('tx_key_003', 'DEPOSITO', 1000.0, 'conta_B'); yield new Transacao('tx_key_002', 'SAQUE', 150.0, 'conta_A'); // Duplicada (Ignorada) } // ========================================================================== // EXECUÇÃO DO SCRIPT // ========================================================================== echo "=== INICIANDO SISTEMA BANCÁRIO FUNCIONAL ===\n\n"; // Estado inicial $contas = [ 'conta_A' => new Conta('conta_A', 0.0), 'conta_B' => new Conta('conta_B', 100.0), ]; // Teste de Currying + Composition $validarMinimo10 = criarValidadorValorMinimo(10.0); try { echo "--- Teste de Validação (Currying + Composition) ---\n"; $depositoValidado = $validarMinimo10(50.0)( fn() => depositar($contas['conta_A'], 50.0) ); echo "Depósito de R$ 50 validado! Novo saldo simulado da conta_A: R$ {$depositoValidado->saldo}\n\n"; } catch (Exception $e) { echo "Erro: " . $e->getMessage() . "\n\n"; } // Processamento funcional com Idempotência echo "--- Processando Stream com array_reduce (Idempotência & Generators) ---\n"; $contasFinais = processarComIdempotencia($contas, gerarStreamTransacoes()); // Exibição funcional declarativa usando a função nativa array_walk echo "\n--- SALDO FINAL DAS CONTAS ---\n"; array_walk($contasFinais, function (Conta $conta) { echo "Conta: {$conta->id} | Saldo Final: R$ {$conta->saldo}\n"; });

Version	System time (s)	User time (s)	Memory (MiB)
8.5.9	0.020	0.006	16.85
8.5.8	0.022	0.007	16.59
8.5.7	0.030	0.009	16.90
8.5.6	0.026	0.004	16.71
8.5.5	0.025	0.007	16.64
8.5.4	0.020	0.006	16.29
8.5.3	0.016	0.006	16.79
8.5.2	0.013	0.006	16.72
8.5.1	0.015	0.009	16.51
8.5.0	0.005	0.007	16.63
8.4.24	0.004	0.007	19.71
8.4.23	0.016	0.005	19.33
8.4.22	0.024	0.010	19.49
8.4.21	0.022	0.008	19.32
8.4.20	0.021	0.009	19.59
8.4.19	0.019	0.005	19.59
8.4.18	0.019	0.008	19.38
8.4.17	0.015	0.007	19.52
8.4.16	0.013	0.008	19.60
8.4.15	0.014	0.005	19.65
8.4.14	0.010	0.010	17.70
8.4.13	0.016	0.006	17.71
8.4.12	0.017	0.006	17.85
8.4.11	0.023	0.010	17.54
8.4.10	0.018	0.007	17.80
8.4.9	0.016	0.011	17.88
8.4.8	0.024	0.011	17.77
8.4.7	0.016	0.006	17.73
8.4.6	0.018	0.006	17.81
8.4.5	0.024	0.003	17.59
8.4.4	0.018	0.006	17.57
8.4.3	0.017	0.005	17.59
8.4.2	0.021	0.003	17.50
8.4.1	0.014	0.006	17.73
8.3.33	0.014	0.006	18.35
8.3.32	0.017	0.003	18.21
8.3.31	0.014	0.005	18.52
8.3.30	0.011	0.007	18.46
8.3.29	0.013	0.004	18.46
8.3.28	0.012	0.007	18.49
8.3.27	0.018	0.002	16.86
8.3.26	0.017	0.004	16.81
8.3.25	0.013	0.006	16.80
8.3.24	0.019	0.005	16.92
8.3.23	0.016	0.003	16.77
8.3.22	0.015	0.005	16.55
8.3.21	0.014	0.005	16.68
8.3.20	0.019	0.003	16.75
8.3.19	0.018	0.004	16.70
8.3.18	0.023	0.005	16.64
8.3.17	0.030	0.007	16.65
8.3.16	0.018	0.002	16.77
8.3.15	0.012	0.006	16.55
8.3.14	0.017	0.003	16.62
8.3.13	0.013	0.004	16.56
8.3.12	0.015	0.004	16.55
8.3.11	0.016	0.002	16.54
8.3.10	0.019	0.004	16.69
8.3.9	0.017	0.005	16.67
8.3.8	0.016	0.005	16.88
8.3.7	0.015	0.005	16.46
8.3.6	0.016	0.005	16.53
8.3.5	0.015	0.007	16.45
8.3.4	0.013	0.007	17.73
8.3.3	0.015	0.002	17.88
8.3.2	0.012	0.005	17.95
8.3.1	0.012	0.006	17.91
8.3.0	0.019	0.005	17.98
8.2.33	0.012	0.006	18.06
8.2.32	0.020	0.004	17.80
8.2.31	0.013	0.005	17.98