buondi'

salve

ciao

ehilà

buon lunedì 🙂

oss del weekend, ho implementato un aggregatore di blob per unrepl che prende i file sorgente, li ordina in dependency order and li concatena cosi' che unrepl possa eval-uarli. In piu' finalmente ho risolto un bacozzo storico in boot-figreload

Ho avuto il piacere di seguire la cosa in diretta, joinate #unrepl se curiosi 😄

un tl;dr su cos'e` unrepl?

e che relazione ha con nREPL/socket-repl

@bronsa e' un'alternativa a nRepl, che viaggia su socket-repl, dove praticamente le varie "feature" sono mandate tramite blob (form edn) client side

i vari blob si auto-`eval`-uano

cosi' che le connessioni al REPL sono "indipendenti"

(stiamo ancora decidendo cosa fare se due client mandano lo stesso namespace in realta')

la stessa implementazione del protocollo unrepl e' mandata client-side

il minimo che serve e' qui: https://github.com/Unrepl/unrepl/blob/master/tasks/leiningen/unrepl_make_blob.clj

o meglio questo: (slurp "src/unrepl/print.clj") (slurp "src/unrepl/repl.clj") "\n(unrepl.repl/start)")

interessante, sta sera ci do un'occhiata

si, e' ancora agli albori mandare cose client-side e' una bella idea ma per esempio il primo eval e' (deve essere) blocking

praticamente l'extension model non e' ancora stato definito, ma si vorrebbe evitare il middleware di nRepl

il client attuale e' https://github.com/pesterhazy/unravel scritto con lumo

c'e' stato un talk a EuroClojure ma i video non sono ancora usciti

Namaste

(def x (/ 1. 0))
(def v [(/ 0. 0) (/ x x) (* 0 x) (- x x) (Math/pow 1 x) (Math/sqrt -1)])
(frequencies v)
{NaN 1, NaN 1, NaN 1, NaN 1, NaN 1, NaN 1}

sto pensando se ci sono altri modi di creare maps con chiavi duplicate

che poi questo qui sopra e' transient in azione

nah, transient non c'entra

e` NaN che compara <> a se stesso

user=> {(identity Double/NaN) 1 (do Double/NaN) 2}
{NaN 1, NaN 2}

mmh, pero' se non usi il trick di distinguirli a compile time il gioco non viene

(ti sto dando ragione)

si` certo, a read time le chiavi devono essere diverse

Ma transient permette questo:

user=> (def m (transient {}))
#'user/m
user=> (assoc! m Double/NaN 1)
user=> (assoc! m Double/NaN 1)
user=> (persistent! m)
{NaN 1, NaN 1}

dovrebbe funzionare anche con assoc normale

non credo, ora provo

user=> (assoc (assoc {} Double/NaN 1) Double/NaN 2)
{NaN 1, NaN 2}

ok, avevo confuso

se vuoi vederne una divertente,

user=> (let [a (array-map Double/NaN 1)] (assoc a (key (first a)) "foo"))
{NaN 1, NaN "foo"}
user=> (let [a (hash-map Double/NaN 1)] (assoc a (key (first a)) "foo"))
{NaN "foo"}

whoa, penso di non aver mai fatto caso a "key" senza la s

ho guardato un po' l'impl dei due assoc. Non ho trovato la risposta in tempi brevi, mi arrendo!

https://dev.clojure.org/jira/browse/CLJ-1792

ah... forse qualcosa di simile a quello che succede con var deref nel seguente

(def x Double/NaN)
(frequencies [x x])
;; {NaN 2}
(frequencies [Double/NaN Double/NaN])
;; {NaN 1, NaN 1}

piu` o meno, quello e` perche` x x comparano identical?

mentre Double/NaN e Double/NaN no