Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Funções, assincronismo e rotinas paralelas

Funções organizam e reaproveitam lógica. No CGD você escreve funções normais, funções seta (=>), funções assíncronas (assincrona/aguardar) e tarefas paralelas em threads (rotina).

Funções normais, valores padrão e arrows (=>)

Declare funções com funcao (ou função), parâmetros opcionais com = valor e argumentos variáveis no final com ...nome. Se uma função terminar sem retorna, ela devolve nulo. Funções anônimas e arrows (=>) funcionam como callbacks sem captura.

funcao somar(a: inteiro, b: inteiro = 1): inteiro {
    retorna a + b
}
const dobrar: funcao = (x: inteiro): inteiro => x * 2

Funções assíncronas: assincrona, aguardar e Promessa

Uma funcao marcada como assincrona devolve automaticamente uma Promessa. Dentro dela, você usa aguardar para esperar temporizadores, requisições HTTP, sockets TCP ou outras promessas sem travar o resto do programa — tudo coordenado por um reactor epoll no runtime C.

Promessa também traz combinadores estáticos prontos: Promessa.resolvida, Promessa.rejeitada, Promessa.todas, Promessa.corrida, Promessa.qualquer e Promessa.todasResolvidas, além de cancelamento cooperativo (.cancelar()).

assincrona funcao buscarDados(): texto {
    const Tempo: qualquer = importar("cgd:assincrono").Tempo
    aguardar Tempo.dormir(10)
    retorna "pronto"
}

Paralelismo real: rotina, Tarefa e Canal

Quando você quer fazer trabalho pesado de CPU em paralelo em outro núcleo, use rotina minhaFuncao(args). Ela dispara a função num pool de threads nativo e devolve uma Tarefa, que você espera com aguardar.

Para evitar condições de corrida e bugs difíceis de rastrear, o compilador audita a função em tempo de compilação (E3401–E3404): rotinas só aceitam argumentos e retornos transferíveis (nulo, lógico, inteiro, real ou texto copiado) e não podem mexer em estado global mutável. Para trocar mensagens entre tarefas, use Canal e GrupoTarefas em cgd:assincrono.

const t1: Tarefa<inteiro> = rotina fib(12)
const t2: Tarefa<inteiro> = rotina fib(14)
escreva(aguardar t1, aguardar t2)

Experimente: 07_funcoes

funcao soma(a: inteiro, b: inteiro = a + 2): inteiro {
    retorna a + b
}

funcao reunir(primeiro: qualquer, ...resto: qualquer): qualquer {
    retorna [primeiro, ...resto]
}

escreva(soma(3))
escreva(reunir(1, ...[2, 3]))

Ver exemplo completo e contrato de teste no GitHub

Experimente: 08_funcoes_valores

funcao dobro(x: qualquer): qualquer {
    retorna x * 2
}

var operacao: funcao = dobro
funcao criar(): qualquer {
    // Esta função não captura nenhuma variável de criar().
    retorna funcao(x: qualquer): qualquer {
        retorna x + 4
    }
}

escreva(operacao(3))
escreva(criar()(5))
escreva(mapear([1, 2, 3], funcao(x: qualquer): qualquer {
    retorna x * 3
}))

Ver exemplo completo e contrato de teste no GitHub

Experimente: 41_assincronismo

assincrona funcao maisUm(valor: inteiro): inteiro {
    retorna valor + 1
}

assincrona funcao mostrar(): vazio {
    escreva("início")
    const futuro: Promessa<inteiro> = maisUm(10)
    const resultado = aguardar futuro
    escreva(resultado)
}

escreva("raiz")
mostrar()
escreva("continua")

Ver exemplo completo e contrato de teste no GitHub

Experimente: 42_rotinas

funcao fib(n: inteiro): inteiro {
    se n <= 1 {
        retorna n
    }

    retorna fib(n - 1) + fib(n - 2)
}

assincrona funcao produtor(canal: qualquer): vazio {
    para var i: inteiro = 1; i <= 5; i++ {
        aguardar canal.enviar(i * 10)
    }

    canal.fechar()
}

assincrona funcao principal(): vazio {
    const Async: qualquer = importar("cgd:assincrono")
    const t1: Tarefa<inteiro> = rotina fib(10)
    const t2: Tarefa<inteiro> = rotina fib(12)
    escreva(aguardar t1)
    escreva(aguardar t2)

    const ch: qualquer = Async.Canal(2)
    const envio: Promessa<vazio> = produtor(ch)
    var soma: inteiro = 0
    enquanto verdadeiro {
        tente {
            soma = soma + aguardar ch.receber()
        } pegue (erro: Excecao) {
            sustar
        }
    }

    aguardar envio
    escreva(soma)
    escreva(ch.fechado())
}

principal()

Ver exemplo completo e contrato de teste no GitHub

No CGD, funções nunca capturam variáveis externas (upvalues). Passe tudo por parâmetro ou use métodos de classe. Assincronismo e rotinas são recursos nativos do CGD, distintos da wiki base da Delégua.