How powerful is language build in vim compare with the language build in emacs?

classic Classic list List threaded Threaded
52 messages Options
123
Reply | Threaded
Open this post in threaded view
|

How powerful is language build in vim compare with the language build in emacs?

Peng Yu
I have learned neither the language for vim scripting nor the language
for emacs scripting (which is lisp, right?). (I know mit-scheme, but I
have never used emacs) May I ask the following questions?

I know Lisp is very powerful. Is the language in vim as powerful?

For what type of tasks, it is more difficult to do in vim scripting
language than lisp in emacs? And for what type of tasks, it is easier
to do in vim scripting language than lisp in emacs?

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Tony Mechelynck
On 25/01/10 06:13, Peng Yu wrote:

> I have learned neither the language for vim scripting nor the language
> for emacs scripting (which is lisp, right?). (I know mit-scheme, but I
> have never used emacs) May I ask the following questions?
>
> I know Lisp is very powerful. Is the language in vim as powerful?
>
> For what type of tasks, it is more difficult to do in vim scripting
> language than lisp in emacs? And for what type of tasks, it is easier
> to do in vim scripting language than lisp in emacs?
>

I don't know. I've seen some Lisp program sources, which AFAICT looked
like a soup of parentheses. Vim script, OTOH, is (to my mind) much
easier to read, and its commands are the "ex-commands" which you can
type at the command-line (where you get by hitting a colon in Normal
mode), including the commands you define. I'd say Vim script belongs to
the family of "structured languages" descended from ALGOL and which
includes C (I think) and Unix shell script.

See for instance ":help design-not" for a few examples of what Vim is
*not* meant to do.


Best regards,
Tony.
--
hundred-and-one symptoms of being an internet addict:
247. You use www.switchboard.com instead of dialing 411 and 555-12-12
      for directory assistance.

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Help with :v

Marczis, Peter (NSN - HU/Budapest)

 Hi,
I would like to delete everything not matching to a pattern...
I usually do it this way:

:v/my pattern/d<CR>

and it works perfect to any single line pattern...

my problem is that I want to keep something like this:

ABC ...
....
....
...
And until the first empty line...

How it is possible ? I was thinking something like this:
:v/ABC\(.|\n)*^\s*$/d

but not really work.

Thanks in advice.

Br,
        Peter.

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: Help with :v

Tim Chase
Marczis, Peter (NSN - HU/Budapest) wrote:

> I usually do it this way:
>
> :v/my pattern/d<CR>
>
> and it works perfect to any single line pattern...
>
> my problem is that I want to keep something like this:
>
> ABC ...
> ....
> ....
> ...
> And until the first empty line...
>
> How it is possible ? I was thinking something like this:
> :v/ABC\(.|\n)*^\s*$/d
>
> but not really work.

My first thought would be to use a "decorate-modify-undecorate"
pattern, something like

   :g/ABC/,/^\s*$/-s/^/@

"on every line matching ABC, from that line through the next
blank line (minus one = "-", which you can remove if you want to
keep the blank lines), tack a '@' character at the beginning of
the line" (mark the lines we want to keep with a unique character)

   :v/^@/d

"delete all the lines we didn't mark as interesting"

   :%s/^@

"remove all the decoration we put in".

It requires being able to find a decoration character that isn't
in use at the beginning of any line, so you might have to use "%"
or some other character instead, but the pattern is the same.

As a side note, it does require at least one blank line after the
each ABC or you'll get a little complaint from Vim.  It also has
difficulty if you have more than one ABC in a section such as

   ABC
   foo
   ABC  <-- there's no blank line above this
   bar      so the overlap with the first ABC
            causes problems

   ABC
   ...

-tim



--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

panshizhu
In reply to this post by Peng Yu
Peng Yu 写道:
> I have learned neither the language for vim scripting nor the language
> for emacs scripting (which is lisp, right?). (I know mit-scheme, but I
> have never used emacs) May I ask the following questions?
>
> I know Lisp is very powerful. Is the language in vim as powerful?
>
> For what type of tasks, it is more difficult to do in vim scripting
> language than lisp in emacs? And for what type of tasks, it is easier
> to do in vim scripting language than lisp in emacs?

In theory, a turing complete language could do anything.

http://en.wikipedia.org/wiki/Turing_completeness

Two turing-complete languages are always inter-translatable.

It is said that Lisp is turing complete.

So if vim script is turing-complete, it is as powerful as Lisp.

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Teemu Likonen
In reply to this post by Peng Yu
* 2010-01-24 21:13 (-0800), Peng Yu wrote:

> I know Lisp is very powerful. Is the language in vim as powerful?

No, it's not. It seems that there are still unique features in Lisp
which are not supported in any other language. In this sense Lisp is the
most powerful language available. Lisp is really different. I don't know
many languages but this is what other people say. Other languages have
gained power by copying Lisp's features.

For example, a Vim script programmer can't use the language to modify
and extend the language itself. On the other hand Lisp programmers do
that pretty much all the time. Emacs people have used Emacs Lisp to
implement quite big part of Common Lisp. A programmer does not see where
the "core language" ends and other features begin because there's no
difference. A good example for this are Common Lisp's standard macros:
the language was used to build part of the language itself.

> For what type of tasks, it is more difficult to do in vim scripting
> language than lisp in emacs? And for what type of tasks, it is easier
> to do in vim scripting language than lisp in emacs?

Now there's the practical angle. Obviously languages don't live in
vacuums; they are part of some environment and often it's the
environment which very much defines language's power and limits. Vim
script is very useful language for interacting with Vim's features. But
a Vim script programmer doesn't have as much freedom as Emacs Lisp
programmer because Vim environment sets more limits than Emacs.

The fundamental difference is that Vim as an environment is pretty much
closed and the Vim script language is just a _scripting_ language for
those features. On the other hand Emacs environment itself is mostly
implemented in Emacs Lisp so programmers kind of live inside the
environment. Emacs Lisp is not a scripting language but the
implementation language of the system itself. This blurs the distinction
between Emacs developers and users. Users get the same access as the
original developers, and all of it interactively without restarting
Emacs.

But are you asking concrete examples of operations which are _easier_ to
do with one editor? There are probably thousands of such examples but
they don't tell much about language's power or environment's abilities.
Well, in Vim script it's easier to go to the first line of current
buffer: 1 (that is, the command is just the number). Nothing can be
simpler than that. The same is more "difficult" in Emacs Lisp code.
Programmers typically do it with (goto-char (point-min)).

It's also probably easier to programmatically search and replace in Vim:

    let cursor = getpos('.')
    %s/regexp/replace/g
    call setpos('.', cursor)

Programmer needs to understand a bit more about actual programming when
doing the same in Emacs Lisp code:

    (save-excursion
      (goto-char (point-min))
      (while (re-search-forward "regexp" nil t)
        (replace-match "replace")))

You know, a conditional loop and all. :-) Some things are easier in
Emacs Lisp - that (save-excursion [...]) macro being one example - but
then again these examples don't tell much about anything.

The bottom line is that

  - on theoretical level no language is more powerful than Lisp and
    therefore Emacs Lisp is more powerful than Vim script.
   
  - on practical level language's power depends on features and limits
    of the surrounding environment. In this area Emacs Lisp also wins
    because the system is almost totally open for a programmer.

  - Vim is obviously an excellent and powerful text editor. I'm just
    comparing features and power of the languages and the two different
    environments as a whole.

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Teemu Likonen
In reply to this post by panshizhu
* 2010-01-27 12:48 (+0800), pansz wrote:

> In theory, a turing complete language could do anything.

In practice the effort of doing things is not equivalent, obviously. :-)
The abstractness and features differ very much and not every programmer
is qualified to compare languages' power. Certainly I'm not.

I'll quote a few paragraphs from Paul Graham's article "Beating the
Averages". It's about comparing languages' power. The article is
available from <http://www.paulgraham.com/avg.html>.

    Programmers get very attached to their favorite languages, and I
    don't want to hurt anyone's feelings, so to explain this point I'm
    going to use a hypothetical language called Blub. Blub falls right
    in the middle of the abstractness continuum. It is not the most
    powerful language, but it is more powerful than Cobol or machine
    language.

    And in fact, our hypothetical Blub programmer wouldn't use either of
    them. Of course he wouldn't program in machine language. That's what
    compilers are for. And as for Cobol, he doesn't know how anyone can
    get anything done with it. It doesn't even have x (Blub feature of
    your choice).

    As long as our hypothetical Blub programmer is looking down the
    power continuum, he knows he's looking down. Languages less powerful
    than Blub are obviously less powerful, because they're missing some
    feature he's used to. But when our hypothetical Blub programmer
    looks in the other direction, up the power continuum, he doesn't
    realize he's looking up. What he sees are merely weird languages. He
    probably considers them about equivalent in power to Blub, but with
    all this other hairy stuff thrown in as well. Blub is good enough
    for him, because he thinks in Blub.

    When we switch to the point of view of a programmer using any of the
    languages higher up the power continuum, however, we find that he in
    turn looks down upon Blub. How can you get anything done in Blub? It
    doesn't even have y.

    By induction, the only programmers in a position to see all the
    differences in power between the various languages are those who
    understand the most powerful one. (This is probably what Eric
    Raymond meant about Lisp making you a better programmer.) You can't
    trust the opinions of the others, because of the Blub paradox:
    they're satisfied with whatever language they happen to use, because
    it dictates the way they think about programs.

    I know this from my own experience, as a high school kid writing
    programs in Basic. That language didn't even support recursion. It's
    hard to imagine writing programs without using recursion, but I
    didn't miss it at the time. I thought in Basic. And I was a whiz at
    it. Master of all I surveyed.

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Ben Schmidt
In reply to this post by panshizhu
> In theory, a turing complete language could do anything.

Not 'do' anything, but 'compute' anything.

And even then, it's not necessarily particularly useful...if it doesn't
have an interface to get the appropriate 'anything' out...or the
appropriate input in. Almost every language is Turing complete, and
Vimscript almost certainly is, though your machine probably doesn't have
an infinite amount of memory. But Vimscript would be pretty useless,
even though Turing complete, if it didn't let you access the text of
your files and operate on it. Fortunately, though, Vim does.

It's a bit of a misunderstanding thinking you don't know Vimscript,
though. If you work in Vim, you already know quite a lot, as Vimscript
is just regular Ex commands. So the learning curve to learning Vimscript
is quite small. Yes, there are a bunch of commands and functions you
will use primarily or exclusively in scripts, but there are plenty you
use both on the commandline and in scripts. Lisp, on the other hand,
isn't the way one usually interacts with Emacs, as far as I know, so
must be learnt separately.

Vim is essentially an imperative procedural language. Lisp is
essentially a functional language. Most people find imperative languages
easier to understand because they're a bit more like recipes and a bit
less like Mathematics! Some people find the reverse, though.

Lisp is certainly more elegant than Vimscript, which is just a mess,
with as many exceptions as rules, and different escaping mechanisms
needed every few lines. If you want to do serious programming, Lisp is
the way to go. If you want a quick hack, Vimscript is probably easier.

Ben.




--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Sean DeNigris
The other thing to consider is that Vim can be compiled with support
for other scripting languages e.g. Tcl, Perl, Python, and Ruby.  I
write nearly all my scripts in Ruby, with a tiny bit of Vimscript glue
code.

Sean

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Teemu Likonen
In reply to this post by Ben Schmidt
* 2010-02-16 09:33 (+1100), Ben Schmidt wrote:

> Vim is essentially an imperative procedural language.

Quite true.

> Lisp is essentially a functional language.

People keep saying that but Emacs Lisp and Common Lisp are really
multi-paradigm languages (Common Lisp more so). You can write these
languages just like you write procedural languages. I started writing
Lisp like I had written other languages - and often still do, whatever
feels natural. The FAQ for comp.lang.functional newsgroup does not even
mention Emacs Lisp and Common Lisp as an example of functional
languages. There is Scheme, though.

For example, you can write procedurally:

    (defun sum-items-loop (list)
      "Sum LIST's items using a loop and store the sum to variable SUM."
      (setq sum 0)
      (dolist (i list)
        (setq sum (+ sum i))))

    (sum-items-loop '(1 2 3 4))
    ;; sum=10

But you can also write:

    (setq sum (let ((sum 0))
                (dolist (i '(1 2 3 4))
                  (setq sum (+ sum i)))
                sum))
    ;; sum=10 (no other effects)

Or use recursion:

    (defun sum-items-recursive (list)
      "Sum LIST's items using recursion."
      (if (not list)
          0
        (let ((i (car list)))
          (+ i (sum-items-recursive (cdr list))))))

    (sum-items-recursive '(1 2 3 4))
    ;; The return value is 10 and there are no side effects.

> Most people find imperative languages easier to understand because
> they're a bit more like recipes and a bit less like Mathematics! Some
> people find the reverse, though.

And some people like both and use Lisp. :-)

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

John Magolske
In reply to this post by Sean DeNigris
* Sean DeNigris <[hidden email]> [100215 16:32]:
> The other thing to consider is that Vim can be compiled with support
> for other scripting languages e.g. Tcl, Perl, Python, and Ruby.  I
> write nearly all my scripts in Ruby, with a tiny bit of Vimscript glue
> code.

Anyone know if Lua support is getting any closer to making it into Vim?

Searching around, I see there's a patch:
http://wiki.linuxfromscratch.org/blfs/attachment/wiki/vim/vim72-lua-0.6.patch.gz

John


--
John Magolske
http://B79.net/contact

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Teemu Likonen
In reply to this post by Teemu Likonen
* 2010-02-16 07:44 (+0200), Teemu Likonen wrote:

> Or use recursion:
>
>     (defun sum-items-recursive (list)
>       "Sum LIST's items using recursion."
>       (if (not list)
>           0
>         (let ((i (car list)))
>           (+ i (sum-items-recursive (cdr list))))))
>
>     (sum-items-recursive '(1 2 3 4))
>     ;; The return value is 10 and there are no side effects.

The function can be written without the temporary variable i:

    (defun sum-items-recursive (list)
      "Sum LIST's items using recursion."
      (if (not list)
          0
        (+ (car list) (sum-items-recursive (cdr list)))))

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Ben Schmidt
In reply to this post by Teemu Likonen
>> Lisp is essentially a functional language.
>
> People keep saying that but Emacs Lisp and Common Lisp are really
> multi-paradigm languages (Common Lisp more so).

Yeah, I know. But I think the 'essence' of the language is more
functional, really. Even 'functional' is used pretty loosely, though.
I was aiming for a broad stereotype. Not like me. Usually I'm horribly
pedantic.

I should get around to learning some Lisp properly. It's somewhat on my
"I'm not all that interested" language list because of the syntax,
though; like Perl. A bit too flexible for my liking, as it can lead a
bit too easily to sloppy programs. And I've never been all that good at
counting parentheses!

Mind you, at least the syntax itself it is absolutely consistent.
Comparatively, Vimscript is a mess!

>> Most people find imperative languages easier to understand because
>> they're a bit more like recipes and a bit less like Mathematics! Some
>> people find the reverse, though.
>
> And some people like both and use Lisp. :-)

Touché!

Grins,

Ben.




--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Teemu Likonen
* 2010-02-17 00:38 (+1100), Ben Schmidt wrote:

> And I've never been all that good at counting parentheses!

Neither have I. Lisp IDEs have features which make writing and
navigating through lists and other s-expressions really easy. For
example, Emacs users write and close lists with Alt+( and Alt+). Even
complex-looking structures are actually trivial to write. But I wouldn't
write a single expression of Lisp with Nano or Notepad! :-)

    (if (setf (nth 3 *foo*) (cond ((and (= bar 1)
                                        (> (length list) 3))
                                   (do-this))
                                  ((or (> blah 1)
                                       (< blah 5 ))
                                   (do-that)
                                   (and-some-more))
                                  (t
                                   (else-do))))
        (then-this)
      (else-this)
      (and-that))

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Bram Moolenaar
In reply to this post by Ben Schmidt

> >> Lisp is essentially a functional language.
> >
> > People keep saying that but Emacs Lisp and Common Lisp are really
> > multi-paradigm languages (Common Lisp more so).
>
> Yeah, I know. But I think the 'essence' of the language is more
> functional, really. Even 'functional' is used pretty loosely, though.
> I was aiming for a broad stereotype. Not like me. Usually I'm horribly
> pedantic.
>
> I should get around to learning some Lisp properly. It's somewhat on my
> "I'm not all that interested" language list because of the syntax,
> though; like Perl. A bit too flexible for my liking, as it can lead a
> bit too easily to sloppy programs. And I've never been all that good at
> counting parentheses!
>
> Mind you, at least the syntax itself it is absolutely consistent.
> Comparatively, Vimscript is a mess!

I'll bite.

One of the most important aspects of a programming or scripting language
is that it's easy to read back.  Only then can one figure out what it's
doing exactly and easily spot mistakes.  Both Perl and Lisp fail
miserably on this aspect.

Unfortunately, programmers are proud of creating something that other
people have a hard time figuring out what it does.  It's like a priest
talking latin, it sets them apart from the crowd.

--
Married is a three ring circus:
First comes the engagement ring.
Then comes the wedding ring.
Then comes the suffering.

 /// Bram Moolenaar -- [hidden email] -- http://www.Moolenaar.net   \\\
///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
\\\        download, build and distribute -- http://www.A-A-P.org        ///
 \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Vincent Arnoux
On Wed, Feb 17, 2010 at 12:45, Bram Moolenaar <[hidden email]> wrote:

> > Comparatively, Vimscript is a mess!
>
> I'll bite.
>
> One of the most important aspects of a programming or scripting language
> is that it's easy to read back.  Only then can one figure out what it's
> doing exactly and easily spot mistakes.  Both Perl and Lisp fail
> miserably on this aspect.
>
> Unfortunately, programmers are proud of creating something that other
> people have a hard time figuring out what it does.  It's like a priest
> talking latin, it sets them apart from the crowd.

Innocent question incoming: Wouldn't it be a good idea to write a
binding of Vimscript in, say, Python or Lua or any other more widely
spread language and ship it with vim?

- Vincent

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Tim Chase

> Innocent question incoming: Wouldn't it be a good idea to write a
> binding of Vimscript in, say, Python or Lua or any other more widely
> spread language and ship it with vim?

You mean like it already does? :)

It has interfaces for Python, Perl, Ruby, TCL, and MZScheme.  You
can find them enumerated at

   :help reference_toc

and skim down to the "Interfaces" section.  Your vim has to be
built with support, but Vim does allow for building with a
variety of language bindings.

-tim


--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

scott-268
On Wednesday 17 February 2010 10:26:47 am Tim Chase wrote:

> > Innocent question incoming: Wouldn't it be a good idea to
> > write a binding of Vimscript in, say, Python or Lua or any
> > other more widely spread language and ship it with vim?
>
> You mean like it already does? :)
>
> It has interfaces for Python, Perl, Ruby, TCL, and
>  MZScheme.  You  can find them enumerated at
>
>    :help reference_toc
>
> and skim down to the "Interfaces" section.  Your vim has to
>  be  built with support, but Vim does allow for building with
>  a variety of language bindings.

also, you can have your cake and eat it too -- vim's filtering
syntax is so good you can have a lean and mean vim with no extra
interpreters built in, then filter the buffer, or a select part
of the buffer through any script or program of your choice

if you are a fan of lisp and want to work on your buffer with it,
there's no need for a lisp-enabled vim, just send whatever part
of your buffer is relevant out to your lisp code and let it send
back the modifications

you are limited only by your imagination

sc

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Teemu Likonen
In reply to this post by Bram Moolenaar
* 2010-02-17 12:45 (+0100), Bram Moolenaar wrote:

> One of the most important aspects of a programming or scripting
> language is that it's easy to read back. Only then can one figure out
> what it's doing exactly and easily spot mistakes. Both Perl and Lisp
> fail miserably on this aspect.

Are there some reliable sources which indicate that Perl and Lisp code
are not usually read, debugged or fixed after the code has been
initially written? Or is there a general consensus or verifiable data
that fixing problems in Perl or Lisp code takes more time than fixing
problems in code written in other languages? "Failing miserably", as you
put it, sounds like there is a clear and somewhat objectively measurable
difference.

I have no answers to those but I sense a danger in discussions like
this. It can easily go to "my favourite language is a very clear one"
and "other people's code and favourite languages are unreadable."

My opinion is that a familiar coding style and familiar language make
code readable. And then also the programming style of not doing too much
different things in a tiny part of code. Perl "fails miserably" with me
because I still haven't had time to actually learn it. But I think it's
me who fails.

I'm relatively new to Lisp but I find it beautiful and clear. It's often
verbose and macros hide boring repetitive code and complexity. Then
again, I have had motivation to learn and understand Lisp. Motivation
helps a lot. :-)

> Unfortunately, programmers are proud of creating something that other
> people have a hard time figuring out what it does.

I can't comment about the pride but I'd like to ask what do you think
affects more, coding style or language? I'm asking because in the
previous paragraph you spoke about languages' readability and now you
switched to programmers. Maybe you mean that some programmers try to do
clever and powerful tricks which do a lot of things with a tiny piece of
code but are difficult to understand quickly (?).

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
Reply | Threaded
Open this post in threaded view
|

Re: How powerful is language build in vim compare with the language build in emacs?

Vincent Arnoux
In reply to this post by Tim Chase
On Wed, Feb 17, 2010 at 17:26, Tim Chase <[hidden email]> wrote:

>
>> Innocent question incoming: Wouldn't it be a good idea to write a
>> binding of Vimscript in, say, Python or Lua or any other more widely
>> spread language and ship it with vim?
>
> You mean like it already does? :)
>
> It has interfaces for Python, Perl, Ruby, TCL, and MZScheme.  You can find
> them enumerated at
>
>  :help reference_toc
>
> and skim down to the "Interfaces" section.  Your vim has to be built with
> support, but Vim does allow for building with a variety of language
> bindings.

I am sorry I was not clear enough... By "ship it with vim", I actually
meant bundle the (Python|Lisp|Perl|Ruby|Whatever) interpreter with vim
so that plugins written in this language are directly usable without
extra installation nor configuration. This would avoid having to
re-invent the wheel with another scripting language specific to vim.
Of course, your argument of the cake I can make myself and eat is
still valid...

- Vincent

--
You received this message from the "vim_use" maillist.
For more information, visit http://www.vim.org/maillist.php
123