Orc has a standard set of infix, prefix, and postfix operators.
Operators in Orc are syntactic sugar for site calls;
they publish at most once, and their operands are deflated.
For example, 1 + 2
is equivalent to (+)(1, 2)
and 1 + 2 * 3
is equivalent to (+)(1, (*)(2, 3))
.
Operators are parsed using the precedence and associativity rules of Orc. In particular, these rules describe the relationship between operators and combinators.

+  Addition 
  Subtraction 
*  Multiplication 
/  Division 
%  Modulus 
**  Exponentiation 
 (unary prefix form)  Arithmetic negation 
Numeric literals with no decimal part, such as 3
, are treated as integers. Arithmetic operators with two integer arguments will perform
an integer operation and return an integer result; for example, 5 / 2
performs integer division and returns 2
.
However, if either argument to an operator has a decimal part (even if it is trivial, as in 3.0
), the other argument will
be promoted, and a decimal operation will be performed. For example, 5 / 2.0
and 5.0 / 2
both
perform decimal division and return 2.5
.
=  Equal to 
/=  Not equal to 
<:  Less than 
:>  Greater than 
<=  Less than or equal to 
>=  Greater than or equal to 
The =
operator can compare values of any type. Values of different type are always unequal; for example,
10 = true
publishes false
.
The operators' syntax (fixity, precedence, and associativity) is fixed by the Orc grammar; however, the site
called is defined by the library and can be changed by a def
or import site
declaration.
Orc permits a special identifier form for operators: the operator name
surrounded by parenthesis, as in (+)
.
To disambiguate the unary prefix operator 
from the
binary infix operator 
, Orc translates the
unary prefix operator as (0)
. Binding a value to such
an identifier redefines the corresponding operator in the scope of
that binding.
Assuming that an operator has not been redefined, it obeys the following typing rules:
An arithmetic operation publishes an Integer
if all of its operands have type Integer
.
If any operand has type Number
(but not Integer
), the operation publishes a Number
.
A comparison operation allows operands of any type, and publishes a Boolean
.
A logical operation allows only Boolean
operands, and publishes a Boolean
.
A string concatenation requires at least one String
operand.
Other operands may be of type Top
; they are converted to strings.
String concatenation publishes a String
.
List construction is polymorphic.
It takes an operand of type T
and an operand of type List
[
T
]
.
It returns a value of type List
[
T
]
.
Record extension takes two records and publishes a record.
Dereference takes an operand of type Ref
[
T
]
and publishes a T
.
Assignment takes operands of types Ref
[
T
]
and T
, and publishes a Signal
.
1 + 2 * 3 { OUTPUT: 7 }
1 + (2  3) { OUTPUT: 3 } { OUTPUT: 4 }
{ Redefine the "", "~", and "?" operators } def ()(x,y) = x + ", or " + y def (~)(x) = "not " + x def (?)(r) = r + ", that is the question." # ("To be"  ~ "to be")? { OUTPUT: "To be, or not to be, that is the question." }
Related Reference Topics
Related Tutorial Sections