Yi

Yi ideas

This page is meant to gather ideas people have for Yi, an extensible editor written in Haskell.

Emacs

Coming from an Emacs background, the current version of Yi lacks a few things I think are essential, mainly the introspection capabilities of Emacs. One of the main problems is that Yi is based on purely compiled code --- there is little or no interaction with the run-time system.

Ideally, the next version of Yi would be based on a (modified?) version of GHCi, maybe taking advantage of package GHC.

Emacs goodness

The following are things I like about Emacs, as an extensible environment:

Really good online documentation

Emacs can tell you a lot about a function or variable with a keypress--- the current value, where it is declared, and a hypertext formation string

Extensibility

All (good) apps allow users to extend, through, e.g., hooks --- a list of functions that are run before/after some event (like saving a file)

Integration

It is really easy in Emacs to have one package interact with another. Thus, I can, e.g., insert a new appointment from my mail app into the diary.

Everything is One Language

Ignoring the actual language (Lisp!), everything is handled in a uniform language --- from binding keys to writing apps.

Easy to start hacking

I can start playing with the system from the second I start up, and things pretty much work as expected. I.e., I can type a bit of code in, execute it, and the result is displayed in the minibuffer. The good docs help immeasurably.

Written for the frequent user

Lots of key shortcuts (and famous for it). There are still menus, for those who like em, but you aren't forced to pretend you just started using it.

A tonne of code

Well, Haskell has this to some degree. Haskell is (IMHO) much easier to write than ELisp, so maybe people will be encouraged to contribute.

Emacs badness

So, why replace it?:

ELisp

Dynamically scoped, Dynamically typed, ugly, old. 'Nuff said

What's a Parser?

A lot of apps in emacs do stuff with text, usually text that is in some language. There is no standard parser (like, e.g. parsec), so a lot of it is ugly handwritten spaghetti. This also means that adding analysis tools isn't really done (or done nicely).

ELisp again

Haskell is a lot cleaner to write, especially because of the large number of libraries.

Emacs maybeness (?)

Some things that are sometimes bad, sometimes good:

Everything is a buffer

Makes some sense, but sometimes doesn't. It is nice to have uniform key bindings do the right thing (e.g., C-Space sets the mark, and the region can then be used, e.g. to delete a sequence of emails in Wl) Sometimes, however, you just want some sort of GUI widget.

OTOH, having the minibuffer be a special kind of buffer is a good idea.

Properties

It is possible to associate arbitrary properties with symbols. This means you can annotate a symbol and then use that information at a later date

Vi ?

What about vi? I believe we want Yi to subsume vi as well.

Yi

Annoying stuff with the current implementation:

• Does not support all terminals properly (e.g. Meta on gnome-terminal)
• Is quite dependent on terminal (gtk port not easy)
• System of windows is strange. A lot of the cursor-logic is spread in many modules. In particular, windows try to move the cursor themselves, while the buffer should take care of it.
• Throwing exception for switching keymap is ugly
• Keymaps take a [Char] as input, with this or that bit set for indication of meta and control. This is somewhat ugly, and certainly lacks a bit of strongness in typing.

Ideas

Yi should include GHCi

like emacs includes a elisp interpreter.

An extension to GHCi to support documentation of symbols.

This seems to be (reasonably) straightforward, as GHCi already has :info. It would mean hacking the type environment (what about values?) to add documentation information. The main problem would seem to be populating this --- maybe hack haddock to produce something from the library docs? I assume that using package GHC uses the parent RTS (package GHC seems to be the way to go, but more investigation is required --- don?)

Intermixed compiled/interpreted code

(for speed/hacking)

GUI abstraction

want it to work on terminals as well as X

1. Use Stefan O'Rear's vty. for terminal. http://members.cox.net/stefanor/vty/
2. Use gtk2hs for X http://haskell.org/gtk2hs/

Views on data

Rather than just editing a file, you would open a view onto the file, i.e. there is no longer a 1-1 correspondence between buffers and files. Why? Well, for aggregate buffers (i.e., editing multiple files in the one view), or for multiple views of a file (e.g. AST and source-level). There would be some primitive ops for editing a buffer (insertChar, delete, etc.), which would then call update functions on anything observing that file.

Remote attach so I can work from home, but still use a remote machine

Haddock documentation

(no brainer), maybe associate with .hi files for binaries.

A class MiniBufferRead (or PromptingRead) which allows the user to

invoke a function similar to M-x in Emacs, but without requiring (interactive)

-- This is incomprehensibe, would the original author elaborate?

Maybe a class YiShow, which all config items must be a member of? This is to emulate describe-variable

Implementation

Considerations:

Configuration

Per mode/file/buffer/whatever Monads, or reload/recompile? Or some hybrid? How does this interact with the documentation aspects? Do we want to have separate sorts of symbols a la emacs (describe-function, describe-variable), or is everything a function? I would think that configuration info doesn't change that frequently --- is this globally true though?

We can probably use a GHCi-like "let". Rebinding a function would then be synonym to assign a variable, thereby achieve unification between functions and variables.

Interface to the runtime

The scheduler, docs, etc.

Introspection of e.g. what processes are running.

There are already libraries in Haskell for processes, but they don't give Yi any extra information --- we really want a layer on top.

...

Sjw 09:15, 2 June 2006 (UTC)