If like me, you've always been a little hazy on the rules for defining OCaml operators then, this little post might help!
It is possible to "inject" user-defined operator syntax into OCaml programs. Here's how it works. First we define a set of characters called "symbol characters".
Symbol character (definition)
A character that is one of
! $ % & * + - . / : < = > ? @ ^ | ~
! ("bang") prefix operator, has a predefined semantic as the operation of "de-referencing" a reference cell. A custom prefix operator can made by from a
! followed by one or more symbol characters.
So, to give some examples, one can define prefix operators like
!~ or even something as exotic as
!::>. For example, one might write something like
let ( !+ ) x : int ref → unit = incr xas a syntactic sugar equivalent to
fun x → incr x
Additionally, prefix operators can begin with one of
? and, as in the case of
!, must be followed by one or more symbol characters. So, in summary, a prefix operator begins with one of
! ~ ?and is followed by one or more symbol characters.
let ( ~! ) x = incr x defines an alternative syntax equivalent to the
!+ operator presented earlier.
Prefix operators have the highest possible precedence.
It is in fact possible to define operators in 5 different categories. What distinguish these categories from each other are their associativity and precedence properties.
Level 0 operators are left associative with the same precedence as
=. A level 0 operator starts with one of
= < > | & $and is followed by zero or more symbol chars. For example,
>>=is an operator much beloved by monadic programmers and
|>(pipe operator) is a builtin equivalent to
let ( |> ) x f = f x.
Level 1 operators are right associative, have a precedence just above
= and start with one of
@ ^. That is, these operators are consistent with operations involving joining things.
@@(the "command" operator) of course has a predefined semantic as function application, that is, equivalent to the definition
let ( @@ ) f x = f x.
Level 2 operators are left associative have a precedence level shared with
- and indeed, are defined with a leading (one of)
+ -and, as usual, followed by a sequence of symbol characters. These operators are consistent for usage with operations generalizing addition or difference like operations. Some potential operators of this kind are
++and so on.
Level 3 operators are also left associative and have a precedence level shared with
/. Operators of this kind start with one of
* / %followed by zero or more symbol characters and are evocative of operations akin to multiplication, division. For example,
*~might make a good companion for
+~of the previous section.
Level 4 operators are right associative and have a precedence above
*. The level 4 operators begin with
**and are followed by zero or more symbol characters. The operation associated with
**is exponentiation (binds tight and associates to the right). The syntax
**~would fit nicely into the
*~set of the earlier sections.