Repository: DesignLiquido/delegua
Pull request #682 (2024-05-18 21:27:50)

Funcao nativa `tupla`
- Implementa https://github.com/DesignLiquido/delegua/issues/629;
- Reorganização da biblioteca global.


Patch:
diff --git a/fontes/bibliotecas/biblioteca-global.ts b/fontes/bibliotecas/biblioteca-global.ts
index 549af082..0234b554 100644
--- a/fontes/bibliotecas/biblioteca-global.ts
+++ b/fontes/bibliotecas/biblioteca-global.ts
@@ -3,645 +3,849 @@ import { ObjetoDeleguaClasse } from '../estruturas/objeto-delegua-classe';
 import { FuncaoPadrao } from '../estruturas/funcao-padrao';
 import { DeleguaClasse } from '../estruturas/delegua-classe';
 import { VisitanteComumInterface, VariavelInterface } from '../interfaces';
-import { PilhaEscoposExecucaoInterface } from '../interfaces/pilha-escopos-execucao-interface';
+import { InterpretadorInterface } from "../interfaces";
 import { DeleguaFuncao } from '../estruturas';
+import { Deceto, Dupla, Noneto, Octeto, Quarteto, Quinteto, Septeto, Sexteto, Trio, Tupla } from '../construtos';
+
+/**
+ * Retorna um número aleatório entre 0 e 1.
+ * @returns {Promise<number>} Número real.
+ */
+export async function aleatorio(
+    interpretador: InterpretadorInterface
+): Promise<number> {
+    return Promise.resolve(Math.random());
+}
 
-export default function (interpretador: VisitanteComumInterface, pilhaEscoposExecucao: PilhaEscoposExecucaoInterface) {
-    const todosEmCondicao = async function (
-        vetor: VariavelInterface | any,
-        funcaoCondicional: VariavelInterface | any
-    ) {
-        if (vetor === null || vetor === undefined)
-            return Promise.reject(
-                new ErroEmTempoDeExecucao(
-                    this.simbolo,
-                    'Parâmetro inválido. O primeiro parâmetro da função todosEmCondicao() não pode ser nulo.'
-                )
-            );
-
-        const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-        const valorFuncaoCondicional = funcaoCondicional.hasOwnProperty('valor')
-            ? funcaoCondicional.valor
-            : funcaoCondicional;
-        if (!Array.isArray(valorVetor)) {
-            return Promise.reject(
-                new ErroEmTempoDeExecucao(
-                    this.simbolo,
-                    'Parâmetro inválido. O primeiro parâmetro da função todosEmCondicao() deve ser um vetor.'
-                )
-            );
-        }
-
-        if (valorFuncaoCondicional.constructor.name !== 'DeleguaFuncao') {
-            return Promise.reject(
-                new ErroEmTempoDeExecucao(
-                    this.simbolo,
-                    'Parâmetro inválido. O segundo parâmetro da função todosEmCondicao() deve ser uma função.'
-                )
-            );
-        }
-
-        for (let indice = 0; indice < valorVetor.length; ++indice) {
-            if (!(await valorFuncaoCondicional.chamar(interpretador, [valorVetor[indice]]))) return false;
+/**
+ * Retorna um número aleatório de acordo com o parâmetro passado.
+ * Mínimo(inclusivo) - Máximo(exclusivo).
+ * @param {number} minimo O número mínimo.
+ * @param {number} maximo O número máximo.
+ * @returns {Promise<number>} Um número real entre os valores máximo e mínimo especificados.
+ */
+export async function aleatorioEntre(
+    interpretador: InterpretadorInterface,
+    minimo: VariavelInterface | number, 
+    maximo: VariavelInterface | number
+): Promise<number> {
+    // eslint-disable-next-line prefer-rest-params
+    if (arguments.length <= 0) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(this.simbolo, 'A função recebe ao menos um parâmetro.')
+        );
+    }
+
+    const valorMinimo = minimo.hasOwnProperty('valor') ? (minimo as VariavelInterface).valor : minimo;
+
+    if (arguments.length === 2) {
+        if (typeof valorMinimo !== 'number') {
+            return Promise.reject(new ErroEmTempoDeExecucao(this.simbolo, 'O parâmetro deve ser um número.'));
         }
 
-        return true;
-    };
+        return Math.floor(Math.random() * (0 - valorMinimo)) + valorMinimo;
+    }
 
-    // Retorna um número aleatório entre 0 e 1.
-    pilhaEscoposExecucao.definirVariavel(
-        'aleatorio',
-        new FuncaoPadrao(1, function () {
-            return Math.random();
-        })
-    );
-
-    // Retorna um número aleatório de acordo com o parâmetro passado.
-    // Mínimo(inclusivo) - Máximo(exclusivo)
-    pilhaEscoposExecucao.definirVariavel(
-        'aleatorioEntre',
-        new FuncaoPadrao(1, async function (minimo: VariavelInterface | number, maximo: VariavelInterface | number) {
-            // eslint-disable-next-line prefer-rest-params
-            if (arguments.length <= 0) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(this.simbolo, 'A função recebe ao menos um parâmetro.')
-                );
-            }
+    if (arguments.length > 3) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(this.simbolo, 'A quantidade de parâmetros máxima para esta função é 2.')
+        );
+    }
 
-            const valorMinimo = minimo.hasOwnProperty('valor') ? (minimo as VariavelInterface).valor : minimo;
+    const valorMaximo = maximo.hasOwnProperty('valor') ? (maximo as VariavelInterface).valor : maximo;
 
-            if (arguments.length === 1) {
-                if (typeof valorMinimo !== 'number') {
-                    return Promise.reject(new ErroEmTempoDeExecucao(this.simbolo, 'O parâmetro deve ser um número.'));
-                }
-
-                return Math.floor(Math.random() * (0 - valorMinimo)) + valorMinimo;
-            }
-
-            if (arguments.length > 2) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(this.simbolo, 'A quantidade de parâmetros máxima para esta função é 2.')
-                );
-            }
-
-            const valorMaximo = maximo.hasOwnProperty('valor') ? (maximo as VariavelInterface).valor : maximo;
-
-            if (typeof valorMinimo !== 'number' || typeof valorMaximo !== 'number') {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(this.simbolo, 'Os dois parâmetros devem ser do tipo número.')
-                );
-            }
-
-            return Promise.resolve(Math.floor(Math.random() * (valorMaximo - valorMinimo)) + valorMinimo);
-        })
-    );
-
-    pilhaEscoposExecucao.definirVariavel(
-        'algum',
-        new FuncaoPadrao(2, async function (vetor: VariavelInterface | any, funcaoPesquisa: VariavelInterface | any) {
-            const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-
-            const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
-
-            if (!Array.isArray(valorVetor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
-                    )
-                );
-            }
-
-            if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'
-                    )
-                );
-            }
-
-            for (let indice = 0; indice < valorVetor.length; ++indice) {
-                if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
-                    return true;
-                }
-            }
-
-            return false;
-        })
-    );
-
-    pilhaEscoposExecucao.definirVariavel(
-        'encontrar',
-        new FuncaoPadrao(1, async function (vetor: VariavelInterface | any, funcaoPesquisa: VariavelInterface | any) {
-            const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-
-            const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
-
-            if (!Array.isArray(valorVetor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
-                    )
-                );
-            }
-
-            if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'
-                    )
-                );
-            }
-
-            for (let indice = 0; indice < valorVetor.length; ++indice) {
-                if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
-                    return valorVetor[indice];
-                }
-            }
-
-            return null;
-        })
-    );
-
-    pilhaEscoposExecucao.definirVariavel(
-        'encontrarUltimo',
-        new FuncaoPadrao(1, async function (vetor: VariavelInterface | any, funcaoPesquisa: VariavelInterface | any) {
-            const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-
-            const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
-
-            if (!Array.isArray(valorVetor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
-                    )
-                );
-            }
-
-            if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'
-                    )
-                );
-            }
-
-            for (let indice = valorVetor.length - 1; indice >= 0; --indice) {
-                if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
-                    return valorVetor[indice];
-                }
-            }
-        })
-    );
-
-    pilhaEscoposExecucao.definirVariavel(
-        'encontrarIndice',
-        new FuncaoPadrao(2, async function (vetor: VariavelInterface | any, funcaoPesquisa: VariavelInterface | any) {
-            const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-
-            const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
-
-            if (!Array.isArray(valorVetor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
-                    )
-                );
-            }
-
-            if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'
-                    )
-                );
-            }
-
-            for (let indice = 0; indice < valorVetor.length; ++indice) {
-                if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
-                    return indice;
-                }
-            }
-
-            return -1;
-        })
-    );
-
-    pilhaEscoposExecucao.definirVariavel(
-        'encontrarUltimoIndice',
-        new FuncaoPadrao(2, async function (vetor: VariavelInterface | any, funcaoPesquisa: VariavelInterface | any) {
-            const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-
-            const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
-
-            if (!Array.isArray(valorVetor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
-                    )
-                );
-            }
-
-            if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'
-                    )
-                );
-            }
-
-            for (let indice = valorVetor.length - 1; indice >= 0; --indice) {
-                if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
-                    return indice;
-                }
-            }
-        })
-    );
-
-    pilhaEscoposExecucao.definirVariavel(
-        'incluido',
-        new FuncaoPadrao(2, async function (vetor: VariavelInterface | any, valor: VariavelInterface | any) {
-            const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-
-            const valorValor = valor.hasOwnProperty('valor') ? valor.valor : valor;
-
-            if (!Array.isArray(valorVetor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
-                    )
-                );
-            }
-
-            for (let indice = 0; indice < valorVetor.length; ++indice) {
-                if (valorVetor[indice] == valorValor) {
-                    return true;
-                }
-            }
-
-            return false;
-        })
-    );
-
-    pilhaEscoposExecucao.definirVariavel(
-        'inteiro',
-        new FuncaoPadrao(1, async function (numero: VariavelInterface | any) {
-            if (numero === null || numero === undefined) return Promise.resolve(0);
-
-            const valor = numero.hasOwnProperty('valor') ? numero.valor : numero;
-
-            if (isNaN(valor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Valor não parece ser um número. Somente números ou textos com números podem ser convertidos para inteiro.'
-                    )
-                );
-            }
+    if (typeof valorMinimo !== 'number' || typeof valorMaximo !== 'number') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(this.simbolo, 'Os dois parâmetros devem ser do tipo número.')
+        );
+    }
 
-            if (!/^(-)?\d+(\.\d+)?$/.test(valor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Valor não parece estar estruturado como um número (texto vazio, falso ou não definido). Somente números ou textos com números podem ser convertidos para inteiro.'
-                    )
-                );
-            }
+    return Promise.resolve(Math.floor(Math.random() * (valorMaximo - valorMinimo)) + valorMinimo);
+}
 
-            return Promise.resolve(parseInt(valor));
-        })
-    );
+/**
+ * Verifica se algum dos elementos satisfaz à condição para por parâmetro.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
+ * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
+ * @returns {Promise<boolean>} Verdadeiro se há algum elemento no vetor com a condição. Falso caso contrário.
+ */
+export async function algum(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any, 
+    funcaoPesquisa: VariavelInterface | any
+): Promise<boolean> {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+
+    const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
+
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
+            )
+        );
+    }
+
+    if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'
+            )
+        );
+    }
+
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
+            return true;
+        }
+    }
 
-    pilhaEscoposExecucao.definirVariavel(
-        'mapear',
-        new FuncaoPadrao(1, async function (vetor: VariavelInterface | any, funcaoMapeamento: VariavelInterface | any) {
-            if (vetor === null || vetor === undefined)
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função mapear() não pode ser nulo.'
-                    )
-                );
-
-            const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-
-            const valorFuncaoMapeamento = funcaoMapeamento.hasOwnProperty('valor')
-                ? funcaoMapeamento.valor
-                : funcaoMapeamento;
-
-            if (!Array.isArray(valorVetor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função mapear() deve ser um vetor.'
-                    )
-                );
-            }
+    return false;
+}
 
-            if (valorFuncaoMapeamento.constructor.name !== 'DeleguaFuncao') {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O segundo parâmetro da função mapear() deve ser uma função.'
-                    )
-                );
-            }
+/**
+ * Encontra o primeiro elemento de um vetor cuja função de pesquisa retorne
+ * verdadeiro na avaliação de cada elemento.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
+ * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
+ * @returns {Promise<any>} Um elemento, caso o elemento seja encontraro, ou nulo em caso contrário.
+ */
+export async function encontrar(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any, 
+    funcaoPesquisa: VariavelInterface | any
+): Promise<any> {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+
+    const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
+
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
+            )
+        );
+    }
+
+    if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'
+            )
+        );
+    }
+
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
+            return valorVetor[indice];
+        }
+    }
 
-            const resultados = [];
-            for (let indice = 0; indice < valorVetor.length; ++indice) {
-                resultados.push(await valorFuncaoMapeamento.chamar(interpretador, [valorVetor[indice]]));
-            }
+    return null;
+}
 
-            return resultados;
-        })
-    );
+/**
+ * Encontra o índice do primeiro elemento de um vetor cuja função de pesquisa retorne
+ * verdadeiro na avaliação de cada elemento.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
+ * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
+ * @returns {Promise<number>} O número correspondente ao índice se o elemento for encontrado, ou nulo em caso contrário.
+ */
+export async function encontrarIndice(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any, 
+    funcaoPesquisa: VariavelInterface | any
+): Promise<number> {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+
+    const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
+
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
+            )
+        );
+    }
+
+    if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'
+            )
+        );
+    }
+
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
+            return indice;
+        }
+    }
 
-    pilhaEscoposExecucao.definirVariavel('todos', new FuncaoPadrao(2, todosEmCondicao));
-
-    pilhaEscoposExecucao.definirVariavel('todosEmCondicao', new FuncaoPadrao(2, todosEmCondicao));
-
-    pilhaEscoposExecucao.definirVariavel(
-        'filtrarPor',
-        new FuncaoPadrao(1, async function (vetor: VariavelInterface | any, funcaoFiltragem: VariavelInterface | any) {
-            if (vetor === null || vetor === undefined)
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função filtrarPor() não pode ser nulo.'
-                    )
-                );
-
-            const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-            const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor')
-                ? funcaoFiltragem.valor
-                : funcaoFiltragem;
-            if (!Array.isArray(valorVetor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função filtrarPor() deve ser um vetor.'
-                    )
-                );
-            }
+    return -1;
+}
 
-            if (valorFuncaoFiltragem.constructor.name !== 'DeleguaFuncao') {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O segundo parâmetro da função filtrarPor() deve ser uma função.'
-                    )
-                );
-            }
+/**
+ * Encontrar o último elemento de um vetor cuja função de pesquisa retorne
+ * verdadeiro na avaliação de cada elemento.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador. 
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript. 
+ * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa. 
+ * @returns {Promise<number>} O número correspondente ao índice se o elemento for encontrado, ou nulo em caso contrário.
+ */
+export async function encontrarUltimo(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any, 
+    funcaoPesquisa: VariavelInterface | any
+): Promise<number> {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+
+    const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
+
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
+            )
+        );
+    }
+
+    if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'
+            )
+        );
+    }
+
+    for (let indice = valorVetor.length - 1; indice >= 0; --indice) {
+        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
+            return valorVetor[indice];
+        }
+    }
 
-            const resultados = [];
-            for (let indice = 0; indice < valorVetor.length; ++indice) {
-                const deveRetornarValor = await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
-                if (deveRetornarValor === false) continue;
-                
-                resultados.push(valorVetor[indice]);
-            }
+    return null;
+}
 
-            return resultados;
-        })
-    );
+/**
+ * 
+ * @param {InterpretadorInterface} interpretador A instância do interpretador. 
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript. 
+ * @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.  
+ * @returns {Promise<number>} O número correspondente ao índice se o elemento for encontrado, ou nulo em caso contrário.
+ */
+export async function encontrarUltimoIndice(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any, 
+    funcaoPesquisa: VariavelInterface | any
+): Promise<number> {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+
+    const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
+
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
+            )
+        );
+    }
+
+    if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'
+            )
+        );
+    }
+
+    for (let indice = valorVetor.length - 1; indice >= 0; --indice) {
+        if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
+            return indice;
+        }
+    }
 
-    pilhaEscoposExecucao.definirVariavel(
-        'primeiroEmCondicao',
-        new FuncaoPadrao(2, async function (vetor: VariavelInterface | any, funcaoFiltragem: VariavelInterface | any) {
-            if (vetor === null || vetor === undefined)
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função primeiroEmCondicao() não pode ser nulo.'
-                    )
-                );
-
-            const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-
-            const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor')
-                ? funcaoFiltragem.valor
-                : funcaoFiltragem;
-            if (!Array.isArray(valorVetor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função primeiroEmCondicao() deve ser um vetor.'
-                    )
-                );
-            }
+    return null;
+}
 
-            if (valorFuncaoFiltragem.constructor.name !== 'DeleguaFuncao') {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O segundo parâmetro da função primeiroEmCondicao() deve ser uma função.'
-                    )
-                );
-            }
+/**
+ * 
+ * @param interpretador 
+ * @param vetor 
+ * @param funcaoFiltragem 
+ * @returns 
+ */
+export async function filtrarPor(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any, 
+    funcaoFiltragem: VariavelInterface | any
+) {
+    if (vetor === null || vetor === undefined)
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função filtrarPor() não pode ser nulo.'
+            )
+        );
+
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor')
+        ? funcaoFiltragem.valor
+        : funcaoFiltragem;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função filtrarPor() deve ser um vetor.'
+            )
+        );
+    }
+
+    if (valorFuncaoFiltragem.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O segundo parâmetro da função filtrarPor() deve ser uma função.'
+            )
+        );
+    }
+
+    const resultados = [];
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        const deveRetornarValor = await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
+        if (deveRetornarValor === false) continue;
+        
+        resultados.push(valorVetor[indice]);
+    }
+
+    return resultados;
+}
 
-            for (let indice = 0; indice < valorVetor.length; ++indice) {
-                const valorResolvido = await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
-                if (valorResolvido !== null) {
-                    return valorResolvido;
-                }
-            }
+/**
+ * 
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.  
+ * @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.  
+ * @param valor 
+ * @returns 
+ */
+export async function incluido(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any, 
+    valor: VariavelInterface | any
+): Promise<boolean> {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+
+    const valorValor = valor.hasOwnProperty('valor') ? valor.valor : valor;
+
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
+            )
+        );
+    }
+
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        if (valorVetor[indice] == valorValor) {
+            return true;
+        }
+    }
 
-            return undefined;
-        })
-    );
+    return false;
+}
 
-    pilhaEscoposExecucao.definirVariavel(
-        'paraCada',
-        new FuncaoPadrao(2, async function (vetor: VariavelInterface | any, funcaoFiltragem: VariavelInterface | any) {
-            if (vetor === null || vetor === undefined)
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função paraCada() não pode ser nulo.'
-                    )
-                );
-
-            const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-            const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor')
-                ? funcaoFiltragem.valor
-                : funcaoFiltragem;
-            if (!Array.isArray(valorVetor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função paraCada() deve ser um vetor.'
-                    )
-                );
-            }
+/**
+ * 
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param numero 
+ * @returns 
+ */
+export async function inteiro(
+    interpretador: InterpretadorInterface,
+    numero: VariavelInterface | any
+) {
+    if (numero === null || numero === undefined) return Promise.resolve(0);
+
+    const valor = numero.hasOwnProperty('valor') ? numero.valor : numero;
+
+    if (isNaN(valor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Valor não parece ser um número. Somente números ou textos com números podem ser convertidos para inteiro.'
+            )
+        );
+    }
+
+    if (!/^(-)?\d+(\.\d+)?$/.test(valor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Valor não parece estar estruturado como um número (texto vazio, falso ou não definido). Somente números ou textos com números podem ser convertidos para inteiro.'
+            )
+        );
+    }
+
+    return Promise.resolve(parseInt(valor));
+}
 
-            if (valorFuncaoFiltragem.constructor.name !== 'DeleguaFuncao') {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O segundo parâmetro da função paraCada() deve ser uma função.'
-                    )
-                );
-            }
+/**
+ * 
+ * @param interpretador 
+ * @param vetor 
+ * @param funcaoMapeamento 
+ * @returns 
+ */
+export async function mapear(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any, 
+    funcaoMapeamento: VariavelInterface | any
+): Promise<any[]> {
+    if (vetor === null || vetor === undefined)
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função mapear() não pode ser nulo.'
+            )
+        );
+
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+
+    const valorFuncaoMapeamento = funcaoMapeamento.hasOwnProperty('valor')
+        ? funcaoMapeamento.valor
+        : funcaoMapeamento;
+
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função mapear() deve ser um vetor.'
+            )
+        );
+    }
+
+    if (valorFuncaoMapeamento.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O segundo parâmetro da função mapear() deve ser uma função.'
+            )
+        );
+    }
+
+    const resultados = [];
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        resultados.push(await valorFuncaoMapeamento.chamar(interpretador, [valorVetor[indice]]));
+    }
+
+    return resultados;
+}
 
-            for (let indice = 0; indice < valorVetor.length; ++indice) {
-                await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
+/**
+ * 
+ * @param vetor 
+ * @returns 
+ */
+export async function ordenar(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | Array<any>
+): Promise<any[]> {
+    if (vetor === null || vetor === undefined)
+        throw new ErroEmTempoDeExecucao(
+            this.simbolo,
+            'Parâmetro inválido. O primeiro parâmetro da função ordenar() não pode ser nulo.'
+        );
+
+    const objeto = vetor.hasOwnProperty('valor') ? (vetor as VariavelInterface).valor : vetor;
+
+    if (!Array.isArray(objeto)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(this.simbolo, 'Valor inválido. Objeto inserido não é um vetor.')
+        );
+    }
+
+    let trocado: boolean;
+    const tamanho = objeto.length;
+    do {
+        trocado = false;
+        for (let i = 0; i < tamanho - 1; i++) {
+            if (objeto[i] > objeto[i + 1]) {
+                [objeto[i], objeto[i + 1]] = [objeto[i + 1], objeto[i]];
+                trocado = true;
             }
-        })
-    );
-
-    pilhaEscoposExecucao.definirVariavel(
-        'ordenar',
-        new FuncaoPadrao(1, async function (vetor: VariavelInterface | Array<any>) {
-            if (vetor === null || vetor === undefined)
-                throw new ErroEmTempoDeExecucao(
-                    this.simbolo,
-                    'Parâmetro inválido. O primeiro parâmetro da função ordenar() não pode ser nulo.'
-                );
+        }
+    } while (trocado);
 
-            const objeto = vetor.hasOwnProperty('valor') ? (vetor as VariavelInterface).valor : vetor;
+    return Promise.resolve(objeto);
+}
 
-            if (!Array.isArray(objeto)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(this.simbolo, 'Valor inválido. Objeto inserido não é um vetor.')
-                );
-            }
+/**
+ * 
+ * @param interpretador 
+ * @param vetor 
+ * @param funcaoFiltragem 
+ * @returns 
+ */
+export async function paraCada(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any, 
+    funcaoFiltragem: VariavelInterface | any
+): Promise<any> {
+    if (vetor === null || vetor === undefined)
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função paraCada() não pode ser nulo.'
+            )
+        );
+
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor')
+        ? funcaoFiltragem.valor
+        : funcaoFiltragem;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função paraCada() deve ser um vetor.'
+            )
+        );
+    }
+
+    if (valorFuncaoFiltragem.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O segundo parâmetro da função paraCada() deve ser uma função.'
+            )
+        );
+    }
+
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
+    }
+}
 
-            let trocado: boolean;
-            const tamanho = objeto.length;
-            do {
-                trocado = false;
-                for (let i = 0; i < tamanho - 1; i++) {
-                    if (objeto[i] > objeto[i + 1]) {
-                        [objeto[i], objeto[i + 1]] = [objeto[i + 1], objeto[i]];
-                        trocado = true;
-                    }
-                }
-            } while (trocado);
-            return Promise.resolve(objeto);
-        })
-    );
+/**
+ * 
+ * @param interpretador 
+ * @param vetor 
+ * @param funcaoFiltragem 
+ * @returns 
+ */
+export async function primeiroEmCondicao(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any, 
+    funcaoFiltragem: VariavelInterface | any
+) {
+    if (vetor === null || vetor === undefined)
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função primeiroEmCondicao() não pode ser nulo.'
+            )
+        );
+
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+
+    const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor')
+        ? funcaoFiltragem.valor
+        : funcaoFiltragem;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função primeiroEmCondicao() deve ser um vetor.'
+            )
+        );
+    }
+
+    if (valorFuncaoFiltragem.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O segundo parâmetro da função primeiroEmCondicao() deve ser uma função.'
+            )
+        );
+    }
+
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        const valorResolvido = await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
+        if (valorResolvido !== null) {
+            return valorResolvido;
+        }
+    }
 
-    pilhaEscoposExecucao.definirVariavel(
-        'real',
-        new FuncaoPadrao(1, async function (numero: VariavelInterface | any) {
-            if (numero === null || numero === undefined) return Promise.resolve(parseFloat('0'));
-
-            const valor = numero.hasOwnProperty('valor') ? numero.valor : numero;
-            if (!/^(-)?\d+(\.\d+)?$/.test(valor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Valor não parece estar estruturado como um número (texto/valor vazio, falso ou não definido). Somente números ou textos com números podem ser convertidos para real.'
-                    )
-                );
-            }
-            return Promise.resolve(parseFloat(valor));
-        })
-    );
+    return undefined;
+}
 
-    pilhaEscoposExecucao.definirVariavel(
-        'reduzir',
-        new FuncaoPadrao(3, async function (
-            vetor: VariavelInterface | any,
-            funcaoReducao: VariavelInterface | any,
-            padrao: VariavelInterface | any = null
-        ) {
-            const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-            const valorFuncaoReducao = funcaoReducao.hasOwnProperty('valor') ? funcaoReducao.valor : funcaoReducao;
-            const valorPadrao = padrao.hasOwnProperty('valor') ? padrao.valor : padrao;
-
-            if (!Array.isArray(valorVetor)) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
-                    )
-                );
-            }
+/**
+ * 
+ * @param interpretador 
+ * @param numero 
+ * @returns 
+ */
+export async function real(
+    interpretador: InterpretadorInterface,
+    numero: VariavelInterface | any
+): Promise<number> {
+    if (numero === null || numero === undefined) return Promise.resolve(parseFloat('0'));
+
+    const valor = numero.hasOwnProperty('valor') ? numero.valor : numero;
+    if (!/^(-)?\d+(\.\d+)?$/.test(valor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Valor não parece estar estruturado como um número (texto/valor vazio, falso ou não definido). Somente números ou textos com números podem ser convertidos para real.'
+            )
+        );
+    }
+
+    return Promise.resolve(parseFloat(valor));
+}
 
-            if (valorFuncaoReducao.constructor.name !== 'DeleguaFuncao') {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(
-                        this.simbolo,
-                        'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'
-                    )
-                );
-            }
+/**
+ * 
+ * @param interpretador 
+ * @param vetor 
+ * @param funcaoReducao 
+ * @param padrao 
+ * @returns 
+ */
+export async function reduzir(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any,
+    funcaoReducao: VariavelInterface | any,
+    padrao: VariavelInterface | any = null
+) {
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoReducao = funcaoReducao.hasOwnProperty('valor') ? funcaoReducao.valor : funcaoReducao;
+    const valorPadrao = padrao.hasOwnProperty('valor') ? padrao.valor : padrao;
+
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'
+            )
+        );
+    }
+
+    if (valorFuncaoReducao.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'
+            )
+        );
+    }
+
+    let resultado = valorPadrao;
+    let inicio = 0;
+
+    if (!resultado) {
+        resultado = vetor[0];
+        inicio = 1;
+    }
+
+    for (let index = inicio; index < vetor.length; ++index) {
+        resultado = await valorFuncaoReducao.chamar(interpretador, [resultado, vetor[index]]);
+    }
+
+    return resultado;
+}
 
-            let resultado = valorPadrao;
-            let inicio = 0;
+/**
+ * 
+ * @param objeto 
+ * @returns 
+ */
+export async function tamanho(
+    interpretador: InterpretadorInterface,
+    objeto: any
+) {
+    const valorObjeto = objeto.hasOwnProperty('valor') ? objeto.valor : objeto;
+
+    if (typeof valorObjeto === 'number') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(this.simbolo, 'Função global tamanho() não funciona com números.')
+        );
+    }
+
+    if (valorObjeto instanceof ObjetoDeleguaClasse) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(this.simbolo, 'Função global tamanho não funciona com objetos complexos.')
+        );
+    }
+
+    if (valorObjeto instanceof DeleguaFuncao) {
+        return Promise.resolve(valorObjeto.declaracao.parametros.length);
+    }
+
+    if (valorObjeto instanceof FuncaoPadrao) {
+        return Promise.resolve(valorObjeto.valorAridade);
+    }
+
+    if (valorObjeto instanceof DeleguaClasse) {
+        const metodos = valorObjeto.metodos;
+        let tamanho = 0;
+
+        if (metodos.inicializacao && metodos.inicializacao.eInicializador) {
+            tamanho = metodos.inicializacao.declaracao.parametros.length;
+        }
 
-            if (!resultado) {
-                resultado = vetor[0];
-                inicio = 1;
-            }
+        return Promise.resolve(tamanho);
+    }
 
-            for (let index = inicio; index < vetor.length; ++index) {
-                resultado = await valorFuncaoReducao.chamar(interpretador, [resultado, vetor[index]]);
-            }
+    return Promise.resolve(valorObjeto.length);
+}
 
-            return resultado;
-        })
+/**
+ * 
+ * @param interpretador 
+ * @param valorOuVariavel 
+ * @returns 
+ */
+export async function texto(
+    interpretador: InterpretadorInterface,
+    valorOuVariavel: VariavelInterface | any
+) {
+    return Promise.resolve(
+        `${valorOuVariavel.hasOwnProperty('valor') ? valorOuVariavel.valor : valorOuVariavel}`
     );
+}
 
-    pilhaEscoposExecucao.definirVariavel(
-        'tamanho',
-        new FuncaoPadrao(1, async function (objeto: any) {
-            const valorObjeto = objeto.hasOwnProperty('valor') ? objeto.valor : objeto;
-
-            if (typeof valorObjeto === 'number') {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(this.simbolo, 'Função global tamanho() não funciona com números.')
-                );
-            }
-
-            if (valorObjeto instanceof ObjetoDeleguaClasse) {
-                return Promise.reject(
-                    new ErroEmTempoDeExecucao(this.simbolo, 'Função global tamanho não funciona com objetos complexos.')
-                );
-            }
-
-            if (valorObjeto instanceof DeleguaFuncao) {
-                return Promise.resolve(valorObjeto.declaracao.parametros.length);
-            }
-
-            if (valorObjeto instanceof FuncaoPadrao) {
-                return Promise.resolve(valorObjeto.valorAridade);
-            }
-
-            if (valorObjeto instanceof DeleguaClasse) {
-                const metodos = valorObjeto.metodos;
-                let tamanho = 0;
-
-                if (metodos.inicializacao && metodos.inicializacao.eInicializador) {
-                    tamanho = metodos.inicializacao.declaracao.parametros.length;
-                }
-
-                return Promise.resolve(tamanho);
-            }
-
-            return Promise.resolve(valorObjeto.length);
-        })
-    );
+/**
+ * 
+ * @param interpretador 
+ * @param vetor 
+ * @param funcaoCondicional 
+ * @returns 
+ */
+export async function todosEmCondicao(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any,
+    funcaoCondicional: VariavelInterface | any
+): Promise<boolean> {
+    if (vetor === null || vetor === undefined)
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função todosEmCondicao() não pode ser nulo.'
+            )
+        );
+
+    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
+    const valorFuncaoCondicional = funcaoCondicional.hasOwnProperty('valor')
+        ? funcaoCondicional.valor
+        : funcaoCondicional;
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O primeiro parâmetro da função todosEmCondicao() deve ser um vetor.'
+            )
+        );
+    }
+
+    if (valorFuncaoCondicional.constructor.name !== 'DeleguaFuncao') {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Parâmetro inválido. O segundo parâmetro da função todosEmCondicao() deve ser uma função.'
+            )
+        );
+    }
+
+    for (let indice = 0; indice < valorVetor.length; ++indice) {
+        if (!(await valorFuncaoCondicional.chamar(interpretador, [valorVetor[indice]]))) return false;
+    }
+
+    return true;
+}
 
-    pilhaEscoposExecucao.definirVariavel(
-        'texto',
-        new FuncaoPadrao(1, async function (valorOuVariavel: VariavelInterface | any) {
+/**
+ * Transforma um vetor de elementos em uma tupla de N elementos, sendo N a 
+ * largura do vetor.
+ * @param interpretador 
+ * @param vetor 
+ * @returns 
+ */
+export async function tupla(
+    interpretador: InterpretadorInterface,
+    vetor: VariavelInterface | any[], 
+): Promise<Tupla> {
+    const valorVetor: any[] = !Array.isArray(vetor) && vetor.hasOwnProperty('valor') ? 
+        vetor.valor : 
+        vetor;
+
+    if (!Array.isArray(valorVetor)) {
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                this.simbolo,
+                'Argumento de função nativa `tupla` não parece ser um vetor.'
+            )
+        );
+    }
+
+    switch (valorVetor.length) {
+        case 2:
             return Promise.resolve(
-                `${valorOuVariavel.hasOwnProperty('valor') ? valorOuVariavel.valor : valorOuVariavel}`
+                new Dupla(valorVetor[0], valorVetor[1])
             );
-        })
-    );
-
-    return pilhaEscoposExecucao;
-}
+        case 3:
+            return Promise.resolve(
+                new Trio(valorVetor[0], valorVetor[1], valorVetor[2])
+            );
+        case 4:
+            return Promise.resolve(
+                new Quarteto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3])
+            );
+        case 5:
+            return Promise.resolve(
+                new Quinteto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4])
+            );
+        case 6:
+            return Promise.resolve(
+                new Sexteto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5])
+            );
+        case 7:
+            return Promise.resolve(
+                new Septeto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6])
+            );
+        case 8:
+            return Promise.resolve(
+                new Octeto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6], valorVetor[7])
+            );
+        case 9:
+            return Promise.resolve(
+                new Noneto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6], valorVetor[7], valorVetor[8])
+            );
+        case 10:
+            return Promise.resolve(
+                new Deceto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6], valorVetor[7], valorVetor[8], valorVetor[9])
+            );
+        case 1:
+        default:
+            return Promise.reject(
+                new ErroEmTempoDeExecucao(
+                    this.simbolo,
+                    'Para ser transformado em uma tupla, vetor precisa ter de 2 a 10 elementos.'
+                )
+            );
+    }
+}
\ No newline at end of file
diff --git a/fontes/estruturas/funcao-padrao.ts b/fontes/estruturas/funcao-padrao.ts
index 514b7c68..a823611a 100644
--- a/fontes/estruturas/funcao-padrao.ts
+++ b/fontes/estruturas/funcao-padrao.ts
@@ -17,12 +17,8 @@ export class FuncaoPadrao extends Chamavel {
     }
 
     async chamar(visitante: VisitanteComumInterface, argumentos: any[], simbolo: SimboloInterface): Promise<any> {
-        return this.chamarInterno(argumentos, simbolo);
-    }
-
-    protected async chamarInterno(argumentos: any[], simbolo: SimboloInterface): Promise<any> {
         this.simbolo = simbolo;
-        return await this.funcao.apply(this, argumentos);
+        return await this.funcao.apply(this, [visitante, ...argumentos]);
     }
 
     /**
diff --git a/fontes/interpretador/comum.ts b/fontes/interpretador/comum.ts
new file mode 100644
index 00000000..79ebff72
--- /dev/null
+++ b/fontes/interpretador/comum.ts
@@ -0,0 +1,111 @@
+import { PilhaEscoposExecucaoInterface } from "../interfaces/pilha-escopos-execucao-interface";
+
+import { FuncaoPadrao } from "../estruturas/funcao-padrao";
+
+import * as bibliotecaGlobal from '../bibliotecas/biblioteca-global';
+
+export function carregarBibliotecasGlobais(pilhaEscoposExecucao: PilhaEscoposExecucaoInterface) {
+    pilhaEscoposExecucao.definirVariavel(
+        'aleatorio',
+        new FuncaoPadrao(1, bibliotecaGlobal.aleatorio)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'aleatorioEntre',
+        new FuncaoPadrao(2, bibliotecaGlobal.aleatorioEntre)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'algum',
+        new FuncaoPadrao(2, bibliotecaGlobal.algum)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'encontrar',
+        new FuncaoPadrao(2, bibliotecaGlobal.encontrar)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'encontrarIndice',
+        new FuncaoPadrao(2, bibliotecaGlobal.encontrarIndice)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'encontrarUltimo',
+        new FuncaoPadrao(2, bibliotecaGlobal.encontrarUltimo)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'encontrarUltimoIndice',
+        new FuncaoPadrao(2, bibliotecaGlobal.encontrarUltimoIndice)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'filtrarPor',
+        new FuncaoPadrao(2, bibliotecaGlobal.filtrarPor)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'incluido',
+        new FuncaoPadrao(2, bibliotecaGlobal.incluido)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'inteiro',
+        new FuncaoPadrao(1, bibliotecaGlobal.inteiro)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'mapear',
+        new FuncaoPadrao(2, bibliotecaGlobal.mapear)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'ordenar',
+        new FuncaoPadrao(1, bibliotecaGlobal.ordenar)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'paraCada',
+        new FuncaoPadrao(2, bibliotecaGlobal.paraCada)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'primeiroEmCondicao',
+        new FuncaoPadrao(2, bibliotecaGlobal.primeiroEmCondicao)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'real',
+        new FuncaoPadrao(1, bibliotecaGlobal.real)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'reduzir',
+        new FuncaoPadrao(3, bibliotecaGlobal.reduzir)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'tamanho',
+        new FuncaoPadrao(1, bibliotecaGlobal.tamanho)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'texto',
+        new FuncaoPadrao(1, bibliotecaGlobal.texto)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'todos', new FuncaoPadrao(2, bibliotecaGlobal.todosEmCondicao)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'todosEmCondicao', 
+        new FuncaoPadrao(2, bibliotecaGlobal.todosEmCondicao)
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'tupla', 
+        new FuncaoPadrao(1, bibliotecaGlobal.tupla)
+    );
+}
diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts
index 81883a77..939eeda4 100644
--- a/fontes/interpretador/interpretador-base.ts
+++ b/fontes/interpretador/interpretador-base.ts
@@ -1,10 +1,5 @@
 import hrtime from 'browser-process-hrtime';
 
-import { EspacoVariaveis } from '../espaco-variaveis';
-import carregarBibliotecasGlobais from '../bibliotecas/biblioteca-global';
-
-import { ErroEmTempoDeExecucao } from '../excecoes';
-import { InterpretadorInterface, ParametroInterface, SimboloInterface, VariavelInterface } from '../interfaces';
 import {
     Aleatorio,
     Bloco,
@@ -78,6 +73,15 @@ import { inferirTipoVariavel } from './inferenciador';
 import { MetodoPrimitiva } from '../estruturas/metodo-primitiva';
 import { ArgumentoInterface } from './argumento-interface';
 
+import { MicroLexador } from '../lexador';
+import { MicroAvaliadorSintatico } from '../avaliador-sintatico';
+import { MicroAvaliadorSintaticoBase } from '../avaliador-sintatico/micro-avaliador-sintatico-base';
+
+import { EspacoVariaveis } from '../espaco-variaveis';
+import { carregarBibliotecasGlobais } from './comum';
+import { ErroEmTempoDeExecucao } from '../excecoes';
+import { InterpretadorInterface, ParametroInterface, SimboloInterface, VariavelInterface } from '../interfaces';
+
 import primitivasDicionario from '../bibliotecas/primitivas-dicionario';
 import primitivasNumero from '../bibliotecas/primitivas-numero';
 import primitivasTexto from '../bibliotecas/primitivas-texto';
@@ -86,9 +90,6 @@ import primitivasVetor from '../bibliotecas/primitivas-vetor';
 import tiposDeSimbolos from '../tipos-de-simbolos/delegua';
 import tipoDeDadosPrimitivos from '../tipos-de-dados/primitivos';
 import tipoDeDadosDelegua from '../tipos-de-dados/delegua';
-import { MicroLexador } from '../lexador';
-import { MicroAvaliadorSintatico } from '../avaliador-sintatico';
-import { MicroAvaliadorSintaticoBase } from '../avaliador-sintatico/micro-avaliador-sintatico-base';
 
 /**
  * O Interpretador visita todos os elementos complexos gerados pelo avaliador sintático (_parser_),
@@ -170,7 +171,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         };
         this.pilhaEscoposExecucao.empilhar(escopoExecucao);
 
-        carregarBibliotecasGlobais(this, this.pilhaEscoposExecucao);
+        carregarBibliotecasGlobais(this.pilhaEscoposExecucao);
     }
 
     /**
@@ -769,7 +770,7 @@ export class InterpretadorBase implements InterpretadorInterface {
             if (entidadeChamada instanceof FuncaoPadrao) {
                 try {
                     return entidadeChamada.chamar(
-                        undefined,
+                        this,
                         argumentos.map((a) =>
                             a && a.valor && a.valor.hasOwnProperty('valor') ? a.valor.valor : a?.valor
                         ),


Test patch:
diff --git a/testes/biblioteca-global.test.ts b/testes/biblioteca-global.test.ts
index 9da0187f..729d2ffe 100644
--- a/testes/biblioteca-global.test.ts
+++ b/testes/biblioteca-global.test.ts
@@ -371,4 +371,47 @@ describe('Biblioteca Global', () => {
             expect(retornoInterpretador.erros).toHaveLength(0);
         });
     });
+
+    describe('tupla()', () => {
+        it('Trivial', async () => {
+            let _saidas = "";
+            interpretador.funcaoDeRetorno = (saida: string) => {
+                _saidas += saida;
+            }
+
+            const retornoLexador = lexador.mapear(["escreva(tupla([1,2,3]))"], -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+            const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+            expect(retornoInterpretador.erros).toHaveLength(0);
+            expect(_saidas).toBe('{"primeiro":1,"segundo":2,"terceiro":3}');
+        });
+
+        it('Falha - Não é vetor', async () => {
+            const retornoLexador = lexador.mapear(["escreva(tupla(0))"], -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+            const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+            expect(retornoInterpretador.erros.length).toBeGreaterThan(0);
+            const erro = retornoInterpretador.erros[0];
+            expect(erro.erroInterno).toBeDefined();
+            expect(erro.erroInterno.mensagem).toBeDefined();
+            expect(erro.erroInterno.mensagem).toBe('Argumento de função nativa `tupla` não parece ser um vetor.');
+        });
+
+        it('Falha - Vetor com mais de 10 elementos', async () => {
+            const retornoLexador = lexador.mapear(["escreva(tupla([1,2,3,4,5,6,7,8,9,10,11]))"], -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+            const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+            expect(retornoInterpretador.erros.length).toBeGreaterThan(0);
+            const erro = retornoInterpretador.erros[0];
+            expect(erro.erroInterno).toBeDefined();
+            expect(erro.erroInterno.mensagem).toBeDefined();
+            expect(erro.erroInterno.mensagem).toBe('Para ser transformado em uma tupla, vetor precisa ter de 2 a 10 elementos.');
+        });
+    });
 });