

EditREPL - Open Vim from within the Python REPL - philipbjorge
http://philipbjorge.github.com/EditREPL/

======
lbolla
IPython has this feature baked in the magic %ed command [1].

[1]: <http://ipython.org/ipython-doc/dev/config/editors.html>

~~~
benatkin
Yes, and to edit the last thing you typed, you can run %ed _. When you exit
%ed it runs the code and then returns the code as a string.

------
pixelmonkey
IPython can also be run as a server (ipython kernel[1]) and then connected to
via a vim plugin called vim-ipython [2]. This means you can do the other
direction: evaluate a vim buffer in a running IPython session, and then
connect to that IPython session to actually use the code you wrote in vim.

See:

[1]
[http://wiki.ipython.org/Cookbook/Connecting_to_a_remote_kern...](http://wiki.ipython.org/Cookbook/Connecting_to_a_remote_kernel_via_ssh)

[2] <https://github.com/ivanov/vim-ipython>

------
bitwize
Nice. Reminds me of a feature I have in Glass Table[0]:

Define a procedure, macro, or record type called foo:

    
    
        (define (foo x) ...)
    

Now say:

    
    
        ,(edit foo)
    

Your definition appears in the editor of your choice. (Try running GT within
Emacs and setting your EDITOR to "emacsclient".) Make changes; provided no
errors occurred (like missing parens) the changes take effect when you save
and quit.

It's a nice little workflow; if you squint, it almost feels like a CADR...

[0] <https://github.com/bitwize/glasstable>

------
JulianWasTaken
Cool.

Haven't looked at the code yet, but I wrote:

[https://github.com/Julian/dotfiles/blob/master/.config/pytho...](https://github.com/Julian/dotfiles/blob/master/.config/python/rc.py#L53)

which does something similar (and is interpreter agnostic as it looks like
this is).

~~~
philipbjorge
Mine's not interpreter agnostic because I had to mess with the stack frames to
insert variables into the global context.

But yours is able to do that because your importing a top-level edit function
while I was pretty set on dynamically creating a vim() method and not having
to import a function (just a module).

I love how yours lists the globals though! I might just have to bite that
feature :).

~~~
JulianWasTaken
Oh, yeah, well, importing stuff on interpreter startup is pretty much exactly
what $PYTHONSTARTUP is for :).

~~~
philipbjorge
And this is why I post code online - to find out the right way to do things.
PYTHONSTARTUP is exactly 100% what I was looking for, but didn't know existed.

------
ashayh
For Ruby IRB, there is interactive editor:
<http://vimcasts.org/episodes/running-vim-within-irb/>

------
jlgreco
I could be mistaken, but isn't this a GNU Readline feature?

Neat regardless.

~~~
philipbjorge
I think this is different because I'm full on opening an instance of vim. (I
didn't know about GNU Readline though and it looks awesome - I'll definitely
try and work it into a project at some point).

~~~
ben0x539
I'm only using GNU readline for my bash prompt, but if I press v it spawns a
full-on $EDITOR instance to edit the commandline.

~~~
philipbjorge
This is awesome (I still have a lot to learn about bash) and effectively what
my module does.

Just so others know, you have to put bash in vi mode and press Esc before v
(otherwise it's ctrl+x ctrl+e).

set -o vi

~~~
jlgreco
Aye, looks like I was wrong. This is a feature that bash has, not Readline.
(in bash 4.2: bashline.c:858)

------
Glench
oh my god this is awesome

