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

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

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.

The basic pattern matching process lets you bind values to simple variables (zero parameters). There are cases where we might want to binding several expressions to an indexed list of variables. For example, if we have a polynomial expression, we might want to bind the coefficients to variables c(0), c(1), etc.

If the polynomial is 3x^2 + 1, then we want is to be able to write a match like:

{ 3 => c(2) } and {1 => c(0) }

and then be able to write expressions like c(2)x^2 on the right-hand side of an Assert to return 3x^2, for example.

But the standard pattern matching won't let us do this. The only thing that would normally match to a pattern like c(0) is a one parameter object with zero in the parameter. So | 0 | would match with "c" bound to Abs for example.

To allow the pattern matching that is intended here, we introduce a namespace called VariableArrays. If c(0) is in the VariableArrays namespace, then a match like { a + b => c[0] } will bind "a + b" to c(0). If "c" is in the Variables namespace, this match would fail.

You can move objects into the VariableArrays namespace using the Namespace command ("n"). Note that the VariableArrays namespace is only one of the results for this command if the object starts out in the variables namespace and has at least one parameter.