Home
The Sym Programming Language
The Sym programming language is designed first and foremost for manipulating expressions. Because it's designed to manipulate expressions, the code in the Sym language is built from Sym expressions rather than text.
Functions
A function is an object definition that includes clauses its Implementation section.
Objects Used in Functions
Null Typed Objects
Objects that have the Null type play a special role in the execution of clauses in functions. The result of this special role is that Null typed objects like the null object, the Exception object, the Return object, and the Break object play a major roll in the "flow of control" in the execution of code in the Sym language.
The Break Object
The Break object is most commonly used to terminate the processing of a list of clauses in an ElseList expression or to terminate the processing of the list of clauses in a function. It's defined in the Code namespace and is typed with the Null type.

The Sym Programming Language
The Sym programming language is designed first and foremost for manipulating expressions. Because it's designed to manipulate expressions, the code in the Sym language is built from Sym expressions rather than text.
- Functions
  A function is an object definition that includes clauses its Implementation section.
  - Clauses
    Clauses are expressions that are added to object definitions when the object is intended to act as a function. These expressions define what happens when the function is executed.
  - Clauses that Build a List of Results
    Since we can construct pattern matches that generate multiple binding lists, it's natural to want to use these pattern match expressions with clauses that can generate multiple results. The AssertList object provides a way to do this.
  - Extensions to Functions
    In some cases, in a library or document, it's necessary to extend a function. For example, the Simplify function is defined in the Core library but there are simplifications that we want in the Simplify function that have be implemented in the Math library, the Trig library, and so on. Extensions provide a way to implement a function that has clauses spread out across multiple libraries.
  - Functions Executed by Commands
    When a command is executed, the function assigned to the command is called. The expressions passed to this function aren't necessarily just the highlighted expression. There are several different ways this can happen depending on the properties of the Command object and on the content that is highlighted.
  - Objects Used in Functions
    - The Assert and AssertList Objects
      The Assert and AssertList objects are the two objects most commonly used in clauses in functions. The left hand side is always a pattern match, the right-hand side is an expression built using the variables bound in the pattern match.
    - The Where Object
      The Where object is used in clauses defined in functions. It provides a way to assign values to additional variables beyond the ones that are defined by the pattern match.
    - The ElseList object
      The ElseList object provide flow of control in a clause that is in some ways similar to an "if/then/else" statement in other programming languages. The difference is that here control is driven by testing for the null object (Code.Null) rather than testing on a Boolean true/false value.
    - The List Object
      The List object in the Code namespace is frequently used in clauses.
    - The DefaultResult Object
      The DefaultResult object defines a result that will be returned by a function as its result if none of the clauses generate a result.
    - The ShowList Object
      The ShowList object is used to indicte that a list of expressions returned by a command should be shown in the autocomplete popup.
    - The ShowListCommand Object
      The ShowListCommand object is used like the ShowList object to indicte that a list of expressions returned by a command should be shown in the autocomplete popup. The difference between this object and the ShowList object is that the expression selected from the result list is passed to a second command along with the expression that is highlighted. This is used, for example, to apply a different style to bulleting. You select from a list of bulleting styles then a second command is used to apply the bulleting style to the highlighted expression(s).
    - Variables
      The variables described here are variables that are used in Sym code. These variables must be in either the Variables or VariableArrays namespaces.
    - Null Typed Objects
      Objects that have the Null type play a special role in the execution of clauses in functions. The result of this special role is that Null typed objects like the null object, the Exception object, the Return object, and the Break object play a major roll in the "flow of control" in the execution of code in the Sym language.
      - The Null Object
        The null (Code.Null) object plays an important role in flow of control in the execution of clauses and functions in the Sym language.
      - The Return Object
        The Return object allows you to abort the processing of a function. The function will return the null object (not the Return object) in this case.
      - The Break Object
        The Break object is most commonly used to terminate the processing of a list of clauses in an ElseList expression or to terminate the processing of the list of clauses in a function. It's defined in the Code namespace and is typed with the Null type.
      - The Exception Objects
        The exception objects include a zero and one parameter version of Code.Exception and the Code.TryCatch objects. Additional objects for exception handling can be defined by the user. The exception objects are typed with the Null type.
- Pattern Matching - Overview
  The purpose of a pattern match is to bind an expression to a variable during the execution of code. Most commonly, the expressions that become the values bound variables are the parameters passed into a function call.
- Unit Testing
  Unit tests provide a way to validate that code functions correctly and to detect errors that might be introduced as code is modified. A Unit Test Module contains a list of unit tests. Unit tests can be run individually, all of the tests in a unit test module can be executed at the same time, or using the Unit Test Runner, unit tests from multiple unit test modules can be run simultaneously.
- Exporters
- The Build Process
  The build process converts the clauses in object definitions into a form that can be executed. The build process also runs the type inferencing process on all of the expressions in the document, which speeds up execution of commands and unit tests. At the end of the build process, the rendering of any open modules is updated to reflect any changes to the renderings in object definitions.

The Break Object

The Break object is most commonly used to terminate the processing of a list of clauses in an ElseList expression or to terminate the processing of the list of clauses in a function. It's defined in the Code namespace and is typed with the Null type.

The action of the Break object is similar to the action of the "break" statement in other programming languages. Typically, you can use "break" to exit out of the processing of a "for" or "while" loop.

This is very similar to the example that we used for the Return object:

Note that TestFnV1 has three clauses, while TestFnV2 only has a single clause.

It's important to recognize that we can't write the first clause as

because when a clause returns the null object, processing just falls through to the next clause.

The object at the top of the expression tree in TestFnV2 is the BreakCatch object. The second parameter of this object is typed as Label. You don't have to create an object definition for the label objects. In the example, the A term is just Local.A. Since this object is undefined, the type inferencer will infer its type to be Label. So in this example, you can create the A term by just typing "A" and then changing the namespace to Local.

The fact that the Break object is typed as Null allows constructing expressions like:

In this clause, if "a" is the Power object, then the first term in outer ElseList would become "break: B + a". But because Break has the Null type, this reduces to just "break: B". Since the top clause in the outer ElseList has produced a result other than the null object, Test3[a] is not evaluated and the BreakCatch will cause the clause to return null. See The Null Object for more details.