ah ah bellissimi 🙂

Buondì

Domandaccia: so che esistono repeat e repatedly ma è tanto brutto usare un reduce su un range?

Mi spiego meglio: leggo da un socket, il primo byte che mi arriva mi dice quanti elementi devo deserializzare dopo

mettiamo che ho 3 Integer da deserializzare: [3 0 0 0 1 0 0 0 2 0 0 0 3]

attualmente uso appunto un reduce

(datemi un attimo e vi fornisco un esempio)

(def b 
  (-> [3 0 0 0 1 0 0 0 2 0 0 0 3]
        byte-array
        java.io.ByteArrayInputStream.
        java.io.DataInputStream.))

(let [size (.readByte b)]
                 (reduce
                  (fn [acc _]
                    (conj acc (.readInt b)))
                  []
                  (range size)))

scusate l'indentazione

l'alternativa sarebbe:

(repeatedly (int (.readByte b)) #(.readInt b))

sicuramente più carina ma non so...

@mdallastella sceglierei quella che e' piu' leggibile ma qui c'e' un'altra differenza: repeatedly ritorna una lazy seq e quindi ha un comportamento assai diverso da reduce

la documentazione di repeatedly dice che consente side-effects

si, non dico di no..la mia osservazione e' diversa...volevo dire che dipende anche da come hai impostato il resto del codice e come vuoi effettuare la read...lazy or non lazy

silly example:

boot.user=> (def t1 (take 10 (repeatedly #(println "tst"))))
#'boot.user/t1
boot.user=> t1
tst
tst
tst
tst
tst
tst
tst
tst
tst
tst
(nil nil nil nil nil nil nil nil nil nil)

quindi la read la faresti lazy (il che pero' vuol dire che se nel frattempo ti chiudono il reader l'`InputStream` sei fregato)

io su I/O ci vado sempre non-lazy

@richiardiandrea quindi meglio il reduce

Mi scusassero, arrivo tardi sul thread. Lazy VS non-lazy dipende da come comunicano client-server. Se i chunk si scambiano una volta ogni tanto, allora puoi aprire lo stream sul socket, leggere e chiudere (qui sopra manca (.close b)). Se i chunk sono continui, allora ti conviene tenere aperto e creare una lazy-seq dei chunk in arrivo. La tua app diventa reactive a quel punto.

(defn chunks [b]
  (lazy-seq
    (cons
      (let [n (.read b)]
        (when (pos? n)
          (mapv (fn [_] (.readInt b)) (range n))))
      (chunks b))))

(def socket
  (-> [3 0 0 0 1 0 0 0 2 0 0 0 3] 
      byte-array 
      java.io.ByteArrayInputStream. 
      java.io.DataInputStream.))

(with-open [b socket] 
  (take-while seq (chunks b)))