-M takes a class

Alright, will play. Thanks!

Actually I guess it is a class, so not

It is possible to use java directly and just use the CLI to generate the classpath with -Spath

We're just working around it: realised we could make a clj namespace that wraps the other class' main function

Thank you though, will look into the straight java route later if we need it

You can also pass a .clj script which can do whatever

Or pass via -e or stdin if you want to make that on the fly

To call a Java function via -X would imply that it can take a single hash map argument and it would be passed a Clojure hash map so, even if you could do it directly, it would be a pretty unusual Java function (unless you were really careful about the command line arguments you passed). Having a Clojure function as a wrapper seems a much safer approach since you could perform argument validation/adapt the Java function's signature etc. I'm curious as to your use case @U24QP2D4J?

Playing with compiling a SOAP service into classes with jaxb and calling from clj. Our builds had fun time yesterday when the enonic maven decided to have a hiccup, so looking at options for moving it to a more reliable place. (I'm not entirely across it, a different engineer is looking at options)

(let [schema #hawk/malli [:map [:k [:maybe map?]]]]
  (println {:schema (.schema schema)
            :map?   map?})
  (malli.core/validate (.schema schema)
                       {:k {}}))
{:schema [:map [:k [:maybe #object[clojure.core$map_QMARK___5489 0x49cfc60c clojure.core$map_QMARK___5489@49cfc60c]]]],
 :map? #object[clojure.core$map_QMARK___5489 0xe0847a9 clojure.core$map_QMARK___5489@e0847a9]}
Execution error (ExceptionInfo) at malli.core/-exception (core.cljc:138).
:malli.core/invalid-schema

so i’m wondering what the proper way to read “complicated” structures are in data-readers

I noticed that ordered/set #'flatland.ordered.set/into-ordered-set, seems to sidestep this issue by not evaling it’s arguments, but it leads to some nonsense like

#ordered/set [1 2 (+ 1 3)]
#{1 2 (+ 1 3)}

this is a slightly different way to handle it but could you use the :map keyword-style of schemas in malli? and then move any custom schemas to the global schema registry?

it is for use in tests. we need some way to dispatch to a malli validation and we have a deftype wrapper. But the fundamental question remains, why do i get a different version of clojure.core/map? and what is the proper way to use data-readers

instead of eval, could you use resolve? maybe postwalk plus resolve?

i'm not sure why eval results in different identity for core functions

walking over the form and resolving sounds strange

lol I agree

safe yourself a lot of pain and do not use reader tags in source code. (hawk/malli [:map [:k [:maybe map?]]]) works just fine with no undefined behavior or quirks 😛 in data this is fine, but for source code you have to deal with a lot of quirks and pain, especially if you want to add AOT compilation

the suggestion from our work slack was

`(->Malli ~form)

everywhere in any .clj(c|s) file, absolutely without question should never contain any reader tags in my view yes

How are you running tests?

Are you using something like polylith?

example usage is

(is (=? {"Rome"   {:pk_ref         (mt/$ids $municipality.id)
                                 :name           "Rome"
                                 :model_id       (:id model)
                                 :model_name     (:name model)
                                 :model_index_id #hawk/malli :int}
                       "Tromsø" {:pk_ref         (mt/$ids $municipality.id)
                                 :name           "Tromsø"
                                 :model_id       (:id model)
                                 :model_name     (:name model)
                                 :model_index_id #hawk/malli :int}}
                      (into {} (comp relevant (map (juxt :name normalize)))
                            (search! "rom"))))

no polylith

another example

(is (=? [{:id   #hawk/malli Tab-Id-Schema
                        :name "A look at Reviews" :position 0}
                       {:id   #hawk/malli Tab-Id-Schema
                        :name "A look at Orders" :position 1}]
                      (:tabs dash)))

(def Tab-Id-Schema
  "Schema for tab-ids. Must be integers for the front-end, but negative so we know they do not (yet) exist in the db."
  [:fn neg-int?])

same, this is clojure code. so why not just :model_index_id (hawk/malli :int)? I mean this might work if this is your reader function, just called as a regular function

It sounds sort of like multiple clojure runtimes isolated from each other by class loaders

it seems that

(defn read-malli
  "Data reader for `#hawk/malli`."
  [schema-form]
  `(->Malli ~schema-form))

(defn read-malli
  "Data reader for `#hawk/malli`."
  [schema-form]
  (->Malli (eval schema-form)))

i’m wondering if eval in the reader macro causes a double eval? I’m a bit scrambled by how many times that gets evaluated

what would that look like (excited to check though)

ok. .getParent on the classloader for each clas

the value passed to the reader function has been read but not evaluated

if you think eval needs to be involved, I would suggest this is probably a bad usage of tagged literals

have you heard about functions? they are pretty cool and do eval for you :)

haha i agree. i think this was a syntax preference in our test code and we didn’t realize some of the tradeoffs involved

the reader value will get evaluated when it's returned so that is likely the source of the double eval

I bet it is because the form you are evaluating has the fn object for map? Embedded in it, not the symbol

probably something like that

if the data reader is meaningful to you, maybe check out the keyword schemas in malli. those will pass through to malli easily

Because the map? doesn't close over anything it gets the generic embed object bytecode treatment of "call no arg constructor of its class"

So multiple instances of the class

ok. so for the flatland ordered set reader

ordered/set #'flatland.ordered.set/into-ordered-set,

(defn into-ordered-set
  [items]
  (into empty-ordered-set items))

#ordered/set [1 2 (+ 1 2)]
#{1 2 (+ 1 2)}

It is complicated, but in general that is correct

I consider that working as intended and nothing to fix. reader tags are meant for data, not "code yet to be evaluated"

ok. so it is intender for literals and using non-literals is abusing it?

kind of

(thank you both. just wanting to fully understand it before jumping into a fix (replacing with raw functions, fixing the reader macro function, only using self-evaluating data in the macro call sites)

Another example:

user=> #inst "2023"
#inst "2023-01-01T00:00:00.000-00:00"

user=> #inst (str 2023)
Syntax error reading source at (REPL:4:17).

they are called "https://clojure.org/reference/reader#tagged_literals" by the documentation

yes. but i was kinda keying off of

#{1 2 (+ 1 2)}
#{1 3 2}

Also echoing @UEENNMX0T - I'd also recommend favoring keyword over functions when defining malli schemas. It just sidesteps some future headaches that may or may not come up.

if you want to make things even more complicated add CLJS into the mix, which handles reader tags in source files entirely different 😛

so this is interesting. Double evaling doesn’t necessarily give me a new instance. But it does if it’s inside a vector

(let [evaled (eval 'map?)
      double (eval evaled)]
  {:evaled evaled
   :double double
   :original map?
   :identical? (identical? map? double)})
{:evaled #object[clojure.core$map_QMARK___5489
                 "0xe0847a9"
                 "clojure.core$map_QMARK___5489@e0847a9"],
 :double #object[clojure.core$map_QMARK___5489
                 "0xe0847a9"
                 "clojure.core$map_QMARK___5489@e0847a9"],
 :original #object[clojure.core$map_QMARK___5489
                   "0xe0847a9"
                   "clojure.core$map_QMARK___5489@e0847a9"],
 :identical? true}

(let [evaled (eval '[:stuff map?])
      double (eval evaled)]
  {:evaled evaled
   :double double
   :original map?
   :identical? (identical? map? (last double))})
{:evaled [:stuff
          #object[clojure.core$map_QMARK___5489
                  "0xe0847a9"
                  "clojure.core$map_QMARK___5489@e0847a9"]],
 :double [:stuff
          #object[clojure.core$map_QMARK___5489
                  "0x506ba0ae"
                  "clojure.core$map_QMARK___5489@506ba0ae"]],
 :original #object[clojure.core$map_QMARK___5489
                   "0xe0847a9"
                   "clojure.core$map_QMARK___5489@e0847a9"],
 :identical? false}

Yeah, you are basically seeing the difference between eval via the interpreter and eval via the compiler

so the tl;dr would be that tagged literals should be reserved for self-evaluating literals. Using the syntax quote solution is working around some of the pitfalls from not using self-evaluating literals but isn’t necessarily clear of all of them and there could be other things lurking.

The issue with reader literals and eval is once you start having your reader literals produce non-core collections at read time, which is a popular usage for them, the evaluator doesn't know how to traverse them

% clj -Sdeps '{:deps {org.flatland/ordered {:mvn/version "1.15.11"}}}'
Clojure 1.11.1
user=> (use 'flatland.ordered.set)
nil
user=> (ordered-set 4 3 1 8 2)
#ordered/set (4 3 1 8 2)
user=> #ordered/set (4 3 1 8 2)
#ordered/set (4 3 1 8 2)
user=> #ordered/set (4 3 1 8 (+ 1 2))
#ordered/set (4 3 1 8 (+ 1 2))
user=> (defprotocol IEliminate (-eliminate [obj]))
IEliminate
user=> (extend-protocol IEliminate (type #ordered/set ()) (-eliminate [x] `(ordered-set ~@(seq x))))
nil
user=> (eval #ordered/set (4 3 1 8 (+ 1 2)))
#ordered/set (4 3 1 8 (+ 1 2))
user=> (eval (-eliminate #ordered/set (4 3 1 8 (+ 1 2))))
#ordered/set (4 3 1 8)
user=> 
% 

if eval would call something like IEliminate internally on unknown objects, you could teach it how to traverse custom collection types and make them behave more like core collections

As the exception says, lists are not comparable. But vectors are.

presumably boils down to random access. You can access the Nth item in a vector in constant time. For a list you have to walk the list N times. So if you compared a bunch of things that were long you would have a drastic slowdown in code execution

you can of course build a comparator that behaves this way. so it is “possible” to sort them. But you are forced to be aware of this

an example would be

(sort (fn [a b] (compare (vec a) (vec b))) ['(1 3) '(1 2)])

Vector comparison is item by item. You don't need random access to be able to implement that with lists.

No clue why lists themselves are not comparable. Perhaps it was never seen as practical, maybe because it's very easy to confuse lists with lazy seqs, and those can be infinite.

of course you don’t. but that’s the default way it is implemented

public int compareTo(Object o){
	IPersistentVector v = (IPersistentVector) o;
	if(count() < v.count())
		return -1;
	else if(count() > v.count())
		return 1;
	for(int i = 0; i < count(); i++)
		{
		int c = Util.compare(nth(i),v.nth(i));
		if(c != 0)
			return c;
		}
	return 0;
}

Because it's the implementation for the vector class. :)

vector’s compare uses constant time access for count and positional comparisons. Both things lacking for lists

Lists do have O(1) count.

ah right you are. sorry about that

(i am conflating infinite seqs with concrete lists)

Thanks to you both, very informative discussion, too

resolve

But defn has compile time effects, so you cannot do what you want and with a runtime conditional

So you need to use a macro or not use def

how can I not use def ?

a macro can work as well I think

you can use https://clojuredocs.org/clojure.core/intern

thanks, I learned so much today 😄

;; needed for Clojure 1.10 compatibility
(when-not (resolve 'clojure.core/parse-long)
  (intern 'migratus.cli 'parse-long
          (fn [s] (Long/valueOf s))))

Long/valueOf isn't entirely complete, parse-long will return nil for an unparsable string instead of throwing an exception

thanks, for my use-case I parse a cli arg to long - don't need more

If your goal is just avoiding the warning, then you can either: • rename your function so it doesn't clash anymore • In your ns form, do this:

(:refer-clojure :exclude [parse-long])

I renamed the fn 🙂

thanks, that is a better solution for my case

Try printing with prn instead of println to see the double quotes around strings. I assume that something in that second block is a string because otherwise that data structure isn't readable.

Also, it depends on what you have in your migratus.sh. You have to be careful with double quotes in scripts - otherwise, you'll end up treating a single argument like "1 2" as two arguments, 1 and 2, which is, seemingly, what's going on here.

user=> (require '[clojure.tools.cli :refer [parse-opts]])
nil
user=> (require '[clojure.edn :as edn])
nil
user=> (def cli-options [["-c" "--config-data EDN" "Configuration Data" :default {} :parse-fn edn/read-string]])
#'user/cli-options
user=> (parse-opts ["-c" "{:store database}"] cli-options)
{:options {:config-data {:store database}}, :arguments [], :summary "  -c, --config-data EDN  {}  Configuration Data", :errors nil}
user=>

thanks, I solved it. I think it was caused by how I was passing args in the shell script. I added quotes around "$@"

clojure -J-Dclojure.main.report=stderr -M:migratus "$@"