I use https://github.com/PEZ/clojure4vscode with paredit.

I can't make this ($x:text "url" %) to indent correctly. It works perfect in Cursive.

It can be tested with:

{:a 1
 :b           2
 :c 3}

I'm using Emacs paredit as the model here:

Given something like this:

(let [x 1])
(println x)

When the cursor is positioned immediately after the 1, slurp-sexp-forward should first push the outermost ) forward to yield this:

(let [x 1]
 (println x))

(In current implementation, slurp-sexp-forward does nothing when the cursor is inside the let binding.)

A second execution of slurp-sexp-forward should then push the ] forward to yield the valid sexp:

(let [x 1
  (println x)])

I know this is not useful, but that's an effect of the simplified example I'm using.

This is a feature request for strict mode. In strict mode, paredit does not allow you to delete any open/close parenthesis without also deleting their corresponding close/open parenthesis. This has been implemented in Cursive and other paredit plugins for other editors. Are there are plans to add support for this here? If this is something that you would like to implement, how can I help?

Thanks for a great plugin! I'd like to use Calva without Paredit, any chance for that to happen? Now when trying to disable Calva Paredit, VSCode throws the following error:

Cannot disable extension 'Calva Paredit'. Extension 'Calva: Clojure & Clojurescript interactive programming made easy' depends on this.

I'm on vscode 1.28.0, Calva 1.3.44 and Calva Paredit 0.1.15.

Commands like paredit.wrapAroundCurly are very useful also in file formats other than lisps. However, the extension seems to have hardcoded the supported languages:

const languages = new Set(["clojure", "lisp", "scheme"]);

This implies that I can't use the commands in keybindings.json to enable them in filetypes other than lisps.

It's a pretty common use case for me - kill a form and then paste it a somewhere else or a few different places. Currently can't do this.

I'm using Emacs paredit as my model here:

Given an sexpr like

(testing "Define schema"| 
   ,,,)

Where the | represents the cursor position.

Pressing backspace should not delete the " because that would unbalance the form. However, it should step backward inside the quoted string and delete the last character there, yielding:

(testing "Define schem|" 
   ,,,)

That means pressing backspace repeatedly will eventually delete the entire contents of the string, leaving

(testing "|"
   ,,,)

At which point, the next backspace would remove the paired delimiters (just as it works today. 😃 )

Expected Behavior

As long as backspace does not cause an unbalanced form, it should delete the contents of the selection.

Actual Behavior

A selection that includes one or more newlines causes an error with the message Running the contributed command: 'paredit.deleteBackward' failed.

Additional information

This certainly occurs in strict mode. I have not verified whether it also occurs in non-strict mode.

Pressing DEL results in a similar error, for the command paredit.deleteForward.

When the cursor is in the middle of a leaf sexp (I'll use a keyword in the examples), I'd expect it to wrap the whole sexp
examples:

• when it's the last sexp inside another sexp

{:bar :fo|o}
{:bar :fo()o}

• when there is a following sexp

{:fo|o :bar}
{:fo(o :bar)}

• when the cursor is at the beggining of the sexp it works fine

{|:foo :bar}
{(:foo) :bar}

When i try to delete some sexp and it is on multiple lines it does not work right.

For example:

(defn test []
  (println "test"))

So when i kill the println it works correct but when i try to kill the whole function the result is:

  (println "test"))

The same is when i put the string on the next line and try to kill the println expression.

I use the current version for paredit (0.1.9) with VS Code 1.24.1 on windows and didn't tried it on linux.

The Paredit: indent command does not work. It gives an error message from Code instead.

When splicing something like

{[foo "ba|r"]}

The expected result is:

{[foo ba|r]}

Actual result is:

{foo ba|r}

Consider this:

[:div|]

(The vertical bar represents the cursor.)

Now enter a semi-colon:

[:div;|]

There is now unbalance in the code!

I have no idea how to fix this. But it would be a nice thing to handle. What do you say, @dentrado?

several times I need to do the following when refactoring my code

(let [...]
 |(my-fn ...)
  (other-fns ...)

raise

|(my-fn ...)

This is a feature that I used a lot on emacs, but I recon that it might not be a priority here since you are too few people to maintain all the calva extensions. BTW, thanks again for the great work

Hitting backspace with (foo) selected:

Expected: (foo) is deleted.

Actual: (foo) is not deleted and the cursor is moved to the end of the selection.

Further: If the selection starts at end of (foo) (the user selects from there and to the start of the text), and you hit backspace, then the character before (foo) is deleted (if allowed by struct mode).

Preferrably strict mode should refuse to delete the selection if it would unbalance things and leave the selection intact. Otherwise just delete the selection. This is how the demo of paredit.js behaves.

Second best would be to not use strict mode for selection deletions. (Quite a lot less best than remaining strict, but anyway.)

backwardUpSexp is already present, so I'd really like to have forwardUpSexp as well

There appear to be a few offenders I care about.

Take the form (inc map)

Transpose will only work if the cursor is on , or m. Ideally (imo) it should work with the cursor on m,a,p, and do nothing on .

All of the wrap functions and all of the kill functions have this issue as well.

It seems you can sort of get around this with custom keybindings (stringing forwardSexp, backwardSexp, and eg transpose together), but that has the unfortunate side-effect of unexpectedly moving your cursor.