if i have a set of things i'm running down, are nested when-let forms ok?

(when-let [a (something-could-be-nil)]
  (when-let [b (other-could-be-nil a)]
    (when-let [c (third-could-be-nil b)]
        c)))

You might prefer the look of (some-> (something-could-be-nil) other-could-be-nil third-could-be-nil))

avoids the need to name the intermediate results

Hey, I am trying to define a local function in a let but issue is the function keeps running when the let is evaluated instead of when the function in the let is evaluated. What can I do about this? I just wish to bind this function and call it later in the function and have it only run when called.

@urbanslug: how does your code look?

(defn bro-life []
  (let [print-msg (println “cat”)]
     (println “Will run but print-msg will not")
     (print-msg)))

something like that

output will be:

cat
will run but print-msg will not

The it seems to block

the problem is that (println "cat") is a function call to println instead of being an anonymous function

the easiest is to use the shorthand syntax for anonymous functions, just put a # in front

or you can use fn, or letfn, which is exactly built for this purpose

in your original code what happens is that (println "cat") gets evaluated, and println returns nil, so now print-msg is equal to nil

so then calling (print-msg) is the same as calling (nil), which will give you a NullPointerException

@plexus: On it

My code is much more complex I hope all works

because I did try wrapping it in a lambda

good luck!

maybe it's easier if you pull it into its own defn?

Yeah nested #() are not allowed but of course (fn [] …) works because no ambiguity

thanks @donaldball !

You have a facts nested within another facts, can you do that?

one sec.

I don’t know the exact reason, but when you give a function f to map to a coll, refrain from using the anonymous shortcut.

So: * use (fn [i] {:date … instead * the get-ins are un-necessary, you can use (:period x) instead

(defn map-invoices [invoices]
  (map (fn[i] { :date (:period-end i)
                :amount (str "$" (:subtotal i))
                :status (if (:paid i) "Paid" "Unpaid")}) invoices))
=> xxx/map-invoices
(map-invoices [{:period-end "pe" :amount 123 :paid true}])
=> ({:date "pe", :amount "$", :status "Paid”})

I believe the basis for you issue is something like this:

boot.user=> (macroexpand-1 '#({:foo 1}))
(fn* [] ({:foo 1}))

vs

boot.user=> (macroexpand-1 '#(hashmap :foo 1))
(fn* [] (hashmap :foo 1))

as st said by using the #(…) reader literal you putting your hashmap in the function call position b/c hashmaps can use IFn to be used like functions

so you make a thunk, that when called wants to use the hashmap as a function

but you didn’t give it a way to ever receive a value as a key

@jswart: thanks for explanation. I stumbled upon this issue many times.

yeah when you use #(…) and you want to return data you have to use the non reader literal so ((fn [x] [x 1 2 3]) 7) => [7 1 2 3] becomes (#(vector % 1 2 3) 7) => [7 1 2 3]

tricky. I tend to avoid the #(…) execpt for very tiny functions

I would have made the data munging form and then used partial to make map-invoices like (def map-invoices (partial map transform-fn))

yes, extracting fn inside map to something named is better.

hello

I working through Clojure Koans and I'm stuck at:

I know that I want to do something with (last coll) (pop coll) `

but I feel like I'm missing something..

Any hints would be super helpful

What you pasted in is the code that handles when the recursive calls should terminate, it feels a bit odd though. Because if you have a collection w/ a count > 1 how will you know to stop?

in general recursive solutions are “divide and conquer”. Where the solution to a problem usually follows the formula If SOME_CONDITION stop else the solution is SOMETHING and a recursive call

Each recursive call does a little bit more of the work, and when you reach the termination clause you start combining the operations on the stack until you get a value.

for example

(defn my-add-coll [coll]
  (if (empty? coll)
    0
    (+ (first coll) (my-add-coll (rest coll))))) 

boot.user=> (my-add-coll [1 2 3])
6

sorry

That was a pretty good hint

I'm revisiting it now

Thanks!

One HUGE caveat is that once you have an intuitive understanding of recursion, and how to write something recursive in clojure you should read up on loop, recur and reduce those are special forms / functions.

There is a “gotcha” to recursion on the JVM when you start writing production code, but for now you are probably okay.

hey thanks @jswart

taking note of your suggestions

np

Everything I know about recursion I learned from SICP, a truly amazing book.

that helps build intuition for recursion

good luck on learning clojure!

I'm gonna pickup SICP in the next month or two

its free online as well, as are the videos

i never actually had the book either

We have a work copy and it is great to leaf through

pickup as in sit down and read it

ah cool, yes. it takes time.

I tried to learn clojure and failed b/c I had no functional/CS experience. I did SICP over about 6 months and then came back to clojure.

is ^long metadata? what is that useful for?

its a type hint

it prevents runtime reflection

b/c now the compiler knows that state is a long

@jswart: ah, thank you

np