ocaml 中的一元减号和一元波浪号减号运算符有什么区别？

Question

I'm learning OCaml, and the docs and books I'm reading aren't very clear on some things.

In simple words, what are the differences between

-10

and

~-10

To me they seem the same. I've encountered other resources trying to explain the differences, but they seem to explain in terms that I'm not yet familiar with, as the only thing I know so far are variables.

Answer 1

In fact, - is a binary operator, so some expression can be ambigous: f 10 -20 is treated as (f 10) - 20 . For example, let's imagine this dummy function:

let f x y = (x, y)

If I want produce the tuple (10, -20) I naïvely would write something like that f 10 -20 which leads me to the following error:

# f 10 -20;;
Error: This expression has type 'a -> int * 'a
       but an expression was expected of type int

because the expression is evaluated as (f 10) - 20 (so a substract over a function:!) so you can write the expression like this: f 10 (-20) , which is valid or f 10 ~-20 since ~- (and ~+ and ~-. ~+. for floats) are unary operators, the predecense is properly respected.

Answer 2

It is easier to start by looking at how user-defined unary (~-) operators work.

type quaternion = { r:float; i:float; j:float; k:float }
let zero = { r = 0.; i = 0.; j = 0.; k = 0. }
let i = { zero with i = 1. }
let (~-) q = { r = -.q.r; i = -.q.i; j = -. q.j; k = -. q.k }

In this situation, the unary operator - (and + ) is a shorthand for ~- (and ~+ ) when the parsing is unambiguous. For example, defining -i with

let mi = -i

works because this - could not be the binary operator - . Nevertheless, the binary operator has a higher priority than the unary - thus

let wrong = Fun.id -i

is read as

let wrong = (Fun.id) - (i)

In this context, I can either use the full form ~-

let ok' = Fun.id ~-i

or add some parenthesis

let ok'' = Fun.id (-i)

Going back to type with literals (eg integers, or floats), for those types, the unary + and - symbol can be part of the literal itself (eg -10 ) and not an operator. For instance redefining ~- and ~+ does not change the meaning of the integer literals in

let (~+) = ()
let (~-) = ()
let really = -10
let positively_real = +10

This can be "used" to create some quite obfuscated expression:

let (~+) r = { zero with r }
let (+) x y = { r = x.r +. y.r; i = x.i +. y.i; k = x.k +. x.k; j =x.k +. y.j  }
let ( *. ) s q = { r = s *. q.r; i = s *. q.i; j = s *. q.j; k = s *. q.k }
let this_is_valid x = +x + +10. *. i

Answer 3

OCaml has two kinds of operators - prefix and infix . The prefix operators pre cede expressions and infix occur in between the two expressions, eg, in !foo we have the prefix operator ! coming before the expression foo and in 2 + 3 we have the infix operator + between expressions 2 and 3 .

Operators are like normal functions except that they have a different syntax for application (aka calling), whilst functions are applied to an arbitrary number of arguments using a simple syntax of juxtaposition, eg, f x1 x2 x3 x4 ¹ , operators can have only one (prefix) or two (infix) arguments. Prefix operators are very close to normal functions, cf., fx and !x , but they have higher precedence (bind tighter) than normal function application. Contrary, the infix operators, since they are put between two expressions, enable a more natural syntax, eg, x + y vs. (+) xy , but have lower precedence (bind less tight) than normal function application. Moreover, they enable chaining several operators in a row, eg, x + y + z is interpreted as (x + y) + z , which is much more readable than add (add (xy) z) .

Operators in OCaml distinguished purely syntactically. It means that the kind of an operator is fully defined by the first character of that operator, not by a special compiler directive, like in some other languages (ie, there is not infix + directive in OCaml). If an operator starts with the prefix-symbol sequence, eg, ! , ?@ , ~% , it is considered as prefix and if it starts with an infix-symbol then it is, correspondingly, an infix operator.

The - and -. operators are treated specially and can appear both as prefix and infix. Eg, in 1 - -2 we have - occurring both in the infix and prefix positions. However, it is only possible to disambiguate between the infix and the prefix versions of the - (and -. ) operators when they occur together with other operators (infix or prefix), but when we have a general expression, the - operator is treated as infix. Eg, max 0 -1 is interpreted as (max 0) - 1 (remember that operator has lower precedence than function application, therefore when they two appear with no parentheses then functions are applied first and operators after that). Another example, Some -1 , which is interpreted as Some - 1 , not as Some (-1) . To disambiguate such code, you can use either the parentheses, eg, max 0 (-1) , or the prefix-only versions, eg, Some ~-1 or max 0 ~-1 .

As a matter of personal style, I actually prefer parentheses as it is usually hard to keep these rules in mind when you read the code.

---

¹⁾ Purists will say that functions in OCaml can have only one argument and f x1 x2 x3 x4 is just ((f x1) x2) x3) x4 , which would be a totally correct statement, but a little bit irrelevant to the current discussion.