aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--luxc/src/lux/analyser/proc/common.clj135
-rw-r--r--luxc/src/lux/compiler/jvm/proc/common.clj117
-rw-r--r--luxc/src/lux/type.clj13
-rw-r--r--luxc/src/lux/type/host.clj5
-rw-r--r--stdlib/source/lux.lux328
-rw-r--r--stdlib/source/lux/concurrency/actor.lux4
-rw-r--r--stdlib/source/lux/concurrency/promise.lux4
-rw-r--r--stdlib/source/lux/concurrency/semaphore.lux10
-rw-r--r--stdlib/source/lux/control/comonad.lux2
-rw-r--r--stdlib/source/lux/control/monad.lux2
-rw-r--r--stdlib/source/lux/control/parser.lux4
-rw-r--r--stdlib/source/lux/control/pipe.lux10
-rw-r--r--stdlib/source/lux/data/bit.lux83
-rw-r--r--stdlib/source/lux/data/coll/array.lux31
-rw-r--r--stdlib/source/lux/data/coll/bits.lux24
-rw-r--r--stdlib/source/lux/data/coll/dictionary/ordered.lux4
-rw-r--r--stdlib/source/lux/data/coll/dictionary/unordered.lux26
-rw-r--r--stdlib/source/lux/data/coll/list.lux32
-rw-r--r--stdlib/source/lux/data/coll/sequence.lux18
-rw-r--r--stdlib/source/lux/data/coll/stream.lux4
-rw-r--r--stdlib/source/lux/data/color.lux26
-rw-r--r--stdlib/source/lux/data/format/css.lux12
-rw-r--r--stdlib/source/lux/data/format/xml.lux2
-rw-r--r--stdlib/source/lux/data/number.lux158
-rw-r--r--stdlib/source/lux/data/number/complex.lux8
-rw-r--r--stdlib/source/lux/data/text.lux2
-rw-r--r--stdlib/source/lux/data/text/lexer.lux8
-rw-r--r--stdlib/source/lux/data/text/regex.lux6
-rw-r--r--stdlib/source/lux/lang/syntax.lux28
-rw-r--r--stdlib/source/lux/lang/type.lux6
-rw-r--r--stdlib/source/lux/lang/type/check.lux10
-rw-r--r--stdlib/source/lux/macro.lux8
-rw-r--r--stdlib/source/lux/macro/code.lux2
-rw-r--r--stdlib/source/lux/macro/poly.lux18
-rw-r--r--stdlib/source/lux/macro/poly/eq.lux2
-rw-r--r--stdlib/source/lux/macro/poly/functor.lux8
-rw-r--r--stdlib/source/lux/macro/poly/json.lux18
-rw-r--r--stdlib/source/lux/macro/syntax.lux2
-rw-r--r--stdlib/source/lux/math.lux2
-rw-r--r--stdlib/source/lux/math/random.lux102
-rw-r--r--stdlib/source/lux/test.lux81
-rw-r--r--stdlib/source/lux/time/date.lux12
-rw-r--r--stdlib/source/lux/time/instant.lux36
-rw-r--r--stdlib/source/lux/type/implicit.lux4
-rw-r--r--stdlib/source/lux/type/object/interface.lux10
-rw-r--r--stdlib/source/lux/type/resource.lux2
-rw-r--r--stdlib/source/lux/type/unit.lux18
-rw-r--r--stdlib/source/lux/world/blob.jvm.lux104
-rw-r--r--stdlib/source/lux/world/console.lux6
-rw-r--r--stdlib/source/lux/world/file.lux4
-rw-r--r--stdlib/source/lux/world/net/tcp.jvm.lux10
-rw-r--r--stdlib/source/lux/world/net/udp.jvm.lux10
-rw-r--r--stdlib/test/test/lux.lux30
-rw-r--r--stdlib/test/test/lux/concurrency/atom.lux4
-rw-r--r--stdlib/test/test/lux/concurrency/frp.lux6
-rw-r--r--stdlib/test/test/lux/concurrency/semaphore.lux8
-rw-r--r--stdlib/test/test/lux/concurrency/stm.lux47
-rw-r--r--stdlib/test/test/lux/control/continuation.lux14
-rw-r--r--stdlib/test/test/lux/control/pipe.lux6
-rw-r--r--stdlib/test/test/lux/control/reader.lux2
-rw-r--r--stdlib/test/test/lux/control/region.lux6
-rw-r--r--stdlib/test/test/lux/control/state.lux12
-rw-r--r--stdlib/test/test/lux/control/writer.lux2
-rw-r--r--stdlib/test/test/lux/data/bit.lux4
-rw-r--r--stdlib/test/test/lux/data/coll/array.lux6
-rw-r--r--stdlib/test/test/lux/data/coll/bits.lux2
-rw-r--r--stdlib/test/test/lux/data/coll/dictionary/unordered.lux10
-rw-r--r--stdlib/test/test/lux/data/coll/list.lux20
-rw-r--r--stdlib/test/test/lux/data/coll/queue.lux4
-rw-r--r--stdlib/test/test/lux/data/coll/queue/priority.lux4
-rw-r--r--stdlib/test/test/lux/data/coll/sequence.lux14
-rw-r--r--stdlib/test/test/lux/data/coll/stack.lux4
-rw-r--r--stdlib/test/test/lux/data/coll/stream.lux30
-rw-r--r--stdlib/test/test/lux/data/coll/tree/rose.lux2
-rw-r--r--stdlib/test/test/lux/data/color.lux2
-rw-r--r--stdlib/test/test/lux/data/error.lux8
-rw-r--r--stdlib/test/test/lux/data/lazy.lux12
-rw-r--r--stdlib/test/test/lux/data/number.lux2
-rw-r--r--stdlib/test/test/lux/data/number/complex.lux6
-rw-r--r--stdlib/test/test/lux/io.lux2
-rw-r--r--stdlib/test/test/lux/lang/syntax.lux6
-rw-r--r--stdlib/test/test/lux/lang/type/check.lux4
-rw-r--r--stdlib/test/test/lux/type/implicit.lux2
-rw-r--r--stdlib/test/test/lux/type/object/interface.lux22
-rw-r--r--stdlib/test/test/lux/type/object/protocol.lux4
-rw-r--r--stdlib/test/test/lux/world/blob.lux8
-rw-r--r--stdlib/test/test/lux/world/file.lux4
87 files changed, 944 insertions, 956 deletions
diff --git a/luxc/src/lux/analyser/proc/common.clj b/luxc/src/lux/analyser/proc/common.clj
index 589ce42e2..19d833cc2 100644
--- a/luxc/src/lux/analyser/proc/common.clj
+++ b/luxc/src/lux/analyser/proc/common.clj
@@ -122,51 +122,71 @@
(&/|list)))))))
(do-template [<name> <op>]
- (defn <name> [analyse exo-type ?values]
- (|do [:let [(&/$Cons input (&/$Cons mask (&/$Nil))) ?values]
- =mask (&&/analyse-1 analyse &type/Nat mask)
- =input (&&/analyse-1 analyse &type/Nat input)
- _ (&type/check exo-type &type/Nat)
- _cursor &/cursor]
- (return (&/|list (&&/|meta exo-type _cursor
- (&&/$proc (&/T ["bit" <op>]) (&/|list =input =mask) (&/|list)))))))
+ (let [inputT (&/$Apply &type/Top &type/I64)
+ outputT &type/I64]
+ (defn <name> [analyse exo-type ?values]
+ (|do [:let [(&/$Cons mask (&/$Cons input (&/$Nil))) ?values]
+ =mask (&&/analyse-1 analyse inputT mask)
+ =input (&&/analyse-1 analyse inputT input)
+ _ (&type/check exo-type outputT)
+ _cursor &/cursor]
+ (return (&/|list (&&/|meta exo-type _cursor
+ (&&/$proc (&/T ["i64" <op>]) (&/|list =input =mask) (&/|list))))))))
- ^:private analyse-bit-and "and"
- ^:private analyse-bit-or "or"
- ^:private analyse-bit-xor "xor"
+ ^:private analyse-i64-and "and"
+ ^:private analyse-i64-or "or"
+ ^:private analyse-i64-xor "xor"
)
-(do-template [<name> <op> <type>]
- (defn <name> [analyse exo-type ?values]
- (|do [:let [(&/$Cons input (&/$Cons shift (&/$Nil))) ?values]
- =shift (&&/analyse-1 analyse &type/Nat shift)
- =input (&&/analyse-1 analyse <type> input)
- _ (&type/check exo-type <type>)
- _cursor &/cursor]
- (return (&/|list (&&/|meta exo-type _cursor
- (&&/$proc (&/T ["bit" <op>]) (&/|list =input =shift) (&/|list)))))))
+(do-template [<name> <op>]
+ (let [inputT (&/$Apply &type/Top &type/I64)
+ outputT &type/I64]
+ (defn <name> [analyse exo-type ?values]
+ (|do [:let [(&/$Cons shift (&/$Cons input (&/$Nil))) ?values]
+ =shift (&&/analyse-1 analyse &type/Nat shift)
+ =input (&&/analyse-1 analyse inputT input)
+ _ (&type/check exo-type outputT)
+ _cursor &/cursor]
+ (return (&/|list (&&/|meta exo-type _cursor
+ (&&/$proc (&/T ["i64" <op>]) (&/|list =input =shift) (&/|list))))))))
- ^:private analyse-bit-left-shift "left-shift" &type/Nat
- ^:private analyse-bit-arithmetic-right-shift "arithmetic-right-shift" &type/Int
- ^:private analyse-bit-logical-right-shift "logical-right-shift" &type/Nat
+ ^:private analyse-i64-left-shift "left-shift"
+ ^:private analyse-i64-arithmetic-right-shift "arithmetic-right-shift"
+ ^:private analyse-i64-logical-right-shift "logical-right-shift"
)
(do-template [<name> <proc> <input-type> <output-type>]
- (defn <name> [analyse exo-type ?values]
- (|do [:let [(&/$Cons x (&/$Cons y (&/$Nil))) ?values]
- =x (&&/analyse-1 analyse <input-type> x)
- =y (&&/analyse-1 analyse <input-type> y)
- _ (&type/check exo-type <output-type>)
- _cursor &/cursor]
- (return (&/|list (&&/|meta exo-type _cursor
- (&&/$proc (&/T <proc>) (&/|list =x =y) (&/|list)))))))
+ (let [inputT <input-type>
+ outputT <output-type>]
+ (defn <name> [analyse exo-type ?values]
+ (|do [:let [(&/$Cons paramC (&/$Cons subjectC (&/$Nil))) ?values]
+ paramA (&&/analyse-1 analyse <input-type> paramC)
+ subjectA (&&/analyse-1 analyse <input-type> subjectC)
+ _ (&type/check exo-type <output-type>)
+ _cursor &/cursor]
+ (return (&/|list (&&/|meta exo-type _cursor
+ (&&/$proc (&/T <proc>) (&/|list subjectA paramA) (&/|list))))))))
+
+ ^:private analyse-i64-eq ["i64" "="] (&/$Apply &type/Top &type/I64) &type/Bool
+ ^:private analyse-i64-add ["i64" "+"] (&/$Apply &type/Top &type/I64) &type/I64
+ ^:private analyse-i64-sub ["i64" "-"] (&/$Apply &type/Top &type/I64) &type/I64
+ )
+
+(do-template [<name> <proc> <input-type> <output-type>]
+ (let [inputT <input-type>
+ outputT <output-type>]
+ (defn <name> [analyse exo-type ?values]
+ (|do [:let [(&/$Cons x (&/$Cons y (&/$Nil))) ?values]
+ =x (&&/analyse-1 analyse <input-type> x)
+ =y (&&/analyse-1 analyse <input-type> y)
+ _ (&type/check exo-type <output-type>)
+ _cursor &/cursor]
+ (return (&/|list (&&/|meta exo-type _cursor
+ (&&/$proc (&/T <proc>) (&/|list =x =y) (&/|list))))))))
- ^:private analyse-int-add ["int" "+"] &type/Int &type/Int
- ^:private analyse-int-sub ["int" "-"] &type/Int &type/Int
^:private analyse-int-mul ["int" "*"] &type/Int &type/Int
^:private analyse-int-div ["int" "/"] &type/Int &type/Int
^:private analyse-int-rem ["int" "%"] &type/Int &type/Int
- ^:private analyse-int-eq ["int" "="] &type/Int &type/Bool
^:private analyse-int-lt ["int" "<"] &type/Int &type/Bool
^:private analyse-frac-add ["frac" "+"] &type/Frac &type/Frac
@@ -207,9 +227,6 @@
(return (&/|list (&&/|meta exo-type _cursor
(&&/$proc (&/T <op>) (&/|list) (&/|list)))))))
- ^:private analyse-int-min &type/Int ["int" "min"]
- ^:private analyse-int-max &type/Int ["int" "max"]
-
^:private analyse-frac-smallest &type/Frac ["frac" "smallest"]
^:private analyse-frac-min &type/Frac ["frac" "min"]
^:private analyse-frac-max &type/Frac ["frac" "max"]
@@ -227,14 +244,13 @@
(return (&/|list (&&/|meta exo-type _cursor
(&&/$proc (&/T <op>) (&/|list =x) (&/|list)))))))
- ^:private analyse-int-char &type/Int &type/Text ["int" "char"]
-
- ^:private analyse-int-to-frac &type/Int &type/Frac ["int" "to-frac"]
- ^:private analyse-frac-to-int &type/Frac &type/Int ["frac" "to-int"]
+ ^:private analyse-int-char &type/Int &type/Text ["int" "char"]
+ ^:private analyse-int-frac &type/Int &type/Frac ["int" "frac"]
+ ^:private analyse-frac-int &type/Frac &type/Int ["frac" "int"]
- ^:private analyse-io-log &type/Text &type/Top ["io" "log"]
- ^:private analyse-io-error &type/Text &type/Bottom ["io" "error"]
- ^:private analyse-io-exit &type/Int &type/Bottom ["io" "exit"]
+ ^:private analyse-io-log &type/Text &type/Top ["io" "log"]
+ ^:private analyse-io-error &type/Text &type/Bottom ["io" "error"]
+ ^:private analyse-io-exit &type/Int &type/Bottom ["io" "exit"]
)
(defn ^:private analyse-io-current-time [analyse exo-type ?values]
@@ -399,12 +415,12 @@
(return (&/|list (&&/|meta exo-type _cursor
(&&/$proc (&/T ["box" "write"]) (&/|list valueA boxA) (&/|list)))))))))))
-(defn ^:private analyse-process-parallelism-level [analyse exo-type ?values]
+(defn ^:private analyse-process-parallelism [analyse exo-type ?values]
(|do [:let [(&/$Nil) ?values]
_ (&type/check exo-type &type/Nat)
_cursor &/cursor]
(return (&/|list (&&/|meta exo-type _cursor
- (&&/$proc (&/T ["process" "parallelism-level"]) (&/|list) (&/|list)))))))
+ (&&/$proc (&/T ["process" "parallelism"]) (&/|list) (&/|list)))))))
(defn ^:private analyse-process-schedule [analyse exo-type ?values]
(|do [:let [(&/$Cons ?milliseconds (&/$Cons ?procedure (&/$Nil))) ?values]
@@ -440,30 +456,27 @@
"lux text char" (analyse-text-char analyse exo-type ?values)
"lux text contains?" (analyse-text-contains? analyse exo-type ?values)
- "lux bit and" (analyse-bit-and analyse exo-type ?values)
- "lux bit or" (analyse-bit-or analyse exo-type ?values)
- "lux bit xor" (analyse-bit-xor analyse exo-type ?values)
- "lux bit left-shift" (analyse-bit-left-shift analyse exo-type ?values)
- "lux bit arithmetic-right-shift" (analyse-bit-arithmetic-right-shift analyse exo-type ?values)
- "lux bit logical-right-shift" (analyse-bit-logical-right-shift analyse exo-type ?values)
-
"lux array new" (analyse-array-new analyse exo-type ?values)
"lux array get" (analyse-array-get analyse exo-type ?values)
"lux array put" (analyse-array-put analyse exo-type ?values)
"lux array remove" (analyse-array-remove analyse exo-type ?values)
"lux array size" (analyse-array-size analyse exo-type ?values)
+ "lux i64 and" (analyse-i64-and analyse exo-type ?values)
+ "lux i64 or" (analyse-i64-or analyse exo-type ?values)
+ "lux i64 xor" (analyse-i64-xor analyse exo-type ?values)
+ "lux i64 left-shift" (analyse-i64-left-shift analyse exo-type ?values)
+ "lux i64 arithmetic-right-shift" (analyse-i64-arithmetic-right-shift analyse exo-type ?values)
+ "lux i64 logical-right-shift" (analyse-i64-logical-right-shift analyse exo-type ?values)
+ "lux i64 +" (analyse-i64-add analyse exo-type ?values)
+ "lux i64 -" (analyse-i64-sub analyse exo-type ?values)
+ "lux i64 =" (analyse-i64-eq analyse exo-type ?values)
- "lux int +" (analyse-int-add analyse exo-type ?values)
- "lux int -" (analyse-int-sub analyse exo-type ?values)
"lux int *" (analyse-int-mul analyse exo-type ?values)
"lux int /" (analyse-int-div analyse exo-type ?values)
"lux int %" (analyse-int-rem analyse exo-type ?values)
- "lux int =" (analyse-int-eq analyse exo-type ?values)
"lux int <" (analyse-int-lt analyse exo-type ?values)
- "lux int min" (analyse-int-min analyse exo-type ?values)
- "lux int max" (analyse-int-max analyse exo-type ?values)
- "lux int to-frac" (analyse-int-to-frac analyse exo-type ?values)
+ "lux int frac" (analyse-int-frac analyse exo-type ?values)
"lux int char" (analyse-int-char analyse exo-type ?values)
"lux frac +" (analyse-frac-add analyse exo-type ?values)
@@ -481,7 +494,7 @@
"lux frac not-a-number" (analyse-frac-not-a-number analyse exo-type ?values)
"lux frac positive-infinity" (analyse-frac-positive-infinity analyse exo-type ?values)
"lux frac negative-infinity" (analyse-frac-negative-infinity analyse exo-type ?values)
- "lux frac to-int" (analyse-frac-to-int analyse exo-type ?values)
+ "lux frac int" (analyse-frac-int analyse exo-type ?values)
"lux math cos" (analyse-math-cos analyse exo-type ?values)
"lux math sin" (analyse-math-sin analyse exo-type ?values)
@@ -499,7 +512,7 @@
"lux atom read" (analyse-atom-read analyse exo-type ?values)
"lux atom compare-and-swap" (analyse-atom-compare-and-swap analyse exo-type ?values)
- "lux process parallelism-level" (analyse-process-parallelism-level analyse exo-type ?values)
+ "lux process parallelism" (analyse-process-parallelism analyse exo-type ?values)
"lux process schedule" (analyse-process-schedule analyse exo-type ?values)
;; else
diff --git a/luxc/src/lux/compiler/jvm/proc/common.clj b/luxc/src/lux/compiler/jvm/proc/common.clj
index c671c5328..571bbadc7 100644
--- a/luxc/src/lux/compiler/jvm/proc/common.clj
+++ b/luxc/src/lux/compiler/jvm/proc/common.clj
@@ -125,9 +125,9 @@
&&/wrap-long)]]
(return nil)))
- ^:private compile-bit-and Opcodes/LAND
- ^:private compile-bit-or Opcodes/LOR
- ^:private compile-bit-xor Opcodes/LXOR
+ ^:private compile-i64-and Opcodes/LAND
+ ^:private compile-i64-or Opcodes/LOR
+ ^:private compile-i64-xor Opcodes/LXOR
)
(do-template [<name> <op>]
@@ -145,9 +145,9 @@
&&/wrap-long)]]
(return nil)))
- ^:private compile-bit-left-shift Opcodes/LSHL
- ^:private compile-bit-arithmetic-right-shift Opcodes/LSHR
- ^:private compile-bit-logical-right-shift Opcodes/LUSHR
+ ^:private compile-i64-left-shift Opcodes/LSHL
+ ^:private compile-i64-arithmetic-right-shift Opcodes/LSHR
+ ^:private compile-i64-logical-right-shift Opcodes/LUSHR
)
(defn ^:private compile-lux-is [compile ?values special-args]
@@ -191,8 +191,9 @@
<wrap>)]]
(return nil)))
- ^:private compile-int-add Opcodes/LADD &&/unwrap-long &&/wrap-long
- ^:private compile-int-sub Opcodes/LSUB &&/unwrap-long &&/wrap-long
+ ^:private compile-i64-add Opcodes/LADD &&/unwrap-long &&/wrap-long
+ ^:private compile-i64-sub Opcodes/LSUB &&/unwrap-long &&/wrap-long
+
^:private compile-int-mul Opcodes/LMUL &&/unwrap-long &&/wrap-long
^:private compile-int-div Opcodes/LDIV &&/unwrap-long &&/wrap-long
^:private compile-int-rem Opcodes/LREM &&/unwrap-long &&/wrap-long
@@ -227,61 +228,49 @@
(.visitLabel $end))]]
(return nil)))
- ^:private compile-int-eq Opcodes/LCMP 0 &&/unwrap-long
+ ^:private compile-i64-eq Opcodes/LCMP 0 &&/unwrap-long
+
^:private compile-int-lt Opcodes/LCMP -1 &&/unwrap-long
^:private compile-frac-eq Opcodes/DCMPG 0 &&/unwrap-double
^:private compile-frac-lt Opcodes/DCMPG -1 &&/unwrap-double
)
-(do-template [<name> <instr> <wrapper>]
+(do-template [<name> <instr>]
(defn <name> [compile ?values special-args]
(|do [:let [(&/$Nil) ?values]
^MethodVisitor *writer* &/get-writer
:let [_ (doto *writer*
- <instr>
- <wrapper>)]]
+ (.visitLdcInsn <instr>)
+ &&/wrap-double)]]
(return nil)))
- ^:private compile-int-min (.visitLdcInsn Long/MIN_VALUE) &&/wrap-long
- ^:private compile-int-max (.visitLdcInsn Long/MAX_VALUE) &&/wrap-long
-
- ^:private compile-frac-smallest (.visitLdcInsn Double/MIN_VALUE) &&/wrap-double
- ^:private compile-frac-min (.visitLdcInsn (* -1.0 Double/MAX_VALUE)) &&/wrap-double
- ^:private compile-frac-max (.visitLdcInsn Double/MAX_VALUE) &&/wrap-double
-
- ^:private compile-frac-not-a-number (.visitLdcInsn Double/NaN) &&/wrap-double
- ^:private compile-frac-positive-infinity (.visitLdcInsn Double/POSITIVE_INFINITY) &&/wrap-double
- ^:private compile-frac-negative-infinity (.visitLdcInsn Double/NEGATIVE_INFINITY) &&/wrap-double
- )
-
-(do-template [<name> <class> <signature> <unwrap>]
- (defn <name> [compile ?values special-args]
- (|do [:let [(&/$Cons ?input (&/$Nil)) ?values]
- ^MethodVisitor *writer* &/get-writer
- _ (compile ?input)
- :let [_ (doto *writer*
- <unwrap>
- (.visitMethodInsn Opcodes/INVOKESTATIC <class> "toString" <signature>))]]
- (return nil)))
+ ^:private compile-frac-smallest Double/MIN_VALUE
+ ^:private compile-frac-min (* -1.0 Double/MAX_VALUE)
+ ^:private compile-frac-max Double/MAX_VALUE
- ^:private compile-frac-encode "java/lang/Double" "(D)Ljava/lang/String;" &&/unwrap-double
+ ^:private compile-frac-not-a-number Double/NaN
+ ^:private compile-frac-positive-infinity Double/POSITIVE_INFINITY
+ ^:private compile-frac-negative-infinity Double/NEGATIVE_INFINITY
)
+(defn ^:private compile-frac-encode [compile ?values special-args]
+ (|do [:let [(&/$Cons ?input (&/$Nil)) ?values]
+ ^MethodVisitor *writer* &/get-writer
+ _ (compile ?input)
+ :let [_ (doto *writer*
+ &&/unwrap-double
+ (.visitMethodInsn Opcodes/INVOKESTATIC "java/lang/Double" "toString" "(D)Ljava/lang/String;"))]]
+ (return nil)))
-(do-template [<name> <method>]
- (defn <name> [compile ?values special-args]
- (|do [:let [(&/$Cons ?input (&/$Nil)) ?values]
- ^MethodVisitor *writer* &/get-writer
- _ (compile ?input)
- :let [_ (doto *writer*
- (.visitTypeInsn Opcodes/CHECKCAST "java/lang/String")
- (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" <method> "(Ljava/lang/String;)[Ljava/lang/Object;"))]]
- (return nil)))
-
- ^:private compile-int-decode "decode_int"
- ^:private compile-frac-decode "decode_frac"
- )
+(defn ^:private compile-frac-decode [compile ?values special-args]
+ (|do [:let [(&/$Cons ?input (&/$Nil)) ?values]
+ ^MethodVisitor *writer* &/get-writer
+ _ (compile ?input)
+ :let [_ (doto *writer*
+ (.visitTypeInsn Opcodes/CHECKCAST "java/lang/String")
+ (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "decode_frac" "(Ljava/lang/String;)[Ljava/lang/Object;"))]]
+ (return nil)))
(defn ^:private compile-int-char [compile ?values special-args]
(|do [:let [(&/$Cons ?x (&/$Nil)) ?values]
@@ -305,8 +294,8 @@
<wrap>)]]
(return nil)))
- ^:private compile-frac-to-int &&/unwrap-double Opcodes/D2L &&/wrap-long
- ^:private compile-int-to-frac &&/unwrap-long Opcodes/L2D &&/wrap-double
+ ^:private compile-frac-int &&/unwrap-double Opcodes/D2L &&/wrap-long
+ ^:private compile-int-frac &&/unwrap-long Opcodes/L2D &&/wrap-double
)
(defn ^:private compile-text-eq [compile ?values special-args]
@@ -626,7 +615,7 @@
(.visitLdcInsn &/unit-tag))]]
(return nil)))
-(defn ^:private compile-process-parallelism-level [compile ?values special-args]
+(defn ^:private compile-process-parallelism [compile ?values special-args]
(|do [:let [(&/$Nil) ?values]
^MethodVisitor *writer* &/get-writer
:let [_ (doto *writer*
@@ -677,14 +666,17 @@
"contains?" (compile-text-contains? compile ?values special-args)
)
- "bit"
+ "i64"
(case proc
- "and" (compile-bit-and compile ?values special-args)
- "or" (compile-bit-or compile ?values special-args)
- "xor" (compile-bit-xor compile ?values special-args)
- "left-shift" (compile-bit-left-shift compile ?values special-args)
- "arithmetic-right-shift" (compile-bit-arithmetic-right-shift compile ?values special-args)
- "logical-right-shift" (compile-bit-logical-right-shift compile ?values special-args))
+ "and" (compile-i64-and compile ?values special-args)
+ "or" (compile-i64-or compile ?values special-args)
+ "xor" (compile-i64-xor compile ?values special-args)
+ "left-shift" (compile-i64-left-shift compile ?values special-args)
+ "arithmetic-right-shift" (compile-i64-arithmetic-right-shift compile ?values special-args)
+ "logical-right-shift" (compile-i64-logical-right-shift compile ?values special-args)
+ "=" (compile-i64-eq compile ?values special-args)
+ "+" (compile-i64-add compile ?values special-args)
+ "-" (compile-i64-sub compile ?values special-args))
"array"
(case proc
@@ -696,16 +688,11 @@
"int"
(case proc
- "+" (compile-int-add compile ?values special-args)
- "-" (compile-int-sub compile ?values special-args)
"*" (compile-int-mul compile ?values special-args)
"/" (compile-int-div compile ?values special-args)
"%" (compile-int-rem compile ?values special-args)
- "=" (compile-int-eq compile ?values special-args)
"<" (compile-int-lt compile ?values special-args)
- "max" (compile-int-max compile ?values special-args)
- "min" (compile-int-min compile ?values special-args)
- "to-frac" (compile-int-to-frac compile ?values special-args)
+ "frac" (compile-int-frac compile ?values special-args)
"char" (compile-int-char compile ?values special-args)
)
@@ -724,7 +711,7 @@
"not-a-number" (compile-frac-not-a-number compile ?values special-args)
"positive-infinity" (compile-frac-positive-infinity compile ?values special-args)
"negative-infinity" (compile-frac-negative-infinity compile ?values special-args)
- "to-int" (compile-frac-to-int compile ?values special-args)
+ "int" (compile-frac-int compile ?values special-args)
"encode" (compile-frac-encode compile ?values special-args)
"decode" (compile-frac-decode compile ?values special-args)
)
@@ -760,7 +747,7 @@
"process"
(case proc
- "parallelism-level" (compile-process-parallelism-level compile ?values special-args)
+ "parallelism" (compile-process-parallelism compile ?values special-args)
"schedule" (compile-process-schedule compile ?values special-args)
)
diff --git a/luxc/src/lux/type.clj b/luxc/src/lux/type.clj
index b9c5898a7..c2650c5b8 100644
--- a/luxc/src/lux/type.clj
+++ b/luxc/src/lux/type.clj
@@ -23,10 +23,17 @@
(def empty-env &/$Nil)
+(def I64 (&/$Named (&/T ["lux" "I64"])
+ (&/$UnivQ empty-env
+ (&/$Primitive "#I64" (&/|list (&/$Bound 1))))))
+(def Nat* (&/$Primitive &&host/nat-data-tag &/$Nil))
+(def Deg* (&/$Primitive &&host/deg-data-tag &/$Nil))
+(def Int* (&/$Primitive &&host/int-data-tag &/$Nil))
+
(def Bool (&/$Named (&/T ["lux" "Bool"]) (&/$Primitive "#Bool" &/$Nil)))
-(def Nat (&/$Named (&/T ["lux" "Nat"]) (&/$Primitive &&host/nat-data-tag &/$Nil)))
-(def Deg (&/$Named (&/T ["lux" "Deg"]) (&/$Primitive &&host/deg-data-tag &/$Nil)))
-(def Int (&/$Named (&/T ["lux" "Int"]) (&/$Primitive "#Int" &/$Nil)))
+(def Nat (&/$Named (&/T ["lux" "Nat"]) (&/$Apply Nat* I64)))
+(def Deg (&/$Named (&/T ["lux" "Deg"]) (&/$Apply Deg* I64)))
+(def Int (&/$Named (&/T ["lux" "Int"]) (&/$Apply Int* I64)))
(def Frac (&/$Named (&/T ["lux" "Frac"]) (&/$Primitive "#Frac" &/$Nil)))
(def Text (&/$Named (&/T ["lux" "Text"]) (&/$Primitive "#Text" &/$Nil)))
(def Ident (&/$Named (&/T ["lux" "Ident"]) (&/$Product Text Text)))
diff --git a/luxc/src/lux/type/host.clj b/luxc/src/lux/type/host.clj
index 2e2db3bf6..d56e85fd7 100644
--- a/luxc/src/lux/type/host.clj
+++ b/luxc/src/lux/type/host.clj
@@ -66,7 +66,9 @@
;; [Exports]
(def array-data-tag "#Array")
(def null-data-tag "#Null")
+(def i64-data-tag "#I64")
(def nat-data-tag "#Nat")
+(def int-data-tag "#Int")
(def deg-data-tag "#Deg")
;; [Utils]
@@ -309,9 +311,8 @@
(def ^:private lux-jvm-type-combos
#{#{"java.lang.Boolean" "#Bool"}
- #{"java.lang.Long" "#Int"}
+ #{"java.lang.Long" i64-data-tag}
#{"java.lang.Double" "#Frac"}
- #{"java.lang.Character" "#Char"}
#{"java.lang.String" "#Text"}})
(defn ^:private lux-type? [^String class-name]
diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux
index 4c52bf00f..795133b33 100644
--- a/stdlib/source/lux.lux
+++ b/stdlib/source/lux.lux
@@ -1,8 +1,8 @@
## Basic types
("lux def" dummy-cursor
("lux check" (+2 (+0 "#Text" (+0))
- (+2 (+0 "#Nat" (+0))
- (+0 "#Nat" (+0))))
+ (+2 (+0 "#I64" (+1 (+0 "#Nat" (+0)) (+0)))
+ (+0 "#I64" (+1 (+0 "#Nat" (+0)) (+0)))))
["" +0 +0])
[["" +0 +0]
(+10 (+1 [[["" +0 +0] (+7 ["lux" "export?"])]
@@ -22,7 +22,7 @@
(+1 [[dummy-cursor (+7 ["lux" "doc"])]
[dummy-cursor (+5 "The type of things whose type does not matter.
- It can be used to write functions or data-structures that can take, or return, anything.")]]
+ It can be used to write functions or data-structures that can take, or return, anything.")]]
(+0)))))])
## (type: Bottom
@@ -38,7 +38,7 @@
(+1 [[dummy-cursor (+7 ["lux" "doc"])]
[dummy-cursor (+5 "The type of things whose type is unknown or undefined.
- Useful for expressions that cause errors or other \"extraordinary\" conditions.")]]
+ Useful for expressions that cause errors or other \"extraordinary\" conditions.")]]
(+0)))))])
## (type: (List a)
@@ -77,9 +77,22 @@
[dummy-cursor (+5 "Your standard, run-of-the-mill boolean values.")]]
#Nil))))])
+("lux def" I64
+ (+10 ["lux" "I64"]
+ (+7 (+0)
+ (+0 "#I64" (#Cons (+4 +1) #Nil))))
+ [dummy-cursor
+ (+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])]
+ [dummy-cursor (+0 true)]]
+ (#Cons [[dummy-cursor (+7 ["lux" "export?"])]
+ [dummy-cursor (+0 true)]]
+ (#Cons [[dummy-cursor (+7 ["lux" "doc"])]
+ [dummy-cursor (+5 "64-bit integers without any semantics.")]]
+ #Nil))))])
+
("lux def" Nat
(+10 ["lux" "Nat"]
- (+0 "#Nat" #Nil))
+ (+0 "#I64" (#Cons (+0 "#Nat" #Nil) #Nil)))
[dummy-cursor
(+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])]
[dummy-cursor (+0 true)]]
@@ -88,12 +101,12 @@
(#Cons [[dummy-cursor (+7 ["lux" "doc"])]
[dummy-cursor (+5 "Natural numbers (unsigned integers).
- They start at zero (+0) and extend in the positive direction.")]]
+ They start at zero (+0) and extend in the positive direction.")]]
#Nil))))])
("lux def" Int
(+10 ["lux" "Int"]
- (+0 "#Int" #Nil))
+ (+0 "#I64" (#Cons (+0 "#Int" #Nil) #Nil)))
[dummy-cursor
(+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])]
[dummy-cursor (+0 true)]]
@@ -103,30 +116,30 @@
[dummy-cursor (+5 "Your standard, run-of-the-mill integer numbers.")]]
#Nil))))])
-("lux def" Frac
- (+10 ["lux" "Frac"]
- (+0 "#Frac" #Nil))
+("lux def" Deg
+ (+10 ["lux" "Deg"]
+ (+0 "#I64" (#Cons (+0 "#Deg" #Nil) #Nil)))
[dummy-cursor
(+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])]
[dummy-cursor (+0 true)]]
(#Cons [[dummy-cursor (+7 ["lux" "export?"])]
[dummy-cursor (+0 true)]]
(#Cons [[dummy-cursor (+7 ["lux" "doc"])]
- [dummy-cursor (+5 "Your standard, run-of-the-mill floating-point (fractional) numbers.")]]
+ [dummy-cursor (+5 "Fractional numbers that live in the interval [0,1).
+
+ Useful for probability, and other domains that work within that interval.")]]
#Nil))))])
-("lux def" Deg
- (+10 ["lux" "Deg"]
- (+0 "#Deg" #Nil))
+("lux def" Frac
+ (+10 ["lux" "Frac"]
+ (+0 "#Frac" #Nil))
[dummy-cursor
(+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])]
[dummy-cursor (+0 true)]]
(#Cons [[dummy-cursor (+7 ["lux" "export?"])]
[dummy-cursor (+0 true)]]
(#Cons [[dummy-cursor (+7 ["lux" "doc"])]
- [dummy-cursor (+5 "Fractional numbers that live in the interval [0,1).
-
- Useful for probability, and other domains that work within that interval.")]]
+ [dummy-cursor (+5 "Your standard, run-of-the-mill floating-point (fractional) numbers.")]]
#Nil))))])
("lux def" Text
@@ -152,7 +165,7 @@
(#Cons [[dummy-cursor (+7 ["lux" "doc"])]
[dummy-cursor (+5 "An identifier.
- It is used as part of Lux syntax to represent symbols and tags.")]]
+ It is used as part of Lux syntax to represent symbols and tags.")]]
#Nil))))])
## (type: (Maybe a)
@@ -1119,20 +1132,14 @@
(#.Cons export-meta
#.Nil))
(#Function Nat (#Function Nat Nat))
- ("lux coerce" Nat
- ("lux int +"
- ("lux coerce" Int subject)
- ("lux coerce" Int param))))
+ ("lux i64 +" param subject))
(def:'' (n/- param subject)
(#.Cons (doc-meta "Nat(ural) substraction.")
(#.Cons export-meta
#.Nil))
(#Function Nat (#Function Nat Nat))
- ("lux coerce" Nat
- ("lux int -"
- ("lux coerce" Int subject)
- ("lux coerce" Int param))))
+ ("lux i64 -" param subject))
(def:'' (n/* param subject)
(#.Cons (doc-meta "Nat(ural) multiplication.")
@@ -2201,28 +2208,24 @@
(list [(tag$ ["lux" "doc"])
(text$ "Nat(ural) equality.")])
(-> Nat Nat Bool)
- ("lux int ="
- ("lux coerce" Int subject)
- ("lux coerce" Int test)))
+ ("lux i64 =" test subject))
(def:''' (high-bits value)
(list)
- (-> Nat Int)
- ("lux coerce" Int ("lux bit logical-right-shift" value +32)))
+ (-> ($' I64 Top) I64)
+ ("lux i64 logical-right-shift" +32 value))
(def:''' low-mask
(list)
- Nat
- ("lux coerce" Nat
- ("lux int -"
- ("lux coerce" Int
- ("lux bit left-shift" +1 +32))
- 1)))
+ I64
+ (|> +1
+ ("lux i64 left-shift" +32)
+ ("lux i64 -" +1)))
(def:''' (low-bits value)
(list)
- (-> Nat Int)
- ("lux coerce" Int ("lux bit and" value low-mask)))
+ (-> ($' I64 Top) I64)
+ ("lux i64 and" low-mask value))
(def:''' #export (n/< test subject)
(list [(tag$ ["lux" "doc"])
@@ -2232,7 +2235,7 @@
subjectH (high-bits subject)]
(if ("lux int <" subjectH testH)
true
- (if ("lux int =" subjectH testH)
+ (if ("lux i64 =" testH subjectH)
("lux int <"
(low-bits subject)
(low-bits test))
@@ -2244,9 +2247,7 @@
(-> Nat Nat Bool)
(if (n/< test subject)
true
- ("lux int ="
- ("lux coerce" Int subject)
- ("lux coerce" Int test))))
+ ("lux i64 =" test subject)))
(def:''' #export (n/> test subject)
(list [(tag$ ["lux" "doc"])
@@ -2260,9 +2261,7 @@
(-> Nat Nat Bool)
(if (n/< subject test)
true
- ("lux int ="
- ("lux coerce" Int subject)
- ("lux coerce" Int test))))
+ ("lux i64 =" test subject)))
(macro:' #export (do-template tokens)
(list [(tag$ ["lux" "doc"])
@@ -2272,8 +2271,8 @@
(-> Int Int)
(i/+ <diff>))]
- [i/inc 1]
- [i/dec -1])")])
+ [inc 1]
+ [dec -1])")])
("lux case" tokens
{(#Cons [[_ (#Tuple bindings)] (#Cons [[_ (#Tuple templates)] data])])
("lux case" [(monad/map Monad<Maybe> get-name bindings)
@@ -2299,9 +2298,7 @@
(list [(tag$ ["lux" "doc"])
(text$ "Deg(ree) equality.")])
(-> Deg Deg Bool)
- ("lux int ="
- ("lux coerce" Int subject)
- ("lux coerce" Int test)))
+ ("lux i64 =" test subject))
(def:''' #export (d/< test subject)
(list [(tag$ ["lux" "doc"])
@@ -2317,9 +2314,7 @@
(if (n/< ("lux coerce" Nat test)
("lux coerce" Nat subject))
true
- ("lux int ="
- ("lux coerce" Int subject)
- ("lux coerce" Int test))))
+ ("lux i64 =" test subject)))
(def:''' #export (d/> test subject)
(list [(tag$ ["lux" "doc"])
@@ -2333,9 +2328,7 @@
(-> Deg Deg Bool)
(if (d/< subject test)
true
- ("lux int ="
- ("lux coerce" Int subject)
- ("lux coerce" Int test))))
+ ("lux i64 =" test subject)))
(do-template [<type>
<eq-proc> <lt-proc> <eq-name> <lt-name> <lte-name> <gt-name> <gte-name>
@@ -2374,7 +2367,7 @@
true
(<eq-proc> subject test)))]
- [ Int "lux int =" "lux int <" i/= i/< i/<= i/> i/>=
+ [ Int "lux i64 =" "lux int <" i/= i/< i/<= i/> i/>=
"Int(eger) equality." "Int(eger) less-than." "Int(eger) less-than-equal." "Int(eger) greater-than." "Int(eger) greater-than-equal."]
[Frac "lux frac =" "lux frac <" f/= f/< f/<= f/> f/>=
@@ -2389,27 +2382,18 @@
(if (n/< param subject)
+0
+1)
- (let' [quotient ("lux bit left-shift"
- ("lux coerce" Nat
- ("lux int /"
- ("lux coerce" Int
- ("lux bit logical-right-shift"
- subject
- +1))
- ("lux coerce" Int param)))
- +1)
- remainder ("lux coerce" Nat
- ("lux int -"
- ("lux coerce" Int subject)
- ("lux int *"
- ("lux coerce" Int quotient)
- ("lux coerce" Int param))))]
+ (let' [quotient ("lux i64 left-shift"
+ +1
+ ("lux int /"
+ ("lux i64 logical-right-shift" +1 subject)
+ ("lux coerce" Int param)))
+ flat ("lux int *"
+ ("lux coerce" Int quotient)
+ ("lux coerce" Int param))
+ remainder ("lux i64 -" flat subject)]
(if (n/< param remainder)
quotient
- ("lux coerce" Nat
- ("lux int +"
- ("lux coerce" Int quotient)
- 1))))))
+ ("lux i64 +" +1 quotient)))))
(def:''' #export (n/% param subject)
(list [(tag$ ["lux" "doc"])
@@ -2418,48 +2402,59 @@
(let' [flat ("lux int *"
("lux coerce" Int (n// param subject))
("lux coerce" Int param))]
- ("lux coerce" Nat
- ("lux int -"
- ("lux coerce" Int subject)
- flat))))
+ ("lux i64 -" flat subject)))
(do-template [<type> <name> <op> <doc>]
[(def:''' #export (<name> param subject)
(list [(tag$ ["lux" "doc"])
(text$ <doc>)])
(-> <type> <type> <type>)
- ("lux coerce" Deg
- (<op> ("lux coerce" Int subject)
- ("lux coerce" Int param))))]
+ (<op> param subject))]
- [ Deg d/+ "lux int +" "Deg(ree) addition."]
- [ Deg d/- "lux int -" "Deg(ree) substraction."]
+ [ Int i/+ "lux i64 +" "Int(eger) addition."]
+ [ Int i/- "lux i64 -" "Int(eger) substraction."]
+
+ [ Deg d/+ "lux i64 +" "Deg(ree) addition."]
+ [ Deg d/- "lux i64 -" "Deg(ree) substraction."]
+ )
+
+(do-template [<type> <name> <op> <doc>]
+ [(def:''' #export (<name> param subject)
+ (list [(tag$ ["lux" "doc"])
+ (text$ <doc>)])
+ (-> <type> <type> <type>)
+ (<op> subject param))]
+
+ [ Int i/* "lux int *" "Int(eger) multiplication."]
+ [ Int i// "lux int /" "Int(eger) division."]
+ [ Int i/% "lux int %" "Int(eger) remainder."]
+
+ [Frac f/+ "lux frac +" "Frac(tion) addition."]
+ [Frac f/- "lux frac -" "Frac(tion) substraction."]
+ [Frac f/* "lux frac *" "Frac(tion) multiplication."]
+ [Frac f// "lux frac /" "Frac(tion) division."]
+ [Frac f/% "lux frac %" "Frac(tion) remainder."]
)
(def:''' #export (d/* param subject)
(list [(tag$ ["lux" "doc"])
(text$ "Deg(ree) multiplication.")])
(-> Deg Deg Deg)
- (let' [subjectH (high-bits ("lux coerce" Nat subject))
- subjectL (low-bits ("lux coerce" Nat subject))
- paramH (high-bits ("lux coerce" Nat param))
- paramL (low-bits ("lux coerce" Nat param))
- bottom ("lux coerce" Int
- ("lux bit logical-right-shift"
- ("lux coerce" Nat ("lux int *" subjectL paramL))
- +32))
- middle ("lux int +"
+ (let' [subjectH (high-bits subject)
+ subjectL (low-bits subject)
+ paramH (high-bits param)
+ paramL (low-bits param)
+ bottom (|> subjectL
+ ("lux int *" paramL)
+ ("lux i64 logical-right-shift" +32))
+ middle ("lux i64 +"
("lux int *" subjectH paramL)
("lux int *" subjectL paramH))
top ("lux int *" subjectH paramH)]
- ("lux coerce" Deg
- ("lux int +"
- (high-bits
- ("lux coerce" Nat
- ("lux int +"
- bottom
- middle)))
- top))))
+ (|> bottom
+ ("lux i64 +" middle)
+ high-bits
+ ("lux i64 +" top))))
(def:''' least-significant-bit-mask (list) Nat +1)
@@ -2467,32 +2462,26 @@
(list)
(-> Nat Nat (#Product Nat Nat))
(if (|> remaining
- ("lux bit and" least-significant-bit-mask)
- ("lux coerce" Int)
- ("lux int =" 0))
+ ("lux i64 and" least-significant-bit-mask)
+ ("lux i64 =" +0))
(without-trailing-zeroes
- (|> count
- ("lux coerce" Int)
- ("lux int +" 1)
- ("lux coerce" Nat))
- ("lux bit logical-right-shift" remaining +1))
+ ("lux i64 +" +1 count)
+ ("lux i64 logical-right-shift" +1 remaining))
[count remaining]))
(def:''' #export (d// param subject)
(list [(tag$ ["lux" "doc"])
(text$ "Deg(ree) division.")])
(-> Deg Deg Deg)
- (if (|> param ("lux coerce" Int) ("lux int =" 0))
+ (if ("lux i64 =" 0 param)
("lux io error" "Cannot divide Deg by zero!")
(let' [[trailing-zeroes remaining] (without-trailing-zeroes +0 ("lux coerce" Nat param))
- [trailing-zeroes denominator] (if (|> trailing-zeroes ("lux coerce" Int) ("lux int =" 0))
- [+1 ("lux bit logical-right-shift" remaining +1)]
- [trailing-zeroes remaining])
- shift ("lux coerce" Nat
- ("lux int -"
- 64
- ("lux coerce" Int trailing-zeroes)))
- numerator ("lux bit left-shift" +1 shift)]
+ [trailing-zeroes denominator] ("lux check" (#Product Nat Nat)
+ (if ("lux i64 =" 0 trailing-zeroes)
+ [+1 ("lux i64 logical-right-shift" +1 remaining)]
+ [trailing-zeroes remaining]))
+ shift ("lux i64 -" trailing-zeroes +64)
+ numerator ("lux i64 left-shift" shift +1)]
("lux coerce" Deg
("lux int *"
("lux coerce" Int subject)
@@ -2508,26 +2497,6 @@
(n/% ("lux coerce" Nat subject)
("lux coerce" Nat param))))
-(do-template [<type> <name> <op> <doc>]
- [(def:''' #export (<name> param subject)
- (list [(tag$ ["lux" "doc"])
- (text$ <doc>)])
- (-> <type> <type> <type>)
- (<op> subject param))]
-
- [ Int i/+ "lux int +" "Int(eger) addition."]
- [ Int i/- "lux int -" "Int(eger) substraction."]
- [ Int i/* "lux int *" "Int(eger) multiplication."]
- [ Int i// "lux int /" "Int(eger) division."]
- [ Int i/% "lux int %" "Int(eger) remainder."]
-
- [Frac f/+ "lux frac +" "Frac(tion) addition."]
- [Frac f/- "lux frac -" "Frac(tion) substraction."]
- [Frac f/* "lux frac *" "Frac(tion) multiplication."]
- [Frac f// "lux frac /" "Frac(tion) division."]
- [Frac f/% "lux frac %" "Frac(tion) remainder."]
- )
-
(def:''' #export (d/scale param subject)
(list [(tag$ ["lux" "doc"])
(text$ "Deg(ree) scale.")])
@@ -2546,7 +2515,7 @@
(n// remaining
("lux case" trailing-zeroes
{+0 ("lux coerce" Nat -1)
- _ ("lux bit left-shift" +1 (n/- trailing-zeroes +64))})))))
+ _ ("lux i64 left-shift" (n/- trailing-zeroes +64) +1)})))))
(do-template [<name> <type> <test> <doc>]
[(def:''' #export (<name> left right)
@@ -5117,7 +5086,7 @@
(macro: #export (update@ tokens)
{#.doc "## Modifies the value of a record at a given tag, based on some function.
- (update@ #age i/inc person)
+ (update@ #age inc person)
## Can also work with multiple levels of nesting:
(update@ [#foo #bar #baz] func my-record)
@@ -5256,8 +5225,8 @@
(-> <from> <to>)
(<proc> [n]))]
- [frac-to-int Frac Int "lux frac to-int"]
- [int-to-frac Int Frac "lux int to-frac"]
+ [frac-to-int Frac Int "lux frac int"]
+ [int-to-frac Int Frac "lux int frac"]
)
(def: (find-baseline-column code)
@@ -5314,34 +5283,31 @@
)]
($_ text/compose "\"" escaped "\"")))
-(do-template [<name> <op> <one> <type> <doc>]
- [(def: #export (<name> value)
+(do-template [<name> <special> <doc>]
+ [(def: #export <name>
{#.doc <doc>}
- (-> <type> <type>)
- (<op> <one> value))]
+ (All [s] (-> (I64 s) (I64 s)))
+ (|>> (<special> +1)))]
- [i/inc i/+ 1 Int "[Int] Increment function."]
- [i/dec i/- 1 Int "[Int] Decrement function."]
- [n/inc n/+ +1 Nat "[Nat] Increment function."]
- [n/dec n/- +1 Nat "[Nat] Decrement function."]
+ [inc "lux i64 +" "Increment function."]
+ [dec "lux i64 -" "Decrement function."]
)
(def: tag/encode
(-> Ident Text)
(|>> ident/encode (text/compose "#")))
-(do-template [<name> <from> <to>]
+(do-template [<name> <to>]
[(def: #export <name>
- (-> <from> <to>)
+ (-> (I64 Top) <to>)
(|>> (:! <to>)))]
- [int-to-nat Int Nat]
- [nat-to-int Nat Int]
+ [i64 I64]
+ [nat Nat]
+ [int Int]
+ [deg Deg]
)
-(def: #export frac-to-nat (|>> frac-to-int int-to-nat))
-(def: #export nat-to-frac (|>> nat-to-int int-to-frac))
-
(def: (repeat n x)
(All [a] (-> Int a (List a)))
(if (i/> 0 n)
@@ -5351,9 +5317,9 @@
(def: (cursor-padding baseline [_ old-line old-column] [_ new-line new-column])
(-> Nat Cursor Cursor Text)
(if (n/= old-line new-line)
- (text/join (repeat (nat-to-int (n/- old-column new-column)) " "))
- (let [extra-lines (text/join (repeat (nat-to-int (n/- old-line new-line)) "\n"))
- space-padding (text/join (repeat (nat-to-int (n/- baseline new-column)) " "))]
+ (text/join (repeat (.int (n/- old-column new-column)) " "))
+ (let [extra-lines (text/join (repeat (.int (n/- old-line new-line)) "\n"))
+ space-padding (text/join (repeat (.int (n/- baseline new-column)) " "))]
(text/compose extra-lines space-padding))))
(def: (text/size x)
@@ -5366,7 +5332,7 @@
(def: (delim-update-cursor [file line column])
(-> Cursor Cursor)
- [file line (n/inc column)])
+ [file line (inc column)])
(def: rejoin-all-pairs
(-> (List [Code Code]) (List Code))
@@ -5437,7 +5403,7 @@
(loop [count 0
x init]
(if (< 10 count)
- (recur (i/inc count) (f x))
+ (recur (inc count) (f x))
x)))"}
(return (list (` [(~ cursor-code)
(#.Text (~ (|> tokens
@@ -5502,7 +5468,7 @@
(loop [count 0
x init]
(if (< 10 count)
- (recur (i/inc count) (f x))
+ (recur (inc count) (f x))
x))
"Loops can also be given custom names."
@@ -5510,7 +5476,7 @@
[count 0
x init]
(if (< 10 count)
- (my-loop (i/inc count) (f x))
+ (my-loop (inc count) (f x))
x)))}
(let [?params (case tokens
(^ (list name [_ (#Tuple bindings)] body))
@@ -5900,7 +5866,7 @@
(#Cons x xs')
(if (n/= +0 idx)
(#Some x)
- (list-at (n/dec idx) xs'))))
+ (list-at (dec idx) xs'))))
(macro: #export ($ tokens)
{#.doc (doc "Allows you to refer to the type-variables in a polymorphic function's type, by their index."
@@ -5955,7 +5921,7 @@
(macro: #export (^|> tokens)
{#.doc (doc "Pipes the value being pattern-matched against prior to binding it to a variable."
(case input
- (^|> value [n/inc (n/% +10) (n/max +1)])
+ (^|> value [inc (n/% +10) (n/max +1)])
(foo value)))}
(case tokens
(^ (list& [_meta (#Form (list [_ (#Symbol ["" name])] [_ (#Tuple steps)]))] body branches))
@@ -6330,31 +6296,27 @@
[Int i//% i// i/%]
)
-(def: (to-significand value)
- (-> Nat Frac)
- (|> ("lux bit logical-right-shift" value +11)
- (:! Int)
- int-to-frac))
+(def: to-significand
+ (-> (I64 Top) Frac)
+ (|>> ("lux i64 logical-right-shift" +11)
+ int-to-frac))
-(def: deg-denominator Frac (to-significand (:! Nat -1)))
+(def: deg-denominator Frac (to-significand -1))
(def: #export (frac-to-deg input)
(-> Frac Deg)
(let [abs (if (f/< 0.0 input)
(f/* -1.0 input)
input)]
- (:! Deg
- ("lux bit left-shift"
- (|> abs
- (f/% 1.0)
- (f/* deg-denominator)
- frac-to-int
- (:! Nat))
- +11))))
+ (|> abs
+ (f/% 1.0)
+ (f/* deg-denominator)
+ frac-to-int
+ ("lux i64 left-shift" +11))))
(def: #export deg-to-frac
(-> Deg Frac)
- (|>> (:! Nat) to-significand (f// deg-denominator)))
+ (|>> to-significand (f// deg-denominator)))
(macro: #export (alias: tokens)
(case tokens
diff --git a/stdlib/source/lux/concurrency/actor.lux b/stdlib/source/lux/concurrency/actor.lux
index 4fdb2c207..1e512d642 100644
--- a/stdlib/source/lux/concurrency/actor.lux
+++ b/stdlib/source/lux/concurrency/actor.lux
@@ -327,11 +327,11 @@
g!actor-refs (: (List Code)
(if (list.empty? actor-vars)
(list)
- (|> actor-vars list.size n/dec
+ (|> actor-vars list.size dec
(list.n/range +0) (list/map (|>> code.nat (~) ($) (`))))))
ref-replacements (|> (if (list.empty? actor-vars)
(list)
- (|> actor-vars list.size n/dec
+ (|> actor-vars list.size dec
(list.n/range +0) (list/map (|>> code.nat (~) ($) (`)))))
(: (List Code))
(list.zip2 g!all-vars)
diff --git a/stdlib/source/lux/concurrency/promise.lux b/stdlib/source/lux/concurrency/promise.lux
index a2311d272..15bad9910 100644
--- a/stdlib/source/lux/concurrency/promise.lux
+++ b/stdlib/source/lux/concurrency/promise.lux
@@ -9,9 +9,9 @@
(concurrency [atom #+ Atom atom])
(type abstract)))
-(def: #export parallelism-level
+(def: #export parallelism
Nat
- ("lux process parallelism-level"))
+ ("lux process parallelism"))
(abstract: #export (Promise a)
{#.doc "Represents values produced by asynchronous computations (unlike IO, which is synchronous)."}
diff --git a/stdlib/source/lux/concurrency/semaphore.lux b/stdlib/source/lux/concurrency/semaphore.lux
index 50a1a621c..c9ac32fcb 100644
--- a/stdlib/source/lux/concurrency/semaphore.lux
+++ b/stdlib/source/lux/concurrency/semaphore.lux
@@ -33,7 +33,7 @@
(case (get@ #open-positions state)
+0 [false (update@ #waiting-list (|>> (#.Cons signal))
state)]
- _ [true (update@ #open-positions n/dec
+ _ [true (update@ #open-positions dec
state)]))]
success? (atom.compare-and-swap state state' semaphore)
_ (if ready?
@@ -53,7 +53,7 @@
#let [[?signal state'] (: [(Maybe (Promise Top)) State]
(case (get@ #waiting-list state)
#.Nil
- [#.None (update@ #open-positions n/inc state)]
+ [#.None (update@ #open-positions inc state)]
(#.Cons head tail)
[(#.Some head) (set@ #waiting-list tail state)]))]
@@ -120,7 +120,7 @@
(if (n/< times step)
(do promise.Monad<Promise>
[_ (signal turnstile)]
- (recur (n/inc step)))
+ (recur (inc step)))
(:: promise.Monad<Promise> wrap []))))
(do-template [<phase> <update> <goal> <turnstile>]
@@ -135,8 +135,8 @@
(wrap []))]
(wait (get@ <turnstile> barrier))))]
- [start n/inc limit #start-turnstile]
- [end n/dec +0 #end-turnstile]
+ [start inc limit #start-turnstile]
+ [end dec +0 #end-turnstile]
)
(def: #export (block barrier)
diff --git a/stdlib/source/lux/control/comonad.lux b/stdlib/source/lux/control/comonad.lux
index 471c6bd2b..833a01c57 100644
--- a/stdlib/source/lux/control/comonad.lux
+++ b/stdlib/source/lux/control/comonad.lux
@@ -29,7 +29,7 @@
{#.doc (doc "A co-monadic parallel to the \"do\" macro."
(let [square (function (_ n) (i/* n n))]
(be CoMonad<Stream>
- [inputs (iterate i/inc 2)]
+ [inputs (iterate inc 2)]
(square (head inputs)))))}
(case tokens
(#.Cons comonad (#.Cons [_ (#.Tuple bindings)] (#.Cons body #.Nil)))
diff --git a/stdlib/source/lux/control/monad.lux b/stdlib/source/lux/control/monad.lux
index 9a1ceb3b9..736296920 100644
--- a/stdlib/source/lux/control/monad.lux
+++ b/stdlib/source/lux/control/monad.lux
@@ -22,7 +22,7 @@
counter
(#.Cons _ xs')
- (recur (n/inc counter) xs'))))
+ (recur (inc counter) xs'))))
(def: (reverse xs)
(All [a]
diff --git a/stdlib/source/lux/control/parser.lux b/stdlib/source/lux/control/parser.lux
index 3c1022fc8..88f2eb20d 100644
--- a/stdlib/source/lux/control/parser.lux
+++ b/stdlib/source/lux/control/parser.lux
@@ -139,7 +139,7 @@
(if (n/> +0 n)
(do Monad<Parser>
[x p
- xs (exactly (n/dec n) p)]
+ xs (exactly (dec n) p)]
(wrap (#.Cons x xs)))
(:: Monad<Parser> wrap (list))))
@@ -163,7 +163,7 @@
(#e.Success [input' x])
(run input'
(do Monad<Parser>
- [xs (at-most (n/dec n) p)]
+ [xs (at-most (dec n) p)]
(wrap (#.Cons x xs))))
))
(:: Monad<Parser> wrap (list))))
diff --git a/stdlib/source/lux/control/pipe.lux b/stdlib/source/lux/control/pipe.lux
index 4e84e7832..19d67ce7d 100644
--- a/stdlib/source/lux/control/pipe.lux
+++ b/stdlib/source/lux/control/pipe.lux
@@ -19,7 +19,7 @@
(|> 20
(i/* 3)
(i/+ 4)
- (new> 0 i/inc)))}
+ (new> 0 inc)))}
(case (list.reverse tokens)
(^ (list& _ r-body))
(wrap (list (` (|> (~+ (list.reverse r-body))))))
@@ -66,7 +66,7 @@
"Both the testing and calculating steps are pipes and must be given inside tuples."
(|> 1
(loop> [(i/< 10)]
- [i/inc])))}
+ [inc])))}
(with-gensyms [g!temp]
(wrap (list (` (loop [(~ g!temp) (~ prev)]
(if (|> (~ g!temp) (~+ test))
@@ -82,7 +82,7 @@
(do> Monad<Identity>
[(i/* 3)]
[(i/+ 4)]
- [i/inc])))}
+ [inc])))}
(with-gensyms [g!temp]
(case (list.reverse steps)
(^ (list& last-step prev-steps))
@@ -102,7 +102,7 @@
{#.doc (doc "Non-updating pipes."
"Will generate piped computations, but their results will not be used in the larger scope."
(|> 5
- (exec> [int-to-nat %n log!])
+ (exec> [.nat %n log!])
(i/* 10)))}
(with-gensyms [g!temp]
(wrap (list (` (let [(~ g!temp) (~ prev)]
@@ -115,7 +115,7 @@
"Allows to run multiple pipelines for a value and gives you a tuple of the outputs."
(|> 5
(tuple> [(i/* 10)]
- [i/dec (i// 2)]
+ [dec (i// 2)]
[Int/encode]))
"Will become: [50 2 \"5\"]")}
(with-gensyms [g!temp]
diff --git a/stdlib/source/lux/data/bit.lux b/stdlib/source/lux/data/bit.lux
index ae5b6e55d..e89cf0c9d 100644
--- a/stdlib/source/lux/data/bit.lux
+++ b/stdlib/source/lux/data/bit.lux
@@ -3,33 +3,41 @@
(def: #export width Nat +64)
## [Values]
-(do-template [<name> <type> <op> <doc>]
+(do-template [<name> <op> <doc>]
+ [(def: #export (<name> param subject)
+ {#.doc <doc>}
+ (All [s] (-> (I64 s) (I64 s) (I64 s)))
+ (<op> param subject))]
+
+ [and "lux i64 and" "Bitwise and."]
+ [or "lux i64 or" "Bitwise or."]
+ [xor "lux i64 xor" "Bitwise xor."]
+ )
+
+(do-template [<name> <op> <doc>]
[(def: #export (<name> param subject)
{#.doc <doc>}
- (-> Nat <type> <type>)
- (<op> subject param))]
-
- [and Nat "lux bit and" "Bitwise and."]
- [or Nat "lux bit or" "Bitwise or."]
- [xor Nat "lux bit xor" "Bitwise xor."]
- [left-shift Nat "lux bit left-shift" "Bitwise left-shift."]
- [logical-right-shift Nat "lux bit logical-right-shift" "Unsigned bitwise logical-right-shift."]
- [arithmetic-right-shift Int "lux bit arithmetic-right-shift" "Signed bitwise arithmetic-right-shift."]
+ (All [s] (-> Nat (I64 s) (I64 s)))
+ (<op> param subject))]
+
+ [left-shift "lux i64 left-shift" "Bitwise left-shift."]
+ [logical-right-shift "lux i64 logical-right-shift" "Unsigned bitwise logical-right-shift."]
+ [arithmetic-right-shift "lux i64 arithmetic-right-shift" "Signed bitwise arithmetic-right-shift."]
)
(alias: right-shift logical-right-shift)
(def: (add-shift shift value)
(-> Nat Nat Nat)
- (|> value (logical-right-shift shift) (n/+ value)))
+ (|> value (right-shift shift) (n/+ value)))
(def: #export (count subject)
{#.doc "Count the number of 1s in a bit-map."}
- (-> Nat Nat)
- (let [count' (n/- (|> subject (logical-right-shift +1) (and +6148914691236517205))
- subject)]
+ (-> (I64 Top) Nat)
+ (let [count' (n/- (|> subject (right-shift +1) (and +6148914691236517205) i64)
+ (i64 subject))]
(|> count'
- (logical-right-shift +2) (and +3689348814741910323) (n/+ (and +3689348814741910323 count'))
+ (right-shift +2) (and +3689348814741910323) (n/+ (and +3689348814741910323 count'))
(add-shift +4) (and +1085102592571150095)
(add-shift +8)
(add-shift +16)
@@ -38,43 +46,44 @@
(def: #export not
{#.doc "Bitwise negation."}
- (-> Nat Nat)
- (let [mask (int-to-nat -1)]
- (xor mask)))
+ (All [s] (-> (I64 s) (I64 s)))
+ (xor (:! I64 -1)))
+
+(def: (flag idx)
+ (-> Nat I64)
+ (|> +1 (:! I64) (left-shift idx)))
(def: #export (clear idx input)
{#.doc "Clear bit at given index."}
- (-> Nat Nat Nat)
- (..and (..not (left-shift idx +1))
- input))
+ (All [s] (-> Nat (I64 s) (I64 s)))
+ (|> idx flag ..not (..and input)))
(do-template [<name> <op> <doc>]
[(def: #export (<name> idx input)
{#.doc <doc>}
- (-> Nat Nat Nat)
- (<op> (left-shift idx +1) input))]
+ (All [s] (-> Nat (I64 s) (I64 s)))
+ (|> idx flag (<op> input)))]
[set ..or "Set bit at given index."]
[flip ..xor "Flip bit at given index."]
)
(def: #export (set? idx input)
- (-> Nat Nat Bool)
- (|> input (..and (left-shift idx +1)) (n/= +0) .not))
+ (-> Nat (I64 Top) Bool)
+ (|> input (:! I64) (..and (flag idx)) (n/= +0) .not))
(do-template [<name> <main> <comp>]
[(def: #export (<name> distance input)
- (-> Nat Nat Nat)
- (..or (<main> distance input)
- (<comp> (n/- (n/% width distance)
- width)
- input)))]
-
- [rotate-left left-shift logical-right-shift]
- [rotate-right logical-right-shift left-shift]
+ (All [s] (-> Nat (I64 s) (I64 s)))
+ (let [backwards-distance (n/- (n/% width distance) width)]
+ (|> input
+ (<comp> backwards-distance)
+ (..or (<main> distance input)))))]
+
+ [rotate-left left-shift right-shift]
+ [rotate-right right-shift left-shift]
)
-(def: #export (region-mask size offset)
- (-> Nat Nat Nat)
- (let [pattern (|> +1 (left-shift size) n/dec)]
- (left-shift offset pattern)))
+(def: #export (region size offset)
+ (-> Nat Nat I64)
+ (|> +1 (:! I64) (left-shift size) dec (left-shift offset)))
diff --git a/stdlib/source/lux/data/coll/array.lux b/stdlib/source/lux/data/coll/array.lux
index 855c35d8e..dd3a94553 100644
--- a/stdlib/source/lux/data/coll/array.lux
+++ b/stdlib/source/lux/data/coll/array.lux
@@ -45,7 +45,7 @@
(#.Some value)
(write (n/+ offset dest-start) value target)))
dest-array
- (list.n/range +0 (n/dec length)))))
+ (list.n/range +0 (dec length)))))
(def: #export (occupied array)
{#.doc "Finds out how many cells in an array are occupied."}
@@ -56,7 +56,7 @@
count
(#.Some _)
- (n/inc count)))
+ (inc count)))
+0
(list.indices (size array))))
@@ -88,12 +88,12 @@
(if (n/< arr-size idx)
(case (read idx xs)
#.None
- (recur (n/inc idx))
+ (recur (inc idx))
(#.Some x)
(if (p x)
(#.Some x)
- (recur (n/inc idx))))
+ (recur (inc idx))))
#.None))))
(def: #export (find+ p xs)
@@ -105,12 +105,12 @@
(if (n/< arr-size idx)
(case (read idx xs)
#.None
- (recur (n/inc idx))
+ (recur (inc idx))
(#.Some x)
(if (p idx x)
(#.Some [idx x])
- (recur (n/inc idx))))
+ (recur (inc idx))))
#.None))))
(def: #export (clone xs)
@@ -129,19 +129,19 @@
(def: #export (from-list xs)
(All [a] (-> (List a) (Array a)))
(product.right (list/fold (function (_ x [idx arr])
- [(n/inc idx) (write idx x arr)])
+ [(inc idx) (write idx x arr)])
[+0 (new (list.size xs))]
xs)))
-(def: underflow Nat (n/dec +0))
+(def: underflow Nat (dec +0))
(def: #export (to-list array)
(All [a] (-> (Array a) (List a)))
- (loop [idx (n/dec (size array))
+ (loop [idx (dec (size array))
output #.Nil]
(if (n/= underflow idx)
output
- (recur (n/dec idx)
+ (recur (dec idx)
(case (read idx array)
(#.Some head)
(#.Cons head output)
@@ -167,11 +167,10 @@
_
false)))
true
- (list.n/range +0 (n/dec sxs)))))
+ (list.n/range +0 (dec sxs)))))
))
-(struct: #export Monoid<Array> (All [a]
- (Monoid (Array a)))
+(struct: #export Monoid<Array> (All [a] (Monoid (Array a)))
(def: identity (new +0))
(def: (compose xs ys)
@@ -194,7 +193,7 @@
(#.Some x)
(write idx (f x) mb)))
(new arr-size)
- (list.n/range +0 (n/dec arr-size)))
+ (list.n/range +0 (dec arr-size)))
))))
(struct: #export _ (Fold Array)
@@ -205,8 +204,8 @@
(if (n/< arr-size idx)
(case (read idx xs)
#.None
- (recur so-far (n/inc idx))
+ (recur so-far (inc idx))
(#.Some value)
- (recur (f value so-far) (n/inc idx)))
+ (recur (f value so-far) (inc idx)))
so-far)))))
diff --git a/stdlib/source/lux/data/coll/bits.lux b/stdlib/source/lux/data/coll/bits.lux
index b2530627c..304076048 100644
--- a/stdlib/source/lux/data/coll/bits.lux
+++ b/stdlib/source/lux/data/coll/bits.lux
@@ -53,10 +53,10 @@
[(def: #export (<name> index input)
(-> Nat Bits Bits)
(let [[chunk-index bit-index] (n//% chunk-size index)]
- (loop [size|output (n/max (n/inc chunk-index)
+ (loop [size|output (n/max (inc chunk-index)
(array.size input))
output ..empty]
- (let [idx|output (n/dec size|output)]
+ (let [idx|output (dec size|output)]
(if (n/> +0 size|output)
(case (|> (chunk idx|output input)
(cond> [(new> (n/= chunk-index idx|output))]
@@ -66,7 +66,7 @@
[]))
+0
## TODO: Remove 'no-op' once new-luxc is the official compiler.
- (let [no-op (recur (n/dec size|output) output)]
+ (let [no-op (recur (dec size|output) output)]
no-op)
chunk
@@ -74,7 +74,7 @@
(: Bits (array.new size|output))
output)
(array.write idx|output chunk)
- (recur (n/dec size|output))))
+ (recur (dec size|output))))
output)))))]
[set bit.set]
@@ -92,7 +92,7 @@
(bit.and (chunk idx reference))
(n/= empty-chunk)
.not)
- (recur (n/inc idx)))
+ (recur (inc idx)))
false))))
(def: #export (not input)
@@ -104,10 +104,10 @@
size|output
(loop [size|output size|output
output ..empty]
- (let [idx (n/dec size|output)]
+ (let [idx (dec size|output)]
(case (bit.not (chunk idx input))
+0
- (recur (n/dec size|output) output)
+ (recur (dec size|output) output)
chunk
(if (n/> +0 size|output)
@@ -115,7 +115,7 @@
(: Bits (array.new size|output))
output)
(array.write idx chunk)
- (recur (n/dec size|output)))
+ (recur (dec size|output)))
output))))))
(do-template [<name> <op>]
@@ -129,18 +129,18 @@
size|output
(loop [size|output size|output
output ..empty]
- (let [idx (n/dec size|output)]
+ (let [idx (dec size|output)]
(if (n/> +0 size|output)
(case (<op> (chunk idx param) (chunk idx subject))
+0
- (recur (n/dec size|output) output)
+ (recur (dec size|output) output)
chunk
(|> (if (is? ..empty output)
(: Bits (array.new size|output))
output)
(array.write idx chunk)
- (recur (n/dec size|output))))
+ (recur (dec size|output))))
output)))))]
[and bit.and]
@@ -156,5 +156,5 @@
(if (n/< size|= idx)
(.and (n/= (chunk idx reference)
(chunk idx sample))
- (recur (n/inc idx)))
+ (recur (inc idx)))
true)))))
diff --git a/stdlib/source/lux/data/coll/dictionary/ordered.lux b/stdlib/source/lux/data/coll/dictionary/ordered.lux
index a099087f3..2feb18e0f 100644
--- a/stdlib/source/lux/data/coll/dictionary/ordered.lux
+++ b/stdlib/source/lux/data/coll/dictionary/ordered.lux
@@ -115,8 +115,8 @@
+0
(#.Some node)
- (n/inc (<op> (recur (get@ #left node))
- (recur (get@ #right node)))))))]
+ (inc (<op> (recur (get@ #left node))
+ (recur (get@ #right node)))))))]
[size n/+]
[depth n/max]
diff --git a/stdlib/source/lux/data/coll/dictionary/unordered.lux b/stdlib/source/lux/data/coll/dictionary/unordered.lux
index e0928e186..aad28249f 100644
--- a/stdlib/source/lux/data/coll/dictionary/unordered.lux
+++ b/stdlib/source/lux/data/coll/dictionary/unordered.lux
@@ -120,10 +120,10 @@
(def: (insert! idx value old-array)
(All [a] (-> Index a (Array a) (Array a)))
(let [old-size (array.size old-array)]
- (|> (array.new (n/inc old-size))
+ (|> (array.new (inc old-size))
(array.copy idx +0 old-array +0)
(array.write idx value)
- (array.copy (n/- idx old-size) idx old-array (n/inc idx)))))
+ (array.copy (n/- idx old-size) idx old-array (inc idx)))))
## Creates a copy of an array with an index set to a particular value.
(def: (update! idx value array)
@@ -138,15 +138,15 @@
## Shrinks a copy of the array by removing the space at index.
(def: (remove! idx array)
(All [a] (-> Index (Array a) (Array a)))
- (let [new-size (n/dec (array.size array))]
+ (let [new-size (dec (array.size array))]
(|> (array.new new-size)
(array.copy idx +0 array +0)
- (array.copy (n/- idx new-size) (n/inc idx) array idx))))
+ (array.copy (n/- idx new-size) (inc idx) array idx))))
## Given a top-limit for indices, produces all indices in [0, R).
(def: indices-for
(-> Nat (List Index))
- (|>> n/dec (list.n/range +0)))
+ (|>> dec (list.n/range +0)))
## Increases the level-shift by the branching-exponent, to explore
## levels further down the tree.
@@ -154,7 +154,7 @@
(-> Level Level)
(n/+ branching-exponent))
-(def: hierarchy-mask BitMap (n/dec hierarchy-nodes-size))
+(def: hierarchy-mask BitMap (dec hierarchy-nodes-size))
## Gets the branching-factor sized section of the hash corresponding
## to a particular level, and uses that as an index into the array.
@@ -201,7 +201,7 @@
## associated with it.
(def: bit-position-mask
(-> BitPosition BitMap)
- n/dec)
+ dec)
## The index on the base array, based on it's bit-position.
(def: (base-index bit-position bitmap)
@@ -227,12 +227,12 @@
#.None [insertion-idx node]
(#.Some sub-node) (if (n/= except-idx idx)
[insertion-idx node]
- [(n/inc insertion-idx)
+ [(inc insertion-idx)
[(set-bit-position (->bit-position idx) bitmap)
(array.write insertion-idx (#.Left sub-node) base)]])
)))
[+0 [clean-bitmap
- (array.new (n/dec h-size))]]
+ (array.new (dec h-size))]]
(list.indices (array.size h-array)))))
## When #Base nodes grow too large, they're promoted to #Hierarchy to
@@ -248,7 +248,7 @@
(product.right (list/fold (function (_ hierarchy-idx (^@ default [base-idx h-array]))
(if (bit-position-is-set? (->bit-position hierarchy-idx)
bitmap)
- [(n/inc base-idx)
+ [(inc base-idx)
(case (array.read base-idx base)
(#.Some (#.Left sub-node))
(array.write hierarchy-idx sub-node h-array)
@@ -289,7 +289,7 @@
[_size sub-node]
_
- [(n/inc _size) empty])]
+ [(inc _size) empty])]
(#Hierarchy _size'
(update! idx (put' (level-up level) hash key val Hash<k> sub-node)
hierarchy)))
@@ -342,7 +342,7 @@
(if (n/>= promotion-threshold base-count)
## If so, I promote it to a #Hierarchy node, and add the new
## KV-pair as a singleton node to it.
- (#Hierarchy (n/inc base-count)
+ (#Hierarchy (inc base-count)
(|> (promote-base put' Hash<k> level bitmap base)
(array.write (level-index level hash)
(put' (level-up level) hash key val Hash<k> empty))))
@@ -399,7 +399,7 @@
## If so, perform it.
(#Base (demote-hierarchy idx [h-size h-array]))
## Otherwise, just clear the space.
- (#Hierarchy (n/dec h-size) (vacant! idx h-array)))
+ (#Hierarchy (dec h-size) (vacant! idx h-array)))
## But if the sub-removal yielded a non-empty node, then
## just update the hiearchy branch.
(#Hierarchy h-size (update! idx sub-node' h-array)))))))
diff --git a/stdlib/source/lux/data/coll/list.lux b/stdlib/source/lux/data/coll/list.lux
index f6c19dcb9..f970ccf9f 100644
--- a/stdlib/source/lux/data/coll/list.lux
+++ b/stdlib/source/lux/data/coll/list.lux
@@ -76,8 +76,8 @@
<then>)
<else>))]
- [take (#.Cons [x (take (n/dec n) xs')]) #.Nil]
- [drop (drop (n/dec n) xs') xs]
+ [take (#.Cons [x (take (dec n) xs')]) #.Nil]
+ [drop (drop (dec n) xs') xs]
)
(do-template [<name> <then> <else>]
@@ -106,7 +106,7 @@
[#.Nil #.Nil]
(#.Cons [x xs'])
- (let [[tail rest] (split (n/dec n) xs')]
+ (let [[tail rest] (split (dec n) xs')]
[(#.Cons [x tail]) rest]))
[#.Nil xs]))
@@ -145,7 +145,7 @@
(All [a]
(-> Nat a (List a)))
(if (n/> +0 n)
- (#.Cons [x (repeat (n/dec n) x)])
+ (#.Cons [x (repeat (dec n) x)])
#.Nil))
(def: (iterate' f x)
@@ -232,7 +232,7 @@
(#.Cons [x xs'])
(if (n/= +0 i)
(#.Some x)
- (nth (n/dec i) xs'))))
+ (nth (dec i) xs'))))
## [Structures]
(struct: #export (Eq<List> Eq<a>)
@@ -303,21 +303,21 @@
xs')]
($_ compose (sort < pre) (list x) (sort < post)))))
-(do-template [<name> <type> <lt> <inc> <gt> <dec>]
+(do-template [<name> <type> <lt> <gt>]
[(def: #export (<name> from to)
{#.doc "Generates an inclusive interval of values [from, to]."}
(-> <type> <type> (List <type>))
(cond (<lt> to from)
- (list& from (<name> (<inc> from) to))
+ (list& from (<name> (inc from) to))
(<gt> to from)
- (list& from (<name> (<dec> from) to))
+ (list& from (<name> (dec from) to))
## (= to from)
(list from)))]
- [i/range Int i/< i/inc i/> i/dec]
- [n/range Nat n/< n/inc n/> n/dec]
+ [i/range Int i/< i/>]
+ [n/range Nat n/< n/>]
)
(def: #export (empty? xs)
@@ -362,14 +362,14 @@
(^ (list [_ (#.Nat num-lists)]))
(if (n/> +0 num-lists)
(let [(^open) Functor<List>
- indices (n/range +0 (n/dec num-lists))
+ indices (n/range +0 (dec num-lists))
type-vars (: (List Code) (map (|>> nat/encode symbol$) indices))
zip-type (` (All [(~+ type-vars)]
(-> (~+ (map (: (-> Code Code) (function (_ var) (` (List (~ var)))))
type-vars))
(List [(~+ type-vars)]))))
vars+lists (|> indices
- (map n/inc)
+ (map inc)
(map (function (_ idx)
(let [base (nat/encode idx)]
[(symbol$ base)
@@ -406,7 +406,7 @@
(^ (list [_ (#.Nat num-lists)]))
(if (n/> +0 num-lists)
(let [(^open) Functor<List>
- indices (n/range +0 (n/dec num-lists))
+ indices (n/range +0 (dec num-lists))
g!return-type (symbol$ "\treturn-type\t")
g!func (symbol$ "\tfunc\t")
type-vars (: (List Code) (map (|>> nat/encode symbol$) indices))
@@ -416,7 +416,7 @@
type-vars))
(List (~ g!return-type)))))
vars+lists (|> indices
- (map n/inc)
+ (map inc)
(map (function (_ idx)
(let [base (nat/encode idx)]
[(symbol$ base)
@@ -509,7 +509,7 @@
#.Nil
(#.Cons x xs')
- (#.Cons [idx x] (enumerate' (n/inc idx) xs'))))
+ (#.Cons [idx x] (enumerate' (inc idx) xs'))))
(def: #export (enumerate xs)
{#.doc "Pairs every element in the list with its index, starting at 0."}
@@ -521,4 +521,4 @@
(All [a] (-> Nat (List Nat)))
(if (n/= +0 size)
(list)
- (|> size n/dec (n/range +0))))
+ (|> size dec (n/range +0))))
diff --git a/stdlib/source/lux/data/coll/sequence.lux b/stdlib/source/lux/data/coll/sequence.lux
index a160a9925..5fe3befae 100644
--- a/stdlib/source/lux/data/coll/sequence.lux
+++ b/stdlib/source/lux/data/coll/sequence.lux
@@ -52,7 +52,7 @@
(def: branch-idx-mask
Nat
- (n/dec full-node-size))
+ (dec full-node-size))
(def: branch-idx
(-> Index Index)
@@ -66,7 +66,7 @@
(-> Nat Nat)
(if (n/< full-node-size vec-size)
+0
- (|> (n/dec vec-size)
+ (|> (dec vec-size)
(bit.logical-right-shift branching-exponent)
(bit.left-shift branching-exponent))))
@@ -85,7 +85,7 @@
(def: (push-tail size level tail parent)
(All [a] (-> Nat Level (Base a) (Hierarchy a) (Hierarchy a)))
- (let [sub-idx (branch-idx (bit.logical-right-shift level (n/dec size)))
+ (let [sub-idx (branch-idx (bit.logical-right-shift level (dec size)))
## If we're currently on a bottom node
sub-node (if (n/= branching-exponent level)
## Just add the tail to it
@@ -108,7 +108,7 @@
(def: (expand-tail val tail)
(All [a] (-> a (Base a) (Base a)))
(let [tail-size (array.size tail)]
- (|> (array.new (n/inc tail-size))
+ (|> (array.new (inc tail-size))
(array.copy tail-size +0 tail +0)
(array.write tail-size val))))
@@ -194,7 +194,7 @@
(if (|> vec-size (n/- (tail-off vec-size)) (n/< full-node-size))
## If so, append to it.
(|> vec
- (update@ #size n/inc)
+ (update@ #size inc)
(update@ #tail (expand-tail val)))
## Otherwise, push tail into the tree
## --------------------------------------------------------
@@ -216,7 +216,7 @@
(update@ #root (push-tail vec-size (get@ #level vec) (get@ #tail vec)))))
## Finally, update the size of the Sequence and grow a new
## tail with the new element as it's sole member.
- (update@ #size n/inc)
+ (update@ #size inc)
(set@ #tail (new-tail val)))
)))
@@ -287,9 +287,9 @@
vec-size
(if (|> vec-size (n/- (tail-off vec-size)) (n/> +1))
(let [old-tail (get@ #tail vec)
- new-tail-size (n/dec (array.size old-tail))]
+ new-tail-size (dec (array.size old-tail))]
(|> vec
- (update@ #size n/dec)
+ (update@ #size dec)
(set@ #tail (|> (array.new new-tail-size)
(array.copy new-tail-size +0 old-tail +0)))))
(maybe.assume
@@ -311,7 +311,7 @@
[level root])
[level root])))]]
(wrap (|> vec
- (update@ #size n/dec)
+ (update@ #size dec)
(set@ #level level')
(set@ #root root')
(set@ #tail new-tail))))))
diff --git a/stdlib/source/lux/data/coll/stream.lux b/stdlib/source/lux/data/coll/stream.lux
index d04b808fb..305a5da4e 100644
--- a/stdlib/source/lux/data/coll/stream.lux
+++ b/stdlib/source/lux/data/coll/stream.lux
@@ -60,7 +60,7 @@
(All [a] (-> Nat (Stream a) a))
(let [[h t] (continuation.run s)]
(if (n/> +0 idx)
- (nth (n/dec idx) t)
+ (nth (dec idx) t)
h)))
(do-template [<taker> <dropper> <splitter> <pred-type> <pred-test> <pred-step>]
@@ -90,7 +90,7 @@
[(list) xs])))]
[take-while drop-while split-while (-> a Bool) (pred x) pred]
- [take drop split Nat (n/> +0 pred) (n/dec pred)]
+ [take drop split Nat (n/> +0 pred) (dec pred)]
)
(def: #export (unfold step init)
diff --git a/stdlib/source/lux/data/color.lux b/stdlib/source/lux/data/color.lux
index dc15c8a6b..8e6254c6b 100644
--- a/stdlib/source/lux/data/color.lux
+++ b/stdlib/source/lux/data/color.lux
@@ -6,17 +6,17 @@
(type abstract)))
(def: rgb Nat +256)
-(def: top Nat (n/dec rgb))
+(def: top Nat (dec rgb))
-(def: rgb-factor Frac (nat-to-frac top))
+(def: rgb-factor Frac (|> top .int int-to-frac))
(def: scale-down
(-> Nat Frac)
- (|>> nat-to-frac (f// rgb-factor)))
+ (|>> .int int-to-frac (f// rgb-factor)))
(def: scale-up
(-> Frac Nat)
- (|>> (f/* rgb-factor) frac-to-nat))
+ (|>> (f/* rgb-factor) frac-to-int .nat))
(abstract: #export Color {}
{#red Nat
@@ -151,7 +151,7 @@
q (|> 1.0 (f/- (f/* f saturation)) (f/* brightness))
t (|> 1.0 (f/- (|> 1.0 (f/- f) (f/* saturation))) (f/* brightness))
v brightness
- mod (|> i (f/% 6.0) frac-to-nat)
+ mod (|> i (f/% 6.0) frac-to-int .nat)
red (case mod +0 v +1 q +2 p +3 p +4 t +5 v _ (undefined))
green (case mod +0 t +1 v +2 v +3 q +4 p +5 p _ (undefined))
blue (case mod +0 p +1 p +2 t +3 v +4 v +5 q _ (undefined))]
@@ -203,8 +203,10 @@
dE (|> 1.0 (f/- dS))
interpolate' (: (-> Nat Nat Nat)
(function (_ end start)
- (frac-to-nat (f/+ (f/* dE (nat-to-frac end))
- (f/* dS (nat-to-frac start))))))
+ (|> (|> start .int int-to-frac (f/* dS))
+ (f/+ (|> end .int int-to-frac (f/* dE)))
+ frac-to-int
+ .nat)))
[redS greenS blueS] (unpack start)
[redE greenE blueE] (unpack end)]
(color [(interpolate' redE redS)
@@ -283,19 +285,19 @@
(let [[hue saturation luminance] (to-hsl color)
slice (normalize slice)]
(L/map (function (_ idx)
- (from-hsl [(|> idx nat-to-frac (f/* slice) (f/+ hue) normalize)
+ (from-hsl [(|> idx .int int-to-frac (f/* slice) (f/+ hue) normalize)
saturation
luminance]))
- (list.n/range +0 (n/dec results))))))
+ (list.n/range +0 (dec results))))))
(def: #export (monochromatic results color)
(-> Nat Color (List Color))
(if (n/= +0 results)
(list)
(let [[hue saturation brightness] (to-hsb color)
- slice (|> 1.0 (f// (nat-to-frac results)))]
- (|> (list.n/range +0 (n/dec results))
- (L/map (|>> nat-to-frac
+ slice (|> 1.0 (f// (|> results .int int-to-frac)))]
+ (|> (list.n/range +0 (dec results))
+ (L/map (|>> .int int-to-frac
(f/* slice)
(f/+ brightness)
normalize
diff --git a/stdlib/source/lux/data/format/css.lux b/stdlib/source/lux/data/format/css.lux
index 5a203440d..360ef416f 100644
--- a/stdlib/source/lux/data/format/css.lux
+++ b/stdlib/source/lux/data/format/css.lux
@@ -40,17 +40,17 @@
(def: #export (rgb color)
(-> Color Value)
(let [[red green blue] (color.unpack color)]
- (format "rgb(" (|> red nat-to-int %i)
- "," (|> green nat-to-int %i)
- "," (|> blue nat-to-int %i)
+ (format "rgb(" (|> red .int %i)
+ "," (|> green .int %i)
+ "," (|> blue .int %i)
")")))
(def: #export (rgba color alpha)
(-> Color Deg Value)
(let [[red green blue] (color.unpack color)]
- (format "rgba(" (|> red nat-to-int %i)
- "," (|> green nat-to-int %i)
- "," (|> blue nat-to-int %i)
+ (format "rgba(" (|> red .int %i)
+ "," (|> green .int %i)
+ "," (|> blue .int %i)
"," (if (d/= (:: number.Interval<Deg> top) alpha)
"1.0"
(format "0" (%d alpha)))
diff --git a/stdlib/source/lux/data/format/xml.lux b/stdlib/source/lux/data/format/xml.lux
index d3c6292cd..ceeb59b1e 100644
--- a/stdlib/source/lux/data/format/xml.lux
+++ b/stdlib/source/lux/data/format/xml.lux
@@ -43,7 +43,7 @@
(#.Some _)
(p.codec number.Hex@Codec<Text,Int> (l.many l.hexadecimal)))]
- (wrap (|> code int-to-nat text.from-code)))
+ (wrap (|> code .nat text.from-code)))
(p.before (l.this ";"))
(p.after (l.this "&#"))))
diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux
index eb712d046..bb5cb8b8a 100644
--- a/stdlib/source/lux/data/number.lux
+++ b/stdlib/source/lux/data/number.lux
@@ -91,10 +91,10 @@
(def: succ <succ>)
(def: pred <pred>))]
- [Nat Order<Nat> n/inc n/dec]
- [Int Order<Int> i/inc i/dec]
+ [Nat Order<Nat> inc dec]
+ [Int Order<Int> inc dec]
[Frac Order<Frac> (f/+ ("lux frac smallest")) (f/- ("lux frac smallest"))]
- [Deg Order<Deg> (d/+ (:! Deg +1)) (d/- (:! Deg +1))]
+ [Deg Order<Deg> inc dec]
)
(do-template [<type> <enum> <top> <bottom>]
@@ -104,7 +104,7 @@
(def: bottom <bottom>))]
[ Nat Enum<Nat> (:! Nat -1) +0]
- [ Int Enum<Int> ("lux int max") ("lux int min")]
+ [ Int Enum<Int> 9_223_372_036_854_775_807 -9_223_372_036_854_775_808]
[Frac Enum<Frac> ("lux frac max") ("lux frac min")]
[ Deg Enum<Deg> (:! Deg -1) (:! Deg +0)]
)
@@ -173,7 +173,7 @@
## [Values & Syntax]
(def: (get-char full idx)
(-> Text Nat (Maybe Text))
- ("lux text clip" full idx (n/inc idx)))
+ ("lux text clip" full idx (inc idx)))
(def: (binary-character value)
(-> Nat (Maybe Text))
@@ -313,7 +313,7 @@
(#e.Error ("lux text concat" <error> repr))
(#.Some digit-value)
- (recur (n/inc idx)
+ (recur (inc idx)
(|> output (n/* <base>) (n/+ digit-value)))))
(#e.Success output)))
@@ -336,12 +336,12 @@
"-"
"")]
(loop [input (|> value (i// <base>) (:: Number<Int> abs))
- output (|> value (i/% <base>) (:: Number<Int> abs) int-to-nat
+ output (|> value (i/% <base>) (:: Number<Int> abs) .nat
<to-character>
maybe.assume)]
(if (i/= 0 input)
("lux text concat" sign output)
- (let [digit (maybe.assume (<to-character> (int-to-nat (i/% <base> input))))]
+ (let [digit (maybe.assume (<to-character> (.nat (i/% <base> input))))]
(recur (i// <base> input)
("lux text concat" digit output))))))))
@@ -363,7 +363,7 @@
(#e.Error <error>)
(#.Some digit-value)
- (recur (n/inc idx)
+ (recur (inc idx)
(|> output (i/* <base>) (i/+ (:! Int digit-value))))))
(#e.Success (i/* sign output)))))
(#e.Error <error>)))))]
@@ -388,7 +388,7 @@
output ""]
(if (n/= +0 zeroes-left)
output
- (recur (n/dec zeroes-left)
+ (recur (dec zeroes-left)
("lux text concat" "0" output))))
padded-output ("lux text concat" zero-padding raw-output)]
("lux text concat" "." padded-output)))
@@ -424,7 +424,7 @@
(if (f/= 0.0 dec-left)
("lux text concat" "." output)
(let [shifted (f/* <base> dec-left)
- digit (|> shifted (f/% <base>) frac-to-int int-to-nat
+ digit (|> shifted (f/% <base>) frac-to-int .nat
(get-char <char-set>) maybe.assume)]
(recur (f/% 1.0 shifted)
("lux text concat" output digit))))))]
@@ -434,7 +434,7 @@
(case ("lux text index" repr "." +0)
(#.Some split-index)
(let [whole-part (maybe.assume ("lux text clip" repr +0 split-index))
- decimal-part (maybe.assume ("lux text clip" repr (n/inc split-index) ("lux text size" repr)))]
+ decimal-part (maybe.assume ("lux text clip" repr (inc split-index) ("lux text size" repr)))]
(case [(:: <int> decode whole-part)
(:: <int> decode decimal-part)]
(^multi [(#e.Success whole) (#e.Success decimal)]
@@ -446,7 +446,7 @@
output 1.0]
(if (n/= +0 muls-left)
output
- (recur (n/dec muls-left)
+ (recur (dec muls-left)
(f/* <base> output))))
adjusted-decimal (|> decimal int-to-frac (f// div-power))
dec-deg (case (:: Hex@Codec<Text,Deg> decode ("lux text concat" "." decimal-part))
@@ -581,7 +581,7 @@
output ""]
(if (n/= +0 zeroes-left)
output
- (recur (n/dec zeroes-left)
+ (recur (dec zeroes-left)
("lux text concat" "0" output))))))
padded-input (if on-left?
("lux text concat" zero-padding input)
@@ -610,7 +610,7 @@
whole-part (maybe.assume ("lux text clip" raw-bin
(if (f/= -1.0 sign) +1 +0)
dot-idx))
- decimal-part (maybe.assume ("lux text clip" raw-bin (n/inc dot-idx) ("lux text size" raw-bin)))
+ decimal-part (maybe.assume ("lux text clip" raw-bin (inc dot-idx) ("lux text size" raw-bin)))
hex-output (|> (<from> false decimal-part)
("lux text concat" ".")
("lux text concat" (<from> true whole-part))
@@ -627,7 +627,7 @@
(case ("lux text index" repr "." +0)
(#.Some split-index)
(let [whole-part (maybe.assume ("lux text clip" repr (if (f/= -1.0 sign) +1 +0) split-index))
- decimal-part (maybe.assume ("lux text clip" repr (n/inc split-index) ("lux text size" repr)))
+ decimal-part (maybe.assume ("lux text clip" repr (inc split-index) ("lux text size" repr)))
as-binary (|> (<to> decimal-part)
("lux text concat" ".")
("lux text concat" (<to> whole-part))
@@ -755,7 +755,7 @@
(let [raw (|> (digits-get idx output)
(n/* +5)
(n/+ carry))]
- (recur (n/dec idx)
+ (recur (dec idx)
(n// +10 raw)
(digits-put idx (n/% +10 raw) output)))
output)))
@@ -766,21 +766,21 @@
output (|> (make-digits [])
(digits-put power +1))]
(if (i/>= 0 (:! Int times))
- (recur (n/dec times)
+ (recur (dec times)
(digits-times-5! power output))
output)))
(def: (digits-to-text digits)
(-> Digits Text)
- (loop [idx (n/dec bit.width)
+ (loop [idx (dec bit.width)
all-zeroes? true
output ""]
(if (i/>= 0 (:! Int idx))
(let [digit (digits-get idx digits)]
(if (and (n/= +0 digit)
all-zeroes?)
- (recur (n/dec idx) true output)
- (recur (n/dec idx)
+ (recur (dec idx) true output)
+ (recur (dec idx)
false
("lux text concat"
(:: Codec<Text,Int> encode (:! Int digit))
@@ -791,7 +791,7 @@
(def: (digits-add param subject)
(-> Digits Digits Digits)
- (loop [idx (n/dec bit.width)
+ (loop [idx (dec bit.width)
carry +0
output (make-digits [])]
(if (i/>= 0 (:! Int idx))
@@ -799,7 +799,7 @@
carry
(digits-get idx param)
(digits-get idx subject))]
- (recur (n/dec idx)
+ (recur (dec idx)
(n// +10 raw)
(digits-put idx (n/% +10 raw) output)))
output)))
@@ -817,7 +817,7 @@
#.None
(#.Some digit)
- (recur (n/inc idx)
+ (recur (inc idx)
(digits-put idx digit output))))
(#.Some output)))
#.None)))
@@ -829,7 +829,7 @@
(let [pd (digits-get idx param)
sd (digits-get idx subject)]
(if (n/= pd sd)
- (recur (n/inc idx))
+ (recur (inc idx))
(n/< pd sd))))))
(def: (digits-sub-once! idx param subject)
@@ -842,21 +842,21 @@
(n/- param))]
(|> subject
(digits-put idx diff)
- (digits-sub-once! (n/dec idx) +1))))))
+ (digits-sub-once! (dec idx) +1))))))
(def: (digits-sub! param subject)
(-> Digits Digits Digits)
- (loop [idx (n/dec bit.width)
+ (loop [idx (dec bit.width)
output subject]
- (if (i/>= 0 (nat-to-int idx))
- (recur (n/dec idx)
+ (if (i/>= 0 (.int idx))
+ (recur (dec idx)
(digits-sub-once! idx (digits-get idx param) output))
output)))
(struct: #export _ (Codec Text Deg)
(def: (encode input)
(let [input (:! Nat input)
- last-idx (n/dec bit.width)]
+ last-idx (dec bit.width)]
(if (n/= +0 input)
".0"
(loop [idx last-idx
@@ -865,9 +865,9 @@
(if (bit.set? idx input)
(let [digits' (digits-add (digits-power (n/- idx last-idx))
digits)]
- (recur (n/dec idx)
+ (recur (dec idx)
digits'))
- (recur (n/dec idx)
+ (recur (dec idx)
digits))
("lux text concat" "." (digits-to-text digits))
)))))
@@ -881,7 +881,7 @@
_
false)]
(if (and dotted?
- (n/<= (n/inc bit.width) length))
+ (n/<= (inc bit.width) length))
(case (|> ("lux text clip" input +1 length)
maybe.assume
text-to-digits)
@@ -893,10 +893,10 @@
(let [power (digits-power idx)]
(if (digits-lt power digits)
## Skip power
- (recur digits (n/inc idx) output)
+ (recur digits (inc idx) output)
(recur (digits-sub! power digits)
- (n/inc idx)
- (bit.set (n/- idx (n/dec bit.width)) output))))
+ (inc idx)
+ (bit.set (n/- idx (dec bit.width)) output))))
(#e.Success (:! Deg output))))
#.None
@@ -915,48 +915,48 @@
(def: exponent-size Nat +11)
(def: #export (frac-to-bits input)
- (-> Frac Nat)
- (cond (not-a-number? input)
- (hex "+7FF7FFFFFFFFFFFF")
-
- (f/= positive-infinity input)
- (hex "+7FF0000000000000")
-
- (f/= negative-infinity input)
- (hex "+FFF0000000000000")
-
- (f/= 0.0 input)
- (let [reciprocal (f// input 1.0)]
- (if (f/= positive-infinity reciprocal)
- ## Positive zero
- (hex "+0000000000000000")
- ## Negative zero
- (hex "+8000000000000000")))
-
- ## else
- (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) n/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 int-to-nat (n/+ double-bias) (bit.and exponent-mask))
- mantissa-bits (|> mantissa frac-to-int int-to-nat)]
- ($_ bit.or
- (bit.left-shift +63 sign-bit)
- (bit.left-shift mantissa-size exponent-bits)
- (bit.clear mantissa-size mantissa-bits)))
- ))
+ (-> Frac I64)
+ (i64 (cond (not-a-number? input)
+ (hex "+7FF7FFFFFFFFFFFF")
+
+ (f/= positive-infinity input)
+ (hex "+7FF0000000000000")
+
+ (f/= negative-infinity input)
+ (hex "+FFF0000000000000")
+
+ (f/= 0.0 input)
+ (let [reciprocal (f// input 1.0)]
+ (if (f/= positive-infinity reciprocal)
+ ## Positive zero
+ (hex "+0000000000000000")
+ ## Negative zero
+ (hex "+8000000000000000")))
+
+ ## else
+ (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)
+ 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))
+ 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)))
+ )))
(do-template [<getter> <mask> <size> <offset>]
- [(def: <mask> (|> +1 (bit.left-shift <size>) n/dec (bit.left-shift <offset>)))
+ [(def: <mask> (|> +1 (bit.left-shift <size>) dec (bit.left-shift <offset>)))
(def: (<getter> input)
- (-> Nat Nat)
- (|> input (bit.and <mask>) (bit.logical-right-shift <offset>)))]
+ (-> (I64 Top) I64)
+ (|> input (bit.and <mask>) (bit.logical-right-shift <offset>) i64))]
[mantissa mantissa-mask mantissa-size +0]
[exponent exponent-mask exponent-size mantissa-size]
@@ -964,7 +964,7 @@
)
(def: #export (bits-to-frac input)
- (-> Nat Frac)
+ (-> (I64 Top) Frac)
(let [S (sign input)
E (exponent input)
M (mantissa input)]
@@ -982,10 +982,10 @@
## else
(let [normalized (|> M (bit.set mantissa-size)
- nat-to-int int-to-frac
+ .int int-to-frac
(f// ("lux math pow" 2.0 52.0)))
power (|> E (n/- double-bias)
- nat-to-int int-to-frac
+ .int int-to-frac
("lux math pow" 2.0))
shifted (f/* power
normalized)]
@@ -1000,7 +1000,7 @@
(struct: #export _ (Hash Int)
(def: eq Eq<Int>)
- (def: hash int-to-nat))
+ (def: hash .nat))
(struct: #export _ (Hash Frac)
(def: eq Eq<Frac>)
diff --git a/stdlib/source/lux/data/number/complex.lux b/stdlib/source/lux/data/number/complex.lux
index 7d4fcbfbf..879ee0c1e 100644
--- a/stdlib/source/lux/data/number/complex.lux
+++ b/stdlib/source/lux/data/number/complex.lux
@@ -286,17 +286,17 @@
(-> Complex Frac)
(math.atan2 real imaginary))
-(def: #export (nth-roots nth input)
+(def: #export (roots nth input)
(-> Nat Complex (List Complex))
(if (n/= +0 nth)
(list)
- (let [r-nth (|> nth nat-to-int int-to-frac)
+ (let [r-nth (|> nth .int int-to-frac)
nth-root-of-abs (|> input c/abs (get@ #real) (math.pow (f// r-nth 1.0)))
nth-phi (|> input argument (f// r-nth))
slice (|> math.pi (f/* 2.0) (f// r-nth))]
- (|> (list.n/range +0 (n/dec nth))
+ (|> (list.n/range +0 (dec nth))
(L/map (function (_ nth')
- (let [inner (|> nth' nat-to-int int-to-frac
+ (let [inner (|> nth' .int int-to-frac
(f/* slice)
(f/+ nth-phi))
real (f/* nth-root-of-abs
diff --git a/stdlib/source/lux/data/text.lux b/stdlib/source/lux/data/text.lux
index 1a9aa112b..9dbf0dec5 100644
--- a/stdlib/source/lux/data/text.lux
+++ b/stdlib/source/lux/data/text.lux
@@ -49,7 +49,7 @@
(def: (last-index-of'' part since text)
(-> Text Nat Text (Maybe Nat))
- (case ("lux text index" text part (n/inc since))
+ (case ("lux text index" text part (inc since))
#.None
(#.Some since)
diff --git a/stdlib/source/lux/data/text/lexer.lux b/stdlib/source/lux/data/text/lexer.lux
index 980926b90..d965020e0 100644
--- a/stdlib/source/lux/data/text/lexer.lux
+++ b/stdlib/source/lux/data/text/lexer.lux
@@ -44,7 +44,7 @@
(function (_ [offset tape])
(case (text.nth offset tape)
(#.Some output)
- (#e.Success [[(n/inc offset) tape] (text.from-code output)])
+ (#e.Success [[(inc offset) tape] (text.from-code output)])
_
(#e.Error cannot-lex-error))
@@ -166,7 +166,7 @@
(#.Some output)
(let [output (text.from-code output)]
(if (text.contains? output options)
- (#e.Success [[(n/inc offset) tape] output])
+ (#e.Success [[(inc offset) tape] output])
(#e.Error ($_ text/compose "Character (" output ") is not one of: " options))))
_
@@ -180,7 +180,7 @@
(#.Some output)
(let [output (text.from-code output)]
(if (.not (text.contains? output options))
- (#e.Success [[(n/inc offset) tape] output])
+ (#e.Success [[(inc offset) tape] output])
(#e.Error ($_ text/compose "Character (" output ") is one of: " options))))
_
@@ -193,7 +193,7 @@
(case (text.nth offset tape)
(#.Some output)
(if (p output)
- (#e.Success [[(n/inc offset) tape] (text.from-code output)])
+ (#e.Success [[(inc offset) tape] (text.from-code output)])
(#e.Error ($_ text/compose "Character does not satisfy predicate: " (text.from-code output))))
_
diff --git a/stdlib/source/lux/data/text/regex.lux b/stdlib/source/lux/data/text/regex.lux
index 4bdc6d3c0..f644c4669 100644
--- a/stdlib/source/lux/data/text/regex.lux
+++ b/stdlib/source/lux/data/text/regex.lux
@@ -181,14 +181,14 @@
(l.Lexer Nat)
(|> (l.many l.decimal)
(p.codec number.Codec<Text,Int>)
- (p/map int-to-nat)))
+ (p/map .nat)))
(def: re-back-reference^
(l.Lexer Code)
(p.either (do p.Monad<Parser>
[_ (l.this "\\")
id number^]
- (wrap (` ((~! ..copy) (~ (code.symbol ["" (int/encode (nat-to-int id))]))))))
+ (wrap (` ((~! ..copy) (~ (code.symbol ["" (int/encode (.int id))]))))))
(do p.Monad<Parser>
[_ (l.this "\\k<")
captured-name identifier-part^
@@ -285,7 +285,7 @@
[idx (code.symbol ["" _name])]
#.None
- [(i/inc idx) (code.symbol ["" (int/encode idx)])])
+ [(inc idx) (code.symbol ["" (int/encode idx)])])
access (if (n/> +0 num-captures)
(` (product.left (~ name!)))
name!)]
diff --git a/stdlib/source/lux/lang/syntax.lux b/stdlib/source/lux/lang/syntax.lux
index 6c7236f76..bc1543cac 100644
--- a/stdlib/source/lux/lang/syntax.lux
+++ b/stdlib/source/lux/lang/syntax.lux
@@ -25,7 +25,7 @@
## (file-name, line, column) to keep track of their provenance and
## location, which is helpful for documentation and debugging.
(.module:
- lux
+ [lux #- nat int deg]
(lux (control monad
["p" parser "p/" Monad<Parser>]
["ex" exception #+ exception:])
@@ -74,7 +74,7 @@
comment (l.some (l.none-of new-line))
_ (l.this new-line)]
(wrap [(|> where
- (update@ #.line n/inc)
+ (update@ #.line inc)
(set@ #.column +0))
comment])))
@@ -111,7 +111,7 @@
[_ (l.this new-line)]
(recur (format comment new-line)
(|> where
- (update@ #.line n/inc)
+ (update@ #.line inc)
(set@ #.column +0))))
## This is the rule for handling nested sub-comments.
## Ultimately, the whole comment is just treated as text
@@ -238,7 +238,7 @@
(do @
[normal (l.none-of "\\\"\n")]
(wrap [(|> where
- (update@ #.column n/inc))
+ (update@ #.column inc))
normal]))
## Must handle escaped
## chars separately.
@@ -250,7 +250,7 @@
_ (l.this "\"")
#let [char (maybe.assume (text.nth +0 char))]]
(wrap [(|> where'
- (update@ #.column n/inc))
+ (update@ #.column inc))
[where (#.Nat char)]])))
(def: (normal-nat where)
@@ -341,7 +341,7 @@
## as many spaces as necessary to be column-aligned.
## This helps ensure that the formatting on the text in the
## source-code matches the formatting of the Text value.
- #let [offset-column (n/inc (get@ #.column where))]
+ #let [offset-column (inc (get@ #.column where))]
[where' text-read] (: (l.Lexer [Cursor Text])
## I must keep track of how much of the
## text body has been read, how far the
@@ -350,7 +350,7 @@
## processing normal text body.
(loop [text-read ""
where (|> where
- (update@ #.column n/inc))
+ (update@ #.column inc))
must-have-offset? false]
(p.either (if must-have-offset?
## If I'm at the start of a
@@ -375,8 +375,8 @@
(update@ #.column (n/+ offset-size)))
false)
(p.fail (format "Each line of a multi-line text must have an appropriate offset!\n"
- "Expected: " (%i (nat-to-int offset-column)) " columns.\n"
- " Actual: " (%i (nat-to-int offset-size)) " columns.\n"))))
+ "Expected: " (%i (.int offset-column)) " columns.\n"
+ " Actual: " (%i (.int offset-size)) " columns.\n"))))
($_ p.either
## Normal text characters.
(do @
@@ -397,7 +397,7 @@
## reaches the right-delimiter.
(do @
[_ (l.this "\"")]
- (wrap [(update@ #.column n/inc where)
+ (wrap [(update@ #.column inc where)
text-read]))))
## If a new-line is
## encountered, it gets
@@ -408,7 +408,7 @@
[_ (l.this new-line)]
(recur (format text-read new-line)
(|> where
- (update@ #.line n/inc)
+ (update@ #.line inc)
(set@ #.column +0))
true)))))]
(wrap [where'
@@ -439,7 +439,7 @@
## end-delimiter.
where' (left-padding^ where)
_ (l.this <close>)]
- (wrap [(update@ #.column n/inc where')
+ (wrap [(update@ #.column inc where')
(sequence.to-list elems)]))))]
(wrap [where'
[where (<tag> elems)]])))]
@@ -474,7 +474,7 @@
(do @
[where' (left-padding^ where)
_ (l.this "}")]
- (wrap [(update@ #.column n/inc where')
+ (wrap [(update@ #.column inc where')
(sequence.to-list elems)]))))]
(wrap [where'
[where (#.Record elems)]])))
@@ -537,7 +537,7 @@
[_ (l.this identifier-separator)
def-name ident-part^]
(wrap [["lux" def-name]
- (n/inc (text.size def-name))]))
+ (inc (text.size def-name))]))
## Not all identifiers must be specified with a module part.
## If that part is not provided, the identifier will be created
## with the empty "" text as the module.
diff --git a/stdlib/source/lux/lang/type.lux b/stdlib/source/lux/lang/type.lux
index 48db0b928..d7dc33ca9 100644
--- a/stdlib/source/lux/lang/type.lux
+++ b/stdlib/source/lux/lang/type.lux
@@ -92,7 +92,7 @@
type type]
(case type
(<tag> env sub-type)
- (recur (n/inc num-args) sub-type)
+ (recur (inc num-args) sub-type)
_
[num-args type])))]
@@ -301,7 +301,7 @@
(-> Nat Type Type)
(case size
+0 body
- _ (<tag> (list) (<name> (n/dec size) body))))]
+ _ (|> body (<name> (dec size)) (<tag> (list)))))]
[univ-q #.UnivQ]
[ex-q #.ExQ]
@@ -329,4 +329,4 @@
(-> Nat Type Type)
(case level
+0 elem-type
- _ (#.Primitive "#Array" (list (array (n/dec level) elem-type)))))
+ _ (|> elem-type (array (dec level)) (list) (#.Primitive "#Array"))))
diff --git a/stdlib/source/lux/lang/type/check.lux b/stdlib/source/lux/lang/type/check.lux
index 1853f0931..4537ae38d 100644
--- a/stdlib/source/lux/lang/type/check.lux
+++ b/stdlib/source/lux/lang/type/check.lux
@@ -114,6 +114,10 @@
(var::get id plist'))
))
+(def: (var::new id plist)
+ (-> Var Type-Vars Type-Vars)
+ (#.Cons [id #.None] plist))
+
(def: (var::put id value plist)
(-> Var (Maybe Type) Type-Vars Type-Vars)
(case plist
@@ -163,7 +167,7 @@
(Check [Nat Type])
(function (_ context)
(let [id (get@ #.ex-counter context)]
- (#e.Success [(update@ #.ex-counter n/inc context)
+ (#e.Success [(update@ #.ex-counter inc context)
[id (#.Ex id)]]))))
(do-template [<name> <outputT> <fail> <succeed>]
@@ -228,8 +232,8 @@
(function (_ context)
(let [id (get@ #.var-counter context)]
(#e.Success [(|> context
- (update@ #.var-counter n/inc)
- (update@ #.var-bindings (var::put id #.None)))
+ (update@ #.var-counter inc)
+ (update@ #.var-bindings (var::new id)))
[id (#.Var id)]]))))
(def: get-bindings
diff --git a/stdlib/source/lux/macro.lux b/stdlib/source/lux/macro.lux
index 1328fc034..8131db902 100644
--- a/stdlib/source/lux/macro.lux
+++ b/stdlib/source/lux/macro.lux
@@ -363,8 +363,12 @@
A prefix can be given (or just be empty text \"\") to better identify the code for debugging purposes."}
(-> Text (Meta Code))
(function (_ compiler)
- (#e.Success [(update@ #.seed n/inc compiler)
- (code.symbol ["" ($_ text/compose "__gensym__" prefix (:: number.Codec<Text,Nat> encode (get@ #.seed compiler)))])])))
+ (#e.Success [(update@ #.seed inc compiler)
+ (|> compiler
+ (get@ #.seed)
+ (:: number.Codec<Text,Nat> encode)
+ ($_ text/compose "__gensym__" prefix)
+ [""] code.symbol)])))
(def: (get-local-symbol ast)
(-> Code (Meta Text))
diff --git a/stdlib/source/lux/macro/code.lux b/stdlib/source/lux/macro/code.lux
index 10bfed3ef..44cd21b6d 100644
--- a/stdlib/source/lux/macro/code.lux
+++ b/stdlib/source/lux/macro/code.lux
@@ -1,5 +1,5 @@
(.module:
- lux
+ [lux #- nat int deg]
(lux (control [eq #+ Eq])
(data bool
number
diff --git a/stdlib/source/lux/macro/poly.lux b/stdlib/source/lux/macro/poly.lux
index 54a856463..4d9d6cf12 100644
--- a/stdlib/source/lux/macro/poly.lux
+++ b/stdlib/source/lux/macro/poly.lux
@@ -151,19 +151,19 @@
all-varsL (: (List Code) (list))]
(if (n/< num-args current-arg)
(if (n/= +0 current-arg)
- (let [varL (label (n/inc funcI))]
- (recur (n/inc current-arg)
+ (let [varL (label (inc funcI))]
+ (recur (inc current-arg)
(|> env'
(dict.put funcI [headT funcL])
- (dict.put (n/inc funcI) [(#.Bound (n/inc funcI)) varL]))
+ (dict.put (inc funcI) [(#.Bound (inc funcI)) varL]))
(#.Cons varL all-varsL)))
(let [partialI (|> current-arg (n/* +2) (n/+ funcI))
- partial-varI (n/inc partialI)
+ partial-varI (inc partialI)
partial-varL (label partial-varI)
- partialC (` ((~ funcL) (~+ (|> (list.n/range +0 (n/dec num-args))
- (list/map (|>> (n/* +2) n/inc (n/+ funcI) label))
+ partialC (` ((~ funcL) (~+ (|> (list.n/range +0 (dec num-args))
+ (list/map (|>> (n/* +2) inc (n/+ funcI) label))
list.reverse))))]
- (recur (n/inc current-arg)
+ (recur (inc current-arg)
(|> env'
(dict.put partialI [.Bottom partialC])
(dict.put partial-varI [(#.Bound partial-varI) partial-varL]))
@@ -215,7 +215,7 @@
(let [env-level (n// +2 (dict.size env))
bound-level (n// +2 idx)
bound-idx (n/% +2 idx)]
- (|> env-level n/dec (n/- bound-level) (n/* +2) (n/+ bound-idx))))
+ (|> env-level dec (n/- bound-level) (n/* +2) (n/+ bound-idx))))
(def: #export bound
(Poly Code)
@@ -402,7 +402,7 @@
(let [idx (adjusted-idx env idx)]
(if (n/= +0 idx)
(|> (dict.get idx env) maybe.assume product.left (to-code env))
- (` (.$ (~ (code.nat (n/dec idx)))))))
+ (` (.$ (~ (code.nat (dec idx)))))))
(#.Apply (#.Named ["lux" "Bottom"] _) (#.Bound idx))
(let [idx (adjusted-idx env idx)]
diff --git a/stdlib/source/lux/macro/poly/eq.lux b/stdlib/source/lux/macro/poly/eq.lux
index ec120e0e1..7d3083660 100644
--- a/stdlib/source/lux/macro/poly/eq.lux
+++ b/stdlib/source/lux/macro/poly/eq.lux
@@ -112,7 +112,7 @@
(do @
[g!eqs (poly.tuple (p.many Eq<?>))
#let [g!_ (code.local-symbol "_____________")
- indices (|> (list.size g!eqs) n/dec (list.n/range +0))
+ indices (|> (list.size g!eqs) dec (list.n/range +0))
g!lefts (list/map (|>> nat/encode (text/compose "left") code.local-symbol) indices)
g!rights (list/map (|>> nat/encode (text/compose "right") code.local-symbol) indices)]]
(wrap (` (: (~ (@Eq inputT))
diff --git a/stdlib/source/lux/macro/poly/functor.lux b/stdlib/source/lux/macro/poly/functor.lux
index 91a325198..525b292c7 100644
--- a/stdlib/source/lux/macro/poly/functor.lux
+++ b/stdlib/source/lux/macro/poly/functor.lux
@@ -29,7 +29,7 @@
(function (_ unwrappedT)
(if (n/= +1 num-vars)
(` (functor.Functor (~ (poly.to-code *env* unwrappedT))))
- (let [paramsC (|> num-vars n/dec list.indices (L/map (|>> %n code.local-symbol)))]
+ (let [paramsC (|> num-vars dec list.indices (L/map (|>> %n code.local-symbol)))]
(` (All [(~+ paramsC)]
(functor.Functor ((~ (poly.to-code *env* unwrappedT)) (~+ paramsC)))))))))
Arg<?> (: (-> Code (poly.Poly Code))
@@ -37,7 +37,7 @@
($_ p.either
## Type-var
(do p.Monad<Parser>
- [#let [varI (|> num-vars (n/* +2) n/dec)]
+ [#let [varI (|> num-vars (n/* +2) dec)]
_ (poly.var varI)]
(wrap (` ((~ funcC) (~ valueC)))))
## Variants
@@ -59,7 +59,7 @@
(do @
[_ (wrap [])
memberC (Arg<?> slotC)]
- (recur (n/inc idx)
+ (recur (inc idx)
(L/compose pairsCC (list [slotC memberC])))))
(wrap pairsCC)))))]
(wrap (` (case (~ valueC)
@@ -72,7 +72,7 @@
outL (code.local-symbol "____________outL")]
[inT+ outC] (poly.function (p.many poly.any)
(Arg<?> outL))
- #let [inC+ (|> (list.size inT+) n/dec
+ #let [inC+ (|> (list.size inT+) dec
(list.n/range +0)
(L/map (|>> %n (format "____________inC") code.local-symbol)))]]
(wrap (` (function ((~ g!) (~+ inC+))
diff --git a/stdlib/source/lux/macro/poly/json.lux b/stdlib/source/lux/macro/poly/json.lux
index 44075647d..51a996c4c 100644
--- a/stdlib/source/lux/macro/poly/json.lux
+++ b/stdlib/source/lux/macro/poly/json.lux
@@ -31,7 +31,7 @@
(def: tag
(-> Nat Frac)
- (|>> nat-to-int int-to-frac))
+ (|>> .int int-to-frac))
(def: (rec-encode non-rec)
(All [a] (-> (-> (-> a JSON)
@@ -40,28 +40,28 @@
(function (_ input)
(non-rec (rec-encode non-rec) input)))
-(def: low-mask Nat (|> +1 (bit.left-shift +32) n/dec))
+(def: low-mask Nat (|> +1 (bit.left-shift +32) dec))
(def: high-mask Nat (|> low-mask (bit.left-shift +32)))
(struct: _ (Codec JSON Nat)
(def: (encode input)
(let [high (|> input (bit.and high-mask) (bit.logical-right-shift +32))
low (bit.and low-mask input)]
- (#//.Array (sequence (|> high nat-to-int int-to-frac #//.Number)
- (|> low nat-to-int int-to-frac #//.Number)))))
+ (#//.Array (sequence (|> high .int int-to-frac #//.Number)
+ (|> low .int int-to-frac #//.Number)))))
(def: (decode input)
(<| (//.run input)
//.array
(do p.Monad<Parser>
[high //.number
low //.number])
- (wrap (n/+ (|> high frac-to-int int-to-nat (bit.left-shift +32))
- (|> low frac-to-int int-to-nat))))))
+ (wrap (n/+ (|> high frac-to-int .nat (bit.left-shift +32))
+ (|> low frac-to-int .nat))))))
(struct: _ (Codec JSON Int)
- (def: encode (|>> int-to-nat (:: Codec<JSON,Nat> encode)))
+ (def: encode (|>> .nat (:: Codec<JSON,Nat> encode)))
(def: decode
- (|>> (:: Codec<JSON,Nat> decode) (:: e.Functor<Error> map nat-to-int))))
+ (|>> (:: Codec<JSON,Nat> decode) (:: e.Functor<Error> map .int))))
(def: (nullable writer)
{#.doc "Builds a JSON generator for potentially inexistent values."}
@@ -159,7 +159,7 @@
(do @
[g!encoders (poly.tuple (p.many Codec<JSON,?>//encode))
#let [g!_ (code.local-symbol "_______")
- g!members (|> (list.size g!encoders) n/dec
+ g!members (|> (list.size g!encoders) dec
(list.n/range +0)
(list/map (|>> nat/encode code.local-symbol)))]]
(wrap (` (: (~ (@JSON//encode inputT))
diff --git a/stdlib/source/lux/macro/syntax.lux b/stdlib/source/lux/macro/syntax.lux
index 0907d3d81..5f5c17e20 100644
--- a/stdlib/source/lux/macro/syntax.lux
+++ b/stdlib/source/lux/macro/syntax.lux
@@ -1,5 +1,5 @@
(.module:
- lux
+ [lux #- nat int deg]
(lux [macro #+ with-gensyms]
(control [monad #+ do Monad]
[eq #+ Eq]
diff --git a/stdlib/source/lux/math.lux b/stdlib/source/lux/math.lux
index 25cf120a3..5994a3c22 100644
--- a/stdlib/source/lux/math.lux
+++ b/stdlib/source/lux/math.lux
@@ -89,7 +89,7 @@
n n]
(if (n/<= +1 n)
acc
- (recur (n/* n acc) (n/dec n)))))
+ (recur (n/* n acc) (dec n)))))
(def: #export (hypotenuse catA catB)
(-> Frac Frac Frac)
diff --git a/stdlib/source/lux/math/random.lux b/stdlib/source/lux/math/random.lux
index e90c3eb6d..484574c82 100644
--- a/stdlib/source/lux/math/random.lux
+++ b/stdlib/source/lux/math/random.lux
@@ -1,5 +1,5 @@
(.module: {#.doc "Pseudo-random number generation (PRNG) algorithms."}
- [lux #- list]
+ [lux #- list i64 nat int deg]
(lux (control [functor #+ Functor]
[apply #+ Apply]
[monad #+ do Monad]
@@ -22,7 +22,7 @@
(type: #export #rec PRNG
{#.doc "An abstract way to represent any PRNG."}
- (-> Top [PRNG Nat]))
+ (-> Top [PRNG I64]))
(type: #export (Random a)
{#.doc "A producer of random values based on a PRNG."}
@@ -64,37 +64,36 @@
(wrap sample)
(filter pred gen))))
-(def: #export nat
- (Random Nat)
- (function (_ prng)
- (let [[prng left] (prng [])
- [prng right] (prng [])]
- [prng (n/+ (bit.left-shift +32 left)
- right)])))
-
-(def: #export int
- (Random Int)
- (:: Monad<Random> map nat-to-int nat))
-
(def: #export bool
(Random Bool)
(function (_ prng)
(let [[prng output] (prng [])]
[prng (|> output (bit.and +1) (n/= +1))])))
-(def: (bits n)
- (-> Nat (Random Nat))
+(def: #export i64
+ (Random I64)
(function (_ prng)
- (let [[prng output] (prng [])]
- [prng (bit.logical-right-shift (n/- n +64) output)])))
+ (let [[prng left] (prng [])
+ [prng right] (prng [])]
+ [prng (|> left
+ (bit.left-shift +32)
+ ("lux i64 +" right))])))
-(def: #export frac
- (Random Frac)
- (:: Monad<Random> map number.bits-to-frac nat))
+(def: #export nat
+ (Random Nat)
+ (:: Monad<Random> map .nat ..i64))
+
+(def: #export int
+ (Random Int)
+ (:: Monad<Random> map .int ..i64))
(def: #export deg
(Random Deg)
- (:: Monad<Random> map (|>> (:! Deg)) nat))
+ (:: Monad<Random> map .deg ..i64))
+
+(def: #export frac
+ (Random Frac)
+ (:: Monad<Random> map number.bits-to-frac nat))
(def: #export (text' char-gen size)
(-> (Random Nat) Nat (Random Text))
@@ -102,18 +101,18 @@
(:: Monad<Random> wrap "")
(do Monad<Random>
[x char-gen
- xs (text' char-gen (n/dec size))]
+ xs (text' char-gen (dec size))]
(wrap (text/compose (text.from-code x) xs)))))
-(type: Char-Range [Nat Nat])
+(type: Region [Nat Nat])
(do-template [<name> <from> <to>]
- [(def: <name> Char-Range [(hex <from>) (hex <to>)])]
+ [(def: <name> Region [(hex <from>) (hex <to>)])]
- [Thaana "+0780" "+07BF"]
- [Khmer-Symbols "+19E0" "+19FF"]
+ [Thaana "+0780" "+07BF"]
+ [Khmer-Symbols "+19E0" "+19FF"]
[Phonetic-Extensions "+1D00" "+1D7F"]
- [Hangul-Syllables "+AC00" "+D7AF"]
+ [Hangul-Syllables "+AC00" "+D7AF"]
[Cypriot-Syllabary "+10800" "+1083F"]
[Tai-Xuan-Jing-Symbols "+1D300" "+1D35F"]
@@ -123,10 +122,11 @@
)
(def: (within? [from to] char)
- (-> Char-Range Nat Bool)
- (and (n/>= from char) (n/<= to char)))
+ (-> Region Nat Bool)
+ (and (n/>= from char)
+ (n/<= to char)))
-(def: unicode-ceiling (n/inc (product.right CJK-Compatibility-Ideographs-Supplement)))
+(def: unicode-ceiling (|> CJK-Compatibility-Ideographs-Supplement product.right inc))
(def: #export unicode
(Random Nat)
@@ -254,7 +254,7 @@
(if (n/> +0 size)
(do Monad<Random>
[x value-gen
- xs (<name> (n/dec size) value-gen)]
+ xs (<name> (dec size) value-gen)]
(wrap (<plus> x xs)))
(:: Monad<Random> wrap <zero>)))]
@@ -278,7 +278,7 @@
(All [a] (-> (Hash a) Nat (Random a) (Random (Set a))))
(if (n/> +0 size)
(do Monad<Random>
- [xs (set Hash<a> (n/dec size) value-gen)]
+ [xs (set Hash<a> (dec size) value-gen)]
(loop [_ []]
(do @
[x value-gen
@@ -292,7 +292,7 @@
(All [k v] (-> (Hash k) Nat (Random k) (Random v) (Random (Dict k v))))
(if (n/> +0 size)
(do Monad<Random>
- [kv (dict Hash<a> (n/dec size) key-gen value-gen)]
+ [kv (dict Hash<a> (dec size) key-gen value-gen)]
(loop [_ []]
(do @
[k key-gen
@@ -313,28 +313,30 @@
{#.doc "An implementation of the PCG32 algorithm.
For more information, please see: http://www.pcg-random.org/"}
- (-> [Nat Nat] PRNG)
+ (-> [(I64 Top) (I64 Top)] PRNG)
(function (_ _)
- (let [seed' (|> seed (n/* pcg-32-magic-mult) (n/+ inc))
- xor-shifted (|> seed (bit.logical-right-shift +18) (bit.xor seed) (bit.logical-right-shift +27))
- rot (|> seed (bit.logical-right-shift +59))]
- [(pcg-32 [inc seed']) (bit.rotate-right rot xor-shifted)]
- )))
+ [(|> seed .nat (n/* pcg-32-magic-mult) ("lux i64 +" inc) [inc] pcg-32)
+ (let [rot (|> seed .i64 (bit.logical-right-shift +59))]
+ (|> seed
+ (bit.logical-right-shift +18)
+ (bit.xor seed)
+ (bit.logical-right-shift +27)
+ (bit.rotate-right rot)
+ .i64))]))
(def: #export (xoroshiro-128+ [s0 s1])
{#.doc "An implementation of the Xoroshiro128+ algorithm.
For more information, please see: http://xoroshiro.di.unimi.it/"}
- (-> [Nat Nat] PRNG)
+ (-> [(I64 Top) (I64 Top)] PRNG)
(function (_ _)
- (let [result (n/+ s0 s1)
- s01 (bit.xor s0 s1)
- s0' (|> (bit.rotate-left +55 s0)
- (bit.xor s01)
- (bit.xor (bit.left-shift +14 s01)))
- s1' (bit.rotate-left +36 s01)]
- [(xoroshiro-128+ [s0' s1']) result])
- ))
+ [(let [s01 (bit.xor s0 s1)]
+ (xoroshiro-128+ [(|> s0
+ (bit.rotate-left +55)
+ (bit.xor s01)
+ (bit.xor (bit.left-shift +14 s01)))
+ (bit.rotate-left +36 s01)]))
+ ("lux i64 +" s0 s1)]))
(def: (swap from to vec)
(All [a] (-> Nat Nat (Sequence a) (Sequence a)))
@@ -352,7 +354,7 @@
[rand nat]
(wrap (swap idx (n/% _size rand) vec))))
sequence
- (list.n/range +0 (n/dec _size)))]
+ (list.n/range +0 (dec _size)))]
(|> _shuffle
(run (pcg-32 [+123 seed]))
product.right)))
diff --git a/stdlib/source/lux/test.lux b/stdlib/source/lux/test.lux
index 7162d8e4f..c78424559 100644
--- a/stdlib/source/lux/test.lux
+++ b/stdlib/source/lux/test.lux
@@ -17,22 +17,12 @@
[duration])
["r" math/random]))
-## [Host]
-(do-template [<name> <signal>]
- [(def: <name>
- (IO Bottom)
- (io.exit <signal>))]
-
- [exit 0]
- [die 1]
- )
-
## [Types]
(type: #export Counters [Nat Nat])
(type: #export Seed
{#.doc "The seed value used for random testing (if that feature is used)."}
- Nat)
+ (I64 Top))
(type: #export Test
(r.Random (Promise [Counters Text])))
@@ -74,10 +64,10 @@
(list/map (: (-> [Text (IO Test) Text] (Promise Counters))
(function (_ [module test description])
(do @
- [#let [pre (io.run instant.now)
- seed (int-to-nat (instant.to-millis pre))]
+ [#let [pre (io.run instant.now)]
[counters documentation] (|> (io.run test)
- (r.run (r.pcg-32 [pcg-32-magic-inc seed]))
+ (r.run (r.pcg-32 [pcg-32-magic-inc
+ (instant.to-millis pre)]))
product.right)
#let [post (io.run instant.now)
_ (log! (format "@ " module " "
@@ -100,6 +90,11 @@
test)]
[prng result])))
+(def: (times-failure seed documentation)
+ (-> (I64 Top) Text Text)
+ (format "Failed with this seed: " (%n (.nat seed)) "\n"
+ documentation))
+
(def: #export (times amount test)
(-> Nat Test Test)
(cond (n/= +0 amount)
@@ -110,14 +105,14 @@
## else
(do r.Monad<Random>
- [seed r.nat]
+ [seed r.i64]
(function (_ prng)
(let [[prng' instance] (r.run (r.pcg-32 [pcg-32-magic-inc seed]) test)]
[prng' (do promise.Monad<Promise>
[[counters documentation] instance]
(if (failed? counters)
- (wrap [counters (format "Failed with this seed: " (%n seed) "\n" documentation)])
- (product.right (r.run prng' (times (n/dec amount) test)))))])))))
+ (wrap [counters (times-failure seed documentation)])
+ (product.right (r.run prng' (times (dec amount) test)))))])))))
## [Syntax]
(syntax: #export (context: description test)
@@ -129,7 +124,7 @@
(loop [counter 0
value 1]
(if (i/< 3 counter)
- (recur (i/inc counter) (i/* 10 value))
+ (recur (inc counter) (i/* 10 value))
value))))
(test "Can create lists easily through macros."
@@ -213,47 +208,43 @@
(list.filter product.left)
(list/map product.right)))))
+(def: (success-message successes failures)
+ (-> Nat Nat Text)
+ (format "Test-suite finished." "\n"
+ (%i (.int successes)) " out of " (%i (.int (n/+ failures successes))) " tests passed." "\n"
+ (%i (.int failures)) " tests failed." "\n"))
+
(syntax: #export (run)
{#.doc (doc "Runs all the tests defined on the current module, and in all imported modules."
(run))}
- (with-gensyms [g!successes g!failures g!total-successes g!total-failures g!text/compose]
+ (with-gensyms [g!successes g!failures g!total-successes g!total-failures]
(do @
[current-module macro.current-module-name
modules (macro.imported-modules current-module)
tests (: (Meta (List [Text Text Text]))
- (|> (#.Cons current-module modules)
+ (|> modules
+ (#.Cons current-module)
list.reverse
(monad.map @ exported-tests)
- (:: @ map list/join)))
- #let [tests+ (list/map (function (_ [module-name test desc])
- (` [(~ (code.text module-name)) (~ (code.symbol [module-name test])) (~ (code.text desc))]))
- tests)
- num-tests (list.size tests+)
- groups (list.split-all promise.parallelism-level tests+)]]
+ (:: @ map list/join)))]
(wrap (list (` (: (~! (IO Top))
((~! io) (exec ((~! do) (~! promise.Monad<Promise>)
[(~' #let) [(~ g!total-successes) +0
(~ g!total-failures) +0]
- (~+ (list/join (list/map (function (_ group)
- (list (` [(~ g!successes) (~ g!failures)]) (` ((~! run') (list (~+ group))))
- (' #let) (` [(~ g!total-successes) (n/+ (~ g!successes) (~ g!total-successes))
- (~ g!total-failures) (n/+ (~ g!failures) (~ g!total-failures))])))
- groups)))]
- (exec (let [(~ g!text/compose) (:: (~! text.Monoid<Text>) (~' compose))]
- (log! ($_ (~ g!text/compose)
- "Test-suite finished."
- "\n"
- ((~! %i) (nat-to-int (~ g!total-successes)))
- " out of "
- ((~! %i) (nat-to-int (n/+ (~ g!total-failures)
- (~ g!total-successes))))
- " tests passed."
- "\n"
- ((~! %i) (nat-to-int (~ g!total-failures))) " tests failed.")))
+ (~+ (|> tests
+ (list/map (function (_ [module-name test desc])
+ (` [(~ (code.text module-name)) (~ (code.symbol [module-name test])) (~ (code.text desc))])))
+ (list.split-all promise.parallelism)
+ (list/map (function (_ group)
+ (list (` [(~ g!successes) (~ g!failures)]) (` ((~! run') (list (~+ group))))
+ (' #let) (` [(~ g!total-successes) (n/+ (~ g!successes) (~ g!total-successes))
+ (~ g!total-failures) (n/+ (~ g!failures) (~ g!total-failures))]))))
+ list/join))]
+ (exec (log! ((~! success-message) (~ g!total-successes) (~ g!total-failures)))
((~! promise.future)
- (if (n/> +0 (~ g!total-failures))
- (~! ..die)
- (~! ..exit)))))
+ ((~! io.exit) (if (n/> +0 (~ g!total-failures))
+ 1
+ 0)))))
[])))))))))
(def: #export (seq left right)
diff --git a/stdlib/source/lux/time/date.lux b/stdlib/source/lux/time/date.lux
index 61c73835a..93fa324cb 100644
--- a/stdlib/source/lux/time/date.lux
+++ b/stdlib/source/lux/time/date.lux
@@ -228,8 +228,8 @@
(-> Date Text)
($_ text/compose
(int/encode year) "-"
- (pad (|> month month-to-nat n/inc nat-to-int)) "-"
- (pad (|> day nat-to-int))))
+ (pad (|> month month-to-nat inc .int)) "-"
+ (pad (|> day .int))))
(def: lex-year
(l.Lexer Int)
@@ -260,7 +260,7 @@
(def: leap-year-months
(Sequence Nat)
- (sequence.update [+1] n/inc normal-months))
+ (sequence.update [+1] inc normal-months))
(def: (divisible? factor input)
(-> Int Int Bool)
@@ -286,13 +286,13 @@
leap-year-months
normal-months)
month-days (|> months
- (sequence.nth (int-to-nat (i/dec utc-month)))
+ (sequence.nth (.nat (dec utc-month)))
maybe.assume)]
_ (l.this "-")
utc-day lex-section
_ (p.assert "Invalid day."
(and (i/>= 1 utc-day)
- (i/<= (nat-to-int month-days) utc-day)))]
+ (i/<= (.int month-days) utc-day)))]
(wrap {#year utc-year
#month (case utc-month
1 #January
@@ -308,7 +308,7 @@
11 #November
12 #December
_ (undefined))
- #day (int-to-nat utc-day)})))
+ #day (.nat utc-day)})))
(def: (decode input)
(-> Text (e.Error Date))
diff --git a/stdlib/source/lux/time/instant.lux b/stdlib/source/lux/time/instant.lux
index 018eeb936..c4d3c6fdf 100644
--- a/stdlib/source/lux/time/instant.lux
+++ b/stdlib/source/lux/time/instant.lux
@@ -97,8 +97,8 @@
(if (i/= 0 (duration.query year time-left))
[reference time-left]
(if (duration/>= duration.empty time-left)
- (recur (i/inc reference) (duration.merge (duration.scale -1 year) time-left))
- (recur (i/dec reference) (duration.merge year time-left)))
+ (recur (inc reference) (duration.merge (duration.scale -1 year) time-left))
+ (recur (dec reference) (duration.merge year time-left)))
))))
(def: normal-months
@@ -110,23 +110,23 @@
(def: leap-year-months
(Sequence Nat)
- (sequence.update [+1] n/inc normal-months))
+ (sequence.update [+1] inc normal-months))
(def: (find-month months time)
(-> (Sequence Nat) duration.Duration [Nat duration.Duration])
(if (duration/>= duration.empty time)
(sequence/fold (function (_ month-days [current-month time-left])
- (let [month-duration (duration.scale (nat-to-int month-days) duration.day)]
+ (let [month-duration (duration.scale (.int month-days) duration.day)]
(if (i/= 0 (duration.query month-duration time-left))
[current-month time-left]
- [(n/inc current-month) (duration.merge (duration.scale -1 month-duration) time-left)])))
+ [(inc current-month) (duration.merge (duration.scale -1 month-duration) time-left)])))
[+0 time]
months)
(sequence/fold (function (_ month-days [current-month time-left])
- (let [month-duration (duration.scale (nat-to-int month-days) duration.day)]
+ (let [month-duration (duration.scale (.int month-days) duration.day)]
(if (i/= 0 (duration.query month-duration time-left))
[current-month time-left]
- [(n/dec current-month) (duration.merge month-duration time-left)])))
+ [(dec current-month) (duration.merge month-duration time-left)])))
[+11 time]
(sequence.reverse months))))
@@ -176,7 +176,7 @@
day-time (duration.frame duration.day offset)
days-of-year (if (duration/>= duration.empty day-time)
days-of-year
- (i/dec days-of-year))
+ (dec days-of-year))
mp (|> days-of-year (i/* 5) (i/+ 2) (i// 153))
day (|> days-of-year
(i/- (|> mp (i/* 153) (i/+ 2) (i// 5)))
@@ -186,7 +186,7 @@
3
-9)))
year (if (i/<= 2 month)
- (i/inc year)
+ (inc year)
year)]
[[year month day]
day-time]))
@@ -251,13 +251,13 @@
leap-year-months
normal-months)
month-days (|> months
- (sequence.nth (int-to-nat (i/dec utc-month)))
+ (sequence.nth (.nat (dec utc-month)))
maybe.assume)]
_ (l.this "-")
utc-day lex-section
_ (p.assert "Invalid day."
(and (i/>= 1 utc-day)
- (i/<= (nat-to-int month-days) utc-day)))
+ (i/<= (.int month-days) utc-day)))
_ (l.this "T")
utc-hour lex-section
_ (p.assert "Invalid hour."
@@ -277,16 +277,16 @@
_ (l.this "Z")
#let [years-since-epoch (i/- epoch-year utc-year)
previous-leap-days (i/- (leap-years epoch-year)
- (leap-years (i/dec utc-year)))
+ (leap-years (dec utc-year)))
year-days-so-far (|> (i/* 365 years-since-epoch)
(i/+ previous-leap-days))
month-days-so-far (|> months
sequence.to-list
- (list.take (int-to-nat (i/dec utc-month)))
+ (list.take (.nat (dec utc-month)))
(L/fold n/+ +0))
total-days (|> year-days-so-far
- (i/+ (nat-to-int month-days-so-far))
- (i/+ (i/dec utc-day)))]]
+ (i/+ (.int month-days-so-far))
+ (i/+ (dec utc-day)))]]
(wrap (|> epoch
(shift (duration.scale total-days duration.day))
(shift (duration.scale utc-hour duration.hour))
@@ -314,7 +314,7 @@
(-> Instant date.Date)
(let [[[year month day] _] (extract-date instant)]
{#date.year year
- #date.month (case (i/dec month)
+ #date.month (case (dec month)
0 #date.January
1 #date.February
2 #date.March
@@ -328,7 +328,7 @@
10 #date.November
11 #date.December
_ (undefined))
- #date.day (int-to-nat day)}))
+ #date.day (.nat day)}))
(def: #export (month instant)
(-> Instant date.Month)
@@ -342,7 +342,7 @@
day-time (duration.frame duration.day offset)
days (if (and (duration.negative? offset)
(not (duration.neutral? day-time)))
- (i/dec days)
+ (dec days)
days)
## 1970/01/01 was a Thursday
y1970m0d0 4]
diff --git a/stdlib/source/lux/type/implicit.lux b/stdlib/source/lux/type/implicit.lux
index 0decd9dba..0d6f5b4df 100644
--- a/stdlib/source/lux/type/implicit.lux
+++ b/stdlib/source/lux/type/implicit.lux
@@ -66,7 +66,7 @@
(#.Product left right)
(if (n/= +0 idx)
(:: tc.Monad<Check> wrap left)
- (find-member-type (n/dec idx) right))
+ (find-member-type (dec idx) right))
_
(if (n/= +0 idx)
@@ -328,7 +328,7 @@
(list.n/range +1 +10)
(list.n/range +1 +10))
"(Functor List) map"
- (::: map n/inc (list.n/range +0 +9))
+ (::: map inc (list.n/range +0 +9))
"Caveat emptor: You need to make sure to import the module of any structure you want to use."
"Otherwise, this macro will not find it.")}
(case args
diff --git a/stdlib/source/lux/type/object/interface.lux b/stdlib/source/lux/type/object/interface.lux
index f94177cd0..393fa929f 100644
--- a/stdlib/source/lux/type/object/interface.lux
+++ b/stdlib/source/lux/type/object/interface.lux
@@ -64,7 +64,7 @@
(if (list.empty? ancestors)
(list)
(|> (list.size ancestors)
- n/dec
+ dec
(list.n/range +0)
(list/map (|>> %n (format "ancestor") code.local-symbol)))))
@@ -102,7 +102,7 @@
g!_behavior (code.symbol ["" "_behavior"])
g!_state (code.symbol ["" "_state"])
g!_extension (code.symbol ["" "_extension"])
- g!_args (list/map (|>> product.left nat-to-int %i (format "_") code.local-symbol)
+ g!_args (list/map (|>> product.left .int %i (format "_") code.local-symbol)
(list.enumerate inputs))
g!destructuring (list/fold (function (_ _ g!bottom) (` [(~ g!_temp) (~ g!_temp) (~ g!bottom)]))
(` [(~ g!_behavior) (~ g!_state) (~ g!_extension)])
@@ -166,7 +166,7 @@
currentT newT]
(case currentT
(#.UnivQ _ bodyT)
- (recur (n/inc depth) bodyT)
+ (recur (inc depth) bodyT)
(#.Function inputT outputT)
(let [[stateT+ objectT] (type.flatten-function currentT)]
@@ -182,9 +182,9 @@
typeC
size
- (|> (n/dec size)
+ (|> (dec size)
(list.n/range +0)
- (list/map (|>> (n/* +2) n/inc code.nat (~) #.Bound (`)))
+ (list/map (|>> (n/* +2) inc code.nat (~) #.Bound (`)))
(list.zip2 (list.reverse mappings))
(list/fold (function (_ [mappingC boundC] genericC)
(code.replace boundC mappingC genericC))
diff --git a/stdlib/source/lux/type/resource.lux b/stdlib/source/lux/type/resource.lux
index 4558fa3a4..c25db4aab 100644
--- a/stdlib/source/lux/type/resource.lux
+++ b/stdlib/source/lux/type/resource.lux
@@ -150,7 +150,7 @@
(#.Cons head tail)
(do macro.Monad<Meta>
[#let [max-idx (list/fold n/max head tail)]
- g!inputs (<| (monad.seq @) (list.repeat (n/inc max-idx)) (macro.gensym "input"))
+ g!inputs (<| (monad.seq @) (list.repeat (inc max-idx)) (macro.gensym "input"))
#let [g!outputs (|> (monad.fold maybe.Monad<Maybe>
(function (_ from to)
(do maybe.Monad<Maybe>
diff --git a/stdlib/source/lux/type/unit.lux b/stdlib/source/lux/type/unit.lux
index 1615a47c7..2af12b5df 100644
--- a/stdlib/source/lux/type/unit.lux
+++ b/stdlib/source/lux/type/unit.lux
@@ -82,7 +82,7 @@
denominator s.int
_ (p.assert (format "Denominator must be positive: " (%i denominator))
(i/> 0 denominator))]
- (wrap [(int-to-nat numerator) (int-to-nat denominator)]))))
+ (wrap [(.nat numerator) (.nat denominator)]))))
(syntax: #export (scale:
{export csr.export}
@@ -97,13 +97,13 @@
(..Scale (~ g!scale))
(def: (~' scale)
(|>> ..out
- (i/* (~ (code.int (nat-to-int numerator))))
- (i// (~ (code.int (nat-to-int denominator))))
+ (i/* (~ (code.int (.int numerator))))
+ (i// (~ (code.int (.int denominator))))
..in))
(def: (~' de-scale)
(|>> ..out
- (i/* (~ (code.int (nat-to-int denominator))))
- (i// (~ (code.int (nat-to-int numerator))))
+ (i/* (~ (code.int (.int denominator))))
+ (i// (~ (code.int (.int numerator))))
..in))
(def: (~' ratio)
[(~ (code.nat numerator)) (~ (code.nat denominator))])))
@@ -139,8 +139,8 @@
(let [[numerator denominator] (|> (:: to ratio) (r.r// (:: from ratio)))]
(|> quantity
out
- (i/* (nat-to-int numerator))
- (i// (nat-to-int denominator))
+ (i/* (.int numerator))
+ (i// (.int denominator))
in)))
(scale: #export Kilo [1 1_000])
@@ -174,5 +174,5 @@
(struct: #export Enum<Unit> (All [unit] (Enum (Qty unit)))
(def: order Order<Unit>)
- (def: succ (|>> ..out i/inc ..in))
- (def: pred (|>> ..out i/dec ..in)))
+ (def: succ (|>> ..out inc ..in))
+ (def: pred (|>> ..out dec ..in)))
diff --git a/stdlib/source/lux/world/blob.jvm.lux b/stdlib/source/lux/world/blob.jvm.lux
index 077fa3863..2cb4ed291 100644
--- a/stdlib/source/lux/world/blob.jvm.lux
+++ b/stdlib/source/lux/world/blob.jvm.lux
@@ -1,5 +1,5 @@
(.module:
- lux
+ [lux #- i64]
(lux (control [monad #+ do]
["ex" exception #+ exception:]
[eq])
@@ -22,96 +22,100 @@
(#static equals [(Array byte) (Array byte)] boolean))
(def: byte-mask
- Nat
- (|> +1 (bit.left-shift +8) n/dec))
+ I64
+ (|> +1 (bit.left-shift +8) dec .i64))
-(def: byte-to-nat
- (-> (primitive "java.lang.Byte") Nat)
- (|>> host.byte-to-long (:! Nat) (bit.and byte-mask)))
+(def: i64
+ (-> (primitive "java.lang.Byte") I64)
+ (|>> host.byte-to-long (:! I64) (bit.and byte-mask)))
+
+(def: byte
+ (-> (I64 Top) (primitive "java.lang.Byte"))
+ (|>> .int host.long-to-byte))
(def: #export (create size)
(-> Nat Blob)
(host.array byte size))
(def: #export (read-8 idx blob)
- (-> Nat Blob (e.Error Nat))
+ (-> Nat Blob (e.Error I64))
(if (n/< (host.array-length blob) idx)
- (|> (host.array-read idx blob) byte-to-nat #e.Success)
+ (|> (host.array-read idx blob) ..i64 #e.Success)
(ex.throw index-out-of-bounds (%n idx))))
(def: #export (read-16 idx blob)
- (-> Nat Blob (e.Error Nat))
+ (-> Nat Blob (e.Error I64))
(if (n/< (host.array-length blob) (n/+ +1 idx))
(#e.Success ($_ bit.or
- (bit.left-shift +8 (byte-to-nat (host.array-read idx blob)))
- (byte-to-nat (host.array-read (n/+ +1 idx) blob))))
+ (bit.left-shift +8 (..i64 (host.array-read idx blob)))
+ (..i64 (host.array-read (n/+ +1 idx) blob))))
(ex.throw index-out-of-bounds (%n idx))))
(def: #export (read-32 idx blob)
- (-> Nat Blob (e.Error Nat))
+ (-> Nat Blob (e.Error I64))
(if (n/< (host.array-length blob) (n/+ +3 idx))
(#e.Success ($_ bit.or
- (bit.left-shift +24 (byte-to-nat (host.array-read idx blob)))
- (bit.left-shift +16 (byte-to-nat (host.array-read (n/+ +1 idx) blob)))
- (bit.left-shift +8 (byte-to-nat (host.array-read (n/+ +2 idx) blob)))
- (byte-to-nat (host.array-read (n/+ +3 idx) blob))))
+ (bit.left-shift +24 (..i64 (host.array-read idx blob)))
+ (bit.left-shift +16 (..i64 (host.array-read (n/+ +1 idx) blob)))
+ (bit.left-shift +8 (..i64 (host.array-read (n/+ +2 idx) blob)))
+ (..i64 (host.array-read (n/+ +3 idx) blob))))
(ex.throw index-out-of-bounds (%n idx))))
(def: #export (read-64 idx blob)
- (-> Nat Blob (e.Error Nat))
+ (-> Nat Blob (e.Error I64))
(if (n/< (host.array-length blob) (n/+ +7 idx))
(#e.Success ($_ bit.or
- (bit.left-shift +56 (byte-to-nat (host.array-read idx blob)))
- (bit.left-shift +48 (byte-to-nat (host.array-read (n/+ +1 idx) blob)))
- (bit.left-shift +40 (byte-to-nat (host.array-read (n/+ +2 idx) blob)))
- (bit.left-shift +32 (byte-to-nat (host.array-read (n/+ +3 idx) blob)))
- (bit.left-shift +24 (byte-to-nat (host.array-read (n/+ +4 idx) blob)))
- (bit.left-shift +16 (byte-to-nat (host.array-read (n/+ +5 idx) blob)))
- (bit.left-shift +8 (byte-to-nat (host.array-read (n/+ +6 idx) blob)))
- (byte-to-nat (host.array-read (n/+ +7 idx) blob))))
+ (bit.left-shift +56 (..i64 (host.array-read idx blob)))
+ (bit.left-shift +48 (..i64 (host.array-read (n/+ +1 idx) blob)))
+ (bit.left-shift +40 (..i64 (host.array-read (n/+ +2 idx) blob)))
+ (bit.left-shift +32 (..i64 (host.array-read (n/+ +3 idx) blob)))
+ (bit.left-shift +24 (..i64 (host.array-read (n/+ +4 idx) blob)))
+ (bit.left-shift +16 (..i64 (host.array-read (n/+ +5 idx) blob)))
+ (bit.left-shift +8 (..i64 (host.array-read (n/+ +6 idx) blob)))
+ (..i64 (host.array-read (n/+ +7 idx) blob))))
(ex.throw index-out-of-bounds (%n idx))))
(def: #export (write-8 idx value blob)
- (-> Nat Nat Blob (e.Error Top))
+ (-> Nat (I64 Top) Blob (e.Error Blob))
(if (n/< (host.array-length blob) idx)
(exec (|> blob
- (host.array-write idx (host.long-to-byte (:! Int value))))
- (#e.Success []))
+ (host.array-write idx (..byte value)))
+ (#e.Success blob))
(ex.throw index-out-of-bounds (%n idx))))
(def: #export (write-16 idx value blob)
- (-> Nat Nat Blob (e.Error Top))
+ (-> Nat (I64 Top) Blob (e.Error Blob))
(if (n/< (host.array-length blob) (n/+ +1 idx))
(exec (|> blob
- (host.array-write idx (host.long-to-byte (:! Int (bit.logical-right-shift +8 value))))
- (host.array-write (n/+ +1 idx) (host.long-to-byte (:! Int value))))
- (#e.Success []))
+ (host.array-write idx (..byte (bit.logical-right-shift +8 value)))
+ (host.array-write (n/+ +1 idx) (..byte value)))
+ (#e.Success blob))
(ex.throw index-out-of-bounds (%n idx))))
(def: #export (write-32 idx value blob)
- (-> Nat Nat Blob (e.Error Top))
+ (-> Nat (I64 Top) Blob (e.Error Blob))
(if (n/< (host.array-length blob) (n/+ +3 idx))
(exec (|> blob
- (host.array-write idx (host.long-to-byte (:! Int (bit.logical-right-shift +24 value))))
- (host.array-write (n/+ +1 idx) (host.long-to-byte (:! Int (bit.logical-right-shift +16 value))))
- (host.array-write (n/+ +2 idx) (host.long-to-byte (:! Int (bit.logical-right-shift +8 value))))
- (host.array-write (n/+ +3 idx) (host.long-to-byte (:! Int value))))
- (#e.Success []))
+ (host.array-write idx (..byte (bit.logical-right-shift +24 value)))
+ (host.array-write (n/+ +1 idx) (..byte (bit.logical-right-shift +16 value)))
+ (host.array-write (n/+ +2 idx) (..byte (bit.logical-right-shift +8 value)))
+ (host.array-write (n/+ +3 idx) (..byte value)))
+ (#e.Success blob))
(ex.throw index-out-of-bounds (%n idx))))
(def: #export (write-64 idx value blob)
- (-> Nat Nat Blob (e.Error Top))
+ (-> Nat (I64 Top) Blob (e.Error Blob))
(if (n/< (host.array-length blob) (n/+ +7 idx))
(exec (|> blob
- (host.array-write idx (host.long-to-byte (:! Int (bit.logical-right-shift +56 value))))
- (host.array-write (n/+ +1 idx) (host.long-to-byte (:! Int (bit.logical-right-shift +48 value))))
- (host.array-write (n/+ +2 idx) (host.long-to-byte (:! Int (bit.logical-right-shift +40 value))))
- (host.array-write (n/+ +3 idx) (host.long-to-byte (:! Int (bit.logical-right-shift +32 value))))
- (host.array-write (n/+ +4 idx) (host.long-to-byte (:! Int (bit.logical-right-shift +24 value))))
- (host.array-write (n/+ +5 idx) (host.long-to-byte (:! Int (bit.logical-right-shift +16 value))))
- (host.array-write (n/+ +6 idx) (host.long-to-byte (:! Int (bit.logical-right-shift +8 value))))
- (host.array-write (n/+ +7 idx) (host.long-to-byte (:! Int value))))
- (#e.Success []))
+ (host.array-write idx (..byte (bit.logical-right-shift +56 value)))
+ (host.array-write (n/+ +1 idx) (..byte (bit.logical-right-shift +48 value)))
+ (host.array-write (n/+ +2 idx) (..byte (bit.logical-right-shift +40 value)))
+ (host.array-write (n/+ +3 idx) (..byte (bit.logical-right-shift +32 value)))
+ (host.array-write (n/+ +4 idx) (..byte (bit.logical-right-shift +24 value)))
+ (host.array-write (n/+ +5 idx) (..byte (bit.logical-right-shift +16 value)))
+ (host.array-write (n/+ +6 idx) (..byte (bit.logical-right-shift +8 value)))
+ (host.array-write (n/+ +7 idx) (..byte value)))
+ (#e.Success blob))
(ex.throw index-out-of-bounds (%n idx))))
(def: #export (size blob)
@@ -130,11 +134,11 @@
(ex.throw index-out-of-bounds <description>)
## else
- (#e.Success (Arrays::copyOfRange [blob (:! Int from) (:! Int (n/inc to))]))))))
+ (#e.Success (Arrays::copyOfRange [blob (:! Int from) (:! Int (inc to))]))))))
(def: #export (slice' from blob)
(-> Nat Blob (e.Error Blob))
- (slice from (n/dec (host.array-length blob)) blob))
+ (slice from (dec (host.array-length blob)) blob))
(struct: #export _ (eq.Eq Blob)
(def: (= reference sample)
diff --git a/stdlib/source/lux/world/console.lux b/stdlib/source/lux/world/console.lux
index 349c8853c..7e5d72790 100644
--- a/stdlib/source/lux/world/console.lux
+++ b/stdlib/source/lux/world/console.lux
@@ -48,7 +48,7 @@
(|>> get@Console
(get@ #input)
(InputStream::read [])
- (:: io.Functor<Process> map (|>> int-to-nat text.from-code))
+ (:: io.Functor<Process> map (|>> .nat text.from-code))
promise.future))
(def: (read-line console)
@@ -57,7 +57,7 @@
(promise.future
(loop [_ []]
(do io.Monad<Process>
- [char (<| (:: @ map (|>> int-to-nat text.from-code))
+ [char (<| (:: @ map (|>> .nat text.from-code))
(InputStream::read [] input))]
(case char
"\n"
@@ -69,7 +69,7 @@
(if (i/> 0 available)
(do @
[_ (InputStream::mark [10] input)
- next (<| (:: @ map (|>> int-to-nat text.from-code))
+ next (<| (:: @ map (|>> .nat text.from-code))
(InputStream::read [] input))]
(case next
"\n"
diff --git a/stdlib/source/lux/world/file.lux b/stdlib/source/lux/world/file.lux
index 93a7bdd73..92fdd1501 100644
--- a/stdlib/source/lux/world/file.lux
+++ b/stdlib/source/lux/world/file.lux
@@ -69,7 +69,7 @@
(do io.Monad<Process>
[#let [file' (java/io/File::new file)]
size (java/io/File::length [] file')
- #let [data (blob.create (int-to-nat size))]
+ #let [data (blob.create (.nat size))]
stream (FileInputStream::new [file'])
bytes-read (InputStream::read [data] stream)
_ (AutoCloseable::close [] stream)]
@@ -81,7 +81,7 @@
(-> File (Process Nat))
(do io.Monad<Process>
[size (java/io/File::length [] (java/io/File::new file))]
- (wrap (int-to-nat size))))
+ (wrap (.nat size))))
(def: #export (files dir)
(-> File (Process (List File)))
diff --git a/stdlib/source/lux/world/net/tcp.jvm.lux b/stdlib/source/lux/world/net/tcp.jvm.lux
index 38721662f..a0cfbc4b6 100644
--- a/stdlib/source/lux/world/net/tcp.jvm.lux
+++ b/stdlib/source/lux/world/net/tcp.jvm.lux
@@ -45,16 +45,16 @@
(-> Blob Nat Nat TCP (Task Nat))
(promise.future
(do io.Monad<Process>
- [bytes-read (InputStream::read [data (nat-to-int offset) (nat-to-int length)]
+ [bytes-read (InputStream::read [data (.int offset) (.int length)]
(get@ #in (@representation self)))]
- (wrap (int-to-nat bytes-read)))))
+ (wrap (.nat bytes-read)))))
(def: #export (write data offset length self)
(-> Blob Nat Nat TCP (Task Top))
(let [out (get@ #out (@representation self))]
(promise.future
(do io.Monad<Process>
- [_ (OutputStream::write [data (nat-to-int offset) (nat-to-int length)]
+ [_ (OutputStream::write [data (.int offset) (.int length)]
out)]
(Flushable::flush [] out)))))
@@ -81,7 +81,7 @@
(-> //.Address //.Port (Task TCP))
(promise.future
(do io.Monad<Process>
- [socket (Socket::new [address (nat-to-int port)])]
+ [socket (Socket::new [address (.int port)])]
(tcp-client socket))))
(def: #export (server port)
@@ -89,7 +89,7 @@
(frp.Channel TCP)]))
(promise.future
(do (e.ErrorT io.Monad<IO>)
- [server (ServerSocket::new [(nat-to-int port)])
+ [server (ServerSocket::new [(.int port)])
#let [signal (: (Promise Top)
(promise #.None))
_ (promise.await (function (_ _)
diff --git a/stdlib/source/lux/world/net/udp.jvm.lux b/stdlib/source/lux/world/net/udp.jvm.lux
index a28adc6bd..da4f8f05d 100644
--- a/stdlib/source/lux/world/net/udp.jvm.lux
+++ b/stdlib/source/lux/world/net/udp.jvm.lux
@@ -62,14 +62,14 @@
(def: #export (read data offset length self)
(-> Blob Nat Nat UDP (T.Task [Nat //.Address //.Port]))
(let [(^open) (@representation self)
- packet (DatagramPacket::new|receive [data (nat-to-int offset) (nat-to-int length)])]
+ packet (DatagramPacket::new|receive [data (.int offset) (.int length)])]
(P.future
(do (e.ErrorT io.Monad<IO>)
[_ (DatagramSocket::receive [packet] socket)
- #let [bytes-read (int-to-nat (DatagramPacket::getLength [] packet))]]
+ #let [bytes-read (.nat (DatagramPacket::getLength [] packet))]]
(wrap [bytes-read
(|> packet (DatagramPacket::getAddress []) (InetAddress::getHostAddress []))
- (int-to-nat (DatagramPacket::getPort [] packet))])))))
+ (.nat (DatagramPacket::getPort [] packet))])))))
(def: #export (write address port data offset length self)
(-> //.Address //.Port Blob Nat Nat UDP (T.Task Top))
@@ -77,7 +77,7 @@
(do (e.ErrorT io.Monad<IO>)
[address (resolve address)
#let [(^open) (@representation self)]]
- (DatagramSocket::send (DatagramPacket::new|send [data (nat-to-int offset) (nat-to-int length) address (nat-to-int port)])
+ (DatagramSocket::send (DatagramPacket::new|send [data (.int offset) (.int length) address (.int port)])
socket))))
(def: #export (close self)
@@ -97,6 +97,6 @@
(-> //.Port (T.Task UDP))
(P.future
(do (e.ErrorT io.Monad<IO>)
- [socket (DatagramSocket::new|server [(nat-to-int port)])]
+ [socket (DatagramSocket::new|server [(.int port)])]
(wrap (@abstraction (#socket socket))))))
)
diff --git a/stdlib/test/test/lux.lux b/stdlib/test/test/lux.lux
index 788085db4..1f0a6e115 100644
--- a/stdlib/test/test/lux.lux
+++ b/stdlib/test/test/lux.lux
@@ -26,7 +26,7 @@
(not (is? x y)))
))))
-(do-template [category rand-gen inc dec even? odd? = < >]
+(do-template [category rand-gen even? odd? = < >]
[(context: (format "[" category "] " "Moving up-down or down-up should result in same value.")
(<| (times +100)
(do @
@@ -52,8 +52,8 @@
(and (|> value inc even?)
(|> value dec even?)))))))]
- ["Nat" r.nat n/inc n/dec n/even? n/odd? n/= n/< n/>]
- ["Int" r.int i/inc i/dec i/even? i/odd? i/= i/< i/>]
+ ["Nat" r.nat n/even? n/odd? n/= n/< n/>]
+ ["Int" r.int i/even? i/odd? i/= i/< i/>]
)
(do-template [category rand-gen = < > <= >= min max]
@@ -86,7 +86,7 @@
["Deg" r.deg d/= d/< d/> d/<= d/>= d/min d/max]
)
-(do-template [category rand-gen = + - * / <%> > <0> <1> <factor> %x <cap> <prep>]
+(do-template [category rand-gen = + - * / <%> > <0> <1> <factor> <cap> <prep>]
[(context: (format "[" category "] " "Additive identity")
(<| (times +100)
(do @
@@ -136,10 +136,10 @@
(|> x' (/ y) (* y) (= x'))))
))))]
- ["Nat" r.nat n/= n/+ n/- n/* n// n/% n/> +0 +1 +1000000 %n (n/% +1000) id]
- ["Int" r.int i/= i/+ i/- i/* i// i/% i/> 0 1 1000000 %i (i/% 1000) id]
- ["Frac" r.frac f/= f/+ f/- f/* f// f/% f/> 0.0 1.0 1000000.0 %r id math.floor]
- ["Deg" r.deg d/= d/+ d/- d/* d// d/% d/> .0 (:! Deg -1) (:! Deg -1) %f id id]
+ ["Nat" r.nat n/= n/+ n/- n/* n// n/% n/> +0 +1 +1_000_000 (n/% +1_000) id]
+ ["Int" r.int i/= i/+ i/- i/* i// i/% i/> 0 1 1_000_000 (i/% 1_000) id]
+ ["Frac" r.frac f/= f/+ f/- f/* f// f/% f/> 0.0 1.0 1_000_000.0 id math.floor]
+ ["Deg" r.deg d/= d/+ d/- d/* d// d/% d/> .0 (.deg -1) (.deg -1) id id]
)
(def: frac-deg
@@ -147,7 +147,7 @@
(|> r.deg
(:: r.Functor<Random> map (|>> (:! Nat) (bit.left-shift +11) (bit.right-shift +11) (:! Deg)))))
-(do-template [category rand-gen -> <- = <cap> %a %z]
+(do-template [category rand-gen -> <- = <cap>]
[(context: (format "[" category "] " "Numeric conversions")
(<| (times +100)
(do @
@@ -156,11 +156,11 @@
(test ""
(|> value -> <- (= value))))))]
- ["Int->Nat" r.int int-to-nat nat-to-int i/= (i/% 1000000) %i %n]
- ["Nat->Int" r.nat nat-to-int int-to-nat n/= (n/% +1000000) %n %i]
- ["Int->Frac" r.int int-to-frac frac-to-int i/= (i/% 1000000) %i %r]
- ["Frac->Int" r.frac frac-to-int int-to-frac f/= math.floor %r %i]
- ["Deg->Frac" frac-deg deg-to-frac frac-to-deg d/= id %d %r]
+ ["Int->Nat" r.int .nat .int i/= (i/% 1_000_000)]
+ ["Nat->Int" r.nat .int .nat n/= (n/% +1_000_000)]
+ ["Int->Frac" r.int int-to-frac frac-to-int i/= (i/% 1_000_000)]
+ ["Frac->Int" r.frac frac-to-int int-to-frac f/= math.floor]
+ ["Deg->Frac" frac-deg deg-to-frac frac-to-deg d/= id]
)
(context: "Simple macros and constructs"
@@ -170,7 +170,7 @@
(loop [counter 0
value 1]
(if (i/< 3 counter)
- (recur (i/inc counter) (i/* 10 value))
+ (recur (inc counter) (i/* 10 value))
value))))
(test "Can create lists easily through macros."
diff --git a/stdlib/test/test/lux/concurrency/atom.lux b/stdlib/test/test/lux/concurrency/atom.lux
index 9063af2e7..a4856252a 100644
--- a/stdlib/test/test/lux/concurrency/atom.lux
+++ b/stdlib/test/test/lux/concurrency/atom.lux
@@ -25,8 +25,8 @@
(n/= swap-value (io.run (&.read box)))))
(test "Can update the value of an atom."
- (exec (io.run (&.update n/inc box))
- (n/= (n/inc swap-value) (io.run (&.read box)))))
+ (exec (io.run (&.update inc box))
+ (n/= (inc swap-value) (io.run (&.read box)))))
(test "Can immediately set the value of an atom."
(exec (io.run (&.write set-value box))
diff --git a/stdlib/test/test/lux/concurrency/frp.lux b/stdlib/test/test/lux/concurrency/frp.lux
index 9630016e4..527fafb36 100644
--- a/stdlib/test/test/lux/concurrency/frp.lux
+++ b/stdlib/test/test/lux/concurrency/frp.lux
@@ -79,7 +79,7 @@
[output (promise.future
(do io.Monad<IO>
[#let [inputs (: (Channel Int) (frp.channel []))
- mapped (:: frp.Functor<Channel> map i/inc inputs)]
+ mapped (:: frp.Functor<Channel> map inc inputs)]
output (read! mapped)
_ (write! (list 0 1 2 3 4 5) inputs)]
(wrap output)))
@@ -96,7 +96,7 @@
>a< (: (Channel Int) (frp.channel []))]
output (read! (let [(^open) frp.Apply<Channel>]
(apply >f< >a<)))
- _ (write! (list i/inc) >f<)
+ _ (write! (list inc) >f<)
_ (write! (list 12345) >a<)]
(wrap output)))
_ (promise.wait +100)
@@ -108,7 +108,7 @@
(wrap (do promise.Monad<Promise>
[output (promise.future
(read! (do frp.Monad<Channel>
- [f (frp.from-promise (promise.delay +100 i/inc))
+ [f (frp.from-promise (promise.delay +100 inc))
a (frp.from-promise (promise.delay +200 12345))]
(frp.from-promise (promise.delay +300 (f a))))))
_ (promise.wait +700)
diff --git a/stdlib/test/test/lux/concurrency/semaphore.lux b/stdlib/test/test/lux/concurrency/semaphore.lux
index a41f06096..af025dbb5 100644
--- a/stdlib/test/test/lux/concurrency/semaphore.lux
+++ b/stdlib/test/test/lux/concurrency/semaphore.lux
@@ -18,7 +18,7 @@
(if (n/> +0 steps)
(do promise.Monad<Promise>
[_ (/.wait semaphore)]
- (recur (n/dec steps)))
+ (recur (dec steps)))
(:: promise.Monad<Promise> wrap []))))
(context: "Semaphore."
@@ -34,7 +34,7 @@
(let [semaphore (/.semaphore open-positions)]
(wrap (do promise.Monad<Promise>
[result (<| (promise.time-out +100)
- (wait-many-times (n/inc open-positions) semaphore))]
+ (wait-many-times (inc open-positions) semaphore))]
(assert "Waiting on a semaphore more than the number of open positions blocks the process."
(case result
(#.Some _)
@@ -50,7 +50,7 @@
(do @
[_ (/.wait semaphore)
_ (/.signal semaphore)]
- (recur (n/dec steps)))
+ (recur (dec steps)))
(wrap []))))]
(assert "Signaling a semaphore replenishes its open positions."
true))))
@@ -122,7 +122,7 @@
resource (atom.atom "")]
($_ seq
(wrap (do promise.Monad<Promise>
- [#let [ids (list.n/range +0 (n/dec limit))
+ [#let [ids (list.n/range +0 (dec limit))
waiters (list/map (function (_ id)
(let [process (waiter resource barrier id)]
(exec (io.run (atom.update (|>> (format "_")) resource))
diff --git a/stdlib/test/test/lux/concurrency/stm.lux b/stdlib/test/test/lux/concurrency/stm.lux
index bf562c0fa..9f3c5bd7e 100644
--- a/stdlib/test/test/lux/concurrency/stm.lux
+++ b/stdlib/test/test/lux/concurrency/stm.lux
@@ -25,46 +25,49 @@
channel)]
(wrap output)))
-(def: iterations/processes Int 100)
+(def: iterations-per-process Nat +100)
(context: "STM"
($_ seq
(wrap (do promise.Monad<Promise>
- [output (&.commit (&.read (&.var 0)))]
+ [output (&.commit (&.read (&.var +0)))]
(assert "Can read STM vars."
- (i/= 0 output))))
+ (n/= +0 output))))
(wrap (do promise.Monad<Promise>
- [#let [_var (&.var 0)]
+ [#let [_var (&.var +0)]
output (&.commit (do &.Monad<STM>
- [_ (&.write 5 _var)]
+ [_ (&.write +5 _var)]
(&.read _var)))]
(assert "Can write STM vars."
- (i/= 5 output))))
+ (n/= +5 output))))
(wrap (do promise.Monad<Promise>
- [#let [_var (&.var 5)]
+ [#let [_var (&.var +5)]
output (&.commit (do &.Monad<STM>
- [_ (&.update (i/* 3) _var)]
+ [_ (&.update (n/* +3) _var)]
(&.read _var)))]
(assert "Can update STM vars."
- (i/= 15 output))))
+ (n/= +15 output))))
(wrap (do promise.Monad<Promise>
- [#let [_var (&.var 0)
+ [#let [_var (&.var +0)
changes (io.run (read! (io.run (&.follow _var))))]
- _ (&.commit (&.write 5 _var))
- _ (&.commit (&.update (i/* 3) _var))
+ _ (&.commit (&.write +5 _var))
+ _ (&.commit (&.update (n/* +3) _var))
changes (promise.future (atom.read changes))]
(assert "Can follow all the changes to STM vars."
- (:: (list.Eq<List> number.Eq<Int>) =
- (list 5 15)
+ (:: (list.Eq<List> number.Eq<Nat>) =
+ (list +5 +15)
(list.reverse changes)))))
- (wrap (let [_concurrency-var (&.var 0)]
+ (wrap (let [_concurrency-var (&.var +0)]
(do promise.Monad<Promise>
- [_ (M.seq @
- (map (function (_ _)
- (M.map @ (function (_ _) (&.commit (&.update i/inc _concurrency-var)))
- (list.i/range 1 iterations/processes)))
- (list.i/range 1 (nat-to-int promise.parallelism-level))))
+ [_ (|> promise.parallelism
+ (list.n/range +1)
+ (map (function (_ _)
+ (|> iterations-per-process
+ (list.n/range +1)
+ (M.map @ (function (_ _) (&.commit (&.update inc _concurrency-var)))))))
+ (M.seq @))
last-val (&.commit (&.read _concurrency-var))]
(assert "Can modify STM vars concurrently from multiple threads."
- (i/= (i/* iterations/processes (nat-to-int promise.parallelism-level))
- last-val)))))))
+ (|> promise.parallelism
+ (n/* iterations-per-process)
+ (n/= last-val))))))))
diff --git a/stdlib/test/test/lux/control/continuation.lux b/stdlib/test/test/lux/control/continuation.lux
index 7f9ff00d9..ea43b511d 100644
--- a/stdlib/test/test/lux/control/continuation.lux
+++ b/stdlib/test/test/lux/control/continuation.lux
@@ -23,16 +23,16 @@
(n/= sample (&.run (&/wrap sample))))
(test "Can use functor."
- (n/= (n/inc sample) (&.run (&/map n/inc (&/wrap sample)))))
+ (n/= (inc sample) (&.run (&/map inc (&/wrap sample)))))
(test "Can use apply."
- (n/= (n/inc sample) (&.run (&/apply (&/wrap n/inc) (&/wrap sample)))))
+ (n/= (inc sample) (&.run (&/apply (&/wrap inc) (&/wrap sample)))))
(test "Can use monad."
- (n/= (n/inc sample) (&.run (do &.Monad<Cont>
- [func (wrap n/inc)
- arg (wrap sample)]
- (wrap (func arg))))))
+ (n/= (inc sample) (&.run (do &.Monad<Cont>
+ [func (wrap inc)
+ arg (wrap sample)]
+ (wrap (func arg))))))
(test "Can use the current-continuation as a escape hatch."
(n/= (n/* +2 sample)
@@ -52,7 +52,7 @@
(&.run (do &.Monad<Cont>
[[restart [output idx]] (&.portal [sample +0])]
(if (n/< +10 idx)
- (restart [(n/+ +10 output) (n/inc idx)])
+ (restart [(n/+ +10 output) (inc idx)])
(wrap output))))))
(test "Can use delimited continuations with shifting."
diff --git a/stdlib/test/test/lux/control/pipe.lux b/stdlib/test/test/lux/control/pipe.lux
index 79e920468..d159cfeb9 100644
--- a/stdlib/test/test/lux/control/pipe.lux
+++ b/stdlib/test/test/lux/control/pipe.lux
@@ -17,7 +17,7 @@
(|> 20
(i/* 3)
(i/+ 4)
- (new> 0 i/inc)
+ (new> 0 inc)
(i/= 1)))
(test "Can give names to piped values within a pipeline's scope."
@@ -44,7 +44,7 @@
(test "Can loop within pipelines."
(|> 1
(loop> [(i/< 10)]
- [i/inc])
+ [inc])
(i/= 10)))
(test "Can use monads within pipelines."
@@ -52,7 +52,7 @@
(do> Monad<Identity>
[(i/* 3)]
[(i/+ 4)]
- [i/inc])
+ [inc])
(i/= 20)))
(test "Can pattern-match against piped values."
diff --git a/stdlib/test/test/lux/control/reader.lux b/stdlib/test/test/lux/control/reader.lux
index f84d8d16f..eba19b47b 100644
--- a/stdlib/test/test/lux/control/reader.lux
+++ b/stdlib/test/test/lux/control/reader.lux
@@ -15,7 +15,7 @@
($_ seq
(test "" (i/= 123 (&.run 123 &.ask)))
(test "" (i/= 246 (&.run 123 (&.local (i/* 2) &.ask))))
- (test "" (i/= 134 (&.run 123 (&/map i/inc (i/+ 10)))))
+ (test "" (i/= 134 (&.run 123 (&/map inc (i/+ 10)))))
(test "" (i/= 10 (&.run 123 (&/wrap 10))))
(test "" (i/= 30 (&.run 123 (&/apply (&/wrap (i/+ 10)) (&/wrap 20)))))
(test "" (i/= 30 (&.run 123 (do &.Monad<Reader>
diff --git a/stdlib/test/test/lux/control/region.lux b/stdlib/test/test/lux/control/region.lux
index 429359057..a266218f9 100644
--- a/stdlib/test/test/lux/control/region.lux
+++ b/stdlib/test/test/lux/control/region.lux
@@ -35,7 +35,7 @@
#let [@@ @
count-clean-up (function (_ value)
(do @
- [_ (thread.update n/inc clean-up-counter)]
+ [_ (thread.update inc clean-up-counter)]
(wrap (#e.Success []))))]
outcome (/.run @
(do (/.Monad<Region> @)
@@ -53,7 +53,7 @@
#let [@@ @
count-clean-up (function (_ value)
(do @
- [_ (thread.update n/inc clean-up-counter)]
+ [_ (thread.update inc clean-up-counter)]
(wrap (#e.Success []))))]
outcome (/.run @
(do (/.Monad<Region> @)
@@ -72,7 +72,7 @@
#let [@@ @
count-clean-up (function (_ value)
(do @
- [_ (thread.update n/inc clean-up-counter)]
+ [_ (thread.update inc clean-up-counter)]
(wrap (: (Error Top) (ex.throw oops [])))))]
outcome (/.run @
(do (/.Monad<Region> @)
diff --git a/stdlib/test/test/lux/control/state.lux b/stdlib/test/test/lux/control/state.lux
index 33a318a2f..381a40b79 100644
--- a/stdlib/test/test/lux/control/state.lux
+++ b/stdlib/test/test/lux/control/state.lux
@@ -38,8 +38,8 @@
[_ (&.update (n/* value))]
&.get)))
(test "Can use the state."
- (with-conditions [state (n/inc state)]
- (&.use n/inc)))
+ (with-conditions [state (inc state)]
+ (&.use inc)))
(test "Can use a temporary (local) state."
(with-conditions [state (n/* value state)]
(&.local (n/* value)
@@ -56,8 +56,8 @@
(^open "&/") &.Monad<State>]]
($_ seq
(test "Can use functor."
- (with-conditions [state (n/inc state)]
- (&/map n/inc &.get)))
+ (with-conditions [state (inc state)]
+ (&/map inc &.get)))
(test "Can use apply."
(and (with-conditions [state value]
(&/wrap value))
@@ -103,12 +103,12 @@
(wrap (n/< limit state)))]]
($_ seq
(test "'while' will only execute if the condition is true."
- (|> (&.while condition (&.update n/inc))
+ (|> (&.while condition (&.update inc))
(&.run +0)
(case> [state' output']
(n/= limit state'))))
(test "'do-while' will execute at least once."
- (|> (&.do-while condition (&.update n/inc))
+ (|> (&.do-while condition (&.update inc))
(&.run +0)
(case> [state' output']
(or (n/= limit state')
diff --git a/stdlib/test/test/lux/control/writer.lux b/stdlib/test/test/lux/control/writer.lux
index 09f37a957..49335de0d 100644
--- a/stdlib/test/test/lux/control/writer.lux
+++ b/stdlib/test/test/lux/control/writer.lux
@@ -14,7 +14,7 @@
(^open "&/") (&.Apply<Writer> text.Monoid<Text>)]
($_ seq
(test "Functor respects Writer."
- (i/= 11 (product.right (&/map i/inc ["" 10]))))
+ (i/= 11 (product.right (&/map inc ["" 10]))))
(test "Apply respects Writer."
(and (i/= 20 (product.right (&/wrap 20)))
diff --git a/stdlib/test/test/lux/data/bit.lux b/stdlib/test/test/lux/data/bit.lux
index 1b8110d31..9008f89cf 100644
--- a/stdlib/test/test/lux/data/bit.lux
+++ b/stdlib/test/test/lux/data/bit.lux
@@ -14,7 +14,7 @@
idx (:: @ map (n/% &.width) r.nat)]
($_ seq
(test "Clearing and settings bits should alter the count."
- (and (n/= (n/dec (&.count (&.set idx pattern)))
+ (and (n/= (dec (&.count (&.set idx pattern)))
(&.count (&.clear idx pattern)))
(|> (&.count pattern)
(n/- (&.count (&.clear idx pattern)))
@@ -66,7 +66,7 @@
(&.rotate-right &.width)
(n/= pattern))))
(test "Shift right respect the sign of ints."
- (let [value (nat-to-int pattern)]
+ (let [value (.int pattern)]
(if (i/< 0 value)
(i/< 0 (&.arithmetic-right-shift idx value))
(i/>= 0 (&.arithmetic-right-shift idx value)))))
diff --git a/stdlib/test/test/lux/data/coll/array.lux b/stdlib/test/test/lux/data/coll/array.lux
index 729f84221..125694cc7 100644
--- a/stdlib/test/test/lux/data/coll/array.lux
+++ b/stdlib/test/test/lux/data/coll/array.lux
@@ -39,7 +39,7 @@
(exec (:: @.Fold<Array> fold
(function (_ x idx)
(exec (@.write idx x manual-copy)
- (n/inc idx)))
+ (inc idx)))
+0
original)
(:: (@.Eq<Array> number.Eq<Nat>) = original manual-copy)))
@@ -109,8 +109,8 @@
(and (= array copy)
(not (is? array copy)))))
(test "Functor should go over all available array elements."
- (let [there (map n/inc array)
- back-again (map n/dec there)]
+ (let [there (map inc array)
+ back-again (map dec there)]
(and (not (= array there))
(= array back-again)))))))))
diff --git a/stdlib/test/test/lux/data/coll/bits.lux b/stdlib/test/test/lux/data/coll/bits.lux
index d33fa61b1..f416f9866 100644
--- a/stdlib/test/test/lux/data/coll/bits.lux
+++ b/stdlib/test/test/lux/data/coll/bits.lux
@@ -51,7 +51,7 @@
/.empty))
(/.intersects? (/.set idx /.empty)
(/.set idx /.empty))
- (not (/.intersects? (/.set (n/inc idx) /.empty)
+ (not (/.intersects? (/.set (inc idx) /.empty)
(/.set idx /.empty)))))
(test "Cannot intersect with one's opposite."
(not (/.intersects? sample (/.not sample))))
diff --git a/stdlib/test/test/lux/data/coll/dictionary/unordered.lux b/stdlib/test/test/lux/data/coll/dictionary/unordered.lux
index 8c6ea275e..f0224a015 100644
--- a/stdlib/test/test/lux/data/coll/dictionary/unordered.lux
+++ b/stdlib/test/test/lux/data/coll/dictionary/unordered.lux
@@ -74,10 +74,10 @@
(test "Should be possible to update values via their keys."
(let [base (&.put non-key test-val dict)
- updt (&.update non-key n/inc base)]
+ updt (&.update non-key inc base)]
(case [(&.get non-key base) (&.get non-key updt)]
[(#.Some x) (#.Some y)]
- (n/= (n/inc x) y)
+ (n/= (inc x) y)
_
false)))
@@ -85,8 +85,8 @@
(test "Additions and removals to a Dict should affect its size."
(let [plus (&.put non-key test-val dict)
base (&.remove non-key plus)]
- (and (n/= (n/inc (&.size dict)) (&.size plus))
- (n/= (n/dec (&.size plus)) (&.size base)))))
+ (and (n/= (inc (&.size dict)) (&.size plus))
+ (n/= (dec (&.size plus)) (&.size base)))))
(test "A Dict should equal itself & going to<->from lists shouldn't change that."
(let [(^open) (&.Eq<Dict> number.Eq<Nat>)]
@@ -99,7 +99,7 @@
(test "If you merge, and the second dict has overlapping keys, it should overwrite yours."
(let [dict' (|> dict &.entries
- (list/map (function (_ [k v]) [k (n/inc v)]))
+ (list/map (function (_ [k v]) [k (inc v)]))
(&.from-list number.Hash<Nat>))
(^open) (&.Eq<Dict> number.Eq<Nat>)]
(= dict' (&.merge dict' dict))))
diff --git a/stdlib/test/test/lux/data/coll/list.lux b/stdlib/test/test/lux/data/coll/list.lux
index 578b652da..73eb25d85 100644
--- a/stdlib/test/test/lux/data/coll/list.lux
+++ b/stdlib/test/test/lux/data/coll/list.lux
@@ -89,8 +89,8 @@
(test "Functor should go over every element of the list."
(let [(^open) &.Functor<List>
- there (map n/inc sample)
- back-again (map n/dec there)]
+ there (map inc sample)
+ back-again (map dec there)]
(and (not (= sample there))
(= sample back-again))))
@@ -154,7 +154,7 @@
(and (n/= size (&.size indices))
(= indices
(&.sort n/< indices))
- (&.every? (n/= (n/dec size))
+ (&.every? (n/= (dec size))
(&.zip2-with n/+
indices
(&.sort n/> indices)))
@@ -163,7 +163,7 @@
(test "The 'interpose' function places a value between every member of a list."
(let [(^open) &.Functor<List>
sample+ (&.interpose separator sample)]
- (and (n/= (|> size (n/* +2) n/dec)
+ (and (n/= (|> size (n/* +2) dec)
(&.size sample+))
(|> sample+ &.as-pairs (map product.right) (&.every? (n/= separator))))))
@@ -179,8 +179,8 @@
(let [(^open) &.Monad<List>
(^open) &.Apply<List>]
(and (= (list separator) (wrap separator))
- (= (map n/inc sample)
- (apply (wrap n/inc) sample)))))
+ (= (map inc sample)
+ (apply (wrap inc) sample)))))
(test "List concatenation is a monad."
(let [(^open) &.Monad<List>
@@ -200,8 +200,8 @@
(&.every? (bool.complement n/even?) sample))))
(test "You can iteratively construct a list, generating values until you're done."
- (= (&.n/range +0 (n/dec size))
- (&.iterate (function (_ n) (if (n/< size n) (#.Some (n/inc n)) #.None))
+ (= (&.n/range +0 (dec size))
+ (&.iterate (function (_ n) (if (n/< size n) (#.Some (inc n)) #.None))
+0)))
(test "Can enumerate all elements in a list."
@@ -216,8 +216,8 @@
(list/= (&.n/range from to)
(&.reverse (&.n/range to from))))
(let [(^open "list/") (&.Eq<List> number.Eq<Int>)
- from (nat-to-int from)
- to (nat-to-int to)]
+ from (.int from)
+ to (.int to)]
(list/= (&.i/range from to)
(&.reverse (&.i/range to from))))))
))))
diff --git a/stdlib/test/test/lux/data/coll/queue.lux b/stdlib/test/test/lux/data/coll/queue.lux
index 34330838b..7edcbf9b4 100644
--- a/stdlib/test/test/lux/data/coll/queue.lux
+++ b/stdlib/test/test/lux/data/coll/queue.lux
@@ -21,9 +21,9 @@
(n/= size (&.size sample))))
(test "Enqueueing and dequeing affects the size of queues."
- (and (n/= (n/inc size) (&.size (&.push non-member sample)))
+ (and (n/= (inc size) (&.size (&.push non-member sample)))
(or (&.empty? sample)
- (n/= (n/dec size) (&.size (&.pop sample))))
+ (n/= (dec size) (&.size (&.pop sample))))
(n/= size (&.size (&.pop (&.push non-member sample))))))
(test "Transforming to/from list can't change the queue."
diff --git a/stdlib/test/test/lux/data/coll/queue/priority.lux b/stdlib/test/test/lux/data/coll/queue/priority.lux
index 2ccb58ec4..38527523a 100644
--- a/stdlib/test/test/lux/data/coll/queue/priority.lux
+++ b/stdlib/test/test/lux/data/coll/queue/priority.lux
@@ -31,10 +31,10 @@
(n/= size (&.size sample)))
(test "Enqueueing and dequeing affects the size of queues."
- (and (n/= (n/inc size)
+ (and (n/= (inc size)
(&.size (&.push non-member-priority non-member sample)))
(or (n/= +0 (&.size sample))
- (n/= (n/dec size)
+ (n/= (dec size)
(&.size (&.pop sample))))))
(test "I can query whether an element belongs to a queue."
diff --git a/stdlib/test/test/lux/data/coll/sequence.lux b/stdlib/test/test/lux/data/coll/sequence.lux
index e1d561fb7..024e91c6b 100644
--- a/stdlib/test/test/lux/data/coll/sequence.lux
+++ b/stdlib/test/test/lux/data/coll/sequence.lux
@@ -30,8 +30,8 @@
(n/= size (&.size sample))))
(test "Can add and remove elements to sequences."
- (and (n/= (n/inc size) (&.size (&.add non-member sample)))
- (n/= (n/dec size) (&.size (&.pop sample)))))
+ (and (n/= (inc size) (&.size (&.add non-member sample)))
+ (n/= (dec size) (&.size (&.pop sample)))))
(test "Can put and get elements into sequences."
(|> sample
@@ -42,9 +42,9 @@
(test "Can update elements of sequences."
(|> sample
- (&.put idx non-member) (&.update idx n/inc)
+ (&.put idx non-member) (&.update idx inc)
(&.nth idx) maybe.assume
- (n/= (n/inc non-member))))
+ (n/= (inc non-member))))
(test "Can safely transform to/from lists."
(|> sample &.to-list &.from-list (&/= sample)))
@@ -58,14 +58,14 @@
(&/fold n/+ +0 sample)))
(test "Functor goes over every element."
- (let [there (&/map n/inc sample)
- back-again (&/map n/dec there)]
+ (let [there (&/map inc sample)
+ back-again (&/map dec there)]
(and (not (&/= sample there))
(&/= sample back-again))))
(test "Apply allows you to create singleton sequences, and apply sequences of functions to sequences of values."
(and (&/= (&.sequence non-member) (&/wrap non-member))
- (&/= (&/map n/inc sample) (&/apply (&/wrap n/inc) sample))))
+ (&/= (&/map inc sample) (&/apply (&/wrap inc) sample))))
(test "Sequence concatenation is a monad."
(&/= (&/compose sample other-sample)
diff --git a/stdlib/test/test/lux/data/coll/stack.lux b/stdlib/test/test/lux/data/coll/stack.lux
index 216c1a8c5..9a5b1b438 100644
--- a/stdlib/test/test/lux/data/coll/stack.lux
+++ b/stdlib/test/test/lux/data/coll/stack.lux
@@ -32,14 +32,14 @@
(test "Popping empty stacks doesn't change anything.
But, if they're non-empty, the top of the stack is removed."
(let [sample' (&.pop sample)]
- (or (n/= (&.size sample) (n/inc (&.size sample')))
+ (or (n/= (&.size sample) (inc (&.size sample')))
(and (&.empty? sample) (&.empty? sample')))
))
(test "Pushing onto a stack always increases it by 1, adding a new value at the top."
(and (is? sample
(&.pop (&.push new-top sample)))
- (n/= (n/inc (&.size sample)) (&.size (&.push new-top sample)))
+ (n/= (inc (&.size sample)) (&.size (&.push new-top sample)))
(|> (&.push new-top sample) &.peek maybe.assume
(is? new-top))))
))))
diff --git a/stdlib/test/test/lux/data/coll/stream.lux b/stdlib/test/test/lux/data/coll/stream.lux
index cbdfcab49..9431e2a46 100644
--- a/stdlib/test/test/lux/data/coll/stream.lux
+++ b/stdlib/test/test/lux/data/coll/stream.lux
@@ -22,28 +22,28 @@
cycle-seed (r.list size r.nat)
cycle-sample-idx (|> r.nat (:: @ map (n/% +1000)))
#let [(^open "List/") (list.Eq<List> number.Eq<Nat>)
- sample0 (&.iterate n/inc +0)
- sample1 (&.iterate n/inc offset)]]
+ sample0 (&.iterate inc +0)
+ sample1 (&.iterate inc offset)]]
($_ seq
(test "Can move along a stream and take slices off it."
- (and (and (List/= (list.n/range +0 (n/dec size))
+ (and (and (List/= (list.n/range +0 (dec size))
(&.take size sample0))
- (List/= (list.n/range offset (n/dec (n/+ offset size)))
+ (List/= (list.n/range offset (dec (n/+ offset size)))
(&.take size (&.drop offset sample0)))
(let [[drops takes] (&.split size sample0)]
- (and (List/= (list.n/range +0 (n/dec size))
+ (and (List/= (list.n/range +0 (dec size))
drops)
- (List/= (list.n/range size (n/dec (n/* +2 size)))
+ (List/= (list.n/range size (dec (n/* +2 size)))
(&.take size takes)))))
- (and (List/= (list.n/range +0 (n/dec size))
+ (and (List/= (list.n/range +0 (dec size))
(&.take-while (n/< size) sample0))
- (List/= (list.n/range offset (n/dec (n/+ offset size)))
+ (List/= (list.n/range offset (dec (n/+ offset size)))
(&.take-while (n/< (n/+ offset size))
(&.drop-while (n/< offset) sample0)))
(let [[drops takes] (&.split-while (n/< size) sample0)]
- (and (List/= (list.n/range +0 (n/dec size))
+ (and (List/= (list.n/range +0 (dec size))
drops)
- (List/= (list.n/range size (n/dec (n/* +2 size)))
+ (List/= (list.n/range size (dec (n/* +2 size)))
(&.take-while (n/< (n/* +2 size)) takes)))))
))
@@ -52,17 +52,17 @@
(test "Can obtain the head & tail of a stream."
(and (n/= offset (&.head sample1))
- (List/= (list.n/range (n/inc offset) (n/+ offset size))
+ (List/= (list.n/range (inc offset) (n/+ offset size))
(&.take size (&.tail sample1)))))
(test "Can filter streams."
(and (n/= (n/* +2 offset)
(&.nth offset
(&.filter n/even? sample0)))
- (let [[evens odds] (&.partition n/even? (&.iterate n/inc +0))]
+ (let [[evens odds] (&.partition n/even? (&.iterate inc +0))]
(and (n/= (n/* +2 offset)
(&.nth offset evens))
- (n/= (n/inc (n/* +2 offset))
+ (n/= (inc (n/* +2 offset))
(&.nth offset odds))))))
(test "Functor goes over 'all' elements in a stream."
@@ -86,9 +86,9 @@
(let [(^open "&/") &.Functor<Stream>
(^open "List/") (list.Eq<List> text.Eq<Text>)]
(List/= (&.take size
- (&/map Nat/encode (&.iterate n/inc offset)))
+ (&/map Nat/encode (&.iterate inc offset)))
(&.take size
- (&.unfold (function (_ n) [(n/inc n) (Nat/encode n)])
+ (&.unfold (function (_ n) [(inc n) (Nat/encode n)])
offset)))))
(test "Can cycle over the same elements as an infinite stream."
diff --git a/stdlib/test/test/lux/data/coll/tree/rose.lux b/stdlib/test/test/lux/data/coll/tree/rose.lux
index 1bf29d533..fdc385515 100644
--- a/stdlib/test/test/lux/data/coll/tree/rose.lux
+++ b/stdlib/test/test/lux/data/coll/tree/rose.lux
@@ -22,7 +22,7 @@
children' (r.list num-children gen-tree)
#let [size' (L/fold n/+ +0 (L/map product.left children'))
children (L/map product.right children')]]
- (wrap [(n/inc size')
+ (wrap [(inc size')
(&.branch value children)]))
))))
diff --git a/stdlib/test/test/lux/data/color.lux b/stdlib/test/test/lux/data/color.lux
index b9290ed19..58bba6749 100644
--- a/stdlib/test/test/lux/data/color.lux
+++ b/stdlib/test/test/lux/data/color.lux
@@ -15,7 +15,7 @@
(def: scale
(-> Nat Frac)
- (|>> nat-to-int int-to-frac))
+ (|>> .int int-to-frac))
(def: square (-> Frac Frac) (math.pow 2.0))
diff --git a/stdlib/test/test/lux/data/error.lux b/stdlib/test/test/lux/data/error.lux
index fb66bc7fe..ed7b6cc58 100644
--- a/stdlib/test/test/lux/data/error.lux
+++ b/stdlib/test/test/lux/data/error.lux
@@ -13,20 +13,20 @@
($_ seq
(test "Functor correctly handles both cases."
(and (|> (: (&.Error Int) (#&.Success 10))
- (&/map i/inc)
+ (&/map inc)
(case> (#&.Success 11) true _ false))
(|> (: (&.Error Int) (#&.Error "YOLO"))
- (&/map i/inc)
+ (&/map inc)
(case> (#&.Error "YOLO") true _ false))
))
(test "Apply correctly handles both cases."
(and (|> (&/wrap 20)
(case> (#&.Success 20) true _ false))
- (|> (&/apply (&/wrap i/inc) (&/wrap 10))
+ (|> (&/apply (&/wrap inc) (&/wrap 10))
(case> (#&.Success 11) true _ false))
- (|> (&/apply (&/wrap i/inc) (#&.Error "YOLO"))
+ (|> (&/apply (&/wrap inc) (#&.Error "YOLO"))
(case> (#&.Error "YOLO") true _ false))))
(test "Monad correctly handles both cases."
diff --git a/stdlib/test/test/lux/data/lazy.lux b/stdlib/test/test/lux/data/lazy.lux
index 07513adec..da28003ba 100644
--- a/stdlib/test/test/lux/data/lazy.lux
+++ b/stdlib/test/test/lux/data/lazy.lux
@@ -31,22 +31,22 @@
($_ seq
(test "Functor map."
(|> (&.freeze sample)
- (:: &.Functor<Lazy> map n/inc)
+ (:: &.Functor<Lazy> map inc)
&.thaw
- (n/= (n/inc sample))))
+ (n/= (inc sample))))
(test "Monad."
(|> (do &.Monad<Lazy>
- [f (wrap n/inc)
+ [f (wrap inc)
a (wrap sample)]
(wrap (f a)))
&.thaw
- (n/= (n/inc sample))))
+ (n/= (inc sample))))
(test "Apply apply."
(let [(^open "&/") &.Monad<Lazy>
(^open "&/") &.Apply<Lazy>]
- (|> (&/apply (&/wrap n/inc) (&/wrap sample))
+ (|> (&/apply (&/wrap inc) (&/wrap sample))
&.thaw
- (n/= (n/inc sample)))))
+ (n/= (inc sample)))))
))))
diff --git a/stdlib/test/test/lux/data/number.lux b/stdlib/test/test/lux/data/number.lux
index 263dd346d..e6692fb3d 100644
--- a/stdlib/test/test/lux/data/number.lux
+++ b/stdlib/test/test/lux/data/number.lux
@@ -160,7 +160,7 @@
(do @
[raw r.frac
factor (|> r.nat (:: @ map (|>> (n/% +1000) (n/max +1))))
- #let [sample (|> factor nat-to-int int-to-frac (f/* raw))]]
+ #let [sample (|> factor .int int-to-frac (f/* raw))]]
(test "Can convert frac values to/from their bit patterns."
(|> sample frac-to-bits bits-to-frac (f/= sample))))))
diff --git a/stdlib/test/test/lux/data/number/complex.lux b/stdlib/test/test/lux/data/number/complex.lux
index 8369ad676..14ab1c76c 100644
--- a/stdlib/test/test/lux/data/number/complex.lux
+++ b/stdlib/test/test/lux/data/number/complex.lux
@@ -28,7 +28,7 @@
(do r.Monad<Random>
[factor (|> r.nat (:: @ map (|>> (n/% +1000) (n/max +1))))
measure (|> r.frac (r.filter (f/> 0.0)))]
- (wrap (f/* (|> factor nat-to-int int-to-frac)
+ (wrap (f/* (|> factor .int int-to-frac)
measure))))
(def: gen-complex
@@ -196,6 +196,6 @@
degree (|> r.nat (:: @ map (|>> (n/max +1) (n/% +5))))]
(test "Can calculate the N roots for any complex number."
(|> sample
- (&.nth-roots degree)
- (list/map (&.pow' (|> degree nat-to-int int-to-frac)))
+ (&.roots degree)
+ (list/map (&.pow' (|> degree .int int-to-frac)))
(list.every? (within? margin-of-error sample)))))))
diff --git a/stdlib/test/test/lux/io.lux b/stdlib/test/test/lux/io.lux
index 43841a708..faddcf42d 100644
--- a/stdlib/test/test/lux/io.lux
+++ b/stdlib/test/test/lux/io.lux
@@ -10,7 +10,7 @@
(context: "I/O"
($_ seq
(test "" (Text/= "YOLO" (&.run (&.io "YOLO"))))
- (test "" (i/= 11 (&.run (:: &.Functor<IO> map i/inc (&.io 10)))))
+ (test "" (i/= 11 (&.run (:: &.Functor<IO> map inc (&.io 10)))))
(test "" (i/= 10 (&.run (:: &.Monad<IO> wrap 10))))
(test "" (i/= 30 (&.run (let [(^open "&/") &.Apply<IO>
(^open "&/") &.Monad<IO>]
diff --git a/stdlib/test/test/lux/lang/syntax.lux b/stdlib/test/test/lux/lang/syntax.lux
index 68830f271..01679b27a 100644
--- a/stdlib/test/test/lux/lang/syntax.lux
+++ b/stdlib/test/test/lux/lang/syntax.lux
@@ -110,8 +110,8 @@
(context: "Frac special syntax."
(<| (times +100)
(do @
- [numerator (|> r.nat (:: @ map (|>> (n/% +100) nat-to-frac)))
- denominator (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1) nat-to-frac)))
+ [numerator (|> r.nat (:: @ map (|>> (n/% +100) .int int-to-frac)))
+ denominator (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1) .int int-to-frac)))
signed? r.bool
#let [expected (|> numerator (f// denominator) (f/* (if signed? -1.0 1.0)))]]
(test "Can parse frac ratio syntax."
@@ -201,7 +201,7 @@
(text.from-code y) "\n"
(text.from-code z))]
(case (&.read "" (dict.new text.Hash<Text>)
- [(|> default-cursor (update@ #.column (n/+ (n/dec offset-size))))
+ [(|> default-cursor (update@ #.column (n/+ (dec offset-size))))
+0
(format "\"" good-input "\"")])
(#e.Error error)
diff --git a/stdlib/test/test/lux/lang/type/check.lux b/stdlib/test/test/lux/lang/type/check.lux
index e10ac5514..517b2561b 100644
--- a/stdlib/test/test/lux/lang/type/check.lux
+++ b/stdlib/test/test/lux/lang/type/check.lux
@@ -216,7 +216,7 @@
tailR (@.ring tail-id)]
(@.assert ""
(let [same-rings? (:: set.Eq<Set> = headR tailR)
- expected-size? (n/= (n/inc num-connections) (set.size headR))
+ expected-size? (n/= (inc num-connections) (set.size headR))
same-vars? (|> (set.to-list headR)
(list.sort n/<)
(:: (list.Eq<List> number.Eq<Nat>) = (list.sort n/< (#.Cons head-id ids))))]
@@ -252,7 +252,7 @@
headRR-post (@.ring head-idR)]
(@.assert ""
(let [same-rings? (:: set.Eq<Set> = headRL-post headRR-post)
- expected-size? (n/= (n/* +2 (n/inc num-connections))
+ expected-size? (n/= (n/* +2 (inc num-connections))
(set.size headRL-post))
union? (:: set.Eq<Set> = headRL-post (set.union headRL-pre headRR-pre))]
(and same-rings?
diff --git a/stdlib/test/test/lux/type/implicit.lux b/stdlib/test/test/lux/type/implicit.lux
index 2ae01ed1b..c07067b3e 100644
--- a/stdlib/test/test/lux/type/implicit.lux
+++ b/stdlib/test/test/lux/type/implicit.lux
@@ -22,7 +22,7 @@
(and (bool/= (:: number.Eq<Nat> = x y)
(::: = x y))
(list/= (list.n/range +1 +10)
- (::: map n/inc (list.n/range +0 +9)))
+ (::: map inc (list.n/range +0 +9)))
)))
(test "Can automatically select second-order structures."
diff --git a/stdlib/test/test/lux/type/object/interface.lux b/stdlib/test/test/lux/type/object/interface.lux
index 7def3113a..f74d32e2a 100644
--- a/stdlib/test/test/lux/type/object/interface.lux
+++ b/stdlib/test/test/lux/type/object/interface.lux
@@ -5,16 +5,16 @@
## No parameters
(interface: Counter
- (inc [] @)
- (read [] Nat))
+ (inc! [] @)
+ (read! [] Nat))
(class: NatC Counter
Nat
- (def: inc
- (update@Counter n/inc))
+ (def: inc!
+ (update@Counter inc))
- (def: read
+ (def: read!
get@Counter))
(interface: Resettable-Counter
@@ -56,28 +56,28 @@
## Polymorphism
(def: (poly0 counter)
(-> Counter Nat)
- (read counter))
+ (read! counter))
(def: poly0-0 Nat (poly0 (new@NatC +0)))
(def: poly0-1 Nat (poly0 (new@NatRC +0 [])))
(def: (poly1 counter)
(-> Resettable-Counter Nat)
- (n/+ (read counter)
- (read (reset counter))))
+ (n/+ (read! counter)
+ (read! (reset counter))))
(def: poly1-0 Nat (poly1 (new@NatRC +0 [])))
(def: (poly2 counter)
(-> NatC Nat)
- (read counter))
+ (read! counter))
(def: poly2-0 Nat (poly2 (new@NatC +0)))
(def: poly2-1 Nat (poly2 (new@NatRC +0 [])))
(def: (poly3 counter)
(-> NatRC Nat)
- (n/+ (read counter)
- (read (reset counter))))
+ (n/+ (read! counter)
+ (read! (reset counter))))
(def: poly3-0 Nat (poly3 (new@NatRC +0 [])))
diff --git a/stdlib/test/test/lux/type/object/protocol.lux b/stdlib/test/test/lux/type/object/protocol.lux
index e5a8dda4b..fcb53d3b1 100644
--- a/stdlib/test/test/lux/type/object/protocol.lux
+++ b/stdlib/test/test/lux/type/object/protocol.lux
@@ -7,7 +7,7 @@
(def: (count [tick return] state)
(Class Nat (Method Top Nat))
- (let [state' (n/inc state)]
+ (let [state' (inc state)]
[(return state') state']))
(def: counter
@@ -38,7 +38,7 @@
(#method2 [arg0 arg1 arg2] output)
(output (%n num-calls)))
- (recur (n/inc num-calls))])))
+ (recur (inc num-calls))])))
(def: _test1
[Nat Object0]
diff --git a/stdlib/test/test/lux/world/blob.lux b/stdlib/test/test/lux/world/blob.lux
index 37deb9d3b..1093f302f 100644
--- a/stdlib/test/test/lux/world/blob.lux
+++ b/stdlib/test/test/lux/world/blob.lux
@@ -29,14 +29,14 @@
(do r.Monad<Random>
[byte r.nat]
(exec (e.assume (/.write-8 idx byte output))
- (recur (n/inc idx))))
+ (recur (inc idx))))
(:: r.Monad<Random> wrap output)))))
(def: (bits-io bytes read write value)
(-> Nat (-> Nat /.Blob (e.Error Nat)) (-> Nat Nat /.Blob (e.Error Top)) Nat Bool)
(let [blob (/.create +8)
bits (n/* +8 bytes)
- capped-value (|> +1 (bit.left-shift bits) n/dec (bit.and value))]
+ capped-value (|> +1 (bit.left-shift bits) dec (bit.and value))]
(succeed
(do e.Monad<Error>
[_ (write +0 value blob)
@@ -67,9 +67,9 @@
(test "Can read/write 64-bit values."
(bits-io +8 /.read-64 /.write-64 value))
(test "Can slice blobs."
- (let [slice-size (|> to (n/- from) n/inc)
+ (let [slice-size (|> to (n/- from) inc)
random-slice (e.assume (/.slice from to random-blob))
- idxs (list.n/range +0 (n/dec slice-size))
+ idxs (list.n/range +0 (dec slice-size))
reader (function (_ blob idx) (/.read-8 idx blob))]
(and (n/= slice-size (/.size random-slice))
(case [(monad.map e.Monad<Error> (reader random-slice) idxs)
diff --git a/stdlib/test/test/lux/world/file.lux b/stdlib/test/test/lux/world/file.lux
index 6f4e26e6d..6d32a994b 100644
--- a/stdlib/test/test/lux/world/file.lux
+++ b/stdlib/test/test/lux/world/file.lux
@@ -73,8 +73,8 @@
read-size (@.size file)
_ (@.delete file)]
(wrap (and (n/= (n/* +2 file-size) read-size)
- (:: blob.Eq<Blob> = dataL (e.assume (blob.slice +0 (n/dec file-size) output)))
- (:: blob.Eq<Blob> = dataR (e.assume (blob.slice file-size (n/dec read-size) output)))))))]
+ (:: blob.Eq<Blob> = dataL (e.assume (blob.slice +0 (dec file-size) output)))
+ (:: blob.Eq<Blob> = dataR (e.assume (blob.slice file-size (dec read-size) output)))))))]
(assert "Can append to files."
(e.default false result))))
(wrap (do P.Monad<Promise>