Hey, coming from the JS community and formatter like prettier https://github.com/prettier/prettier , is there like one formatter considered as a standard in clojure, so far I found clfmt https://github.com/weavejester/cljfmt

Hi. I have seen someone using a keyword like that: :a/b/c 1. is it normal? 2. what is the semantic of a, b, c ?

no, that’s wrong, don’t do it

I must admit, I was a bit surprised at just how permissive the reader is about keywords...

user=> :a//
:a//
user=> :a:b
:a:b
user=> :
:

I saw it in a recent JEE conf in a talk about clojure. https://youtu.be/Svhhga9Rxnc?t=1448

Does the '/' in the keyword have only a conventional meaning or a real technical meaning? What other character we should use to replace it if we want to represent a kind of directory or tree in the keyword?

@vincent.cantin It has a technical meaning as well. It separates the two parts of the keyword - the namespace and the name. These are separately accessible through functions with those same names, and are provided as separate arguments to the keyword function. If you want to have a namespace with deeper hierarchy, you should use "." separators like regular Clojure namespaces.

eg. :a.b/c

What is the internal representation of keywords, flat string or structure with a namepace and a local id?

Internally they're objects with a bunch of stuff

but the short answer is, the latter

They seems to be implemented as wrappers around symbols https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/Keyword.java#L28

@michael.gaare you are right: https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/Symbol.java#L63

Are there any good libraries for testing external REST APIs? I could just use clojure.test with some generic http client, but I wonder if there are ergonomics/conciseness out there that I might be missing.

Hi. Could you suggest Clojure quick start book or website?

@relan https://clojure.org/community/resources#_tutorials_and_learning_materials

What you should choose really depends on your learning preferences and background

Hi

(defn health [level]

(if (= level :low) "Go to doc" "You are fine"))

How do I call health function

(health [:low]) is giving and error

you should call (health :low)

Got it !!

without the []

Yes man

👍

Thanks anyway

Clojure's syntax is simple if we look beyond the parentheses :)

(def mylist '(1 2 3 ) )

(map inc mylist) 

Kindly explain the above snippet

you’re defining the Var mylist to be the list with elements 1, 2 and 3, and then mapping over it applying inc over every argument

So to use two functions for the same data structure u use ; (first function second function data-structure)

Is it correct?

no

you always do (my-fun arg1 arg2 arg3)

map is a function that takes a function as its first argument and a collection as its second

it’s called a higher order function

Ooooooo

Okay

Can u provide another example ?

what are you trying to do?

i.e. are you calling a function for its side-effects or to transform some data to be used in a later fn?

Transform some data to be used in a later fn

are you looking for something like this?

(let [mylist '(1 2 3)
      a (func-a mylist)
      b (func-b mylist)]
  .. use `a` and `b` here
  )

or

(let [mylist '(1 2 3)
      a (func-a mylist)
      b (func-b a)]
  .. use `a` and `b` here
  )

and as @madstap mentioned if you don’t need to reference the value a separately, you can do:

(let [mylist '(1 2 3)
      b (func-b (func-a mylist))]
  .. use `b` here
  )

@bjr whats happening in the first code ?

I see that mylist gets (1 2 3)

After that..i didnt get it

func-a is executed with the value of mylist and the result is bound to the symbol a

then the same is done with func-b

the value bound to the symbol mylist does not change

and the symbols mylist, a and b can all be used within the body of the let expression

Okay..got it now !

Gracias

de nada

Btw..as per my understanding ..clojure has Own standard library + Clojar + java ecosystem ?

yeah, something like that

Niceeee

super late to the party but here's my 2c anyway: I love elixir's pattern matching support in functions (especially symbolic equality matching) and like clojure, it also supports macros (you can manipulate code as data structures). It's great if you want to play with the erlang OTP. However, the biggest advantage for Clojure is the libraries from both the Java and JS world.

Example of what I mean by symbolic equality, this function in elixir returns true if the 2 arguments are equal:

def equal(a,a), do: true
def equal(_,_), do: false

neat

and since elixir supports applying fn without parens (for better or worse), you can actually write elixir in lispy syntax: (myFn foo, bar)

I gather those loathsome commas are required? 😉

yes, unfortunately

In case folks want to dig deep into non-Clojure languages, there's a #other-languages channel.

I have a large sequence of maps (with some nested values), for which most of the values are the same, and therefore uninteresting. i’d like to see the different values in the map.

so for the input:

[{:a 1, :b "something", :c "same"} {:a 1, :b "else", :c "same"}]

[{:b ["something" "else"]}]

clojure.data/diff might be what you're looking for

oh golly. i was writing a hairy reduce, but that looks great. thanks.

there still might be a slightly hairy reduce - not sure if you can just diff each element to it's neighbor, or if you need something more advanced than that

clojure.data/diff works for comparing two arguments. yeah, is getting it to work on a seq of args as easy as (reduce clojure.data/diff my-seq)?

(def a [{:a 1 :b "unique" :c "same"} {:a 1 :b "differe" :c "same"} {:a 1 :b "three" :c "same"}])
(clojure.data/diff (first a) (second a)) <-- works as intended

(reduce clojure.data/diff {} a) produces:
[[(nil {:a 1, :b "unique", :c "same"} nil) {:a 1, :b "differe", :c "same"} nil] {:a 1, :b "three", :c "same"} nil]

you end up diffing the next map against a diff that way

ah

right

and when it compares the diff against the next map in the seq, they look competely different

right

i’ll have to keep thinking about this a little bit. thanks lilactown and sundarj for your help so far

if comparing each el to the previous in the seq, then you can probably reduce it to a value that's like [prev-map seq-of-diffs]

(reduce (fn [[prev diffs] cur] [cur (conj diffs (clojure.data/diff prev cur))]) 
        [{} []] 
        my-seq)