Clojurians Log v2
clojuredesign-podcast 2020-11-10
@heow sorry to miss your thread about let examples, but here's one from my recent code. I posted a short babashka script for downloading artifacts from CircleCI, and the artifacts-for function has an example. The first let line fetches recent builds, but I don't know if I've found a build number that I want, so the artifact-urls local variable is guarded by a when call. https://gist.github.com/justone/87918a0ca5ab65575d94bc6a127aa48e
the artifact-urls function:
(defn artifacts-for
[ci user project job-name]
(let [recent-builds (-> (recent-builds-url ci user project recent-build-count "completed")
(curl/get)
(parse-body-json))
recent-job-build-num (find-build-num-for recent-builds job-name)
artifact-urls (when recent-job-build-num
(-> (artifacts-url ci user project recent-job-build-num)
(curl/get)
(parse-body-json)))]
artifact-urls))It could also be done with a some->>, like this:
(defn artifacts-for
[ci user project job-name]
(let [recent-builds (-> (recent-builds-url ci user project recent-build-count "completed")
(curl/get)
(parse-body-json))
artifact-urls (some->> (find-build-num-for recent-builds job-name)
(artifacts-url ci user project)
(curl/get)
(parse-body-json))]
artifact-urls))it's a little contrived, but I hope it helps as an example
Great thanks a ton!
I know exactly how hard this is, I've written articles on functional programming without code and it's a challenge. :-) That the podcast has a really great job of it!
thanks, it's a tough line to walk, especially in our recent episodes where we focus on a single function
I just listen to the Let Tricks episode too 😃 cool. There is a very famous trick in other communities called "Let over Lambda" (there is still a book with the same name) which is using let and defining a function inside the let body. The idea is to create a lexical scope to the variables that are visible only by that function.
For example in this code we used this trick https://github.com/lsevero/abclj/blob/master/src/abclj/core.clj#L60
these are also called closures
nice reading https://letoverlambda.com/index.cl/guest/chap2.html#:~:text=A%20closure%20is%20like%20an,can%20funcall%20in%20multiple%20ways.&text=This%20let%20over%20two%20lambdas,the%20same%20enclosing%20counter%20variable.. ( I need to warn about the style/kind of language used by the author... might be good to read https://letoverlambda.com/index.cl/clarifications too)