1 files changed, 23 insertions, 22 deletions

diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux
index 1b2fc62d7..773300f31 100644
--- a/stdlib/source/lux/data/number.lux
+++ b/stdlib/source/lux/data/number.lux
@@ -12,8 +12,9 @@
    [data
     ["e" error]
     [maybe]
-    [bit]
-    [text]]])
+    [text]]]
+  [/
+   [i64]])
 
 ## [Structures]
 (do-template [<type> <test>]
@@ -735,7 +736,7 @@
 
 (def: (make-digits _)
   (-> Any Digits)
-  ("lux array new" bit.width))
+  ("lux array new" i64.width))
 
 (def: (digits-get idx digits)
   (-> Nat Digits Nat)
@@ -775,7 +776,7 @@
 
 (def: (digits-to-text digits)
   (-> Digits Text)
-  (loop [idx (dec bit.width)
+  (loop [idx (dec i64.width)
          all-zeroes? true
          output ""]
     (if (i/>= 0 (:coerce Int idx))
@@ -794,7 +795,7 @@
 
 (def: (digits-add param subject)
   (-> Digits Digits Digits)
-  (loop [idx (dec bit.width)
+  (loop [idx (dec i64.width)
          carry +0
          output (make-digits [])]
     (if (i/>= 0 (:coerce Int idx))
@@ -810,7 +811,7 @@
 (def: (text-to-digits input)
   (-> Text (Maybe Digits))
   (let [length ("lux text size" input)]
-    (if (n/<= bit.width length)
+    (if (n/<= i64.width length)
       (loop [idx +0
              output (make-digits [])]
         (if (n/< length idx)
@@ -828,7 +829,7 @@
 (def: (digits-lt param subject)
   (-> Digits Digits Bool)
   (loop [idx +0]
-    (and (n/< bit.width idx)
+    (and (n/< i64.width idx)
          (let [pd (digits-get idx param)
                sd (digits-get idx subject)]
            (if (n/= pd sd)
@@ -849,7 +850,7 @@
 
 (def: (digits-sub! param subject)
   (-> Digits Digits Digits)
-  (loop [idx (dec bit.width)
+  (loop [idx (dec i64.width)
          output subject]
     (if (i/>= 0 (.int idx))
       (recur (dec idx)
@@ -859,13 +860,13 @@
 (structure: #export _ (Codec Text Rev)
   (def: (encode input)
     (let [input (:coerce Nat input)
-          last-idx (dec bit.width)]
+          last-idx (dec i64.width)]
       (if (n/= +0 input)
         ".0"
         (loop [idx last-idx
                digits (make-digits [])]
           (if (i/>= 0 (:coerce Int idx))
-            (if (bit.set? idx input)
+            (if (i64.set? idx input)
               (let [digits' (digits-add (digits-power (n/- idx last-idx))
                                         digits)]
                 (recur (dec idx)
@@ -884,7 +885,7 @@
                     _
                     false)]
       (if (and dotted?
-               (n/<= (inc bit.width) length))
+               (n/<= (inc i64.width) length))
         (case (|> ("lux text clip" input +1 length)
                   maybe.assume
                   text-to-digits)
@@ -892,14 +893,14 @@
           (loop [digits digits
                  idx +0
                  output +0]
-            (if (n/< bit.width idx)
+            (if (n/< i64.width idx)
               (let [power (digits-power idx)]
                 (if (digits-lt power digits)
                   ## Skip power
                   (recur digits (inc idx) output)
                   (recur (digits-sub! power digits)
                          (inc idx)
-                         (bit.set (n/- idx (dec bit.width)) output))))
+                         (i64.set (n/- idx (dec i64.width)) output))))
               (#e.Success (:coerce Rev output))))
 
           #.None
@@ -940,26 +941,26 @@
              (let [sign (:: Number<Frac> signum input)
                    input (:: Number<Frac> abs input)
                    exponent ("lux math floor" (log2 input))
-                   exponent-mask (|> +1 (bit.left-shift exponent-size) dec) 
+                   exponent-mask (|> +1 (i64.left-shift exponent-size) dec) 
                    mantissa (|> input
                                 ## Normalize
                                 (f// ("lux math pow" 2.0 exponent))
                                 ## Make it int-equivalent
                                 (f/* ("lux math pow" 2.0 52.0)))
                    sign-bit (if (f/= -1.0 sign) +1 +0)
-                   exponent-bits (|> exponent frac-to-int .nat (n/+ double-bias) (bit.and exponent-mask))
+                   exponent-bits (|> exponent frac-to-int .nat (n/+ double-bias) (i64.and exponent-mask))
                    mantissa-bits (|> mantissa frac-to-int .nat)]
-               ($_ bit.or
-                   (bit.left-shift +63 sign-bit)
-                   (bit.left-shift mantissa-size exponent-bits)
-                   (bit.clear mantissa-size mantissa-bits)))
+               ($_ i64.or
+                   (i64.left-shift +63 sign-bit)
+                   (i64.left-shift mantissa-size exponent-bits)
+                   (i64.clear mantissa-size mantissa-bits)))
              )))
 
 (do-template [<getter> <mask> <size> <offset>]
-  [(def: <mask> (|> +1 (bit.left-shift <size>) dec (bit.left-shift <offset>)))
+  [(def: <mask> (|> +1 (i64.left-shift <size>) dec (i64.left-shift <offset>)))
    (def: (<getter> input)
      (-> (I64 Any) I64)
-     (|> input (bit.and <mask>) (bit.logical-right-shift <offset>) i64))]
+     (|> input (i64.and <mask>) (i64.logical-right-shift <offset>) i64))]
 
   [mantissa mantissa-mask mantissa-size +0]
   [exponent exponent-mask exponent-size mantissa-size]
@@ -984,7 +985,7 @@
             (f/* -1.0 0.0))
 
           ## else
-          (let [normalized (|> M (bit.set mantissa-size)
+          (let [normalized (|> M (i64.set mantissa-size)
                                .int int-to-frac
                                (f// ("lux math pow" 2.0 52.0)))
                 power (|> E (n/- double-bias)