oh, I wondered what that offered and it just calls the constructor

https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/MapEntry.java#L19

Is there something like this to valid a lazy seq? (lazy-seq? (seq (range)))

i don't believe so. what problem are you trying to solve? how does laziness impact you?

chunk something?

i dont remember where i saw it

i will try to paste my code

@papachan http://clojuredocs.org/clojure.core/chunked-seq_q ?

oh yeah

found something like this: user> (instance? clojure.lang.LazySeq (lazy-seq (map inc))) ;; => true

@papachan There are a lot of lazy sequences that are different types...

clojure.lang.LongRange
user=> (type (range))
clojure.lang.Iterate
user=>

Neither of those are LazySeq, for example:

user=> (instance? clojure.lang.LazySeq (range 10))
false
user=> (chunked-seq? (range 10))
true
user=> (instance? clojure.lang.LazySeq (range))
false
user=> (chunked-seq? (range))
false
user=>

what problem are you trying to solve?

(that was my next question 🙂 )

sequences are inherently maybe lazy. asking whether it is implies that you care if it isn't, and that's usually a sign that you're doing something fragile or wrong

realized? is another predicate in this area but it's fraught with similar perils and is also something I recommend not using

Hello! I'm looking for an interactive tutorial of clojure, like something that guides you through the basics. Does anyone know of such a thing? Thanks!

If I may suggest this: https://clojurebridgelondon.github.io/

Look at the section, Learning Paths

Colours and Shapes is interactive

as is Clojure Essentials

Thanks @dharrigan!

You're most welcome! 🙂

(when-let [{:keys [a b c]} {}]
  (prn :ruhroh a b c))

😞 this is a bit of a shame

i’d have hoped it would guard the destructured attributes all to have been non-nil

a b c are all nil in this case

but the prn is still evaluated

The when condition is about the map

the right hand side? ok

(when-let [foo (:a {})]
  (prn :got foo))

Well I’d say the left hand side, which is fundamentally about a map (and also about its structure)

hah yes, it’s the source

I was thinking about it as the bindings being nil

Read it as “when there is a map to destructure, destructure it’s bindings and invoke the body”

thank you that’s helpful

If you want to guard against missing keys in a map m, you could do something like

(when-let [{:keys [a b c]} (and 
                                            (every? (fn [k] (some? (get m k)))[:a :b :c])
                                            m)]
  (prn a b c))

Wouldn’t just (and a b c) be easier?

I always find it tricky to manage false-y vs. nil vs. missing

Just been looking at http://chouser.n01se.net/apply-concat/ What would you recommend if you had a sequence of either maps or sequences of maps, and you wanted a sequence of maps?

e.g. [{:a 1} [{:a 2} {:a 3}] {:a 4}] and we want ({:a 1} {:a 2} {:a 3} {:a 4}) Flatten seems to be the only correct one here, apply concat and friends all turn the un-nested maps into vectors, ([:a 1] {:a 2} {:a 3} [:a 4])

Usually there’s a good way to ensure you’re only getting sequences of maps. Is that possible in your case?

(defn splice-when
  [pred]
  (fn [rf]
    (fn
      ([] (rf))
      ([result] (rf result))
      ([result input]
       (if (pred input)
         (reduce rf result input)
         (rf result input))))))

(sequence (splice-when vector?) [{:a 1} [{:b 1} {:c 1}] {:d 1}])

A funny way using a transducer

I've got a bunch of functions that each return a thing (mostly) but sometimes multiple things and sometimes no things, and I want to collect those things.

I think if you sometimes return multiple things, it would make most sense to always return multiple things even if it’s a sequence of one thing (or nil if theres no things)

At the moment they return a map or vector of maps or nil. I suppose I could get them to always return a vector of maps (maybe empty) but the commonest case is one map so seems a bit wasteful

@danieleneal yeah, you may be right

It would make for a cleaner api imo

then you can just (sequence cat xs) or (mapcat identity xs) away without a care in the world

👍

I'll look into it!

Does a function like this have a name in functional programming? And does such a function exist in clojure.core and I just haven’t found it?

(defn apply-if
  "Returns a function that applies f if pred returns true for the specified value"
  [pred f]
  (fn [v]
    (if (pred v)
      (f v)
      v)))

Hi guys, I have a question , so in OOP world , we have the repository pattern that is responsible to query and save the domain objects , it can be either single object or a graph of them, usually under a ORM to deal with the object relational mismatch or manual mapping. What is the approach in Clojure? I asume that there is nothing like the respository pattern, would then it be , for query load the tables and transform to domain model as clojure maps? and for persistence , transform the domain model map back to sql insert/update using some statement builder ? , that seems to be a lot of manual work.

@vachichng I would look at next-jdbc (https://github.com/seancorfield/next-jdbc). In my code, I've just treat things like maps and get and store.

It really is quite simple, if you just think of it as maps 🙂

An in terms of "work" - I've found it to be refreshingly easier/simplier and more comprehensible than working with an ORM

Even in my non-clojure work (Kotlin), I use jooq which is a very simple layer over sql

I've abandoned things like hibernate

next-jdbc + honeysql gives me all the power and flexibility I need 🙂

thanks, I will play a bit with next-jdbc + honeysql 🙂

you're most welcome

@vachichng if you want to dig deeper there are #sql and #honeysql channels

But the Clojure way is to use plain data (hash maps) for domain objects / entities and simply read / write them from / to a database. You won't find much support for "relations" for example.

is there a best way for this same result:

(apply str (remove #((set "[]") %) "[abc]"))

for one thing, (set "[]") is idiomatically #{\[ \]} imho

but using seq operations to go from one string to another is usually a bad idea

(clojure.string/replace "[abc]" #"[\[\]]" "")

also #(s %) for some set s, is just s

for all #(f %) you should replace it with f, with the exception of enforcing only one arity being possible via runtime error (which...)

thanks @noisesmith @schmee

what purpose is the use of (delay ...) serving here? https://github.com/http-kit/http-kit/blob/master/src/org/httpkit/client.clj#L97

i'm not sure why (HttpClient.) would need to be cached

because of the defonce

it's about not instantiating the client when the namespace loads

but rather, when something dereferences the delay

so, lazy loading

thanks

@csd it's helpful to remember that all def forms are evaluated when clojure loads a file, there's no "compile only mode" available

so a delay is a simple way to ensure you can load up the code without firing the missiles

for example, without the delay, doing aot compilation while making a jar would create a new http client