Are the keywords fixed, or arbitrary text? Do you need to sub-text-search within the keywords? (ex. expect "browser" to match "browser-bug")?

And... "does it need to be web-scale"? (ie. what performance do you expect of it?)

...b/c without considering performance, almost every db can probably do what you say. Postgres, H2, Datomic, XTDB...

Are you using any db for other things already?

Elastic Search is also a consideration for text searches, as is Lucene.

the keywords are arbitrary, but common. no need for full-text search, exact match is good. it doesn't have to be "web" scale, but i can expect up to 10k new records in a day. i'd prefer a database that has a native way to express a query like "most frequent keywords today" without inner-joining eventually massive tables. so basically i guess what i'm asking is if there is a database (with a smaller resource footprint than elasticsearch) that can do date histogram queries over multi-valued attributes (in this case the keywords) efficiently

A time-series database maybe... like https://github.com/timescale/timescaledb (haven't used).

yeah i was looking at various time-series databases, but i couldn't yet find one that can handle multi-valued attributes

I wonder if timescaledb supports array column types (to avoid joins). Or, maybe just insert each event multiple times.

it supposedly supports every postgres data type, so i'll consider it for sure

I think Apache Druid might have the features you need

@UK0810AQ2 i couldn't find any details about what data types are supported in druid in its documentation. do you happen to know?

https://druid.apache.org/docs/latest/querying/nested-columns.html

https://druid.apache.org/docs/latest/ingestion/data-model.html

thanks!

The main question for me is whether this is really gonna be used mainly for OLAP. It sounds like an operational database that must be some for some analytical/reporting queries too. I don't have much experience with them, but could a document database fit the bill? It seems that those phone calls are fairly independent (you could say "documents"). I know that many people hate MongoDB (I'm not suggesting to use it per se; and I don't like it much either) but maybe something like this could be used: • https://www.bmc.com/blogs/mongodb-unwind/ • https://stackoverflow.com/questions/27752840/mongo-aggregation-on-array-elements

hmm thanks! i've used mongo from clojure before, but i haven't considered it for this use case. i'll look into how it performs and see!

Malli supports "closed" maps.

(m/validate
  [:map {:closed true} [:x :int]]
  {:x 1, :extra "key"})

Also, you may need to combine with :optional

[:map {:closed true} 
   [:x :int] 
   [:y {:optional true} :int]]

@UC1DTFY1G Why do you specifically want to exclude "unknown" keys? Clojure in general tries to be open to extension and the approach to maps is usually to just ignore additional keys.

Sample data: (on mobile so can’t format properly)

(def data {"k1" 1, "k2" "s", "k5" 4.3, "k23" "ss"}) # I need to validate that "k1", "k2" are present and every key present is in the set #{"k1", "k2", "k3" … "k225"}

Works with string keys as well:

(malli.core/explain
  [:map {:closed true} 
   ["x" :int] 
   ["y" {:optional true} :int]]
  {"x" 1 ;; required
   "y" 3 ;; optional
   "z" 2 ;; not-allowed
   })

But if you only want to validate keys and without malli, you could do it manually, (set (keys data)) and using some clojure.set/... functions

Ok I didn’t know you can give string keys in malli schema

pr-str

or prn

pr-str returns a string; prn logs like println

@U0CLNM0N6 That is what I wanted, Thank you 🙂

https://clojuredocs.org/clojure.core/remove-ns can remove a namespace (but is seems not the clojure.* namespace - which is probably a good safety net )

Although those docs suggest tools.namespace which may have better functions for the purpose described

Although it seems tools.namespace is deprecated.. tools.namespace

If you delete a namespace file, then run refresh, it blows up. If you run remove-ns on the removed NS, then refresh again, it still blows up. Restarting the reply seems to be the only recourse

@U05254DQM why do you think https://github.com/clojure/tools.namespace is deprecated?

The http://Clojure.org API says the namespace is deprecated.

Its seems more a case that things have moved around…. and things have been moved to namespaces under tools. namespace in several cases… not the clearest 😞

Oh.. huh

I assume if the namespace name & file is changed then refresh removes it from the REPL, but then tries to load it again and goes bang. I guess a hack would be to disable-reload! the old name of the namespace and then reload will not try and reload it. https://github.com/clojure/tools.namespace#disabling-refresh-in-a-namespace

Or perhaps clojure.tools.namespace.reload/remove-lib is a better approach This uses the original suggestion of remove-ns but also seems to update the list of loaded libs (if I am reading https://github.com/clojure/tools.namespace/blob/27194f2edfe3f5f9e1343f993beca4b43f0bafe8/src/main/clojure/clojure/tools/namespace/reload.clj#L15 correctly)

Sometimes I do need to edit/save the file that is failing to reset, which is not always the namespace I refactored (but something that might refer that namespace. Editing the namespace that cant be found seems to force (reset) to look again. So it seems to be a combination of remove-ns or clojure.tools.namespace/remove-lib or editing/saving the file of the namespace that has issues…

You should be able to do that with a macro. But you might want to try typing out a few real-ish examples of using the new api before you try. From what I'm seeing, it doesn't look like this removes very much duplication. Mostly it just moves the update fns from the recur to the let binding, making it less obvious what your code does. And using such a macro will likely add friction to injecting arbitrary extra steps to massage your data. This looks like a fold. So maybe using reduce could clean up a bit of the boilerplate? (or might only make it awkward and hard to follow).

(first
 (reduce (fn [[results [param-1
                        ...
                        param-n]] item]
           [(conj results)
            [(update-1 ...)
             ...
             (update-n)]])
         [[] [(init-param-1)
              ...
              (init-param-n)]] my-list))

Yeah, recommend looking at reduce, which does everything your template does (and potentially more).

not sure if this directly applies, but reminds me of https://aphyr.com/posts/360-loopr-a-loop-reduction-macro-for-clojure

People mostly use shadow-cljs nowadays I guess. I found it easy to use.

Thanks! I’ll look that one up

I work on a base project, might be useful to check https://github.com/damesek/deps-fullstack (not lein/project.clj, deps.edn)

I’ll take a look bit to be honest I’m not feeling like my main problem getting started is a lack of IDE options

Ok, as you feel. That is just a source code.

@UN16R9L93 I haven't touched emacs+cider, but this looks to be cider stuff for shadow-cljs: https://docs.cider.mx/cider/cljs/shadow-cljs.html

Figwheel-main is a simpler approach to start with, as there are fewer moving parts, especially if sticking with ClojureScript (and html/css) Use shadown-cljs if you want to make use of JavaScript packages npm packages.

When using Cider then cider-jack-in-cljs will start up a REPL, prompting for a few startup options https://docs.cider.mx/cider/cljs/figwheel.html#starting-a-repl

I tend to use the figwheel hotloading of changes when saving source code files. I mostly use the REPL directly for experimenting with the atom that represents the state of the app. Updating the data in the atom affects the components that are ‘listening’ to that state, via reagent (or rum, react if using those instead)

If you take the Figwheel-main approach, then take a look at this guide for help https://practical.li/clojurescript/figwheel-main-projects/

If taking the shadow-cljs approach, then study the user guide in detail. It is very detailed and there are quite a few things to be aware of https://shadow-cljs.github.io/docs/UsersGuide.html

Thanks! Sounds like I’ll stick with fig wheel-main for a bit. I appreciate the pointers

By design, it does not matter, shadow away

I see. And here I was going through lenghts name destructred keys and such

You will only regret it if you shadow, and then forgetfully use the name inside that scope, forgetting about the shadowing, and wishing it were the clojure.core version

Especially with name :’)

The amount of time I’ve had that class java.lang.String cannot be cast to class clojure.lang.IFn…

Although Clojure is not concerned about shadowing, those who have to work with the code might not appreciate it. So if it’s meaningless code, then go ahead, but if its supposed to be maintainable code, then consider using more meaningful names.

any code sample?

(compare [0 2] [1]) ;; => 1

(sort '([1 3] [1 2] [1 1]))
;; => ([1 1] [1 2] [1 3])
(sort '([1 3] [1 2 3] [1 1]))
;; => ([1 1] [1 3] [1 2 3])

I expected the second one to be ([1 1] [1 2 3] [1 3]), and I wonder why it is like it is. Is this a performance optimisation, or is there some common use case where sorting by length first is nicer?

https://github.com/clojure/clojure/blob/5ffe3833508495ca7c635d47ad7a1c8b820eab76/src/jvm/clojure/lang/APersistentVector.java#L437

what else would you do?

My first intuition was sorting by elements first.

I don't know off the top of head how that decision was made or the factors that went into it

certainly it's faster to compare length of two arbitrary vectors than values

Lexicographer order with shorter vectors first as tie-breaker, i.e. dictionary order, would meet some people’s expectations, but it is slower for no -equal length vectors

Easy to write a lexicographic compare function if you need one, of course

Thanks everyone! I see this is a very old behaviour, for now I'll assume it's not built for some idiom I'm missing but is more of a performance thing.

A couple points: • there's not really a "last key" in a map (unless you're specifically using something like ordered-map) • your framework probably already includes a function that builds query strings. this implementation doesn't escape keys or values which is a security issue. even if it's ok for the current usage to skip escaping, someone may use it in another context in the future.

Thanks for the pointers @U7RJTCH6J. I am doing this because for the moment I am not using a framework, but that's good to know.

if I were trying to implement something like that, I would probably do something like:

(->> {:a 42
      :b :bar
      :c nil}
     (filter #(some? (val %)))
     (map (fn [[k v]]
            (str (name k) "=" v)))
     (clojure.string/join "&"))

even if you're not using a framework, both the java and javascript standard libraries have implementations

The particular API I am trying to hit for whatever reason retains keys that have no corresponding value in the query string.

is this clj or cljs?

CLJ

there is a great library https://github.com/clojure/tools.trace you can trace step by step to see what your form evaluated @U04AYRTELNM

hmm, it seems using the java standard lib version is less straightforward than I remember. anyway, there's a library that does just the query parameter part for you, https://github.com/ring-clojure/ring-codec

once i saw a trace tool to log each result generate by form but i forget what’s names

http://brownsofa.org/blog/2014/08/03/debugging-in-clojure-tools/ this one

see ring.util.codec/form-encode

if you think of this as a 'constructor' call, there is no 'this' in the context of constructor arguments, so I don't think so - more generally, I'd say the closest idiomatic thing would be a protocol function (but I'd happily defer to smarter people on that)

You want a record to have a way to include a reference to a function (by being the value of a field in the record), and you want the function to have a reference to that record. That is impossible if all of the references are immutable, because one of those two things must be created before the other, and thus the first one has no way to refer to the second one created.

However, if there is at least one mutable reference in there somewhere, it can be created.

Clojure records are immutable, so without changing their implementation, you cannot have a mutable reference inside of the record.

why don't you just make it a function on the record? then you'd get the this

needs to be from an interface, but definterface or defprotocol can do that for you

yeah, I could add even more details to the answer I was starting, but what I was describing is definitely the more involved difficult way 🙂

Thanks. I'm not really sure the best way forward. It's a nesting problem. I'm trying to augment a record by wrapping it with another.

(def A (->Foo [val "a value"
               foo-fn (...)]))

(defn make-b [v f]
  (->Foo [val v
          foo-fn (fn [x]
                   (let [y ((:foo A) x)]
                     (assoc y z v)))]))

So I guess I could work this out by making foo-fn part of a protocol? But then I still need to work out how that translates to wrapping one around the other. And can a protocol method also be a basis field at the same time?

Running clj does it - but it also starts a repl

The -P flag will download dependencies in deps.edn, clojure -P for the main dependencies of the project, clojure -P -M:test/run to download the main project dependencies and all the libraries in the :test/run alias

Thanks

I see it in the --help output under exec-opts now I just missed it

The -P flag also works with -X and -T flag aliases too, so long as the -P flag is first

Typically you don't really need to "install" dependencies, because whenever you start clj/`clojure` it downloads anything listed in deps.edn that is missing. You only need the`-P` flag if you have a specific goal that calls for pre-installing, such as avoiding network usage at a later time, or caching in a Docker image.

clojure -A:build:tests-deps:check-syntax-and-reflections:run-tests:build -Stree -A - all aliases deps which you want to include to install deps

maybe there is other way, than -Stree.

oh yes, I see -P was added 👍

but the point is -A which can be necessary to use with -P