Método filtrarPor não filtra vetor

fontes/bibliotecas/biblioteca-global.ts

@@ -406,9 +406,9 @@ export default function (interpretador: VisitanteComumInterface, pilhaEscoposExe
             const resultados = [];
             for (let indice = 0; indice < valorVetor.length; ++indice) {
                 const deveRetornarValor = await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
-                if (deveRetornarValor) {
-                    resultados.push(valorVetor[indice]);
-                }
+                if (deveRetornarValor === false) continue;
+
+                resultados.push(valorVetor[indice]);
             }
 
             return resultados;

fontes/interpretador/interpretador-base.ts

@@ -1605,6 +1605,11 @@ export class InterpretadorBase implements InterpretadorInterface {
             return objeto ? 'verdadeiro' : 'falso';
         }
 
+        if (objeto instanceof RetornoQuebra) {
+            if (typeof objeto.valor === 'boolean')
+                return objeto.valor ? 'verdadeiro' : 'falso';
+        }
+
         if (objeto instanceof Date) {
             const formato = Intl.DateTimeFormat('pt', {
                 dateStyle: 'full',
@@ -1616,11 +1621,11 @@ export class InterpretadorBase implements InterpretadorInterface {
         if (Array.isArray(objeto)) {
             let retornoVetor: string = '[';
             for (let elemento of objeto) {
-                retornoVetor += `${this.paraTexto(elemento)},`;
+                retornoVetor += typeof elemento === 'string' ? `'${elemento}', ` : `${this.paraTexto(elemento)}, `;
             }
 
             if(retornoVetor.length > 1){
-                retornoVetor = retornoVetor.slice(0, -1);
+                retornoVetor = retornoVetor.slice(0, -2);
             }
             retornoVetor += ']';
 

testes/biblioteca-global.test.ts

@@ -159,7 +159,7 @@ describe('Biblioteca Global', () => {
     });
 
     describe('todosEmCondicao()', () => {
-        it('Sucesso', async () => {
+        it('Sucesso - todosEmCondicao', async () => {
             const codigo = [
                 "var f = funcao(x) { retorna(x < 10) }",
                 "escreva(todosEmCondicao([1, 2, 3, 4, 5, 6], f))"
@@ -172,6 +172,25 @@ describe('Biblioteca Global', () => {
             expect(retornoInterpretador.erros).toHaveLength(0);
         });
 
+        it('Sucesso - filtrarPor', async () => {
+            const codigo = [
+                "var valoresLogicos = ['verdadeiro', 'falso', 'falso', verdadeiro, 'falso', 'verdadeiro']",
+                "var f = funcao(valor) { retorna valor == 'verdadeiro' ou valor == verdadeiro }",
+                "var valoresVerdadeiros = filtrarPor(valoresLogicos, f)",
+                "escreva(valoresVerdadeiros)"
+            ];
+            const retornoLexador = lexador.mapear(codigo, -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+            interpretador.funcaoDeRetorno = (saida: any) => {
+                expect(saida).toEqual('[\'verdadeiro\', verdadeiro, \'verdadeiro\']');
+            };
+
+            const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+            expect(retornoInterpretador.erros).toHaveLength(0);
+        });
+
         it('Falha - Funçao de mapeamento inválida', async () => {
             const codigo = [
                 "var f = 'Sou uma função'",

testes/interpretador/interpretador.test.ts

@@ -1129,7 +1129,7 @@ describe('Interpretador', () => {
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual('[1,2,3]');
+                        expect(saida).toEqual('[1, 2, \'3\']');
                     };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -1151,7 +1151,7 @@ describe('Interpretador', () => {
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual('[Olá,mundo]');
+                        expect(saida).toEqual('[\'Olá\', \'mundo\']');
                     };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -1170,7 +1170,7 @@ describe('Interpretador', () => {
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual('[maçã,banana,morango]');
+                        expect(saida).toEqual('[\'maçã\', \'banana\', \'morango\']');
                     };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -1383,8 +1383,8 @@ describe('Interpretador', () => {
 
                         expect(retornoInterpretador.erros).toHaveLength(0);
                         expect(saidas).toHaveLength(2);
-                        expect(saidas[0]).toEqual('[a,b,c]');
-                        expect(saidas[1]).toEqual('[1,2,3]');
+                        expect(saidas[0]).toEqual('[\'a\', \'b\', \'c\']');
+                        expect(saidas[1]).toEqual('[1, 2, 3]');
                     });
                 });
 
@@ -1403,7 +1403,7 @@ describe('Interpretador', () => {
                         const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                         interpretador.funcaoDeRetorno = (saida: string) => {
-                            expect(saida).toEqual('[12,8,4,2]');
+                            expect(saida).toEqual('[12, 8, 4, 2]');
                         };
 
                         const retornoInterpretador = await interpretador.interpretar(

testes/primitivas/primitivas-vetor.test.ts

@@ -1,5 +1,10 @@
 import primitivasVetor from '../../fontes/bibliotecas/primitivas-vetor';
+import { Binario, FuncaoConstruto, Literal, Logico, Variavel } from '../../fontes/construtos';
+import { Retorna } from '../../fontes/declaracoes';
+import { DeleguaFuncao } from '../../fontes/estruturas';
 import { InterpretadorBase } from '../../fontes/interpretador';
+import { Simbolo } from '../../fontes/lexador';
+import tiposDeSimbolos from '../../fontes/tipos-de-simbolos/delegua';
 
 describe('Primitivas de vetor', () => {
     let interpretador: InterpretadorBase;
@@ -32,6 +37,52 @@ describe('Primitivas de vetor', () => {
         });
     });
 
+    describe('filtrarPor()', () => {
+        it('Trivial', async () => {
+            const deleguaFuncao = new DeleguaFuncao(
+                'qualquernome', 
+                new FuncaoConstruto(
+                    -1,
+                    -1,
+                    [{
+                        abrangencia: 'padrao', 
+                        nome: new Simbolo(tiposDeSimbolos.IDENTIFICADOR, 'valor', null, -1, -1)
+                    }],
+                    [
+                        new Retorna(
+                            new Simbolo(tiposDeSimbolos.RETORNA, 'retorna', null, -1, -1),
+                            new Logico(-1, 
+                                new Binario(
+                                    -1,
+                                    new Variavel(-1, 
+                                        new Simbolo(tiposDeSimbolos.IDENTIFICADOR, 'valor', null, -1, -1)    
+                                    ),
+                                    new Simbolo(tiposDeSimbolos.IGUAL_IGUAL, '==', null, -1, -1),
+                                    new Literal(-1, -1, 'verdadeiro'),
+                                ),
+                                new Simbolo(tiposDeSimbolos.OU, 'ou', null, -1, -1),
+                                new Binario(
+                                    -1,
+                                    new Variavel(-1, 
+                                        new Simbolo(tiposDeSimbolos.IDENTIFICADOR, 'valor', null, -1, -1)    
+                                    ),
+                                    new Simbolo(tiposDeSimbolos.IGUAL_IGUAL, '==', null, -1, -1),
+                                    new Literal(-1, -1, true),
+                                )
+                            )
+                        )
+                    ]
+                )
+            );
+            const resultado = await primitivasVetor.filtrarPor(
+                interpretador, 
+                ['verdadeiro', 'falso', 'falso', 'verdadeiro', 'falso', 'verdadeiro'], 
+                deleguaFuncao
+            );
+            expect(resultado).toStrictEqual(['verdadeiro', 'verdadeiro', 'verdadeiro']);
+        });
+    });
+
     describe('inclui()', () => {
         it('Trivial', async () => {
             const resultado = await primitivasVetor.inclui(interpretador, [1, 2, 3], 3);