Paradigma Imperativo x Declarativo x Funcional

Conceitos

Paradigma Imperativo

Paradigma Declarativo

Exemplos:

• SQL:

SELECT * FROM pedidos WHERE valor > 100;

• HTML:

<button>Salvar</button>

Paradigma Funcional

Paradigma funcional É um tipo de programação declarativa que segue algumas regras fortes

• Funções puras

  • Mesma entrada → sempre a mesma saída
  • Não mexem em variáveis globais, não escrevem em banco, não printam na tela (idealmente).

• Imutabilidade

  • Você não altera estruturas de dados; cria novas versões.
  • Sem “sair mutando” variáveis por aí.

• Funções como valores

  • Você passa função como parâmetro, retorna função, compõe função com função (map, filter, reduce).

• Pouco ou nenhum controle de fluxo explícito

  • Quase nada de for/while; no lugar, map, filter, reduce, recursão.

Exemplo funcional em JS:

const numeros = [1, 2, 3, 4, 5];

const pares = numeros.filter(n => n % 2 === 0);
const soma  = pares.reduce((acc, n) => acc + n, 0);

Aqui você:

• Fala o que quer (pares, depois soma) → declarativo
• E faz isso só com funções, sem mudar estado externo → funcional

Como enxergar a relação do paradigma declarativo x funcional

Pensa assim:

• Paradigma Declarativo = guarda-chuva maior
  Tudo que foca em dizer o que você quer, e não como fazer.

• Declarativo = jeito de falar com o computador

• Funcional = _um “estilo dentro do declarativo”, com regras extras

• Declarativo: foca em descrever o resultado (“o que”) e esconde o passo a passo.

• Funcional: é um jeito declarativo de programar onde:

  • você organiza tudo em funções puras,
  • evita estado mutável,
  • e compõe resultados com map/filter/reduce etc.

👉 Todo código funcional é (em essência) declarativo, mas dá pra ser declarativo sem ser funcional (SQL, HTML, etc.).

Ponto Central

Qual abordagem é melhor?

A melhor abordagem é aquela em que olhando o código você entende a intenção sem esforço.

• Se o estilo declarativo deixa a regra cristalina (Filter, Reduce, SQL, etc.), use declarativo.

• Se pra entender o que está acontecendo você precisa “abrir a cabeça” da função genérica, aí o declarativo virou mágica demais → melhor voltar para o imperativo simples.

• Na prática do dia a dia, vamos notar que misturamos os dois.

Exemplo Prático

Paradigma Imperativo

• Foco: como chegar no resultado.
• Você controla o fluxo: laços, if, variáveis mudando de valor.
• É como dar receita de bolo: “pegue X, depois faça Y, depois Z…”.
• Controle total do passo a passo (ótimo para performance, otimizações finas, algoritmos complexos).
• Mais fácil de debugar em Go: você vê o for, põe breakpoint, vê variáveis mudando.
• Em Go, é o jeito idiomático padrão (a linguagem foi pensada com loops simples e claros).
• Tem tudo ali dentro: validação, regra de negócio, update.
• É claro, mas a lógica de domínio fica misturada com detalhe mecânico (for, map, etc.).

type ItemPedido struct {
    ProdutoID int64
    Qtd       int
}

type Estoque struct {
    ProdutoID int64
    QtdAtual  int
}

type MapaEstoque map[int64]int

// AtualizarEstoqueImperativo baixa o estoque diretamente a partir dos itens do pedido.
func AtualizarEstoqueImperativo(estoque MapaEstoque, itens []ItemPedido) error {
    // 1. Valida e atualiza tudo num loop só
    for _, item := range itens {
        qtdAtual, ok := estoque[item.ProdutoID]
        if !ok {
            return fmt.Errorf("produto %d não encontrado no estoque", item.ProdutoID)
        }

        if item.Qtd <= 0 {
            return fmt.Errorf("quantidade inválida para produto %d: %d", item.ProdutoID, item.Qtd)
        }

        if qtdAtual < item.Qtd {
            return fmt.Errorf("estoque insuficiente para produto %d: atual=%d, solicitado=%d",
                item.ProdutoID, qtdAtual, item.Qtd)
        }

        // 2. Atualiza o estoque
        novo := qtdAtual - item.Qtd
        estoque[item.ProdutoID] = novo
    }

    return nil
}

Paradigma Declarativo

Você diz o que quer, não como fazer.

• Foco: o que deve ser obtido.
• O “como” (o passo a passo) fica escondido dentro do sistema/biblioteca.
• É como fazer um pedido no restaurante: “quero uma pizza de calabresa”; você não dita a receita.

No modo DECLARATIVO montamos as funções, conforme abaixo:

// MovimentoEstoque representa um ajuste no estoque.
// Delta negativo = saída, positivo = entrada.
type MovimentoEstoque struct {
    ProdutoID int64
    Delta     int
    
    
// GerarMovimentosSaida: "para cada item do pedido, gere um movimento de saída".
func GerarMovimentosSaida(itens []ItemPedido) []MovimentoEstoque {
    movimentos := make([]MovimentoEstoque, 0, len(itens))

    for _, item := range itens {
        if item.Qtd <= 0 {
            continue // regra simples: ignora item com qtd inválida
        }
        movimentos = append(movimentos, MovimentoEstoque{
            ProdutoID: item.ProdutoID,
            Delta:     -item.Qtd, // saída => negativo
        })
    }

    return movimentos
}

// ConsolidarMovimentos agrupa por produto somando os deltas.
func ConsolidarMovimentos(movs []MovimentoEstoque) []MovimentoEstoque {
    acc := make(map[int64]int)

    for _, m := range movs {
        acc[m.ProdutoID] += m.Delta
    }

    result := make([]MovimentoEstoque, 0, len(acc))
    for produtoID, delta := range acc {
        result = append(result, MovimentoEstoque{
            ProdutoID: produtoID,
            Delta:     delta,
        })
    }

    return result
}

// ValidarEstoqueSuficiente verifica se todos os movimentos podem ser aplicados.
func ValidarEstoqueSuficiente(estoque MapaEstoque, movimentos []MovimentoEstoque) error {
    for _, m := range movimentos {
        qtdAtual, ok := estoque[m.ProdutoID]
        if !ok {
            return fmt.Errorf("produto %d não encontrado no estoque", m.ProdutoID)
        }

        novo := qtdAtual + m.Delta // lembre: Delta pode ser negativo
        if novo < 0 {
            return fmt.Errorf("estoque insuficiente para produto %d: atual=%d, movimento=%d, resultaria em %d",
                m.ProdutoID, qtdAtual, m.Delta, novo)
        }
    }
    return nil
}

// AplicarMovimentos aplica os deltas no mapa de estoque.
func AplicarMovimentos(estoque MapaEstoque, movimentos []MovimentoEstoque) {
    for _, m := range movimentos {
        estoque[m.ProdutoID] += m.Delta
    }
}

    
}```

Código Principal no estilo mais declarativo:
```go
// AtualizarEstoqueDeclarativo orquestra o fluxo de domínio.
func AtualizarEstoqueDeclarativo(estoque MapaEstoque, itens []ItemPedido) error {
    // 1. Declara: "quero movimentos de saída a partir dos itens"
    movimentos := GerarMovimentosSaida(itens)

    // 2. Declara: "quero consolidar esses movimentos por produto"
    movimentos = ConsolidarMovimentos(movimentos)

    // 3. Declara: "verifique se o estoque suporta esses movimentos"
    if err := ValidarEstoqueSuficiente(estoque, movimentos); err != nil {
        return err
    }

    // 4. Declara: "aplique os movimentos"
    AplicarMovimentos(estoque, movimentos)

    return nil
}

Como ficaria numa camada de serviço + repositório (DB real)

Imagina que em vez de MapaEstoque, você tem um repositório com Go + sqlx:

type EstoqueRepository interface {
    // Busca o estoque atual de uma lista de produtos
    BuscarPorProdutos(ctx context.Context, produtoIDs []int64) (MapaEstoque, error)

    // Aplica uma lista de movimentos (pode ser um UPDATE por produto, ou um batch)
    AplicarMovimentos(ctx context.Context, movimentos []MovimentoEstoque) error
}

Na camada de serviço, você poderia fazer algo assim (bem declarativo):

func (s *EstoqueService) BaixarEstoquePedido(ctx context.Context, itens []ItemPedido) error {
    produtoIDs := extrairProdutoIDs(itens)

    estoqueAtual, err := s.repo.BuscarPorProdutos(ctx, produtoIDs)
    if err != nil {
        return err
    }

    movimentos := GerarMovimentosSaida(itens)
    movimentos = ConsolidarMovimentos(movimentos)

    if err := ValidarEstoqueSuficiente(estoqueAtual, movimentos); err != nil {
        return err
    }

    // Aqui dá pra envolver tudo em transação, etc.
    if err := s.repo.AplicarMovimentos(ctx, movimentos); err != nil {
        return err
    }

    return nil
}

Aqui a camada de serviço está bem declarativa, focada na regra de negócio,
e o repositório por baixo usa Go imperativo normal com SQL.

O que você ganha com esse estilo “misto”

• Na regra de negócio (service): código mais próximo de “linguagem ubíqua” de domínio.
• Nos helpers/repositórios: Go idiomático, loops explícitos, fácil de debugar, performático.
• Fica muito fácil evoluir a regra:

Exemplo Prático Simplificado

Versão Imperativa

func BaixarEstoqueImperativo(estoque map[int]int, pedido Pedido) error {
    // 1) Verifica se o produto existe no estoque
    qtdAtual, existe := estoque[pedido.ProdutoID]
    if !existe {
        return fmt.Errorf("produto %d não encontrado", pedido.ProdutoID)
    }

    // 2) Verifica se a quantidade é válida
    if pedido.Quantidade <= 0 {
        return fmt.Errorf("quantidade inválida: %d", pedido.Quantidade)
    }

    // 3) Verifica se tem estoque suficiente
    if qtdAtual < pedido.Quantidade {
        return fmt.Errorf("estoque insuficiente: atual=%d, solicitado=%d",
            qtdAtual, pedido.Quantidade)
    }

    // 4) Atualiza o estoque (baixa)
    estoque[pedido.ProdutoID] = qtdAtual - pedido.Quantidade

    return nil
}

Uso no main:

func main() {
    estoque := map[int]int{
        10: 100,
    }

    pedido := Pedido{
        ProdutoID:  10,
        Quantidade: 3,
    }

    err := BaixarEstoqueImperativo(estoque, pedido)
    if err != nil {
        fmt.Println("Erro:", err)
        return
    }

    fmt.Println("Novo estoque do produto 10:", estoque[10]) // 97
}

Versão Declarativa

Quebramos a mesma rotina em funções com nomes claros, ou seja, funções pequenas bem nomeadas.

  func ValidarBaixaEstoque(estoque map[int]int, pedido Pedido) error {
    qtdAtual, existe := estoque[pedido.ProdutoID]
    if !existe {
        return fmt.Errorf("produto %d não encontrado", pedido.ProdutoID)
    }

    if pedido.Quantidade <= 0 {
        return fmt.Errorf("quantidade inválida: %d", pedido.Quantidade)
    }

    if qtdAtual < pedido.Quantidade {
        return fmt.Errorf("estoque insuficiente: atual=%d, solicitada=%d",
            qtdAtual, pedido.Quantidade)
    }

    return nil
}

func AplicarBaixaEstoque(estoque map[int]int, pedido Pedido) {
    estoque[pedido.ProdutoID] = estoque[pedido.ProdutoID] - pedido.Quantidade
}

func BaixarEstoqueDeclarativo(estoque map[int]int, pedido Pedido) error {
    // 1) Declara a intenção: "validar se posso baixar"
    if err := ValidarBaixaEstoque(estoque, pedido); err != nil {
        return err
    }

    // 2) Declara a intenção: "aplicar a baixa"
    AplicarBaixaEstoque(estoque, pedido)

    return nil
}

Uso no main (igual ao outro, só trocando o nome):

func main() {
    estoque := map[int]int{
        10: 100,
    }

    pedido := Pedido{
        ProdutoID:  10,
        Quantidade: 3,
    }

    err := BaixarEstoqueDeclarativo(estoque, pedido)
    if err != nil {
        fmt.Println("Erro:", err)
        return
    }

    fmt.Println("Novo estoque do produto 10:", estoque[10]) // 97
}

Conclusão Final