Yi 0.5.0 Release Notes

Yi

Yi is a text editor written and extensible in Haskell. The long-term goal of the Yi project is to provide the editor of choice for Haskell programmers.

Yi is not a finished product. This is a beta-quality release. However, Yi has become a lot more usable than previously, so if you feel like testing it, now might be a good time to take a look.

Installation

Using cabal install:

cabal install yi–0.5.0.1

If you want unix console support, pass the -fvty option to cabal install.

Features

• A purely functional editor core
• Key-bindings written as parsers of the input
• Emacs, Vim and partial Cua emulations provided by default
• Unix Console front-end (Gtk2Hs frontend is not supported in this release)
• Static configuration (XMonad style) for fast load
• Haskell support:
  • Lexical highlighting
  • Layout-aware parenthesis-matching
  • Auto-indentation
  • Call cabal build within the editor

Links

• download
• FAQ
• homepage
• blog and release notes
• check and report issues
• darcs repository

Credits

This release is brought to you by:

• Allan Clark
• Corey O’Connor
• Gustav Munkby
• Gwern Branwen
• Jean-Philippe Bernardy
• Jeff Wheeler
• Nicolas Pouillard
• Thomas Schilling
• Tristan Allwood

and all the contributors to the previous versions.

I gave a Yi demo at the Haskell Symposium, and the video (recorded “guerrilla style”) is available! It should eventually appear on the ACM Digital Library too, hopefully in better quality, but don’t hold your breath.

The first part demonstrates the Haskell support capabilities, while the second one shows how Yi can be configured and extended.

The demo abstract can be found here.

In this post I’ll give a walkthrough to a simple Yi configuration.

First, note that Yi has no special purpose configuration language. Yi provides building blocks, that the user can combine to create their own editor. This means that the configuration file is a top-level Haskell script , defining a main function.

import Yi
import Yi.Keymap.Emacs as Emacs
import Yi.String (modifyLines)

main :: IO ()
main = yi $ defaultConfig {
  defaultKm = 
     -- take the default Emacs keymap...
     Emacs.keymap <|> 
     -- ... and bind the function to 'Ctrl->'
      (ctrl (char '>') ?>>! increaseIndent)
 }


-- | Increase the indentation of the selection    
increaseIndent :: BufferM ()
increaseIndent = do
  r <- getSelectRegionB 
  r' <- unitWiseRegion Line r 
     -- extend the region to full lines
  modifyRegionB (modifyLines (' ':)) r'
     -- prepend each line with a space

In the above example, the user has defined a new BufferM action, increaseIndent, using the library of functions available in Yi. Then, he has created a new key-binding for it. Using the disjunction operator (<|>), this binding has been merged with the emacs emulation keymap.

This is a very simple example, but it shows how powerful the approach is: there is no limit to what functions the user can create. It is also trivial to use any Haskell package and make its function available in the editor. This is an obvious advantage over the traditional approach, where only a special purpose language is available in the configuration file.

Another advantage to this configuration style is is purely declarative falvour. The user defines the behaviour of the editor “from the ground up”. This can be constrasted to emacs (and lisp) style, where the configuration is a series of modifications of the state.

Finally, I shall say that this configuration model is not unique to Yi: it has already been used with success in the XMonad window manager.