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 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 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 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.

If the right side of an Assert evaluates to null, the function continues to the next clause.

A function where none of the clauses generate a non-null result will return null.

If any term in the right side of a function evaluates to null, the entire right side evaluates to null and processing continues with the next clause. For example, in this clause the IntegerEvaluate on the right-hand side will be null if "b" is odd (or not an integer). In this case, the whole clause will evaluate to null.

Note that the null object doesn't cause exceptions in Sym the way that null does in other programming languages.

Be careful not to confuse the Null type (which is in the Types namespace and has type of Type) with the null object (which is in the Code namespace and has type Null). This is one of a number of cases where it's convenient to have an object and a type with the same name, but all of these objects live in different namespaces.