In case you were like wtf is yamlscript, it's a yaml based programming language (written in clojure) that compiles to clojure code and is eval'd using sci. The ys cli is created by having the yamlscript compiler and sci and libraries compiled with graalvm native-image. It also builds a shared library for ffi binding to other langs like say python where it can be used as a normal or highly-dynamic-as-clojure yaml loader. My question here is about the clojure code genned:

$ ys --compile sample/lol.ys 
(defn lol [x] (let [y (_* 2 x)] (fn [_1] (+ _1 y))))
(say ((lol 10) 4))

“let over lambda” refers to a specific design pattern for holding state, so your friend is right

well what does that look in clojure

he said it would look like (let [x 1] (defn a [] x)) which doesn't make sense. at least not without context

it helps to use a lisp that supports mutation, but in clojure you can emulate it with atoms like so

(defn make-account [initial-balance]
  (let [balance (atom initial-balance)]
    (fn withdraw [amount]
      (if (< @balance amount)
        :insufficient-funds
        (reset! balance (- @balance amount))))))

(def withdraw (make-account 100))

(withdraw 5)   ;=> 95
(withdraw 5)   ;=> 90
(withdraw 91)  ;=> :insufficient-funds
(withdraw 5)   ;=> 85

also this works in ys:

$ cat sample/lol2.ys 
!yamlscript/v0

defn lol(x):
  y =: 2 * x
  defn f(z): z + y

say:
  lol(10): 4
$ ys --compile sample/lol2.ys 
(defn lol [x] (let [y (_* 2 x)] (defn f [z] (_+ z y))))
(say ((lol 10) 4))
$ ys sample/lol2.ys 
24

see above

“let over lambda” is more of a design pattern if anything — its a way to create functions that behave like objects, in the sense that the functions hold state

my understanding was that lol is let returning a closure around one or more let vars

that is how they achieve holding state, but again, the point is doing this to hold state

i.e. what makes this design pattern interesting is the fact you can use it to create stateful objects

for more inspiration you can look at chapter 3 of SICP, which covers the exact same thing as “let-over-lambda”, but doesnt use a cool sounding name like that

we also use this pattern in clojurescript libraries like reagent, where UI components are functions returning HTML as data, and state is introduced by using this exact same pattern:

(defn my-component []
  (let [count (r/atom 0)]
    (fn []
      [:div
       [:p "You clicked " @count " times"]
       [:button {:on-click #(swap! count inc)} "Click me"]]))

"State" here implies mutable state that changes from one execution of the function to another, not an effective constant that gets lexically closed over.

Yeah I'm starting to see that. I was reading part of https://letoverlambda.com/ and it said > Let Over Lambda > Let over lambda is a nickname given to a lexical closure. Let over lambda more closely mirrors the lisp code used to create closures than does most terminology. In a let over lambda scenario, the last form returned by a let statement is a lambda expression. It literally looks like let is sitting on top of lambda: >

* (let ((x 0))
>     (lambda () x))

(let ((counter 0))
>   (lambda () (incf counter)))

my original example was gonna be in common lisp precisely because its easier to mutate there compared to clojure 🙂 ended up using clojure anyway since you asked how let-over-lambda would look in practice in clojure

let-made-atoms seem to work out perfectly here though

I think I got LoL right in YS now:

$ cat sample/lol.ys 
!yamlscript/v0

do:
  count =: atom(0)
  counter =: \(swap! count inc)

  say: counter()
  say: counter()
  say: counter()
$ ys sample/lol.ys -c
(do
 (let
  [count (atom 0) counter (fn [] (swap! count inc))]
  (say (counter))
  (say (counter))
  (say (counter))))
$ ys sample/lol.ys 
1
2
3

(the top level do was necessary here because a =: b gens (def a b) at the top level and (let [a b] ...) when not at top; and LoL examples really should have a let)

Seems right to me

Awesome!

I'm already doing this in java using the build-helper-maven-plugin which allows for relative paths, but now I want to add clojure source paths.

Another solution would be to alter $basedir, but that doesn't seem possible.

Maybe you could do that via HTML transformations? https://github.com/weavejester/codox#html-transformations

You can download the jar and refer to it from your deps.edn.

https://github.com/metabase/metabase/blob/master/modules/drivers/athena/deps.edn

we host them in an s3 bucket

oh my god, you are a life saver. thank you!

this project isn't using deps.edn which is a whole other thing

yeah. just adding a jar to the classpath is super annoying in lein

@U0ETXRFEW magically turned my lein project into a lein project with dependencies managed by deps.edn, but otherwise configured by lein.

Depends on what tool you want to target. For Lein - yes, probably a plugin. For tools.deps it would be a tool, similar to what https://github.com/seancorfield/deps-new does.

Another option is to create a stand-alone executable, similar to https://github.com/babashka/neil. You'd have infinite flexibility but you'd have to manage your own installation channels.

There's also this kind of hackery that will let you write a script that runs via the shebang line: https://gist.github.com/ericnormand/6bb4562c4bc578ef223182e3bb1e72c5

You can make an npx command using #C029PTWD3HR, fwiw

If you want to run code that is in the current project, then clojure -M -m some.namespace runs some.namespace/-main -- and you can have -main in as many namespaces as you want; and clojure -X some.namespace/my-fn will run that function, passing a single argument: a hash map of key/value pairs read from the command-line.

Aliases in deps.edn would let you shrink those to something like clojure -M:my-cli or clojure -X:my-exec depending on whether you used :main-opts or :exec-fn.

If you want to run code from a library, you don't need to "install" it -- you can either specify its "coordinates" on the command-line or hide it behind an alias in your deps.edn file: clojure -Sdeps '{:deps {my-new/library {:mvn/version "RELEASE"}}}' -M -m that.library (or -X that.library/function). But putting aliases into your user deps.edn is a pretty common what to deal with this. This is my user deps.edn file: https://github.com/seancorfield/dot-clojure/blob/develop/deps.edn

Thanks all