Is it possible to get a mutable primitive place? I thought that this might work, but doesn’t seem to

(defprotocol P
  (add! [_ ^long x]))

(deftype T
    [^:volatile-mutable ^long c]
  P
  (add! [_ x]
    #_(set! c  x)))
(add! (->T 0) 1)

==> class user$eval42522$fn__42523$G__42513__42530 cannot be cast to class clojure.lang.IFn$OLO

Is there a codeq analyzer for csharp?

As part of my journey of getting my head properly around transducers, I’m looking at the source of partition-all. I’m confused by one part of it: why is the call to .clear necessary in the completion arity? What would go wrong if this line was deleted? As far as I can see, there’s no need to clear it because the completion arity will only ever be the last call to a transducer? I suspect I’m missing something though? https://github.com/clojure/clojure/blob/17ae75eadbb93152e460cd156adeb7876e616631/src/clj/clojure/core.clj#L7258

Just want to make sure I understand interop with vararg methods. In Java given a method signature void foo(int… someNumbers) you can call it like obj.foo(). In Clojure, you can’t leave out the argument, right? You have to explicitly provide the argument to call the correct arity method. Ie, (.foo obj (int-array [])). Using the google cloud sdk and they sure like varags. https://javadoc.io/doc/com.google.cloud/google-cloud-storage/latest/com/google/cloud/storage/Blob.html#signUrl-long-java.util.concurrent.TimeUnit-com.google.cloud.storage.Storage.SignUrlOption...-

trying to write a macro that will do this

(do (import (thing Foo))
    (let [x Foo]))

but i cant seem to make Foo resolve without running the import in a seperate statement

works

user=> (do (import (java.util HashMap)) (let [x HashMap] (type x)))
java.lang.Class
user=>

Maybe the quoting is wrong. This also works:

user=> (defmacro m [] `(do (import ~'(x X)) (let [x# ~'X] (println x#))))
#'user/m
user=> (m)
x.X

my guess would be you are trying to do something like (let [x String] (new x "foo")) which as you have found out, you cannot do

(you cannot do using clojure's interop, you have to use java reflection directly)

nah just trying to generate transit handlers

and it seems to only break if the class hasn’t been loaded in yet

so List and HashMap work

trying to find an obscure standard library class to test

seems unlikely

this is the generated code that wasn’t working from a fresh repl

(do
 (clojure.core/require (quote [com.company.todo.model]))
 (clojure.core/import (com.company.todo.model Todo))
 {:write-handlers (clojure.core/let
                   [model__45767__auto__ Todo]
                   {model__45767__auto__ (com.company.util.transit/record-writer "todo")}),
  :read-handlers {"todo" (com.company.transit/record-reader
                                        com.company.todo.model/map->Todo)}})

and what error do you get doing what?

Syntax error compiling at (shared-src/lumanu/com/company/todo/transit.cljc:5:7).
Unable to resolve symbol: Todo in this context

but if i run each one of those statements seperately it works

the call to import may need quoting

(ah, no)

ah, but that do is embedded in a larger expression

which is why it returns a map

which cause the whole do to be compiled and evaluated at once

instead of form by form

which means what the let is being compiled, the import hasn't run yet

so in clojure its an easy fix -

(eval `(do (require (quote [~model-namespace]))
                 (import ~(symbol
                           (str
                             (csk/->snake_case_string model-namespace)
                             "."
                             model-name))))))

but if i am expanding the macro in cljs the compiler doesnt complain

which i am now suspicious of

the fix is to re-write things so the do is a top level form

It seems like requiring com.company.todo.model actually creating a class. For that, you can either use Class/forName or do what some of the clojure core functions do: create the class when the macro is called and return the code that creates the class.

nah, the issue is top level do forms are broken apart and each seperately compiled and executed

which means in a toplevel do form, the import macro can run before the let is compiled

but when the do is not a top level form, the whole thing is compiled as a single expression, which means the import hasn't run, and its side effect hasn't changed the compilation environment for the let

"the gilardi scenario"

http://technomancy.us/143

and why wouldn't using Class/forName or importing the class when the macro is called and returning the code fix it?

here is exactly the boilerplate i am trying to replace

because the code that loads the namespace hasn't run yet, so the type is not created yet

I dunno what the structure of whatever you are doing is, but basically you need to lift compilation environment effecting forms (require, import, etc) out of subexpressions and hoist them into an enclosing do

(ns com.company.private-note.transit
  (:require
   [com.company.private-note.model :as model]
   [com.company.transit :as transit])
  #?(:clj
     (:import [com.company.private_note.model PrivateNote])))

(def transit-tag "private-note")

(def private-note-writer (transit/record-writer transit-tag))
(def private-note-reader (transit/record-reader model/map->PrivateNote))

(def write-handlers
  (let [private-note #?(:clj PrivateNote :cljs model/PrivateNote)]
    {private-note private-note-writer}))

(def read-handlers {transit-tag private-note-reader})

(ns com.company.todo.transit
  (:require [com.company.transit :as transit]))

(let [{:keys [read-handlers write-handlers]}
      (transit/generate-transit-handlers
       "com.company.todo.model/Todo")]
  (def read-handlers read-handlers)
  (def write-handlers write-handlers))

and this^ is what i came up with

now the reason the macro doesn’t just generate the vars is that cursive can’t handle that

yeah, the only way to make that work is if your macro loads code as a sideeffect, which is gross

being in a let like means it is all part of the same compilation unit (the same top level form)

loading code as a side effect is how clojure works for defrecord

loading code as a side effect of macro expansion

and the reason i don’t make the macro just put handlers into a mutable registry is that there is a lot of code to change for that right now

> loading code as a side effect of macro expansion So yeah, im fine with this i guess, i just don’t understand why the clojurescript compiler seems okay with it

i guard the loading with a (when (:ns &env))

imports work differently in clojurescript, but I know less about it

so clojurescript should just see a require and then a usage, but the require is in the let

the compilation model for clojurescript is very different, because of the way the meta lanaguage for clojurescript is clojure, not clojurescript

(let [{:keys [read-handlers]} (do (require '[com.company.thing.model])
                                  {"tag" com.company.thing.model/map->Thing})])

does it maybe “lift” requires, even if they are nested in expressions?

it might, it might lean more on runtime effects instead of mutating the compilation environment

it would make a lot of sense if the compiler lifted requires and imports, I just don't know

maybe I have it reversed, clojurescript relies less on runtime effects, and instead uses macros that have side effects when expanded