Add js BigInts

changelog.md

@@ -56,7 +56,7 @@
 - `writeStackTrace` is available in JS backend now.
 
 - `strscans.scanf` now supports parsing single characters.
-- `strscans.scanTuple` added which uses `strscans.scanf` internally, returning a tuple which can be unpacked for easier usage of `scanf`. 
+- `strscans.scanTuple` added which uses `strscans.scanf` internally, returning a tuple which can be unpacked for easier usage of `scanf`.
 
 - Added `setutils.toSet` that can take any iterable and convert it to a built-in set,
   if the iterable yields a built-in settable type.
@@ -66,6 +66,8 @@
 - `echo` and `debugEcho` will now raise `IOError` if writing to stdout fails.  Previous behavior
   silently ignored errors.  See #16366.  Use `-d:nimLegacyEchoNoRaise` for previous behavior.
 
+- Add `jsbigints` module, arbitrary precision integers for JavaScript target.
+
 - Added new operations for singly- and doubly linked lists: `lists.toSinglyLinkedList`
   and `lists.toDoublyLinkedList` convert from `openArray`s; `lists.copy` implements
   shallow copying; `lists.add` concatenates two lists - an O(1) variation that consumes

lib/js/jsbigints.nim

@@ -0,0 +1,127 @@
+## Arbitrary precision integers.
+## * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt
+when not defined(js) and not defined(nimdoc):
+  {.fatal: "Module jsbigints is designed to be used with the JavaScript backend.".}
+
+type JsBigInt* = ref object of JsRoot ## Arbitrary precision integer for JavaScript target.
+
+func newBigInt*(integer: cstring or SomeInteger): JsBigInt {.importjs: "BigInt(#)".}
+  ## Constructor for `JsBigInt`.
+
+func toLocaleString*(this: JsBigInt): cstring {.importjs: "#.$1()".}
+  ## https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/toLocaleString
+
+func toLocaleString*(this: JsBigInt; locales: cstring): cstring {.importjs: "#.$1(#)".}
+  ## https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/toLocaleString
+
+func toLocaleString*(this: JsBigInt; locales: openArray[cstring]): cstring {.importjs: "#.$1(#)".}
+  ## https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/toLocaleString
+
+func toString*(this: JsBigInt; radix: int): cstring {.importjs: "#.$1(#)".}
+  ## https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/toString
+
+func `$`*(this: JsBigInt): cstring {.importjs: "#.toString()".}
+  ## https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/toString
+
+func asIntN*(width: int; bigInteger: JsBigInt): int {.importjs: "BigInt.$1(#, #)".}
+  ## https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/asIntN
+
+func asUintN*(width: int; bigInteger: JsBigInt): int {.importjs: "BigInt.$1(#, #)".}
+  ## https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/asUintN
+
+func `+`*(x, y: JsBigInt): JsBigInt {.importjs: "(# $1 #)".}
+
+func `-`*(x, y: JsBigInt): JsBigInt {.importjs: "(# $1 #)".}
+
+func `*`*(x, y: JsBigInt): JsBigInt {.importjs: "(# $1 #)".}
+
+func `div`*(x, y: JsBigInt): JsBigInt {.importjs: "(# / #)".}
+   ## Same as `div` but for `JsBigInt`.
+
+func `mod`*(x, y: JsBigInt): JsBigInt {.importjs: "(# % #)".}
+  ## Same as `mod` but for `JsBigInt` (uses JavaScript `BigInt() % BigInt()`).
+
+func `+=`*(x, y: JsBigInt): JsBigInt {.importjs: "(# $1 #)", discardable.}
+
+func `-=`*(x, y: JsBigInt): JsBigInt {.importjs: "(# $1 #)", discardable.}
+
+func `*=`*(x, y: JsBigInt): JsBigInt {.importjs: "(# $1 #)", discardable.}
+
+func `/=`*(x, y: JsBigInt): JsBigInt {.importjs: "(# $1 #)", discardable.}
+
+func `mod=`*(x, y: JsBigInt): JsBigInt {.importjs: "(# $1 #)", discardable.}
+
+func `inc`*(x: JsBigInt): JsBigInt {.importjs: "(++#)", discardable.}
+  ## Same as `inc` but for `JsBigInt` (uses JavaScript `++BigInt()`).
+
+func `dec`*(x: JsBigInt): JsBigInt {.importjs: "(--#)", discardable.}
+  ## Same as `dec` but for `JsBigInt` (uses JavaScript `--BigInt()`).
+
+func `<`*(x, y: JsBigInt): bool {.importjs: "(# $1 #)".}
+
+func `<=`*(x, y: JsBigInt): bool {.importjs: "(# $1 #)".}
+
+func `==`*(x, y: JsBigInt): bool {.importjs: "(# === #)".}
+
+func `**`*(x, y: JsBigInt): JsBigInt {.importjs: "((#) $1 #)".}
+
+func `and`*(x, y: JsBigInt): JsBigInt {.importjs: "(# && #)".}
+
+func `or`*(x, y: JsBigInt): JsBigInt {.importjs: "(# || #)".}
+
+func `not`*(x: JsBigInt): JsBigInt {.importjs: "(!#)".}
+
+func `in`*(x, y: JsBigInt): JsBigInt {.importjs: "(# $1 #)".}
+
+func `-`*(a: JsBigInt): JsBigInt {.importjs: "($1#)".}
+
+func `xor`*(x, y: JsBigInt): JsBigInt {.importjs: "(# ^ #)".}
+
+func `shl`*(a, b: JsBigInt): JsBigInt {.importjs: "(# << #)".}
+
+func `shr`*(a, b: JsBigInt): JsBigInt {.importjs: "(# >> #)".}
+
+func inc*(a, b: JsBigInt): JsBigInt {.importjs: "(# += #)", discardable.}
+
+func dec*(a, b: JsBigInt): JsBigInt {.importjs: "(# -= #)", discardable.}
+
+func `+`*(a: JsBigInt): JsBigInt {.error.} # Can not be used by design.
+  ## https://github.com/tc39/proposal-bigint/blob/master/ADVANCED.md#dont-break-asmjs
+
+
+runnableExamples:
+  let big1: JsBigInt = newBigInt(2147483647)
+  let big2: JsBigInt = newBigInt("666".cstring)
+  var big3: JsBigInt = newBigInt("2".cstring)
+  doAssert big1 != big2
+  doAssert big1 > big2
+  doAssert big1 >= big2
+  doAssert big2 < big1
+  doAssert big2 <= big1
+  doAssert not(big1 == big2)
+  inc big3
+  doAssert big3 == newBigInt(3)
+  dec big3
+  doAssert big3 == newBigInt(2)
+  inc big3, newBigInt(420)
+  doAssert big3 == newBigInt(422)
+  dec big3, newBigInt(420)
+  doAssert big3 == newBigInt(2)
+  doAssert (big3 xor big2) == newBigInt(664)
+  doAssert (big1 mod big2) == newBigInt("613".cstring)
+  doAssert -big1 == newBigInt("-2147483647".cstring)
+  doAssert big1 div big2 == newBigInt("3224449".cstring)
+  doAssert big1 + big2 == newBigInt("2147484313".cstring)
+  doAssert big1 - big2 == newBigInt("2147482981".cstring)
+  doAssert big1 shl big3 == newBigInt("8589934588".cstring)
+  doAssert big1 shr big3 == newBigInt("536870911".cstring)
+  doAssert big1 * big2 == newBigInt("1430224108902".cstring)
+  doAssert big1.toLocaleString("EN".cstring) == "2,147,483,647".cstring
+  doAssert big1.toLocaleString(["EN".cstring, "ES".cstring]) == "2,147,483,647".cstring
+  doAssert $big1 == "2147483647".cstring
+  doAssert big1.toString(10) == "2147483647".cstring
+  doAssert big1.toString(2) == "1111111111111111111111111111111".cstring
+  doAssert big2 ** big3 == newBigInt(443556)
+  discard newBigInt("999999999999999999999999999999999999999999999999999999999999999999999999999999999999999".cstring)
+  discard newBigInt("0".cstring)
+  discard newBigInt("-999999999999999999999999999999999999999999999999999999999999999999999999999999999999999".cstring)