Unary minus and floating point number in OCaml

by

Here’s how I think it goes (after reading docs and experimenting). There really are four completely different operators:

-    Integer subtraction        int -> int -> int
-.   Floating subtraction       float -> float -> float
~-   Integer unary negation     int -> int
~-.  Floating unary negation    float -> float

If everybody used these operators, things would be clear, but unfortunately it’s also a pretty clumsy notation. In my experience the ~- and ~-. operators are rarely used. The OCaml grammar is specified to let you use the subtraction operators as unary negation operators, as in many other languages. If you do that, you often have to use extra parentheses. If you’re willing to use the specific unary operators, you don’t need the parentheses.

I.e., you can write (as in pad’s edited answer):

[|pt 0. 0.; pt ~-.4. 1.; pt ~-.7. ~-.2.; pt 4. 5.; pt 1. 1.|]

Or you can write:

[|pt 0. 0.; pt (-.4.) 1.; pt (-.7.) (-.2.); pt 4. 5.; pt 1. 1.|]

There’s also one extra confusing factor, which is that the OCaml lexer is specified to let you use the integer subtraction operator for unary negation when you use it with a floating constant. Again, this makes the notation more like other languages. Since it’s fundamentally a binary operator, you need the parentheses here too.

This means you can write:

[|pt 0. 0.; pt (-4.) 1.; pt (-7.) (-2.); pt 4. 5.; pt 1. 1.|]

This notation only works for negative floating constants. The other two notations work for any expression you might want to negate.

# (-) ;;
- : int -> int -> int = <fun>
# (-.) ;;
- : float -> float -> float = <fun>
# (~-) ;;
- : int -> int = <fun>
# (~-.) ;;
- : float -> float = <fun>

# let f x = x +. 2.0;;
val f : float -> float = <fun>

# f ~-.5.;;
- : float = -3.

# f -.5.;;
Characters 0-1:
  f -.5.;;
  ^
Error: This expression has type float -> float
       but an expression was expected of type float
# f (-.5.);;
- : float = -3.

# f -5.;;
  ^
Error: This expression has type float -> float
       but an expression was expected of type int
# f (-5.);;
- : float = -3.

More Related Contents:

  1. What does “dyn” mean in a type?
  2. YAML: Do I need quotes for strings in YAML?
  3. Comments in Markdown
  4. What are the precise rules for when you can omit parenthesis, dots, braces, = (functions), etc.?
  5. What does an underscore and interface name after keyword var mean?
  6. How to concatenate strings in twig
  7. What is the RTF syntax for a hyperlink?
  8. What does the “@” symbol do in PowerShell?
  9. What’s the difference between eq, eql, equal and equalp, in Common Lisp?
  10. Are semicolons optional in Rust?
  11. What is this “err.(*exec.ExitError)” thing in Go code? [duplicate]
  12. how to reference a YAML “setting” from elsewhere in the same YAML file?
  13. Knockout.js containerless “foreach” not working with
  14. Kotlin asterisk operator before variable name or Spread Operator in Kotlin
  15. How to select all leaf nodes using XPath expression?
  16. F# forward type declarations
  17. How can I split a shell command over multiple lines when using an IF statement?
  18. Tuple parameter declaration and assignment oddity
  19. History of trailing comma in programming language grammars
  20. What are some example use cases for symbol literals in Scala?
  21. What does flow {| brace pipe |} syntax do?
  22. Can I get “&&” or “-and” to work in PowerShell?
  23. LaTeX package for syntax highlighting of code in various languages
  24. List of Scala’s “magic” functions
  25. Overloaded inline operators in F#: ( |+| )
  26. Is there syntax for moving fields between similar structs?
  27. Tilde in path doesn’t expand to home directory
  28. How do I select an element that has a certain class?
  29. Is whitespace allowed within XML/HTML tags?
  30. Javascript history.PushState not working?

Leave a Comment