Clojure na visão de um dev JS
Tags: javascript, clojure, lisp, programming
Published: 2022-07-21 02:09:07


![XKCD HQ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ub761gn88nlmy11ejszx.png)
## Por qual razão LISP (Clojure) ?

Tenho visto possivelmente depois de algum tempo aprendendo Orientação a Objetos, alguns limites desse paradigma e para ter uma mudança de ares busquei algo que resolvia alguns problemas de uma maneira diferente

Essa tirinha do xkcd é sempre atemporal, mesmo depois de muitos anos da existência do lisp, ainda acabamos por usar ele novamente, nesse caso com uma roupagem mais atual e um carro poderoso que quase todo o mundo usa. A JVM, todos sabemos o poder da JVM com paralelismo e concorrência, sendo o padrão de mercado faz um tempo. O Clojure junto da maquina virtual do java traz esse poder com a simplicidade de código como dado.

## Código é dado

Em lisp tudo é uma lista e entenda lista como Array. Outro ponto essencial é que por ser uma linguagem funcional, um dialeto de lisp, ele usa funções como seu core. Claro que você como dev JS já sabe o que isso implica, usar funções e callbacks, ter funções como retorno e usar funções como argumento.

### Como é isso dai de fazer função?

Em JS declaramos funções de varias formas, de maneira mais clara podemos fazer desse jeito:
o exemplo que farei é uma função que soma dois argumentos e retorna o resultado

```js
  function somar( a, b){
    return a + b
  }
```

agora em clojure:

```clojure
(defn somar
  "Recebe dois valores como parametro e retorna o resultado da soma"
  [a b]
  (+ a b))
```

Pontos super legais que eu amei no clojure, essa string que eu coloquei como segundo parametro é a documentação da função. <b>Código auto documentable </b>.
Somar e todas as funções matematicas seguem a <a href="https://pt.wikipedia.org/wiki/Nota%C3%A7%C3%A3o_polonesa">notação polonesa </a>

## E as variaveis ?

Na nossa tentativa de diminuir side effects criamos variaveis dentro de funções para mostrar o que significa cada simbolo.
Nesse exemplo a seguir eu criei algumas variaveis.

```clojure
(defn delivery-tax
  "Calculate the price of the delivery tax based on input based on this table:
   80 => $ -> 15
   80  < $ > 250 -> 5
   $ >=  250  -> 0"
  [final-items-value]
  (let [free-tax 0   ;;Variaveis
        mid-tax 5
        max-tax 15
        min-price-limit 80
        max-price-limit 250
        ]
    (cond
      (<= final-items-value 0) "err"
      (<= final-items-value min-price-limit) max-tax
      (and (> final-items-value min-price-limit) (< final-items-value max-price-limit)) mid-tax
      (>= final-items-value max-price-limit) free-tax)))
```

## Tem tudo isso de parenteses mesmo ?

Você coda JS, o que você vê em um dia de parenteses e colchetes é pouco comparado ao código em clojure.
mas por ser apenas parenteses, ganhamos alguns super poderes, como os de macro e gostaria de finalizar o blog-post com dois macro engraçados que  mostram o poder da linguagem.
A função some em clojure e outras muitas langs, pegam um array e verificam se algum valor está presente no array como nesse caso aqui

```clojure
(some #(= 5 %) [1 2 3 4 5])
=> true
```

podemos alterar via macro para que essa mesma função some (rs) todos os resultado do array

```clojure
(some [1 2 3 4 5])
=> 15
```

Por fim posso fazer o some literalmente sumir com meu array se eu quiser mudar a macro

```clojure
(some [1 2 3 4 5])
=> []
```

essa simples introdução ao Clojure era algo que eu queria ter visto antes e teria me deixado mais animado ainda para codar nisso que é tão simples e tão divertido ao mesmo tempo.

recomendo a todos que tal como eu estavam meio cansado do mesmo de sempre.