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

Example:

The Where object doesn't really introduce any new functionality. It's really just syntactic sugar for this expression:

The second paramter of the Where object should contain an Assign object, as in the example above, or a List of Assign objects.

This is an example of a Where term with a list in the second parameter:

The left-hand side of the equality in a Where object can contain a more complex pattern than just a single variable. For example: