Input Syntax

Entering Characters

Typical ways to enter characters.

All printable ASCII characters can be entered directly. Those that are not alphanumeric are assigned explicit names in the Wolfram Language, allowing them to be entered even on keyboards where they do not explicitly appear.

Full names for non-alphanumeric printable ASCII characters.

All characters which are entered into the Wolfram Language kernel are interpreted according to the setting for the (RefLink[CharacterEncoding, paclet:ref/CharacterEncoding]) option for the stream from which they came.

Ways to enter characters.

Codes for characters can be generated using (RefLink[ToCharacterCode, paclet:ref/ToCharacterCode]). The Unicode standard is followed, with various extensions.

8-bit characters have codes less than 256; 16-bit characters have codes between 256 and 65535. Approximately 900 characters are assigned explicit names in the Wolfram Language. Other characters must be entered using their character codes.

Some special 8-bit characters.

Types of Input Syntax

The standard input syntax used by the Wolfram Language is the one used by default in (RefLink[InputForm, paclet:ref/InputForm]) and (RefLink[StandardForm, paclet:ref/StandardForm]). You can modify the syntax by making definitions for (RefLink[MakeExpression, paclet:ref/MakeExpression])[expr,form].

Options can be set to specify what form of input should be accepted by a particular cell in a notebook or from a particular stream.

The input syntax in (RefLink[TraditionalForm, paclet:ref/TraditionalForm]), for example, is different from that in (RefLink[InputForm, paclet:ref/InputForm]) and (RefLink[StandardForm, paclet:ref/StandardForm]).

In general, what input syntax does is to determine how a particular string or collection of boxes should be interpreted as an expression. When boxes are set up, say with the notebook front end, there can be hidden (RefLink[InterpretationBox, paclet:ref/InterpretationBox]) or (RefLink[TagBox, paclet:ref/TagBox]) objects which modify the interpretation of the boxes.

Character Strings

Entering character strings.

Character strings can contain any sequence of 8- or 16-bit characters. Characters entered by name or character code are stored the same as if they were entered directly.

In a notebook front end, text pasted into a string by default automatically has appropriate ∖ characters inserted so that the string stored in the Wolfram Language reproduces the text that was pasted.

Within ∖!∖(…∖) any box structures represented using backslash sequences can be used.

(RefLink[StringExpression, paclet:ref/StringExpression]) objects can be used to represent strings that contain symbolic constructs, such as pattern elements.

Symbol Names and Contexts

Symbol names and contexts.

Symbol names and contexts can contain any characters that are treated by the Wolfram Language as letters or letter-like forms. They can contain digits but cannot start with them. Contexts must end in a backquote `.

Numbers

Input forms for numbers.

Numbers can be entered with the notation base^^digits in any base from 2 to 36. The base itself is given in decimal. For bases larger than 10, additional digits are chosen from the letters a–z or A–Z. Upper- and lower-case letters are equivalent for these purposes. Floating-point numbers can be specified by including . in the digits sequence.

In scientific notation, mantissa can contain ` marks. The exponent n must always be an integer, specified in decimal.

The precision or accuracy s can be any real number; it does not need to be an integer.

In the form base^^number`s the precision s is given in decimal, but it gives the effective number of digits of precision in the specified base, not in base 10.

An approximate number x is taken to be machine precision if the number of digits given in it is (RefLink[Ceiling, paclet:ref/Ceiling])[(RefLink[$MachinePrecision, paclet:ref/$MachinePrecision])]+1 or less. If more digits are given, then x is taken to be an arbitrary-precision number. The accuracy of x is taken to be the number of digits that appear to the right of the decimal point, while its precision is taken to be (RefLink[Log, paclet:ref/Log])[10,(RefLink[Abs, paclet:ref/Abs])[x]]+(RefLink[Accuracy, paclet:ref/Accuracy])[x].

A number entered in the form "0``"s is taken to have precision 0 and accuracy s.

Bracketed Objects

Bracketed objects use explicit left and right delimiters to indicate their extent. They can appear anywhere within Wolfram Language input, and can be nested in any way.

The delimiters in bracketed objects are matchfix operators. But since these delimiters explicitly enclose all operands, no precedence need be assigned to such operators.

Bracketed objects without comma-separated elements.

Comments can be nested, and can continue for any number of lines. They can contain any 8- or 16-bit characters.

Parentheses must enclose a single complete expression; neither (e,e) nor () are allowed.

Bracketed objects that allow comma-separated elements.

The notation … is used to stand for any sequence of expressions.

{(Subscript[e, 1]),(Subscript[e, 2]),…} can include any number of elements, with successive elements separated by commas.

{} is (RefLink[List, paclet:ref/List])[], a list with zero elements.

⟨(Subscript[e, 1]),(Subscript[e, 2]),…⟩ can be entered as ∖[LeftAngleBracket](Subscript[e, 1]),(Subscript[e, 2]),…∖[RightAngleBracket].

The character ∖[InvisibleComma] can be used interchangeably with ordinary commas; the only difference is that ∖[InvisibleComma] will not be displayed.

When the delimiters are special characters, it is a convention that they are named ∖[LeftName] and ∖[RightName].

∖(…∖) is used to enter boxes using one-dimensional strings. Note that within the outermost ∖(…∖) in a piece of input the syntax used is slightly different from outside, as described in "Input of Boxes".

Bracketed objects with heads.

Bracketed objects with heads explicitly delimit all their operands except the head. A precedence must be assigned to define the extent of the head.

The precedence of h[e] is high enough that !h[e] is interpreted as (RefLink[Not, paclet:ref/Not])[h[e]]. However, h_s[e] is interpreted as (h_s)[e].

Two-Dimensional Input Forms

Two-dimensional input forms with built-in evaluation rules.

Any array of expressions represented by a (RefLink[GridBox, paclet:ref/GridBox]) is interpreted as a list of lists. Even if the (RefLink[GridBox, paclet:ref/GridBox]) has only one row, the interpretation is still {{(Subscript[a, 1]),(Subscript[a, 2]),…}}.

In the form (∫_(Subscript[x, min])^(Subscript[x, max]))yw((dx)/z) the limits (Subscript[x, min]) and (Subscript[x, max]) can be omitted, as can y and w.

Two-dimensional input forms without built-in evaluation rules.

There is no issue of precedence for forms such as (Sqrt[x]) and (OverHat[x]) in which operands are effectively spanned by the operator. For forms such as (Subscript[x, y]) and (SuperDagger[x]) a left precedence does need to be specified, so such forms are included in the main table of precedences above.

Input of Boxes

Ways to input boxes.

Control Keys

Standard control keys.

On English-language keyboards both forms will work where alternates are given. On other keyboards the first form should work but the second may not.

Boxes Constructed from Text

When textual input that you give is used to construct boxes, as in (RefLink[StandardForm, paclet:ref/StandardForm]) or (RefLink[TraditionalForm, paclet:ref/TraditionalForm]) cells in a notebook, the input is handled slightly differently from when it is fed directly to the kernel.

The input is broken into tokens, and then each token is included in the box structure as a separate character string. Thus, for example, xx+yyy is broken into the tokens "xx", "+", "yyy".

Types of tokens in text used to construct boxes.

A (RefLink[RowBox, paclet:ref/RowBox]) is constructed to hold each operator and its operands. The nesting of (RefLink[RowBox, paclet:ref/RowBox]) objects is determined by the precedence of the operators in standard Wolfram Language syntax.

Note that spacing characters are not automatically discarded. Instead, each sequence of consecutive such characters is made into a separate token.

String-Based Input

Inputting raw and interpreted boxes.

Any textual input that you give between \( and \) is taken to specify boxes to construct. The boxes are only interpreted if you specify with \! that this should be done. Otherwise x\^y is left for example as (RefLink[SuperscriptBox, paclet:ref/SuperscriptBox])[x,y], and is not converted to (RefLink[Power, paclet:ref/Power])[x,y].

Within the outermost \(…∖), further \(…∖) specify grouping and lead to the insertion of (RefLink[RowBox, paclet:ref/RowBox]) objects.

String-based ways of constructing raw boxes.

In string-based input between \( and \) spaces, tabs and newlines are discarded. ∖␣ can be used to insert a single space. Special spacing characters such as (RefLink[\[ThinSpace], paclet:ref/character/ThinSpace]), (RefLink[\[ThickSpace], paclet:ref/character/ThickSpace]), or (RefLink[\[NegativeThinSpace], paclet:ref/character/NegativeThinSpace]) are not discarded.

When you input typesetting forms into a string, the internal representation of the string uses the above forms. The front end displays the typeset form, but uses the \(…∖) notation when saving the content to a file or when sending the string to the kernel for evaluation.

The Extent of Input Expressions

The Wolfram Language will treat all input that you give on a single line as being part of the same expression.

The Wolfram Language allows a single expression to continue for several lines. In general, it treats the input that you give on successive lines as belonging to the same expression whenever no complete expression would be formed without doing this.

Thus, for example, if one line ends with =, then the Wolfram Language will assume that the expression must continue on the next line. It will do the same if for example parentheses or other matchfix operators remain open at the end of the line.

If at the end of a particular line the input you have given so far corresponds to a complete expression, then the Wolfram Language will normally begin immediately to process that expression.

You can however explicitly tell the Wolfram Language that a particular expression is incomplete by putting a ∖ or a  ((RefLink[\[Continuation], paclet:ref/character/Continuation])) at the end of the line. The Wolfram Language will then include the next line in the same expression, discarding any spaces or tabs that occur at the beginning of that line.

Special Input

Special input lines.

In most implementations of the Wolfram Language, you can give a line of special input anywhere in your input. The only constraint is that the special input must start at the beginning of a line.

Some implementations of the Wolfram Language may not allow you to execute external commands using !command.

Front End Files

Notebook files as well as front end initialization files can contain a subset of standard Wolfram Language syntax. This syntax includes:

Any Wolfram Language expression in (RefLink[FullForm, paclet:ref/FullForm]).

Lists in {…} form. The operators ->, :>, and &. Function slots in # form.

Various Wolfram Language operators such as +, *, ;, etc.

Special characters in ∖[Name], ∖:nnnn, or ∖.xx form.

String representation of boxes involving ∖(, ∖), and other backslash operators.

Wolfram Language comments delimited by (* and *).