I’m going through 4clojure exercises and was asked to create palindrome checker. What I’ve done is

(defn palindrome? [v]
  (loop [original v reversed (reverse v) result false]
    (if (empty? original)
      result
      (if (= (first original) (first reversed))
        (recur (rest original) (rest reversed) true)
        (recur (rest original) (rest reversed) false)))))

(defn palindrome? [v] (= (reverse v) (reverse (reverse v))))

They could've substituted (reverse (reverse v)) with (seq v).

know what you feel. IM a little but further on 4 clojure and still feel stupid @peb.brzezinski

How does that work @jaihindhreddy? (= (seq [1 2 3]) (reverse [1 2 3])) why are they equal? :thinking_face:

@peb.brzezinski what does reverse [1 2 3] returns ?

I know it returns (3 2 1)

But then I don’t get why (1 2 3) is equal to (3 2 1)

oke

Seems like I need to read a bit about seqs. Anyway, thanks for making me dig deeper 🙂

YW

@peb.brzezinski It’s not, because (1 2 3) is not a palindrome

lol, right

haha

I have to repeat every character in a seq 2 times. Is this a good solution or can it be improved

(defn my-repeat2[s]
  (flatten(map (fn[item](repeat 2 item)) s)))

@roelof and @peb.brzezinski when I compare my code that of more advanced Clojure developers, I too am often humbled. I’ve still much to learn, and I since I find joy in learning, especially amongst such friendly guides, I find that exciting.

@lee I agree totally with you. The community is very helpfull here

Sure thing, this is the best way. I always enjoy a good feedback/peaking at a better solution. This is one of the reasons I try to work through 4clojure and one of the reasons I’ve been going back to exercism so often 🙂

that are the two thing I do now. 4clojure for the practising and exercism for practising and the feedback of hopefully experienced developers

Hello all, does anybody have a quick reference they can point me to for setting up a networked repl connection? I'd like to remotely repl into a production app using the CLJ CLI. Thank you!

How do I make sure cloverage covers spec/keys. For some reason my test aren't covering most of them (under the forms %)

@andyfry01 socket REPL, pREPL, nREPL?

there is no "socket REPL", there is a stream-based clojure.main REPL. all of these repls operate remotely over sockets.

What do you experts think of my solution of the re-implmentation of range

(defn my-range [low high]
  (if (> low  high)
    ()
    (cons low (my-range (inc low) high))))

check (my-range 1 1) vs (range 1 1)

solved

(defn my-range [low high]
  (if (>= low  high)
    ()
    (cons low (my-range (inc low) high))))

One last question for today (I promise :P). I tried to implement dedupe function

(defn my-dedupe [val]
  (reduce #(if (= (last %1) %2) 
             %1
             (conj %1 %2)
             ) val))

your paren placement is super weird

try using an init for the collection rather than the implicit one (first item in (seq val) )

It was easier for me to read that way, but I get your point.

instead of (reduce f "string") , (reduce f [] "string")

@peb.brzezinski it will be easiest in the long term if we all agree on what the layout should look like - lisp conventions don't put hanging ) on its own line, especially not as a leading character before other forms

Got it 👍

it's kind of like driving on the same side of the road - it's easier if we all stick to the agreement

Sure, I have nothing against conventions. Thanks for pointing that out.

(fn [val]
  (reduce #(if (= (last %1) %2) 
             %1
             (conj %1 %2)) [] val))

also, not everyone agrees here, but I prefer to align args horizontally if they are siblings - I'd write that out as

(fn [val]
  (reduce (fn [acc e]
            (if (= (last acc) e)
              acc
              (conj acc e)))
          []
          val))

Ah ok, so each arg to reduce on the same lvl.

I like that.

that makes it clearer to me - not everyone sticks to that of course

also, if a #() is complex enough for line breaks, I prefer to be able to name args

but I tend to waste more vertical space than others prefer

I prefer being explicit too in that case, I’m just trying to get used to the shorthand version of anonymous fns.

(partial reduce
         #(if (= (last %1) %2)
             %1
             (conj %1 %2))
         [])

(that's not how I'd ever write anything)

I think roughly 3 forms is a sensible limit for shorthand lambdas

I'd never specified a number myself, but that sounds about right

also I'd always replace #(do ...) with an fn that has implicit do

and I never use #(let [... ...] ...)

Both of those give me anxiety. Good suggestion.

hi:) New here - quick question on IDEs. I've been used to working with VS code for some time now, but I understood there are much stronger IDEs for Clojure. Anyone had any experience with the VS Code extensions for Clojure and can recommend?

I use Calva for some weeks and very very happy with it

VS Code with Calva gives you all the essential features

The intellij + cursive option is very good too. I don’t write a ton of Java, but my experience is that if you do, you want a full-blown IDE.

Emacs is often praised. But the two times I tried I ended up in configuration hell and decision fatigue.

yeah, the emacs and vim integrations are quite featureful, but I wouldn't start learning emacs or vim just to use them with clojure

Calva is great out-of-the-box and you get auto-formatting and linting right along with it. I'd recommend that for a Clojure beginner since it does a lot for you without having to understand all the detail yet.

I'll +1 VS Code for Clojure development (although I use Clover, rather than Calva -- Clover requires a bit more knowledge of stuff, since it uses a Socket REPL instead of the more common nREPL that Leiningen starts up).

@ilan800 welcome! I'm the creator of Calva. It's made with people for whom VS Code is home turf. Please see Tao of Calva and see if it seems to chime with you. https://github.com/BetterThanTomorrow/calva/wiki#the-tao-of-calva

Thank you all for the answers!:) I'll definitely start using Calva

Nice! Please feel welcome to #calva for assistance.

Im not really trying to change your mind, but if you want to start with a predefined emacs setup ready for clojure, I would use #practicalli spacemacs.d configuration and all instructions proposed there. It is the closest from the out of the box I know. Its emacs, out of the box and still open

Good evening, morning, night, day (depending where you live in the world!) Say I wanted add to an array this is found on a key in a map inside of a vector atom, how would I do that? Simple example: (def todos atom [{:id "1337 :desc "todo-list" :todos []} ]) How would I add todos this atom?

@georghagen (swap! todos conj ...)

@georghagen an atom is a container that manages the changes to its contents, the basic things needed are swap! and deref

it looks like your atom has a weird structure, which means you would need to use a more complex call to swap! or use a simpler structure

Any suggestions for a simpler structure?

for example

(ins)user=>  (def todos (atom []))
#'user/todos
(ins)user=> (swap! todos conj {:what "homework" :when 0})
[{:what "homework", :when 0}]

currently your "todos" seems to contain metadata that isn't the contents, but about the contents

In JS I would just do todos[0].todos.push({id: 2, desc: "okdf"}). Yeah maybe I should just show you my real example

(defn create-checklist [] { :id (.toString (java.util.UUID/randomUUID)) :sequenceMap [] ;Map<Integer, UUID> / Map of question number vs question UUID, to create sequences for each checklist / :answerMap [] ;Map<Integer, UUID> :expectedAnswerMap [] ;Map<Integer, UUID> :isSigned false })

[] is never a map in clojure

Im using a template from a kotlin programmer

yeah, that doesn't really look like clojure code (though it would compile)

you can combine swap! with update-in to do nested operations

ins)user=>  (def todos (atom {:id 0 :items []})) 
#'user/todos
(ins)user=> (swap! todos update-in [:items] conj {:what "homework" :when 0})
{:id 0, :items [{:what "homework", :when 0}]}

this is closer to what you initially had

but using an atom and def already implies a global / singular nature that doesn't line up with the particularity of having and id etc. at the top level

Aha! I see.. I am using to simulate a database

because I am creating mock data for a frontend

right, that's the usual role of an atom

on reflection my first example is closer to what you had, I misread it

having a vector at the top level of an atom is relatively rare, usually you want keyed rather than indexed lookup

but perhaps your db is actually a queue or stack

Nono, it was a choice made without too much thought. I am coming straigth from javascript

straight*

I have not chosen a db yet actually

right, instead of [{:id 10 ... ...} {:id 20 ... ...}] we'd usually have {10 {... ...} 20 {... ...}}

(or in your case actually the uuids you generate)

Yeah of course, makes much more sense to have the UUID as a key to your other checklist data

Nice!

unlike js we only sometimes use hashes as "objects", and generally use them as databases

so more like

(ins)user=>  (def todos (atom {})) 
#'user/todos
(ins)user=> (swap! todos assoc (java.util.UUID/randomUUID) {:what "homework"})
{#uuid "701b9c5d-6d61-45e6-bf81-8024953aa50d" {:what "homework"}}

@georghagen a pattern you'll likely see is that most of the sort of code you'd usually write is replaced with a few combinations of collection operations in clojure code

Yeah, that's what I really love about Clojure. I just have to get more experience to know my way around the collection operations! Thanks a lot for all the input, can't wait untill I can start contributing back to the clojure community myself 😃

GN my friends. Hopefully I can work on exercism or 4clojure or my web project tomorrow

IS there a good free hosting platform for the website im building with compujure and ring ?

@georghagen You should maybe consider looking into the set data-structure and relational operations. Your collection looks like a set (since it has unique ids). You can use index to get a map from a unique key to each item in the collection, you can join sets arbitrarily, select on a predicate and so on.

If you are new to Clojure (or not!), we would love to have your feedback in the annual State of Clojure survey https://www.surveymonkey.com/r/clojure2021 - we've been doing this survey in the community for about a decade and it provides important information about trends and usage. If you're interested, last year's results can be found here: https://clojure.org/news/2020/02/20/state-of-clojure-2020

I'm having trouble finding the clojure equivalent of lein deps, has anyone got it to hand?