Fix backtick syntax (for the last time)

Author: hdgarrood

guides/Common-Operators.md

@@ -2,13 +2,21 @@
 
 Or, "what is the PureScript equivalent of \<X operator\> in JS?"
 
-Although the PureScript language defines no built-in operators, plenty are defined in the `Prelude` and other core libraries. This guide gives you a overview of these operators and the corresponding operators in JavaScript.
+Although the PureScript language defines no built-in operators, plenty
+are defined in the `Prelude` and other core libraries. This guide
+gives you a overview of these operators and the corresponding
+operators in JavaScript.
 
 ## JavaScript's unary operators
 
-All PureScript operators are binary, with one exception: there is syntax sugar for unary negation, whereby in PureScript code, `-x` is desugared to `negate x`, which uses whichever `negate` is in scope.
+All PureScript operators are binary, with one exception: there is
+syntax sugar for unary negation, whereby in PureScript code, `-x` is
+desugared to `negate x`, which uses whichever `negate` is in scope.
 
-This means that the PureScript analogues to unary JavaScript operators (other than `-`) are not operators, but normal functions which must be applied using the standard prefix-style function application, so e.g. `!x` in JS must be written as `not x` in PureScript.
+This means that the PureScript analogues to unary JavaScript operators
+(other than `-`) are not operators, but normal functions which must be
+applied using the standard prefix-style function application, so
+e.g. `!x` in JS must be written as `not x` in PureScript.
 
 | JS Operator | PureScript Function | Defined in            | Meaning          |
 |-------------|---------------------|-----------------------|------------------|
@@ -42,18 +50,46 @@ This means that the PureScript analogues to unary JavaScript operators (other th
 | `>>`        | `shr`               | `Data.Int.Bits`       | Shift Right                              |
 | `>>>`       | `zshr`              | `Data.Int.Bits`       | Zero-fill Shift Right                    |
 
-Most of these functions and operators are re-exported by the `Prelude`, so to have access to them in your code, you should normally just write `import Prelude`.
+Most of these functions and operators are re-exported by the
+`Prelude`, so to have access to them in your code, you should normally
+just write `import Prelude`.
 
-Additionally, many of these functions and operators are defined in type classes and work with lots of different types. For example, `+` and `*` work with not only `Int` and `Number`, but also any instance of the `Semiring` type class defined in the `Prelude`.
+Additionally, many of these functions and operators are defined in
+type classes and work with lots of different types. For example, `+`
+and `*` work with not only `Int` and `Number`, but also any instance
+of the `Semiring` type class defined in the `Prelude`.
 
 ### A note on remainder/modulus (`%`)
 
-Normally, when we ask for the remainder of one number after dividing by another, we are talking about integers. Clearly the remainder of 10 after dividing by 3 is 1, and indeed in JS, `10 % 3 == 1`. Likewise, in PureScript, `10 ``mod`` 3 == 1`.
-
-It's a bit harder to say what a 'remainder' operation should mean if we are trying to extend it to real (non-integral) numbers, though. Real numbers can be divided into one another with nothing 'left over', i.e. in some sense, the remainder of dividing one number by another is always 0.
-
-Since JS just has one number type, it has to come up with a sensible way of handling cases where one or both of its arguments are non-integral. To address this, it uses a behaviour where it tries to find the largest *integer* multiple of the second argument which is smaller than the first argument, and then returns the difference between these. For example, in JS, `10.5 % 3 == 1.5`.
-
-If this is the behaviour you want in PureScript, you should use `%` from the `Math` module in `purescript-math`. Its type is `Number -> Number -> Number` and it simply delegates to the `%` operator in JS.
-
-However, PureScript's `Prelude` aims to provide a stronger theoretical foundation for common operators such as this one, which is why the `Prelude` exports a slightly different function, `mod :: forall a. EuclideanRing a => a -> a -> a`. For integers, `mod` works how you expect it to: ``10 `mod` 3 == 1``, just as before. However, for Numbers, `mod` always returns 0. This may be surprising; however, the reason it works this way is that it is based upon a mathematical structure called a *Euclidean Ring*, whose definition requires this behaviour. For more info, see the [EuclideanRing documentation](https://pursuit.purescript.org/packages/purescript-prelude/2.1.0/docs/Data.EuclideanRing#t:EuclideanRing).
+Normally, when we ask for the remainder of one number after dividing
+by another, we are talking about integers. Clearly the remainder of 10
+after dividing by 3 is 1, and indeed in JS, `10 % 3 == 1`. Likewise,
+in PureScript, ``10 `mod` 3 == 1``.
+
+It's a bit harder to say what a 'remainder' operation should mean if
+we are trying to extend it to real (non-integral) numbers,
+though. Real numbers can be divided into one another with nothing
+'left over', i.e. in some sense, the remainder of dividing one number
+by another is always 0.
+
+Since JS just has one number type, it has to come up with a sensible
+way of handling cases where one or both of its arguments are
+non-integral. To address this, it uses a behaviour where it tries to
+find the largest *integer* multiple of the second argument which is
+smaller than the first argument, and then returns the difference
+between these. For example, in JS, `10.5 % 3 == 1.5`.
+
+If this is the behaviour you want in PureScript, you should use `%`
+from the `Math` module in `purescript-math`. Its type is `Number ->
+Number -> Number` and it simply delegates to the `%` operator in JS.
+
+However, PureScript's `Prelude` aims to provide a stronger theoretical
+foundation for common operators such as this one, which is why the
+`Prelude` exports a slightly different function, `mod :: forall
+a. EuclideanRing a => a -> a -> a`. For integers, `mod` works how you
+expect it to: ``10 `mod` 3 == 1``, just as before. However, for
+Numbers, `mod` always returns 0. This may be surprising; however, the
+reason it works this way is that it is based upon a mathematical
+structure called a *Euclidean Ring*, whose definition requires this
+behaviour. For more info, see the [EuclideanRing
+documentation](https://pursuit.purescript.org/packages/purescript-prelude/2.1.0/docs/Data.EuclideanRing#t:EuclideanRing).