why is (s/replace "1-1" #"-" "\\-") outputting 1-1 instead of 1\-1 ?

ah, "\\\\-" was the correct way

This seems like a bug since (s/replace "1-1" "-" "\\-") works fine. I think I'm going a little crazy but (.toString ^CharSequence "\\") throws an exception for me, whereas

(let [a "\\"]
  (.toString ^CharSequence a))

could someone help me understand what's the use of :state under gen-class ? i have the following class:

(ns test.core
    (:gen-class
     :name Testing
     :extends javax.swing.JFrame
     :init init
     :constructors {[String] [String]})
    (:import (javax.swing JFrame)))
(defn -init [x]
  [[x] (ref {})])

test.core> (def f (Testing. "a"))
#'test.core/f
test.core> (.getTitle f)
"a"
test.core> (.setTitle f "b")
nil
test.core> (.getTitle f)
"b"

Is there any public examples of the use of the com.cognitect.aws/athena lib to run a query against athena?

Ah scratch that. Seems like it might be easier to just use the jdbc client

So if I when I use deps, do aliases apply to transitive dependency also? I am trying to make a library that has an optional additional dependency that enables more configuration formats.

My guess is no

no, but I created an issue to add support for similar functionality 🙂

https://clojure.atlassian.net/browse/TDEPS-116

no, not transitive

Yeah... speaking of managed dependencies... in java being able to inherit maven configuration from Spring base and have library versions default to specific values in all projects was a game changer and it's a killer feature in larger organizations

Hey guys, I have a really naive question: How do I compose a hash like {:a <any function> :f <any function> ...} I have tried something like (merge-with (fn [a f] {a f }) [:a f] (reaptedly *)) But at the end I just have some similar to {:a 1 :f 1} How do I merge a index with a function as value?

not sure I understand what you want (what's your input and desired output?), but zipmap comes to mind, is it what you want?

(zipmap [:a :b] (repeat *))
=> {:a * :b *}

@mbrum note that I used repeat, not repeatedly

(take 2 (repeatedly *)) #_ =>(1 1)

one of the most satisfying things about clojure is returning to the source code of a project i worked on 4 years ago and can still completely comprehend wth is going on.

any one know a function like merge-with but that accept 3 or more args at on? like : (merge-with-xxx (fn [a b c] (......)) {:a 1} {:a 2} {:a 3})? or something similar as merge-with-key (merge-with-key (f val-in-result val-in-latter) maps) both kind of function suits me.. cheers...

people that use reloaded style workflows: how do you deal with your work-in-progress code which needs to use the main system? I have a system which I can fully reset but this means I cannot refer to the system at the top level, which is something I usually want to do in a scratch namespace of of stuff I'm working on. Is it as simple as just have your work-in-progress stuff outside of the tools.namespace.repl refresh dirs? Or are there other techniques I'm missing?

I’ll usually opt a scratch namespace out of tools namespace with disable-reload! and pluck what bits of the system I need out of the running system map at https://github.com/weavejester/reloaded.repl/blob/master/src/reloaded/repl.clj (integrant.repl has a similar internal value)

Awesome, I think that should do

@jjttjj if you're using mount, it will only start/stop the parts of the application state in the namespaces you've recompiled in the REPL (it's not the same as a full refresh, but for ongoing work this is rarely necessary I find). I really like that feature and until actually using it had no idea how it improves your workflow.

Does anyone know how to dynamically set logging level with clojure.tools.logging, preferably when using log4j 2? I've tried something like this https://github.com/jumarko/clojure-experiments/blob/master/src/clojure_experiments/logging.clj#L39-L48 but it didn't work (even without slf4j dependencies on the classpath). I got to some "weird" state when it somehow worked but after restarting the REPL it's not reliably working anymore. The log level seems to be stuck at whatever level was set at startup from the config file

@jumar dynamic configuration will need to go through the underlying logging implementation, e.g., log4j.

IIRC, log4j can support reloading when the config file changes.

it seems like function metadata in clojure is stored on the var, not the function object

(defn- takes-args? [f]
  (->> f meta :arglists (some (comp pos? count)) boolean))

(defn foo [x])

(takes-args? #'foo)
;; => true

(takes-args? (fn [x]))
;; => false

no

usually if you're asking that question, it's a good sign you have gone down the wrong path. what is your actual goal?

@denik You can use introspection to get a list of arities. (I don't remember how vararg is handled.)

What are you using this for?

I agree with @alexmiller. That said... https://gist.github.com/ataggart/7f7826507ff99985a7565dd20bba9617

just as a general handwavey thing, if you're trying to do something in Clojure and it's hard, you should take that as a sign

Why does the core.cache README examples use a fifo cache factory with a regular clojure map? That seems misleading given regular clojure maps do not have order guarantees, and a fifo cache is typically only used on data that has order.

what makes you say that?

first in first out is relative to the insertion order in the cache, it isn't via some ordering of elements of the cache

Oh, that's how core.cached works?

that is how fifo caches work

Sure, but I'm talking about the specific library here. From core.cache fifo docstring: > If the associative structure can guarantee ordering, then the said ordering will define the eventual eviction order. Otherwise, there are no guarantees for the eventual eviction ordering.

the initial map passed in is the "seed" of the cache

the entries in it need some insertion order

so the cache just uses the order you get back from calling seq on the seed

If I'm following you correctly, that's exactly my point. Calling seq on a regular Clojure map does not guarantee order.

correct, and as the doc string suggests, if that doesn't work for you, you can seed the cache with some other associative structure that does have some order

there are a number of different clojure map implementations that preserve some kind of order, and I expect it also works on java.util.Maps, of which many preserve order as well

Right - I get that but it seems like the example could be improved by using a structure that does preserve order.

so the example of a fifo cache from core.cached is not fifo?

Right

but you may also say "hey, this is the seed of the cache, everything as an arbitrary insertion of now, so just do whatever with them"

it is fifo

for some arbitrary notion of first?

yes

because everything you start with in the seed is tied for first, and it just picks a way to break the tie

i'm confused. if you seed with an empty map, add 5 things, when it needs to evict it won't evict the first of the 5 things added after the seed but whichever reports as first when calling seq on the map

Wait so order is preserved when inserting into a seed that does not preserve order?

the seed is not the cache

ah. ok. i was mistaken. i thought it would evict on seq of the current state

https://github.com/clojure/core.cache/blob/master/src/main/clojure/clojure/core/cache.clj#L173 keeps a queue of keys for eviction

Oh I see. So basically if your cache seed does not guarantee order, eviction order is not guaranteed for the seed values. All values after that get evicted in a fifo fashion.

it's like, imagine there is a clock for the cache, and every operation on the cache advances the clock one tick, so the clock starts and time 0, the first operation becomes 1, etc, etc

because it is an immutable cache, and you can only add one item at a time, no two items will be added on the same clock tick, and at eviction time you always evict the item added at the lowest clock value

but, at the very beginning, the base items are all added at the same tick, so the clock value is the same for all of them

so given a tie when it is time to evict, what do you do?

so it is still fifo, it is just fifo, but some times things are added at the exact same time so "first" is an arbitrary member of that set of tied items