Clojurians
#clojure-italy
<
2017-05-31
>

This page is not created by, affiliated with, or supported by Slack Technologies, Inc.

reborg09:05:36

Burghenhall!

reborg12:05:53

1000 punti per la seguente:

(defn plus [x y] (+ x y))
(defn plus2 [y] (plus 2 y))
(plus2 5) ;; 7

;; plus2 is based on plus
(with-redefs [plus (constantly 0)] (plus2 5)) ;; 0

(defn plus3 [y] (inc (plus2 y)))
(plus3 5) ;; 8

;; plus3 is based on plus2 (which is based on plus)
(with-redefs [plus (constantly 0)] (plus3 5)) ;; 1

(def plus4 (fn [x] (+ 2 (plus2 x))))
(plus4 5) ;; 9

;; plus4 is based again on plus2 (which is based on plus)
(with-redefs [plus (constantly 0)] (plus4 5)) ;; 2

(def plus5 (fn [x] (plus x 5)))
(plus5 5) ;; 10

;; plus5 is based directly on plus with anon fn indirection
(with-redefs [plus (constantly 0)] (plus5 5)) ;; 0

(def plus6 (partial plus 6))
(plus6 5) ;; 11

;; plus6 is based on partial, which uses the anon fn indirection
(with-redefs [plus (constantly 0)] (plus6 5)) ;; 11
Perche' with-redefs smette di funzionare con partial?

bronsa16:05:09

resolution a definition time vs resolution a use time

reborg16:05:31

500 punti. C'e' un mix di resolution tra plus1-6

reborg16:05:06

Non posso darti gli altri 500 se non mi spieghi qual e' definition e qual e' use :slightly_smiling_face:

reborg16:05:32

(io faccio fatica a capire)

bronsa16:05:52

plus 2 to 3 essenzialmente non hanno grosse differenze, nonostante le varie indirezioni, plus non viene mai catturato in un environment esterno al body di ciascuna definizione, quindi with-redefs ha effetto

bronsa16:05:21

plus6 e` l'unico diverso, ed e` sostanzialmente equivalente a (let [plus plus] (fn [x] (plus 6 x)))

bronsa16:05:31

i.e. in plus6 il linking e` a una variabile locale inizializzata a plus che viene catturata, invece di un linking alla var plus stessa

reborg17:05:00

mmh, sto metabolizzando... grazie

reborg17:05:39

partial e' essenzialmente (defn partial [f arg1] (fn [x] (f arg1 x))) quindi mi stai dicendo che quando passo "f" come parametro in quel momento viene risolta f

bronsa18:05:18

si`, f viene closed over la funzione ritornata

bronsa18:05:01

pensa alla differenza tra (let [x x] (fn [] x)) e (fn [] x), con x una var (nel secondo x e` la var e viene dereffata a ogni invocazione, nel primo la var viene dereffata solo una volta e il valore viene catturato dentro al corpo della funzione)

bronsa18:05:25

poi l'intuizione e` che non c'e` differenza tra quel let e ((fn [x] (fn [] x)) x)

bronsa18:05:45

che se squinti e` isomorfo a come e` definito partial

bronsa18:05:02

e` molto piu` complicato da spiegare in modo semplice di quanto lo sia effettivamente :)