aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source
diff options
context:
space:
mode:
Diffstat (limited to '')
-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
48 files changed, 644 insertions, 667 deletions
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))))))
)