

Lisp support in vim - kul_
http://vimdoc.sourceforge.net/htmldoc/if_mzsch.html

======
terhechte
I recently (about 6 months ago, I think) switched from Vim to Emacs + Evil (a
really good Vim emulator) and the switch can only be described as awesome:

I feel (and this may be just me) that Lisp in Emacs is easier to learn, better
integrated, and offers more flexibility than VimScript in Vim. Thus, while my
whole of custom VimScript over 5 years of usage can be reduced to around 20
lines in my vimrc, I've already written several small scripts, plugins, and
more in emacs lisp since I started using emacs.

Also, the plugin / extension ecosystem is fantastic, the editor has a lot of
great features, and almost every customization I could think of was easily (or
sometimes not so easily done).

All the while, I kept using the deeply-in-muscle-memory-ingrained Vim normal
mode syntax and I use and act in Emacs just like I would in Vim. There're very
very few differences. (In fact, I regularly fire up vim for quick config file
editing, and there's no _getting used to it_ because it really feels the same,
only looks different and has less functionality, something which I don't need
when I'm quickly changing a couple of lines in a config file).

If you like Vim but are wishing for a better integration language and possible
more IDE like features, give Emacs + Evil a try:

[http://www.emacswiki.org/emacs/Evil](http://www.emacswiki.org/emacs/Evil)

~~~
MetaCosm
I gave it 21 days. Evil is by far the best vim emulator I have ever used.
Seriously, nothing else comes close. It is also fairly trivial to fix the
rough edges via the init.el.

> Lisp in Emacs is easier to learn

Agreed, not so much because the baseline is simpler, but because it is
consistent -- everything is a function call -- and once you get over the hump,
this is a huge benefit. Vimscript has gobs of gotchas.

> Also, the plugin / extension ecosystem is fantastic

Can't agree here. The plugins are often hard / annoying to use and missing
critical features. I still think (despite vimscript) that the vim plugins are
far better in most cases. Decent fuzzy finding across everything I care about
(files, tags, buffers, etc) is a rather robust example of where emacs falls
down... I tried literally dozens of extensions.. to get basically a "meh"
solution.

At the end of the day, after using Evil 10 hours a day for 3 weeks -- I came
the the conclusion that it is very good and very usable... some rough edges
when you break out of evil mode, annoying console support (you need sr-
speedbar, not speedbar), and annoying color schemes.

It did make me focus my vim workflow a little more with tools like vimux
(works with tmux), expandregion, easymotion and a few other tricks that I
learned to love from emacs.

------
daniel-levin
Vim-fireplace with Clojure is really awesome. Check it out [1]. It's written
by Tim Pope, who is a very active developer of Vim related tooling. The setup
is simpler than Emacs, and works out of the box (cider for Emacs gave me
endless headaches [2]).

I recommend it highly because it shortens your code-run-feedback cycle
dramatically.

[1] [https://github.com/tpope/vim-fireplace](https://github.com/tpope/vim-
fireplace) [2] [https://github.com/clojure-
emacs/cider/issues](https://github.com/clojure-emacs/cider/issues)

------
UNIXgod
I'm interested in creating my own scheme interpreter and I've used
/n?(vi)|m?|(e(x|d))/ for many years. For any external script the end user can
stream back the transform simply by using the bang operator. How would I go
about calling one of my scripts in vimscript so I could create named macros
without the bang operator? Is there a library function which I can create a
small system wrapper to call _any_ language on the system to extend it without
bang?

------
francis-
Vim gets threading support via LISP before Emacs does - good for you guys.

(I'm a LISP + EMACS user who desperately needs threads in EMACS)

------
phaer
...or you could use Emacs viper-mode and get lisp support in vim in lisp.

~~~
jimmcslim
Yo dawg, I heard you like Lisp so we...

