The procedure from the book

the first branch calls (empty? tree). on (scale-tree 2 10) it is calling (empty? 2)

seqexp=> (empty? 2)
Execution error (IllegalArgumentException) at net.cgrand.seqexp/eval1715 (REPL:1173).
Don't know how to create ISeq from: java.lang.Long

seqexp=> (doc empty?)
-------------------------
clojure.core/empty?
([coll])
  Returns true if coll has no items - same as (not (seq coll)).
  Please use the idiom (seq x) rather than (not (empty? x))
nil

right, my rubber duck debugging didn't work this time 🙂. Thanks!

This works, however the first condition doesn't seem very elegant. Is there a way to improve the first condition?

you can always make another function that has a more intention-revealing name and use it there

The next thing you might run into is using list? is usually a mistake in clojure, you want seq?

A while back i tried to do SICP in Clojure and it just really doesn't fit very well. I think just using chicken scheme, guile or MIT scheme is the best way to go

Off topic question: how many times did you learn SICP? I’m planning to do a second one in a couple of months 😄

I've gone through it two or three times. But I never finish. But I still get the charm

Might check out the series produced by code_report who did a series on SICP in Racket. Was a great way to follow along.

Sorry I’m a few days late… One of the (several) reasons for not working through SICP in Clojure is that it’s not idiomatic at all. For instance, Scheme is frequently looking for an empty list, while most Clojure functions that return an empty list will use nil punning instead. So it’s more common to use next rather than rest (for instance, this is what destructuring does… if you get to that part of Clojure). Consequently, a more idiomatic approach might be:

(defn scale-tree
  [tree factor]
  (cond (nil? tree) nil
        (not (sequential? tree)) (* tree factor)
        :else (cons (scale-tree (first tree) factor)
                    (scale-tree (next tree) factor))))

(defn scale-tree
  [tree factor]
  (when tree
    (cond (not (sequential? tree)) (* tree factor)
          :else (cons (scale-tree (first tree) factor)
                      (scale-tree (next tree) factor)))))

(defn scale-tree
  [tree factor]
  (when tree
    (if (sequential? tree)
      (cons (scale-tree (first tree) factor)
            (scale-tree (next tree) factor))
      (* tree factor))))

(defn scale-tree
  [tree factor]
  (when tree
    (if-let [[f & r] (and (sequential? tree) (seq tree))]
      (cons (scale-tree f factor)
            (scale-tree r factor))
      (* tree factor))))

Thanks for the detailed response! I love these step by step on how to improve a piece of code. I took on @U03493LJW0H suggestions and I'm watching the code_report lessons as video is a format that I learn well too.

A line comment ;; would be the only option for writing docs for a defrecord. Alternatively, consider using a Clojure hash-map instead of a defrecord and add a clojure.spec if validation of values is required.

You should add () if you want to call a function

(starts-with? val "\"")

AAAHH, of course, thank you so much!

(also for the super fast reply, much appreciated!)

Clojure is not Haskell. Clojure encourages and supports writing pure functions, and it is idiomatic, i.e. many functions in many widely-used libraries are pure functions. But there are no "pure function types" that are statically checked anywhere that require that one writes pure functions.

Unlike a language such as Java, Python, Ruby, JavaScript,where you have to go out of your way and against the grain of popular use to write pure functions.

people generally use whatever they want, there are tools for each editor. the actual numbers are can usually be found on the state of clojure yearly survey. here are last year’s results (Q16 is about dev environment) https://www.surveymonkey.com/results/SM-S2L8NR6K9/

if you have emacs questions, there’s an #emacs channel where you should be able to get some targeted help

I see, thanks Darin

Emacs has been used by the majority of Clojure developers as it has always had support from the early days. There are a wide range of editors that support Clojure https://practical.li/clojure/clojure-editors/

I use Prelude emacs (so Cider) for Clojure, works great with practically zero setup

Maybe with xforms https://github.com/cgrand/xforms/blob/master/src/net/cgrand/xforms.cljc#L87

the remove nil sounds incredibly dangerous

(remove nil?) isn't even necessary

(conj {} nil) = {}

map requires a Clojure function, e.g. something that implements the IFn interface. getName, the method on Java’s File class, is not a function for Clojure

The .getName is actually syntactic sugar for the “dot” special form for java-interop. Think of getName as an argument for .

(this is an area we are looking at for Clojure 1.12)

grateful for the input 🙏

@U064X3EF3 I know this is such a little thing, but I run into it so often when doing java interop-y work. I’m so glad this is being looked into

@U064X3EF3...since I already asked once : ) and I've been mulling over how such an implementation would actually work. Is the clojure team looking at actually making it so that java methods will work as is or is there some other solution under consideration. And I understand nothing is cut in stone, just curious what direction the investigation is going...

not going to go into it here, it's more complicated than it appears, and is adjacent to other things we're considering.

ok fair enough. Look forward to whatever the end result ends up being.

Remembers the halcyon days of memfn