Clojurians Log v2

Eu aprendi sobre fnil e letfn outro dia, achei massa

Ele mês passado, do nada, fez o Merge de uma porrada de coisa e agora parece que não está conseguindo compilar e subir a versão que está na master no host dele pelo que entendi da nota dele aqui: https://github.com/zk/clojuredocs/blob/master/.notes.zk.org#2023-07-24-mon-1014

Eu até comecei a fazer um novo, separei a stack em um cara pra extrair definições de função e documentação em um datalevin, um backend pra gerir a parte social e consultar coisas do datalevin e um front. Eu fiz o extrator e estou no meio do backend, mas estou fazendo just for fun nem sei se minhas decisões foram as melhores na real

hahah ja parece menos enrolado que o original 👀

https://github.com/clj-codes/ Tá tudo bem wip aí se alguém tiver curiosidade, estou andando bem devagar btw, é mais pra estudo e desafio do que mais nada

Outro uso legal:

(-> 3
  inc 
  (doto clojure.pprint/pprint) 
  dec)

ou mesmo:

(-> 3
  inc
  (->> (def _x) deref)
  dec)

vai crescendo junto com o nivel de desespero

(-> 3
  inc
  (doto (as-> %
          (def _x %)
          (prn %)
          (tap> %)))
  dec)

Sobre o as->: ele suporta desconstruição no bind do simbilo. por favor não use!

(-> {}
  (assoc-in [:a :a :a] 3)
  (as-> {:keys [a]} a a a)
  identity)
=> 3

> Outro uso legal: @souenzzo me perdi, não entendi sobre o que vc ta falando 😅 pode me explicar? 🙏

é possivel compor as macros -> ->> as-> cond-> doto ... etc por exemplo, quando vc está em um ->, no meio da cadeia de funcoes, as vezes vc quer colocar um print, sem comprometer o retorno algumas libs de log implementam o log/spy que faz isso Mas é possivel também compor o (-> ... (doto prn) ...) para obter o mesmo resultado

So pode uma ? 😛 clojure.core/comp , clojure.core/complement e clojure.core/interpose

clojure.core/iteration

clojure.core/interpose parece bem interessante! hahah não conhecia

@eduardomrb é iteration mesmo? ou iterate?

@arthurfucher iteration mesmo; relativamente nova, veio com clojure 1.11

clojure.core/iteration [step & {:keys [somef vf kf initk] :or {vf identity kf identity somef some? initk nil}}]

Creates a seqable/reducible via repeated calls to step,
a function of some (continuation token) 'k'. The first call to step
will be passed initk, returning 'ret'. Iff (somef ret) is true,
(vf ret) will be included in the iteration, else iteration will
terminate and vf/kf will not be called. If (kf ret) is non-nil it
will be passed to the next step call, else iteration will terminate.

This can be used e.g. to consume APIs that return paginated or batched data.

 step - (possibly impure) fn of 'k' -> 'ret'

 :somef - fn of 'ret' -> logical true/false, default 'some?'
 :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'
 :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'
 :initk - the first value passed to step, default 'nil'

It is presumed that step with non-initk is unreproducible/non-idempotent.
If step with initk is unreproducible it is on the consumer to not consume twice.

achei a api/doc do iteration ruinzinha hehe

hmmm procurei no https://clojuredocs.org/ e não achei 😕

o clojuredocs ta sem clojure 1.11 pq o mano nao ta mais mantendo, estamos tentando trazer pro clj-common https://clojurians.slack.com/archives/CE1A21MPF/p1688563409482329

gosto muito dessa combinação de transducers com juxt aqui: (into {} (map (juxt :id identity)) coll) o que faz: transforma uma coleção em um mapa, indexado pela chave :id

eu adoro juxt. pra mim é um fazedor de forma de tijolo. mto bom pra fazer planilha

juxt é um bagulho que eu preciso aprender mais pra ter no repertório

Mais uma função do dia: (find {:a 42} :a) => [:a 42] (find {:a 42} :b) => nil Bem util para quem usa datomic (transformar mapas em eid)

também é legal usar no if-let e tal

(if-let [[_ a] (find params :a)]
  "se a existir, mesmo que {:a nil}"
  "se a não estiver presente em params")