hey i've got a dumb question...

when i run lein figwheel, the resulting REPL that i have access to - how do i navigate in it? i can't use arrow keys to navigate within the block i'm typing, or pressing up arrow doesn't reveal last command, etc

@aconanlai calling it as rlwrap lein figwheel will give you typical readline stuff like up-arrow for history. Stuff like navigating between lines depends on the environment. For stuff like that, I'd recommend starting figwheel from inside an editor/IDE instead of from a terminal.

(you many need to install rlwrap if you don't already have it -- see https://github.com/hanslub42/rlwrap )

https://twitter.com/scriptclojure

Hi everyone, is fdef in spec doesn't actually validate the input and output of the function when the function is called?

I'm having some problem with my code, and if I run it in cider-debug I can see what the problem is, but I dont understand why.

arguments to recur seem to be in the wrong order

additionally, the atom is not needed

(loop [sheet spreadsheet
          checksum 0]
         (if (empty? sheet) checksum
             (recur (rest sheet) (+ checksum (calculate-list (first sheet)))))

Ah, would it also work if I change the order of the arguments in the loop vector?

yes

it is indeed working now. So the order of the loop and the recur need to be the same.

Hi guys, how to avoid nesting during error checking?

(defn foo [x y z]
  (if (< x 0)
    (throw (IllegalArgumentException. "Positive x is required"))
    (if (> y 0)
      (throw (IllegalArgumentException. "Negative y is required"))
      (if (= y -100)
        (throw (IllegalArgumentException. "Y -100 is prohibited."))
        (if (or (< z 0) (> z 100))
          (throw (IllegalArgumentException. "Z in (range 101) is required"))
          (* x y z))))))

@ghsgd2 If only checking the args, I use pre conditions like this:

(defn foo
  [x y z]
  {:pre [(< x 0) (> y 0) (= y -100) (or (< z 0) (> z 100))]}
  (* x y z))

thank you, @rahul080327!

Is it a good coding style to count :bar the following way (is that optimized by compiler)?

(count (filter #(= % :bar) [:foo :bar :bar :foo :foobar]))

@ghsgd2 (:bar (frequencies [:foo :bar :bar :foo :foobar]))

@ghsgd2 if you want to keep your messages for the exceptions and also avoid nesting, I’d recommend the cond function:

user=> (defn foo[x y z]
  #_=>   (cond
  #_=>     (< x 0) (throw (IllegalArgumentException. "Positive x is required"))
  #_=>     (> y 0) (throw (IllegalArgumentException. "Negative y is required"))
  			...
  #_=>     :else (* x y z)))
#'user/foo
user=> (foo -1 2 3)

IllegalArgumentException Positive x is required  user$foo.invokeStatic (:3)

Correction: cond is a macro, not a function 🙂

@tonywang897 >`(:bar (frequencies [:foo :bar :bar :foo :foobar]))` but it will be doing unneeded work computing frequencies of :foo and :foobar @sammy.castaneda90 that's an option, thank you!

@ghsgd2 1. Exceptions stop evaluations of the function, so no need for an else. You can just do (when x (throw...)) (all good to go) 2. (count (filter ...)) won't be optimized by the compiler. It'll generate the sequence lazily. If you need performance you'd have to reduce this yourself or use transducers.

@rauh 1. So it will be (do (when x (throw...)) (when y (throw...)) (all good to go)). 2. I. e. reduce or transducers. I see. Thank you a lot!

Hello

a very basic question

Why does (realized? (lazy-seq [1 2 3])) return false

What does this lazy sequence have to "realize "?

i see the above code in LazySeq.java

@diginomad none of the lazy sequence has been realized because it hasn’t been used. It’s lazy in the sense that it won’t do anything with the [1 2 3] at all until you actually use it by passing it as an argument to a function like seq

What is the fn when i say (lazy-seq [1 2 3])

return new PersistentList()?

lazy-seq is a macro that wraps the body into a fn. in that case the fn is (fn [] [1 2 3])

you can see it if you type (macroexpand ’(lazy-seq [1 2 3])) into your repl

so,(class (lazy-seq [1 2 3])) returns Fn?

no, it returns a clojure.lang.LazySeq object

i am having trouble getting the concept of realization i guess

i was of the opinion that (lazy-seq [1 2 3]) is already realized

if you’re using a repl it makes things like lazy seqs a little harder to understand because the repl will automatically realize the sequence to print it to the screen.

that is one other thing

u r right

but i guess it makes sense

if we have a very very huge list

and we want to make it Lazy from thereon

I think a quick rule of thumb is that if you’ve never used the lazy seq anywhere besides where you’re binding it, then it hasn’t been realized.

we can wrap that into LazySeq

and use it without fear of OOMException from thereon

until actually "used"

well, if the list already exists in memory somewhere, then wrapping it into a lazy sequence doesn’t really do a whole lot. in the lazy-seq case, if you’re wrapping a vector in a lazy-seq then that vector is completely held in memory.

ya

thats why i said from thereon

what if i am planning to put a million more

not sure if what i am saying is technically correct though

it really depends on where you’re getting the list from. For instance, if you’re reading it from a file, then it’s definitely possible to read it from the file as a lazy sequence.

The main thing to remember about lazy seqs is that if you expect (prn foo) to give you [1 2 3] and instead it gives you LazySeq@84038, you need to put a doall around foo to realize it into the actual values you’re expecting.

And of course to make sure the value of foo won’t go bOOM.

How could it be realized if it's printed as LazySeq@7c42?

> (realized? (doall (map #(inc %) [1 2 3])))
true
> (str (doall (map #(inc %) [1 2 3])))
"clojure.lang.LazySeq@7c42"

Wow, that surprises me

seq works

(str (seq (map #(inc %) [1 2 3])))
=> "(2 3 4)"

but I would have expected doall to return a realized value.

@manutter51 I expected too. Thank you!

Use pr-str

pr is for printing as readable data

@alexmiller Curious:

(pr-str (map #(do (println "hello world")(inc %)) [1 2 3]))
"(hello world\nhello world\nhello world\n2 3 4)"

Yes, it will for the -str variant. If realizing your data structure has side effects, then you should realize it first

Is there a function or idiom for mapping conditionally? e.g.

(map-when odd? #(* % 2) [1 2 3])) -> [2 2 6]

I don’t know about idiom per se but there’s #(cond-> % (odd? %) (* 2)) as a function

(yeah, that's what I was typing in as the answer!)

And that's another case where I'd reach for the predicate-threading variant we have in our "util" library at work: (map #(condp-> % odd? (* 2)) [1 2 3]) 🙂

oh nice - I’ve wanted to write condp-> but also wasn’t sure of the name

Any reason why core.match isn't included by default on clojure? Is it not "idiomatic"?

@dromar56 https://www.youtube.com/watch?v=dGVqrGmwOAw

Rich ins’t a big fan of pattern matching

It’s a long video but he mentions it in there somewhere

Anything in particular you looking to do with core.match or just curious about leaving it out?

Not specially, but I thought pattern matching was the functional way of solving a basic problem I'm having

I'm writing a cli that can do different actions, with different parameters, for example action1 arg1 arg2 and action2 arg1 arg2 arg3

I thought that match was an easy way to both dispatch each action to it's corresponding function and verify that they had the correct arguments

Are you using clojure.tools.cli?

Ah, nop. will look into that

https://github.com/clojure/tools.cli

@dromar56 If you just want to dispatch on a string for the action and handle those cases separately, a multimethod might be a reasonable approach -- if you don't want the full-on argument parsing of tools.cli (which is geared much more to Posix-style command lines).

https://clojure.org/reference/multimethods

Yes since it's a learning project I think I'll use destructuring and multimethod for now

(I maintain tools.cli but I'm perfectly happy to point folks at simpler solutions 🙂 )

So I got this:

(defmulti action-dispatch first)

(defmethod action-dispatch "action1" [[action arg1 arg2]]
  (if (and (string? arg1)
           ((every-pred number? pos?) arg2))
    (do-something  action arg1 arg2)
    (print-usage)))

(defmethod action-dispatch "action2" [[action arg1 arg2 arg3]]
  (if (and (string? arg1)
           (string? arg2)
           ((every-pred number? pos?) arg3))
    (do-something-else  action arg1 arg2)
    (print-usage)))

(defmethod action-dispatch :default [_]
  (print-usage))

Is that an ok way of doing argument validation?

I'm not happy I had to write (print-usage) three times

Oh I guess I could remove all calls to print-usage and instead do something like (when-not (action-dispatch args) (print-usage))

you could make a dispatch function that either returns ::error or (first arg1) then have a single dispatch to print your usage

then do all the validation in the dispatch

maybe that’s hacky

Command line arguments are all strings so I wouldn't expect number? to return true...

It would be a long dispatch function, since it has differents kinds of arguments for each action

Ah that's right, will need to cast it somewhere

@dromar56 what about two multimethods - one for action-dispatch and antother for validating the action

and both could dispatch on the first item in the coll

then (if (validate args) (dispatch args) (print-usage))

or (defprotocol IAction (validate [this arglist]) (execute [this arglist])) and select some instance of IAction based on the first item in the arglist (?)

that seems nice @noisesmith, I will try the defprotocol method since I haven't used it yet

then you’d have like (def action1 (reify IAction (validate [this args] (and (string? (first args) …)) (execute [this args] (do-something …))

one for each action

I’m surprised no one has mentioned spec yet

haha sometimes I forget what channel I’m in

dependencies intensify

I’m just going to leave this here to hopefully get us back on track lol https://www.braveclojure.com/