I spent some time the other day thinking about zippers and structural editors and I wanted to share some of the ideas, because they were interesting, so this is going to be a thread about that
Discussion
Replies:
45
Boosts:
1
when we think about editors, the canonical example is a text editor, which is conceptually very simple. in the functional programming context, we often think of editors in terms of a structure called a zipper, which you can read about here:
the usual way of looking at a text editor through the lens of a zipper is to view the string/text as split in two, the stuff before the cursor and the stuff after, with the stuff before the cursor reversed
but the equivalent of this is hard to figure out for tree structures. the closest analog for tree structures has to pluck out an entire subtree, which isn't quite the same thing as splitting a string in two
you can massage the idea of splitting a string by saying well, you've "plucked" out a character from the middle, but i think this is a mistake. we're really dealing with distinct concepts and its useful to try to figure out how to understand their relationship
in particular, I think it's useful to think about the different cursor types that exist in terminals, especially in older settings
what i mean is the difference between vertical line cursors and underline/box cursors
historically, the underline/box cursor and the vertical line cursor had different meanings/usages
the vertical line cursor was an insertion cursor that indicated you were going to insert a character at the cursor position BETWEEN existing characters in the string
thats why it was a vertical line -- to fit between two characters. sometimes a subscripted ^ was used for a similar purpose
the underline and box cursors were whole character width because they would be overlaid on top of an existing character to indicate that the character would be _replaced_ and _overwritten_
if you've ever wondered what the "Insert" key on a keyboard is for, it's for toggling between insertion and overwrite ("overtype") mode
overwrite was the default for decades, because terminals were _typewriters_ and you literally couldn't insert at all
so early electronic terminals kept the overwriting as a default, and also offered an insertion mode with a key to toggle. this is also why backspacing sometimes seems to do nothing in terminal emulators except move the cursor to the left -- teletypes couldn't backspace either
the distinction between the Insert line cursor and the Overtype box cursor lines up rather neatly with the kind of zippers I mentioned earlier
text editing zippers are INSERT zippers, while tree zippers are OVERTYPE zippers
interesting!
in the case of a text editing zipper for overtype mode, that's pretty easy too:
it's not a pair of strings, but rather a string for the reversed stuff before the overwritable character, the character that would be overwritten with an edit, and the string after the character
but strings/lists are just a kind of single-branching tree, so strings should ALSO have an overtype-style zipper when viewed as trees, and they do: it plucks out an entire sub-list from the string
at this point its useful to emphasize that in tree zippers, there are two parts -- the node in focus, and the context of the rest of the tree around the node
similar to how overtype for strings is a character in focus and the rest of the string around it (qua pair of strings)
for a string-as-tree, the overtype zipper is still a node plus the tree around it
in this case, the node is an entire sub-string, ie a sublist, i.e. the tail of some portion of a non-empty list
the context is the rest of the tree around it, ie the not-tail part of the list
this is basically an insertion zipper for a text editing string, which is a neat fact
perhaps we can make some larger unification of these ideas to understand how to get insertion editing operations for trees!
the observation to make is that if we view a text insertion zipper as a normal tree overtype zipper on a string, rather than a true insertion zipper, we can analyze insertion and overtype as follows:
a string-with-insertion-cursor, such as
fo|o
corresponds to the tree zipper
"o" @ "fo_"
where the LHS of @ is the thing in focus, the RHS is the one-hold context (with an _ representing the hole)
the act of typing a character, such as 't' should produce the string-with-insertion-cursor
fot|o
which is
"o" @ "fot_"
which is equivalent to updating the zipper to
"to" @ "fo_"
and then navigating to the next recursive tree position
but when we view these tree contexts through McBride's tube view, where a one hole context is a stack of frames of local subtrees, we get this:
fo|o
is the tube-y zipper
"o" @ [ 'o':_, 'f':_ ]
and
fot|o
is
"o" @ [ 't':_, 'o':_, 'f':_ ]
from this perspective, we can describe the insertion operation as follows:
1. we have a whole subtree "o" to operate on
2. we want to insert a single character 't'
3. we find the unique list/string constructor that has a single char arg and a single list arg: cons (`:`)
4. we partially apply cons (`:`) to the single char 't', and form a one hole zipper 't':_
5. we push that onto the tube-y context stack
now, we could view key presses as complex commands, which specifically mean that precise thing. and that's fine. but i want to generalize this and think about something a bit more eh.. rich?
i phrased the above sequence of operations the way i did because i want to consider the possibility that our tree structure isn't as simple as lists
instead, lets imagine that its some arbitrary tree type that has many constructors some of them with char args
for instance, i dunno, something like
data Tree = Z | O Char Tree | T Char Tree Tree
now when we press a single key, we look at step 3 and say, well, there is a unique constructor `O` that takes a char and a recursive tree, yes, indeed, so we can push `O 't' _` to the stack
but there's ALSO a constructor `T` that takes two recursive trees
we obviously can't use that right? i mean, which subtree gets the hole? and what do we put in for the other subtree?
well if we have a way of representing an as of yet un-filled portion of a tree (also called a "hole" but this type a different sort, so i'll just call it a "gap" for clarity), we can say this:
we can also add either of
T 'f' _ ?
and
T 'f' ? _
to the stack as well
here i'm using ? to represent gaps that must be filled in eventually
so here we have a situation where a single key press can reasonably suggest edits that "insert" three different kinds of tree nodes:
an O node, that's like a string insertion
a T node with a gap on the right
a T node with a gap on the left
from a UI perspective, we have an ambiguity here, in terms of what is intended by the user with the single keypress
this could be resolved with different modes selected prior to the keypress, or by offering up the different options with one selected as a default
the idea of using gaps is not all that peculiar, fwiw
dependently typed programming languages have them (called holes, sheds, and typed holes depending on language)
so do some text editors, for instance in the form of TextMate's snippet tab stops
but i want to go even further afield and consider the idea that we might not treat the keypresses as characters-as-data instead, but rather characters-as-pretty-printing