Visão geral

Laços

cycle, persist, perform, halt e skip — os quatro laços da linguagem.

cycle — intervalo numérico#

dataforge

cycle i from 1 to 5:
    out i                 # 1 2 3 4 5 — o limite é INCLUSIVO

cycle i from 0 to 10 step 2:
    out i                 # 0 2 4 6 8 10

cycle i from 5 to 1 step -1:
    out i                 # 5 4 3 2 1

cycle — sobre uma coleção#

dataforge

cycle fruta in ["maca", "uva", "pera"]:
    out fruta

cycle letra in "abc":
    out letra

precos := {"maca": 3.5, "uva": 8.0}
cycle chave in precos.keys():
    out $"{chave}: {precos[chave]}"

Percorrer um Vault diretamente com cycle k in precos também funciona e itera as chaves — a mesma convenção de in.

persist — enquanto (while)#

dataforge

n := 1024
divisoes := 0
persist n bigger 1:
    n := n ~/ 2
    divisoes += 1

out $"1024 vira 1 apos {divisoes} divisoes"

saída

1024 vira 1 apos 10 divisoes

perform — faça-enquanto (do-while)#

A condição é testada depois do corpo, então ele roda pelo menos uma vez:

dataforge

execucoes := 0
perform:
    execucoes += 1
persist no

out $"executou {execucoes} vez mesmo com a condicao falsa"

halt e skip#

Palavra	Efeito
`halt`	sai do laço
`skip`	vai para a próxima iteração

dataforge

selecionados := []
cycle i from 1 to 100:
    given i % 3 is 0:
        skip                  # pula os múltiplos de 3
    given i bigger 10:
        halt                  # para ao passar de 10
    selecionados.append(i)

out selecionados

saída

[1, 2, 4, 5, 7, 8, 10]

Laços aninhados#

dataforge

matriz := []
cycle i from 1 to 3:
    linha := []
    cycle j from 1 to 3:
        linha.append(i * j)
    matriz.append(linha)

cycle l in matriz:
    out l

halt e skip afetam apenas o laço mais interno em que aparecem.

Quando não usar laço#

Para transformar ou filtrar uma coleção, compreensões e pipelines dizem melhor o que você quer:

dataforge

# com laço — descreve COMO
quadrados := []
cycle n in nums:
    quadrados.append(n * n)

# com compreensão — descreve O QUE
quadrados := [n * n cycle n in nums]

# com pipeline — quando há vários estágios
total := nums >> sift n: n bigger 0 >> morph n: n * n >> distill a, v: a + v 0

O laço continua sendo a escolha certa quando há lógica com vários passos, efeitos colaterais ou saída antecipada.