Syntree

Content

Introduction
Usage
Controlling the design of the tree
Org-babel integration

Introduction

syntree is a package for GNU Emacs that draws plain text constituency trees. It is meant to be for plain text what packages like qtree or forest are for LaTeX, providing only those features that make sense for the plain text format.

While it is written with the linguist’s usage in mind, syntree can obviously be used for any sort of tree-like diagram. Here’s an example of what you can get from syntree:

("Sentence"
    "_NP:the man"
    ("VP" "Verb:hit"
    ("NP" "T:the" "N:ball")))

      Sentence
   ._____|_____.
   |           |
   NP          VP
.__|__.    .___|___.
|_____|    |       |
the man  Verb      NP
          hit   .__|__.
                |     |
                T     N
               the  ball

The drawing is done interactively, with the output displayed as you type:

It does not provide functionalities such as drawing arrows between nodes. Once the tree is drawn, however, arrows are rather easily added manually with picture-mode (built-in in GNU Emacs).

You can install syntree through melpa.

Usage

Create a new tree

Upon calling the command syntree-new a new frame is created that is split in two windows: the upper one visits the input buffer, the lower one visits the output buffer. Both buffers are in syntree-mode.

At this point, syntree-mode-map is activated in the two buffers (more on this here). The output buffer will redisplay the tree every time the input buffer has changed and a valid syntree input is detected in it (or whenever the value of syntree--current-style is changed by calling some interactive command—more on that below).

Syntax of the input

The input is a substring of the buffer made up by parentheses and objects formatted as strings. This input is read as a list. Thus, these are valid inputs:

("abc" ("def" "ghi"))

("abc" "def" "ghi")

Every list must contain more than one string. These are not valid inputs:

"abc" "def"         ; this is not a list

("abc" ("def" ghi)) ; not everything here is a string

("abc" ("def"))     ; the embedded list contains only one string

The first string in a list is the label of the branching node. Here, the embedded constituent has an empty label:

("XP" "abc" ("" "def" "ghi" "X:xyz"))

      XP
  ____|____
 /         \
 |         |
abc    ____|____
      /    |    \
      |    |    X
     def  ghi  xyz

Terminal nodes can themselves be labeled: the label and the text are separated by a : (i.e., a colon). Here some examples of terminals:

 ("" "XP:abcd")  |   |
                 |  XP
                 | abcd
                 |
-----------------+-------
                 |
 ("" "abcd")     |   |
                 | abcd
                 |
-----------------+-------
                 |
 ("YP" ":abcd")  |  YP
                 |   |
                 | abcd
                 |
-----------------+-------
                 |
 ("YP" ":ab:cd") |  YP
                 |   |
                 | ab:cd

If the label on the terminal node starts with, or is _, the leaf will be under some sort of roof. For linguists, this usually indicates that the internal syntax of that node is ignored.

("DP" "D:a" "_NP:beautiful tree")
("DP" "D:a" "_:beautiful tree")

     DP                      DP
.____|____.             .____|____.
|         |             |         |
D        NP             D  .______|_____.
a  .______|_____.       a  |____________|
   |____________|          beautiful tree
   beautiful tree

Whether you are under a roof or not, if you want to force the text of a terminal node or of a label to be on multiple lines, use \n in the input.

("Modified \n sentence"
    "NP:the man"
    "_VP:vigorously\nhit the ball")


      Modified
      sentence
   ._____|_____.
   |           |
   NP         VP
the man  ._____|____.
         |__________|
          vigorously
         hit the ball

Whether the input string in the buffer is split in different lines or not, and whether it is indented in any way or not is irrelevant.

The interactive commands

These are all the commands that are available in syntree-mode buffers, each with the default keybinding. You can define your own keybindings in syntree-mode-map.

syntree-info

Read the documentation for syntree in the info system.

syntree-change-value (C-c C-v)

Change the value of any properties, with completion, and redisplay the tree according to the new value.

Note that changing values this way does not change the value of the property in the current style, neither permanently nor for the duration of the Emacs session. The value is simply temporarily overwritten. If, after changing a value you reset the style, the change will be discarded.

syntree-increase-padding (M-<right>) and syntree-reduce-padding (M-<left>)

Increase and reduce (if possible) the value of :hspace (see properties).

Note that changing values this way does not change the value of the property in the current style, neither permanently nor for the duration of the Emacs session. The value is simply temporarily overwritten. If, after changing a value you reset the style, the change will be discarded.

syntree-increase-height (M-<down>) and syntree-reduce-height (M-<up>)

Increase and reduce (if possible) the value of :height (see properties).

Note that changing values this way does not change the value of the property in the current style, neither permanently nor for the duration of the Emacs session. The value is simply temporarily overwritten. If, after changing a value you reset the style, the change will be discarded.

syntree-change-style (C-c C-v)

Select a different style defined in syntree-styles-list, with completion, as the current one, and redisplay the tree.

What the current style is right after syntree-new is called is determined by the value of syntree-default-style (more on this here).

syntree-done (C-c C-c)

Once you are satisfied with how the tree looks like, you can call syntree-done: the input and the output (the source for the tree and the tree itself) are added to the kill ring (in that order), the two syntree buffers and their dedicated frame are killed, and point is back in the position it was when syntree-new was called. You can now yank the tree.

Controlling the design of the tree

syntree produces a tree according to a specific style. A style is a plist that associates properties to values. Interactively, one can switch between predefined styles.

Properties

The properties defining how a tree looks like can be divided in two: the first group has booleans, integers or symbols as value, the second has strings or characters. We first examine the first group.

:growing

This property accepts one of these four symbols as value:

down
up
right
left

It determines the direction of growth of the tree: for example, if the value is right, the root of the tree will be to the left and the tree will horizontally grow to the right.

:oneline

This property has a boolean value.

If it is t, it means that all terminal nodes will be aligned (horizontally or vertically depending on the value of :growing).