59 · Tipos literais

python3 exercicios/run_all.py 59

// ele e cobrado — o 'check' prova com o literal na mao, a fronteira
// cobra o resto, e 'yes' nao se confunde com 1.

type Estado := "ativo" | "inativo" | "suspenso"
type Nivel  := 1 | 2 | 3
type Ligado := yes

out "== 1. a fronteira confere =="

action mudar(e: Estado) -> String:
    yield e

assert mudar("ativo") is "ativo"
assert mudar("suspenso") is "suspenso"
out "   'ativo' e 'suspenso' passam"

out ""
out "== 2. o que nao esta na lista e recusado =="

recusados := 0
monitor:
    mudar("excluido")
handle Error as e:
    recusados := recusados + 1

monitor:
    mudar("")
handle Error as e:
    recusados := recusados + 1

assert recusados is 2
out $"   {recusados} valores de fora da lista recusados"

out ""
out "== 3. numero e booleano tambem sao literais =="

action nivel(n: Nivel) -> Integer:
    yield n * 10

assert nivel(1) is 10
assert nivel(3) is 30

l: Ligado := yes
assert l is yes
out "   Nivel 1|2|3 e Ligado yes"

out ""
out "== 4. 'yes' e '1' NAO se confundem =="

// Em Python 'True == 1'. Sem conferir o TIPO, um 'type Ligado := yes'
// aceitaria o numero 1 calado — um valor que ninguem escreveu passando
// por um tipo que existe justamente para nao deixar.
action ligar(v: Ligado) -> Boolean:
    yield v

pegou := no
monitor:
    ligar(1)
handle Error as e:
    pegou := yes
assert pegou
out "   o numero 1 nao passa por um tipo 'yes'"

out ""
out "== 5. a base de uma uniao de literais e conhecida =="

// 'e' e um String para o analisador — e e isso que permite concatenar
// e declarar '-> String'. Sem essa leitura, a forma mais natural de
// usar o recurso seria acusada de devolver o que nao declarou.
action rotulo(e: Estado) -> String:
    yield e + "!"

assert rotulo("ativo") is "ativo!"
out "   String + String, dentro de um tipo literal"

out ""
out "== 6. uma uniao MISTA nao tem base unica =="

// '"auto" | Integer' aceita os dois, e o analisador cala em vez de
// escolher uma base: escolher faria ele aprovar o que a execucao
// recusa.
type Modo := "auto" | Integer

action usar(m: Modo) -> String:
    yield str(m)

assert usar("auto") is "auto"
assert usar(3) is "3"
out "   'auto' e 3, os dois legitimos"

out ""
out "ok — 398"

action mudar(e):
    given e is not "ativo" and e is not "inativo":
        trigger $"estado invalido: {e}"
    ...

type Estado := "ativo" | "inativo" | "suspenso"

// veja o que ele acusa num texto e num cluster — e onde ele CALA, que
// e a metade que custa mais.

adopt Arcane.IO as IO
adopt Arcane.OS as OS
adopt Arcane.Process as Proc

pasta := $"{OS.temp_dir()}/df-399-{randint(100000, 999999)}"
IO.mkdir(pasta)
defer:
    IO.remove_tree(pasta)

action conferir(codigo):
    caminho := $"{pasta}/prova.df"
    IO.write(caminho, codigo)
    r := Proc.run(["dataforge", "check", caminho])
    yield r["stdout"] + r["stderr"]

out "== 1. o que existe continua funcionando =="

nome := "ana"
assert nome.upper() is "ANA"
assert nome.length() is 3

xs := [1, 2, 3]
xs.append(4)
assert len(xs) is 4
out "   upper, length e append: normais"

out ""
out "== 2. o erro de digitacao vira erro do analisador =="

saida := conferir("""nome := "ana"
out nome.uppper()
""")
assert "uppper" in saida
assert "upper" in saida
out "   'uppper' acusado, com 'upper' na sugestao"

saida := conferir("""xs := [1, 2, 3]
out xs.apend(4)
""")
assert "apend" in saida
assert "append" in saida
out "   'apend' acusado, com 'append' na sugestao"

out ""
out "== 3. e a forma SEM chamar tambem =="

// Ler o metodo sem chamar e legitimo ('f := xs.append'), entao o erro
// aqui e o mesmo: o nome nao existe naquele tipo.
saida := conferir("""nome := "ana"
f := nome.uppper
out f
""")
assert "uppper" in saida
out "   'f := nome.uppper' tambem"

out ""
out "== 4. onde ele CALA, e por que =="

// Um Vault fica de FORA: 'v.cidade' cai na CHAVE quando ela existe, e
// acusar exigiria saber as chaves — que um vault montado em execucao
// nao tem.
saida := conferir("""v := {"cidade": "Floripa"}
v["uf"] := "SC"
out v.uf
""")
assert "sem erros" in saida
out "   vault: o membro pode ser uma chave, entao ele cala"

// E 'length' nao mora na tabela — ele e tratado a parte no
// interpretador. Sem essa linha, a forma que a propria doc ensina
// viraria um falso alarme.
saida := conferir("""nome := "ana"
out nome.length()
""")
assert "sem erros" in saida
out "   'length' continua valendo"

// Um nome comecando com '_' e combinado entre quem escreveu, nao um
// engano.
saida := conferir("""nome := "ana"
out nome._interno
""")
assert "sem erros" in saida
out "   nome com '_' na frente: combinado, nao engano"

out ""
out "ok — 399"

nome := "ana"
out nome.naoExiste()      // passava limpo, e estourava em execução