• ← The structure of things
• → Control statements

Functions and patterns

Functions can be defined in the following way:

• • f[x_] := x ^ 2

This tells Mathics to replace every occurrence of f with one (arbitrary) parameter x with x ^ 2.

• • f[3]

• • f[a]

The definition of f does not specify anything for two parameters, so any such call will stay unevaluated:

• • f[1, 2]

In fact, functions in Mathics are just one aspect of patterns: f[x_] is a pattern that matches expressions like f[3] and f[a]. The following patterns are available:

_ or Blank[]

matches one expression.

Pattern[x, p]

matches the pattern p and stores the value in x.

x_ or Pattern[x, Blank[]]

matches one expression and stores it in x.

__ or BlankSequence[]

matches a sequence of one or more expressions.

___ or BlankNullSequence[]

matches a sequence of zero or more expressions.

_h or Blank[h]

matches one expression with head h.

x_h or Pattern[x, Blank[h]]

matches one expression with head h and stores it in x.

p | q or Alternatives[p, q]

matches either pattern p or q.

p ? t or PatternTest[p, t]

matches p if the test t[p] yields True.

p /; c or Condition[p, c]

matches p if condition c holds.

Verbatim[p]

matches an expression that equals p, without regarding patterns inside p.

As before, patterns can be used to define functions:

• • g[s___] := Plus[s] ^ 2

• • g[1, 2, 3]

MatchQ[e, p] tests whether e matches p:

• • MatchQ[a + b, x_ + y_]

• • MatchQ[6, _Integer]

ReplaceAll (/.) replaces all occurrences of a pattern in an expression using a Rule given by ->:

• • {2, "a", 3, 2.5, "b", c} /. x_Integer -> x ^ 2

You can also specify a list of rules:

• • {2, "a", 3, 2.5, "b", c} /. {x_Integer -> x ^ 2.0, y_String -> 10}

ReplaceRepeated (//.) applies a set of rules repeatedly, until the expression doesn't change anymore:

• • {2, "a", 3, 2.5, "b", c} //. {x_Integer -> x ^ 2.0, y_String -> 10}

There is a “delayed” version of Rule which can be specified by :> (similar to the relation of := to =):

• • a :> 1 + 2

• • a -> 1 + 2

This is useful when the right side of a rule should not be evaluated immediately (before matching):

• • {1, 2} /. x_Integer -> N[x]

Here, N is applied to x before the actual matching, simply yielding x. With a delayed rule this can be avoided:

• • {1, 2} /. x_Integer :> N[x]

While ReplaceAll and ReplaceRepeated simply take the first possible match into account, ReplaceList returns a list of all possible matches. This can be used to get all subsequences of a list, for instance:

• • ReplaceList[{a, b, c}, {___, x__, ___} -> {x}]

ReplaceAll would just return the first expression:

• • ReplaceAll[{a, b, c}, {___, x__, ___} -> {x}]

In addition to defining functions as rules for certain patterns, there are pure functions that can be defined using the & postfix operator, where everything before it is treated as the funtion body and # can be used as argument placeholder:

• • h = # ^ 2 &;

• • h[3]

Multiple arguments can simply be indexed:

• • sum = #1 + #2 &;

• • sum[4, 6]

It is also possible to name arguments using Function:

• • prod = Function[{x, y}, x * y];

• • prod[4, 6]

Pure functions are very handy when functions are used only locally, e.g., when combined with operators like Map:

• • # ^ 2 & /@ Range[5]

Sort according to the second part of a list:

• • Sort[{{x, 10}, {y, 2}, {z, 5}}, #1[[2]] < #2[[2]] &]

Functions can be applied using prefix or postfix notation, in addition to using []:

• • h @ 3

• • 3 // h