hi everyone, i used to program in clojure a while ago - at that time vim wasn't supported as well as emacs, there was no such thing as a language server, etc... i feel like things might be different now, and while i can get by in spacemacs i would prefer to use neovim. Could someone point me at a 2019 friendly setup for neovim? I have been using coc for most of my other languages and have clojure-lsp working but i get a LOT of errors (unknown namespace, unknown symbol, etc) and i'm thinking i have something setup wrong. if anyone could point me at their dotfiles as an example or an up to date tutorial i would be grateful, thanks (p.s. - something that works well for clojure and clojurescript would be great) thank you for any help

Hi @fredmonroe. Mine probably isn't a lot better than what you've got, but it's working well: https://github.com/walterl/dotfiles/tree/master/nvim

thank you @clojurians-slack100

If you're using vim-fireplace, make sure that you have it connected to a running nrepl. That enables a bunch more interactive functionality.

But it seems like there are quite a few cool alternatives going around, with authors in this channel 🙂

haha yes - i have some paralysis because of that (e.g. - https://github.com/clojure-vim/acid.nvim)

oh, something that may not be clear from the dotfiles: I have clj-kondo in my $PATH, so ale picks it up and uses it automagically https://github.com/borkdude/clj-kondo

One day I should also get around to adding this to my dotfiles repo:

$ cat ~/.lsp/config.edn 
{"macro-defs"
 {clojure.java.jdbc/with-db-connection
  [:bindings :bound-elements]

  clojure.java.jdbc/with-db-transaction
  [:bindings :bound-elements]

  metabase.api.common/defendpoint
  [:element
   {:pred :string}
   {:pred :string}
   :function-params-and-bodies]

  schema.core/defn
  [{:element :declaration, :tags [:local]}
   ':-
   :element  ; return value signature
   {:pred :string}  ; docstring
   [{:element [:param ':- :element], :repeat true}]  ; parameters
   :bound-elements  ; body
   ]

  schema.core/defmethod
  [{:element :declaration, :tags [:local]}
   :element
   ':-
   :element  ; return value signature
   {:pred :string}  ; docstring
   [{:element [:param ':- :element], :repeat true}]  ; parameters
   :bound-elements  ; body
   ]}}

It helps with some of those red lines that clojure-lsp generates 😉

oh! very helpful - i feel like some of my errors are related to arguments in macros - ("let-release", "with-release") - would this help with those?

My config won't help for those macros you mention, but if you add something similar to ~/.lsp/config.edn, it can. Docs are here: https://github.com/snoe/clojure-lsp#macro-defs, but there's a few details undocumented. So if you want to go deep, check out clojure-lsp's parsing code: https://github.com/snoe/clojure-lsp/blob/master/src/clojure_lsp/parser.clj

you are awesome thanks much. if you ever need help w/ fastai/python or something in that kind of realm i'm your guy - pretty rusty on clojure these days

gtg, but if you don't manage with the macro-defs, leave them (and the definitions of the macros) here and I'll have a look later

this is a simple example, i'll work on it myself, just to show you: (time (dotimes [i 10000] * Unknown symbol: i (mv! t (col a i) y))) * Unknwon symbol: i

@fredmonroe && @clojurians-slack100 I'd be happy to take your macrodefs as contributions too, my stance is clojure.core and popular library macros should be included.

@snoe I’m so noob I’m still trying to figure out which errors are just me setting things up wrong - but will definitely share macrodefs once I know what I’m doing

Thank you for making closure-lsp!

@fredmonroe you may also want to consider conjure instead of fireplace (#conjure). It's a plugin for neovim that uses an io-repl - has support for coc (using coc-conjure) and will shortly (to be merged into master) have the ability to hook into REBL

(and hook into lots of things)

https://github.com/Olical/conjure

by io-repl, do you mean prepl?

😹 here's 10 ways to set up, you wanted help with picking one right?

yes, io-prepl 🙂

thanks for the clarification 🙂

Hey, at least we have options now in Vim land 😄

Even if we're all dabbling in different things. I suppose there's only about 12 of us in the Vim+Clojure Venn diagram so there's enough room for each of us to have a totally different setup 😬

12 people. 12 plugins. Which 13 will you choose?

Here's a spanner for you guys: what would it take to "language server" these 12 plugins. How can we make it so we aren't all rewriting each other's plugins all the time in order to build on top of a different base is slight set of differences.

For example, a UI library for clojure displays might be one way of doing that. And it could be wired into different connection managers. You pass it a map of info and it would display the doc however the user wants it (repl buffer, echo, preview buffer, etc)

Honestly, I feel the amount of choice is a double-edged sword. For (relative) beginners (to clojure, not vim) it is very hard if not impossible to choose the right set of plugins, some of which are even conflicting (e.g. I discovered that slurp/barf from vim-sexp (I think) don’t work well when you have parinfer smart mode enabled). This is a great selling point of Calva/VSCode IMHO: just click “install” and you have something that works quite well so that you can get started and have all that setup stuff out of the way. For me it would be great if someone(s) in this community would stand up and create a clear recommendation for beginners: install <these plugins> and you’re good to go. And, as a relative beginner/newcomer I would strongly suggest that parinfer smart mode should be part of that set of recommended plugins.

Fireplace. Vim-sexp. Async-clj-omni. Asyncomplete.nvim. Vim-sexp-for-regular-people.

Hasn't Shaun given up about smart mode? https://github.com/shaunlebron/parinfer/tree/master/lib

We have made separate attempts to implement Smart Mode in Cursive, Vim, Atom, and Emacs through some wrangling that made integration very difficult and delicate, and ultimately incomplete.

For a beginner to clojure and not vim. Those plugins are what you want. The completion ones are maybe optional.

is there some way to get a "set" of plugins? have been thinking that such sets could be convenient for trying out various combinations -- whether one is a beginner or not.

There's packages in vim now. That would work.

I’ve been using vim-iced (`coc.nvim` has been extremely flaky for me, so I’ve been using it only for TypeScript/JavaScript): https://github.com/mwistrand/dotfiles/tree/master/config/nvim

i'd be interested to zero in on what exactly are the categories of plugins, which plugins are available in each category, and what makes somebody choose one over the other i think paredit vs. parinfer might be one category completion is another category. linting is another. etc.

i would bet that part of the problem is that we have some plugins (cough ALE cough) that do too much and cross the lines between categories

like, if you have to choose between X plugin that does ABC, and Y plugin that does BCD, what do you do if you want ABCD?

seems like it would be better if we just had separate plugins for A, B, C, and D

I've speculated that ALE is the result of building upon an emerging ecosystem at just the wrong time such that scope creeped.

right, that's my sense too

I think most people don't 'choose' they pick what their coworkers use or what they got to work initially.

cough emacs

I'm discussing less LSP itself though, and more of a in-vim standard. Although the LSP clients may be amenable to taking this role. I'm talking about something that perhaps uses the socket repl or nrepl and passes the result to an LSP client to display.

I guess I'm thinking of an "IDE client library" for vim.

But I'm happy to suggest making it clojure specific. The transport is irrelevant. We are all talking about the same thing. Arglists always look the same.

isn't LSP meant to serve the purpose of IDE support in Whatever Text Editor?

I think an IDE client library is exactly the goal of lsp

ha, jinx 🙂

Yeah. I'm not sure how agnostic they are of that transport though.

Maybe we should be working on lsp to prepl tools

yeah, I get it, Jonathan Blow explicitly calls out lsp in his End of Civilization talk. But my feeling is that there's so much momentum across editors for lsp that taking advantage of the existing clients is a quicker path.

Hi all. I’m drinking from the Clojure fire hose at the moment with Vim Fireplace. It it possible with Fireplace, or perhaps something else, to attach a debugger at a breakpoint in my code?

@darrell I use debug-nrepl for this. It starts a repl in the middle of your code and then you can make evaluations or continue.

The gfred library

On mobile now, else I'd link

No problem. I found it, thanks!

Scope capture is also very good in this space