O que é uma função pura?
Bem, uma função pura se parece com isso, nós temos uma função, então ao invés de uma caixa que tínhamos antes
de objetos com todas essas funcionalidades, pense nisso apenas como uma função simples.
E digamos que forneçamos uma lista contendo um, dois e três.
Se dermos essa entrada a esta função, o que esperaríamos de uma função pura é que algo aconteça
a essa entrada que sempre resulta na mesma coisa.
Digamos que multipliquemos isso por dois, receberíamos dois, quatro e seis.
Agora, uma função pura tem duas regras.
Uma é que dada a mesma entrada, sempre retornará a mesma saída, ou seja, toda vez que atribuímos um, dois e
três a essa lista, atribuímos a uma função que criamos.
Deve sempre retornar a mesma saída.
Portanto, se eu executar essa função milhões de vezes com a mesma entrada, ela deve resultar na mesma saída.
E o segundo ponto é que essa ideia de função não deve produzir efeitos colaterais.
Quais são os efeitos colaterais?
Os efeitos colaterais são coisas que funcionam.
Isso afeta o mundo exterior?
Por exemplo, se eu fosse imprimir algo dentro desta função, isso afetaria o mundo externo, certo?
Porque estou imprimindo algo em uma tela.
A tela é o mundo exterior.
Ou, por exemplo, se esta função estava tocando uma variável que vivia fora de um escopo diferente, isso é
um efeito colateral.
Vamos dar uma olhada.
Um código para entender um pouco mais esse conceito.
Digamos que temos uma função e essa função se multiplica.
Por para uma lista, então vamos apenas dizer um aliado, que será a nossa lista, e aqui o que queremos fazer
é repetir o item.
No ultimo.
E então cada item que queremos multiplicar e anexar a uma nova lista.
Portanto, vamos criar uma nova lista que será uma lista vazia.
E aqui, vamos dizer nova lista, ponto apêndice.
E multiplique por dois.
E finalmente, no final desta função, queremos retornar a nova lista.
Vamos dar uma chance.
Se eu disser multiplique por dois e dê um, dois, três e vamos imprimir.
Aqui, a saída.
Se eu clicar, corra.
Eu tenho dois, quatro, seis.
Esta é uma função pura, vamos pensar sobre isso.
A primeira regra dá a mesma entrada, ou seja, um, dois e três.
Ele sempre retornará a mesma saída, não importa quantas vezes eu execute isso, sempre vai me
dar a mesma saída.
Então, OK, passamos no primeiro teste.
E o segundo teste que não produz efeitos colaterais?
Isso produz efeitos colaterais?
Isso afeta alguma coisa no mundo exterior?
Pense nisso.
Não, ele não escreve nada do mundo externo importa para esta função.
Porque tudo está contido aqui.
Se, por exemplo, em vez de imprimir aqui, simplesmente temos imprimir.
E aqui.
Se eu clicar, corra.
Obtemos a mesma saída, mas isso tem efeitos colaterais?
Bem, sim, é verdade.
Ele interage com o mundo exterior, que é a declaração impressa.
A declaração de impressão me diz, ei, vou imprimir em qualquer tela que esta máquina tenha.
Em nosso caso, ele será impresso aqui, mas não sabemos realmente o que a instrução print faz porque
ela interage com a tela deste lado.
Então, é isso.
Efeitos colaterais, damos controle à impressão, mas não sabemos o que ela fará.
Outro exemplo que posso dar.
Será isso o que acontecerá se tivermos uma nova lista aqui que realmente definirmos do lado de fora?
Igual a.
Para que tenhamos uma nova lista como esta, se eu clicar em executar.
Ainda chego a quatro, seis, mas isso tem efeitos colaterais?
Bem, sim, é verdade.
Ele interage com o mundo exterior e o que está fora desse mundo de uma função
que lembre, é o escopo, bem, ele interage com essa nova lista.
Acontece com essa nova lista.
Portanto, se um programador aparece e talvez antes de executarmos esta função, decidimos dizer nova lista.
Nós mudamos para uma string vazia.
Bem, quando eu executo esta função.
Recebo um erro porque agora esta nova lista é um objeto de string.
Então a nova lista que mora no mundo externo desta função pode ser modificada por outro desenvolvedor ou por
um programa e não saberíamos sobre isso.
E quando executarmos essa função, ocorrerá um erro.
Isso tem um efeito colateral.
Então, idealmente, contemos nossas funções.
E torná-los puros, porque, como você pode ver, nunca teremos um bug ou um erro em nosso código a menos que
escrevamos algo errado aqui, mas porque não nos importamos com o mundo exterior, porque tudo
que nós dar como entrada sempre vai produzir um bom resultado, vai ser puro.
Agora, é difícil entender por que esse conceito é tão poderoso sem ter um pouco de experiência no local de
trabalho.
Mas deixe-me apenas dizer uma coisa, quando você tem funções puras.
Você tem menos código com erros, é capaz de testá-lo melhor.
É mais fácil entender seu código e no geral.
Você tem os benefícios de não ter partes diferentes de seu código, tocando umas às outras e afetando umas
às outras, o que torna sua vida como programador muito mais fácil.
Portanto, essa ideia de funções puras é muito importante.
Mas a única coisa que quero que você descubra isso é que funções puras são mais uma diretriz do
que um absoluto.
É impossível ter funções puras em todos os lugares, porque se uma função não afeta o mundo exterior de
forma alguma, bem, não teríamos nenhum programa.
Não seríamos capazes de exibir coisas.
Não poderíamos salvar coisas como nosso perfil de jogo.
Portanto, é impossível ter funções puras em todos os lugares.
No entanto, quando você pode onde quer que você possa, a programação funcional nos ensina que suas funções são boas.
Tente criar funções puras e ter apenas algumas funções não puras que talvez interajam com o mundo
exterior para as quais possamos voltar sempre que tivermos bugs em nosso código, porque provavelmente
esses são os que terão bugs e funções puras como isso para finalizar nosso conceito de programação funcional.
Se, por exemplo, este fosse o nosso assistente dos vídeos anteriores com programação funcional, teríamos
um objeto assistente.
Ou o dicionário Wizzard que tinha nome.
Digamos Marlon.
E poder.
De 50.
E em vez de contê-los em uma classe, eu teria métodos diferentes, como ataque.
E isso não seria um método, seria uma função porque não mora dentro de uma classe.
Na programação funcional, eles dizem, ei, não precisamos combinar dados com funções, vamos mantê-los
separados, vamos apenas criar funções puras que podem ser passadas como um caractere.
E, dessa forma, mantemos essas duas coisas separadas para que possamos nos concentrar em funções puras e nos
dados, então é aí que está a diferença.
No final do dia, trata-se de tentar manter nosso casaco limpo e evitar bichos em nosso casaco, um grande
problema que os programadores têm o tempo todo.
Portanto, é apenas uma maneira diferente de pensar.
Vamos aprender mais no próximo vídeo.