Difference between revisions of "Yi"

From HaskellWiki
Jump to navigation Jump to search
m (fixed typo)
(Delete outdated stuff, point to yi website instead)
 
(260 intermediate revisions by 30 users not shown)
Line 1: Line 1:
  +
[[Category:Applications]]
== Yi ideas ==
 
   
  +
[[Image:Yi-logo.png]]
This page is meant to gather ideas people have for
 
[http://www.cse.unsw.edu.au/~dons/yi.html Yi], an extensible editor
 
written in Haskell.
 
   
  +
== About ==
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.
 
   
  +
Yi is a text editor written in Haskell and extensible in Haskell.
Ideally, the next version of Yi would be based on a (modified?)
 
version of GHCi, maybe taking advantage of package GHC.
 
   
=== Emacs goodness ===
+
== External links ==
   
  +
* Website: http://yi-editor.github.io/
The following are things I like about Emacs, as an extensible
 
  +
* Repository: https://github.com/yi-editor/yi
environment:
 
  +
* Hackage page: http://hackage.haskell.org/package/yi
; Really good online documentation
 
  +
* IRC channel: #yi on Freenode
: Emacs can tell you a lot about a function or variable with a
 
: keypress--- the current value, where it is declared, and a hypertext
 
: information 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 Lisp
 
: Ignoring the actual language, 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
 
 
=== Ideas ===
 
 
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 haddocl 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
 
 
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)
 
 
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 ala 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?
 
; 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.
 
 
...
 
 
[[User:Sjw|Sjw]] 09:15, 2 June 2006 (UTC)
 
 
[[Category:Applications]]
 

Latest revision as of 17:29, 28 June 2016


Yi-logo.png

About

Yi is a text editor written in Haskell and extensible in Haskell.

External links