Why don't you put it on a git forge like github/gitlab and use it like a normal git dependency?

If you are just sharing this lib with your other projects, then you can access the shared library via the local/root coordinate. See https://clojure.org/guides/deps_and_cli for more.

Awesome! That’s remarkably clean and simple. I don’t know why I spend so much time messing around with Leiningen, deps-new, templates, etc.

I don't use any of those /shrug

By the way, kudos for writing https://clojure.org/guides/deps_and_cli. It was straightforward to follow. I just wanted to make sure I had understood correctly how little is required to get rolling.

@U064X3EF3 Am I correct in assuming that the Clojure CLI install has the equivalent of :path ["src"] , so that the src/core.clj file in lelfericf's example is found on the class path without needing to be specified in the project deps.edn

Yes, that's the default in the root deps.edn

https://github.com/clojure/tools.deps.alpha/blob/master/src/main/resources/clojure/tools/deps/deps.edn

Ah yes, I also found /usr/local/lib/clojure/deps.edn on my file space. Thank you.

The file on disk is there for legacy but it's not used

The root is a resource loaded from the tools.deps jar (really the uberjar in the cli)

Yeah, I could fire up the REPL with clj without deps.edn. But I think it’s rare that there will be no dependencies for my projects, so I view it as necessary. I tried running clj with an empty deps.end, but that resulted in an error. It was happy as long as it got a pair of {}.

The algorithm for signing is well documented, and all the crypto code for it ships with the jvm, so it is a nice little exercise to sit down and write. Zero dependencies.

You could use

https://github.com/clojure/tools.gitlibs from boot maybe

Might be a chicken and egg problem though

(the readme does show gitlibs as being in a maven repo)

But I guess that wouldn't get you transitive deps of tools.build

Hi sorry to disturb @U064X3EF3 any news on this one?

Sorry, what's the question?

Ah we might have come to a work-around internally on this, we’re trying to use tools.build from a boot system but tools.build is only available as a git sha at the moment we’d like it to be on maven ideally I think our work around is going to be to create a library that uses tools.build, then turn that into a jar, then require that jar into our other repos

oh, gotcha. haven't gotten around to it.

(let [a 1
      b (+ a 1)
      ;; the line below is generated by the macro (pos? b) is the form provided to the macro
      b (if (pos? b) "foo" "bar")]
  b) => "foo"

ill do this in an editor 😄

so when traversing the let form b is available as a symbol (on line 4).

OK so that's the expansion, what would the input look like?

the input is the form (pos? b)

no, I mean the whole thing, including the macro call

(let [a 1
      b (+ a 1)
      :do-test (pos? b)]
  b)

The only macro call in what you wrote is let

Macro calls always look like (macro-name <zero or more expressions here>)

So the macro I want to write takes that form and generates the snippet at the beginning of this thread.

(defmacro m [&forms]
…)
(m 
(let [a 1
      b (+ a 1)
      :do-test [(pos? b) "foo" "bar"]]
  b))
=>
(let [a 1
      b (+ a 1)
      ;; the line below is generated by the macro (pos? b) is the form provided to the macro
      b (if (pos? b) "foo" "bar")]
  b) => "foo"

You want to write a macro, for example named mylet, and then put mylet in place of the let in the expression you wrote?

Apologies for the lack of clarity. I’m reaching here…

It seems odd to want to write a macro where the input is almost exactly the same length and complexity as the output

but maybe you have other use cases in mind where the output is trickier or more tedious/long to type?

It involves monads 😄

So it looks quite doable to write a macro that would take that let form as input, and transform it into the let form you show as the result, by writing appropriate Clojure code that turns one of those expressions into the other.

More precisely it involves clandestine types with values wrapped in tag-tuples

The :do-test should always look for the most recently bound symbol, and bind it again, I suppose?

That’s right!

So the most recently bound symbol is right there in the vector of expressions after the symbol let. Should be straightforward to look for 3rd, 5th, 7th, etc. elements of that vector equal to :do-test, and if they are equal to that, replace it with the element 2 elements earlier?

Perhaps, I’m concerned about the row above only in my case.

I’m traversing the pairs of symbol--values in reverse order.

Do you want to allow, or signal as an error, an input with two "consecutive" :do-test symbols? I don't know the meaning you are going for here, but if you want to allow that, perhaps going in forward order rather than reverse order would be easier.

It could be that the order does not matter. I haven’t thought about validating input yet.

I’m working with for rather than let I might add.

it shouldn't be hard to translate into :let clauses in the for - but definitely go in forward order rather than back to front

watch out for emitted code size being too large for a method body though - for is a beast and can produce huge output already

Thanks for the tip. I created this problem for myself because of how challenging the implementation of for was to understand.

right - for is a beast, but I think you can just expand into a for invocation, rather than re-implementing it

I am using the sequence monad from algo.monads instead already actually. Simplifying the syntax using macros was the last hurdle before finishing up this project and the write-up.

Thanks for all the help! I’ll have to return to this problem later.

given that your problem statement is "I have a thing that works, and want a better syntax", it might help to think of macros differently here - fundamentally they are a function that takes a form, and returns a new form to be compiled. if you are worrying about semantics you are probably going astray, they are a syntax -> syntax transform

so eg. instead of looking for a mechanism that creates new local bindings, you'd look for a transform that creates the form that establishes those bindings

I see what you mean. My aim originally was to have an extended version of core/for, which could be used interchangeably with core/for. This somewhat puts constraints on the syntax used for the resulting macro.

btw you don't need to quote '[1 2]. [1 2] is the literal vector. It's only lists and symbols that are special

Because iterate is a function that returns a collection that has an unlimited quantity of elements. You have to use some other function to collect the results, like the 'take' function for example. See the docs and examples here https://clojuredocs.org/clojure.core/iterate Start trying (take 1 (iterate fib-add [1 2])) Then take 2 etc.

millionth fibonacci result

also, if you prefer heap exhaustion rather than integer overflow (or, more seriously, if you want results too large to fit in a Long), you can use +' instead of +

@U051SS2EU lul