souenzzo

;; escreva uma função que recebe o listas e simbolos como argumento,
;; e faca as transformacoes
(defn my-with-open-fn
  [bindings body]
  `(let ~bindings
     (try
       ~@body
       (finally
         ~@(for [v (map first (partition-all 2 bindings))]
             `(.close ~v))))))

souenzzo

(-> (js/fetch "/api.json")
  (.then (fn [response]
           ;; I can access the response/headers, but can't access the json/body. :(
           (.json response)))
  (.then (fn [json]
           ;; I can access the json/body, but can't access the response/headers. :(
           ...)))

(-> (js/fetch "/api.json")

souenzzo

(require '[io.pedestal.http :as http]
  '[io.pedestal.test :refer [response-for]]
  '[clojure.java.io :as io]

  ;; clojure.data.json isn't fast. 
  ;; if you need speed, look at cheshire
  '[clojure.data.json :as j])
(let [get-lazy-vs (fn []
                    ;; just a dummy lazy get function
                    ;; it takes 100ms to get each element

souenzzo

(ns build
  (:require [clojure.tools.build.api :as b]
            [shadow.cljs.devtools.api :as shadow.api]
            [shadow.cljs.devtools.server :as shadow.server]
            [cheshire.core :as json]
            [clojure.java.io :as io]
            [clojure.string :as string])
  (:import (org.apache.commons.compress.archivers ArchiveStreamFactory)
           (java.util.zip GZIPInputStream CheckedInputStream Adler32)
           (java.security MessageDigest DigestInputStream)

souenzzo

(defn select-as
  [value query]
  (letfn [(selector [{:keys [children]
                      :as   node}
                     value]
            (cond
              (map? value) (into {}
                             (keep (fn [{:keys [key params]
                                         :as   node}]
                                     (when-let [[_ v] (find value key)]

souenzzo

How to turn your sync API into an async one

Let's suppose that you have a sync API send

(send params)

This API has at least 2 behaviors:

1. Return a value
2. Throw an exception

souenzzo

(def spy-plugin
  {::pc/wrap-resolve (fn [resolve]
                       (fn [env input]
                         (let [resolver-sym (-> env ::pc/resolver-data ::pc/sym)
                               _ (prn {:sym    resolver-sym
                                       :input  input
                                       :entity (p/entity env)})
                               output (resolve env input)]
                           (prn {:sym    resolver-sym
                                 :output output

souenzzo

Função promover/rebaixar (parte 1)

Dado uma coleção coll, por exemplo, [:a :b :c :d :e] e um predicado pred, por exemplo #{:c}, implementar uma função promover que recebe (promover #{:c} [:a :b :c :d :e]) e retorna a coleção com o elemento selecionado "uma posição a frente": [:a :c :b :d :e]

Implementar também a função rebaixar, com a mesma assinatura, porém resulta em [:a :b :d :c :e]

Os casos de borda (elementos repetidos, agrupamentos degenerados) não são importantes.

souenzzo

(ns digital-wallet.main-test-old
  (:require [clojure.test :refer [deftest]]
            [midje.sweet :refer [fact =>]])
  (:import (clojure.lang ILookup)
           (java.lang AutoCloseable)
           (java.util Properties)
           (org.apache.kafka.common.serialization Serdes Serdes$StringSerde Serdes$LongSerde)
           (org.apache.kafka.streams TopologyTestDriver StreamsConfig Topology KeyValue)
           (org.apache.kafka.streams.processor.api ProcessorSupplier Processor ProcessorContext Record)
           (org.apache.kafka.streams.state Stores KeyValueStore)

souenzzo

(ns eql-hodur
  (:require [edn-query-language.core :as eql]
            [clojure.spec.alpha :as s]
            [datascript.core :as ds]))

(defn add-prop
  [prop {:keys [children]
         :as   node}]
  (if (contains? node :children)
    (assoc node