📝 adds a bit of info about lambdas, formatting

Author: PoorlyDefinedBehaviour

docs/tutorial/secao83.md

@@ -3,11 +3,11 @@
 Recursão é um conceito não exclusivo do C++, onde uma função chama a si mesma até que uma condição seja alcançada.
 
 Tudo que pode ser resolvido por loops, pode ser resolvido por recursão.
-Tudo que pode ser revolsido por recursão, pode ser revolsido por loops.
+Tudo que pode ser resolvido por recursão, pode ser resolvido por loops.
 
-Por que usar recursão?
+Por que usar recursão? Legibilidade.
 
-Legibilidade, algumas soluções são mais fáceis de serem expressadas por recursão.
+Algumas soluções são mais fáceis de serem expressadas por recursão.
 Assim como outras são mais fáceis através de loops.
 
 # Exemplos

docs/tutorial/secao84.md

@@ -1,14 +1,19 @@
 # 8.4 - Funções Lambda
 
-Funções lambda foram implementadas no C++11 e versões posteriores, onde podemos declarar objetos de funções em forma anônima, podendo ser utilizada em contextos assíncronos.
+Funções lambda foram implementadas no C++11 e versões posteriores, onde podemos declarar objetos de funções em forma anônima, normalmente utilizadas quando precisamos de uma função que não precisará existir após ser utilizada.
 
 Sintaxe:
+`[]() -> T {}`
 
-`[]() {};`
+CAPTURAS `[]` <br/>
+PARÂMETROS `()` <br/>
+TIPO DO RETORNO `-> T` <br/>
+CORPO DA FUNÇÃO `{}`
 
-Chamamos uma função lambda como: `nome_variavel()`
+Chamamos uma função lambda da mesma forma que chamamos uma função normal: `nome_variavel()`
 
 Exemplo:
+
 ```cpp{0}
 #include <iostream>
 #include <cstdlib>
@@ -24,10 +29,7 @@ int main(int argc, const char **argv)
 
     int a(3), b(5);
 
-    /* auto significa irá idenficar o que se retorna ou o que é associavel
-     * neste caso precisamos utilizar auto,pois soma se associa com: class lambda[] int (int n1, int n2) -> int
-     * Iremos ter uma seção específica apenas para a keyword auto, não se preocupe com isso.
-     */
+    /* Quando criamos uma lambda, precisamos usar 'auto', pois o tipo de cada função é único. */
 
     auto soma = [](int n1, int n2) {
         return n1 + n2;
@@ -48,15 +50,15 @@ auto func()
 }
 ```
 
-Também podemos fazer lambda localmente para executar um determinado procedimento
+Também podemos criar lambdas que são executadas imediatamente. Esse tipo de função é conhecido como IILE(Immediately Invoked Lambda Expression) ou IIFE(Immediately Invoked Function Expression)
 
 Exemplos:
 
 ```cpp{0}
 #include <iostream>
 #include <cstdlib>
 
-int main(int argc,const char **argv) 
+int main(int argc,const char **argv)
 {
   /*|--------------------------------------|
    *|                                      |
@@ -70,11 +72,12 @@ int main(int argc,const char **argv)
     return EXIT_SUCCESS;
 }
 ```
+
 ```cpp{0}
 #include <iostream>
 #include <cstdlib>
 
-int main() 
+int main()
 {
     /*|--------------------------------------|
      *|                                      |
@@ -92,4 +95,4 @@ int main()
 
     return EXIT_SUCCESS;
 }
-```
+```