Replace unicode syntax with ascii syntax

Author: JordanMartinez

src/Data/Number.purs

@@ -39,24 +39,24 @@ import Global as G
 -- | > fromString "  1.2 ??"
 -- | (Just 1.2)
 -- | ```
-fromString ∷ String → Maybe Number
+fromString :: String -> Maybe Number
 fromString = G.readFloat >>> check
   where
     check num | isFinite num = Just num
               | otherwise    = Nothing
 
 -- | Not a number (NaN).
-nan ∷ Number
+nan :: Number
 nan = G.nan
 
 -- | Test whether a `Number` is NaN.
-isNaN ∷ Number → Boolean
+isNaN :: Number -> Boolean
 isNaN = G.isNaN
 
 -- | Positive infinity.
-infinity ∷ Number
+infinity :: Number
 infinity = G.infinity
 
 -- | Test whether a number is finite.
-isFinite ∷ Number → Boolean
+isFinite :: Number -> Boolean
 isFinite = G.isFinite

src/Data/Number/Approximate.purs

@@ -41,7 +41,7 @@ newtype Fraction = Fraction Number
 -- | > (eqRelative (Fraction 0.01)) (0.1 + 0.2) 0.3
 -- | true
 -- | ```
-eqRelative ∷ Fraction → Number → Number → Boolean
+eqRelative :: Fraction -> Number -> Number -> Boolean
 eqRelative (Fraction frac) 0.0   y =       abs y <= frac
 eqRelative (Fraction frac)   x 0.0 =       abs x <= frac
 eqRelative (Fraction frac)   x   y = abs (x - y) <= frac * abs (x + y) / 2.0
@@ -60,17 +60,17 @@ eqRelative (Fraction frac)   x   y = abs (x - y) <= frac * abs (x + y) / 2.0
 -- | > 0.1 + 0.2 ≅ 0.3
 -- | true
 -- | ```
-eqApproximate ∷ Number → Number → Boolean
+eqApproximate :: Number -> Number -> Boolean
 eqApproximate = eqRelative onePPM
   where
-    onePPM ∷ Fraction
+    onePPM :: Fraction
     onePPM = Fraction 1.0e-6
 
 infix 4 eqApproximate as ~=
 infix 4 eqApproximate as ≅
 
 -- | The complement of `eqApproximate`.
-neqApproximate ∷ Number → Number → Boolean
+neqApproximate :: Number -> Number -> Boolean
 neqApproximate x y = not (x ≅ y)
 
 infix 4 neqApproximate as ≇
@@ -91,6 +91,6 @@ newtype Tolerance = Tolerance Number
 -- | > (eqAbsolute (Tolerance 0.1)) 133.7 133.0
 -- | false
 -- | ```
-eqAbsolute ∷ Tolerance → Number → Number → Boolean
+eqAbsolute :: Tolerance -> Number -> Number -> Boolean
 eqAbsolute (Tolerance tolerance) x y = abs (x - y) <= tolerance
 

src/Data/Number/Format.purs

@@ -30,9 +30,9 @@ module Data.Number.Format
 
 import Prelude
 
-foreign import toPrecisionNative ∷   Int → Number → String
-foreign import toFixedNative ∷       Int → Number → String
-foreign import toExponentialNative ∷ Int → Number → String
+foreign import toPrecisionNative ::   Int -> Number -> String
+foreign import toFixedNative ::       Int -> Number -> String
+foreign import toExponentialNative :: Int -> Number -> String
 
 -- | The `Format` data type specifies how a number will be formatted.
 data Format
@@ -42,21 +42,21 @@ data Format
 
 -- | Create a `toPrecision`-based format from an integer. Values smaller than
 -- | `1` and larger than `21` will be clamped.
-precision ∷ Int → Format
+precision :: Int -> Format
 precision = Precision <<< clamp 1 21
 
 -- | Create a `toFixed`-based format from an integer. Values smaller than `0`
 -- | and larger than `20` will be clamped.
-fixed ∷ Int → Format
+fixed :: Int -> Format
 fixed = Fixed <<< clamp 0 20
 
 -- | Create a `toExponential`-based format from an integer. Values smaller than
 -- | `0` and larger than `20` will be clamped.
-exponential ∷ Int → Format
+exponential :: Int -> Format
 exponential = Exponential <<< clamp 0 20
 
 -- | Convert a number to a string with a given format.
-toStringWith ∷ Format → Number → String
+toStringWith :: Format -> Number -> String
 toStringWith (Precision p)   = toPrecisionNative p
 toStringWith (Fixed p)       = toFixedNative p
 toStringWith (Exponential p) = toExponentialNative p
@@ -73,4 +73,4 @@ toStringWith (Exponential p) = toExponentialNative p
 -- | > toString 1.2e-10
 -- | "1.2e-10"
 -- | ```
-foreign import toString ∷ Number → String
+foreign import toString :: Number -> String

test/Main.purs

@@ -15,13 +15,13 @@ import Test.Assert (assertTrue', assertFalse', assertEqual)
 
 
 -- | Comparison up to 10% relative error.
-eqRelative' ∷ Number → Number → Boolean
+eqRelative' :: Number -> Number -> Boolean
 eqRelative' = eqRelative (Fraction 0.1)
 
 infix 1 eqRelative' as ~=
 
 -- | Comparison up to 0.1 absolute error.
-eqAbsolute' ∷ Number → Number → Boolean
+eqAbsolute' :: Number -> Number -> Boolean
 eqAbsolute' = eqAbsolute (Tolerance 0.1)
 
 infix 1 eqAbsolute' as =~=