Pular para o conteúdo

Orientação a objetos

Sobrecarga

overload: variantes da mesma ação escolhidas pela aridade e pelos tipos, com empate recusado.

Uma linguagem dinâmica não precisa de sobrecarga para aceitar tipos diferentes — um given typeof(x) resolve. O que ela ganha com sobrecarga é declarar as formas aceitas, e deixar a linguagem recusar a que não serve com a lista das que servem.

dataforge
overload action formatar(valor: Integer):
    yield $"{valor}"
overload action formatar(valor: Float):
    yield $"{round(valor, 2)}"
overload action formatar(valor: String, largura: Integer):
    yield valor.ljust(largura)

assert formatar(3) is "3"
assert formatar(2.5) is "2.5"
assert formatar("ab", 4) is "ab  "

monitor:
    formatar(yes)
    assert no
handle OverloadResolutionError as e:
    out e.message

Como a variante é escolhida#

  1. descarta as que não aceitam a quantidade e os nomes dos argumentos;
  2. confere os tipos declarados, com a mesma regra de qualquer anotação (um Integer serve onde se pede Float);
  3. entre as que sobram, vence a que declara mais tipos — a mais específica;
  4. um empate é AmbiguousOverloadError. Escolher pela ordem de escrita faria mover uma variante de lugar mudar um programa que não a chama.

Construtores sobrecarregados#

dataforge
blueprint Cor:
    r := 0
    g := 0
    b := 0
    overload action setup(cinza: Integer):
        self.r := cinza
        self.g := cinza
        self.b := cinza
    overload action setup(r: Integer, g: Integer, b: Integer):
        self.r := r
        self.g := g
        self.b := b

assert (spawn Cor(128)).g is 128
assert (spawn Cor(1, 2, 3)).b is 3