// Função IMPURA - tem efeitos colaterais
let contadorGlobal = 0;

function funcaoImpura(valor) {
    contadorGlobal++; // Efeito colateral: modifica variável externa
    console.log('Processando:', valor); // Efeito colateral: E/S
    return valor + contadorGlobal; // Resultado depende do estado externo
}

// Função PURA - sem efeitos colaterais
function funcaoPura(valor, incremento) {
    return valor + incremento;
}

// Testando a previsibilidade
console.log(funcaoPura(5, 2)); // Sempre 7
console.log(funcaoPura(5, 2)); // Sempre 7
console.log(funcaoPura(5, 2)); // Sempre 7

// Exemplo prático: funções puras vs impuras
const dadosExternos = [
    { id: 1, nome: 'João', idade: 30 },
    { id: 2, nome: 'Maria', idade: 25 }
];

// Função IMPURA - modifica o array original
function adicionarIdadeImpura(array) {
    for (let i = 0; i < array.length; i++) {
        array[i].idade += 1; // Modifica o objeto original
    }
    return array;
}

// Função PURA - não modifica os dados originais
function adicionarIdadePura(array) {
    return array.map(pessoa => ({
        ...pessoa,
        idade: pessoa.idade + 1
    }));
}

// Testando imutabilidade
const dadosOriginais = [...dadosExternos]; // Cópia
console.log('Antes:', dadosExternos[0].idade); // 30
const dadosAtualizados = adicionarIdadePura(dadosExternos);
console.log('Depois:', dadosExternos[0].idade); // Ainda 30
console.log('Novos dados:', dadosAtualizados[0].idade); // 31

// Funções que encapsulam efeitos colaterais
function criarLogger() {
    const logs = [];
    
    return {
        log: function(mensagem) {
            const timestamp = new Date().toISOString();
            const logEntry = `${timestamp}: ${mensagem}`;
            logs.push(logEntry);
            
            // Efeito colateral: impressão no console
            console.log(logEntry);
            
            return logEntry;
        },
        
        getLogs: function() {
            return [...logs]; // Retorna cópia para manter imutabilidade
        }
    };
}

const logger = criarLogger();
logger.log('Aplicação iniciada');

// Evitando mutações acidentais com Object.freeze (limitado)
function criarObjetoImutavel(objeto) {
    Object.keys(objeto).forEach(key => {
        if (typeof objeto[key] === 'object' && objeto[key] !== null) {
            objeto[key] = criarObjetoImutavel(objeto[key]);
        }
    });
    return Object.freeze(objeto);
}

// Exemplo de função com dependências injetadas (melhora testabilidade)
function processarPedidos(pedidos, servicoCalculoImpostos, servicoEnvioEmail) {
    return pedidos.map(pedido => ({
        ...pedido,
        imposto: servicoCalculoImpostos.calcular(pedido.valor),
        status: 'processado'
    }));
}

// Simulação de serviços
const servicoCalculoImpostos = {
    calcular: function(valor) { return valor * 0.1; }
};

const pedidos = [
    { id: 1, valor: 100 },
    { id: 2, valor: 200 }
];

const pedidosProcessados = processarPedidos(pedidos, servicoCalculoImpostos, null);
console.log(pedidosProcessados);

// Cópia rasa vs cópia profunda
const objetoOriginal = {
    nome: 'Teste',
    endereco: {
        rua: 'Avenida Principal',
        numero: 123
    },
    hobbies: ['ler', 'correr']
};

// Cópia rasa (cuidado com mutações aninhadas!)
const copiaRasa = { ...objetoOriginal };
copiaRasa.nome = 'Atualizado'; // Isso é seguro
copiaRasa.endereco.rua = 'Rua Secundária'; // Isso altera o original!

console.log(objetoOriginal.endereco.rua); // 'Rua Secundária' (problema!)

// Cópia profunda manual
function copiaProfunda(obj) {
    if (obj === null || typeof obj !== 'object') return obj;
    if (obj instanceof Date) return new Date(obj);
    if (obj instanceof Array) return obj.map(item => copiaProfunda(item));
    if (typeof obj === 'object') {
        const copia = {};
        for (let key in obj) {
            if (obj.hasOwnProperty(key)) {
                copia[key] = copiaProfunda(obj[key]);
            }
        }
        return copia;
    }
}

const copiaSegura = copiaProfunda(objetoOriginal);
copiaSegura.endereco.rua = 'Rua Segura';
console.log(objetoOriginal.endereco.rua); // Ainda 'Avenida Principal'

// Imutabilidade com arrays
const numeros = [1, 2, 3, 4, 5];

// Mutações diretas (NÃO funcional)
// numeros.push(6); // Muta o array original
// numeros[0] = 10; // Muta o array original

// Operações funcionais (seguras)
const numerosComNovo = [...numeros, 6]; // Adiciona elemento
const numerosDobrados = numeros.map(n => n * 2); // Transforma
const numerosPares = numeros.filter(n => n % 2 === 0); // Filtra
const somaTotal = numeros.reduce((acc, n) => acc + n, 0); // Reduz

console.log('Original:', numeros); // [1, 2, 3, 4, 5]
console.log('Com novo:', numerosComNovo); // [1, 2, 3, 4, 5, 6]
console.log('Dobrados:', numerosDobrados); // [2, 4, 6, 8, 10]

// Trabalhando com objetos complexos de forma imutável
const estadoInicial = {
    usuario: {
        perfil: {
            nome: 'João',
            dadosPessoais: {
                idade: 30,
                endereco: { cidade: 'São Paulo', pais: 'Brasil' }
            }
        },
        preferencias: {
            tema: 'escuro',
            notificacoes: true
        }
    },
    aplicacao: {
        carregado: true,
        modo: 'prod'
    }
};

// Função para atualizar nome (maneira funcional)
function atualizarNome(estado, novoNome) {
    return {
        ...estado,
        usuario: {
            ...estado.usuario,
            perfil: {
                ...estado.usuario.perfil,
                nome: novoNome
            }
        }
    };
}

// Função para atualizar cidade (maneira funcional)
function atualizarCidade(estado, novaCidade) {
    return {
        ...estado,
        usuario: {
            ...estado.usuario,
            perfil: {
                ...estado.usuario.perfil,
                dadosPessoais: {
                    ...estado.usuario.perfil.dadosPessoais,
                    endereco: {
                        ...estado.usuario.perfil.dadosPessoais.endereco,
                        cidade: novaCidade
                    }
                }
            }
        }
    };
}

// Utilização
const estadoAtualizado = atualizarNome(estadoInicial, 'João Silva');
const estadoComCidade = atualizarCidade(estadoAtualizado, 'Rio de Janeiro');

// Criando utilitários para atualizações imutáveis
function atualizarPropriedade(objeto, caminho, novoValor) {
    const partes = caminho.split('.');
    const copia = { ...objeto };
    
    function atualizarRecursivo(alvo, partesRestantes, valor) {
        if (partesRestantes.length === 1) {
            return {
                ...alvo,
                [partesRestantes[0]]: valor
            };
        } else {
            const [primeiraParte, ...restoPartes] = partesRestantes;
            return {
                ...alvo,
                [primeiraParte]: atualizarRecursivo(
                    { ...alvo[primeiraParte] },
                    restoPartes,
                    valor
                )
            };
        }
    }
    
    return atualizarRecursivo(copia, partes, novoValor);
}

// Exemplo de uso
const estadoModificado = atualizarPropriedade(
    estadoInicial,
    'usuario.perfil.dadosPessoais.endereco.pais',
    'Portugal'
);

// Utilizando Object.freeze para proteção adicional (limitação: não é profundo automaticamente)
function criarObjetoCongelado(obj) {
    Object.keys(obj).forEach(key => {
        if (typeof obj[key] === 'object' && obj[key] !== null && !Object.isFrozen(obj[key])) {
            obj[key] = criarObjetoCongelado(obj[key]);
        }
    });
    return Object.freeze(obj);
}

const objetoCongelado = criarObjetoCongelado({
    dados: { valor: 100 },
    status: 'ativo'
});

// objetoCongelado.dados.valor = 200; // Isso falhará em strict mode

// Imutabilidade com arrays e objetos aninhados
function adicionarItemAoCarrinho(carrinho, novoItem) {
    return {
        ...carrinho,
        itens: [
            ...carrinho.itens,
            { ...novoItem, id: Date.now() } // Novo ID para o item
        ],
        total: carrinho.total + novoItem.preco
    };
}

function removerItemDoCarrinho(carrinho, itemId) {
    return {
        ...carrinho,
        itens: carrinho.itens.filter(item => item.id !== itemId),
        total: carrinho.itens
            .filter(item => item.id !== itemId)
            .reduce((total, item) => total + item.preco, 0)
    };
}

function atualizarQuantidade(carrinho, itemId, novaQuantidade) {
    return {
        ...carrinho,
        itens: carrinho.itens.map(item =>
            item.id === itemId ? { ...item, quantidade: novaQuantidade } : item
        )
    };
}

// Exemplo completo de carrinho de compras imutável
const carrinhoInicial = {
    itens: [],
    total: 0,
    usuarioId: 123
};

const carrinhoComItem = adicionarItemAoCarrinho(carrinhoInicial, {
    nome: 'Camiseta',
    preco: 29.90,
    quantidade: 2
});

console.log('Carrinho com item:', carrinhoComItem);

// Funções de ordem superior básicas
function aplicarOperacao(array, operacao) {
    return array.map(operacao);
}

// Funções de transformação
const numeros = [1, 2, 3, 4, 5];
const numerosAoQuadrado = aplicarOperacao(numeros, n => n * n);
const numerosDobrados = aplicarOperacao(numeros, n => n * 2);

console.log('Quadrados:', numerosAoQuadrado); // [1, 4, 9, 16, 25]
console.log('Dobrados:', numerosDobrados);   // [2, 4, 6, 8, 10]

// Funções que retornam outras funções (closures)
function criarMultiplicador(multiplicador) {
    return function(numero) {
        return numero * multiplicador;
    };
}

const dobrador = criarMultiplicador(2);
const triplicador = criarMultiplicador(3);
const quadriplicador = criarMultiplicador(4);

console.log(dobrador(5));      // 10
console.log(triplicador(5));   // 15
console.log(quadriplicador(5)); // 20

// Validação reutilizável com funções de ordem superior
function criarValidador(regra, mensagemErro) {
    return function(valor) {
        if (!regra(valor)) {
            throw new Error(mensagemErro);
        }
        return true;
    };
}

const validarEmail = criarValidador(
    valor => typeof valor === 'string' && valor.includes('@'),
    'Email inválido: deve conter @'
);

const validarIdade = criarValidador(
    valor => typeof valor === 'number' && valor >= 0 && valor <= 150,
    'Idade inválida: deve ser um número entre 0 e 150'
);

// Exemplo de uso
try {
    validarEmail('usuario@exemplo.com');
    console.log('Email válido');
    
    validarIdade(25);
    console.log('Idade válida');
} catch (erro) {
    console.error(erro.message);
}

// Funções utilitárias reutilizáveis
const operacoes = {
    somar: (a, b) => a + b,
    subtrair: (a, b) => a - b,
    multiplicar: (a, b) => a * b,
    dividir: (a, b) => b !== 0 ? a / b : null
};

function criarCalculadora(operacao) {
    return function(a, b) {
        return operacoes[operacao](a, b);
    };
}

const calculadoraSoma = criarCalculadora('somar');
const calculadoraDivisao = criarCalculadora('dividir');

console.log(calculadoraSoma(10, 5));     // 15
console.log(calculadoraDivisao(10, 2));  // 5

// Composição de funções
function composicao(...funcoes) {
    return function(valor) {
        return funcoes.reduceRight((acumulado, fn) => fn(acumulado), valor);
    };
}

// Funções para compor
const paraMaiusculas = str => str.toUpperCase();
const adicionarPrefixo = str => `Olá, ${str}`;
const adicionarSufixo = str => `${str}!`;

// Compor funções
const saudacaoCompleta = composicao(
    adicionarSufixo,
    paraMaiusculas,
    adicionarPrefixo
);

console.log(saudacaoCompleta('mundo')); // "OLÁ, MUNDO!"

// Utilizando o operador pipeline (propriedade experimental, simulado aqui)
function pipe(valor, ...funcoes) {
    return funcoes.reduce((acumulado, fn) => fn(acumulado), valor);
}

const resultado = pipe(
    '  mundo  ',
    str => str.trim(),
    str => str.toLowerCase(),
    str => `olá, ${str}`,
    str => str.toUpperCase()
);

console.log(resultado); // "OLÁ, MUNDO"

// Funções utilitárias avançadas
function memoizar(funcao) {
    const cache = new Map();
    
    return function(...args) {
        const chave = JSON.stringify(args);
        
        if (cache.has(chave)) {
            console.log('Retornando do cache');
            return cache.get(chave);
        }
        
        const resultado = funcao.apply(this, args);
        cache.set(chave, resultado);
        return resultado;
    };
}

// Função cara para testar memoização
const fibonacci = memoizar(function(n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
});

console.log(fibonacci(10)); // Calculado
console.log(fibonacci(10)); // Do cache

// Funções utilitárias para manipulação de listas
function criarFiltroPersonalizado(condicao) {
    return function(array) {
        return array.filter(condicao);
    };
}

const apenasPares = criarFiltroPersonalizado(n => n % 2 === 0);
const apenasStrings = criarFiltroPersonalizado(item => typeof item === 'string');
const apenasMaioresQue = limite => criarFiltroPersonalizado(n => n > limite);

console.log(apenasPares([1, 2, 3, 4, 5, 6])); // [2, 4, 6]
console.log(apenasStrings([1, 'a', 2, 'b', true])); // ['a', 'b']
console.log(apenasMaioresQue(3)([1, 2, 3, 4, 5])); // [4, 5]

// Funções utilitárias para validação complexa
function criarValidadorComposta(...validadores) {
    return function(valor) {
        const erros = [];
        
        for (const validador of validadores) {
            try {
                validador(valor);
            } catch (erro) {
                erros.push(erro.message);
            }
        }
        
        if (erros.length > 0) {
            throw new Error(`Validações falharam: ${erros.join(', ')}`);
        }
        
        return true;
    };
}

const validarNomeCompleto = criarValidadorComposta(
    criarValidador(
        nome => typeof nome === 'string' && nome.length > 0,
        'Nome deve ser uma string não vazia'
    ),
    criarValidador(
        nome => nome.length >= 2,
        'Nome deve ter pelo menos 2 caracteres'
    ),
    criarValidador(
        nome => !nome.includes('123'),
        'Nome não pode conter "123"'
    )
);

try {
    validarNomeCompleto('João Silva');
    console.log('Nome válido');
} catch (erro) {
    console.error(erro.message);
}

// Criando um sistema de middleware funcional
function criarPipeline(...middlewares) {
    return function(valor) {
        return middlewares.reduce((acc, middleware) => middleware(acc), valor);
    };
}

const pipelineAutenticacao = criarPipeline(
    (req) => ({ ...req, autenticado: true }),
    (req) => ({ ...req, permissao: 'leitura' }),
    (req) => ({ ...req, timestamp: Date.now() })
);

const requisicao = { id: 1, dados: 'sensíveis' };
const requisicaoProcessada = pipelineAutenticacao(requisicao);
console.log(requisicaoProcessada);

// Utilizando funções de ordem superior para criar DSLs (Domain Specific Languages)
function criarQuery(campos) {
    const estado = { campos, where: [], orderBy: [] };
    
    return {
        where: function(condicao) {
            estado.where.push(condicao);
            return this;
        },
        orderBy: function(campo, direcao = 'ASC') {
            estado.orderBy.push({ campo, direcao });
            return this;
        },
        exec: function(dados) {
            let resultado = [...dados];
            
            // Aplicar where
            for (const condicao of estado.where) {
                resultado = resultado.filter(condicao);
            }
            
            // Aplicar orderBy
            for (const { campo, direcao } of estado.orderBy) {
                resultado.sort((a, b) => {
                    if (a[campo] < b[campo]) return direcao === 'ASC' ? -1 : 1;
                    if (a[campo] > b[campo]) return direcao === 'ASC' ? 1 : -1;
                    return 0;
                });
            }
            
            return resultado;
        }
    };
}

// Exemplo de uso da DSL
const usuarios = [
    { nome: 'Ana', idade: 25, cidade: 'São Paulo' },
    { nome: 'Pedro', idade: 30, cidade: 'Rio de Janeiro' },
    { nome: 'Maria', idade: 22, cidade: 'São Paulo' }
];

const resultadoQuery = criarQuery(['nome', 'idade'])
    .where(u => u.idade >= 25)
    .orderBy('idade', 'DESC')
    .exec(usuarios);

console.log(resultadoQuery);

// Implementação básica de currying
function curry(funcao) {
    return function curried(...args) {
        if (args.length >= funcao.length) {
            return funcao.apply(this, args);
        } else {
            return function(...argsMais) {
                return curried.apply(this, args.concat(argsMais));
            };
        }
    };
}

// Função original
function somar(a, b, c) {
    return a + b + c;
}

// Função curryficada
const somarCurry = curry(somar);

console.log(somarCurry(1)(2)(3)); // 6
console.log(somarCurry(1, 2)(3)); // 6
console.log(somarCurry(1)(2, 3)); // 6

// Exemplos práticos de currying
const formataMoeda = curry((moeda, valor) => `${moeda} ${valor.toFixed(2)}`);
const formataReal = formataMoeda('R$');
const formataDolar = formataMoeda('US$');

console.log(formataReal(123.45)); // "R$ 123.45"
console.log(formataDolar(123.45)); // "US$ 123.45"

const aplicarDesconto = curry((desconto, preco) => preco * (1 - desconto));
const desconto10 = aplicarDesconto(0.10);
const desconto20 = aplicarDesconto(0.20);

const precos = [100, 200, 300];
const precosCom10 = precos.map(desconto10);
const precosCom20 = precos.map(desconto20);

console.log('10% desconto:', precosCom10); // [90, 180, 270]
console.log('20% desconto:', precosCom20); // [80, 160, 240]

// Composição de funções
const compor = (...funcoes) => valor => funcoes.reduceRight((acc, fn) => fn(acc), valor);

// Funções para compor
const paraMaiusculas = str => str.toUpperCase();
const removerEspacos = str => str.replace(/\s+/g, '');
const adicionarPrefixo = prefixo => str => `${prefixo}${str}`;
const adicionarSufixo = sufixo => str => `${str}${sufixo}`;

// Compor funções para processamento de texto
const processarTexto = compor(
    adicionarSufixo('!'),
    paraMaiusculas,
    removerEspacos,
    adicionarPrefixo('>>')
);

console.log(processarTexto('  olá mundo  ')); // ">>OLÁMUNDO!"

// Composição com curry para funções mais flexíveis
const substituir = curry((padrao, substituto, str) => str.replace(padrao, substituto));
const removerAcentos = substituir(/[áàâãä]/g, 'a');
const substituirEspacosPorUnderscore = substituir(/\s+/g, '_');

const normalizarTexto = compor(
    substituirEspacosPorUnderscore,
    removerAcentos,
    paraMaiusculas
);

console.log(normalizarTexto('Olá, mundo brasileiro!')); // "OLÁ,_MUNDO_BRASILEIRO!"

// Funções utilitárias para operações matemáticas
const adicionar = curry((a, b) => a + b);
const multiplicar = curry((a, b) => a * b);
const dividir = curry((a, b) => b !== 0 ? a / b : null);
const aplicarImposto = curry((taxa, valor) => valor * (1 + taxa));

// Composição para cálculos financeiros
const calcularPrecoFinal = compor(
    aplicarImposto(0.1), // 10% de imposto
    adicionar(5)         // frete de R$5
);

const precosIniciais = [100, 200, 300];
const precosFinais = precosIniciais.map(calcularPrecoFinal);
console.log('Preços finais:', precosFinais);

// Currying com validações
const validarCampo = curry((regra, nomeCampo, valor) => {
    if (!regra(valor)) {
        throw new Error(`Campo ${nomeCampo} inválido`);
    }
    return valor;
});

const validarEmailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
const validarEmail = validarCampo(
    valor => typeof valor === 'string' && validarEmailRegex.test(valor),
    'email'
);

const validarIdade = validarCampo(
    valor => typeof valor === 'number' && valor >= 0 && valor <= 150,
    'idade'
);

// Funções utilitárias para listas com currying
const mapear = curry((funcao, array) => array.map(funcao));
const filtrar = curry((predicado, array) => array.filter(predicado));
const reduzir = curry((funcao, inicial, array) => array.reduce(funcao, inicial));

// Exemplo prático: processamento de dados de usuários
const usuarios = [
    { nome: 'Ana Silva', idade: 28, ativo: true, pontos: 150 },
    { nome: 'Pedro Santos', idade: 35, ativo: false, pontos: 200 },
    { nome: 'Maria Oliveira', idade: 22, ativo: true, pontos: 80 }
];

const extrairNomes = mapear(usuario => usuario.nome);
const filtrarAtivos = filtrar(usuario => usuario.ativo);
const somarPontos = reduzir((total, usuario) => total + usuario.pontos, 0);

const nomes = extrairNomes(usuarios);
const usuariosAtivos = filtrarAtivos(usuarios);
const totalPontos = somarPontos(usuarios);

console.log('Nomes:', nomes);
console.log('Ativos:', usuariosAtivos.map(u => u.nome));
console.log('Total de pontos:', totalPontos);

// Composição para transformação de dados
const processarUsuarios = compor(
    mapear(u => ({ ...u, nomeMaiusculo: u.nome.toUpperCase() })),
    filtrar(u => u.ativo),
    mapear(u => ({ ...u, pontosBonus: u.pontos * 1.1 }))
);

const usuariosProcessados = processarUsuarios(usuarios);
console.log('Usuários processados:', usuariosProcessados);

// Função para criar funções especializadas com currying
const criarFiltro = curry((propriedade, operador, valor, objeto) => {
    const valorProp = objeto[propriedade];
    
    switch (operador) {
        case 'gt': return valorProp > valor;
        case 'lt': return valorProp < valor;
        case 'eq': return valorProp === valor;
        case 'contains': return String(valorProp).includes(String(valor));
        default: return false;
    }
});

const filtrarPorIdadeMaior = criarFiltro('idade', 'gt');
const filtrarPorNomeContem = criarFiltro('nome', 'contains');

const jovens = usuarios.filter(filtrarPorIdadeMaior(25));
const comSilva = usuarios.filter(filtrarPorNomeContem('Silva'));

console.log('Jovens (mais de 25):', jovens.map(u => u.nome));
console.log('Contém Silva:', comSilva.map(u => u.nome));

// Currying para funções de ordenação
const ordenarPor = curry((propriedade, direcao, array) => {
    return [...array].sort((a, b) => {
        if (a[propriedade] < b[propriedade]) return direcao === 'asc' ? -1 : 1;
        if (a[propriedade] > b[propriedade]) return direcao === 'asc' ? 1 : -1;
        return 0;
    });
});

const ordenarPorIdadeAsc = ordenarPor('idade', 'asc');
const ordenarPorNomeDesc = ordenarPor('nome', 'desc');

console.log('Ordenado por idade:', ordenarPorIdadeAsc(usuarios).map(u => u.nome));
console.log('Ordenado por nome desc:', ordenarPorNomeDesc(usuarios).map(u => u.nome));

// Composição para pipeline de transformações
const pipelineTransformacao = compor(
    filtrar(usuario => usuario.pontos > 100),           // Filtrar usuários com mais de 100 pontos
    ordenarPor('pontos', 'desc'),                       // Ordenar por pontos (desc)
    mapear(usuario => ({                               // Transformar para dados resumidos
        nome: usuario.nome.split(' ')[0],
        nivel: usuario.pontos > 150 ? 'ouro' : 'prata',
        pontos: usuario.pontos
    })),
    mapear(usuario => ({                               // Adicionar status VIP
        ...usuario,
        status: usuario.nivel === 'ouro' ? 'VIP' : 'Regular'
    }))
);

const resultadoPipeline = pipelineTransformacao(usuarios);
console.log('Resultado do pipeline:', resultadoPipeline);

// Implementação básica de transducers
const TRANSFORMADOR = {
    init: () => [],
    result: (acc) => acc
};

// Função para criar um transformador de mapeamento
const map = transformador => funcao => (acc, entrada) => 
    transformador(acc, funcao(entrada));

// Função para criar um transformador de filtro
const filter = transformador => predicado => (acc, entrada) => 
    predicado(entrada) ? transformador(acc, entrada) : acc;

// Função para compor transformadores
const comporTransformadores = (...transformadores) => 
    transformadores.reduce((acc, curr) => curr(acc));

// Função para transformar um array com transducers
const transformarArray = (array, ...transducers) => {
    const transformador = comporTransformadores(...transducers);
    
    let resultado = TRANSFORMADOR.init();
    for (const item of array) {
        resultado = transformador(resultado, item);
    }
    return TRANSFORMADOR.result(resultado);
};

// Exemplo de uso de transducers
const numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const dobrarEFilterPar = comporTransformadores(
    map(filter(x => x % 2 === 0))(x => x * 2)
);

const resultadoTransducer = transformarArray(numeros, dobrarEFilterPar);
console.log('Transducer resultado:', resultadoTransducer); // [4, 8, 12, 16, 20]

// Implementação mais completa de transducers
const criarTransducer = {
    map: fn => transformador => (acc, entrada) => 
        transformador(acc, fn(entrada)),
    
    filter: predicado => transformador => (acc, entrada) => 
        predicado(entrada) ? transformador(acc, entrada) : acc,
    
    take: n => transformador => {
        let count = 0;
        return (acc, entrada) => {
            if (count < n) {
                count++;
                return transformador(acc, entrada);
            }
            return acc;
        };
    },
    
    takeWhile: predicado => transformador => {
        let parar = false;
        return (acc, entrada) => {
            if (parar || !predicado(entrada)) {
                parar = true;
                return acc;
            }
            return transformador(acc, entrada);
        };
    }
};

// Transducer para arrays
const paraArray = {
    init: () => [],
    result: x => x,
    step: (acc, entrada) => (acc.push(entrada), acc)
};

// Transducer para contagem
const paraContagem = {
    init: () => 0,
    result: x => x,
    step: (acc) => acc + 1
};

// Função para aplicar transducer
const aplicarTransducer = (transducer, redutor, col) => {
    const reducao = transducer(redutor.step);
    let resultado = redutor.init();
    
    for (const item of col) {
        if (reducao(resultado, item) === resultado) { // Se não houver mudança, pode ser sinal de "parar"
            break;
        } else {
            resultado = reducao(resultado, item);
        }
    }
    
    return redutor.result(resultado);
};

// Exemplos práticos com transducers
const dados = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];

const resultado1 = aplicarTransducer(
    compor(
        criarTransducer.filter(x => x % 2 === 0), // Apenas pares
        criarTransducer.map(x => x * 3),          // Triplica
        criarTransducer.take(3)                   // Pega os 3 primeiros
    ),
    paraArray,
    dados
);

console.log('Transducer 1:', resultado1); // [6, 12, 18]

// Implementação de Maybe (monad básico para lidar com null/undefined)
const Maybe = {
    nothing: () => ({ 
        isNothing: true, 
        map: () => Maybe.nothing(), 
        flatMap: () => Maybe.nothing(),
        getOrElse: (defaultValue) => defaultValue
    }),
    
    just: (value) => ({ 
        isNothing: false, 
        map: (fn) => Maybe.maybeOf(fn(value)),
        flatMap: (fn) => fn(value),
        getOrElse: () => value
    }),
    
    maybeOf: (value) => value != null ? Maybe.just(value) : Maybe.nothing()
};

// Exemplo de uso do Maybe
const buscarUsuario = (id) => {
    const usuarios = {
        1: { nome: 'João', email: 'joao@exemplo.com', endereco: { cidade: 'São Paulo' } },
        2: { nome: 'Maria', email: 'maria@exemplo.com' }
    };
    return usuarios[id] || null;
};

const extrairCidade = (usuario) => usuario.endereco ? usuario.endereco.cidade : null;

// Sem Maybe - propenso a erros
const getCidadeUsuario = (id) => {
    const usuario = buscarUsuario(id);
    return usuario && usuario.endereco ? usuario.endereco.cidade : null;
};

// Com Maybe - mais seguro
const getCidadeUsuarioSeguro = (id) => 
    Maybe.maybeOf(buscarUsuario(id))
         .flatMap(usuario => Maybe.maybeOf(extrairCidade(usuario)))
         .getOrElse('Cidade não disponível');

console.log(getCidadeUsuarioSeguro(1)); // 'São Paulo'
console.log(getCidadeUsuarioSeguro(2)); // 'Cidade não disponível'
console.log(getCidadeUsuarioSeguro(99)); // 'Cidade não disponível'

// Implementação de Either (para tratamento de erros funcionais)
const Either = {
    left: (error) => ({
        isLeft: true,
        isRight: false,
        map: () => Either.left(error),
        flatMap: () => Either.left(error),
        getOrElse: () => error,
        fold: (leftFn, rightFn) => leftFn(error)
    }),
    
    right: (value) => ({
        isLeft: false,
        isRight: true,
        map: (fn) => Either.right(fn(value)),
        flatMap: (fn) => fn(value),
        getOrElse: () => value,
        fold: (leftFn, rightFn) => rightFn(value)
    })
};

// Função que pode falhar
const dividir = (numerador, denominador) => 
    denominador === 0 
        ? Either.left(new Error('Divisão por zero'))
        : Either.right(numerador / denominador);

// Combinando divisões com Either
const calcular = (a, b, c) => 
    dividir(a, b)
        .flatMap(resultado1 => dividir(resultado1, c))
        .fold(
            erro => `Erro: ${erro.message}`,
            resultado => `Resultado: ${resultado}`
        );

console.log(calcular(10, 2, 5)); // "Resultado: 1"
console.log(calcular(10, 0, 5)); // "Erro: Divisão por zero"

// Point-free style (também chamado de tacit programming)
// Funções definidas sem referência explícita aos argumentos

// Forma tradicional
const somarTres = (a, b, c) => a + b + c;

// Point-free usando curry
const somarTresPF = compor(
    curry(somar)(1),
    curry(somar)(2)
);

// Criando funções utilitárias em estilo point-free
const pipePF = (...fns) => (initial) => fns.reduce((acc, fn) => fn(acc), initial);
const comporPF = (...fns) => (initial) => fns.reduceRight((acc, fn) => fn(acc), initial);

// Funções utilitárias point-free
const sempre = curry((valor, _) => valor);
const identidade = (x) => x;
const aplicar = curry((fn, arg) => fn(arg));
const flip = curry((fn, a, b) => fn(b, a));

// Exemplo de pipeline point-free
const processarTextoPF = pipePF(
    str => str.trim(),
    str => str.toLowerCase(),
    str => str.split(' '),
    palavras => palavras.map(p => p.charAt(0).toUpperCase() + p.slice(1)),
    palavras => palavras.join(' ')
);

console.log(processarTextoPF('  ola mundo  ')); // "Ola Mundo"

// Funções puras para operações de conjunto
const diferenca = curry((a, b) => a.filter(item => !b.includes(item)));
const intersecao = curry((a, b) => a.filter(item => b.includes(item)));
const uniao = curry((a, b) => [...new Set([...a, ...b])]);

const array1 = [1, 2, 3, 4, 5];
const array2 = [4, 5, 6, 7, 8];

console.log('Diferença:', diferenca(array1, array2)); // [1, 2, 3]
console.log('Interseção:', intersecao(array1, array2)); // [4, 5]
console.log('União:', uniao(array1, array2)); // [1, 2, 3, 4, 5, 6, 7, 8]

// Implementação de uma biblioteca funcional simples
const Funcao = {
    // Cria um functor funcional
    of: (value) => ({
        value,
        map: (fn) => Funcao.of(fn(value)),
        flatMap: (fn) => fn(value),
        run: () => value
    }),
    
    // Função utilitária para encadeamento
    encadear: (valor, ...funcoes) => {
        return funcoes.reduce((acc, fn) => fn(acc), valor);
    }
};

// Exemplo de uso da biblioteca funcional
const resultadoFuncao = Funcao.of('  OLÁ MUNDO  ')
    .map(str => str.trim())
    .map(str => str.toLowerCase())
    .map(str => str.split(' '))
    .map(palavras => palavras.map(p => p.charAt(0).toUpperCase() + p.slice(1)))
    .map(palavras => palavras.join(' '))
    .run();

console.log('Funcao resultado:', resultadoFuncao); // "Olá Mundo"

// Criando um sistema de validação funcional
const Validacao = {
    sucesso: (valor) => ({
        sucesso: true,
        valor,
        mensagens: [],
        flatMap: (fn) => fn(valor),
        map: (fn) => Validacao.sucesso(fn(valor))
    }),
    
    falha: (mensagens) => ({
        sucesso: false,
        valor: null,
        mensagens,
        flatMap: () => Validacao.falha(mensagens),
        map: () => Validacao.falha(mensagens)
    })
};

const validarEmail = (email) => 
    /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email) 
        ? Validacao.sucesso(email)
        : Validacao.falha(['Email inválido']);

const validarTamanho = (min, max) => (str) =>
    str.length >= min && str.length <= max
        ? Validacao.sucesso(str)
        : Validacao.falha([`Tamanho deve ser entre ${min} e ${max} caracteres`]);

const validarUsuario = (dados) => {
    return validarEmail(dados.email)
        .flatMap(email => 
            validarTamanho(3, 50)(dados.nome)
                .flatMap(nome => 
                    dados.idade >= 18
                        ? Validacao.sucesso({ ...dados, email, nome })
                        : Validacao.falha(['Usuário deve ter 18 anos ou mais'])
                )
        );
};

const usuarioValido = validarUsuario({ 
    nome: 'João Silva', 
    email: 'joao@exemplo.com', 
    idade: 25 
});

const usuarioInvalido = validarUsuario({ 
    nome: 'Jo', 
    email: 'invalido', 
    idade: 15 
});

console.log('Usuário válido:', usuarioValido);
console.log('Usuário inválido:', usuarioInvalido);