Funções

Funções são blocos de código que podem ou não devolver um valor ao final de sua execução.

Funções em Delégua podem ser identificadas por um nome ou não.

Função com nome

Funções com nome podem ser declaradas usando a palavra-chave funcao (ou função), seguida de um nome de função, uma lista de argumentos dentro de parênteses, sendo cada elemento separado por vírgula, e, por fim, um bloco de escopo para o corpo da função dentro das chaves de escopo:

funcao principal() {
  escreva("sim!")
}

escreva(principal) // saídas <função principal>

Funções com nome são declaradas como variáveis e também vinculadas ao escopo local, como qualquer outra variável.

Argumentos e parâmetros

Argumentos são variáveis ou constantes, obrigatórias ou opcionais, que são passadas na chamada da função. A passagem é por valor, ou seja, os valores dessas variáveis ou constantes são copiadas para o escopo da função. Variáveis ou constantes copiadas a partir de argumentos são chamadas de parâmetros.

Delégua aceita até 255 argumentos por função. Uma função com mais de 255 argumentos levantará erro.

Argumentos podem ter um tipo especificado ou não:

função soma3(a, b, c) {
    retorna a + b + c
}

funcao multiplica3(a: numero, b: numero, c: numero) {
    retorna a * b * c
}

Se mais argumentos são necessários, ou ainda, se o número de argumentos for variável, pode-se usar o operador * para indicar que todos os argumentos passados serão agregados a um único parâmetro na execução da função. Por exemplo:

função teste(*argumentos) {
    escreva(argumentos)
}

teste(1, 2, 3) // Escreve "[1, 2, 3]"

Neste caso, * é um operador de aglutinação de N argumentos em um único parâmetro.

O operador de aglutinação de argumentos só pode ser usado no último argumento da função. Por exemplo, o código abaixo é inválido e levantará erro:

função teste(*argumentos, outroArgumento) {
    escreva(argumentos)
}

teste(1, 2, 3) // Nem executa, porque teremos um erro de avaliação sintática.

Função anônima

Delégua permite a criação de funções sem um nome especificado. São usadas normalmente como variáveis em outras funções que peçam como argumento outra função.

Um exemplo disso é a função mapear(), função global de Delégua e Égua. O primeiro parâmetro é um vetor de números, e o segundo parâmetro é uma função que mapear() chama para cada elemento do vetor.

var funcaoParaMapear = funcao(a) { 
  retorna a * 2
};

escreva(mapear([5, 3], funcaoParaMapear))

Chamada de função

Uma função que retorna dados como resultado.

var multiplicacaoPorDois = funcao(a) { 
  retorna a * 2
};

multiplicacaoPorDois(3) // retorna 6

Retornos de função e retorna

Uma função pode ou não retornar valores de dados processados dentro de funções.

funcao principal() {
  retorna 1
}

var dado = principal() // `dado` recebe o valor retornado por `principal()`
escreva(dado) // imprimirá 1

retorna é uma construção especial que, além de definir qual o valor a ser retornado, também quebra a execução no momento em que é chamada.

funcao principal() {
  escreva("a") // saída a
  retorna
  escreva("b") // nunca executa, pois `retorna` finaliza a execução da função, quebrando seu fluxo na linha em que é executada.
}

var dado = principal() // `dado` recebe o valor `nulo` devido a nada ter sido retornado.
escreva(dado) // Saída nula

retorna pode opcionalmente utilizar parênteses:

funcao principal() {
  retorna(1)
}

Também pode ser usada quantas vezes for necessário dentro de uma função. Por exemplo, uma implementação do cálculo da sequência de Fibonacci pode ser implementada da seguinte forma:

funcao fibonacci(n) {
  se n == 0 {
    retorna 0
  }
    
  se n == 1 {
    retorna 1
  }

  var n1 = n - 1
  var n2 = n - 2
  var f1 = fibonacci(n1)
  var f2 = fibonacci(n2)
  retorna f1 + f2
}

escreva(fibonacci(6)) // Escreve '8'.