Nesta aula nós vamos aprender a fazer um Unfclosure, a função que retorna a outra função e essa outra função que é retornada da função tem acesso às variáveis da função exterior. Se confundiu de tanta função retornando a função, então vamos ver um exemplo. Vamos criar uma função, essa função, vou escrever aqui func, chamar ela de adicionador. Essa função aqui, adicionador, tem como entrada nenhum parâmetro, mas vai retornar uma função como valor de saída. Essa função vai ter que vai ser retornada, vai ter como entrada um inteiro e vai retornar outro inteiro. Mas o que é que essa função vai fazer? Então nós vamos criar uma função para retornar outra função e essa outra função, cada vez que a gente chamar, a gente pode adicionar o valor de entrada a uma soma. A gente vai acumular uma soma. É como se fosse fazer aquele loop da soma de algumas coisas. Nesse caso a gente vai adicionar a uma soma que começa do zero, sempre que chamar a função retornada pelo adicionador. Então para começar, vamos definir uma variável aqui, soma do tipo inteiro que vai ter o valor zero. Essa variável começa do zero e o adicionador, quando for chamado, vai iniciar soma para zero e vai retornar a uma função. Essa função leva como argumento um inteiro, vou chamar o valor de, sei lá, a, que é um inteiro e vai retornar o valor int. E essa função aqui de dentro vai pegar e fazer o seguinte, vai pegar a e vai adicionar o valor da soma. Vou chamar a soma. Então a soma vai ser igual a soma mais o valor de a. E a gente pode retornar essa nova soma como valor int. Então vamos ver aqui. Se eu chamar adicionador, nós vamos bater aqui, vai definir soma como zero, a variável local ao adicionador e vai retornar uma função. Essa função aqui. Então vamos armazenar essa função aqui. Vamos chamar ad1, variável ad1, que é o tipo que, função, mas eu não vou dizer explicitamente, vou deixar implícito. Agora, se eu chamar ad1, a gente vai chamar essa função aqui, que é retornada. Essa função leva um argumento que é o a. Vamos, por exemplo, se eu adicionar 21, ele vai chamar essa função de dentro, que já está armazenado em ad1. O a vai ser 21, soma é igual a soma mais 21, zero mais 21 é 21 e vai retornar a soma. Então vamos dar o fmt.println desse valor retornado para ver no que dá. 21, tá? Agora o que acontece é continuar chamar ad1 várias vezes. No próximo chamado, vou chamar de novo ad1 com o valor 13. Olha o que acontece agora. Agora o soma dá 34, vira o 34. Note um detalhe aqui que o som é um variável que é declarado fora dessa função, fora aqui. Na verdade, é no scopo do adicionador, mas o adicionador já foi chamado aqui anteriormente e a gente só retornou essa função de dentro. Não é mais o adicionador de fora que a gente chama quando a gente fala ad1, ad1. Então isso é um exemplo de uma closure, chamada closure de uma função, em que a função que é retornada referencia variáveis de fora da função, nesse caso a variável soma. Ele pode manipular a soma e arreta e buir valores e ainda vai continuar lá, permanece definida, embora que o adicionador já tenha sido chamado, essa função, somente uma vez na linha 15 aqui. Então você pode usar isso para criar vários tipos de adicionadores. Isto é, se eu criar um novo variável chamado ad2 e chamar adicionador, ele vai criar uma nova soma que não é igual a soma do ad1. Olha aqui, se eu dizer fmt println ad2 e eu passar 7, vamos ver aqui. Esperamos que o valor seja 7, legal. Deixe-me adicionar um delimitador aqui, duas raspas. Para poder separar os dois. Então 7. Agora se eu dar o println do ad1 e não quiser adicionar nada, zero, tá? Olha aqui, a soma ainda está 34 para o ad1, embora que eu adicionei 7 para o ad2. Então, essas variáveis soma, embora tenha o mesmo nome, soma é diferente para o ad1 e é diferente para o ad2. Então com isso criamos dois tipos de adicionadores diferentes. E eles, ambos, chamam adicionador que retorna a função, com a soma começa do zero, mas essa variável pode ser usada de dentro da função como um enclosure. Tá bom? Então vamos revisar o que aprendemos. Aprendemos a criar uma closure, função de closure, né? Isto é uma função que retorna a função e da função retornada, referenciamos variáveis declaradas e definidas exteriormente, né? Lado de fora da função, nesse caso, soma é definida fora da nossa função retornada. E a gente ainda pode referenciar esse valor e ainda atribuir novos valores de dentro dessa função. Embora que o adicionador não seja mais chamada depois da primeira vez. Quando a gente chama adicionador, cada vez vai criar um scopo de uma nova variável soma. Isto é, se eu tiver ad1 variável que for definida como a chamada de adicionador e ad2, outra variável também com a chamada, mesmo chamado de adicionador, eles não irão compartilhar a mesma soma. Isto é, serão somas diferentes. E cada um vai começar do zero e você pode adicionar e formar somas diferentes, tá? Está aqui o assinatura retorna, a função adicionador retorna a função. E para essa aula é só e até a próxima.