The Wolfram Language Plugin supports three different kinds of code folding:
- Inside code to collapse the body of
Block, etc. but also lists and other constructs
- Sectioning comments to structure your package into logical regions
- Named characters to collapse, e.g.
Code folding helps to improve readability while you are working by hiding the contents of larger portions of code you are currently not working on. It needs to be mentioned that this doesn’t change any code; it merely affects the representation of your code inside the editor.
To collapse or expand folding regions, it is possible to use the menu entries und Code | Folding or keyboard
More details can be found in the official
Assume you need the first 100 digits of pi, and you stored these in a list inside your code.
To hide the contents of this long list, you can collapse it into a compressed form.
This kind of folding code is supported for lists and all Wolfram functions that work as scoping constructs with local
Do, and many more.
Folding section comments
The Wolfram Language has a dedicated way to structure package-files into logical parts by inserting sectioning comments. Comment sections have a specific form and like in text documents, they can be used to start chapters, sections, subsections, etc. Such comments always have the section specifier in one line with nothing else inside the comment, and the descriptive text in the next line. A simple example looks like this:
These sections act as folding region, and you can collapse everything between the beginning of a section and the start of the next
section, including possible sub-sections, sub-sub-sections or text.
We can collapse the first section by using
., clicking on the
- indicator on the left side of the editor, or
using menu entries.
Now, it only shows the title of the section hiding its entire content, and note how the indicator on the left side changed
into a small
All these special comments work perfectly within Mathematica and are displayed as appropriate text cells.
Therefore, when opening the short example in the Mathematica front end, it looks like this
It goes without saying that this gives you a powerful tool to create readable, structured, and maintainable packages.
Folding named characters
Named characters in Mathematica
are special glyphs like λ that are represented using the form
\[Lambda] in ASCII package code.
The Wolfram Language Plugin supports the correct rendering of a subset of the named characters like
\[Alpha] (α) that are available in Mathematica.
In general, package code should only consist of ASCII characters, but since it is sometimes unavoidable to have, e.g.
Greek characters inside a
Manipulate, the Wolfram Language Plugin can display
\[Alpha] as if it where a unicode
This is realized using mini folding regions for each character.
\[XXX] can be collapsed into its unicode representation or later expanded back into its
Note that the Wolfram Language Plugin only supports named characters that can be part of symbols like
are not operators like
\[Rule]. Therefore, please use
a->b and not
One of the reasons for the lack of support is that Mathematica still has no official syntax specification that lays out all available operators
with their exact precedences and associativity. Another important reason is that many unicode operators in Mathematica can only
be displayed with Wolfram’s fonts and have no public representation. The code points of these characters are
in the private use area of unicode and the rendered
\[Rule] arrow is one
example: It has the unicode point
U+F522 and while inside Mathematica
a \:f522 b is instantly converted into a nicely
rendered rule, the glyph is only available in Wolfram’s own fonts.