I don't know if you've ever seen the Ron Jeffries vs Peter Norvig sudoku stuff online (http://ravimohan.blogspot.com/2007/04/learning-from-sudoku-solvers.html?m=1), but that to me highlights the folly of just trying to ‘explore’ your way to a software solution, either in terms of functionality or architecture.

It does show up the prn within the test namespaces when running tests, but not the prns of the server namespaces :thinking_face:

Some time ago I did check it and couldn't find any instances in Clojure itself where that wouldn't be true. However, nothing prevents someone from creating a custom class that implements Fn but doesn't implement IFn.

Thanks. I believe I shouldn't care of such cases.

Just call symbol? (symbol that-random-string).

thanks @U2FRKM4TW! Found it!

The actual form I want to generate is something like

(do (when ((ns-map *ns*) 'R1-rect)
      (prn "Unmapping existing var!")
      (ns-unmap *ns* 'R1-rect))

    (def R1-rect "hi!"))

do you want alter-var-root?

@U0P0TMEFJ that will have the same problem, since simply including the else branch will cause the error before the alter-var-root branch is executed

meaning just having def inside any conditional at all is the problem, not the actual effect of the ns-unmap call

sure ... but I think I mean that you probably don't want to call ns-unmap, you probably want to call alter-var-root maybe like this?

(defonce random-var nil)

(alter-var-root #'random-var (fn [_] :new-value))

@U0P0TMEFJ sure, that’s a good change. Can you write the conditional part now, where random-var does not exist and you want the else clause to create it and bind it to :new-value ?

that is what is causing the bug

why would the var not exist? ... how is it getting created?

I think I need some more context to help

The idea here is to write a form like one of these two:

(define-coordinates [x y] R2-rect)
(define-coordinates [x y] some-ns/R2-rect)

this macro will bind a bunch of functions:

x, y, dx, dy, d:dx, d:dy

what does define-coordinates look like so far?

here is a simplified version:

(defmacro define-coordinates
  [coordinate-prototype coordinate-system]
  (let [sys-name (symbol (name coordinate-system))
        mapping-sym (gensym)]
    `(let [~mapping-sym (ns-map *ns*)]
       (when (~mapping-sym '~sys-name)
         (prn "Unmapping " '~sys-name)
         (ns-unmap *ns* '~sys-name))

       (def ~sys-name
         (m/with-coordinate-prototype
           ~coordinate-system
           ~(quotify-coordinate-prototype coordinate-prototype))))))

@U0P0TMEFJ if someone calls (define-coordinates [x y] some-ns/R2-rect) there is no problem

but I want to rebind R2-rect in the case where R2-rect already is imported with no prefix, like (define-coordinates [x y] R2-rect)

that form looks weird ... like it's trying to define something in another namespace

Vars defined with def are interned by the compiler, so where won't have an effect. But you should be able to use intern instead of def. Alternatively, if that's possible, you might evaluate that where during macro expansion.

@U0P0TMEFJ I don’t think so

@U2FRKM4TW trying intern !

I think the simplied code you posted is a bit too simplified ... mapping-sym isn`t set

sorry, it was (gensym)

updated

I did that so I could use it in two separate spots, not under the same

@U2FRKM4TW intern was the ticket

(defmacro define-coordinates [coordinate-prototype coordinate-system]
    (let [sys-name (symbol (name coordinate-system))]
      `(do (defonce ~sys-name nil)
           (alter-var-root (var ~sys-name) (fn [old#]
                                             (prn "Defining" (quote ~sys-name) "used to be" old#)
                                             (quote [~coordinate-system ~coordinate-prototype]))))))

@U0P0TMEFJ in the simplified form, yes, but the real one is this:

(defmacro define-coordinates
  "Give some `coordinate-system` like `R2-rect` and a `coordinate-prototype` like
  `[x y]` or `(up x y), `binds the following definitions into the namespace
  where [[define-coordinates]] is invoked:

  - `R2-rect` binds to a new version of the coordinate system with its
    `coordinate-prototype` replaced by the supplied prototype

  - `x` and `y` bind to coordinate functions, ie, functions from manifold point
  to that particular coordinate

  - `d:dx` and `d:dy` bind to the corresponding vector field procedures

  - `dx` and `dy` bind to 1-forms for each coordinate."
  [coordinate-prototype coordinate-system]
  (let [sys-name           (symbol (name coordinate-system))
        coord-names        (symbols-from-prototype coordinate-prototype)
        vector-field-names (map vf/coordinate-name->vf-name coord-names)
        form-field-names   (map ff/coordinate-name->ff-name coord-names)
        value-sym          (gensym)
        mapping-sym        (gensym)]
    `(let [~mapping-sym (ns-map *ns*)]
       (when (~mapping-sym '~sys-name)
         (log/warn "Replacing" '~sys-name "in namespace" *ns*))

       (ns-unmap *ns* '~sys-name)

       (intern *ns* '~sys-name
               (m/with-coordinate-prototype
                 ~coordinate-system
                 ~(quotify-coordinate-prototype coordinate-prototype)))

       (let [~value-sym
             (into [] (flatten
                       [(coordinate-functions ~sys-name)
                        (vf/coordinate-system->vector-basis ~sys-name)
                        (ff/coordinate-system->oneform-basis ~sys-name)]))]
         ~@(map-indexed
            (fn [i sym]
              `(do
                 (when (~mapping-sym '~sym)
                   (log/warn "Replacing" '~sym "in namespace" *ns*))
                 (ns-unmap *ns* '~sym)
                 (intern *ns* '~sym (nth ~value-sym ~i))))
            (concat coord-names vector-field-names form-field-names))))))

@U0P0TMEFJ I use mapping-sym inside the ~@ block below where I generate snippets, so if I used mapping-sym# in both places it’s used above i would get different symbols

👍

@U2FRKM4TW looking at defonce, I see that they are doing a slightly different trick:

(defmacro defonce
  "defs name to have the root value of the expr iff the named var has no root value,
  else expr is unevaluated"
  {:added "1.0"}
  [name expr]
  `(let [v# (def ~name)]
     (when-not (.hasRoot v#)
       (def ~name ~expr))))

@U2FRKM4TW is it worth copying this style, and calling (def ~sym) to get the binding in the first place?

I suppose the question is which style is more Clojurescript friendly

clojurescript doesn't have vars

or macros

well ... you run macros on the jvm ... right?

the macroexpansion generates a form like (intern *ns* 'sym ...) , I just mean is that correct for redefining something in cljs

@U0P0TMEFJ the reason I was calling unmap was because if you don’t, you get

R1-rect already refers to: #'sicmutils.env/R1-rect in namespace:
   sicmutils.fdg.ch1-test

when you try to intern. Is there some better way?

a var is a container for a value that has update semantics ... if you want to change the root value of a var you can use alter-var-root to do that ... and defonce to ensure that it already exists ... I would have thought that unmapping things from the namespace is a dev time reply thing to do to avoid restarting the jvm ... I wouldn't expect to use that in production code ... it just seems like an odd thing to do to me ... but if you have something you're happy with, then you should totally ignore me 😉

@U0P0TMEFJ the library here is an interactive system for doing math and physics, sort of like Mathematica

@U0P0TMEFJ so this form is either a supplement to your namespace definition and should live near the top of a file, or something you would type during REPL investigation, or in a notebook form

Hmm, interesting how defonce is implemented. It suggests that my explanation might be incorrect.

Ah, wait - that's a completely orthogonal thing. Your initial warning was not because def is evaluated during compilation but rather because you replace conj that came from clojure.core.

And with that in mind, what defonce does won't help you if you keep using names like conj - that very warning will still be there. And there will be no warnings if you use your old approach but with names that don't shadow imported things.

yeah, I am trying to bind something, but only if it does not exist

intern it is then. :) Unless you confirm that defonce somehow works there, which it shouldn't.

so def was in the else clause, where I had determined that there was no binding; but the compiler sees def and creates an unbound var, so errors even if the form is in the else clause of a conditional

@U2FRKM4TW yup! of course Clojurescript does not like my conditional test 🙂

62 |     (let [e (e/coordinate-system->vector-basis coordsys)]
  63 |       ((L2 mass metric) ((point coordsys) x) (* e v)))))
  64 |
  65 | (define-coordinates t e/R1-rect)
-------^------------------------------------------------------------------------
Encountered error when macroexpanding cljs.core/ns-unmap.
AssertionError: Assert failed: Arguments to ns-unmap must be quoted symbols

Yeah, you can't do that in CLJS. If you need that to be cross-platform, you will have to evaluate that when during macro expansion. So that the resulting code either has the (def ...) itself, without when, or has nothing at all.

@U2FRKM4TW if I am lucky, maybe cljs will not error on a redefinition

and I can just emit def

It will, I just checked. (defonce conj 1) - same warning.

@U2FRKM4TW nice, all done now. in Clojurescript it is NOT an error, just a warning as you say, to redefine, so I don’t need to do these shenanigans

https://gist.github.com/sritchie/76ac9bbd86c6892d00446cbfb7116dfe

final form

well, probably needs slightly more tidying, but this works.

this new version will only take the intern branch if you are redefining something that was imported for somewhere else. If you are overwriting something defined in the namespace itself (or running the form twice), no warnings, just like normal def behavior

Wait, it's is also a warning in CLJ:

Clojure 1.10.3
user=> (def conj 1)
WARNING: conj already refers to: #'clojure.core/conj in namespace: user, being replaced by: #'user/conj
#'user/conj
user=> conj
1

@U2FRKM4TW that is only for clojure.core

if you redefine something from a non clojure.core namespace it errors

https://github.com/clojure/clojure/blob/b1b88dd25373a86e41310a525a21b497799dbbf2/src/jvm/clojure/lang/Namespace.java#L81-L92

it was a good tip though to move the *ns* inspection to macroexpand time, of course everything I need has to be there once the namespace is already defined

I see, didn't realize it becomes a syntax error.

The README says to just use GitHub issues for questions: > Please use the project's https://github.com/ptaoussanis/sente/issues for all questions, ideas, etc.

i saw that! i was hoping to chat with folks who use it, who might have different opinions/use cases than just Peter (not to belittle his work or his usage) as subtleties in a library and workflow can come out of not being the implementor

I’ll open an issue about my situation tho, see what’s good

Ah, in this case I'd probably ask in #off-topic

didn’t know that channel existed, so perfect