I think I found one. Looked it up right after your response.

I bet you can even get fancier by using something like component to try to preserve state in the face of reloads.

Morning !!!

When to use (delay ) in my code

Hi, you’ve ebook about clojure for recommend me? I beginning with clojure.

Clojure for the true and brave

A very good book.... That moves at a decent pace

Living clojure will get your started very quickly

delay is useful for situations where you might want to evaluate some code, but not yet, and if you do you might use the value multiple times but only want to calculate it once

like a lazy-seq but it's just one value

Great !! Gracias!

Hi! I'm trying to get Sente to work. Right now client and server seem to be connected (I see ping messages). But when I try to push a message from the server to a client like this ((:send-fn channel) "dabecca4-ca3a-496a-9016-cf46ddc34f45" [:sample.event/some-id {:data "data"}]), I get the following error: java.lang.IllegalArgumentException: No implementation of method: :pack of protocol: #'taoensso.sente.interfaces/IPacker found for class: taoensso.sente.EdnPacker

I have been staring at the code for a couple of hours now and can't think of anything else to try

Any help would be appreciated

Hey peeps, I'm using Brave and True to learn Clojure and I've noticed that it doesn't even mention the for iterator. Is that intentional you think? Is using for - unless absolutely necessary - regarded as bad form in Clojure?

@nikoszp I think they don't mention it because it's not that often used. Most cases where you could use for, it's more idiomatic to use map, reduce, or doseq. It's useful to generate multiple elements from a list for example.

Guys.. I have a list : (def mylist '() ) How do I write a function that adds elements to the list by user input without the use of atoms

Why no atom? Clojure is immutable by default, but you could use a transient vector to store them which is mutable, or use java interop and use a java list. But really one of the greatest things in clojure is the atom, cause it's a very nice and easy way to work with concurrency.

@suryapjr Sounds a bit like you still need to get into a functional mindset! 🙂 (conj mylist the-new-input) will return a new list with the element added. You'll use this new list in whatever coming function calls you're performing. What is the end goal in your program? It will be a bit easier to help if you elaborate some more. PS: Using the list literal '() is fairly uncommon (in fact, I've never seen it in production code). Vectors [] is the data structure people tend to use for ordered collections.

@curlyfry true as (= 1 1)

Not getting into FP properly

I want to see the elements added in my list in the end

(conj mylist input) returns a new list which has to assigned to a variable using def or let ..but since I don't know how much elements will be added in the future,I can't bind values to def ..

@gklijs..someone told me that atoms are rarely used in clojure 🙂

I try to avoid atoms as much as possible unless there is no other way to do something (usually something inherently stateful from "the outside world" such as a database connection)

@suryapjr I'll try to write up a quick example of a more functional user input loop, just a sec!

Thanks ! @curlyfry

Eventually you want to have state somewhere, it's easier to have it in an atom than external. If you just want to use the list for something else you don't need an atom.

@gklijs agreed..but since list is immutable ..need a atom

Transient list is not

Transient list ??..I'll look it up..

Here is an example of updating a list based on a user input loop:

(defn user-input-loop [input-list]
  (let [user-input (read-line)
        updated-list (conj input-list user-input)]
    (println updated-list)
    (when-not (= user-input "quit")
      (recur updated-list))))

(defn start-input-loop []
  (user-input-loop []))

without using any atoms!

You start the loop using (start-input-loop)

@suryapjr Try to see if you understand this example. The gist of it is that we are calling the user-input-loop function over and over again (with recur) using the new, updated list as an argument.

@pooboy @gklijs transients can't model identity and I would definitely not suggest it to a beginner

I agree with @leonoel

I understood the example..but why is there another function called start-input-loop

@curlyfry..great example ... 👍

It's just a small convenience so we don't have to give an empty vector as an argument when we start the user-input-loop. Basically just a habit of mine!

Cool !!

@curlyfry..when-not ?

Look it up on clojuredocs!

Got it !!!

What's recur ?

I'm not getting it

@suryapjr Consider this example

(defn foo [x]
  (if (zero? (rem x 107))
    x
    (foo (inc x))))

(defn foo [x]
  (if (zero? (rem x 107))
    x
    (recur (inc x))))

@mfikes Crystal clear !! Thanks !!

@suryapjr Sometimes it helps me to see the code generated for these things. If you start up Lumo or Planck with the -v option (for verbose) you would see the JavaScript generated for each, which might help in seeing what it does in a more familiar language. The first produces

cljs.user.foo = (function cljs$user$foo(x){
if((cljs.core.rem.call(null,x,(107)) === (0))){
   return x;
} else {
   return cljs.user.foo.call(null,(x + (1)));
}

while(true){
  if((cljs.core.rem.call(null,x,(107)) === (0))){
     return x;
  } else {
     var G__22 = (x + (1));
     x = G__22;
     continue;
  }
  break;
}

@mfikes 👍

What are some of the best practices for writing more readable clojure?

regarding style there is https://github.com/bbatsov/clojure-style-guide

@suryapjr A couple of lessons to learn: 1) Don’t try to create very compact, terse code. Use (fn [ ] ...) instead of #( ... ) more often than you might initially think. 2) Try to break things apart. You can end up with a function that essentially looks like a gigantic single equation on a blackboard, which is hard to read. Find the pieces inside of it and break them out into separate functions.

Having said the first item above, there is definitely a balance, and some constructs leading to shorter code make it more readable. For example, using destructuring. And, if you can express an idea more succinctly with less code, it can be more readily understood. Just don’t try to squeeze it down beyond where it becomes hard to read.

Another bit of advice for readable code is to not to initially worry too much about performance. Write code that is clear and if it is fast enough, then you end up with a readable result. 🙂

The threading macros -> and ->> often lead to more readable code

@mfikes great !!!

@suryapjr and take the clojure-style-guide with a grain of salt. Most devs I know have more than a few objections with it. To a pirate from a movie: "it's more of what you call guidelines than actual rules".

@tbaldridge noted !!

Guys ..should I master clojure and then jump to clojurescript?

Or I can learn both of them simultaneously?

you can learn them both. 90% of the languages is the same, it's only when you dig into more complex topics that the differences show up.

Coool...

I want to use ArrayList from java

How should I proceed? I did this ..

(import java.util.ArrayList)

(def a (new ArrayList))

Now ?

(.add a 1) (.add a "apple") works - it's untyped, though

@suryapjr right, a.add(42) in Java becomes (.add a 42) in clojure

Coool..this is greatly

Great *

When I was importing the Java.util.Random library , I had done this : (.nextInt (java.util.Random). 100)

And it had worked..

For ArrayList, ` (def a (new ArrayList)) `

More than one way of doing things in clojure ? 😀

https://clojure.org/reference/java_interop lists both of those next to each other - I think they're the same

Why was it so important not to implement contains? over lists, in clojure core? how would you support that design decision? thanks!

@matan https://lambdaisland.com/blog/02-10-2017-clojure-gotchas-associative-contains

@matan Well, lists are not keyed by indexes

But, perhaps you are asking a different question; you can do (.indexOf '(:a :b :c) :b) in both Clojure and ClojureScript

Combine that with neg? and you have a way to do it.

Using the example from that post

(def beatles ["John" "Paul" "Ringo" "George"])
(not (neg? (.indexOf beatles "Ringo")))

If you want to iterate in Clojure: (some #{"Ringo"} ["John" "Paul" "Ringo" "George"])

Guys when we do ...

(def magic (new Random)) 

Do we create a object?

Yes, and an alternative syntax for (new Random) is (Random.)

The . at the end is a macro-ish thing.

(macroexpand '(Random.))

But clojure is a functional language,right ? :)

Noob question..sorry

Definitely, but it lets you do imperative things if you really want

Clojure is functional, but Java is not

Hmmmm...

Java interop is very useful for clojure

indeed 🙂

What are macros used for

Contains? Only works on hash-sets?

extending the core syntax, stuff like cond or -> are macros

contains? works on sets maps and vectors (but on vectors it tests on index, not on element equality)

Coool!

Can you give me a simple example of a macro ?

of the definition of a macro?

Yes

(defmacro my-when [test & body] `(if ~test (do ~@body)))

Looks like a func

yeah

macros are functions of data to data

except the data is then interpreted as code

Coool

Thanks @bronsa!

@suryapjr As an exercise, if you try to write my-when above as a function, you will come away understanding why it needs to be a macro

@mfikes sure !!!

When we call java in clojure..take the example of a linked list ..we can mutate the object.. immutability is switched off during interop with Java ?

no, you can mutate

you’re just making the exact same call you’d make in Java, with the same effects

Yesss...normally clojure is immutable but when interop with Java ..we can mutate

@suryapjr immutability isn't a property of Clojure the language itself, it's a property of the data structures Clojure uses. Java has immutability for e.g. strings, but for most other data structures in Java, you mutate to use them (even from Clojure).

Clojure's strings are in fact just Java strings (since they're immutable):

=> (type "")
java.lang.String

you can also use Clojure's immutable data structures from Java, just like you can use Java's mutable data structures from Clojure

@sundarj thanks for the detailed explanation ,mate.

Hey all, for the new clj --main cljs.main --compile hello-world.core --repl command. This is going to implicitly look for hello-world.core within a src directory, yes? How can I change where this command looks for my namespace?

@tkjone Add :paths ["foo/bar"] to your deps.edn

Nice. Thanks!

https://github.com/clojure/clojurescript/wiki/Using-cljc#general-considerations this seems to say that src/cljc/project-name is acceptable. but when using the clj command line tool its not finding this. is there something i'm doing wrong?

[dan@localhost paths]$ tree
.
├── deps.edn
├── scripts
│   └── run
└── src
    └── cljc
        └── paths
            └── paths.cljc

if src/cljc is on your path, you should be able to require paths.paths

clj sees it automatically when its at src/paths/paths.cljc but not with the intermediate level of cljc folder there

then you need to make sure src/cljc is on your classpath

I wouldnt' expect that to be automatic

also, separate folder structures for clj/cljc/cljs isn't needed, but it is a convention some people like

once src/clj, src/cljc, and src/cljs are all on the classpath, as far as clojure is concerned the stuff underneath could be in any of those directories

thanks. i'm just now venturing into cljc territory and want to use clj. a lot of moving parts 🙂

Question about clj --main cljs.main and the watch option If I have a directory structure like this:

test
   src
       test.cljs
   deps.edn

For anyone who gets stumped on this, the order of the --watch CLI option seems to matter. To get this to work:

clj --main cljs.main --watch src --compile test --repl

Yeah, do -h and it will explain the argument order.

how would I force lazy seqs to show their values in the repl?

matan use pr-str instead of str

So say I have this function:

(defn regex-escape [s]
  " turn a regex agnostic string into its corresponding escaped regex string "
  (str
    (map
        #(if (clojure.string/index-of "#$()*+.?[^{|\\" %)
              (str "\\" %)
              %)
         s)))

pr is what the repl uses to show values, so if you directly return the lazy-seq to the repl you will see the right thing

use apply str instead of just str in that code

because the string form of the lazy-seq still isn't what you want

@matan to be clear: (str (map ...)) gives a silly object notation, (pr-str (map ...)) is a string of a list of things, (apply str (map ...)) is the string made of each thing returned by map

mmmm that works. trying to figure why from your last comment. thanks!

user=> (str (map identity "hi"))
"clojure.lang.LazySeq@10c2"
user=> (pr-str (map identity "hi"))
"(\\h \\i)"
user=> (apply str (map identity "hi"))
"hi"

and for symmetry

user=> (apply pr-str (map identity "hi"))
"\\h \\i"

yeah should be easy, just a long day....

oh of course, apply makes perfect sense

tinkering it after solving my itch, this is a little confusing:

=> (str ["3333" "3333"])
"[\"3333\" \"3333\"]"

that's the string representation of a vector of strings - it looks better if you call println on it

okay 🙂 kind of internal-ish but makes sense

thanks again for pointing out my error

I don't think you made an error - I'm just saying that's why it looks like that

it's a little odd since (str "foo") isn't "\"foo\""

well thanks none the same!

I wish to share something more abstract. Compared to typed languages, I find that for me writing clojure creates a lot of technical debt: it is simple to put together a small library, but then unless I sprinkle type and shape checking all over the place, it is close to impossible to evolve and maintain the code later on. Any caller can easily abuse my code with wrong input typing, and most of all, I'd find it hard to follow what types a function expects when I come back to old code.

So if I need to deliver and maintain quality code, I end up working harder to type-check stuff with my own lines of code, compared to a typed language, and using spec for that isn't that elegant/compact compared to typed-languages.

Are you guys sure that large teams can use clojure like that?

@matan I've had these same problems

part of this is a trade off for lisps - I'm very interested by the addition of extensible variant types in recent OCaml versions (but this goes into off topic)

@matan One thing: I would point you to prismatic/schema instead of spec. spec so so heavyweight that i found myself avoiding it. schema has a much lighter syntax and does the thing I care about the most: check the shape of the map while acting as internal documentation. if you’ve ever used flow type or typescript, the feel of schema is very similar

of course it is runtime

using spec with the purpose of checking incoming data and acting as internal documentation is made much better by https://github.com/metosin/spec-tools#data-specs

I still get caught out by some of the complexity of spec. Like instrumenting functions that have side effects, for example.

spec is doing a lot of stuff whereas schema mostly does one thing

Hi everyone 👋 Curious if anyone knows how easy it would be to get a nested sequence collection based on knowing a value within the sequence? For example, given [(:foo :bar) (:baz :bat)] and I know :bat, I would like to get (:baz :bat)

(->> '[(:foo :bar) (:baz :bat)]
     (filter #(= (last %) :bat)))

Won't necessarily be the last item though 🙂

Guessing I could use filter with something like contains?

yep, basically you need filter, also you'd want to use first since filter returns a coll

if you need more advanced filtering consider specter

Cool, thanks. Trying to avoid extra libraries on this one as it's a learning exercise 🙂

filter returns a lazy-seq, which doesn't work with contains?

contains? is specifically for associative structures, and only looks by key

user=> (contains? '(a b) 'b)

IllegalArgumentException contains? not supported on type: clojure.lang.PersistentList  clojure.lang.RT.contains (RT.java:814)
user=> (contains? '[a b] 'b)
false
user=> (contains? '[a b] 1)
true
user=>  ('[a b] 1)
b

i think he was talking about the test used for filtering, such as

(->> '[(:foo :bar) (:baz :bat)]
     (filter #(contains? (set %) :bat)))

implying the input sequences are actually meant to be sets

oh, right, I misread

@noisesmith just come back to slack. I am hitting that exact issue re lazy-seq and contains? not supporting lazy-seq

right, if you have a specific question about my example above let me know - the simple thing might be to call set on the thing first

Perfection. Thanks @noisesmith. I wrapped my % in my anonymous function for the contains? and it sorted the issue

TIL 🙂