Personal tools

Yi

From HaskellWiki

(Difference between revisions)
Jump to: navigation, search
(Get Yi: mention you need darcs-2)
(New issue tracker for Yi)
(25 intermediate revisions by 15 users not shown)
Line 14: Line 14:
 
* Keybindings written as parsers of the input;
 
* Keybindings written as parsers of the input;
 
* Emacs, Vim and Cua (subset) emulations provided by default;
 
* Emacs, Vim and Cua (subset) emulations provided by default;
* Vty, Gtk2Hs, and (experimental) Cocoa frontends
+
* Vty, Gtk2Hs, and, in development, Cocoa and Pango frontends.
   
 
The long term goal of the project is to make Yi the editor of choice for the haskell hacker.
 
The long term goal of the project is to make Yi the editor of choice for the haskell hacker.
Line 22: Line 22:
 
* add cool features
 
* add cool features
   
former Yi homepage: http://www.cse.unsw.edu.au/~dons/yi.html
+
former Yi homepage: http://www.cse.unsw.edu.au/~dons/yi.html (this link is dead as of Nov 7, 2011).
   
 
== Get Yi ==
 
== Get Yi ==
   
*[http://hackage.haskell.org/cgi-bin/hackage-scripts/package/yi Stable release on Hackage]
+
=== From Hackage ===
*Development repository:
 
darcs get --partial http://code.haskell.org/yi/
 
Note that we use the [[Darcs]]-2 repository format (to benefit from the improved performance and merge algorithms), so you will need Darcs 2.0 or higher to 'get' or 'pull'.
 
   
We try to keep the repository in a clean and buildable state, so it's "testable". If you have Darcs installed and a GHC 6.8.x installation, this is a better choice.
+
Yi depends on the [http://haskell.org/platform Haskell Platform] which must be installed. Many Haskellers haven't installed this explicitly, as they have already installed most of the utilities it contains; to be sure you have everything that is needed, it is recommended that you explicitly install the Platform.
   
=== Yi for Mac OS X ===
+
Following that, simply:
  +
  +
cabal update<br />
  +
cabal install yi
  +
  +
More information about the package is available about [http://hackage.haskell.org/package/yi Yi on Hackage].
  +
  +
=== From GitHub ===
  +
  +
See the GitHub [https://github.com/yi-editor/yi repository]. Or get it with git:
  +
  +
$ git clone git://github.com/yi-editor/yi.git
  +
  +
We try to keep the repository in a clean and buildable state, so it's "testable" for new users. Yi usually only works on the latest GHC release.
  +
  +
''Note that the old yi-contrib repository is now just a subdirectory of the yi repo.''
  +
  +
=== Platform Support ===
  +
  +
==== Mac OS X ====
   
 
The easiest way to get Yi for Mac OS X is currently no different from the above. There is also a very old deprecated Yi release in MacPorts. Please use the Hackage version instead.
 
The easiest way to get Yi for Mac OS X is currently no different from the above. There is also a very old deprecated Yi release in MacPorts. Please use the Hackage version instead.
   
Additionally, if you want a nice .app front-end you can download [http://tetration.itgo.com/hs/Yi.app-0.3.dmg.gz Yi.app] (which does not contain Yi, it is just a wrapper, for now) and edit Yi.app/Contents/Resources/script if you did not use MacPorts to install Yi.
+
==== Windows ====
  +
  +
The current version on Hackage (0.6.1) can be built on windows. Configure with flag -f-vty -fpango to force pango interface (vty is not supported in windows).
   
 
== Screenshots (0.3) ==
 
== Screenshots (0.3) ==
Line 41: Line 41:
 
[[Image:Yi-20080114-vty.png|thumb|none|500px|The Vty frontend]]
 
[[Image:Yi-20080114-vty.png|thumb|none|500px|The Vty frontend]]
   
== NEWS ==
+
== News ==
 
(Recent items first)
 
   
* I will give a Yi demo at the Haskell symposium 2008. The [http://code.haskell.org/yi/doc/hask08.pdf abstract] is a good 1-page introduction to Yi.
+
There is a Yi blog, that reports the important news about Yi, at [http://yi-editor.blogspot.com/ http://yi-editor.blogspot.com/]. It also delves into algorithms and the Yi internals.
* support for cabal build
 
* Many more usability improvements (highlighted search, ...)
 
* I gave a talk about incremental parsing in Yi at the Chalmers' FP workshop. Find the slides here: http://code.haskell.org/yi/doc/IncrementalParsing.odp
 
* preliminary Haskell-specific support
 
* many small usability enhancements
 
* Buffer modes
 
* Context-free (ie. non-regular) syntax highlighters
 
* Fast (incremental) syntax highlighters
 
* [[XMonad]]-style, static configuration (fast load!)
 
* More Vim emulation
 
* Many bugfixes
 
* Yi 0.3 released
 
* 'sdist' functionality
 
* Haddocked API
 
* Reverse incremental search
 
* "rope-like" structure for buffer (eg. for reading/editing huge log files)
 
* Experimental Cocoa frontend (OS X)
 
* More functionality of emacs/vim implemented
 
* Andy wrote a nice Yi 0.3 tutorial: http://nobugs.org/developer/yi/index.html (note that this tutorial probably will not work for darcs Yi/Yi 0.4)
 
* Yi is now hosted on code.haskell.org/yi
 
* Further simplify build process
 
   
[[/OldNews]]
+
You can also check the [[/OldNews]].
   
 
== Bugs ==
 
== Bugs ==
   
Check/report bug reports here: [http://code.google.com/p/yi-editor/issues/list Google Code: yi-editor]
+
Check/report bug reports here: [https://github.com/yi-editor/yi/issues Github issue tracker]
   
 
== FAQs ==
 
== FAQs ==
Line 57: Line 57:
 
== Contribute ==
 
== Contribute ==
   
Get the repo here:
+
Fork the source on GitHub and send requests for merges to the mailing list. Patches are always welcome. :)
 
darcs get --partial http://code.haskell.org/yi/
 
 
Work on whatever you please, patches are always welcome. :)
 
   
 
Otherwise, see the complete list of open issues here:
 
Otherwise, see the complete list of open issues here:
Line 72: Line 72:
 
=== Write access policy ===
 
=== Write access policy ===
   
One does not need write access to the repository to contribute. Use "darcs send" to send your patches to the Yi development mailing list; someone else can apply them.
+
One does not need write access to the repository to contribute. Please fork the main repository and send pull requests.
   
 
Write access can however be granted, with the following disclaimer:
 
Write access can however be granted, with the following disclaimer:
Line 96: Line 96:
 
*Views on data
 
*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.
 
: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.
  +
  +
*Support for perl style regular expressions
  +
:Emacs regexes don't support the same set of features; perl regexes are more tersely powerful. This could be a good feature for luring users from vanilla emacs.
   
 
*Remote attach so I can work from home, but still use a remote machine
 
*Remote attach so I can work from home, but still use a remote machine
Line 106: Line 109:
   
 
*Support for collaborative editing. This would be very good for #haskell work, and the text editor Gobby and its [http://gobby.0x539.de/trac/wiki/ObbyProtocol Obby protocol] seem to provide a candidate way of doing things.
 
*Support for collaborative editing. This would be very good for #haskell work, and the text editor Gobby and its [http://gobby.0x539.de/trac/wiki/ObbyProtocol Obby protocol] seem to provide a candidate way of doing things.
  +
   
 
=== Borrowing from other editors ===
 
=== Borrowing from other editors ===
Line 125: Line 129:
 
; Hooks-Extensibility
 
; Hooks-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)
 
: 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)
  +
  +
; List of must-have features
  +
: http://glyph.twistedmatrix.com/2008/12/emacs-test.html
   
   
Line 152: Line 159:
 
: 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
 
: 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? ====
+
==== Vim? ====
   
 
; good things
 
; good things
 
: modal key editing -> configuration system is powerful enough!
 
: modal key editing -> configuration system is powerful enough!
: light weight - fast startup -> yi has this :)
+
: light weight -> fast startup -> yi has this :)
   
   
Line 175: Line 182:
 
== Trivia ==
 
== Trivia ==
   
Y I is the most recursive acronym. (Read it as combinators).
+
;Y I is the most recursive acronym. (Read it as combinators).
義, pronounced yi, means righteousness, one of the five virtues of confucianism.
+
;義, pronounced yi, means righteousness, one of the five virtues of confucianism.
  +
;Yi is the symbol for a yobi - the largest [http://en.wikipedia.org/wiki/Binary_prefix#Prefixes binary prefix], meaning 2^80
  +
  +
== External links ==
  +
  +
* Blog: http://yi-editor.blogspot.com/
  +
* Haddock: http://projects.haskell.org/yi/doc/
  +
* Repository: https://github.com/yi-editor/yi
  +
* Issues tracker: https://github.com/yi-editor/yi/issues
  +
* Hackage page: http://hackage.haskell.org/package/yi
  +
* IRC channel: #yi on Freenode

Revision as of 10:43, 30 November 2012

Yi-logo.png

Contents

1 About

Yi is a text editor written in Haskell and extensible in Haskell. The goal of Yi is to provide a flexible, powerful and correct editor core scriptable in Haskell.

Features:

  • A purely functional editor core;
  • Keybindings written as parsers of the input;
  • Emacs, Vim and Cua (subset) emulations provided by default;
  • Vty, Gtk2Hs, and, in development, Cocoa and Pango frontends.

The long term goal of the project is to make Yi the editor of choice for the haskell hacker.

The main short term goal is to maximize Yi's Fun Factor. This includes:

  • improve hackability (and therefore architecture)
  • add cool features

former Yi homepage: http://www.cse.unsw.edu.au/~dons/yi.html (this link is dead as of Nov 7, 2011).

2 Get Yi

2.1 From Hackage

Yi depends on the Haskell Platform which must be installed. Many Haskellers haven't installed this explicitly, as they have already installed most of the utilities it contains; to be sure you have everything that is needed, it is recommended that you explicitly install the Platform.

Following that, simply:

cabal update
cabal install yi

More information about the package is available about Yi on Hackage.

2.2 From GitHub

See the GitHub repository. Or get it with git:

$ git clone git://github.com/yi-editor/yi.git

We try to keep the repository in a clean and buildable state, so it's "testable" for new users. Yi usually only works on the latest GHC release.

Note that the old yi-contrib repository is now just a subdirectory of the yi repo.

2.3 Platform Support

2.3.1 Mac OS X

The easiest way to get Yi for Mac OS X is currently no different from the above. There is also a very old deprecated Yi release in MacPorts. Please use the Hackage version instead.

2.3.2 Windows

The current version on Hackage (0.6.1) can be built on windows. Configure with flag -f-vty -fpango to force pango interface (vty is not supported in windows).

3 Screenshots (0.3)

(thumbnail)
The GTK frontend
(thumbnail)
The Vty frontend

4 News

There is a Yi blog, that reports the important news about Yi, at http://yi-editor.blogspot.com/. It also delves into algorithms and the Yi internals.

You can also check the /OldNews.

5 Bugs

Check/report bug reports here: Github issue tracker

6 FAQs

6.1 Installation

  • How do I install Yi?
Get it from Hackage. Configure, compile and install Yi as you would do for any other Cabal package. See also above-mentioned (2.3 Platform Support).
  • Setup configure fails with
Setup.hs: Package yi-0.4 can't be built on this system.
It means that you have no UI package available. You need VTY or GTK2hs installed. Get them from Hackage.
  • cabal install yi fails with dependency errors, e.g.:
$ cabal install yi
Resolving dependencies...
cabal.exe: dependencies conflict: ghc-6.8.3 requires bytestring ==0.9.0.1.1
however
bytestring-0.9.0.1.1 was excluded because bytestring-0.9.0.1 was selected
instead
bytestring-0.9.0.1.1 was excluded because yi-0.3 requires bytestring =0.9.0.1
Try removing all your old yi packages, and do
cabal update

before attempting to install.

  • cabal install -fghcAPI fails
If you want GHC API special capabilities, you have to download, configure, build and copy separately:
cd yi
cabal configure -fghcAPI
cabal build
cabal copy
  • Compilation fails with a message about alex not being available?
Currently, Cabal doesn't track programs, just libraries, so it won't warn you if you are missing Alex (as many people are). The solution here is to just cabal install alex first. (Yi uses Alex to generate code for parsing stuff with syntax, like Haskell source.)
  • I can't install yi-gtk or yi-vty! It wants sourceview or something.
As the Hackage descriptions say, yi-gtk and yi-vty are only for versions of older than Yi 0.3. You really should be running the latest development (GitHub) or stable (Hackage) versions of Yi, so don't try to install these two packages. Yi supports VTY and Gtk2hs directly in the yi package now.
  • On Mac OS X if you get an error message similar to this:
yi: can't load .so/.DLL for: gthread-2.0 (dlopen(libgthread-2.0.dylib, 10): image not found)
then your dynamic library search path variable is probably not set correctly. You can set it (in Bash) using:
export DYLD_LIBRARY_PATH=/opt/local/lib
(Adjust the specific path to your system. You can find the right location using locate libgthread)
  • On Mac OS 10.6 (Snow Leopard) if you get the following error:
 Loading package cairo-0.11.1 ... <command line>: can't load .so/.DLL for: pixman-1 (dlopen(/opt/local/lib/libpixman-1.dylib, 9): no suitable image found.  Did find:
       /opt/local/lib/libpixman-1.dylib: mach-o, but wrong architecture)
 cabal: Error: some packages failed to install:
 yi-0.6.2.4 failed during the building phase. The exception was:
 ExitFailure 1
then the problem is that GHC currently only supports linking against i386 libraries, and your ports are compiled for x86_64. To fix, recompile your ports with the +universal variant like so:
 port install installed +universal
  • Compilation fails with errors about template-haskell or data-accessor:

Add constraints about which release of those libraries to use.

 $ cabal install yi --constraint="data-accessor < 0.2.1" --constraint="template-haskell < 2.4"

6.2 Default key bindings

6.2.1 CUA key bindings

6.2.1.1 File operations
Ctrl-o Open file.
Ctrl-s Save the current file.
Ctrl-q Quit the editor.
6.2.1.2 Cursor/selection movement
Move cursor forward one character.
Move cursor back one character.
Move cursor down one line.
Move cursor down one line.
Shift+→ Extend selection forward one character.
Shift+← Extend selection back one character.
Shift+↓ Extend selection down one line.
Shift+↑ Extend selection up one line.
Ctrl-→ Move cursor forward one word.
Ctrl-← Move cursor back one word.
Home Move cursor to beginning of line.
End Move cursor to end of line.
Ctrl-Home Move cursor to beginning of document.
Ctrl-End Move cursor to end of document.
6.2.1.3 Miscellaneous operations
Ctrl-f Incremental search.
Ctrl-x Cut the selected area and save it to the clipboard
Ctrl-c Copy the selected area to the clipboard
Ctrl-v Paste contents of clipboard at cursor.
Ctrl-z Undo last operation.
Ctrl-y Redo last operation.

6.2.2 Vim key bindings

6.2.3 Emacs key bindings

C = Control

M = Meta = Alt|Esc

6.2.3.1 Basics
C-x C-f "Find" file i.e. open/create a file in buffer
C-x C-s Save the file
C-x C-w Write the text to an alternate name
C-x i Insert file at cursor position
C-x b Create/switch buffers
C-x C-b Show buffer list
C-x k Kill buffer
C-z Suspend Yi
C-x C-c Close down Yi
6.2.3.2 Basic movement
C-f Forward char
C-b Backward char
C-p Previous line
C-n Next line
M-f Forward one word
M-b Backward one word
C-a Beginning of line
C-e End of line
C-v One page up
M-v Scroll down one page
M-< Beginning of text
M-> End of text
6.2.3.3 Editing
M-n Repeat the following command n times
C-u Repeat the following command 4 times
C-d Delete a char
M-d Delete word
M-Del Delete word backwards
C-k Kill line
C-Space Set beginning mark (for region marking for example)
C-W "Kill" (delete) the marked region region
M-W Copy the marked region
C-y "Yank" (paste) the copied/killed region/line
M-y Yank earlier text (cycle through kill buffer)
C-x C-x Exchange cursor and mark
C-t Transpose two chars
M-t Transpose two words
M-u Make letters uppercase in word from cursor position to end
M-c Simply make first letter in word uppercase
M-l Opposite to M-u
6.2.3.4 Important
C-g Quit the running/entered command
C-x u Undo previous action
M-/ Undo previous action
6.2.3.5 Search/Replace
C-s Search forward
C-r Search backward
M-% Query replace
Space or y Replace this occurrence
Del or n Don't replace
! Replace all following occurrences
ENTER or q Quit replace
6.2.3.6 Window-Commands
C-x 2 Split window vertically
C-x o Change to other window
C-x 0 Delete window
C-x 1 Close all windows except the one the cursors in
6.2.3.7 DIRectory EDitor (dired)
C-x d Start up dired
C (large C) Copy
d Mark for erase
D Delete right away
e or f Open file or directory
g Re-read directory structure from file
m Mark with *
n Move to next line
q Quit dired
R Rename file
u Remove mark
x Delete files marked with D
+ Create directory
6.2.3.8 Programming
6.2.3.9 C, C++ and Java Modes
M-m Move to first (non-space) char in this line
M-^ Attach this line to previous
M-; Formatize and indent comment
M-a Beginning of statement
M-e End of statement
C-c C-c Comment out marked area

6.3 Development

  • How do I install Yi for development?
Fork the repository on GitHub, then clone your version to your machine. Push to your repo on GitHub, and then make merge requests.
  • What are some of the dependancies?
There is a rather long list of dependencies for Yi, check the yi.cabal file for a list.
If you are on Mac OS X and are using MacPorts, then these will not be included in the GHC in that distribution. Many of the dependancies are in MacPorts (for example: ghc, ghc-devel, alex, and gtk2hs). However, you may have some trouble building with Cabal-1.5.2, since it is a development version of Cabal. To work around these issues, you might have to add the line "Build-Type: Simple" to the .cabal files in the above required packages.

6.4 Configuration

6.4.1 How to Configure Yi

You can find configuration file examples in the 'examples/' directory, or online at http://code.haskell.org/yi/examples/.

You can find some user configs at https://github.com/yi-editor/yi/tree/master/yi-contrib/src/Yi/Config/Users

A good way to start is to copy yi.hs in your $XDG_CONFIG_HOME/yi directory (create it if needed), and hack as needed.

6.5 Usage

6.5.1 GError on startup

I get the error message "yi.exe: <<System.Glib.GError.GError>>" when I try to run yi.

Sometimes this is a result of yi not being able to find the contents of the art directory when trying to start in graphical mode (e.g. Gtk or Pango). Check that the install has be done correctly or use the VTY mode ($ yi -f vty).

For more detail on the error, modify main in Yi/Main.hs to catch GError:

 Right finalCfg -> do catchGError (do
                                   when (debugMode finalCfg) $ initDebug ".yi.dbg" 
                                   startEditor finalCfg state) (\(GError dom code msg) -> fail msg)

Note that more recent versions of Yi (e.g. from the GitHub repo) no longer simply display the anonymous GError but instead provide a more detailed error message (making the above code snippet unnecessary).

7 Contribute

Fork the source on GitHub and send requests for merges to the mailing list. Patches are always welcome. :)

Otherwise, see the complete list of open issues here: http://code.google.com/p/yi-editor/issues/list

(Note you can start working on all issues in New/Accepted state, regardless of the owner of the issue. -- you can send an email to the list with your plan if unsure)

Post your questions and follow up on the mailing list: http://groups.google.com/group/yi-devel

Some other pending tasks are described below.

7.1 Write access policy

One does not need write access to the repository to contribute. Please fork the main repository and send pull requests.

Write access can however be granted, with the following disclaimer:

  • All people with write access can apply patches without prior approval. If one thinks a patch would be controversial, it might be a good idea to discuss it on the list though.
  • Try to not break the build. (By Murphy's law, if you do so it will happen at the most annoying moment...) So, always try to build before pushing patches. Bypassing Darcs's test build to record a patch indicates you should further improve your patch.
  • I can at any time rollback a patch for whatever reason. This however should not upset the author of the patch. Most contributions are welcome, so a patch revert normally would only mean that a detail or two need to be worked out. (eg. it breaks an important feature in some configuration, etc.)

8 Yi ideas

This section is meant to gather ideas people have for Yi.

  • Evolution to an IDE:
Show exact location of compilation errors: 80% of an haskell project
Support for the ghci debugger & others: 10 % of an haskell project (Added bonus: greath for learning: trough the debugger, people learn the real execution flow of an haskell program. Better if this is done inside an editor)
Integration of refactoring tools : 5 %
Edition: only 5%


  • 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?)
  • 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.
  • Support for perl style regular expressions
Emacs regexes don't support the same set of features; perl regexes are more tersely powerful. This could be a good feature for luring users from vanilla emacs.
  • Remote attach so I can work from home, but still use a remote machine
Like Emacs's server?
  • Haddock documentation
(no brainer), maybe associate with .hi files for binaries.
  • Maybe a class YiShow, which all config items must be a member of? This is to emulate describe-variable
  • Support for collaborative editing. This would be very good for #haskell work, and the text editor Gobby and its Obby protocol seem to provide a candidate way of doing things.


8.1 Borrowing from other editors

Take some ideas from emacs, some from vi, but don't stick them all together without a single core philosophy. Otherwise, you'll end up with an editor that looks like it was thrown together. Some people come from an emacs background, some from vi, some from elsewhere, and ALL of them will want yi to behave like their regular editor. The best way to do this is to have a single person make all the decisions on behaviour.

8.1.1 Emacs

Coming from an Emacs background, I think a few things are essential, mainly the introspection capabilities of Emacs.

8.1.1.1 Emacs goodness

The following are things I like about Emacs, as an extensible environment, and miss in Yi:

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
Hooks-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)
List of must-have features
http://glyph.twistedmatrix.com/2008/12/emacs-test.html


8.1.1.2 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.

(See also WhyDoesElispSuck on the Emacs wiki.)

8.1.1.3 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

8.1.2 Vim?

good things
modal key editing -> configuration system is powerful enough!
light weight -> fast startup -> yi has this :)


8.2 Ideas

8.3 Implementation

Considerations:

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.

...

9 Trivia

Y I is the most recursive acronym. (Read it as combinators).
義, pronounced yi, means righteousness, one of the five virtues of confucianism.
Yi is the symbol for a yobi - the largest binary prefix, meaning 2^80

10 External links