user=> (def r (doall (range 1e+7)))
#'user/r
user=> (let [v (vec r)]
  #_=>   (time (last v))
  #_=>   (time (last r)))
"Elapsed time: 387.154079 msecs"
"Elapsed time: 157.53812 msecs"
9999999
user=> (let [v (vec r)]
  #_=>   (time (last r))
  #_=>   (time (last v)))
"Elapsed time: 277.38866 msecs"
"Elapsed time: 559.517154 msecs"
9999999

I realized range, so that I really deal on the data instead of the realization. However, using last on a list seems to be way faster than on the preallocated vector . Does anyone have an explanation for that?

On the contrary - last doesn't check its argument's concrete type, so it traverses the whole structure. What's faster for vectors is peek.

Oh! So I misunderstood. Then why is it much slower to traverse the vector?

https://gist.github.com/reborg/dc8b0c96c397a56668905e2767fd697f#why-cannot-last-be-fast-on-vector

Btw by using 1e+7 (a double) you get the nonoptimized version of range that works on longs

you also want to run these many times to avoid jvm jit effects

I’m expecting that the wild variations in time are due to the JVM effects. https://github.com/hugoduncan/criterium is ideal for this (documentation on the page)

no

@U051GFP2V It seems that you can do it using jDeploy: https://www.jdeploy.com/docs/manual/#_runtime_arguments

jdeploy also serves a bit of a different purpose as its output isn't a jar file, which may be a dealbreaker in some usecases.

Main motivation would be a rough estimate of how much work it would take to port to clojure/script/dart/clojurl/jank-lang etc.

That feels like something you might be able to do with #clj-kondo analysis

iff is an abbreviation used in math for “if and only if”

that is its intent here

ah my bad sorry

Could you use gen/fmap to perform type conversion?

size-bounded-bigint generator seems to have this option, i just don’t know the syntax for it

https://github.com/clojure/test.check/blob/master/src/test/clojure/clojure/test/check/test.cljc#L918 is this an example/

i just want to know how to pass in force-bigint?

that example is the same as what I did, it generate both longs and bigints

I think this should work for you.

(def gen-bigint (gen/such-that
                 #(= clojure.lang.BigInt (type %))
                 gen/size-bounded-bigint))

thx, will go with this for now