Getting Help

The top loop provides easy access to the documentation that is built into Storm through the help command. For example, to get help about the layout package one can type: help layout The system then responds roughly as follows: 

layout (package):

Layout Library
==============

This is a library for specifying the layout of a set of rectangles inside a
container (for example, UI components on the screen). The library itself is
generic and requires a small amount of code to integrate it in whichever context
it should be used.

The library is centered around the `Component` class, which represents a
rectangle that should be positioned. Components are positioned inside a
`Layout`, that is in charge of determining the relative position of each
component. Each `Layout` is also a `Component`, which means that layout rules
can be nested to create arbitrarily complex layouts.

The layout system does not introduce additional coordinate systems. Rather, all
coordinates produced are in the same coordinate system as those specified to the
`Layout` that contains the `Component`s.


At: <unknown location>

Members:
 @ 0 extends lang.bs.SAtom, on core.Compiler
 @ 1 extends layout.SLayoutRoot, on core.Compiler
...
 Anchor extends layout.Layout [public]
 Border extends layout.Layout [public]
 Cardinal extends core.Object [public]
 Component extends core.Object [public]
...

The first line specifies what the name refers to. In this case it is a package, which is represented by the package name followed by (package). After that line, the documentation for the entity is printed if it exists. After the documentation, the source location is printed. Since packages are not defined in a particular file, the system prints <unknown location> to indicate this. Finally, all members in the package are printed. The first few (starting with @) are anonymous types generated by the syntax language. After them are a few classes.

If we are interested in more information about the class Component, we can then type: help layout:Component, which results in output similar to the following: 

public Component extends core.Object:

Describes a component in the layout hierarchy.

A component is a rectangle that will be laid out according to the rules of the
active Layout. The Component class also stores information about the underlying
component, such as minimum size and other component-specific information.

Provide a function called `component` to wrap custom types inside the
`Component` class. The system will try to call that function automatically when
possible.

Generally, all information inside a particular component is assumed to be read-only.

At: /.../root/layout/component.bs(583-1413)

Members:
 __init(layout.Component) -> void
 __init(layout.Component, layout.Component) -> void
 bundleRoot(layout.Component) -> core.Maybe(layout.Component) [public]
 deepCopy(layout.Component, core.CloneEnv) -> void
 findAll(layout.Component, core.Fn(void, layout.Component)) -> void [public]
 minSize(layout.Component) -> core.geometry.Size [public]
 pos(layout.Component) -> core.geometry.Rect [public]
 pos(layout.Component, core.geometry.Rect) -> void, assign [public]
 toAdd(layout.Component) -> layout.Component [public]

This time, the name layout:Component refers to a class, which is printed using a format similar to the class definition (public Component extends core.Object). Again, after the description of what the name refers to is the documentation of the entity is shown, and the location in the source code. The numbers after the file name indicates the range of characters in the file where the entity is defined. Finally, a list of members are listed. The lines __init indicate constructors.

Finally, assume we wish to read the documentation for the pos member. The full name of this entity is layout:Component:pos(layout:Component) or layout:Component:pos(layout:Component, core:geometry:Rect). It is possible to type these names as parameters to help. Since that would be cumbersome to do, the help syntax allows omitting parameter lists. So, typing help layout:Component:pos is enough, and produces the following output: 

Found 2 overloads for pos:

public pos(layout.Component this) -> core.geometry.Rect:

Get the position of this component.

At: /home/filip/Projects/storm/root/layout/component.bs(1135-1138)

public pos(layout.Component this, core.geometry.Rect p) -> void, assign:

Set the position of this component.

At: /home/filip/Projects/storm/root/layout/component.bs(1205-1208)

The first line states that the system found two overloads of pos in the package. It then proceeds to display both of them. In this case, we can see that the first function takes a parameter called this (since it is a member function) and returns a core:geometry:Rect. The second version accepts another parameter (p) and returns void. Furthermore, the second function is marked as assign, which tells the system that the member may be used when assigning to the pos member.