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.
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.
Objects Used in Pattern Matching
There are a number of objects used in the pattern matching process, depending on what type of match is required.
The Match Object
The Match object is one of the most commonly used match objects. It matches an expression to a pattern and generates one or more lists of variable bindings.

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.
- 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.
  - Objects Used in Pattern Matching
    There are a number of objects used in the pattern matching process, depending on what type of match is required.
    - The Match Object
      The Match object is one of the most commonly used match objects. It matches an expression to a pattern and generates one or more lists of variable bindings.
    - The MatchParameters Object
      The MatchParameters object is used to match to the parameters passed into functions.
    - The MatchIn Object
      The MatchIn object is designed to allow creating pattern match expressions that will generate a list of bindings for each of the parameters of an expression. Among other uses, the MatchIn object provides a way to iterate over a list.
    - The MatchInIndexed Object
      The MatchInIndexed object works the same way as the MatchIn object except that the binding includes both the term and the index of the term in the parent expression.
    - The And, Or, and Not Objects for PatternMatching
      There are two sets of And, Or, and Not objects defined. The first set represent the conventional Boolean objects. The second set is in the Code namespace and are used with pattern matching. These objects can take objects of type Boolean or PatternMatch as parameters. When the And, Or, and Not in the Code namespace contain multiple match objects, they build the appropriate cumulative binding list as the match expressions are executed.
    - The ListVariable Objects
      The ListVariable objects are typically used in patterns where the parent object of the ListVariable is a monoid. Their purpose is to allow matching against a expressions with a variable number of parameters. Patterns with list variables can be used to find a particular pattern anywhere in the list of parameters of an expression.
    - The ListVariableIndexed Object
      The ListVariable object is used to bind to an arbitrary number of terms from a list object. The ListVariableIndexed object is similar, but is designed to do one of two things. It can be used to bind to a specified number of parameters of an object or it can be used to return the number of parameters that were bound
    - The ParameterList Object
      The ParameterList object is used in the processing of clauses, it was introduced to allow list variables and patterns that include list variables to be used on expressions that aren't monoids. It has two applications. First, it allows matching against any object that has a list of parameters. Second it allows putting a list of parameters back into any object.
  - Pattern Matching to Monoids
    In the pattern matching process, there are often cases where we want to create patterns that will match against objects with differing numbers of parameters. Examples include wanting to match against the first parameter of any object that has parameters or matching to any Add object that contains a parameter that has a particular pattern (like "a/b", for example).
  - Pattern Matching on Numbers and Text
    All numbers are represented by the Num object in the Math namespace. A Num object can have a value attached to it. Similarly, strings of text are created using the Text object in the Text namespace. A Text object can optionally have a value attached to it.
  - Pattern Matching to Arrays of Variables
    The purpose of a pattern match is to bind an expression to a variable. There are several advanced ways that variables can be used in this process.
  - Pattern Matching to Null Typed Objects
    The standard pattern matching objects are not designed to handle objects with the Null type. There are pattern matching objects designed to allow you to match to Null typed objects.
- 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 Match Object

The Match object is one of the most commonly used match objects. It matches an expression to a pattern and generates one or more lists of variable bindings.

Pattern matching is processed from the top down. Consider the pattern match:

the pattern matching process may be easier to follow if we write both the expression and the pattern without any rendering:

Add[x, Div[y, Sub[z, 2]]]

Add[a, Div[b, c]]

If the object at the top of the pattern is not a variable, then matching process just compares the expression to the pattern and succeeds if the names (name and namespace) are the same. If the match succeeds, then we move to the parameters and match each parameter of the expression to the corresponding parameter in the pattern. So the next step is to match "x" to "a". Since "a" is a variable, the matching process just binds "a" with the value "x" and reports this step in the match to be a success. The second parameter follows the same process. The Div matches, the variable "b" is bound to the value "y" and the variable "c" is bound to Sub[z, 2]. The matching process is now complete and returns a binding list containing three variables.

Note that it's allowed to create patterns where the same variable appears more than once. For example, consider the match:

When this pattern match is processed, the Div will match, the first parameter of the Div will bind "a" to "x + 1" and when the second parameter is process, since "a" is alreay bound, the pattern matcher will just verify that the expression that was previously bound to the variable matches the current expression.

It's also possible to create patterns that generate more than one list of bindings. The section on Pattern Matching to Monoids describes these patterns in detail.

It's also possible for the expression on the left-hand side of the pattern match to contain terms in the variables namespace. These terms are never treated as variables during the pattern matching. They are just treated like any other term in this case.