Enzzo 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:

Return a value
Throw an exception

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.

	;; 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))))))


	(-> (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")

	(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

	(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)

	(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)]

	(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

	(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)

	(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