Is there a preferred, idiomatic way to convert a map to a flat array (ie. [:a 1 :b 2 :c 3])? I can think of about 3 different ways to do it.

(flatten (vec my-map), (vec (mapcat identity my-map)), (into [] cat my-map)...

Uh, there we go

Thanks!

also, flatten is pretty much never the right answer

(and problems that really call for flatten are usually a symptom of a design problem elsewhere)

You mean flatten the function or, the operation in general I was asking about?

specifically flatten

Yeah, I was leaning towards cat with into, but I have this niggling memory of having read somewhere that converting maps to vecs with into is not considered idiomatic.

Maybe that was just for the trivial case without any additional transformation, or maybe it was just a bad source.

how do you set a static field of a java class in clojure using interop?

Classname/staticField is how you get it (from https://clojure.org/reference/java_interop)

i can't find anything about setting it though

haha, anyway ... https://clojure.org/reference/java_interop (set! (. Classname-symbol staticFieldName-symbol) expr)

@bcbradley ^

@josh.freckleton partial might be slightly helpful. Possibly its distant cousins -> and ->>, too. I think we don't have arity functions like you want because they're easy to write--as you have done.

not really cousins.

is it possible for a function in clojure to do different things based on the types of its arguments, in a general sense?

protocols can dispatch on the type of the first argument, i know that

and i know you can define functions of multiple arity

but what i mean is the general case of different types per argument and different numbers of arguments

for instance, if you had a function foo that could take 2 strings, 1 int and 1 string or 1 string and 1 int, and each of these overloads does something different, how would you implement it?

(defn foo [a b] (if (== (type a) ... ))

hrm, is there a way to do it efficiently? (protocol dispatches on the type of the first arg in constant time, regardless of the number of types)

Sounds like a job for defmulti and defmethod.

I don't know about its efficiency, though.

@branch14 Looks weird, but dispatching with identity feels wrong in the first place.

Why identity, and not say type?

@adambros This is an example. I'm dispatching on identity to keep the the example simple.

Sure but you could use the instance from the arguments, and dispatch based on that it's a C

No, because I've different instances of C that I want to dispatch on.

Well but surely there's a dispatch for telling them apart

Other than equality?

Actually that's a weird one, what does it use... What kind of equality is it doing, and are vars/pointers messing that up

That might be, I can try to find one, but that would be a work around for the issue I'm facing, which I haven't fully understood yet. 😉

Essentially, you should be able to tell two instances apart, or they'd be the same

But I could see cases, like regex, where it's hard to tell if they capture the same strings

Hi, a question about package naming conventions and leiningen? I notice that if my project.clj :main definition refers to something like org.my-project.core, then leiningen fails finding my code when I try to run, even if I do have something like the following in my source files: (ns org.my-project.core (:gen-class)) What should I know about the source directories hierarchy in clojure/leiningen project, to get around this? Should the directory structure under src/ strictly mirror the namespaces which I declare?

Yes, which works for records and generally it works for vars declared up front. But it doesn't seem to work for records declared up front.

Well so why are you trying to use declare like this... Why isn't there a better dispatch function?

@matan lol was that it? You'd be surprised at how many times silly things can get the most experienced developers

Wouldn't worry about it

@adambros Oh, well I think I nailed it

Just trying to fiddle an interleaving of Java → Clojure → Java leiningen compilation here 🙂

Ah yeah I've seen co-workers run into nightmare ish issues with that stuff

The reason to use declare and dispatching on record instances are beyond the example. I can find other ways and rewrite the code, but I was hoping that I just missed something.

Yeah I just feel it's wrong to declare a thing, dispatch based on identity, and then put an (complicated) object in that var...

For all I know, it could be holding on to the value of c when you defined the multi method

Thereby causing the problem you are seeing

I see, but wouldn't that be a general problem with dispatching on upfront declared vars?

@adambros thanks for the encouragement 😉

lol

but it feels mostly "right" when writing a library project that should be used from Java not only from clojure applications

@noisesmith Oh that's annoying, should I catch throwables instead?

@adambros thanks it was probably a mixture of uppercase and lowercase naming of source file names (a al Java) and clojure namespaces, close enough to your dash/underscore guess 🙂

Who maintains http://clojure.org ? There’s a broken link on the swag page (not broken, but it doesn’t direct properly)

if i run a test with clojure.test/run-tests, if a test fails, does it exit with 0 or 1? the docs don’t really say how it exits

is there any better we can do to read a properties file into a hashmap:?

(defn props [path] 
     (->> (doto (java.util.Properties.)
                 (.load ( path)))
             (map (juxt #(.getKey %) #(.getValue %) ))
             (into {})))

maybe with bean,or maybe not (untested)

@m, seems like a decent solution already

@m, (-> (doto (java.util.Properties.) (.load ( "test.properties"))) pr-str read-string) 😆

oh, or (into {} (doto (java.util.Properties.) (.load ( "test.properties")))) @m ^^

So much for sandwiching clojure between Java compilation steps? 🙂 https://github.com/technomancy/leiningen/issues/847#issuecomment-290026580

I should probably give up on that..

@m, or (clojure.lang.PersistentHashMap/create (doto (java.util.Properties.) (.load ( "test.properties")))) 🙂

is there a way to find all implementations of a protocol?

i see in core there's a find-protocol-impl but it lacks documentation

that's an internal function

there's really no good way of doing that as classes can implement the underlying protocol interface (e.g. if you implement a protocol inline)

and that's not visible unless you inspect every loaded class

so from a tooling standpoint, this will need to be done from a textual starting point rather than a semantic point and using clojure itself?

@tbaldridge I had some time to think about what you said about breaking GL (and other) naming conventions with the lwjgl wrapper i was making, and after carefully considering it I think you are probably right. It'd be a shame to throw away all the work I've done, so maybe I'll make a json file out of the edn I extracted from the lwjgl javadocs and put it somewhere on a forum for people who might be interested in having it.

what is the simplest way in clojure to get a list of all fonts I can use ?

@qqq (into [] (.getAvailableFontFamilyNames (java.awt.GraphicsEnvironment/getLocalGraphicsEnvironment)))

the into call just gives you something that’s readable in the repl in its printed form, if you plan on iterating on the result the into call is not needed

@noisesmith : thanks! I didn't realize getLocalGraphicsEnvironment was a static member function, which threw me off

I can fix the "Unable to resolve symbol: POne" by adding "(:import (rec_test2.protocols POne)" in ns function, but then I get ClassNotFoundException: rec_test2.protocols.POne. I tried requiring the namespace in various ways, and compiling the protocols file first, but nothing has helped yet. Any ideas would be appreciated.

In your Leiningen project.clj, specify that you want to AOT-compile this file using the :aot option. I think that something like that will help.

(Or maybe I'm not thinking it through properly.)

@poverholt be sure that you require the other ns too

just the import doesn’t suffice

and no, this doesn’t need aot

Those are the areas I am trying. No luck yet. :aot did not help. I have both the require for the ns and import for the protocol symbol itself. No luck there either. Do I need the gen-class in the protocol's namespace?

no, you don’t need gen-class

can you share the code for the namespace that attempts to use POne?

Any best practices for Component/Integrant, like where to define the components and how to name integrant keys?

Does the clojure.core.cache/ttl actually evict values and drop them from memory ones the ttl expires, or does it simply respin once queried?

laujensen it doesn’t even know how to mutate your store (I use it with an immutable cache object, and use the cache function to swap! it)

it can’t evict until a query happens (unless you have a timer running to swap! on it periodically I guess…)

Okay thanks

@poverholt minimal working example

justin@S: /tmp/proto-example$ cat src/example/a.clj
(ns example.a)

(defprotocol Aproto
  (foo [this])
  (bar [this]))
justin@S: /tmp/proto-example$ cat src/example/b.clj
(ns example.b
  (:require [example.a :as a]))

(defrecord Brecord []
  a/Aproto
  (foo [this] :one)
  (bar [this] :two))

justin@S: /tmp/proto-example$
justin@S: /tmp/proto-example$ cat src/example/c.clj
(ns example.c
  (:require [example.a :as a]
            [example.b :as b]))

(defn -main
  [& args]
  (println (a/foo (b/->Brecord))))
justin@S: /tmp/proto-example$ java -cp ~/bin/clojure.jar:src clojure.main -m example.c
:one

literally wrote and ran this just now

@poverholt lines 21 and 22 in test2.core need to namespace qualify the method calls

eg. proto/a

and you don’t need to use import

@noisesmith It works! Thank you. The primary problem was NoClassFoundException and removing all gen-class seems to have fixed that. In the end, our team will compile all code, but that is a problem for another day. Thanks again.

@poverholt why are you compiling the code?

there’s valid reasons to never do so, is why I ask

@noisesmith We have never deployed source code and I expect we would have to jump through hoops with our lawyers before we could do so. It's not impossible, just not likely. What are the concerns?

aot tends to break things in unpredictable ways, protocols in particular

it’s manageable (especially with the help of stuartsierra/component and clojure.tools.namespace/refresh) - but it’s a big hassle and it’s nice to avoid it altogether if you can

but if you have a reason to not deploy source, that makes sense

one nice trick for aot on deploy but never having it break things during dev (which is when it really tends to be a hassle), is to create a shim namespace that only uses clojure.core, and none of your other code. Inside that namespace (which uses gen-class) you have a -main that calls require at runtime and then uses resolve to find your real main and run it

@noisesmith Thanks. I'll check out the links.

as long as you never use the shim namespace during dev (and you don’t need to) you can avoid a lot of the aot related dev time problems

is there a better/more composable way of saying: “if function applied to a value returns true, return the value, otherwise nil”? Having to wrap whole thing in a lambda doesn’t look great, e.g: (#(if (.isValid %) %)), you can use this in threading macros and with comp but I’m wondering if there’s nicer way?

I’m looking for minimal, readable/concise construct

i need to connect to a redshfit database and I’d like to use HugSQL, what should my db map look like?

@ag with specter it's just (select-first some-pred? some-val)

@nathanmarz nice, but we’re not using specter yet (not in all our projects)

(defmacro keep-when [x & preds] `(when (and ~@(map (fn [pred] `(~pred ~x)) preds)) ~x))

@ag some-fn ? Returns false, is that important?

Nope

@shdzzl I need to return the value itself, e.g. identity

Returns nil actually.

do you need the result of the computation or the value?

Ah

i.e. (foo f x) do you want (f x) or x?

Misunderstood, my bad.

x, not (f x)

@bja if (f x) is true, return x

(and (f x) x)

(and (true? (f x)) x)?

(when (f x) x) ; if you prefer nil to false

oh, if the literal value true is important, yeah

(when (true? (f x)) x) - if you need nil if not literally a true

(defmacro when-pred [f x] `(let [y# (~f ~x)] (when (true? y#) ~x)))

I thought I saw something very similar to this in a utility library once upon a time

sigh. I just want to do something like this:

(some-> v js/moment (#(when (.isValid %) %))

if-let?

@mobileink how’s that different? You still need lambda

Why can't you just use filter?

@quaeledyn filter complicates it even more - you can’t “filter” single value - have to wrap it in a list, then return very first value

though (comp first (partial filter f) list) has a certain point-free charm, as a definition

I think it just makes sense to have fn like this:

(defn some-val
 [val pred-fn]
 (when (pred-fn val) val))

and just use it

¯\(ツ)/¯

@ag the definition of when-pred I provided basically is some-val as a macro. It doesn't need to be a macro I guess.

(some->> v js/moment (when-pred (memfn isValid)))

I don't think you'll really get around memfn though, unless you build in support for it

(or use a lambda instead of memfn)

oh - a method call is a reason to use a macro maybe

you could definitely take something passed as a "function", determine if it's a symbol, and if it is, and it starts with a period, interpret that as an interop call

which would be a valid way to use a macro, although probably a bit too magical for my personal taste

such that this would work (when-pred .isValid x) => (when (true? (.isValid x)) x)

theoretically .isEmpty works without doing that detection, but I didn't try it

btw. can someone tell me is there equivalent in clojure of Haskell’s flip? Function that flips first two arguments?

How about (as-> x (if (. isValid x) x))?

e.g.

(some-> 1 (as-> n (if (even? n) n)))
nil
(some-> 2 (as-> n (if (even? n) n)))
2

(.isValid x) cannot return x if true?

(I don't know what .isvalid is, so I'm guessing at your actual use case)

@quaeledyn oh, yeah, I guess I forgot about as->

I'd prefer an anonymous function myself, but each their own I guess 🙂

defmacro ->?, passing the output of expressions but the input of predicates that eval true?

If you look at what gets done to make as-> work I can't imagine why you'd want to use it for this (presumably) simple case

not much difference between using as-> and a lambda, no?