!(x: bool): bool

Logical negation.

!=(x, y): bool

Value in-equality test. See Value Equality

!after(p: piece, q: piece): pieceset
!after(p: pieceset, q: piece): pieceset
!after(p: piece, q: pieceset): pieceset
!after(p: pieceset, q: pieceset): pieceset

All the elements of p that are not after any element of q.

!before(p: piece, q: piece): pieceset
!before(p: pieceset, q: piece): pieceset
!before(p: piece, q: pieceset): pieceset
!before(p: pieceset, q: pieceset): pieceset

All the elements of p that do not precede any element of q.

!contain(p: piece, q: piece): pieceset
!contain(p: pieceset, q: piece): pieceset
!contain(p: piece, q: pieceset): pieceset
!contain(p: pieceset, q: pieceset): pieceset

All the elements of p that do not contain any element of q.

!directlyafter(p: piece, q: piece): pieceset
!directlyafter(p: pieceset, q: piece): pieceset
!directlyafter(p: piece, q: pieceset): pieceset
!directlyafter(p: pieceset, q: pieceset): pieceset

All the elements of p that do not follow directly after any element of q.

!directlybefore(p: piece, q: piece): pieceset
!directlybefore(p: pieceset, q: piece): pieceset
!directlybefore(p: piece, q: pieceset): pieceset
!directlybefore(p: pieceset, q: pieceset): pieceset

All the elements of p that are not directly before any element of q.

!directlycontain(p: piece, q: piece): pieceset
!directlycontain(p: pieceset, q: piece): pieceset
!directlycontain(p: piece, q: pieceset): pieceset
!directlycontain(p: pieceset, q: pieceset): pieceset

All the elements of p that do not directly contain any element of q.

!directlyinside(p: piece, q: piece): pieceset
!directlyinside(p: pieceset, q: piece): pieceset
!directlyinside(p: piece, q: pieceset): pieceset
!directlyinside(p: pieceset, p: pieceset): pieceset

All the elements of p that are not directly inside any element of q.

!inside(p: piece, q: piece): pieceset
!inside(p: pieceset, q: piece): pieceset
!inside(p: piece, q: pieceset): pieceset
!inside(p: pieceset, q: pieceset): pieceset

All the elements of p that are not located inside any element of q.

!overlap(p: piece, q: piece): pieceset
!overlap(p: pieceset, q: piece): pieceset
!overlap(p: piece, q: pieceset): pieceset
!overlap(p: pieceset, q: pieceset): pieceset

All the elements of p that do not overlap any element in q.

*(q1: piece, q2: piece): pieceset
*(q: piece, s: pieceset): pieceset
*(s: pieceset, q: piece): pieceset
*(s1: pieceset, s2: pieceset): pieceset

Piece set intersection.

*(x: int, y: int): int
*(x: int, y: real): real
*(x: real, y: int): real
*(x: real, y: real): real

Numeric multiplication.

*(x: set, y: set): set

Set intersection.

+(q1: piece, q2: piece): pieceset
+(q: piece, s: pieceset): pieceset
+(s: pieceset, q: piece): pieceset
+(s1: pieceset, s2: pieceset): pieceset

Piece set union.

+(x: char, y: string): string
+(x: char, y: char): string
+(x: string, y: string): string
+(x: string, y: char): string

String and character concatenation.

+(x: int, y: int): int
+(x: int, y: real): real
+(x: real, y: int): real
+(x: real, y: real): real

Numeric addition x + y.

+(x: list, y: list): list

List concatenation.

+(x: set, y: set): set

Set union.

-(q1: piece, q2: piece): pieceset
-(q: piece, s: pieceset): pieceset
-(s: pieceset, q: piece): pieceset
-(s1: pieceset, s2: pieceset): pieceset

Piece set difference.

-(x: int): int
-(x: real): real

Numeric negation.

-(x: int, y: int): int
-(x: int, y: real): real
-(x: real, y: int): real
-(x: real, y: real): real

Numeric substraction.

-(x: set, y: set): set

Set exclusion.

.(x: object, y): any

Object field access.

/(x: int, y: int): int
/(x: int, y: real): real
/(x: real, y: int): real
/(x: real, y: real): real

Numeric division.

== (x, y): bool

Value equality test. See Value Equality

[](s: pieceset, i: int): piece

Indexing into a piece set. Pieces are numbered 0 to Size - 1.

[](x: list, i: int): any
[](x: object, i): any
[](x: string, i: int): char

List, object, and string indexing1. Elements in a list and string are numbered from 0 to Size-1.

after(p: piece, q: piece): pieceset
after(p: pieceset, q: piece): pieceset
after(p: piece, q: pieceset): pieceset
after(p: pieceset, q: pieceset): pieceset

All the elements of p that are after any element of q.

before(p: piece, q: piece): pieceset
before(p: pieceset, q: piece): pieceset
before(p: piece, q: pieceset): pieceset
before(p: pieceset, q: pieceset): pieceset

All the elements of p that precede any element of q.

C(x: int, y: int): bool
C(x: int, y: real): bool
C(x: real, y: int): bool
C(x: real, y: real): bool

Numerical comparison, where C is one of <, <=, >, or >=.

C(x: string, y: string): bool
C(x: char, y: char): bool

Lexical comparison, where C is one of <, <=, >, or >=.

contain(p: piece, q: piece): pieceset
contain(p: pieceset, q: piece): pieceset
contain(p: piece, q: pieceset): pieceset
contain(p: pieceset, q: pieceset): pieceset

All the elements of p that contain any element of q.

directlyafter(p: piece, q: piece): pieceset
directlyafter(p: pieceset, q: piece): pieceset
directlyafter(p: piece, q: pieceset): pieceset
directlyafter(p: pieceset, q: pieceset): pieceset

All the elements of p that follow directly after any element of q.

directlybefore(p: piece, q: piece): pieceset
directlybefore(p: pieceset, q: piece): pieceset
directlybefore(p: piece, q: pieceset): pieceset
directlybefore(p: pieceset, q: pieceset): pieceset

All the elements of p that are directly before any element of q.

directlycontain(p: piece, q: piece): pieceset
directlycontain(p: pieceset, q: piece): pieceset
directlycontain(p: piece, p: pieceset): pieceset
directlycontain(p: pieceset, q: pieceset): pieceset

All the elements of p that directly contain any element of q.

directlyinside(p: piece, q: piece): pieceset
directlyinside(p: pieceset, q: piece): pieceset
directlyinside(p: piece, q: pieceset): pieceset
directlyinside(p: pieceset, q: pieceset): pieceset

All the elements of p that are directly inside any element of q.

div(x: int, y: int): int

Whole division.

inside(p: piece, q: piece): pieceset
inside(p: pieceset, q: piece): pieceset
inside(p: piece, q: pieceset): pieceset
inside(p: pieceset, q: pieceset): pieceset

All the elements of p that are located inside any element of q.

intersect(p: piece, q: piece): pieceset
intersect(p: pieceset, q: piece): pieceset
intersect(p: piece, q: pieceset): pieceset
intersect(q: pieceset, p: pieceset): pieceset

All the elements of p that overlap an element in q, each of them repeatedly intersected with all overlapping elements in q.

member(x, s: set): bool
member(x, l: list): bool
member(x, o: object): bool

Set, list and object2 membership test.

mod(x: int, y: int): int

x mod y.

or(x: bool, y: bool): bool
and(x: bool, y: bool): bool

Logical operators (short-circuit evaluation).

overlap(p: piece, q: piece): pieceset
overlap(p: pieceset, q: piece): pieceset
overlap(p: piece, q: pieceset): pieceset
overlap(p: pieceset, p: pieceset): pieceset

All the elements of p that overlap any element in q.

without(p: piece, q: piece): pieceset
without(p: pieceset, q: piece): pieceset
without(p: piece, q: pieceset): pieceset
without(p: pieceset, q: pieceset): pieceset

All the elements of p where overlaps with any element of q have been removed.