2.4.3 Programação Orientada a Dados e Aditividade

A estratégia geral de verificar o tipo de um dado e chamar uma função apropriada é chamada dispatch sobre tipo. Esta é uma técnica poderosa para obter modularidade no design do sistema. Por outro lado, implementá-la conforme fizemos na seção 2.4.2 tem duas fraquezas significativas.

Problemas com Dispatch Explícito

As funções genéricas devem conhecer todas as representações diferentes
Mesmo que as representações individuais possam ser projetadas separadamente, devemos garantir que não haja dois procedimentos com o mesmo nome em todo o sistema

Programação Orientada a Dados

Uma abordagem melhor é usar uma técnica conhecida como programação orientada a dados. Esta é uma forma de projetar programas para trabalhar com uma tabela de operações e tipos que permite adicionar novas representações sem modificar o código existente.

A Tabela de Operações

Imagine uma tabela bidimensional onde:

As linhas correspondem a operações (real_part, imag_part, magnitude, angle)
As colunas correspondem a tipos (polar, rectangular)
Cada célula contém a função apropriada para aquela operação naquele tipo

Exemplo de Código

1// Sistema de tabela (interface simplificada)
2// put e get operam em uma tabela global
3
4// Instalando o pacote retangular
5function install_rectangular_package() {
6  // funções internas
7  function real_part(z) { return head(z); }
8  function imag_part(z) { return tail(z); }
9  function make_from_real_imag(x, y) { return pair(x, y); }
10
11  // interface para o resto do sistema
12  function tag(x) {
13      return attach_tag("rectangular", x);
14  }
15
16  put("real_part", "rectangular", real_part);
17  put("imag_part", "rectangular", imag_part);
18  put("make_from_real_imag", "rectangular",
19      (x, y) => tag(make_from_real_imag(x, y)));
20
21  return "done";
22}
23
24// Instalando o pacote polar
25function install_polar_package() {
26  // funções internas
27  function magnitude(z) { return head(z); }
28  function angle(z) { return tail(z); }
29  function make_from_mag_ang(r, a) { return pair(r, a); }
30
31  // interface para o resto do sistema
32  function tag(x) {
33      return attach_tag("polar", x);
34  }
35
36  put("magnitude", "polar", magnitude);
37  put("angle", "polar", angle);
38  put("make_from_mag_ang", "polar",
39      (r, a) => tag(make_from_mag_ang(r, a)));
40
41  return "done";
42}

// Sistema de tabela (interface simplificada)
// put e get operam em uma tabela global

// Instalando o pacote retangular
function install_rectangular_package() {
  // funções internas
  function real_part(z) { return head(z); }
  function imag_part(z) { return tail(z); }
  function make_from_real_imag(x, y) { return pair(x, y); }

  // interface para o resto do sistema
  function tag(x) {
      return attach_tag("rectangular", x);
  }

  put("real_part", "rectangular", real_part);
  put("imag_part", "rectangular", imag_part);
  put("make_from_real_imag", "rectangular",
      (x, y) => tag(make_from_real_imag(x, y)));

  return "done";
}

// Instalando o pacote polar
function install_polar_package() {
  // funções internas
  function magnitude(z) { return head(z); }
  function angle(z) { return tail(z); }
  function make_from_mag_ang(r, a) { return pair(r, a); }

  // interface para o resto do sistema
  function tag(x) {
      return attach_tag("polar", x);
  }

  put("magnitude", "polar", magnitude);
  put("angle", "polar", angle);
  put("make_from_mag_ang", "polar",
      (r, a) => tag(make_from_mag_ang(r, a)));

  return "done";
}

⛓ sessãoCódigo editável · Ctrl+Enter executa · Esc solta o foco

Operações Genéricas via Dispatch

Agora os seletores genéricos são muito mais simples:

Exemplo de Código

1function apply_generic(op, arg) {
2  const type_tag = type_tag(arg);
3  const fun = get(op, type_tag);
4  return fun !== undefined
5         ? fun(contents(arg))
6         : error(list(op, type_tag),
7                 "no method for these types -- apply_generic");
8}
9
10function real_part(z) {
11  return apply_generic("real_part", z);
12}
13
14function imag_part(z) {
15  return apply_generic("imag_part", z);
16}
17
18function magnitude(z) {
19  return apply_generic("magnitude", z);
20}
21
22function angle(z) {
23  return apply_generic("angle", z);
24}

function apply_generic(op, arg) {
  const type_tag = type_tag(arg);
  const fun = get(op, type_tag);
  return fun !== undefined
         ? fun(contents(arg))
         : error(list(op, type_tag),
                 "no method for these types -- apply_generic");
}

function real_part(z) {
  return apply_generic("real_part", z);
}

function imag_part(z) {
  return apply_generic("imag_part", z);
}

function magnitude(z) {
  return apply_generic("magnitude", z);
}

function angle(z) {
  return apply_generic("angle", z);
}

⛓ sessãoCódigo editável · Ctrl+Enter executa · Esc solta o foco

Message Passing (Passagem de Mensagens)

Uma alternativa à programação orientada a dados é decompor a tabela de forma diferente. Em vez de ter "operações inteligentes" que fazem dispatch com base no tipo de dados, podemos ter "dados inteligentes" que fazem dispatch com base no nome da operação:

Exemplo de Código

1function make_from_real_imag(x, y) {
2  function dispatch(op) {
3      return op === "real_part"
4             ? x
5             : op === "imag_part"
6             ? y
7             : op === "magnitude"
8             ? math_sqrt(square(x) + square(y))
9             : op === "angle"
10             ? math_atan(y, x)
11             : error(op, "unknown op -- make_from_real_imag");
12  }
13  return dispatch;
14}
15
16function apply_generic(op, arg) {
17  return arg(op);
18}

function make_from_real_imag(x, y) {
  function dispatch(op) {
      return op === "real_part"
             ? x
             : op === "imag_part"
             ? y
             : op === "magnitude"
             ? math_sqrt(square(x) + square(y))
             : op === "angle"
             ? math_atan(y, x)
             : error(op, "unknown op -- make_from_real_imag");
  }
  return dispatch;
}

function apply_generic(op, arg) {
  return arg(op);
}

⛓ sessãoCódigo editável · Ctrl+Enter executa · Esc solta o foco

Esta é a essência da programação com message passing. O objeto de dados é uma função que, quando chamada com um nome de operação, retorna o resultado apropriado.

Aditividade

Ambas as abordagens (programação orientada a dados e message passing) permitem design aditivo de sistemas—novos tipos de dados e operações podem ser adicionados sem modificar o código existente. Isso é crucial para construir sistemas grandes e modulares.

Exercícios

Exercício 2.73: Reescreva o programa de diferenciação simbólica (seção 2.3.2) para que o dispatch seja feito de forma orientada a dados.

Exercício 2.74: Implemente um sistema genérico para acessar registros de pessoal de uma empresa com divisões independentes.

Exercício 2.75: Implemente o construtor make_from_mag_ang em estilo message-passing.

Exercício 2.76: Compare as três estratégias de organização (dispatch explícito, data-directed, message-passing) para adicionar novos tipos e novas operações.

📝 Encontrou algo errado nesta página?

Sua ajuda é muito importante para melhorar a qualidade da tradução!

🐛 Encontrou um erro?

Se você encontrou:

Erro de tradução (palavra incorreta, termo técnico errado)
Erro de ortografia ou gramática
Link quebrado
Código de exemplo que não funciona
Problema de formatação

Reporte um bug →

❓ Tem uma dúvida?

Se você tem:

Dúvida sobre o conteúdo desta seção
Pergunta sobre um conceito do SICP
Dificuldade em entender algum exemplo
Questão sobre a tradução de algum termo

Inicie uma discussão →

💡 Tem uma sugestão de melhoria?

Se você quer sugerir:

Melhoria na explicação
Exemplo adicional
Recurso visual (diagrama, ilustração)
Qualquer outra ideia

Sugira uma melhoria →

🌍 Quer discutir a tradução?

Se você quer debater:

Escolha de tradução de algum termo
Consistência de terminologia
Nuances do português

Discussão de tradução →

Problemas com Dispatch Explícito​

Programação Orientada a Dados​

A Tabela de Operações​

Operações Genéricas via Dispatch​

Message Passing (Passagem de Mensagens)​

Aditividade​

Exercícios​

📝 Encontrou algo errado nesta página?

🐛 Encontrou um erro?

❓ Tem uma dúvida?

💡 Tem uma sugestão de melhoria?

🌍 Quer discutir a tradução?

Problemas com Dispatch Explícito

Programação Orientada a Dados

A Tabela de Operações

Operações Genéricas via Dispatch

Message Passing (Passagem de Mensagens)

Aditividade

Exercícios