Lexical structure

This page describes how MaSH turns source text into words and symbols, before it works out what they mean.

Source text

A script is plain text. Line endings can be \n, \r\n or \r; all three are read as one line ending. Characters MaSH does not recognise, such as a byte-order mark or a zero-width space, are skipped without an error.

Spaces and tabs separate words and are otherwise ignored. Indentation has no meaning.

Comments

A comment starts with # and runs to the end of the line.

Natural

# a whole-line comment
set x to 5 # a trailing comment
printline x

5

Standard

# a whole-line comment
x = 5 # a trailing comment
printline(x)

5

A # inside a string is part of the string, not a comment.

Natural

printline "# not a comment"
printline 'also # not a comment'

# not a comment
also # not a comment

Standard

printline("# not a comment")
printline('also # not a comment')

# not a comment
also # not a comment

There are no block comments.

Names

A name starts with a letter, an underscore, or any non-ASCII character. After that it can also contain digits. Accented letters work.

Natural

set café to 3
set _count2 to 4
printline café + _count2

7

Standard

café = 3
_count2 = 4
printline(café + _count2)

7

Variable names are case sensitive. X and x are two variables.

Natural

set X to 1
set x to 2
printline X
printline x

1
2

Standard

X = 1
x = 2
printline(X)
printline(x)

1
2

Keywords are not case sensitive. IF, If and if are the same word, and so are PRINTLINE and printline.

Natural

set x to 2
IF x is 2
  PRINTLINE "upper case works"
END

upper case works

Standard

x = 2
IF x == 2
  PRINTLINE "upper case works"
END

upper case works

Reserved words

These words belong to the language. You cannot use them as variable names, parameter names or block names, with two exceptions covered below.

as	block	break	by	clone
debug	decrement	divide	each	else
elseif	end	ensure	error	errorblock
exit	fail	false	here	if
in	increment	matches	multiply	next
not	null	pblock	raise	return
set	stoponerror	throw	to	true
until	while	yield

raise is another spelling of throw.

Some words only work as operators. They are written as words, but the reader turns them into symbols, so a variable cannot have these names either:

Word	Means
and, or	&&, ||
otherwise	??
thru, through	...
is, equals, equal to	==
is not	!=
is less than, is more than, is greater than	<, >

The Expressions page gives the full list.

else if (two words) is the same as elseif. here block (two words) is the same as pblock.

Note

The words debug, stoponerror and errorblock are keywords only when followed by =. Anywhere else they are ordinary names, so a block called debug can be called as debug "message".

An assignment to a reserved word is refused when the script is compiled, and the script does not start. The names mash and event are refused too, because they always mean the built-in objects.

Natural

set mash to 1

Standard

mash = 1

Keywords after a dot, and as dictionary keys

After a dot, every word is a plain property name, whatever it is. In a dictionary literal, a reserved word works as a bare key.

Natural

set d to {if: 1, end: 2, Error: 3}
printline d.if
printline d.end
printline d["Error"]

1
2
3

Standard

d = {if: 1, end: 2, Error: 3}
printline(d.if)
printline(d.end)
printline(d["Error"])

1
2
3

Literals

Null and booleans

null, true and false are literals. null is the absence of a value.

Integers and decimals

A number is a run of digits, with an optional decimal part. A leading - makes it negative. Underscores inside the digits are ignored, so large numbers can be read at a glance.

Natural

printline 1_000_000
printline .5
printline -3
printline 2.50

1000000
0.5
-3
2.5

Standard

printline(1_000_000)
printline(.5)
printline(-3)
printline(2.50)

1000000
0.5
-3
2.5

There is no exponent form, no hexadecimal form and no octal form. 1e3 is read as the number 1 followed by the name e3. 0x10 is read as 0 followed by the name x10.

An integer too large for 64 bits becomes a decimal number.

Natural

printline 100000000000000000000

1.0E+20

Standard

printline(100000000000000000000)

1.0E+20

A minus sign straight after a complete expression is a subtraction, with or without spaces.

Natural

block double n
  return n * 2
end
set y to 3 -1
printline y
set z to 2 * 3 -1
printline z
set a to [5, 6]
printline a[1 -1]
printline (4 -1)
printline double(4 -1)

2
5
5
3
6

Standard

block double(n) {
  return n * 2
}
y = 3 -1
printline(y)
z = 2 * 3 -1
printline(z)
a = [5, 6]
printline(a[1 -1])
printline (4 -1)
printline(double(4 -1))

2
5
5
3
6

Caution

Two places read the minus as the start of a separate negative number. In a bracketless call’s argument list it is a new argument, so check 5 -3 calls check(5, -3), and printline 3 -1 is an error because printline takes one argument. Straight after the name of a block or built-in, the call wins, so y = double -1 is -2. Spaces on both sides (3 - 1) are never ambiguous.

Strings

A string is text in double or single quotes. The two differ in two ways:

• A double-quoted string has escape sequences and {{ }} interpolation.
• A single-quoted string is literal. Only \\ and \' are escapes. Everything else, including \n and {{x}}, is kept as written.

Natural

set x to 5
printline "x is {{x}}"
printline 'x is {{x}}'
printline "two\nlines"
printline 'one\nline'

x is 5
x is {{x}}
two
lines
one\nline

Standard

x = 5
printline("x is {{x}}")
printline('x is {{x}}')
printline("two\nlines")
printline('one\nline')

x is 5
x is {{x}}
two
lines
one\nline

A string can run across several lines. The line endings become part of the string.

Natural

printline "first
second"

first
second

Standard

printline("first
second")

first
second

The escape sequences in a double-quoted string are:

Escape	Character
\n	new line
\t	tab
\r	carriage return
\b, \f, \v, \e, \a	backspace, form feed, vertical tab, escape, bell
\0	the zero character, or an octal code of up to two more digits after it
\xHH	the character with hexadecimal code HH
\\, \", \'	a backslash, a double quote, a single quote
\{, \}	a literal brace

A backslash before any other character is kept as it is, backslash included. "\d" is the two characters \d.

Natural

printline "tab[\t] quote[\"] backslash[\\] hex[\x41] other[\d]"

tab[  ] quote["] backslash[\] hex[A] other[\d]

Standard

printline("tab[\t] quote[\"] backslash[\\] hex[\x41] other[\d]")

tab[  ] quote["] backslash[\] hex[A] other[\d]

Interpolation

In a double-quoted string, {{ expression }} is replaced by the value of the expression. The expression can be anything: a name, arithmetic, a method call, an index, even a string.

Natural

set n to 3
set d to {a: 7}
printline "n={{n}} next={{ n + 1 }} a={{ d['a'] }} items={{ count([1, 2]) }}"

n=3 next=4 a=7 items=2

Standard

n = 3
d = {a: 7}
printline("n={{n}} next={{ n + 1 }} a={{ d['a'] }} items={{ count([1, 2]) }}")

n=3 next=4 a=7 items=2

Interpolation is shorthand for joining strings with ~. A null becomes an empty string, and a true or false becomes true or false.

Natural

set x to null
printline "[{{x}}] [{{true}}]"

[] [true]

Standard

x = null
printline("[{{x}}] [{{true}}]")

[] [true]

Three rules cover the odd cases:

• {{ with no }} before the closing quote is plain text.
• {{{ makes the first brace literal.
• \{{ stops interpolation.

Natural

set n to 3
printline "{{{n}}}"
printline "open {{ never closed"
printline "single {n}"
printline "escaped \{\{n}}"

{3}
open {{ never closed
single {n}
escaped {{n}}

Standard

n = 3
printline("{{{n}}}")
printline("open {{ never closed")
printline("single {n}")
printline("escaped \{\{n}}")

{3}
open {{ never closed
single {n}
escaped {{n}}

Regular expressions

A regular expression is written between slashes, with optional flags after the second slash: i, m, s, u, U and x. It is a string underneath, so it can be stored in a variable, and the matches operator accepts it.

Natural

set pattern to /a.c/i
printline "xABCx" matches pattern
printline "xyz" matches /a.c/

true
false

Standard

pattern = /a.c/i
printline("xABCx" matches pattern)
printline("xyz" matches /a.c/)

true
false

A / starts a regular expression only where an expression can start. After a number, a string, a name, ) or ], it is division. That makes a regular expression written straight after a bare name read as a division.

Caution

printline /a.c/i does not print a pattern. After the name printline the first / is a division, and the statement does nothing and reports nothing. Put the pattern in a variable first, or write the call with brackets: printline(/a.c/i).

The library reference covers what you can do with patterns beyond matches.

Operators and punctuation

Token	Use
+ - * / % **	arithmetic
~	join strings
== === != !==	equality
< > <= >=	comparison
&& || !	and, or, not
??	first value that is not null
? :	conditional expression; : also separates dictionary keys and named arguments
= += -= *= /=	assignment
... ..< ..	ranges
.	member access
@	reference to a block
=>	recognised but not used by any statement
( ) [ ] { }	grouping, calls, indexes, arrays, dictionaries, bodies
,	separates items
;	ends a statement, like a new line

A single & or | is an error: Unexpected character '&' — did you mean '&&'?

.. with two dots is a range, the same as ....

Where a statement ends

A new line ends a statement. A semicolon does the same, so several statements can share a line.

Natural

set x to 1; set y to 2; printline x + y

3

Standard

x = 1; y = 2; printline x + y

3

Blank lines are ignored.

A statement carries on to the next line in these cases:

• The line ends with an operator, a comma, an opening bracket, =, . or =>.
• The next line starts with . or =.
• The statement is inside ( ), [ ], or an argument list. New lines are ignored there.

Natural

set total to 1 +
  2 +
  3
set list to [
  10,
  20
]
set text to "a"
printline total
printline count(list)
printline mash.collect([1, 2, 3])
  .count()

6
2
3

Standard

total = 1 +
  2 +
  3
list = [
  10,
  20
]
text = "a"
printline(total)
printline(count(list))
printline(mash.collect([1, 2, 3])
  .count())

6
2
3

Caution

A line that starts with +, -, ~, and or or does not continue the one above. Put the operator at the end of the first line instead. A line starting with + 2 is a syntax error.

Inside a { } body, new lines separate statements again, even if the braces are inside brackets.