(update-in 
  [{:name '(:value-required)} {:email ()}] 
  [1] 
  (fn [m] (dissoc m :email))) 

I believe u can do drop-last as well. As email is second element of your vector :

(def m (drop-last 1 [{:name '(:value-required)} {:email ()}]))

Thank you @UAEH11THP. not-every? was what I am looking for

Do clojure devs mainly do lookups on clojars to determine the latest version and only upgrade as needed?

i can imagine this getting complex as a project grows in dependencies

Maven and/or Clojars, yes. Or on the GitHub page of the project.

But there's a preference for reproducible builds so it's OK to use RELEASE for dev tools sometimes but not for builds you actually want to take to production -- we value stability.

FWIW, I use "RELEASE" a lot for quick dev exploration and testing, and most of my "dot clojure" file uses "RELEASE" deliberately to always pull in the latest versions of dev/test tooling.

See https://github.com/seancorfield/dot-clojure/blob/master/deps.edn

that's very helpful! thank you Sean 😄

Either I'm misunderstanding read-string completely or I'm making a very basic mistake. TIA.

Looking...

Ah, well, it's a syntax error

So we're not even getting to the point where load-string and slurp are being used

Looks like the compiler expects stuff to already be defined

But I do wonder if you could just define stuff with a stand in value, and then let stuff.clj override it

That' way it will compile and use the new value

At the same time I'm not sure if this is best practice. I can't say for sure though cause I don't know your goal. I imagine something like load-string is best used in the REPL.

I'm trying to have some sort of simple external configuration.

Use EDN instead of trying to write config-as-code.

Configuration should be "just" a data structure. In your example, stuff.edn would contain {:a 1 :b 2 :c 3} and you would use clojure.edn/read-string -- https://clojure.github.io/clojure/clojure.edn-api.html#clojure.edn/read-string -- to turn it into Clojure data

:thinking_face: Neat. I will take a look. Thank you guys.

cljs.user=> (require '[clojure.core.async.interop :as interop :refer [<p!] :rename {<p! await}])
nil
cljs.user=> (source await)
(defmacro <p!
  "EXPERIMENTAL: Takes the value of a promise resolution. The value of a rejected promise
  will be thrown wrapped in a instance of ExceptionInfo, acessible via ex-cause."
  [exp]
  `(let [v# (cljs.core.async/<! (cljs.core.async.interop/p->c ~exp))]
     (if (and
          (instance? cljs.core/ExceptionInfo v#)
          (= (:error (ex-data v#)) :promise-error))
       (throw v#)
       v#)))
nil
cljs.user=>

i didn't know about the rename part, awesome thanks!

You do not need quotes before fn1 or fn2 in that code.

The Clojure compiler will always tell you if recur cannot be compiled because it is not in tail position. Those example should both be in tail position.

That particular code is an infinite loop, unless something throws an exception, by the way, since all cases recur

You could also replace the entire (if ...) with something like this, if you like: (recur (if (apply-ok? apply-result) fn1 fn2) remaining-items)

Yeah, thanks. I wasn't sure of the "right" way to do something like this 🙂

And yes, I need a base case for sure 🙂

yeah i use ragtime for hobby and work too

I see it is not maintained for a while, does it have any audit feature? to see all db executions

it stores which migration was applied when, but that's all i think

probably not sufficient for a strict audit

so what are your main usages of ragtime? in workplace*

uh, migrate the database without having to manually run sql. we don't have strict audit requirements regarding database schema (yet)

I use flyway with Clojure

It's dead simple

I see it's not possible to rollback in the free-edition

how do you handle that?

I don't rollback

I test test test first locally, confident that later I won't need to rollback

I can't recall a time I had to rollback.

i figure if you have serious audit reviews "confidence" won't be sufficient

One is never 100% confident with software. It could fail at any point. However, I ensure that I've tested to an inch of its life locally.

I handle volumes of data that is approaching nearly 1 million entries per day

I see that the other lib's deal with rollback just as they perform the opposite-execution

And it's pretty damn important data too - insurance data.

I'm pretty confident 🙂

I don't see how that oposite will work well

those libs do up-down with create-drop

an 'undo' of 'flyaway' isn't really a rollback then

you have to write the .sql file yourself

If a n other lib does a drop of a table

how do you roll back that?

you don't

precisely

i'm just saying that the 'undo' in flyway is not a rollback

sql migrations, no matter the tech, are always fraught with the potential of scrwing your db up tremendously 🙂

youv'e been using the 'undo' then?

never used the undo

never had to

Flyway does point out the caveats of undo

Caveat emptor 🙂

Right now I'm in mongo territory

I'm not fond 🙂

heh

🙂

or rather 😞

Hey. I was facing the same error too. Try this

(:require
 ["react-checkbox-tree" :as CheckboxTree])
(defn checkbox-component []
  [:> CheckboxTree
                  {:nodes [{:value "a" :label "b"}]}])

Call (checkbox-component) to render it.

indeed that got it to work. any idea what could be the problem?

It should be defn and not def 'cos when I used def, it said expecting a function. Also the react-checkbox-tree expects :nodes as required property.

did you manage to get it to open/close?

needed to pass the values to on-check and on-expand like [:branch-check %]

it should work. can you post your specific example?

what's the error?

Sorry false report. My function had some problems. I got confused because (is) wasn't giving me the actual output.

you probably want to use concat?

or flatten?

(apply conj [1 2 3] [4 5])

but the phrase "what i want from conj" sounds strange. conj can do it in this case though

(don't use flatten, it doesn't do what you'd want in 99% of cases)

to me this looks like a classic use case for into

thank u all. concat, into and apply all work out. but then can i use them in reduce on characters of a string?( i want to analyze characters. but i get Don't know how to create ISeq from: java.lang.Character. on following code:

(defn stack [one two]
  (if-let [oneLast (last one)]
    (if-not (and (= oneLast \() (= two \)))
      (into [] (concat one two))
      (into [] (drop-last 1 one)))
    [two]))
(defn reduceStack []
  (let [reducedStack (reduce stack  (seq string))]))

(concat one two) makes no sense if two could be equal to \)

you can use (conj one two) if one is a vector and two is an element for the vector

also you can replace (into [] (drop-last 1 one)) with (pop one) if one is a vector

oh... one is a char like \a \b

also, the last arg to reduce is always processed via seq, you don't need to do that by hand

@U014CTZJK2S how could one be a character if above you call last on it?

I think you need to step back and think more clearly about the data representation here

@U014CTZJK2S a subtle and easy to miss error: you use reduce without the optional init arg, which means that on the first iteration, you get a Character as your "one", and on all further iterations you would get a Vector

I think you want (reduce stack [(first string)] (rest string))

that way the data type provided to stack remains consistent

also, you can simplify your code with the stack oriented functions (which work on vectors) peek (gets the last item of a vector) pop (gets the vector without the last element)

@noisesmith Yes u are right. but still i get "Don't know how to create ISeq from: java.lang.Character" from :

(defn stack [one two]
  (let [lastOne (last one)]
        (if (and (= lastOne \{) (= two \}))
          (pop one)
          (conj one two))))

(defn reduceStack []
  (let [reduced (reduce stack [(first string) (rest string)])]
    reduced))

you want (reduce stack [(first string)] (rest string)) and then the rest should just work

you are using an extra arg to reduce here (one which many of us wish was mandatory...)

@noisesmith Thank you so much. saved me hours ....

so are you looking for the list of references in the paper?

i think its how to cite this paper

or the reference for this paper itself?

No, I'm interested in citing This new clojure paper in another paper i'm submitting to Dynamic Languages Symposium in one month.

the info you need is in the footer isn't it?

this is a pre-print, I don't think the proceedings have actually been published yet

Yes, I can reconstruct it. But normaly one uses the official bibtex entry provided by the author or the publisher. But yes, it's not so difficult to construct one from scratch.

ACM Reference Format:Rich Hickey. 2020. A History of Clojure.Proc. ACM Program. Lang.4, HOPL, Article 71 (June 2020), 46 pages.

Is that a journal, or a conference preceedings. I think it is a journal.

conference proceedings

HOPL 4

ahh. good, I guessed wrong. HOPL is History of Programming Languages?

yaeh

https://clojure.org/about/history

see links

Nice article by the way.

some kind of websockets connection will undoubtledly be needed. sente sounds right up your alley and correct-amount-of-kill

if you’re interested in an example. I recently made a simple web app that let’s you play a networked board game with friends. It’s uses websockets to sync data between the open tabs: https://github.com/phronmophobic/wavelength_helper/tree/networking webserver code: https://github.com/phronmophobic/wavelength_helper/blob/networking/src/wavelength_server/core.clj single file html/css/js: https://github.com/phronmophobic/wavelength_helper/blob/networking/resources/public/index.html

all messages sent to the server on the websocket are broadcast to all the other users in the same “room”. there’s not a chat room, but it would be pretty straightforward to adapt for that use case

I've combined websockets and coreasync, which has some pubsub capabilities. I thought they were a nice combo. I also felt sente was kinda heavy for my modest needs.

Maybe https://github.com/jarohen/chord or https://github.com/lynaghk/jetty7-websockets-async

Here's what I tried with swap! but it doesn't work

(def supported-nontrivial-types
  "Which types are currently supported?  This list denotes the
  type names which appear as (something maybe-args), which are
  supported by RTE.  The goal is to support all those supported
  by typep, but that's not yet implemented."
  (atom #{}))

(defmacro register-type [type-name]
  `(swap! supported-nontrivial-types
         (fn [_] (conj @supported-nontrivial-types '~type-name))))

(register-type rte)
(register-type =)
(register-type member)

Show: Project-Only All 
  Hide: Clojure Java REPL Tooling Duplicates  (23 frames hidden)

2. Unhandled clojure.lang.Compiler$CompilerException
   Error compiling src/clojure_rte/rte.clj at (126:1)
   #:clojure.error{:phase :macro-syntax-check,
                   :line 126,
                   :column 1,
                   :source
                   "/Users/jimka/Repos/clojure-rte/src/clojure_rte/rte.clj",
                   :symbol clojure.core/fn}
             Compiler.java: 6971  clojure.lang.Compiler/checkSpecs
             Compiler.java: 6987  clojure.lang.Compiler/macroexpand1
             Compiler.java: 7092  clojure.lang.Compiler/analyzeSeq
             Compiler.java: 6789  clojure.lang.Compiler/analyze
             Compiler.java: 6745  clojure.lang.Compiler/analyze
             Compiler.java: 3888  clojure.lang.Compiler$InvokeExpr/parse
             Compiler.java: 7108  clojure.lang.Compiler/analyzeSeq
             Compiler.java: 6789  clojure.lang.Compiler/analyze
             Compiler.java: 6745  clojure.lang.Compiler/analyze
             Compiler.java: 6120  clojure.lang.Compiler$BodyExpr$Parser/parse
             Compiler.java: 5467  clojure.lang.Compiler$FnMethod/parse
             Compiler.java: 4029  clojure.lang.Compiler$FnExpr/parse
             Compiler.java: 7104  clojure.lang.Compiler/analyzeSeq
             Compiler.java: 6789  clojure.lang.Compiler/analyze
             Compiler.java: 7173  clojure.lang.Compiler/eval
             Compiler.java: 7131  clojure.lang.Compiler/eval
                  core.clj: 3214  clojure.core/eval
                  core.clj: 3210  clojure.core/eval
                  main.clj:  414  clojure.main/repl/read-eval-print/fn
                  main.clj:  414  clojure.main/repl/read-eval-print
                  main.clj:  435  clojure.main/repl/fn
                  main.clj:  435  clojure.main/repl
                  main.clj:  345  clojure.main/repl
               RestFn.java:  137  clojure.lang.RestFn/applyTo
                  core.clj:  665  clojure.core/apply
                  core.clj:  660  clojure.core/apply
                regrow.clj:   20  refactor-nrepl.ns.slam.hound.regrow/wrap-clojure-repl/fn
               RestFn.java: 1523  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   79  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:   55  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:  142  nrepl.middleware.interruptible-eval/interruptible-eval/fn/fn
                  AFn.java:   22  clojure.lang.AFn/run
               session.clj:  171  nrepl.middleware.session/session-exec/main-loop/fn
               session.clj:  170  nrepl.middleware.session/session-exec/main-loop
                  AFn.java:   22  clojure.lang.AFn/run
               Thread.java:  834  java.lang.Thread/run

1. Caused by clojure.lang.ExceptionInfo
   Call to clojure.core/fn did not conform to spec.
   #:clojure.spec.alpha{:problems
                        ({:path [:fn-tail :arity-1 :params],
                          :reason "Extra input",
                          :pred
                          (clojure.spec.alpha/cat

deref of the thing you swap! on inside swap! is an error

the value of the thing is passed to the swapping function, that's the value you need to use

`(swap! supported-nontrivial-types
        conj '~type-name)

also, this is symbol in / symbol out, you can just use ' in the initial call and use a function instead of a macro

finally, the compilation error is because (fn [x] ...) is invalid inside ` - the transform turns x into ns/x which is an invalid binding

Ahh I've had this problem many times. what is the correct way to put an anonymous function inside a quasiquote?

(fn [x#] ...)

but you don't want that here, for reasons already described

great that works.

so this works as well.

(defmacro register-type [type-name]
  `(swap! supported-nontrivial-types
          (fn [_#] (conj @supported-nontrivial-types '~type-name))))

but as you pointed out this is simpler:

(defmacro register-type [type-name]
  `(swap! supported-nontrivial-types
          conj '~type-name))

the fn is not needed, and the deref inside swap! is a race condition

not just simpler - actually correct

if you need the anon-fn in the future, use the value passed in instead of calling deref inside the body:

(fn [v#] (conj v# ...))

usually you don't need this due to how swap! lets you use varargs

In my case each symbol registered adds a new syntactical element to a DSL.

when the DLS is parsed, and an unregistered symbol is encountered, I print the valid symbols as part of the error message.

(remove #{:default} (keys (methods m))) seems like it would do that

frankly, even though I was skeptical, its not a bad suggestion.

it's a bit of a forced fit sadly - you could wrap the fact that it's a multi with a simple set of functions

Here is where it is used https://gitlab.lrde.epita.fr/jnewton/clojure-rte#how-to-extend-the-type-system

in case you're interested

If you are already using CIDER, you are in luck. https://docs.cider.mx/cider/debugging/debugger.html

There are a bunch of other things there, apart from the debugger. I have not used those, but looks super helpful.

Oh! There’s a bunch of stuff there! I’ll go back and read the manual!

also consider that if you are coding idiomatically (using immutable data) you can use swap! or def to capture data in a function, and then use it as you like in the repl

Ok, you mean like writing data from inside a function to an atom outside?

eg.

(def debug-data (atom []))
(add-tap (fn [x] (swap! debug-data conj x)))

(defn f [x y x]
  (tap> {:context ::f :x x :y y :z z})
  ...)

Ah, I see!

there are a few corner cases where a proper debugger like in CIDER is still clearly better (when using volatile state / ephemeral objects that lose meaning outside one narrow context), but good clojure code minimizes such things, and the technique using tap> and an atom works everywhere (no matter your editor or run environment)

a variant for code you don't control:

(alter-var-root #'some-lib/foo (fn [f] (fn [& args] (tap> {:context :some-lib/foo :args args}) (apply f args)))

So for example when I want to tap some data I’d replace (existing-form) with (do (tap> a) (existing-form))

Or tap just evaluates the third thing?

pretty much - you can send whatever you want to tap> - note that defn, let, when etc. all have implicit do already

Oh! That’s neat

So the “variant for code you don’t control” is like wrapping a function and tapping function args?

yeah - the basic template is (alter-var-root #'foo/bar (fn [f] (fn [& args] (apply f args))) - that's the no-op version, but you can fill in any other logging / inspection / alteration of args or return value as needed for debugging

And that’s something you’d do in a REPL? Some (in-ns 'x) and then do the thing with a symbol?

you don't need to change namespace - it takes a fully qualified var

Ok I see

yes, this is something you'd set up via a repl or scratch buffer

(ins)user=> (alter-var-root #'clojure.core/subs (fn [f] (fn [& args] (println "subs:" args) (apply f args))))
#object[user$eval208$fn__209$fn__210 0x1ab6718 "user$eval208$fn__209$fn__210@1ab6718"]
(ins)user=> (subs "hello" 1 3)
subs: (hello 1 3)
"el"
(cmd)user=> (subs "hello" 3)
subs: (hello 3)
"lo"

Ok nice!

A scratch buffer is just a place to evaluate some forms from? Can you use Emacs normal scratch buffer for this?

there are gotchas (like you need to require / reload the entire namespace to get the old def back), but it is a useful trick

yeah, by scratch buffer I just meant code that isn't part of your project that you can send to your repl, some people find that preferable to typing into a repl directly

there's a special cider-scratch buffer iirc (I haven't used emacs in years)

Ok, yeah I like having this at the bottom of my file

(comment
  (f 1 1)
)

exactly

I'll often have a separate file, not in project source control, where I combine links to places in the project code, exploratory repl snippets, and a to-do list, with the work ticket in the file name oh, and I'll put sample data captured in the functions I'm interested in the file too

in emacs org-mode is perfect for this sort of thing IMHO

Cool! Elaborate workflow!

What are you using now after leaving Emacs?

vim - but any editor would work with this workflow (I do have plugins that run a repl in a buffer, and send a selection to that repl etc. but could copy/paste the normal way...)

Ok! I have years of experience with vim but figured I try some Emacs with Clojure. Tried vim-fireplace in vim. Are you using some sexp editing tools as well?

vim-clojure-static, vim-sexp, neoterm and fireplace in neovim I start nrepl in a neoterm terminal, use neoterm to send selections to that terminal buffer (I like this as it gives me a trace of things I tried and outputs as the repl scrollback), and then I use fireplace for :Require which just reloads the whole file, and sometimes the jump-to-def and show-docs features of fireplace

I like vim-sexp because I use text-objects heavily in editing, and that maps perfectly to clojure forms

Thank you for all your tips!

I’ve written down most of it.

🙇

I should make a blog post, but so much of what I do is just copied from talks / posts by others in the community most of the work would be in collecting and properly citing references

page edited. 30 seconds!

haha, thanks, I didn't have login handy or I would have done it myself