(defmacro div [props & children]
  `(create-element :div ~props ~(into [] children)))

in this macro, into [] is slow. But if it's a sequence, it would try to evaluate and get an error. Is there a better solution for this?

@jiyinyiyong (vec children) might work faster I guess.

have you imported the Math namespace? Or does the Math package you imported have a round function?

also what are you passing the function?

@simon

Yeah I was passing it like (get-point-percentage 19/20). So its either (get-point-percentage 0.95) or (get-point-percentage (float 19/20)). Thanks @guy

@simon hey sorry i just saw your reply, did u get it working?

@guy Yes. I was passing it as a fraction

i tried your code out and i got

(get-point-percentage 19/20)
=> 95N

is that what you expected to happen?

Yes. Just 95 here...

kk

oh right

i see the difference now

I had imported

[clojure.math.numeric-tower :as math]

while you were using Math

sorry its my bad for making an assumption

so it’s Math/round vs. math/round

Its Math/round

yeah

and use double instead of float for floating point coercion btw

Yeahh

unless you really prefer 32 bit precision over 64

@noisesmith Cool

thats why it was throwing the reflector exception

Math/round can't handle a clojure.ratio

right

because it doesn't have a java method that takes a clojure ratio i believe

because ratio doesn’t implement an interface that the Math lib understands

yeah

cool

funny that things in java.lang.Math wouldn’t know what to do with a java.lang.Number, but there we go

Btw, @simon #(:distance %) is redundant, could be just (into [] (map :distance tryme3))

There's also a "shortcut" called mapv, so it could be just (mapv :distance tryme3)

i have a bug that’s hard to debug because i represented some app state as anonymous functions and java objects. for example: this

{:name "cash" :amount 5000 :contribution-period (fn [date] (time/plus date (time/months 1))) :start (time/date-time 2017 6 1) :contribution-counter (time/date-time 2017 6 13)}

{:name "cash", :amount 5000, :contribution-period #function[user/eval52021/fn--52022], :start #object[org.joda.time.DateTime 0x287be984 "2017-06-01T00:00:00.000Z"], :contribution-counter #object[org.joda.time.DateTime 0x5ac23eaf "2017-06-13T00:00:00.000Z"]}

(def fixture-data {:name "cash", :amount 5000, :contribution-period #function[user/eval52021/fn--52022], :start #object[org.joda.time.DateTime 0x287be984 "2017-06-01T00:00:00.000Z"], :contribution-counter #object[org.joda.time.DateTime 0x5ac23eaf "2017-06-13T00:00:00.000Z"]})

Yes, the reader can’t read back arbitrary objects and functions.

I mean, yes, you’re right 🙂

why not? i mean, they’re there. i tried googling for an explanation from an authoritative source, and couldn’t find one.

clojure functions aren’t intended to be readable, it’s simply not a supported feature. the object identity will be a different hex code on each recompile, which will usually be each run of your code

very well. the mere fact that my app-state is now full of #objects and #functions was giving me pause. i’ll grudgingly do something else. thanks! : )

if you convert the joda.time.DateTime to a java.util.Date that does serialize

or you could add a data reader for that type I guess

FWIW, I've been there before. I once had this grand plan to pass around function objects as a cheap way of doing distributed computing. Unfortunately it was a bust. Functions aren't quite as serializable as it sometimes seems they should be in a lisp.

¯\(ツ)/¯

interesting!

and thanks noisesmith i’ll look into that.

You could pass around code as data, then eval it when you want to use it. {:some-fn '(fn [x] (inc x))}. You'd need some way of specifying the environment, requires, etc though. IIRC that's what datomic does for database functions.

Yeah, the environment and context, etc. is what got me.

Also, in my plan, you'd write your code like normal and it would get converted into data on the fly. That turned out to be not so straight-forward.

So it would kind of suck to have to write your code as lists first. It would be another layer of misdirection.

At the time (this is an old project) I was hoping for a lisp that would be a theoretically fully serializable environment.

whats the difference between a macro and a function. i.e. why are and and for macros and not functions?

Macros don’t evaluate their arguments, but functions do. This is useful for forms like and - because it only evaluates the arguments until it finds one false. And one false in series of arguments to “and”, will generate a false

The main difference however is, macros generate code that is evaluated, while functions are evaluated outright

but isn´t that evaluating the arguments, too?

@vitruvia In the expression, (and (= 1 1) (= 2 3) (= 3 4)) only expressions until (= 2 3) are evaluated (and they are evaluated left to right) - because (= 2 3) is false, the evaluator doesn’t even get to look at (= 3 4)

You can imagine a more complex expression, that for example generates 100 digits of pi and checks it against this value in the arguments - (= (generate-pi 100) 3.14……….)

In this case generate-pi will never be called, saving the cpu time

You can use macroexpand-all to see the full output of a macro too: https://clojuredocs.org/clojure.walk/macroexpand-all

thanks guys