@wilkerlucio: @jr: I’m collecting more information about cases like this, I’m curious whether just by covering the obvious stuff like JSValue and Var we’ll be good enough

would prefer to stop adding compiler options

@wilkerlucio: if you can add that to CLJS-1666 that would be helpful

@dnolen: sure, should I add the full stack as well or just the description?

How would I go about pretty printing cljs.spec error output in the browser console?

I’m currently in the process of implementing PCG (http://www.pcg-random.org/), in particular the pcg32 variant, using ClojureScript. Because Clojure tends to eschew mutable state, I’ve chosen to implement the generator as a seq:

(defn- bit-rotate-right [x n]
  (bit-or (unsigned-bit-shift-right x n)
          (bit-shift-left x (- n))))

(defn- unsigned [x]
  (aget (.of js/Uint32Array x) 0))

(defn make-pcg32-seq [seed seqid]
  (let [state (or seed (generate-seed))
        increment (if seqid
                    (.or (.shiftLeft seqid 1) (.getOne Long))
                    default-increment)]
    (map #(-> %
              (.shiftRightUnsigned 18)
              (.xor %)
              (.shiftRightUnsigned 27)
              .toInt
              (bit-rotate-right (.toInt (.shiftRightUnsigned % 59)))
              unsigned)
         (iterate #(-> %
                       (.multiply default-multiplier)
                       (.add increment))
                  state))))

1. Is using a lazy seq a good way to implement this, or is there a better approach?

2. Assuming this is a good approach, is this a good implementation?

3. I also have a function that implements the equivalent of rand-int using a backing random-seq:

(defn bounded-random [random-seq bound]
  (let [threshold (js-mod (unsigned (- bound)) bound)]
    (loop [rs random-seq]
      (if (>= (first rs) threshold)
        [(js-mod (first rs) bound) (rest rs)]
        (recur (rest rs))))))

(defn bounded-random [random-seq bound]
  (let [threshold (js-mod (unsigned (- bound)) bound)]
    (some #(if (>= (first %) threshold)
             [(js-mod (first %) bound) (rest %)])
          (iterate next random-seq))))

(Having written all this out, I’m tempted to post this as a question on Code Review Stack Exchange, also. )

If you’re curious about the definition of things like generate-seed, default-increment, default-multiplier, etc., here’s the whole source file: https://gitlab.com/cky/emojisweeper/blob/master/src/cljs/emojisweeper/pcg.cljs

@mfikes: Good thought, and it was false, but binding it to true doesn't appear to fix it. Oh well.

@peeja The only other (unfounded) thought I have is that perhaps you are expecting pprint to wrap but it is not doing so owing to *print-right-margin* being set to a large value.

Oh, good thought…

No, unfortunately it's 72, and the length of the output is 42739. 😛

cljs.spec question: is there a way to see the stack trace of the errors from (spec'ed) function? i can see the errors and explained message in the browser console, but sometimes find it difficult to track which part of code is throwing it

also, the error thrown is always a giant one-line blob. would be nice if it’s pprint'ed

@settinghead: I don’t understand it’s “hard to see which part is throwing it"

the stack trace tells you exactly all the calls leading up to where it failed

also “giant one-line” blob what is this referring to?

a screenshot or something would help

however, if the :val is say a giant map, it becomes harder to read when everything is serialized in one single line

@settinghead: yeah I’m not sure about pretty printing - but will think about - some of these decisions need to bounced around with what is happening in clojure.spec

also nothing is stopping fancier tooling from doing this stuff

you can probably even do this yourself with a window level exception handler during dev

@dnolen: makes sense. will try. thanks

I figured out the pprint problem! I had an om/MapCursor, which pprint doesn't natively know to treat like a map

@wilkerlucio: when you have some time if you could try master that would be helpful - hopefully it just works - if not I’d like to find a minimal case to repro that doesn’t involve other stuff

re: JSValue problem with Transit JSON analysis caches

sure, going to try now

whats the command to build from the sources?

./script/build

@dnolen: thanks, and the compilation is working on my project 🙂

@wilkerlucio: ok so that particular issue is fixed for you?

yes

@wilkerlucio: I would try running a Figwheel REPL as well and requiring something etc.

if you have that setup in your project

ok, I'll try that

I think it's all working, I tried cleaning my build and also loading a file that contains #js tags, all worked

@wilkerlucio: ok, cool thanks much for the check!

no problem, you'r welcome

@jr re: I’d like a bit more information about what is going on

somehow non-compilable things are getting into the analysis cache which really should never happen

something that would help me would be to know where in the structure of the cache this is happening for you

if you use a previous version of ClojureScript and grep through the EDN analysis cache for #object that would explain a lot of things