Several definitions attached to the same symbol can be used:

Compile a function that uses the definitions:

This calls the definition that uses a condition:

This calls the definition that uses a literal 2:

This calls the last catchall definition:

Definitions attached to a symbol can be used in more than one declaration with different types:

Make two declarations with different types and compile functions that use each:

Call the integer case:

Call the real case:

Definitions attached to a symbol can be declared with a polymorphic type:

Make a polymorphic declaration and compile functions that use it for different types:

Call the integer case:

Call the real case:

Function declarations that use a symbol definition can call themselves:

Make a declaration and compile a function that uses it:

Call the function:

A pattern argument does not need a name:

Compile a function that uses the definition:

Call the function with different values:

If the same name appears more than once in a definition, when called, the value must be the same:

Compile a function that uses the definition:

Call the function with different values:

Call the function with the same value and it uses the definition for the same value:

A pattern can be written to match the head:

Make a polymorphic declaration that uses the definition:

Compile a function that uses the declaration with an argument that does not match the head:

Call the function with an integer and that uses the definition that does not match the head:

Compile a function that uses the declaration with an argument that does match the head:

Call the function with a real and that uses the definition that matches the head:

Compiled patterns can use PatternTest:

Compile a function that uses the definition:

The input is even:

The input is odd:

Compiled patterns can use Condition:

Compile a function that uses the definition:

The input has arguments in order:

The input has arguments not in order, so in the output, they are reversed:

Compiled patterns can use Except:

Make a declaration and compile a function that uses it:

The argument is even, so the first definition is not used:

The argument is odd, so the first definition is used:

Compile a function that uses the definition:

The argument is even and greater than 20, so the first definition is not used:

The argument is odd and greater than 20, so the first definition is used:

The argument is odd but less than 20, so the first definition is not used:

Compiled patterns can use Alternatives:

Make a declaration:

Compile a function to use the declaration:

This function matches the input, so a result is generated:

Compile a function with a different type to use the declaration:

This function also matches the input, so a result is generated:

Compilation supports compounds patterns for certain types such as "InertExpression" and "PackedArray":

Compile a function that uses the definition:

This function matches the input so a result is generated:

Compile a function with a different type to use the declaration:

Compilation supports certain sequence patterns for "InertExpression":

Compile a function that uses the definition:

This sequence gets flattened:

The pattern with a sequence does not match, so this returns a failure:

The pattern can have a compound head of any expression type:

This matches:

This does not match:

Declarations that use symbol definitions are useful if the declaration is used more than once:

A FunctionDeclaration that refers to the symbol:

A function that uses the symbol:

Compiled code for the function:

A vector plot based on the data that was created:

The compiled version is much faster:

An animation of the output:

DownValuesFunction uses the definitions used when the compilation is carried out:

The result uses the definitions in place when the compilation is done:

If there is no definition that applies to particular arguments, a runtime error case will be added:

This returns a result:

There is no definition that works for this input and hence a runtime error results:

All the branches of pattern definitions must return the same type:

All the branches of pattern definitions must compile for the arguments:

This compiles:

This does not compile:

Optional patterns are not supported:

Held patterns are not supported:

Verbatim patterns are not supported:

Sequence patterns do not support polymorphic declarations:

Make a polymorphic declaration, but the compilation cannot use it: