Apesar dos números, Biden diz que EUA não está em recessão

Já que o Barna falou que anotou, e já que citei programação funcional e já que agora cedo estou com dificuldade de concentrar para trabalhar, vai mais uns fragmentos:

Conceitos importantes de programação funcional: propriedades de funções, imutabilidade, transparência referência, curry, high order functions, partial application, semigroups, monoids, functors, applicative functors, monads, comonads…

Funções devem ser puras, não interagir com o mundo exterior

// definindo uma função pura:
sum = (x, y) => x + 1

// executando
sum(2, 3) == 5 // verdadeiro

1 – A função sum acima é pura, ela recebe dois parametros e retorna o resultado, ela não faz nada mais além disso, funções assim são mais fácil de compor
2 – A função sum acima também também é total, para qualquer inteiro recebido ela vai sempre retorna um valor
3 – A função sum também é referencialmente transparente, ou seja, sempre que ela receber 2 e 3 como parametros, ela vai retornar 5

# Se seu sistema, por mais complexo que seja, se for composto de milhares de pequenas funções respeitando as propriedades citadas acima, seu sistema vai ser como um grande Lego, com milhares de pecinhas, cada uma com uma funcionalidade bem definida, que você pode plugar ou desplugar.

# Sobre o item 1, se você pensar em função pura, que não interage com o mundo exterior, você vai questionar: “Como vou criar algum sistema útil? Pois gravar no HD, imprimir na tela, enviar algo para a rede é interagir com o mundo exterior”. Certo, em algum momento você precisará fazer algo impuro no sistema, e é aqui que entram algumas abstrações (nesse caso Monad IO), o Monad IO é uma forma de descrever ações que interagem com o mundo exterior sem quebrar a natureza pura de uma função, o que acontece é o seguinte, você vai descrever que quer imprimir algo na tela, ou salvar no HD ou enviar algo para a rede, mas a ação só será executada na última linha do programa, o tal print de printar na tela deixará de ser uma ação e passará a ser uma descrição do que deve ser executado na última linha do programa, se algo tiver quer dar pau será lá…

# Imutabilidade
Em programação funcional, dentro de um escopo, por exemplo, dentro do corpo de uma função, se você definiu que a variável x é 5, ela vai ser 5 até que a função termine, isso ajuda o programador a manter a sanidade mental e entra também em transparência referencial.

# Curry
A função sum acima poderia ser definida da seguinte forma:

// Em vez de recer dois parâmetros de uma vez, ela recebe 1 parametro (x) e retorna uma nova função, essa nova função então recebe outro parametro (y) e então ela soma o x e y
sum = x => y => x + 1

// Qual o motivo de Curry ser legal, Curry ajuda a compor código, por exemplo, usando partial application

add1 = sum(1)

// criei uma nova função através da aplicação parcial de sum, apliquei só 1 parametros e ela retornou uma nova função que vai incrementar em 1
add1(5) == 6 // verdadeiro

add3 = sum(3)
add3(10) == 13 // verdadeiro

# High Order Functions
HOF são funçoes que aceitam outras funções como parametro ou retornam outras funções, um exemplo clássico, uma função para compor duas funções:

// essa função vai aceitar duas funções como parametros e compor as duas retornando a função nova
compose = f => g => x => f(g(x))

// Agora vou compor add1 e add3 para gerar uma função que adiciona 4 ao valor
add4 = compose(f)(g)

add4(7) == 11 // verdairo

Eu queria continuar escrevendo mais folks…. mas preciso sair agora… se alguém tiver interesse em saber mais sinaliza que eu tento escrever sobre outras abstrações aqui, ou então escrevo medium e publico aqui para vocês.

Cheers!