Port Number-related code from deprecated purescript-globals into this repo

bower.json

@@ -2,13 +2,13 @@
   "name": "purescript-numbers",
   "description": "Functions for working with Numbers",
   "license": "MIT",
-  "homepage": "https://github.com/sharkdp/purescript-numbers",
+  "homepage": "https://github.com/purescript/purescript-numbers",
   "authors": [
     "David Peter <mail@david-peter.de>"
   ],
   "repository": {
     "type": "git",
-    "url": "git://github.com/sharkdp/purescript-numbers.git"
+    "url": "git://github.com/purescript/purescript-numbers.git"
   },
   "ignore": [
     "**/.*",
@@ -17,8 +17,8 @@
   ],
   "dependencies": {
     "purescript-math": "master",
-    "purescript-globals": "master",
-    "purescript-maybe": "master"
+    "purescript-maybe": "master",
+    "purescript-functions": "master"
   },
   "devDependencies": {
     "purescript-console": "master",

src/Data/Number.js

@@ -0,0 +1,33 @@
+/* globals exports */
+"use strict";
+
+exports.nan = NaN;
+
+exports.isNaN = isNaN;
+
+exports.infinity = Infinity;
+
+exports.isFinite = isFinite;
+
+exports.readInt = function (radix) {
+  return function (n) {
+    return parseInt(n, radix);
+  };
+};
+
+exports.readFloat = parseFloat;
+
+var formatNumber = function (format) {
+  return function (fail, succ, digits, n) {
+    try {
+      return succ(n[format](digits));
+    }
+    catch (e) {
+      return fail(e.message);
+    }
+  };
+};
+
+exports._toFixed = formatNumber("toFixed");
+exports._toExponential = formatNumber("toExponential");
+exports._toPrecision = formatNumber("toPrecision");

src/Data/Number.purs

@@ -5,12 +5,34 @@ module Data.Number
   , isNaN
   , infinity
   , isFinite
+  , readInt
+  , readFloat
+  , toFixed
+  , toExponential
+  , toPrecision
   ) where
 
 import Prelude
-
+import Data.Function.Uncurried (Fn4, runFn4)
 import Data.Maybe (Maybe(..))
-import Global as G
+
+-- | Not a number (NaN)
+foreign import nan :: Number
+
+-- | Test whether a number is NaN
+foreign import isNaN :: Number -> Boolean
+
+-- | Positive infinity
+foreign import infinity :: Number
+
+-- | Test whether a number is finite
+foreign import isFinite :: Number -> Boolean
+
+-- | Parse an integer from a `String` in the specified base
+foreign import readInt :: Int -> String -> Number
+
+-- | Parse a floating point value from a `String`
+foreign import readFloat :: String -> Number
 
 -- | Attempt to parse a `Number` using JavaScripts `parseFloat`. Returns
 -- | `Nothing` if the parse fails or if the result is not a finite number.
@@ -40,23 +62,33 @@ import Global as G
 -- | (Just 1.2)
 -- | ```
 fromString :: String -> Maybe Number
-fromString = G.readFloat >>> check
+fromString = readFloat >>> check
   where
     check num | isFinite num = Just num
               | otherwise    = Nothing
 
--- | Not a number (NaN).
-nan :: Number
-nan = G.nan
+foreign import _toFixed :: forall a. Fn4 (String -> a) (String -> a) Int Number a
+
+foreign import _toExponential :: forall a. Fn4 (String -> a) (String -> a) Int Number a
+
+foreign import _toPrecision :: forall a. Fn4 (String -> a) (String -> a) Int Number a
 
--- | Test whether a `Number` is NaN.
-isNaN :: Number -> Boolean
-isNaN = G.isNaN
+-- | Formats Number as a String with limited number of digits after the dot.
+-- | May return `Nothing` when specified number of digits is less than 0 or
+-- | greater than 20. See ECMA-262 for more information.
+toFixed :: Int -> Number -> Maybe String
+toFixed digits n = runFn4 _toFixed (const Nothing) Just digits n
 
--- | Positive infinity.
-infinity :: Number
-infinity = G.infinity
+-- | Formats Number as String in exponential notation limiting number of digits
+-- | after the decimal dot. May return `Nothing` when specified number of
+-- | digits is less than 0 or greater than 20 depending on the implementation.
+-- | See ECMA-262 for more information.
+toExponential :: Int -> Number -> Maybe String
+toExponential digits n = runFn4 _toExponential (const Nothing) Just digits n
 
--- | Test whether a number is finite.
-isFinite :: Number -> Boolean
-isFinite = G.isFinite
+-- | Formats Number as String in fixed-point or exponential notation rounded
+-- | to specified number of significant digits. May return `Nothing` when
+-- | precision is less than 1 or greater than 21 depending on the
+-- | implementation. See ECMA-262 for more information.
+toPrecision :: Int -> Number -> Maybe String
+toPrecision digits n = runFn4 _toPrecision (const Nothing) Just digits n

src/Data/Number/Unsafe.js

@@ -0,0 +1,20 @@
+/* globals exports, JSON */
+"use strict";
+
+exports.unsafeToFixed = function (digits) {
+  return function (n) {
+    return n.toFixed(digits);
+  };
+};
+
+exports.unsafeToExponential = function (digits) {
+  return function (n) {
+    return n.toExponential(digits);
+  };
+};
+
+exports.unsafeToPrecision  = function (digits) {
+  return function (n) {
+    return n.toPrecision(digits);
+  };
+};

src/Data/Number/Unsafe.purs

@@ -0,0 +1,21 @@
+module Data.Number.Unsafe where
+
+-- | Formats Number as a String with limited number of digits after the dot.
+-- |
+-- | May throw RangeError if the number of digits is not within the allowed range
+-- | (standard precision range is 0 to 20, but implementations may change it)
+foreign import unsafeToFixed :: Int -> Number -> String
+
+-- | Formats Number as String in exponential notation limiting number of digits
+-- | after the decimal dot.
+-- |
+-- | May throw RangeError if the number of digits is not within the allowed range
+-- | (standard precision range is 0 to 20, but implementations may change it)
+foreign import unsafeToExponential :: Int -> Number -> String
+
+-- | Formats Number as String in fixed-point or exponential notation rounded
+-- | to specified number of significant digits.
+-- |
+-- | May throw RangeError if the number of digits is not within the allowed range
+-- | (standard precision range is 0 to 100, but implementations may change it)
+foreign import unsafeToPrecision :: Int -> Number -> String

test/Main.purs → test/Test/Main.purs

@@ -3,16 +3,97 @@ module Test.Main where
 import Prelude
 
 import Data.Maybe (Maybe(..), fromMaybe)
-import Data.Number (nan, isNaN, infinity, isFinite, fromString)
+import Effect (Effect)
+import Effect.Console (log)
+
+import Data.Number (readFloat, readInt, isFinite, infinity,
+                    nan, isNaN, fromString,
+                    toPrecision, toExponential, toFixed)
 import Data.Number.Format (precision, fixed, exponential, toStringWith,
                            toString)
 import Data.Number.Approximate (Fraction(..), Tolerance(..), eqRelative,
                                 eqAbsolute, (≅), (≇))
+import Data.Number.Unsafe (unsafeToPrecision, unsafeToExponential, unsafeToFixed)
 
-import Effect (Effect)
-import Effect.Console (log)
-import Test.Assert (assertTrue', assertFalse', assertEqual)
+import Test.Assert (assert, assertTrue', assertFalse', assertEqual)
+
+main :: Effect Unit
+main = do
+  globalsTestCode
+  numbersTestCode
+
+-- Test code for the `purescript-globals` repo before its' Number-related
+-- code was moved into this repo
+globalsTestCode :: Effect Unit
+globalsTestCode = do
+  let num = 12345.6789
+
+  log "nan /= nan"
+  assert $ nan /= nan
+
+  log "not (isNaN 6.0)"
+  assert $ not (isNaN 6.0)
+
+  log "isNaN nan"
+  assert $ isNaN nan
+
+  log "infinity > 0.0"
+  assert $ infinity > 0.0
+
+  log "-infinity < 0.0"
+  assert $ -infinity < 0.0
+
+  log "not (isFinite infinity)"
+  assert $ not (isFinite infinity)
+
+  log "isFinite 0.0"
+  assert $ isFinite 0.0
 
+  log "readInt 16 \"0xFF\" == 255.0"
+  assert $ readInt 16 "0xFF" == 255.0
+
+  log "readInt 10 \"3.5\" == 3.0"
+  assert $ readInt 10 "3.5" == 3.0
+
+  log "readFloat \"3.5\" == 3.5"
+  assert $ readFloat "3.5" == 3.5
+
+  -- note the rounding
+  log $ "unsafeToFixed 1" <> (show num) <> " == \"12345.7\""
+  assert $ unsafeToFixed 1 num == "12345.7"
+
+  -- padded with zeros
+  log $ "unsafeToFixed 6" <> (show num) <> " == \"12345.678900\""
+  assert $ unsafeToFixed 6 num == "12345.678900"
+
+  log $ "unsafeToExponential 4" <> (show num) <> " == \"1.2346e+4\""
+  assert $ unsafeToExponential 4 num == "1.2346e+4"
+
+  log $ "unsafeToPrecision 3" <> (show num) <> " == \"1.23e+4\""
+  assert $ unsafeToPrecision 3 num == "1.23e+4"
+
+  log $ "unsafeToPrecision 6" <> (show num) <> " == \"12345.7\""
+  assert $ unsafeToPrecision 6 num == "12345.7"
+
+  -- note the rounding
+  log $ "toFixed 1" <> (show num) <> " == (Just \"12345.7\")"
+  assert $ toFixed 1 num == Just "12345.7"
+
+  -- padded with zeros
+  log $ "toFixed 6" <> (show num) <> " == (Just \"12345.678900\")"
+  assert $ toFixed 6 num == Just "12345.678900"
+
+  log $ "toExponential 4" <> (show num) <> " == (Just \"1.2346e+4\")"
+  assert $ toExponential 4 num == Just "1.2346e+4"
+
+  log $ "toPrecision 3" <> (show num) <> " == (Just \"1.23e+4\")"
+  assert $ toPrecision 3 num == Just "1.23e+4"
+
+  log $ "toPrecision 6" <> (show num) <> " == (Just \"12345.7\")"
+  assert $ toPrecision 6 num == Just "12345.7"
+
+-- Test code originally in this repo before parts of deprecated
+-- `purescript-globals` repo was moved to this repo.
 
 -- | Comparison up to 10% relative error.
 eqRelative' :: Number -> Number -> Boolean
@@ -26,8 +107,8 @@ eqAbsolute' = eqAbsolute (Tolerance 0.1)
 
 infix 1 eqAbsolute' as =~=
 
-main :: Effect Unit
-main = do
+numbersTestCode :: Effect Unit
+numbersTestCode = do
 
 
   log "Data.Number.fromString"