For something like that, I'd probably turn to regex... Clojure exposes all of Java's regex functionality in an idiomatic way.

(str/replace input #"^[^:]+: " "") might be reasonable to just remove the leading text, up to and including the : characters?

Fair, I was mostly trying to learn Clojure so decided to implement the logic in clojure.

That feels like imperative/iterative thinking -- part of being fluent in Clojure is trying to work at a higher level: working at the whole collection (or whole string) level instead of at the element (or character) level.

Depending on your background, that can take time since you may need to "unlearn" a bunch of habits from other languages...

True, have been using Java and similar languages for over 10 years.

That's a lot of "bad" habits to unlearn 🙂 If it's any consolation, I did Java and similar for over ten years too before coming to Clojure back in 2010.

(and before Java I did over a decade of C++/C)

Yup, I guess I’ve to push through the discomfort of feeling of starting from scratch again. Thanks for suggestions though 🙂 FWIW I think using -> in this method is making things more readable.

Yeah, coming from a lot of OOP to FP, it really feels like being a complete beginner all over again...

Sidestepping your methodology for the particular example, I often build things from the inside out just like that. To help with this, the popular editors should offer both automatic parentheses balancing and Paredit ( "strucural editing" ). You should not try to swallow all of Paredit in one go, but picking up useful commands here and there over time will definitely pay off. A good straightforward place to start is with Slurp and Barf, which will move expressions into and out of parentheses without having to add/delete parens or copy/paste any code. So at this step ( representing the cursor with | ) ...

(rest|)(str/split message ":")

(rest |(str/split message ":"))

What editor are you using?

Me? VS Code.

Yup, same. VSCode with Calva

@U90R0EPHA slurp is really neat trick 🙂 thanks a lot for that.

If not mistaken, Paredit originated in Emacs for Common Lisp.

In my Emacs setup, it looks like this:

@U0K064KQV I did it that way before I learned to Slurp.

@U04JZS3AC59 You're welcome. Slurp can also go backward instead of forward, and Barf does the inverse, spitting the expression closest to the containing paren out of the front or back of the form.

Once Slurp and Barf are getting into your muscle-memory, go look at https://calva.io/paredit/ to find something else that looks promising to your workflow. (After slurp/barf, my next step would probably be some navigation commands, but you find your own path.)

Never got used to slurp/barf, went back to just backward/forward/up/down/raise sexp instead. Feels I'm faster with those and they are more reliable.

You can also do this:

The slurping seems slower to me, but also I don't like that it temporarily means I don't have the parenthesis the way they are meant to. But YMMV, the point is there are many options.

If it wasn't obious, in none of those examples did I use the mouse

> Feels I'm faster with those and they are more reliable. Fair enough. I got an extra boost on Slurp/`Barf` because, at the time I learned it, I was getting way more mileage from Slurp Backward than would be normal because of writing experimental code that would typically end up in either -> or comp in the wild.

(some-fn)|
(some-fn)(some-val|)
((some-fn) some-val|)

> You can also do this: editor-flow2.gif Not sure what command you are using here, but the behavior is exactly the same as slurping; except you are doing extra keystrokes to move the cursor the next contained form before doing what amounts to a Slurp.

I'm using TAB. It's more like parinfer, it just aligns the parenthesis with the spacing. It's called Lisp indent and List dedent (the opposite).

Sorry I misread it.

You're right, it behaves a bit like slurp forward and barf forward I guess. Never really thought about it too much haha. But it only works on independent lines

Not sure exact logic of what you are showing, but the result is still the same steps as Slurp, but Slurp use fewer keystrokes and less precision of cursor placement. You are going to the form you want to move and somehow pushing it backward into the target, while Slurp lets you just pull it in from where your cursor already is, inside the target.

I'm just doing TAB or SHIFT-TAB

No idea what command Tab or Shift-Tab does in your setup. In Calva neither of those keys would have any effect on paren balancing by default.

Yup I think that luxury is limited to emacs 😞

Don't think it exists in VSCode.

It's called adjust-parens mode in Emacs

It reminds me of Parinfer.

I would absolutely hate it if Tab affected paren balancing.

Ya, it's kind of like a less intrusive Pareinfer. Pareinfer indents based on the parenthesis, so you type the parenthesis and it indents. This does the opposite, you indent or dedent and it fixes the parenthesis.

Hum, no I got that wrong. Pareinfer fixes the parenthesis based on indentation as well, sorry, but this only does it for explicit indent and dedent calls, while pareinfer is always doing it even if you space, erase, etc.

Pretty sure Parinfer has 2 modes? the well known one editing parens based on indents, and the other editing indents based onb parens. But it doesn't sound like you are activating such a toggle, so idk.

Not a fan of Parinfer myself. Not enough value added to pay for the use of magic, imo.

Oh right, that's probably why I got confused. No this is just one mode, basically you say indent to the next level and it indents the form adjusting the parens. Or you say dedent and it does the opposite.

Pareinfer is too intrusive, like if you paste code, it will rewrite the parenthesis if the indentation is wrong for example. I find this is less intrusive, though it is a bit less powerful as well.

Hmmm. Less intrusive, but also less powerful..... It's almost like there are trade-offs when choosing your tools. 😉

See: https://wikemacs.org/wiki/Lisp_editing#Managing_parenthesis

They say: Parinfer [...] It could be seen as a more advanced adjust-parens.

The pasting code issue was my biggest annoyance with parinfer. But my only real obstacle with paredit was just investing the time to learn it (and learn the key bindings for my current editor). It was time well spent - and it just continues to make me more and more productive as I learned more of it.

(I was not a fan of paredit for years BTW)

We are a long way off the OP's question at this point... So I hope this diversion has been useful...

> We are a long way off the OP's question at this point... So I hope this diversion has been useful... From my interpretation, OP clearly described a frustration keeping parens balanced. So I do not think we are all that far off track... 🤷 @U04JZS3AC59, please feel free to restate your concern if you think we've gone off the rails.

This conversation have been more than helpful thanks a lot guys. I learned quite a few things today. I am already loving slurp 😛

@U04JZS3AC59 , my recommendation up next after slurp, if you haven’t seen in the paredit guide, is the 2 pairs of commands for alt-arrow keys! (Correct me if I’m wrong I believe these are default calva bindings) Alt-left and -right traverse to the start/end of sexp. So, outside a paren you’ll jump across the form to its match. Inside a paren, your cursor points to the individual form it’s touching, which means jumping across individual symbols/primitives/etc Alt-up and -down jumps the cursor similarly, but move the form it’s touching along with it. It just swaps the position of neighboring forms without rebalancing anything. So it is probably the simplest/most linear way to reorder the content within a sexp, easiest to use without garbling up the structure. And, paredit bonus, alt-up and -down will maintain pairs in maps, moving two forms the k and v at once! To me, slurp/barf, forward/back, and shuffle are the simple trinity of paredit with the most bang for your buck :)

It's helpful if you can try to use Command Names instead of (or in addtion to) shortcuts. This way, no matter what platform someone uses, they can find the command in the Command Palette or the Keyboard Settings Panel, or know what to look for in the https://calva.io/paredit/. Plus in this case, many other editors also offer Paredit, so your suggestion is potentially useful to anyone. I think you are describing Forward/Backward Sexp (which defaults to Ctrl+ →/`←`on Windows or Linux) and Drag Sexp Backward/Forward ?

Hi, all true! Wrote that on the couch early morning without a desktop in front of me. Correct, just checked and didn't know fwd/bkwd sexp defaulted to ctrl outside of macos. Thanks for the clarifications, all accurate, and helpful advice

https://www.clojure.org/about/rationale

See also work-in-progress https://jank-lang.org/

Clojure can now be compiled to native code as well. https://github.com/clj-easy/graal-docs

Thanks!

Some additional details on the native question in the https://clojure.org/guides/faq#native

(mapv #(str %) "some string")

well this will give me a vector, and I wanted a list 😞

https://clojuredocs.org/clojure.core/doall

(type (map #(str %) "hi there"))
=> clojure.lang.LazySeq
(type (doall (map #(str %) "hi there")))
=> clojure.lang.LazySeq

Oh, a list specifically,.maybe wrap it in with (list ...)

Or try: (into (list) ...)

if wrapping with list then I need to do (first (list (map #(str %) "hi there"))) a bit ugly, isn't it something build -in like map to return non lazy list?

What are you trying to achieve? It's not idiomatic to work with specific types.

I want to build a list from a string and peek on an element

and vector peek and list peek are different

call first from the result of map. you don't need a list for that

You can peak into a LazySeq as well:

(first (map inc [1 2 3]))

ok, and how do I pop if needed?

You don't have to "pop", you traverse the sequence

Otherwise you can use the transducer map to return a list: (into (list) (map inc) [1 2 3])

To rephrase: why would you need to pop?

You would pop with rest and peek with first over sequences

btw https://clojuredocs.org/clojure.core/pop works with lazy seqs just fine

OK let say for example I want to check a string that is valid only if I have paired brackets so this is a valid string (())[{}] in java we do that with stack data structure

@U04V4KLKC I don't think so. Pop doesn't seem to be implemented for LazySeq

> OK let say for example I want to check a string that is valid only if I have paired brackets so this is a valid string (())[{}] in java we do that with stack data structure > I'm pretty sure you can do that with filter and then just string substitutions. A more imperative approach would be reduce. Neither solution requires popping lists :)

I think you're trying to do this:

(->
 (reduce
  (fn [acc e]
   (if (= "(" e)
    (conj acc e)
    (pop acc)))  
  (list)
  "(())(())")
 empty?)

(This would work with a vector too btw)

Thanks guys, I'll try that 🙏

Ya, both vectors and lists can be used as a Stack. Even though conj/pop/peek on a list is the first element, and conj/pop/peek on a vector is the last element, for a Stack it doesn't matter, conj/pop/peek still behaves in a first-in-last-out manner.

Absolutely!

Is it easy to integrate Clojurescript in my webpack bundling? Or should I take an independent route to get Clojurescript into the project?

I would suggest going an independent route, with shadow-cljs

there's some information here about using it with webpack if you still have a need to, but I would try vanilla shadow-cljs and see how you get on https://code.thheller.com/blog/shadow-cljs/2020/05/08/how-about-webpack-now.html

shadow-cljs looks fine. Thanks

Clojure and ClojureScript are approximately 99.99% the same language, although the hosts they run on are quite different as are the types of applications build (e.g frontend, backend) http://funcool.github.io/clojurescript-unraveled/ is a good ClojureScript reference https://clojurescript.org/ provides a good starting point. If using shadow-cljs, then ensure to read https://shadow-cljs.github.io/docs/UsersGuide.html in detail Or https://figwheel.org/ if using figwheel.main instead of shadow-cljs

Where is your build.clj

ah! I don't have one

Somehow I thought using deps.edn meant you didn't use build.clj

If you haven’t yet, might want to read https://www.clojure.org/guides/tools_build

Okay so I created it:

(ns build
  (:require [clojure.tools.build.api :as b]))

(def lib 'my/lib1)
(def version (format "1.2.%s" (b/git-count-revs nil)))
(def class-dir "target/classes")
(def basis (b/create-basis {:project "deps.edn"}))
(def jar-file (format "target/%s-%s.jar" (name lib) version))

(defn clean [_]
  (b/delete {:path "target"}))

(defn jar [_]
  (b/write-pom {:class-dir class-dir
                :lib lib
                :version version
                :basis basis
                :src-dirs ["src"]})
  (b/copy-dir {:src-dirs ["src" "resources"]
               :target-dir class-dir})
  (b/jar {:class-dir class-dir
          :jar-file jar-file}))

But when I do clj -T:build uber I get Namespace build loaded but function not found: uber.

This is because there is no uber function in your build.clj? :)

Yep just figured that out 🙂 It works now. Thanks for the help. It's my 1st day with Clojure.

Think of tools.deps (aka deps.edn) as a Clojure launcher. All it does is launch Clojure programs (and download their dependencies if needed in order to launch them). Every alias describe a different program to launch or the same program launched with a different context (different entry point, different dependencies, different jvm arguments, etc.) And then the "build" tasks are just Clojure programs you launch with tools.deps. So what you're doing is just telling Clojure that clj -T:build uber should launch the script from build.clj with the uber function as the entry point, and that it should be launched in the context of a tool.

well , there is no such filter by namespace existed, i think it's not hard to write one

(into {} (for [[k v] m :when [(= "foo" (namespace k)] [k v]))

(into {} (filter (comp #{"foo"} namespace first) m)) if that's how you roll

I roll many ways 🙂

(defn select-keys-namespaced [key map]
  (filter #(= (namespace %1) (name key)) (keys map)))

noice

thank you everyone, very helpful 🙂

generally no reason to do that except at an edge in the system

(wire / database)

(ignore the stuff you don’t care about in a particular context)

There isn't a Clojure one in the standard library

Most people would use a third party one over interop, I'd imagine

I've used the Java 12(?) HTTP client via interop and it's pretty easy but usually go with clj-http

Generally the standard library is considered to be Java standard library + Clojure core library. It's very rare Clojure will provide its own when Java has one that's good enough.

It's kind of part of the "being hosted" mantra, don't reinvent the wheel if there's not any major benefits.

I guess I'm unclear as to what parts of Clojure are novel, and what are just wrappers around Java SDK.

Hum, I don't think there's a clear ways to know haha. I/O is normally always wrappers, because the JVM already took care of creating Write ounce, Run everywhere IO abstractions over multiple operating systems and hardware targets. Everything related to the Clojure syntax, the immutable data-structures, the Lisp macros, the higher order functions, STMs, Atoms, Agents, transducers, sequence abstraction and all the sequence functions, core.async, etc. is all Clojure novel.

Sorry for the silly questions. The last time I studied a Lisp-like language was in college in 1992 when I learned Scheme.

Clojure's even more fun than Scheme

Java comes with a better built in http client than httpurpconnection these days

https://docs.oracle.com/en/java/javase/11/docs/api/java.net.http/java/net/http/HttpClient.html

All I remember about Scheme is car and cdr

those days are GONE!

^ that's the HttpClient I meant

> I guess I’m unclear as to what parts of Clojure are novel, and what are just wrappers around Java SDK. Idiomatic Clojure allows the use of immutable, persistent data structures in your general coding. It has great data literal syntax to make domain modeling quite simple. Spec (and other 3rd party libraries) allows for opt-in contract enforcement at runtime if you like. Using a REPL is incredible once you get used to it. Using a query-able repl is a game changer in my opinion (check out (find-doc "binding") to search all docstrings that mention “binding” for instance. And after all of this, if you want to hit the host language, you can just interop directly with anything on the jvm already (like reusing an existing http client). There’s a lot to love about Clojure and there’s always the jvm underneath when you need it

I was just playing around with GraalVM and being able to compile Clojure down to a single native binary is also very appealing.

There are some pitfalls to it but there’s lots of tooling using that route to make some responsive goodies.

clojure.core/slurp accepts url, kinda built-in pure man http client :)

https://github.com/gnarroway/hato wraps HttpClient and is pretty similar to clj-http if you don’t mind a third party library with no extra dependencies edit: I remember the reason I switched over to Hato over clj-http-lite (which uses HttpUrlConnection) was that HttpUrlConnection doesn’t support the PATCH verb, which was pretty annoying 😐

Most likely a version conflict -- you're using a more recent version of Clojure than the tutorial works with.

You could fix this by either using an older version of Clojure or by using a more recent version of Lacinia I expect.

but I have chosen the newest of both

Ah, then maybe you have a syntax error in your own code... what is percap.schema?

that is my namespace located in the src/ folder

and what does the ns form look like in your own code?

(ns percap.schema (:require [http://clojure.java.io :as io] [com.walmartlabs.lacinia.util :as util] [com.walmartlabs.lacinia.schema :as schema] [clojure.edn :as edn]))

What about the code where you are requiring percap.schema :as s?

That's the form I think it is complaining about...

I dont understand the question

(user (:require [percap.schema :as s] [com.walmartlabs/lacinia :as lacinia])) is what it is complaining about in that exception.

yes

ahh

im stupid

it should be percap/schema right?

No, namespaces have . in them -- / is for files.

What file is that (ns user ..) form in?

(ns user (:require [percap.schema :as s] [com.walmartlabs/lacinia :as lacinia]))

its located in dev/user.clj

I think i found it now.

[com.walmartlabs/lacinia :as lacinia])) should be [com.walmartlabs.lacinia :as lacinia]))

thank you for your help! now i have a different error that I need to figure out

Oh, ouch. Sorry, I should have spotted that...

np 🙂

FWIW, group/artifact for dependencies has no relation to that might be inside it. It can be confusing if they look similar (as in this case).

thanks